openAgent

1import { describe, expect, test } from "bun:test"
2import { Effect, Schema } from "effect"
3import { LLM } from "../src"
4import * as OpenAIChat from "../src/protocols/openai-chat"
5import { Auth } from "../src/route"
6import { Tool, toDefinitions } from "../src/tool"
7import { it } from "./lib/effect"
8import { dynamicResponse } from "./lib/http"
9import { finishChunk, toolCallChunk } from "./lib/openai-chunks"
10import { sseEvents } from "./lib/sse"
11 
12type OpenAIChatBody = {
13  readonly tool_choice?: unknown
14  readonly tools?: ReadonlyArray<{
15    readonly function: {
16      readonly parameters: unknown
17    }
18  }>
19}
20 
21const model = OpenAIChat.route
22  .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
23  .model({ id: "gpt-4o-mini" })
24 
25const Json = Schema.fromJsonString(Schema.Unknown)
26const decodeJson = Schema.decodeUnknownSync(Json)
27const decodeBody = (text: string): OpenAIChatBody => decodeJson(text) as OpenAIChatBody
28 
29describe("Tool.make (dynamic JSON Schema)", () => {
30  test("forwards JSON Schema and description through toDefinitions", () => {
31    const jsonSchema = {
32      type: "object" as const,
33      properties: { city: { type: "string" } },
34      required: ["city"],
35    }
36    const lookup = Tool.make({
37      description: "Look up something",
38      jsonSchema,
39      execute: () => Effect.succeed({ ok: true }),
40    })
41    const [definition] = toDefinitions({ lookup })
42    expect(definition?.name).toBe("lookup")
43    expect(definition?.description).toBe("Look up something")
44    expect(definition?.inputSchema).toEqual(jsonSchema)
45  })
46 
47  test("execute receives the raw input untouched", async () => {
48    const seen: unknown[] = []
49    const tool = Tool.make({
50      description: "echo",
51      jsonSchema: { type: "object" },
52      execute: (params) =>
53        Effect.sync(() => {
54          seen.push(params)
55          return { ok: true }
56        }),
57    })
58    const result = await Effect.runPromise(tool.execute({ hello: "world" }))
59    expect(seen).toEqual([{ hello: "world" }])
60    expect(result).toEqual({ ok: true })
61  })
62})
63 
64describe("LLM.generateObject", () => {
65  it.effect("forces a synthetic tool call and decodes the input", () =>
66    Effect.gen(function* () {
67      const bodies: OpenAIChatBody[] = []
68      const layer = dynamicResponse((input) =>
69        Effect.sync(() => {
70          bodies.push(decodeBody(input.text))
71          return input.respond(
72            sseEvents(
73              toolCallChunk("call_1", "generate_object", '{"city":"Paris","temp":22}'),
74              finishChunk("tool_calls"),
75            ),
76            { headers: { "content-type": "text/event-stream" } },
77          )
78        }),
79      )
80 
81      const response = yield* LLM.generateObject({
82        model,
83        prompt: "Return a structured weather report.",
84        schema: Schema.Struct({ city: Schema.String, temp: Schema.Number }),
85      }).pipe(Effect.provide(layer))
86 
87      expect(response.object).toEqual({ city: "Paris", temp: 22 })
88      expect(response.response.toolCalls).toHaveLength(1)
89      expect(bodies).toHaveLength(1)
90      expect(bodies[0].tool_choice).toEqual({ type: "function", function: { name: "generate_object" } })
91      const tool = bodies[0].tools?.[0]
92      expect(bodies[0].tools).toHaveLength(1)
93      expect(tool).toMatchObject({
94        type: "function",
95        function: { name: "generate_object" },
96      })
97      const params = tool?.function.parameters as {
98        readonly type?: unknown
99        readonly required?: unknown
100        readonly properties?: Record<string, unknown>
101      }
102      expect(params.type).toBe("object")
103      expect(params.required).toEqual(["city", "temp"])
104      expect(params.properties?.city).toMatchObject({ type: "string" })
105      expect(params.properties?.temp).toBeDefined()
106    }),
107  )
108 
109  it.effect("accepts a raw JSON Schema and returns the input untouched", () =>
110    Effect.gen(function* () {
111      const bodies: OpenAIChatBody[] = []
112      const layer = dynamicResponse((input) =>
113        Effect.sync(() => {
114          bodies.push(decodeBody(input.text))
115          return input.respond(
116            sseEvents(toolCallChunk("call_1", "generate_object", '{"name":"Ada","age":30}'), finishChunk("tool_calls")),
117            { headers: { "content-type": "text/event-stream" } },
118          )
119        }),
120      )
121 
122      const response = yield* LLM.generateObject({
123        model,
124        prompt: "Extract the user.",
125        jsonSchema: {
126          type: "object",
127          properties: { name: { type: "string" }, age: { type: "number" } },
128          required: ["name", "age"],
129        },
130      }).pipe(Effect.provide(layer))
131 
132      expect(response.object).toEqual({ name: "Ada", age: 30 })
133      expect(bodies[0].tools?.[0]?.function.parameters).toEqual({
134        type: "object",
135        properties: { name: { type: "string" }, age: { type: "number" } },
136        required: ["name", "age"],
137      })
138    }),
139  )
140 
141  it.effect("fails when the model does not call the synthetic tool", () =>
142    Effect.gen(function* () {
143      const layer = dynamicResponse((input) =>
144        Effect.sync(() =>
145          input.respond(sseEvents({ id: "x", choices: [{ delta: { content: "no thanks" }, finish_reason: "stop" }] }), {
146            headers: { "content-type": "text/event-stream" },
147          }),
148        ),
149      )
150 
151      const exit = yield* LLM.generateObject({
152        model,
153        prompt: "Return a structured value.",
154        schema: Schema.Struct({ value: Schema.Number }),
155      }).pipe(Effect.provide(layer), Effect.exit)
156 
157      expect(exit._tag).toBe("Failure")
158    }),
159  )
160 
161  it.effect("fails with a decode error when the tool input does not match the schema", () =>
162    Effect.gen(function* () {
163      const layer = dynamicResponse((input) =>
164        Effect.sync(() =>
165          input.respond(
166            sseEvents(
167              toolCallChunk("call_1", "generate_object", '{"value":"not-a-number"}'),
168              finishChunk("tool_calls"),
169            ),
170            { headers: { "content-type": "text/event-stream" } },
171          ),
172        ),
173      )
174 
175      const exit = yield* LLM.generateObject({
176        model,
177        prompt: "Return a structured value.",
178        schema: Schema.Struct({ value: Schema.Number }),
179      }).pipe(Effect.provide(layer), Effect.exit)
180 
181      expect(exit._tag).toBe("Failure")
182    }),
183  )
184})
185