openAgent

1import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
2import { OpencodeClient } from "@opencode-ai/sdk/v2"
3import { runInteractiveMode } from "@/cli/cmd/run/runtime"
4import type { FooterApi, RunProvider } from "@/cli/cmd/run/types"
5 
6type SessionMessage = NonNullable<Awaited<ReturnType<OpencodeClient["session"]["messages"]>>["data"]>[number]
7 
8const provider: RunProvider = {
9  id: "openai",
10  name: "OpenAI",
11  source: "api",
12  env: [],
13  options: {},
14  models: {
15    "gpt-5": {
16      id: "gpt-5",
17      providerID: "openai",
18      api: {
19        id: "openai",
20        url: "https://openai.test",
21        npm: "@ai-sdk/openai",
22      },
23      name: "Little Frank",
24      capabilities: {
25        temperature: true,
26        reasoning: true,
27        attachment: true,
28        toolcall: true,
29        input: {
30          text: true,
31          audio: false,
32          image: false,
33          video: false,
34          pdf: false,
35        },
36        output: {
37          text: true,
38          audio: false,
39          image: false,
40          video: false,
41          pdf: false,
42        },
43        interleaved: false,
44      },
45      cost: {
46        input: 0,
47        output: 0,
48        cache: {
49          read: 0,
50          write: 0,
51        },
52      },
53      limit: {
54        context: 128000,
55        output: 8192,
56      },
57      status: "active",
58      options: {},
59      headers: {},
60      release_date: "2026-01-01",
61    },
62  },
63}
64 
65const transportProviders: RunProvider[][] = []
66 
67function defer<T>() {
68  let resolve!: (value: T | PromiseLike<T>) => void
69  const promise = new Promise<T>((done) => {
70    resolve = done
71  })
72  return { promise, resolve }
73}
74 
75function ok<T>(data: T) {
76  return Promise.resolve({
77    data,
78    error: undefined,
79    request: new Request("https://opencode.test"),
80    response: new Response(),
81  })
82}
83 
84function footer(): FooterApi {
85  let closed = false
86  const closes = new Set<() => void>()
87 
88  const notify = () => {
89    for (const fn of closes) fn()
90  }
91 
92  return {
93    get isClosed() {
94      return closed
95    },
96    onPrompt: () => () => {},
97    onQueuedRemove: () => () => {},
98    onClose(fn) {
99      if (closed) {
100        fn()
101        return () => {}
102      }
103 
104      closes.add(fn)
105      return () => {
106        closes.delete(fn)
107      }
108    },
109    event() {},
110    append() {},
111    idle() {
112      return Promise.resolve()
113    },
114    close() {
115      if (closed) {
116        return
117      }
118 
119      closed = true
120      notify()
121    },
122    destroy() {
123      if (closed) {
124        return
125      }
126 
127      closed = true
128      notify()
129    },
130  }
131}
132 
133afterEach(() => {
134  mock.restore()
135  transportProviders.length = 0
136})
137 
138describe("run interactive runtime", () => {
139  test("waits for provider metadata before eager replay transport bootstrap", async () => {
140    const providersStarted = defer<void>()
141    const providers = defer<void>()
142 
143    const sdk = new OpencodeClient()
144    spyOn(sdk.config, "providers").mockImplementation(async () => {
145      providersStarted.resolve()
146      await providers.promise
147      return ok({ providers: [provider], default: {} })
148    })
149    spyOn(sdk.session, "messages").mockImplementation(() =>
150      ok([
151        {
152          info: {
153            id: "msg-user-1",
154            sessionID: "ses-1",
155            role: "user",
156            time: {
157              created: 1,
158            },
159            agent: "build",
160            model: {
161              providerID: "openai",
162              modelID: "gpt-5",
163              variant: undefined,
164            },
165          },
166          parts: [
167            {
168              id: "part-user-1",
169              sessionID: "ses-1",
170              messageID: "msg-user-1",
171              type: "text",
172              text: "hello",
173            },
174          ],
175        } satisfies SessionMessage,
176      ]),
177    )
178    spyOn(sdk.session, "get").mockRejectedValue(new Error("not needed"))
179    spyOn(sdk.app, "agents").mockImplementation(() => ok([]))
180    spyOn(sdk.experimental.resource, "list").mockImplementation(() => ok({}))
181    spyOn(sdk.command, "list").mockImplementation(() => ok([]))
182 
183    const task = runInteractiveMode(
184      {
185        sdk,
186        directory: "/tmp",
187        sessionID: "ses-1",
188        sessionTitle: "Session",
189        resume: true,
190        replay: true,
191        replayLimit: 100,
192        agent: "build",
193        model: {
194          providerID: "openai",
195          modelID: "gpt-5",
196        },
197        variant: undefined,
198        files: [],
199        thinking: true,
200        backgroundSubagents: false,
201      },
202      {
203        createRuntimeLifecycle: async () => ({
204          footer: footer(),
205          onResize: () => () => {},
206          refreshTheme: () => {},
207          resetForReplay: () => Promise.resolve(),
208          close: () => Promise.resolve(),
209        }),
210        streamTransport: Promise.resolve({
211          createSessionTransport: async (input: { providers?: () => RunProvider[]; footer: FooterApi }) => {
212            transportProviders.push(input.providers?.() ?? [])
213            setTimeout(() => {
214              input.footer.close()
215            }, 0)
216            return {
217              runPromptTurn: async () => {},
218              selectSubagent: () => {},
219              replayOnResize: async () => false,
220              close: async () => {},
221            }
222          },
223          formatUnknownError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
224        }),
225      },
226    )
227 
228    await providersStarted.promise
229 
230    expect(transportProviders).toEqual([])
231 
232    providers.resolve()
233 
234    await task
235 
236    expect(transportProviders).toEqual([[provider]])
237  })
238})
239