openAgent

1import { expect, test } from "bun:test"
2import { Effect, Schema, Stream } from "effect"
3import { LLMEvent } from "@opencode-ai/llm"
4import { EventV2 } from "@opencode-ai/core/event"
5import { SessionEvent } from "@opencode-ai/core/session/event"
6import { SessionMessage } from "@opencode-ai/core/session/message"
7import { SessionV2 } from "@opencode-ai/core/session"
8import { ModelV2 } from "@opencode-ai/core/model"
9import { ProviderV2 } from "@opencode-ai/core/provider"
10import { createLLMEventPublisher } from "@opencode-ai/core/session/runner/publish-llm-event"
11 
12const sessionID = SessionV2.ID.make("ses_tool_event_test")
13const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB"
14 
15const capture = () => {
16  const published: Array<{ readonly type: string; readonly data: unknown }> = []
17  const events = EventV2.Service.of({
18    publish: (definition, data) =>
19      Effect.sync(() => {
20        const event = { id: EventV2.ID.create(), type: definition.type, data } as EventV2.Payload<typeof definition>
21        published.push({
22          type: definition.durable
23            ? EventV2.versionedType(definition.type, definition.durable.version)
24            : definition.type,
25          data,
26        })
27        return event
28      }),
29    subscribe: () => Stream.empty,
30    all: () => Stream.empty,
31    durable: () => Stream.empty,
32    listen: () => Effect.succeed(Effect.void),
33    project: () => Effect.void,
34    replay: () => Effect.void,
35    replayAll: () => Effect.succeed(undefined),
36    remove: () => Effect.void,
37    claim: () => Effect.void,
38  })
39  return {
40    published,
41    publisher: createLLMEventPublisher(events, {
42      sessionID,
43      agent: "build",
44      model: {
45        id: ModelV2.ID.make("model"),
46        providerID: ProviderV2.ID.make("provider"),
47      },
48    }),
49  }
50}
51 
52const call = LLMEvent.toolCall({ id: "call-image", name: "read", input: { path: "pixel.png" } })
53const result = LLMEvent.toolResult({
54  id: "call-image",
55  name: "read",
56  result: {
57    type: "content",
58    value: [
59      { type: "text", text: "Image read successfully" },
60      { type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png", name: "pixel.png" },
61    ],
62  },
63  output: {
64    structured: { type: "media", mime: "image/png" },
65    content: [
66      { type: "text", text: "Image read successfully" },
67      { type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png", name: "pixel.png" },
68    ],
69  },
70})
71 
72test("local tool success serializes media base64 once and reconstructs from structured content", async () => {
73  const { published, publisher } = capture()
74  await Effect.runPromise(publisher.publish(call))
75  await Effect.runPromise(publisher.publish(result))
76 
77  const success = published.find((event) => event.type === "session.next.tool.success.1")
78  expect(success).toBeDefined()
79  const serialized = JSON.stringify(success)
80  expect(serialized.split(base64)).toHaveLength(2)
81  expect(success?.data).not.toHaveProperty("result")
82 
83  expect(success?.data).toMatchObject({
84    content: [
85      { type: "text", text: "Image read successfully" },
86      { type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png" },
87    ],
88  })
89})
90 
91test("provider-executed success retains its compatibility result", async () => {
92  const { published, publisher } = capture()
93  await Effect.runPromise(publisher.publish(LLMEvent.toolCall({ ...call, providerExecuted: true })))
94  await Effect.runPromise(publisher.publish(LLMEvent.toolResult({ ...result, providerExecuted: true })))
95  const success = published.find((event) => event.type === "session.next.tool.success.1")
96  expect(success?.data).toHaveProperty("result")
97})
98 
99test("binary failure emits no success event", async () => {
100  const { published, publisher } = capture()
101  await Effect.runPromise(publisher.publish(call))
102  await Effect.runPromise(
103    publisher.publish(
104      LLMEvent.toolResult({
105        id: call.id,
106        name: call.name,
107        result: { type: "error", value: "Cannot read binary file" },
108      }),
109    ),
110  )
111  expect(published.some((event) => event.type === "session.next.tool.success.1")).toBe(false)
112  expect(published.some((event) => event.type === "session.next.tool.failed.1")).toBe(true)
113})
114 
115test("old success event data containing result still decodes", () => {
116  const decoded = Schema.decodeUnknownSync(SessionEvent.Tool.Success.data)({
117    sessionID,
118    timestamp: Date.now(),
119    assistantMessageID: SessionMessage.ID.create(),
120    callID: "call-old",
121    structured: { type: "media", mime: "image/png" },
122    content: [{ type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png" }],
123    result: { type: "content", value: [{ type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png" }] },
124    provider: { executed: false },
125  })
126  expect(decoded.result).toMatchObject({ type: "content" })
127})
128 
129test("step finish records settlement without publishing step ended", async () => {
130  const { published, publisher } = capture()
131  await Effect.runPromise(publisher.publish(LLMEvent.stepStart({ index: 0 })))
132  await Effect.runPromise(publisher.publish(LLMEvent.stepFinish({ index: 0, reason: "stop" })))
133 
134  expect(published.some((event) => event.type === "session.next.step.ended.2")).toBe(false)
135  expect(publisher.stepSettlement()).toMatchObject({ finish: "stop" })
136})
137