fix: improve plugin system robustness — agent/command resolution, async errors, hook timing, two-phase init (#18280)

Co-authored-by: Aiden Cline <63023139+rekram1-node@users.noreply.github.com>

Author: ryanskidmore

packages/opencode/src/plugin/index.ts

@@ -136,7 +136,11 @@ export namespace Plugin {
 
 // Notify plugins of current config
 for(consthookofhooks){
-await(hookasany).config?.(cfg)
+try{
+await(hookasany).config?.(cfg)
+}catch(err){
+log.error("plugin config hook failed",{error: err})
+}
 }
 })
 

packages/opencode/src/server/routes/session.ts

@@ -19,6 +19,8 @@ import { PermissionID } from "@/permission/schema"
 import{ModelID,ProviderID}from"@/provider/schema"
 import{errors}from"../error"
 import{lazy}from"../../util/lazy"
+import{Bus}from"../../bus"
+import{NamedError}from"@opencode-ai/util/error"
 
 constlog=Log.create({service: "server"})
 
@@ -846,7 +848,13 @@ export const SessionRoutes = lazy(() =>
 returnstream(c,async()=>{
 constsessionID=c.req.valid("param").sessionID
 constbody=c.req.valid("json")
-SessionPrompt.prompt({ ...body, sessionID })
+SessionPrompt.prompt({ ...body, sessionID }).catch((err)=>{
+log.error("prompt_async failed",{ sessionID,error: err})
+Bus.publish(Session.Event.Error,{
+ sessionID,
+error: newNamedError.Unknown({message: errinstanceofError ? err.message : String(err)}).toObject(),
+})
+})
 })
 },
 )

packages/opencode/src/session/prompt.ts

@@ -418,6 +418,16 @@ export namespace SessionPrompt {
 )
 letexecutionError: Error|undefined
 consttaskAgent=awaitAgent.get(task.agent)
+if(!taskAgent){
+constavailable=awaitAgent.list().then((agents)=>agents.filter((a)=>!a.hidden).map((a)=>a.name))
+consthint=available.length ? ` Available agents: ${available.join(", ")}` : ""
+consterror=newNamedError.Unknown({message: `Agent not found: "${task.agent}".${hint}`})
+Bus.publish(Session.Event.Error,{
+ sessionID,
+error: error.toObject(),
+})
+throwerror
+}
 consttaskCtx: Tool.Context={
 agent: task.agent,
 messageID: assistantMessage.id,
@@ -560,6 +570,16 @@ export namespace SessionPrompt {
 
 // normal processing
 constagent=awaitAgent.get(lastUser.agent)
+if(!agent){
+constavailable=awaitAgent.list().then((agents)=>agents.filter((a)=>!a.hidden).map((a)=>a.name))
+consthint=available.length ? ` Available agents: ${available.join(", ")}` : ""
+consterror=newNamedError.Unknown({message: `Agent not found: "${lastUser.agent}".${hint}`})
+Bus.publish(Session.Event.Error,{
+ sessionID,
+error: error.toObject(),
+})
+throwerror
+}
 constmaxSteps=agent.steps??Infinity
 constisLastStep=step>=maxSteps
 msgs=awaitinsertReminders({
@@ -964,7 +984,18 @@ export namespace SessionPrompt {
 }
 
 asyncfunctioncreateUserMessage(input: PromptInput){
-constagent=awaitAgent.get(input.agent??(awaitAgent.defaultAgent()))
+constagentName=input.agent||(awaitAgent.defaultAgent())
+constagent=awaitAgent.get(agentName)
+if(!agent){
+constavailable=awaitAgent.list().then((agents)=>agents.filter((a)=>!a.hidden).map((a)=>a.name))
+consthint=available.length ? ` Available agents: ${available.join(", ")}` : ""
+consterror=newNamedError.Unknown({message: `Agent not found: "${agentName}".${hint}`})
+Bus.publish(Session.Event.Error,{
+sessionID: input.sessionID,
+error: error.toObject(),
+})
+throwerror
+}
 
 constmodel=input.model??agent.model??(awaitlastModel(input.sessionID))
 constfull=
@@ -1531,6 +1562,16 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 awaitSessionRevert.cleanup(session)
 }
 constagent=awaitAgent.get(input.agent)
+if(!agent){
+constavailable=awaitAgent.list().then((agents)=>agents.filter((a)=>!a.hidden).map((a)=>a.name))
+consthint=available.length ? ` Available agents: ${available.join(", ")}` : ""
+consterror=newNamedError.Unknown({message: `Agent not found: "${input.agent}".${hint}`})
+Bus.publish(Session.Event.Error,{
+sessionID: input.sessionID,
+error: error.toObject(),
+})
+throwerror
+}
 constmodel=input.model??agent.model??(awaitlastModel(input.sessionID))
 constuserMsg: MessageV2.User={
 id: MessageID.ascending(),
@@ -1783,7 +1824,14 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 log.info("command",input)
 constcommand=awaitCommand.get(input.command)
 if(!command){
-thrownewNamedError.Unknown({message: `Command not found: "${input.command}"`})
+constavailable=awaitCommand.list().then((cmds)=>cmds.map((c)=>c.name))
+consthint=available.length ? ` Available commands: ${available.join(", ")}` : ""
+consterror=newNamedError.Unknown({message: `Command not found: "${input.command}".${hint}`})
+Bus.publish(Session.Event.Error,{
+sessionID: input.sessionID,
+error: error.toObject(),
+})
+throwerror
 }
 constagentName=command.agent??input.agent??(awaitAgent.defaultAgent())
 

packages/opencode/test/plugin/auth-override.test.ts

@@ -54,3 +54,19 @@ describe("plugin.auth-override", () => {
 expect(plainMethods[ProviderID.make("github-copilot")][0].label).not.toBe("Test Override Auth")
 },30000)// Increased timeout for plugin installation
 })
+
+constfile=path.join(import.meta.dir,"../../src/plugin/index.ts")
+
+describe("plugin.config-hook-error-isolation",()=>{
+test("config hooks are individually error-isolated in the layer factory",async()=>{
+constsrc=awaitBun.file(file).text()
+
+// The config hook try/catch lives in the InstanceState factory (layer definition),
+// not in init() which now just delegates to the Effect service.
+expect(src).toContain("plugin config hook failed")
+
+constpattern=
+/for\s*\(consthookofhooks\)\s*\{[\s\S]*?try\s*\{[\s\S]*?\.config\?\.\([\s\S]*?\}\s*catch\s*\(err\)\s*\{[\s\S]*?pluginconfighookfailed[\s\S]*?\}/
+expect(pattern.test(src)).toBe(true)
+})
+})

packages/opencode/test/server/session-messages.test.ts

@@ -117,3 +117,16 @@ describe("session messages endpoint", () => {
 })
 })
 })
+
+describe("session.prompt_async error handling",()=>{
+test("prompt_async route has error handler for detached prompt call",async()=>{
+constsrc=awaitBun.file(path.join(import.meta.dir,"../../src/server/routes/session.ts")).text()
+conststart=src.indexOf('"/:sessionID/prompt_async"')
+constend=src.indexOf('"/:sessionID/command"',start)
+expect(start).toBeGreaterThan(-1)
+expect(end).toBeGreaterThan(start)
+constroute=src.slice(start,end)
+expect(route).toContain(".catch(")
+expect(route).toContain("Bus.publish(Session.Event.Error")
+})
+})

packages/opencode/test/session/prompt.test.ts

@@ -1,5 +1,6 @@
 importpathfrom"path"
 import{describe,expect,test}from"bun:test"
+import{NamedError}from"@opencode-ai/util/error"
 import{fileURLToPath}from"url"
 import{Instance}from"../../src/project/instance"
 import{ModelID,ProviderID}from"../../src/provider/schema"
@@ -210,3 +211,78 @@ describe("session.prompt agent variant", () => {
 }
 })
 })
+
+describe("session.agent-resolution",()=>{
+test("unknown agent throws typed error",async()=>{
+await using tmp=awaittmpdir({git: true})
+awaitInstance.provide({
+directory: tmp.path,
+fn: async()=>{
+constsession=awaitSession.create({})
+consterr=awaitSessionPrompt.prompt({
+sessionID: session.id,
+agent: "nonexistent-agent-xyz",
+noReply: true,
+parts: [{type: "text",text: "hello"}],
+}).then(
+()=>undefined,
+(e)=>e,
+)
+expect(err).toBeDefined()
+expect(err).not.toBeInstanceOf(TypeError)
+expect(NamedError.Unknown.isInstance(err)).toBe(true)
+if(NamedError.Unknown.isInstance(err)){
+expect(err.data.message).toContain('Agent not found: "nonexistent-agent-xyz"')
+}
+},
+})
+},30000)
+
+test("unknown agent error includes available agent names",async()=>{
+await using tmp=awaittmpdir({git: true})
+awaitInstance.provide({
+directory: tmp.path,
+fn: async()=>{
+constsession=awaitSession.create({})
+consterr=awaitSessionPrompt.prompt({
+sessionID: session.id,
+agent: "nonexistent-agent-xyz",
+noReply: true,
+parts: [{type: "text",text: "hello"}],
+}).then(
+()=>undefined,
+(e)=>e,
+)
+expect(NamedError.Unknown.isInstance(err)).toBe(true)
+if(NamedError.Unknown.isInstance(err)){
+expect(err.data.message).toContain("build")
+}
+},
+})
+},30000)
+
+test("unknown command throws typed error with available names",async()=>{
+await using tmp=awaittmpdir({git: true})
+awaitInstance.provide({
+directory: tmp.path,
+fn: async()=>{
+constsession=awaitSession.create({})
+consterr=awaitSessionPrompt.command({
+sessionID: session.id,
+command: "nonexistent-command-xyz",
+arguments: "",
+}).then(
+()=>undefined,
+(e)=>e,
+)
+expect(err).toBeDefined()
+expect(err).not.toBeInstanceOf(TypeError)
+expect(NamedError.Unknown.isInstance(err)).toBe(true)
+if(NamedError.Unknown.isInstance(err)){
+expect(err.data.message).toContain('Command not found: "nonexistent-command-xyz"')
+expect(err.data.message).toContain("init")
+}
+},
+})
+},30000)
+})