fix(run): align mini with current session contracts (#35354)

2026-07-04 21:14:01 +02:00
parent d17751832d
commit 46ffcd0f56
10 changed files with 1063 additions and 80 deletions
@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
 import { OpencodeClient } from "@opencode-ai/sdk/v2"
 import { runInteractiveMode } from "@/cli/cmd/run/runtime"
-import type { FooterApi, RunProvider } from "@/cli/cmd/run/types"
+import type { FooterApi, FooterEvent, RunProvider } from "@/cli/cmd/run/types"

 const provider: RunProvider = {
  id: "openai",
@@ -53,7 +53,7 @@ function ok<T>(data: T) {
  })
 }

-function footer(): FooterApi {
+function footer(events: FooterEvent[] = []): FooterApi {
  let closed = false
  const closes = new Set<() => void>()

@@ -78,7 +78,9 @@ function footer(): FooterApi {
        closes.delete(fn)
      }
    },
-    event() {},
+    event(value) {
+      events.push(value)
+    },
    append() {},
    idle() {
      return Promise.resolve()
@@ -296,4 +298,183 @@ describe("run interactive runtime", () => {
    expect(legacyAgents).not.toHaveBeenCalled()
    expect(legacyCommands).not.toHaveBeenCalled()
  })
+
+  test("retains last-known-good state across failed coalesced refreshes and retries later", async () => {
+    const sdk = new OpencodeClient()
+    const refreshGate = defer<void>()
+    let providerCalls = 0
+    let modelCalls = 0
+    let agentCalls = 0
+    let referenceCalls = 0
+    const events: FooterEvent[] = []
+    const api = footer(events)
+    spyOn(sdk.v2.provider, "list").mockImplementation(async () => {
+      providerCalls++
+      if (providerCalls === 2) {
+        await refreshGate.promise
+        throw new Error("provider refresh failed")
+      }
+      return ok({
+        location: { directory: "/tmp" },
+        data: [
+          {
+            id: "openai",
+            name: providerCalls >= 3 ? "OpenAI refreshed" : "OpenAI",
+            api: { type: "native", settings: {} },
+            request: { headers: {}, body: {} },
+          },
+        ],
+      }) as never
+    })
+    spyOn(sdk.v2.model, "list").mockImplementation(() => {
+      modelCalls++
+      return ok({
+        location: { directory: "/tmp" },
+        data: [
+          {
+            id: "gpt-5",
+            providerID: "openai",
+            name: "Little Frank",
+            api: { id: "openai", type: "native", settings: {} },
+            capabilities: { tools: true, input: ["text"], output: ["text"] },
+            request: { headers: {}, body: {} },
+            variants:
+              modelCalls >= 4
+                ? []
+                : [{ id: modelCalls >= 3 ? "high" : "low", settings: {}, headers: {}, body: {} }],
+            time: { released: 1 },
+            cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
+            status: "active",
+            enabled: true,
+            limit: { context: modelCalls >= 3 ? 256000 : 128000, output: 8192 },
+          },
+        ],
+      }) as never
+    })
+    spyOn(sdk.v2.agent, "list").mockImplementation(async () => {
+      agentCalls++
+      if (agentCalls === 2) throw new Error("agent refresh failed")
+      return ok({
+        location: { directory: "/tmp" },
+        data: [{ id: "build", description: agentCalls >= 3 ? "Refreshed agent" : "Agent", mode: "primary" }],
+      }) as never
+    })
+    spyOn(sdk.v2.reference, "list").mockImplementation(() => {
+      referenceCalls++
+      return ok({
+        location: { directory: "/tmp" },
+        data: [
+          { name: "effect", path: "/effect", description: referenceCalls >= 3 ? "Refreshed reference" : "Reference" },
+        ],
+      }) as never
+    })
+    spyOn(sdk.v2.command, "list").mockImplementation(() =>
+      ok({ location: { directory: "/tmp" }, data: [{ name: "check", description: "Check" }] }) as never,
+    )
+    spyOn(sdk.v2.skill, "list").mockImplementation(() =>
+      ok({ location: { directory: "/tmp" }, data: [] }) as never,
+    )
+    let finalProviders: RunProvider[] = []
+    let finalLimits: Record<string, number> = {}
+    let retainedProviders: RunProvider[] = []
+    let retainedLimits: Record<string, number> = {}
+    let retainedCatalog: FooterEvent | undefined
+    let selectedDefault: unknown
+    let selectDefault: (() => unknown) | undefined
+    let selectVariant: ((variant: string | undefined) => unknown) | undefined
+    let defaultRefreshVariants: FooterEvent | undefined
+
+    await runInteractiveMode(
+      {
+        sdk,
+        directory: "/tmp",
+        sessionID: "ses-1",
+        sessionTitle: "Session",
+        resume: false,
+        agent: "build",
+        model: { providerID: "openai", modelID: "gpt-5" },
+        variant: "low",
+        files: [],
+        thinking: false,
+        backgroundSubagents: false,
+      },
+      {
+        createRuntimeLifecycle: async (input) => {
+          selectDefault = () => input.onVariantSelect?.(undefined)
+          selectVariant = (variant) => input.onVariantSelect?.(variant)
+          return {
+            footer: api,
+            onResize: () => () => {},
+            refreshTheme: () => {},
+            resetForReplay: () => Promise.resolve(),
+            close: () => Promise.resolve(),
+          }
+        },
+        streamTransport: Promise.resolve({
+          createSessionTransport: async (input) => {
+            while (
+              !events.some(
+                (event) => event.type === "variants" && event.variants.includes("low") && event.current === "low",
+              )
+            )
+              await Bun.sleep(0)
+            selectedDefault = await Promise.resolve(selectDefault?.())
+            input.onCatalogRefresh?.()
+            input.onCatalogRefresh?.()
+            input.onCatalogRefresh?.()
+            while (providerCalls < 2) await Bun.sleep(0)
+            refreshGate.resolve()
+            await new Promise((resolve) => setTimeout(resolve, 0))
+            retainedProviders = input.providers?.() ?? []
+            retainedLimits = input.limits()
+            retainedCatalog = events.filter((event) => event.type === "catalog").at(-1)
+            input.onCatalogRefresh?.()
+            input.onCatalogRefresh?.()
+            while (providerCalls < 3 || modelCalls < 3 || agentCalls < 3) await Bun.sleep(0)
+            await new Promise((resolve) => setTimeout(resolve, 0))
+            defaultRefreshVariants = events.filter((event) => event.type === "variants").at(-1)
+            await Promise.resolve(selectVariant?.("high"))
+            input.onCatalogRefresh?.()
+            while (providerCalls < 4 || modelCalls < 4) await Bun.sleep(0)
+            await new Promise((resolve) => setTimeout(resolve, 0))
+            finalProviders = input.providers?.() ?? []
+            finalLimits = input.limits()
+            setTimeout(() => input.footer.close(), 0)
+            return {
+              runPromptTurn: async () => {},
+              interruptActiveTurn: async () => {},
+              selectSubagent: () => {},
+              replayOnResize: async () => false,
+              close: async () => {},
+            }
+          },
+          formatUnknownError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
+        }),
+      },
+    )
+
+    expect(providerCalls).toBe(4)
+    expect(modelCalls).toBe(4)
+    expect(retainedProviders[0]?.name).toBe("OpenAI")
+    expect(retainedProviders[0]?.models["gpt-5"]?.variants).toEqual({ low: {} })
+    expect(retainedLimits["openai/gpt-5"]).toBe(128000)
+    expect(retainedCatalog).toMatchObject({
+      agents: [{ name: "build", description: "Agent" }],
+      references: [{ name: "effect", description: "Reference" }],
+    })
+    expect(selectedDefault).toMatchObject({ variant: undefined })
+    expect(defaultRefreshVariants).toMatchObject({ variants: ["high"], current: undefined })
+    expect(finalProviders[0]?.name).toBe("OpenAI refreshed")
+    expect(finalProviders[0]?.models["gpt-5"]?.variants).toEqual({})
+    expect(finalLimits["openai/gpt-5"]).toBe(256000)
+    expect(events.filter((event) => event.type === "variants").at(-1)).toMatchObject({
+      variants: [],
+      current: undefined,
+    })
+    expect(events.filter((event) => event.type === "catalog").at(-1)).toMatchObject({
+      agents: [{ name: "build", description: "Refreshed agent" }],
+      references: [{ name: "effect", description: "Refreshed reference" }],
+      commands: [{ name: "check", description: "Check" }],
+    })
+  })
 })