openAgent

1import { expect, test } from "bun:test"
2import { isSessionNotFoundError, isUnauthorizedError, OpenCode } from "../src"
3 
4test("exposes every standard HTTP API group", () => {
5  const client = OpenCode.make({ baseUrl: "http://localhost:3000" })
6 
7  expect(Object.keys(client)).toEqual([
8    "health",
9    "location",
10    "agents",
11    "sessions",
12    "messages",
13    "models",
14    "providers",
15    "integrations",
16    "credentials",
17    "permissions",
18    "files",
19    "commands",
20    "skills",
21    "events",
22    "ptys",
23    "questions",
24    "references",
25    "projectCopies",
26  ])
27  expect(Object.keys(client.messages)).toEqual(["list"])
28  expect(Object.keys(client.integrations)).toEqual([
29    "list",
30    "get",
31    "connectKey",
32    "connectOauth",
33    "attemptStatus",
34    "attemptComplete",
35    "attemptCancel",
36  ])
37  expect(Object.keys(client.files)).toEqual(["list", "find"])
38  expect(Object.keys(client.ptys)).toEqual(["list", "create", "get", "update", "remove"])
39})
40 
41test("sessions.get returns the wire projection", async () => {
42  const client = OpenCode.make({
43    baseUrl: "http://localhost:3000",
44    fetch: async (input) => {
45      expect(typeof input === "string" ? input : input instanceof URL ? input.href : input.url).toBe(
46        "http://localhost:3000/api/session/ses_test",
47      )
48      return Response.json(session)
49    },
50  })
51 
52  const result = await client.sessions.get({ sessionID: "ses_test" })
53 
54  expect(result.time.created).toBe(1_717_171_717_000)
55})
56 
57test("events.subscribe exposes the Promise event stream wire projection", async () => {
58  const client = OpenCode.make({
59    baseUrl: "http://localhost:3000",
60    fetch: async () =>
61      new Response(
62        `: heartbeat\n\ndata: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
63          `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
64        { headers: { "content-type": "text/event-stream" } },
65      ),
66  })
67  const events = []
68  for await (const event of client.events.subscribe()) events.push(event)
69 
70  expect(events).toEqual([{ id: "evt_connected", type: "server.connected", data: {} }, modelSwitchedEvent])
71  expect(events[1]?.type === "session.next.model.switched" && events[1].data.timestamp).toBe(1_717_171_717_000)
72})
73 
74test("events.subscribe terminates on malformed Promise SSE data", async () => {
75  const client = OpenCode.make({
76    baseUrl: "http://localhost:3000",
77    fetch: async () => new Response("data: {not-json}\n\n", { headers: { "content-type": "text/event-stream" } }),
78  })
79 
80  await expect(client.events.subscribe()[Symbol.asyncIterator]().next()).rejects.toMatchObject({
81    name: "ClientError",
82    reason: "MalformedResponse",
83  })
84})
85 
86test("session methods use the public HTTP contract", async () => {
87  const requests: Array<{ url: string; init?: RequestInit }> = []
88  let historyPage = 0
89  const client = OpenCode.make({
90    baseUrl: "http://localhost:3000",
91    fetch: async (input, init) => {
92      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url
93      requests.push({ url, init })
94      if (url.includes("/event")) {
95        return new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\n`, {
96          headers: { "content-type": "text/event-stream" },
97        })
98      }
99      if (url.includes("/history")) {
100        historyPage++
101        return Response.json(
102          historyPage === 1 ? { data: [modelSwitchedEvent], hasMore: true } : { data: [], hasMore: false },
103        )
104      }
105      if (url.includes("/prompt")) return Response.json(admission)
106      if (url.includes("/context")) return Response.json({ data: [] })
107      if (url.includes("/message/")) return Response.json({ data: modelSwitchedMessage })
108      if (url.endsWith("/api/session/active")) return Response.json({ data: { ses_test: { type: "running" } } })
109      if (init?.method === "POST" && url.endsWith("/api/session")) return Response.json(session)
110      if (init?.method === "POST") return new Response(null, { status: 204 })
111      return Response.json({ data: [session.data], cursor: { next: "next" } })
112    },
113  })
114 
115  const page = await client.sessions.list({ limit: 10, order: "desc" })
116  const active = await client.sessions.active()
117  const created = await client.sessions.create({ location: { directory: "/tmp/project" } })
118  await client.sessions.switchAgent({ sessionID: "ses_test", agent: "build" })
119  await client.sessions.switchModel({
120    sessionID: "ses_test",
121    model: { id: "claude", providerID: "anthropic" },
122  })
123  const admitted = await client.sessions.prompt({
124    sessionID: "ses_test",
125    prompt: { text: "Hello" },
126    resume: false,
127  })
128  await client.sessions.compact({ sessionID: "ses_test" })
129  await client.sessions.wait({ sessionID: "ses_test" })
130  const context = await client.sessions.context({ sessionID: "ses_test" })
131  const history = await client.sessions.history({ sessionID: "ses_test", after: 0, limit: 1 })
132  const historyAfter = history.data.at(-1)?.durable?.seq
133  const historyNext = history.hasMore
134    ? await client.sessions.history({ sessionID: "ses_test", after: historyAfter, limit: 2 })
135    : undefined
136  const events = []
137  for await (const event of client.sessions.events({ sessionID: "ses_test", after: 0 })) events.push(event)
138  await client.sessions.interrupt({ sessionID: "ses_test" })
139  const message = await client.sessions.message({ sessionID: "ses_test", messageID: "msg_model" })
140 
141  expect(page.cursor.next).toBe("next")
142  expect(active).toEqual({ ses_test: { type: "running" } })
143  expect(created.id).toBe("ses_test")
144  expect(admitted.id).toBe("msg_test")
145  expect(context).toEqual([])
146  expect(history).toEqual({ data: [modelSwitchedEvent], hasMore: true })
147  expect(historyNext).toEqual({ data: [], hasMore: false })
148  expect(events).toEqual([modelSwitchedEvent])
149  expect(message).toEqual(modelSwitchedMessage)
150  expect(requests.map((request) => [request.init?.method, request.url])).toEqual([
151    ["GET", "http://localhost:3000/api/session?limit=10&order=desc"],
152    ["GET", "http://localhost:3000/api/session/active"],
153    ["POST", "http://localhost:3000/api/session"],
154    ["POST", "http://localhost:3000/api/session/ses_test/agent"],
155    ["POST", "http://localhost:3000/api/session/ses_test/model"],
156    ["POST", "http://localhost:3000/api/session/ses_test/prompt"],
157    ["POST", "http://localhost:3000/api/session/ses_test/compact"],
158    ["POST", "http://localhost:3000/api/session/ses_test/wait"],
159    ["GET", "http://localhost:3000/api/session/ses_test/context"],
160    ["GET", "http://localhost:3000/api/session/ses_test/history?limit=1&after=0"],
161    ["GET", "http://localhost:3000/api/session/ses_test/history?limit=2&after=1"],
162    ["GET", "http://localhost:3000/api/session/ses_test/event?after=0"],
163    ["POST", "http://localhost:3000/api/session/ses_test/interrupt"],
164    ["GET", "http://localhost:3000/api/session/ses_test/message/msg_model"],
165  ])
166  const body = requests.find((request) => request.url.endsWith("/api/session/ses_test/prompt"))?.init?.body
167  if (typeof body !== "string") throw new Error("Expected JSON request body")
168  expect(JSON.parse(body)).toEqual({
169    prompt: { text: "Hello" },
170    resume: false,
171  })
172})
173 
174test("middleware errors remain declared client errors", async () => {
175  const client = OpenCode.make({
176    baseUrl: "http://localhost:3000",
177    fetch: async () =>
178      Response.json({ _tag: "UnauthorizedError", message: "Authentication required" }, { status: 401 }),
179  })
180 
181  try {
182    await client.sessions.create({})
183    throw new Error("Expected request to fail")
184  } catch (error) {
185    expect(isUnauthorizedError(error)).toBe(true)
186  }
187})
188 
189test("sessions.history decodes SessionNotFoundError", async () => {
190  const client = OpenCode.make({
191    baseUrl: "http://localhost:3000",
192    fetch: async () =>
193      Response.json(
194        { _tag: "SessionNotFoundError", sessionID: "ses_missing", message: "Session not found" },
195        { status: 404 },
196      ),
197  })
198 
199  try {
200    await client.sessions.history({ sessionID: "ses_missing" })
201    throw new Error("Expected request to fail")
202  } catch (error) {
203    expect(isSessionNotFoundError(error)).toBe(true)
204  }
205})
206 
207const session = {
208  data: {
209    id: "ses_test",
210    projectID: "project",
211    cost: 0,
212    tokens: {
213      input: 1,
214      output: 2,
215      reasoning: 3,
216      cache: { read: 4, write: 5 },
217    },
218    time: {
219      created: 1_717_171_717_000,
220      updated: 1_717_171_717_000,
221    },
222    title: "Test",
223    location: { directory: "/tmp/project" },
224  },
225}
226 
227const admission = {
228  data: {
229    admittedSeq: 0,
230    id: "msg_test",
231    sessionID: "ses_test",
232    prompt: { text: "Hello" },
233    delivery: "steer",
234    timeCreated: 1_717_171_717_000,
235  },
236}
237 
238const modelSwitchedMessage = {
239  id: "msg_model",
240  type: "model-switched",
241  time: { created: 1_717_171_717_000 },
242  model: { id: "claude", providerID: "anthropic" },
243}
244 
245const modelSwitchedEvent = {
246  id: "evt_model",
247  type: "session.next.model.switched",
248  durable: { aggregateID: "ses_test", seq: 1, version: 1 },
249  data: {
250    timestamp: 1_717_171_717_000,
251    sessionID: "ses_test",
252    messageID: "msg_model",
253    model: { id: "claude", providerID: "anthropic" },
254  },
255}
256