fix(acp): resolve cold-start race with belt-and-suspenders defense

Two complementary fixes for the ACP cold-start race condition where
DB migration delays provider loading, causing defaultModel() to fall
through to Provider.sort() and pick a paid model.

Proactive fix (acp.ts):
- Poll providers endpoint (max 10x, 500ms intervals) before accepting
  requests, ensuring providers are loaded post-migration
- Log warning if providers don't load within 5s

Defensive fix (agent.ts):
- When user specifies a model in config.json but the provider is not
  yet loaded (or provider loaded but model not indexed), return the
  user's explicit choice instead of falling through to Provider.sort()

Extracted testable modules:
- resolve-model.ts: pure resolution logic (6 unit tests)
- wait-for-providers.ts: polling loop with configurable retry (4 unit tests)

Fixes #865, Fixes #866

Author: chaodu-agent

packages/opencode/src/acp/agent.ts

@@ -38,6 +38,7 @@ import { ACPSessionManager } from "./session"
 import type { ACPConfig } from "./types"
 import { Provider } from "../provider"
 import { ModelID, ProviderID } from "../provider/schema"
+import { resolveDefaultModel } from "./resolve-model"
 import { Agent as AgentModule } from "../agent/agent"
 import { AppRuntime } from "@/effect/app-runtime"
 import { Installation } from "@/installation"
@@ -1563,12 +1564,8 @@ async function defaultModel(config: ACPConfig, cwd?: string): Promise<{ provider
       return []
     })
 
-  if (specified && providers.length) {
-    const provider = providers.find((p) => p.id === specified.providerID)
-    if (provider && provider.models[specified.modelID]) return specified
-  }
-
-  if (specified && !providers.length) return specified
+  const resolved = resolveDefaultModel(specified, providers)
+  if (resolved) return resolved
 
   const opencodeProvider = providers.find((p) => p.id === "opencode")
   if (opencodeProvider) {

packages/opencode/src/acp/resolve-model.ts

@@ -0,0 +1,22 @@
+import { ModelID, ProviderID } from "../provider/schema"
+
+/**
+ * Pure resolution logic for choosing the default model.
+ * Separated for testability — no SDK calls, no side effects.
+ */
+export function resolveDefaultModel(
+  specified: { providerID: ProviderID; modelID: ModelID } | undefined,
+  providers: Array<{ id: string; models: Record<string, unknown> }>,
+): { providerID: ProviderID; modelID: ModelID } | undefined {
+  if (specified && providers.length) {
+    const provider = providers.find((p) => p.id === specified.providerID)
+    if (provider && provider.models[specified.modelID]) return specified
+    // Provider not yet loaded or model not found — still honor the user's explicit choice
+    // rather than falling through to Provider.sort() which may pick a paid model
+    if (!provider || !provider.models[specified.modelID]) return specified
+  }
+
+  if (specified && !providers.length) return specified
+
+  return undefined // let caller handle fallback
+}

packages/opencode/src/acp/wait-for-providers.ts

@@ -0,0 +1,21 @@
+import { Log } from "../util"
+
+const log = Log.create({ service: "acp-command" })
+
+/**
+ * Wait for at least one provider to be loaded.
+ * Returns true if providers loaded, false if timed out.
+ */
+export async function waitForProviders(
+  poll: () => Promise<{ data?: { providers?: unknown[] } }>,
+  opts: { maxAttempts?: number; intervalMs?: number } = {},
+): Promise<boolean> {
+  const { maxAttempts = 10, intervalMs = 500 } = opts
+  for (let i = 0; i < maxAttempts; i++) {
+    const resp = await poll()
+    if (resp.data?.providers?.length) return true
+    await new Promise((r) => setTimeout(r, intervalMs))
+  }
+  log.warn("providers not loaded within timeout, proceeding anyway")
+  return false
+}

packages/opencode/src/cli/cmd/acp.ts

@@ -6,6 +6,7 @@ import { ACP } from "@/acp/agent"
 import { Server } from "@/server/server"
 import { createOpencodeClient } from "@mimo-ai/sdk/v2"
 import { withNetworkOptions, resolveNetworkOptions } from "../network"
+import { waitForProviders } from "@/acp/wait-for-providers"
 
 const log = Log.create({ service: "acp-command" })
 
@@ -29,6 +30,13 @@ export const AcpCommand = cmd({
         baseUrl: `http://${server.hostname}:${server.port}`,
       })
 
+      // Wait for providers to be fully loaded after potential DB migration.
+      // Without this, the first request may race with provider initialization
+      // and fall back to Provider.sort() which picks a paid model.
+      await waitForProviders(() =>
+        sdk.config.providers({ directory: args.cwd }, { throwOnError: false }),
+      )
+
       const input = new WritableStream<Uint8Array>({
         write(chunk) {
           return new Promise<void>((resolve, reject) => {

packages/opencode/test/acp/default-model.test.ts

@@ -0,0 +1,48 @@
+import { test, expect, describe } from "bun:test"
+import { resolveDefaultModel } from "../../src/acp/resolve-model"
+import { ProviderID, ModelID } from "../../src/provider/schema"
+
+describe("resolveDefaultModel", () => {
+  const mimo = {
+    providerID: ProviderID.make("mimo"),
+    modelID: ModelID.make("mimo-auto"),
+  }
+
+  test("returns specified when provider is not in providers list", () => {
+    const result = resolveDefaultModel(mimo, [
+      { id: "xiaomi", models: { "some-model": {} } },
+    ])
+    expect(result).toEqual(mimo)
+  })
+
+  test("returns specified when provider exists but model not indexed", () => {
+    const result = resolveDefaultModel(mimo, [
+      { id: "mimo", models: {} },
+    ])
+    expect(result).toEqual(mimo)
+  })
+
+  test("returns specified when providers list is empty", () => {
+    const result = resolveDefaultModel(mimo, [])
+    expect(result).toEqual(mimo)
+  })
+
+  test("returns specified when provider and model both present", () => {
+    const result = resolveDefaultModel(mimo, [
+      { id: "mimo", models: { "mimo-auto": { id: "mimo-auto" } } },
+    ])
+    expect(result).toEqual(mimo)
+  })
+
+  test("returns undefined when no specified model", () => {
+    const result = resolveDefaultModel(undefined, [
+      { id: "mimo", models: { "mimo-auto": {} } },
+    ])
+    expect(result).toBeUndefined()
+  })
+
+  test("returns undefined when no specified and no providers", () => {
+    const result = resolveDefaultModel(undefined, [])
+    expect(result).toBeUndefined()
+  })
+})

packages/opencode/test/acp/wait-for-providers.test.ts

@@ -0,0 +1,34 @@
+import { test, expect, describe } from "bun:test"
+import { waitForProviders } from "../../src/acp/wait-for-providers"
+
+describe("waitForProviders", () => {
+  test("returns true immediately when providers are available", async () => {
+    const poll = () => Promise.resolve({ data: { providers: [{ id: "mimo" }] } })
+    const result = await waitForProviders(poll, { maxAttempts: 3, intervalMs: 10 })
+    expect(result).toBe(true)
+  })
+
+  test("retries and returns true when providers load on Nth attempt", async () => {
+    let calls = 0
+    const poll = () => {
+      calls++
+      if (calls < 3) return Promise.resolve({ data: { providers: [] } })
+      return Promise.resolve({ data: { providers: [{ id: "mimo" }] } })
+    }
+    const result = await waitForProviders(poll, { maxAttempts: 5, intervalMs: 10 })
+    expect(result).toBe(true)
+    expect(calls).toBe(3)
+  })
+
+  test("returns false after exhausting all attempts", async () => {
+    const poll = () => Promise.resolve({ data: { providers: [] } })
+    const result = await waitForProviders(poll, { maxAttempts: 3, intervalMs: 10 })
+    expect(result).toBe(false)
+  })
+
+  test("handles undefined data gracefully", async () => {
+    const poll = () => Promise.resolve({ data: undefined })
+    const result = await waitForProviders(poll, { maxAttempts: 2, intervalMs: 10 })
+    expect(result).toBe(false)
+  })
+})