openAgent

1import { expect, test } from "bun:test"
2import { DateTime, Effect, Stream } from "effect"
3import { HttpClient, HttpClientResponse } from "effect/unstable/http"
4import { AbsolutePath, Agent, Location, Model, OpenCode, Prompt, Session, SessionMessage } from "../src/effect"
5 
6test("sessions.get returns the decoded Effect projection", async () => {
7  const httpClient = HttpClient.make((request) =>
8    Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(session))),
9  )
10  const result = await Effect.gen(function* () {
11    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
12    return yield* client.sessions.get({ sessionID: Session.ID.make("ses_test") })
13  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
14 
15  expect(DateTime.toEpochMillis(result.time.created)).toBe(1_717_171_717_000)
16})
17 
18test("events.subscribe exposes and decodes the native Effect event stream", async () => {
19  const httpClient = HttpClient.make((request) =>
20    Effect.succeed(
21      HttpClientResponse.fromWeb(
22        request,
23        new Response(
24          `data: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
25            `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
26          { headers: { "content-type": "text/event-stream" } },
27        ),
28      ),
29    ),
30  )
31  const events = await Effect.gen(function* () {
32    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
33    return yield* client.events.subscribe().pipe(Stream.runCollect)
34  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
35 
36  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.next.model.switched"])
37  const durable = events[1]
38  if (durable?.type !== "session.next.model.switched") throw new Error("Expected model event")
39  expect(DateTime.toEpochMillis(durable.data.timestamp)).toBe(1_717_171_717_000)
40  expect(durable.durable).toEqual({ aggregateID: "ses_test", seq: 1, version: 1 })
41})
42 
43test("events.subscribe terminates on Effect protocol decode failures", async () => {
44  const httpClient = HttpClient.make((request) =>
45    Effect.succeed(
46      HttpClientResponse.fromWeb(
47        request,
48        new Response(`data: {"type":"server.connected"}\n\n`, {
49          headers: { "content-type": "text/event-stream" },
50        }),
51      ),
52    ),
53  )
54  const error = await Effect.gen(function* () {
55    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
56    return yield* client.events.subscribe().pipe(Stream.runCollect, Effect.flip)
57  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
58 
59  expect(error._tag).toBe("ClientError")
60})
61 
62test("session methods retain decoded Effect inputs and outputs", async () => {
63  const historyQueries: Array<Record<string, string>> = []
64  let historyPage = 0
65  const httpClient = HttpClient.make((request) => {
66    const url = request.url
67    if (url.includes("/event")) {
68      return Effect.succeed(
69        HttpClientResponse.fromWeb(
70          request,
71          new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\n`, {
72            headers: { "content-type": "text/event-stream" },
73          }),
74        ),
75      )
76    }
77    if (url.includes("/history")) {
78      historyPage++
79      historyQueries.push(Object.fromEntries(request.urlParams.params))
80      return Effect.succeed(
81        HttpClientResponse.fromWeb(
82          request,
83          Response.json(
84            historyPage === 1 ? { data: [modelSwitchedEvent], hasMore: true } : { data: [], hasMore: false },
85          ),
86        ),
87      )
88    }
89    if (url.includes("/prompt")) {
90      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(admission)))
91    }
92    if (url.includes("/context")) {
93      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ data: [] })))
94    }
95    if (url.includes("/message/")) {
96      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ data: modelSwitchedMessage })))
97    }
98    if (url.endsWith("/api/session/active")) {
99      return Effect.succeed(
100        HttpClientResponse.fromWeb(request, Response.json({ data: { ses_test: { type: "running" } } })),
101      )
102    }
103    if (request.method === "POST" && url.endsWith("/api/session")) {
104      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(session)))
105    }
106    if (request.method === "POST") {
107      return Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status: 204 })))
108    }
109    return Effect.succeed(
110      HttpClientResponse.fromWeb(request, Response.json({ data: [session.data], cursor: { next: "next" } })),
111    )
112  })
113  const result = await Effect.gen(function* () {
114    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
115    const page = yield* client.sessions.list({ limit: 10 })
116    const active = yield* client.sessions.active()
117    const created = yield* client.sessions.create({
118      location: Location.Ref.make({ directory: AbsolutePath.make("/tmp/project") }),
119    })
120    yield* client.sessions.switchAgent({ sessionID: Session.ID.make("ses_test"), agent: Agent.ID.make("build") })
121    yield* client.sessions.switchModel({
122      sessionID: Session.ID.make("ses_test"),
123      model: Model.Ref.make({ id: "claude", providerID: "anthropic" }),
124    })
125    const admitted = yield* client.sessions.prompt({
126      sessionID: Session.ID.make("ses_test"),
127      prompt: Prompt.make({ text: "Hello" }),
128      resume: false,
129    })
130    yield* client.sessions.compact({ sessionID: Session.ID.make("ses_test") })
131    yield* client.sessions.wait({ sessionID: Session.ID.make("ses_test") })
132    const context = yield* client.sessions.context({ sessionID: Session.ID.make("ses_test") })
133    const history = yield* client.sessions.history({
134      sessionID: Session.ID.make("ses_test"),
135      after: 0,
136      limit: 1,
137    })
138    const historyNext = history.hasMore
139      ? yield* client.sessions.history({
140          sessionID: Session.ID.make("ses_test"),
141          after: history.data.at(-1)?.durable?.seq,
142          limit: 2,
143        })
144      : undefined
145    const events = yield* client.sessions
146      .events({ sessionID: Session.ID.make("ses_test"), after: 0 })
147      .pipe(Stream.runCollect)
148    yield* client.sessions.interrupt({ sessionID: Session.ID.make("ses_test") })
149    const message = yield* client.sessions.message({
150      sessionID: Session.ID.make("ses_test"),
151      messageID: SessionMessage.ID.make("msg_model"),
152    })
153    return { page, active, created, admitted, context, history, historyNext, events, message }
154  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
155 
156  expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
157  expect(result.active).toEqual({ ses_test: { type: "running" } })
158  expect(Object.getPrototypeOf(result.page.data[0])).toBe(Object.prototype)
159  expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
160  expect(result.created.id).toBe("ses_test")
161  expect(Object.getPrototypeOf(result.admitted)).toBe(Object.prototype)
162  expect(Object.getPrototypeOf(result.admitted.prompt)).toBe(Object.prototype)
163  expect(DateTime.toEpochMillis(result.admitted.timeCreated)).toBe(1_717_171_717_000)
164  expect(result.context).toEqual([])
165  expect(DateTime.toEpochMillis(result.history.data[0].data.timestamp)).toBe(1_717_171_717_000)
166  expect(result.history).toEqual(expect.objectContaining({ hasMore: true }))
167  expect(result.historyNext).toEqual({ data: [], hasMore: false })
168  expect(historyQueries[0]).toEqual({ limit: "1", after: "0" })
169  expect(historyQueries[1]).toEqual({ limit: "2", after: "1" })
170  expect(DateTime.toEpochMillis(result.events[0].data.timestamp)).toBe(1_717_171_717_000)
171  expect(result.message).toEqual(expect.objectContaining({ id: "msg_model", type: "model-switched" }))
172})
173 
174test("sessions.history retains the typed SessionNotFoundError", async () => {
175  const httpClient = HttpClient.make((request) =>
176    Effect.succeed(
177      HttpClientResponse.fromWeb(
178        request,
179        Response.json(
180          { _tag: "SessionNotFoundError", sessionID: "ses_missing", message: "Session not found" },
181          { status: 404 },
182        ),
183      ),
184    ),
185  )
186  const error = await Effect.gen(function* () {
187    const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
188    return yield* client.sessions
189      .history({
190        sessionID: Session.ID.make("ses_missing"),
191      })
192      .pipe(Effect.flip)
193  }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
194 
195  expect(error._tag).toBe("SessionNotFoundError")
196})
197 
198const session = {
199  data: {
200    id: "ses_test",
201    projectID: "project",
202    cost: 0,
203    tokens: {
204      input: 1,
205      output: 2,
206      reasoning: 3,
207      cache: { read: 4, write: 5 },
208    },
209    time: {
210      created: 1_717_171_717_000,
211      updated: 1_717_171_717_000,
212    },
213    title: "Test",
214    location: { directory: "/tmp/project" },
215  },
216}
217 
218const admission = {
219  data: {
220    admittedSeq: 0,
221    id: "msg_test",
222    sessionID: "ses_test",
223    prompt: { text: "Hello" },
224    delivery: "steer",
225    timeCreated: 1_717_171_717_000,
226  },
227}
228 
229const modelSwitchedMessage = {
230  id: "msg_model",
231  type: "model-switched",
232  time: { created: 1_717_171_717_000 },
233  model: { id: "claude", providerID: "anthropic" },
234}
235 
236const modelSwitchedEvent = {
237  id: "evt_model",
238  type: "session.next.model.switched",
239  durable: { aggregateID: "ses_test", seq: 1, version: 1 },
240  data: {
241    timestamp: 1_717_171_717_000,
242    sessionID: "ses_test",
243    messageID: "msg_model",
244    model: { id: "claude", providerID: "anthropic" },
245  },
246}
247