openAgent

1import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
2import { OpencodeClient, type Provider } from "@opencode-ai/sdk/v2"
3import type { Resolved } from "@opencode-ai/tui/config"
4import { TuiConfig } from "@/config/tui"
5import { resolveDiffStyle, resolveModelInfo, resolveRunTuiConfig } from "@/cli/cmd/run/runtime.boot"
6import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
7 
8function model(id: string, providerID: string, context: number, variants?: Record<string, Record<string, never>>) {
9  return {
10    id,
11    providerID,
12    api: {
13      id: providerID,
14      url: `https://${providerID}.test`,
15      npm: `@ai-sdk/${providerID}`,
16    },
17    name: id,
18    capabilities: {
19      temperature: true,
20      reasoning: true,
21      attachment: true,
22      toolcall: true,
23      input: {
24        text: true,
25        audio: false,
26        image: false,
27        video: false,
28        pdf: false,
29      },
30      output: {
31        text: true,
32        audio: false,
33        image: false,
34        video: false,
35        pdf: false,
36      },
37      interleaved: false,
38    },
39    cost: {
40      input: 0,
41      output: 0,
42      cache: {
43        read: 0,
44        write: 0,
45      },
46    },
47    limit: {
48      context,
49      output: 8192,
50    },
51    status: "active" as const,
52    options: {},
53    headers: {},
54    release_date: "2026-01-01",
55    variants,
56  }
57}
58 
59function config(input?: {
60  leader?: string
61  leaderTimeout?: number
62  diff_style?: "auto" | "stacked"
63  bindings?: Partial<{
64    commandList: string[]
65    variantCycle: string[]
66    interrupt: string[]
67    historyPrevious: string[]
68    historyNext: string[]
69    inputClear: string[]
70    inputSubmit: string[]
71    inputNewline: string[]
72  }>
73}): Resolved {
74  const bind = input?.bindings
75  return createTuiResolvedConfig({
76    diff_style: input?.diff_style,
77    leader_timeout: input?.leaderTimeout,
78    keybinds: {
79      ...(input?.leader && { leader: input.leader }),
80      ...(bind?.commandList && { command_list: bind.commandList }),
81      ...(bind?.variantCycle && { variant_cycle: bind.variantCycle }),
82      ...(bind?.interrupt && { session_interrupt: bind.interrupt }),
83      ...(bind?.historyPrevious && { history_previous: bind.historyPrevious }),
84      ...(bind?.historyNext && { history_next: bind.historyNext }),
85      ...(bind?.inputClear && { input_clear: bind.inputClear }),
86      ...(bind?.inputSubmit && { input_submit: bind.inputSubmit }),
87      ...(bind?.inputNewline && { input_newline: bind.inputNewline }),
88    },
89  })
90}
91 
92describe("run runtime boot", () => {
93  afterEach(() => {
94    mock.restore()
95  })
96 
97  test("reads footer keybinds from resolved keybind config", async () => {
98    spyOn(TuiConfig, "get").mockResolvedValue(
99      config({
100        leader: "ctrl+g",
101        bindings: {
102          commandList: ["ctrl+p"],
103          variantCycle: ["ctrl+t", "alt+t"],
104          interrupt: ["ctrl+c"],
105          historyPrevious: ["k"],
106          historyNext: ["j"],
107          inputClear: ["ctrl+l"],
108          inputSubmit: ["ctrl+s"],
109          inputNewline: ["alt+return"],
110        },
111      }),
112    )
113 
114    const result = await resolveRunTuiConfig()
115 
116    expect(result.keybinds.get("leader")?.[0]?.key).toBe("ctrl+g")
117    expect(result.leader_timeout).toBe(2000)
118    expect(result.keybinds.get("command.palette.show")?.[0]?.key).toBe("ctrl+p")
119    expect(result.keybinds.get("variant.cycle").map((item) => item.key)).toEqual(["ctrl+t", "alt+t"])
120    expect(result.keybinds.get("session.interrupt")?.[0]?.key).toBe("ctrl+c")
121    expect(result.keybinds.get("prompt.history.previous")?.[0]?.key).toBe("k")
122    expect(result.keybinds.get("prompt.history.next")?.[0]?.key).toBe("j")
123    expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+l")
124    expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("ctrl+s")
125    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("alt+return")
126  })
127 
128  test("falls back to default tui keymap config when config load fails", async () => {
129    spyOn(TuiConfig, "get").mockRejectedValue(new Error("boom"))
130 
131    const result = await resolveRunTuiConfig()
132 
133    expect(result.keybinds.get("leader")?.[0]?.key).toBe("ctrl+x")
134    expect(result.leader_timeout).toBe(2000)
135    expect(result.diff_style).toBe("auto")
136    expect(result.keybinds.get("command.palette.show")?.[0]?.key).toBe("ctrl+p")
137    expect(result.keybinds.get("variant.cycle")?.[0]?.key).toBe("ctrl+t")
138    expect(result.keybinds.get("session.interrupt")?.[0]?.key).toBe("escape")
139    expect(result.keybinds.get("prompt.history.previous")?.[0]?.key).toBe("up")
140    expect(result.keybinds.get("prompt.history.next")?.[0]?.key).toBe("down")
141    expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+c")
142    expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("return")
143    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,alt+return,ctrl+j")
144  })
145 
146  test("preserves disabled leader from resolved tui config", async () => {
147    spyOn(TuiConfig, "get").mockResolvedValue(config({ leader: "none" }))
148 
149    const result = await resolveRunTuiConfig()
150 
151    expect(result.keybinds.get("leader")).toEqual([])
152  })
153 
154  test("reads diff style and falls back to auto", async () => {
155    spyOn(TuiConfig, "get").mockResolvedValue(config({ diff_style: "stacked" }))
156    await expect(resolveDiffStyle()).resolves.toBe("stacked")
157 
158    mock.restore()
159    spyOn(TuiConfig, "get").mockRejectedValue(new Error("boom"))
160    await expect(resolveDiffStyle()).resolves.toBe("auto")
161  })
162 
163  test("prefers configured providers for model selector data", async () => {
164    const sdk = new OpencodeClient()
165    const data: {
166      all: Provider[]
167      default: Record<string, string>
168      connected: string[]
169    } = {
170      all: [
171        {
172          id: "openai",
173          name: "OpenAI",
174          source: "api",
175          env: [],
176          options: {},
177          models: {
178            "gpt-5": model("gpt-5", "openai", 128000, {
179              high: {},
180              minimal: {},
181            }),
182          },
183        },
184        {
185          id: "anthropic",
186          name: "Anthropic",
187          source: "api",
188          env: [],
189          options: {},
190          models: {
191            sonnet: model("sonnet", "anthropic", 200000),
192          },
193        },
194      ],
195      default: {},
196      connected: [],
197    }
198    const configured = {
199      providers: [data.all[0]!],
200      default: {},
201    }
202    const list = spyOn(sdk.provider, "list").mockImplementation(() =>
203      Promise.resolve({
204        data,
205        error: undefined,
206        request: new Request("https://opencode.test"),
207        response: new Response(),
208      }),
209    )
210    spyOn(sdk.config, "providers").mockImplementation(() =>
211      Promise.resolve({
212        data: configured,
213        error: undefined,
214        request: new Request("https://opencode.test"),
215        response: new Response(),
216      }),
217    )
218 
219    await expect(resolveModelInfo(sdk, "/workspace", { providerID: "openai", modelID: "gpt-5" })).resolves.toEqual({
220      providers: configured.providers,
221      variants: ["high", "minimal"],
222      limits: {
223        "openai/gpt-5": 128000,
224      },
225    })
226    expect(list).not.toHaveBeenCalled()
227  })
228 
229  test("falls back to provider list when configured providers are unavailable", async () => {
230    const sdk = new OpencodeClient()
231    const data: {
232      all: Provider[]
233      default: Record<string, string>
234      connected: string[]
235    } = {
236      all: [
237        {
238          id: "openai",
239          name: "OpenAI",
240          source: "api",
241          env: [],
242          options: {},
243          models: {
244            "gpt-5": model("gpt-5", "openai", 128000, {
245              high: {},
246              minimal: {},
247            }),
248          },
249        },
250        {
251          id: "anthropic",
252          name: "Anthropic",
253          source: "api",
254          env: [],
255          options: {},
256          models: {
257            sonnet: model("sonnet", "anthropic", 200000),
258          },
259        },
260      ],
261      default: {},
262      connected: [],
263    }
264    spyOn(sdk.config, "providers").mockRejectedValue(new Error("boom"))
265    spyOn(sdk.provider, "list").mockImplementation(() =>
266      Promise.resolve({
267        data,
268        error: undefined,
269        request: new Request("https://opencode.test"),
270        response: new Response(),
271      }),
272    )
273 
274    await expect(resolveModelInfo(sdk, "/workspace", { providerID: "openai", modelID: "gpt-5" })).resolves.toEqual({
275      providers: data.all,
276      variants: ["high", "minimal"],
277      limits: {
278        "openai/gpt-5": 128000,
279        "anthropic/sonnet": 200000,
280      },
281    })
282  })
283})
284