fix: retry on Anthropic overloaded_error instead of halting session

packages/opencode/src/agent/agent.ts

@@ -75,6 +75,7 @@ export namespace Agent {
       const config = yield* Config.Service
       const auth = yield* Auth.Service
       const skill = yield* Skill.Service
+      const provider = yield* Provider.Service
 
       const state = yield* InstanceState.make<State>(
         Effect.fn("Agent.state")(function* (ctx) {
@@ -330,9 +331,9 @@ export namespace Agent {
           model?: { providerID: ProviderID; modelID: ModelID }
         }) {
           const cfg = yield* config.get()
-          const model = input.model ?? (yield* Effect.promise(() => Provider.defaultModel()))
-          const resolved = yield* Effect.promise(() => Provider.getModel(model.providerID, model.modelID))
-          const language = yield* Effect.promise(() => Provider.getLanguage(resolved))
+          const model = input.model ?? (yield* provider.defaultModel())
+          const resolved = yield* provider.getModel(model.providerID, model.modelID)
+          const language = yield* provider.getLanguage(resolved)
 
           const system = [PROMPT_GENERATE]
           yield* Effect.promise(() =>
@@ -393,6 +394,7 @@ export namespace Agent {
   )
 
   export const defaultLayer = layer.pipe(
+    Layer.provide(Provider.defaultLayer),
     Layer.provide(Auth.defaultLayer),
     Layer.provide(Config.defaultLayer),
     Layer.provide(Skill.defaultLayer),

packages/opencode/src/provider/error.ts

@@ -112,7 +112,7 @@ export namespace ProviderError {
     | {
         type: "api_error"
         message: string
-        isRetryable: false
+        isRetryable: boolean
         responseBody: string
       }
 
@@ -121,6 +121,18 @@ export namespace ProviderError {
     if (!body) return
 
     const responseBody = JSON.stringify(body)
+
+    // Anthropic returns {"type":"overloaded_error","message":"Overloaded"} when
+    // at capacity — this is retryable and should not terminate the session.
+    if (body.type === "overloaded_error") {
+      return {
+        type: "api_error",
+        message: typeof body.message === "string" ? body.message : "Provider is overloaded",
+        isRetryable: true,
+        responseBody,
+      }
+    }
+
     if (body.type !== "error") return
 
     switch (body?.error?.code) {

packages/opencode/src/provider/provider.ts

@@ -1541,10 +1541,9 @@ export namespace Provider {
     }),
   )
 
-  const { runPromise } = makeRuntime(
-    Service,
-    layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(Auth.defaultLayer)),
-  )
+  export const defaultLayer = layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(Auth.defaultLayer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
 
   export async function list() {
     return runPromise((svc) => svc.list())

packages/opencode/src/session/compaction.ts

@@ -63,7 +63,13 @@ export namespace SessionCompaction {
   export const layer: Layer.Layer<
     Service,
     never,
-    Bus.Service | Config.Service | Session.Service | Agent.Service | Plugin.Service | SessionProcessor.Service
+    | Bus.Service
+    | Config.Service
+    | Session.Service
+    | Agent.Service
+    | Plugin.Service
+    | SessionProcessor.Service
+    | Provider.Service
   > = Layer.effect(
     Service,
     Effect.gen(function* () {
@@ -73,6 +79,7 @@ export namespace SessionCompaction {
       const agents = yield* Agent.Service
       const plugin = yield* Plugin.Service
       const processors = yield* SessionProcessor.Service
+      const provider = yield* Provider.Service
 
       const isOverflow = Effect.fn("SessionCompaction.isOverflow")(function* (input: {
         tokens: MessageV2.Assistant["tokens"]
@@ -170,11 +177,9 @@ export namespace SessionCompaction {
         }
 
         const agent = yield* agents.get("compaction")
-        const model = yield* Effect.promise(() =>
-          agent.model
-            ? Provider.getModel(agent.model.providerID, agent.model.modelID)
-            : Provider.getModel(userMessage.model.providerID, userMessage.model.modelID),
-        )
+        const model = agent.model
+          ? yield* provider.getModel(agent.model.providerID, agent.model.modelID)
+          : yield* provider.getModel(userMessage.model.providerID, userMessage.model.modelID)
         // Allow plugins to inject context or replace compaction prompt.
         const compacting = yield* plugin.trigger(
           "experimental.session.compacting",
@@ -377,6 +382,7 @@ When constructing the summary, try to stick to this template:
   export const defaultLayer = Layer.unwrap(
     Effect.sync(() =>
       layer.pipe(
+        Layer.provide(Provider.defaultLayer),
         Layer.provide(Session.defaultLayer),
         Layer.provide(SessionProcessor.defaultLayer),
         Layer.provide(Agent.defaultLayer),

packages/opencode/src/session/prompt.ts

@@ -84,6 +84,7 @@ export namespace SessionPrompt {
       const status = yield* SessionStatus.Service
       const sessions = yield* Session.Service
       const agents = yield* Agent.Service
+      const provider = yield* Provider.Service
       const processor = yield* SessionProcessor.Service
       const compaction = yield* SessionCompaction.Service
       const plugin = yield* Plugin.Service
@@ -206,14 +207,14 @@ export namespace SessionPrompt {
 
         const ag = yield* agents.get("title")
         if (!ag) return
+        const mdl = ag.model
+          ? yield* provider.getModel(ag.model.providerID, ag.model.modelID)
+          : ((yield* provider.getSmallModel(input.providerID)) ??
+            (yield* provider.getModel(input.providerID, input.modelID)))
+        const msgs = onlySubtasks
+          ? [{ role: "user" as const, content: subtasks.map((p) => p.prompt).join("\n") }]
+          : yield* Effect.promise(() => MessageV2.toModelMessages(context, mdl))
         const text = yield* Effect.promise(async (signal) => {
-          const mdl = ag.model
-            ? await Provider.getModel(ag.model.providerID, ag.model.modelID)
-            : ((await Provider.getSmallModel(input.providerID)) ??
-              (await Provider.getModel(input.providerID, input.modelID)))
-          const msgs = onlySubtasks
-            ? [{ role: "user" as const, content: subtasks.map((p) => p.prompt).join("\n") }]
-            : await MessageV2.toModelMessages(context, mdl)
           const result = await LLM.stream({
             agent: ag,
             user: firstInfo,
@@ -932,21 +933,35 @@ NOTE: At any point in time through this workflow you should feel free to ask the
         return { info: msg, parts: [part] }
       })
 
-      const getModel = (providerID: ProviderID, modelID: ModelID, sessionID: SessionID) =>
-        Effect.promise(() =>
-          Provider.getModel(providerID, modelID).catch((e) => {
-            if (Provider.ModelNotFoundError.isInstance(e)) {
-              const hint = e.data.suggestions?.length ? ` Did you mean: ${e.data.suggestions.join(", ")}?` : ""
-              Bus.publish(Session.Event.Error, {
-                sessionID,
-                error: new NamedError.Unknown({
-                  message: `Model not found: ${e.data.providerID}/${e.data.modelID}.${hint}`,
-                }).toObject(),
-              })
-            }
-            throw e
-          }),
-        )
+      const getModel = Effect.fn("SessionPrompt.getModel")(function* (
+        providerID: ProviderID,
+        modelID: ModelID,
+        sessionID: SessionID,
+      ) {
+        const exit = yield* provider.getModel(providerID, modelID).pipe(Effect.exit)
+        if (Exit.isSuccess(exit)) return exit.value
+        const err = Cause.squash(exit.cause)
+        if (Provider.ModelNotFoundError.isInstance(err)) {
+          const hint = err.data.suggestions?.length ? ` Did you mean: ${err.data.suggestions.join(", ")}?` : ""
+          yield* bus.publish(Session.Event.Error, {
+            sessionID,
+            error: new NamedError.Unknown({
+              message: `Model not found: ${err.data.providerID}/${err.data.modelID}.${hint}`,
+            }).toObject(),
+          })
+        }
+        return yield* Effect.failCause(exit.cause)
+      })
+
+      const lastModel = Effect.fnUntraced(function* (sessionID: SessionID) {
+        const model = yield* Effect.promise(async () => {
+          for await (const item of MessageV2.stream(sessionID)) {
+            if (item.info.role === "user" && item.info.model) return item.info.model
+          }
+        })
+        if (model) return model
+        return yield* provider.defaultModel()
+      })
 
       const createUserMessage = Effect.fn("SessionPrompt.createUserMessage")(function* (input: PromptInput) {
         const agentName = input.agent || (yield* agents.defaultAgent())
@@ -960,9 +975,12 @@ NOTE: At any point in time through this workflow you should feel free to ask the
         }
 
         const model = input.model ?? ag.model ?? (yield* lastModel(input.sessionID))
+        const same = ag.model && model.providerID === ag.model.providerID && model.modelID === ag.model.modelID
         const full =
-          !input.variant && ag.variant
-            ? yield* Effect.promise(() => Provider.getModel(model.providerID, model.modelID).catch(() => undefined))
+          !input.variant && ag.variant && same
+            ? yield* provider
+                .getModel(model.providerID, model.modelID)
+                .pipe(Effect.catch(() => Effect.succeed(undefined)))
             : undefined
         const variant = input.variant ?? (ag.variant && full?.variants?.[ag.variant] ? ag.variant : undefined)
 
@@ -1109,7 +1127,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                   ]
                   const read = yield* Effect.promise(() => ReadTool.init()).pipe(
                     Effect.flatMap((t) =>
-                      Effect.promise(() => Provider.getModel(info.model.providerID, info.model.modelID)).pipe(
+                      provider.getModel(info.model.providerID, info.model.modelID).pipe(
                         Effect.flatMap((mdl) =>
                           Effect.promise(() =>
                             t.execute(args, {
@@ -1711,6 +1729,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
         Layer.provide(FileTime.defaultLayer),
         Layer.provide(ToolRegistry.defaultLayer),
         Layer.provide(Truncate.layer),
+        Layer.provide(Provider.defaultLayer),
         Layer.provide(AppFileSystem.defaultLayer),
         Layer.provide(Plugin.defaultLayer),
         Layer.provide(Session.defaultLayer),
@@ -1856,15 +1875,6 @@ NOTE: At any point in time through this workflow you should feel free to ask the
     return runPromise((svc) => svc.command(CommandInput.parse(input)))
   }
 
-  const lastModel = Effect.fnUntraced(function* (sessionID: SessionID) {
-    return yield* Effect.promise(async () => {
-      for await (const item of MessageV2.stream(sessionID)) {
-        if (item.info.role === "user" && item.info.model) return item.info.model
-      }
-      return Provider.defaultModel()
-    })
-  })
-
   /** @internal Exported for testing */
   export function createStructuredOutputTool(input: {
     schema: Record<string, any>

packages/opencode/src/session/retry.ts

@@ -73,6 +73,9 @@ export namespace SessionRetry {
     if (!json || typeof json !== "object") return undefined
     const code = typeof json.code === "string" ? json.code : ""
 
+    if (json.type === "overloaded_error") {
+      return "Provider is overloaded"
+    }
     if (json.type === "error" && json.error?.type === "too_many_requests") {
       return "Too Many Requests"
     }

packages/opencode/test/fake/provider.ts

@@ -0,0 +1,81 @@
+import { Effect, Layer } from "effect"
+import { Provider } from "../../src/provider/provider"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+
+export namespace ProviderTest {
+  export function model(override: Partial<Provider.Model> = {}): Provider.Model {
+    const id = override.id ?? ModelID.make("gpt-5.2")
+    const providerID = override.providerID ?? ProviderID.make("openai")
+    return {
+      id,
+      providerID,
+      name: "Test Model",
+      capabilities: {
+        toolcall: true,
+        attachment: false,
+        reasoning: false,
+        temperature: true,
+        interleaved: false,
+        input: { text: true, image: false, audio: false, video: false, pdf: false },
+        output: { text: true, image: false, audio: false, video: false, pdf: false },
+      },
+      api: { id, url: "https://example.com", npm: "@ai-sdk/openai" },
+      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+      limit: { context: 200_000, output: 10_000 },
+      status: "active",
+      options: {},
+      headers: {},
+      release_date: "2025-01-01",
+      ...override,
+    }
+  }
+
+  export function info(override: Partial<Provider.Info> = {}, mdl = model()): Provider.Info {
+    const id = override.id ?? mdl.providerID
+    return {
+      id,
+      name: "Test Provider",
+      source: "config",
+      env: [],
+      options: {},
+      models: { [mdl.id]: mdl },
+      ...override,
+    }
+  }
+
+  export function fake(override: Partial<Provider.Interface> & { model?: Provider.Model; info?: Provider.Info } = {}) {
+    const mdl = override.model ?? model()
+    const row = override.info ?? info({}, mdl)
+    return {
+      model: mdl,
+      info: row,
+      layer: Layer.succeed(
+        Provider.Service,
+        Provider.Service.of({
+          list: Effect.fn("TestProvider.list")(() => Effect.succeed({ [row.id]: row })),
+          getProvider: Effect.fn("TestProvider.getProvider")((providerID) => {
+            if (providerID === row.id) return Effect.succeed(row)
+            return Effect.die(new Error(`Unknown test provider: ${providerID}`))
+          }),
+          getModel: Effect.fn("TestProvider.getModel")((providerID, modelID) => {
+            if (providerID === row.id && modelID === mdl.id) return Effect.succeed(mdl)
+            return Effect.die(new Error(`Unknown test model: ${providerID}/${modelID}`))
+          }),
+          getLanguage: Effect.fn("TestProvider.getLanguage")(() =>
+            Effect.die(new Error("ProviderTest.getLanguage not configured")),
+          ),
+          closest: Effect.fn("TestProvider.closest")((providerID) =>
+            Effect.succeed(providerID === row.id ? { providerID: row.id, modelID: mdl.id } : undefined),
+          ),
+          getSmallModel: Effect.fn("TestProvider.getSmallModel")((providerID) =>
+            Effect.succeed(providerID === row.id ? mdl : undefined),
+          ),
+          defaultModel: Effect.fn("TestProvider.defaultModel")(() =>
+            Effect.succeed({ providerID: row.id, modelID: mdl.id }),
+          ),
+          ...override,
+        }),
+      ),
+    }
+  }
+}