openAgent

1import { describe, expect } from "bun:test"
2import { LayerNode } from "@opencode-ai/core/effect/layer-node"
3import { Cause, Effect, Exit, Schema } from "effect"
4import { Agent } from "../../src/agent/agent"
5import { MessageID, SessionID } from "../../src/session/schema"
6import { Tool } from "@/tool/tool"
7import { Truncate } from "@/tool/truncate"
8import { testEffect } from "../lib/effect"
9 
10const it = testEffect(LayerNode.compile(LayerNode.group([Truncate.node, Agent.node])))
11 
12const params = Schema.Struct({ input: Schema.String })
13 
14function makeCtx(): Tool.Context {
15  return {
16    sessionID: SessionID.descending(),
17    messageID: MessageID.ascending(),
18    agent: "build",
19    abort: new AbortController().signal,
20    messages: [],
21    metadata() {
22      return Effect.void
23    },
24    ask() {
25      return Effect.void
26    },
27  }
28}
29 
30function makeTool(id: string, executeFn?: () => void) {
31  return {
32    description: "test tool",
33    parameters: params,
34    execute() {
35      executeFn?.()
36      return Effect.succeed({ title: "test", output: "ok", metadata: {} })
37    },
38  }
39}
40 
41describe("Tool.define", () => {
42  it.effect("object-defined tool does not mutate the original init object", () =>
43    Effect.gen(function* () {
44      const original = makeTool("test")
45      const originalExecute = original.execute
46 
47      const info = yield* Tool.define("test-tool", Effect.succeed(original))
48 
49      yield* info.init()
50      yield* info.init()
51      yield* info.init()
52 
53      expect(original.execute).toBe(originalExecute)
54    }),
55  )
56 
57  it.effect("effect-defined tool returns fresh objects and is unaffected", () =>
58    Effect.gen(function* () {
59      const info = yield* Tool.define(
60        "test-fn-tool",
61        Effect.succeed(() => Effect.succeed(makeTool("test"))),
62      )
63 
64      const first = yield* info.init()
65      const second = yield* info.init()
66 
67      expect(first).not.toBe(second)
68    }),
69  )
70 
71  it.effect("object-defined tool returns distinct objects per init() call", () =>
72    Effect.gen(function* () {
73      const info = yield* Tool.define("test-copy", Effect.succeed(makeTool("test")))
74 
75      const first = yield* info.init()
76      const second = yield* info.init()
77 
78      expect(first).not.toBe(second)
79    }),
80  )
81 
82  it.effect("execute receives decoded parameters", () =>
83    Effect.gen(function* () {
84      const parameters = Schema.Struct({
85        count: Schema.NumberFromString.pipe(Schema.optional, Schema.withDecodingDefaultType(Effect.succeed(5))),
86      })
87      const calls: Array<Schema.Schema.Type<typeof parameters>> = []
88      const info = yield* Tool.define(
89        "test-decoded",
90        Effect.succeed({
91          description: "test tool",
92          parameters,
93          execute(args: Schema.Schema.Type<typeof parameters>) {
94            calls.push(args)
95            return Effect.succeed({ title: "test", output: "ok", metadata: { truncated: false } })
96          },
97        }),
98      )
99      const ctx = makeCtx()
100      const tool = yield* info.init()
101      const execute = tool.execute as unknown as (args: unknown, ctx: Tool.Context) => ReturnType<typeof tool.execute>
102 
103      yield* execute({}, ctx)
104      yield* execute({ count: "7" }, ctx)
105 
106      expect(calls).toEqual([{ count: 5 }, { count: 7 }])
107    }),
108  )
109 
110  // Regression for #28438: the wrap is the canonical "untyped → typed" boundary.
111  // When the LLM emits a tool call with a payload that fails the parameter
112  // schema, the wrap must surface a typed `Tool.InvalidArgumentsError` whose
113  // `.message` is the actionable prose the AI SDK feeds back to the model.
114  it.effect("invalid args surface as Tool.InvalidArgumentsError with friendly message and JSON path", () =>
115    Effect.gen(function* () {
116      const parameters = Schema.Struct({
117        questions: Schema.Array(
118          Schema.Struct({
119            question: Schema.String,
120            options: Schema.Array(Schema.String),
121          }),
122        ),
123      })
124      const info = yield* Tool.define(
125        "qtest",
126        Effect.succeed({
127          description: "test tool",
128          parameters,
129          execute() {
130            return Effect.succeed({ title: "ok", output: "ok", metadata: { truncated: false } })
131          },
132        }),
133      )
134      const tool = yield* info.init()
135      const execute = tool.execute as unknown as (args: unknown, ctx: Tool.Context) => ReturnType<typeof tool.execute>
136 
137      // Missing required `question` field on the first questions[] entry.
138      const exit = yield* execute({ questions: [{ options: ["a"] }] }, makeCtx()).pipe(Effect.exit)
139      expect(Exit.isFailure(exit)).toBe(true)
140      if (!Exit.isFailure(exit)) return
141 
142      // The wrap ends with Effect.orDie, so the failure lives in the cause as a
143      // defect. Recover the typed instance from there.
144      const die = exit.cause.reasons.find(Cause.isDieReason)
145      const error = die?.defect
146      expect(error).toBeInstanceOf(Tool.InvalidArgumentsError)
147      const args = error as Tool.InvalidArgumentsError
148      expect(args.tool).toBe("qtest")
149      expect(args.message).toContain("qtest tool was called with invalid arguments")
150      expect(args.message).toContain("Please rewrite the input")
151      expect(args.message).toContain(`["questions"][0]["question"]`)
152    }),
153  )
154})
155