openAgent

1import { describe, expect, test } from "bun:test"
2import type { SessionNotification } from "@agentclientprotocol/sdk"
3import { LayerNode } from "@opencode-ai/core/effect/layer-node"
4import { ProviderV2 } from "@opencode-ai/core/provider"
5import { ModelV2 } from "@opencode-ai/core/model"
6import { UsageService } from "@/acp/usage"
7import { Provider } from "@/provider/provider"
8import { Effect, Layer } from "effect"
9import { it } from "../lib/effect"
10 
11const assistant = (
12  input: Partial<UsageService.AssistantMessage> & Pick<UsageService.AssistantMessage, "cost">,
13): UsageService.SessionMessage => ({
14  info: {
15    role: "assistant",
16    providerID: "anthropic",
17    modelID: "claude-sonnet",
18    tokens: {
19      input: 10,
20      output: 20,
21      reasoning: 0,
22      cache: { read: 0, write: 0 },
23    },
24    ...input,
25  },
26})
27 
28const user = (): UsageService.SessionMessage => ({
29  info: { role: "user" },
30})
31 
32const assistantWithoutProvider = (): UsageService.SessionMessage => ({
33  info: {
34    role: "assistant",
35    modelID: "claude-sonnet",
36    cost: 1,
37    tokens: {
38      input: 10,
39      output: 20,
40      reasoning: 0,
41      cache: { read: 0, write: 0 },
42    },
43  },
44})
45 
46const model = (providerID: ProviderV2.ID, modelID: ModelV2.ID, context: number): Provider.Model => ({
47  id: modelID,
48  providerID,
49  api: {
50    id: modelID,
51    url: "https://example.com",
52    npm: "@ai-sdk/openai-compatible",
53  },
54  name: modelID,
55  family: "test",
56  capabilities: {
57    temperature: true,
58    reasoning: false,
59    attachment: false,
60    toolcall: true,
61    input: { text: true, audio: false, image: false, video: false, pdf: false },
62    output: { text: true, audio: false, image: false, video: false, pdf: false },
63    interleaved: false,
64  },
65  cost: {
66    input: 0,
67    output: 0,
68    cache: { read: 0, write: 0 },
69  },
70  limit: {
71    context,
72    output: 4096,
73  },
74  status: "active",
75  options: {},
76  headers: {},
77  release_date: "2026-01-01",
78})
79 
80const providers = (context = 128_000): Record<ProviderV2.ID, Provider.Info> => {
81  const providerID = ProviderV2.ID.make("anthropic")
82  const modelID = ModelV2.ID.make("claude-sonnet")
83  return {
84    [providerID]: {
85      id: providerID,
86      name: "Anthropic",
87      source: "config",
88      env: [],
89      options: {},
90      models: {
91        [modelID]: model(providerID, modelID, context),
92      },
93    },
94  }
95}
96 
97const fakeLayer = (input: {
98  readonly messages?: Effect.Effect<readonly UsageService.SessionMessage[], unknown>
99  readonly providers?: (directory: string) => Effect.Effect<Record<ProviderV2.ID, Provider.Info>, unknown>
100}) =>
101  LayerNode.compile(UsageService.node, [
102    [
103      UsageService.messageLoaderNode,
104      Layer.succeed(
105        UsageService.MessageLoader,
106        UsageService.MessageLoader.of({
107          messages: () => input.messages ?? Effect.succeed([]),
108        }),
109      ),
110    ],
111    [
112      UsageService.contextLimitLoaderNode,
113      Layer.succeed(
114        UsageService.ContextLimitLoader,
115        UsageService.ContextLimitLoader.of({
116          providers: input.providers ?? (() => Effect.succeed(providers())),
117        }),
118      ),
119    ],
120  ])
121 
122const connection = (updates: SessionNotification[]) => ({
123  sessionUpdate(params: SessionNotification) {
124    updates.push(params)
125    return Promise.resolve()
126  },
127})
128 
129describe("acp usage", () => {
130  test("builds ACP Usage from assistant token shape", () => {
131    expect(
132      UsageService.buildUsage({
133        cost: 0.02,
134        tokens: {
135          input: 100,
136          output: 40,
137          reasoning: 7,
138          cache: { read: 11, write: 13 },
139        },
140      }),
141    ).toEqual({
142      inputTokens: 100,
143      outputTokens: 40,
144      thoughtTokens: 7,
145      cachedReadTokens: 11,
146      cachedWriteTokens: 13,
147      totalTokens: 171,
148    })
149  })
150 
151  test("omits optional token fields when they are zero", () => {
152    expect(
153      UsageService.buildUsage({
154        cost: 0,
155        tokens: {
156          input: 3,
157          output: 4,
158          reasoning: 0,
159          cache: { read: 0, write: 0 },
160        },
161      }),
162    ).toEqual({
163      inputTokens: 3,
164      outputTokens: 4,
165      totalTokens: 7,
166    })
167  })
168 
169  test("finds the latest assistant message", () => {
170    expect(
171      UsageService.latestAssistantMessage([assistant({ cost: 1, modelID: "older" }), user(), assistant({ cost: 2 })]),
172    ).toMatchObject({ cost: 2 })
173  })
174 
175  test("calculates total session cost from assistant messages", () => {
176    expect(UsageService.totalSessionCost([assistant({ cost: 1.25 }), user(), assistant({ cost: 2.5 })])).toBe(3.75)
177  })
178 
179  it.effect("loads context limits from providers and caches by directory/provider/model", () => {
180    const calls: string[] = []
181    return Effect.gen(function* () {
182      const usage = yield* UsageService.Service
183      const first = yield* usage.contextLimit({
184        directory: "/workspace",
185        providerID: ProviderV2.ID.make("anthropic"),
186        modelID: ModelV2.ID.make("claude-sonnet"),
187      })
188      const second = yield* usage.contextLimit({
189        directory: "/workspace",
190        providerID: ProviderV2.ID.make("anthropic"),
191        modelID: ModelV2.ID.make("claude-sonnet"),
192      })
193 
194      expect(first).toBe(200_000)
195      expect(second).toBe(200_000)
196      expect(calls).toEqual(["/workspace"])
197    }).pipe(
198      Effect.provide(
199        fakeLayer({
200          providers: (directory) =>
201            Effect.sync(() => {
202              calls.push(directory)
203              return providers(200_000)
204            }),
205        }),
206      ),
207    )
208  })
209 
210  it.effect("includes cache reads and writes in ACP context usage", () => {
211    const updates: SessionNotification[] = []
212    return Effect.gen(function* () {
213      const usage = yield* UsageService.Service
214      yield* usage.sendUpdate({
215        connection: connection(updates),
216        sessionID: "ses_1",
217        directory: "/workspace",
218      })
219 
220      expect(updates).toEqual([
221        {
222          sessionId: "ses_1",
223          update: {
224            sessionUpdate: "usage_update",
225            used: 22,
226            size: 128_000,
227            cost: { amount: 3, currency: "USD" },
228          },
229        },
230      ])
231    }).pipe(
232      Effect.provide(
233        fakeLayer({
234          messages: Effect.succeed([
235            assistant({ cost: 1 }),
236            assistant({
237              cost: 2,
238              tokens: {
239                input: 10,
240                output: 20,
241                reasoning: 0,
242                cache: { read: 5, write: 7 },
243              },
244            }),
245          ]),
246        }),
247      ),
248    )
249  })
250 
251  it.effect("skips usage update when messages cannot be fetched", () => {
252    const updates: SessionNotification[] = []
253    return Effect.gen(function* () {
254      const usage = yield* UsageService.Service
255      yield* usage.sendUpdate({
256        connection: connection(updates),
257        sessionID: "ses_1",
258        directory: "/workspace",
259      })
260 
261      expect(updates).toEqual([])
262    }).pipe(Effect.provide(fakeLayer({ messages: Effect.fail(new Error("boom")) })))
263  })
264 
265  it.effect("skips usage update when no assistant message exists", () => {
266    const updates: SessionNotification[] = []
267    return Effect.gen(function* () {
268      const usage = yield* UsageService.Service
269      yield* usage.sendUpdate({
270        connection: connection(updates),
271        sessionID: "ses_1",
272        directory: "/workspace",
273      })
274 
275      expect(updates).toEqual([])
276    }).pipe(Effect.provide(fakeLayer({ messages: Effect.succeed([user()]) })))
277  })
278 
279  it.effect("skips usage update when assistant message has no provider or model", () => {
280    const updates: SessionNotification[] = []
281    return Effect.gen(function* () {
282      const usage = yield* UsageService.Service
283      yield* usage.sendUpdate({
284        connection: connection(updates),
285        sessionID: "ses_1",
286        directory: "/workspace",
287      })
288 
289      expect(updates).toEqual([])
290    }).pipe(
291      Effect.provide(
292        fakeLayer({
293          messages: Effect.succeed([assistantWithoutProvider()]),
294        }),
295      ),
296    )
297  })
298 
299  it.effect("skips usage update when context size is unknown", () => {
300    const updates: SessionNotification[] = []
301    return Effect.gen(function* () {
302      const usage = yield* UsageService.Service
303      yield* usage.sendUpdate({
304        connection: connection(updates),
305        sessionID: "ses_1",
306        directory: "/workspace",
307      })
308 
309      expect(updates).toEqual([])
310    }).pipe(
311      Effect.provide(
312        fakeLayer({
313          messages: Effect.succeed([assistant({ cost: 1, providerID: "missing" })]),
314        }),
315      ),
316    )
317  })
318})
319