@miaws/miaw 1.18.3 → 1.18.5

package/test/tool/parameters.test.ts

@@ -0,0 +1,293 @@
+import { describe, expect, test } from "bun:test"
+import { Result, Schema } from "effect"
+import { ToolJsonSchema } from "../../src/tool/json-schema"
+
+// Each tool exports its parameters schema at module scope so this test can
+// import them without running the tool's Effect-based init. The JSON Schema
+// snapshot captures what the LLM sees; the parse assertions pin down the
+// accepts/rejects contract. `ToolJsonSchema.fromSchema` is the same helper `session/
+// prompt.ts` uses to emit tool schemas to the LLM, so the snapshots stay
+// provider-compatible while tools use Effect Schema internally.
+
+import { Parameters as ApplyPatch } from "../../src/tool/apply_patch"
+import { Parameters as Edit } from "../../src/tool/edit"
+import { Parameters as Glob } from "../../src/tool/glob"
+import { Parameters as Grep } from "../../src/tool/grep"
+import { Parameters as Invalid } from "../../src/tool/invalid"
+import { Parameters as Lsp } from "../../src/tool/lsp"
+import { Parameters as Plan } from "../../src/tool/plan"
+import { Parameters as Question } from "../../src/tool/question"
+import { Parameters as Read } from "../../src/tool/read"
+import { Parameters as Shell } from "../../src/tool/shell"
+import { Parameters as Skill } from "../../src/tool/skill"
+import { Parameters as Task } from "../../src/tool/task"
+import { Parameters as Todo } from "../../src/tool/todo"
+import { Parameters as WebFetch } from "../../src/tool/webfetch"
+import { Parameters as WebSearch } from "../../src/tool/websearch"
+import { Parameters as Write } from "../../src/tool/write"
+
+const parse = <S extends Schema.Decoder<unknown>>(schema: S, input: unknown): S["Type"] =>
+  Schema.decodeUnknownSync(schema)(input)
+
+const accepts = (schema: Schema.Decoder<unknown>, input: unknown): boolean =>
+  Result.isSuccess(Schema.decodeUnknownResult(schema)(input))
+
+const toJsonSchema = ToolJsonSchema.fromSchema
+
+describe("tool parameters", () => {
+  describe("JSON Schema (wire shape)", () => {
+    test("apply_patch", () => expect(toJsonSchema(ApplyPatch)).toMatchSnapshot())
+    test("bash", () => expect(toJsonSchema(Shell)).toMatchSnapshot())
+    test("edit", () => expect(toJsonSchema(Edit)).toMatchSnapshot())
+    test("glob", () => expect(toJsonSchema(Glob)).toMatchSnapshot())
+    test("grep", () => expect(toJsonSchema(Grep)).toMatchSnapshot())
+    test("invalid", () => expect(toJsonSchema(Invalid)).toMatchSnapshot())
+    test("lsp", () => expect(toJsonSchema(Lsp)).toMatchSnapshot())
+    test("plan", () => expect(toJsonSchema(Plan)).toMatchSnapshot())
+    test("question", () => expect(toJsonSchema(Question)).toMatchSnapshot())
+    test("read", () => expect(toJsonSchema(Read)).toMatchSnapshot())
+    test("skill", () => expect(toJsonSchema(Skill)).toMatchSnapshot())
+    test("task", () => expect(toJsonSchema(Task)).toMatchSnapshot())
+    test("todo", () => expect(toJsonSchema(Todo)).toMatchSnapshot())
+    test("webfetch", () => expect(toJsonSchema(WebFetch)).toMatchSnapshot())
+    test("websearch", () => expect(toJsonSchema(WebSearch)).toMatchSnapshot())
+    test("write", () => expect(toJsonSchema(Write)).toMatchSnapshot())
+
+    test("inlines named child schemas for provider compatibility", () => {
+      const schema = toJsonSchema(Question)
+      expect(schema).not.toHaveProperty("$defs")
+      expect(schema).toMatchObject({
+        properties: {
+          questions: { items: { properties: { options: { items: { properties: { label: { type: "string" } } } } } } },
+        },
+      })
+    })
+
+    test("preserves required nullable fields", () => {
+      expect(toJsonSchema(Schema.Struct({ value: Schema.NullOr(Schema.String) }))).toMatchObject({
+        properties: { value: { anyOf: expect.arrayContaining([{ type: "null" }]) } },
+      })
+    })
+
+    test("keeps repeated allOf constraints instead of dropping duplicates", () => {
+      expect(
+        toJsonSchema(
+          Schema.Struct({ value: Schema.String.check(Schema.isPattern(/^a/)).check(Schema.isPattern(/z$/)) }),
+        ),
+      ).toMatchObject({ properties: { value: { allOf: [{ pattern: "^a" }, { pattern: "z$" }] } } })
+    })
+
+    test("bounds bare integer fields to safe integer range", () => {
+      expect(toJsonSchema(Schema.Struct({ value: Schema.Int }))).toMatchObject({
+        properties: { value: { minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER } },
+      })
+    })
+
+    test("does not expose defaulted optional keys as nullable", () => {
+      expect(toJsonSchema(WebFetch)).toMatchObject({
+        properties: { format: { type: "string", enum: ["text", "markdown", "html"], default: "markdown" } },
+      })
+      expect(toJsonSchema(WebFetch).properties?.format).not.toHaveProperty("anyOf")
+    })
+  })
+
+  describe("apply_patch", () => {
+    test("accepts patchText", () => {
+      expect(parse(ApplyPatch, { patchText: "*** Begin Patch\n*** End Patch" })).toEqual({
+        patchText: "*** Begin Patch\n*** End Patch",
+      })
+    })
+    test("rejects missing patchText", () => {
+      expect(accepts(ApplyPatch, {})).toBe(false)
+    })
+    test("rejects non-string patchText", () => {
+      expect(accepts(ApplyPatch, { patchText: 123 })).toBe(false)
+    })
+  })
+
+  describe("shell", () => {
+    test("accepts minimum: command + description", () => {
+      expect(parse(Shell, { command: "ls", description: "list" })).toEqual({ command: "ls", description: "list" })
+    })
+    test("accepts optional timeout + workdir", () => {
+      const parsed = parse(Shell, { command: "ls", description: "list", timeout: 5000, workdir: "/tmp" })
+      expect(parsed.timeout).toBe(5000)
+      expect(parsed.workdir).toBe("/tmp")
+    })
+    test("rejects missing description", () => {
+      expect(accepts(Shell, { command: "ls" })).toBe(false)
+    })
+    test("rejects missing command", () => {
+      expect(accepts(Shell, { description: "list" })).toBe(false)
+    })
+  })
+
+  describe("edit", () => {
+    test("accepts all four fields", () => {
+      expect(parse(Edit, { filePath: "/a", oldString: "x", newString: "y", replaceAll: true })).toEqual({
+        filePath: "/a",
+        oldString: "x",
+        newString: "y",
+        replaceAll: true,
+      })
+    })
+    test("replaceAll is optional", () => {
+      const parsed = parse(Edit, { filePath: "/a", oldString: "x", newString: "y" })
+      expect(parsed.replaceAll).toBeUndefined()
+    })
+    test("rejects missing filePath", () => {
+      expect(accepts(Edit, { oldString: "x", newString: "y" })).toBe(false)
+    })
+  })
+
+  describe("glob", () => {
+    test("accepts pattern-only", () => {
+      expect(parse(Glob, { pattern: "**/*.ts" })).toEqual({ pattern: "**/*.ts" })
+    })
+    test("accepts optional path", () => {
+      expect(parse(Glob, { pattern: "**/*.ts", path: "/tmp" }).path).toBe("/tmp")
+    })
+    test("rejects missing pattern", () => {
+      expect(accepts(Glob, {})).toBe(false)
+    })
+  })
+
+  describe("grep", () => {
+    test("accepts pattern-only", () => {
+      expect(parse(Grep, { pattern: "TODO" })).toEqual({ pattern: "TODO" })
+    })
+    test("accepts optional path + include", () => {
+      const parsed = parse(Grep, { pattern: "TODO", path: "/tmp", include: "*.ts" })
+      expect(parsed.path).toBe("/tmp")
+      expect(parsed.include).toBe("*.ts")
+    })
+    test("rejects missing pattern", () => {
+      expect(accepts(Grep, {})).toBe(false)
+    })
+  })
+
+  describe("invalid", () => {
+    test("accepts tool + error", () => {
+      expect(parse(Invalid, { tool: "foo", error: "bar" })).toEqual({ tool: "foo", error: "bar" })
+    })
+    test("rejects missing fields", () => {
+      expect(accepts(Invalid, { tool: "foo" })).toBe(false)
+      expect(accepts(Invalid, { error: "bar" })).toBe(false)
+    })
+  })
+
+  describe("lsp", () => {
+    test("accepts all fields", () => {
+      const parsed = parse(Lsp, { operation: "hover", filePath: "/a.ts", line: 1, character: 1 })
+      expect(parsed.operation).toBe("hover")
+    })
+    test("rejects line < 1", () => {
+      expect(accepts(Lsp, { operation: "hover", filePath: "/a.ts", line: 0, character: 1 })).toBe(false)
+    })
+    test("rejects character < 1", () => {
+      expect(accepts(Lsp, { operation: "hover", filePath: "/a.ts", line: 1, character: 0 })).toBe(false)
+    })
+    test("rejects unknown operation", () => {
+      expect(accepts(Lsp, { operation: "bogus", filePath: "/a.ts", line: 1, character: 1 })).toBe(false)
+    })
+  })
+
+  describe("plan", () => {
+    test("accepts empty object", () => {
+      expect(parse(Plan, {})).toEqual({})
+    })
+  })
+
+  describe("question", () => {
+    test("accepts questions array", () => {
+      const parsed = parse(Question, {
+        questions: [
+          {
+            question: "pick one",
+            header: "Header",
+            custom: false,
+            options: [{ label: "a", description: "desc" }],
+          },
+        ],
+      })
+      expect(parsed.questions.length).toBe(1)
+    })
+    test("rejects missing questions", () => {
+      expect(accepts(Question, {})).toBe(false)
+    })
+  })
+
+  describe("read", () => {
+    test("accepts filePath-only", () => {
+      expect(parse(Read, { filePath: "/a" }).filePath).toBe("/a")
+    })
+    test("accepts optional offset + limit", () => {
+      const parsed = parse(Read, { filePath: "/a", offset: 10, limit: 100 })
+      expect(parsed.offset).toBe(10)
+      expect(parsed.limit).toBe(100)
+    })
+  })
+
+  describe("skill", () => {
+    test("accepts name", () => {
+      expect(parse(Skill, { name: "foo" }).name).toBe("foo")
+    })
+    test("rejects missing name", () => {
+      expect(accepts(Skill, {})).toBe(false)
+    })
+  })
+
+  describe("task", () => {
+    test("accepts description + prompt + subagent_type", () => {
+      const parsed = parse(Task, { description: "d", prompt: "p", subagent_type: "general" })
+      expect(parsed.subagent_type).toBe("general")
+    })
+    test("accepts optional background flag", () => {
+      const parsed = parse(Task, { description: "d", prompt: "p", subagent_type: "general", background: true })
+      expect(parsed.background).toBe(true)
+    })
+    test("rejects missing prompt", () => {
+      expect(accepts(Task, { description: "d", subagent_type: "general" })).toBe(false)
+    })
+  })
+
+  describe("todo", () => {
+    test("accepts todos array", () => {
+      const parsed = parse(Todo, {
+        todos: [{ id: "t1", content: "do x", status: "pending", priority: "medium" }],
+      })
+      expect(parsed.todos.length).toBe(1)
+    })
+    test("rejects missing todos", () => {
+      expect(accepts(Todo, {})).toBe(false)
+    })
+  })
+
+  describe("webfetch", () => {
+    test("defaults omitted format to markdown", () => {
+      expect(parse(WebFetch, { url: "https://example.com" })).toEqual({
+        url: "https://example.com",
+        format: "markdown",
+      })
+      expect(parse(WebFetch, { url: "https://example.com", format: undefined })).toEqual({
+        url: "https://example.com",
+        format: "markdown",
+      })
+    })
+  })
+
+  describe("websearch", () => {
+    test("accepts query", () => {
+      expect(parse(WebSearch, { query: "miaw" }).query).toBe("miaw")
+    })
+  })
+
+  describe("write", () => {
+    test("accepts content + filePath", () => {
+      expect(parse(Write, { content: "hi", filePath: "/a" })).toEqual({ content: "hi", filePath: "/a" })
+    })
+    test("rejects missing filePath", () => {
+      expect(accepts(Write, { content: "hi" })).toBe(false)
+    })
+  })
+})

package/test/tool/question.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect } from "bun:test"
+import { Effect, Fiber, Layer, Queue } from "effect"
+import { QuestionTool } from "../../src/tool/question"
+import { Question } from "../../src/question"
+import { SessionID, MessageID } from "../../src/session/schema"
+import { Agent } from "../../src/agent/agent"
+import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
+import { Truncate } from "@/tool/truncate"
+import { testEffect } from "../lib/effect"
+import { EventV2Bridge } from "../../src/event-v2-bridge"
+
+const ctx = {
+  sessionID: SessionID.make("ses_test-session"),
+  messageID: MessageID.make("msg_test-message"),
+  callID: "test-call",
+  agent: "test-agent",
+  abort: AbortSignal.any([]),
+  messages: [],
+  metadata: () => Effect.void,
+  ask: () => Effect.void,
+}
+
+const it = testEffect(
+  Layer.mergeAll(
+    Question.layer.pipe(Layer.provideMerge(EventV2Bridge.defaultLayer)),
+    CrossSpawnSpawner.defaultLayer,
+    Truncate.defaultLayer,
+    Agent.defaultLayer,
+  ),
+)
+
+const pending = Effect.fn("QuestionToolTest.pending")(function* (question: Question.Interface) {
+  const events = yield* EventV2Bridge.Service
+  const asked = yield* Queue.unbounded<void>()
+  const off = yield* events.listen((event) => {
+    if (event.type === Question.Event.Asked.type) Queue.offerUnsafe(asked, undefined)
+    return Effect.void
+  })
+  yield* Effect.addFinalizer(() => off)
+
+  for (;;) {
+    const items = yield* question.list()
+    const item = items[0]
+    if (item) return item
+    yield* Queue.take(asked).pipe(Effect.timeout("2 seconds"))
+  }
+})
+
+describe("tool.question", () => {
+  it.instance("should successfully execute with valid question parameters", () =>
+    Effect.gen(function* () {
+      const question = yield* Question.Service
+      const toolInfo = yield* QuestionTool
+      const tool = yield* toolInfo.init()
+      const questions = [
+        {
+          question: "What is your favorite color?",
+          header: "Color",
+          options: [
+            { label: "Red", description: "The color of passion" },
+            { label: "Blue", description: "The color of sky" },
+          ],
+          multiple: false,
+        },
+      ]
+
+      const fiber = yield* tool.execute({ questions }, ctx).pipe(Effect.forkScoped)
+      const item = yield* pending(question)
+      yield* question.reply({ requestID: item.id, answers: [["Red"]] })
+
+      const result = yield* Fiber.join(fiber)
+      expect(result.title).toBe("Asked 1 question")
+    }),
+  )
+
+  it.instance("should now pass with a header longer than 12 but less than 30 chars", () =>
+    Effect.gen(function* () {
+      const question = yield* Question.Service
+      const toolInfo = yield* QuestionTool
+      const tool = yield* toolInfo.init()
+      const questions = [
+        {
+          question: "What is your favorite animal?",
+          header: "This Header is Over 12",
+          options: [{ label: "Dog", description: "Man's best friend" }],
+        },
+      ]
+
+      const fiber = yield* tool.execute({ questions }, ctx).pipe(Effect.forkScoped)
+      const item = yield* pending(question)
+      yield* question.reply({ requestID: item.id, answers: [["Dog"]] })
+
+      const result = yield* Fiber.join(fiber)
+      expect(result.output).toContain(`"What is your favorite animal?"="Dog"`)
+    }),
+  )
+
+  // intentionally removed the zod validation due to tool call errors, hoping prompting is gonna be good enough
+  //   test("should throw an Error for header exceeding 30 characters", async () => {
+  //     const tool = await QuestionTool.init()
+  //     const questions = [
+  //       {
+  //         question: "What is your favorite animal?",
+  //         header: "This Header is Definitely More Than Thirty Characters Long",
+  //         options: [{ label: "Dog", description: "Man's best friend" }],
+  //       },
+  //     ]
+  //     try {
+  //       await tool.execute({ questions }, ctx)
+  //       // If it reaches here, the test should fail
+  //       expect(true).toBe(false)
+  //     } catch (e: any) {
+  //       expect(e).toBeInstanceOf(Error)
+  //       expect(e.cause).toBeInstanceOf(z.ZodError)
+  //     }
+  //   })
+
+  //   test("should throw an Error for label exceeding 30 characters", async () => {
+  //     const tool = await QuestionTool.init()
+  //     const questions = [
+  //       {
+  //         question: "A question with a very long label",
+  //         header: "Long Label",
+  //         options: [
+  //           { label: "This is a very, very, very long label that will exceed the limit", description: "A description" },
+  //         ],
+  //       },
+  //     ]
+  //     try {
+  //       await tool.execute({ questions }, ctx)
+  //       // If it reaches here, the test should fail
+  //       expect(true).toBe(false)
+  //     } catch (e: any) {
+  //       expect(e).toBeInstanceOf(Error)
+  //       expect(e.cause).toBeInstanceOf(z.ZodError)
+  //     }
+  //   })
+})