rird 1.0.200

package/src/tests/tool-registry.test.ts

@@ -0,0 +1,589 @@
+import { describe, test, expect } from "bun:test"
+import z from "zod"
+import { Tool } from "../tool/tool"
+import { BashTool } from "../tool/bash"
+import { ReadTool } from "../tool/read"
+import { WriteTool } from "../tool/write"
+import { EditTool } from "../tool/edit"
+import { GlobTool } from "../tool/glob"
+import { GrepTool } from "../tool/grep"
+import { ListTool } from "../tool/ls"
+import { TaskTool } from "../tool/task"
+import { TodoWriteTool, TodoReadTool } from "../tool/todo"
+import { WebFetchTool } from "../tool/webfetch"
+import { BatchTool } from "../tool/batch"
+import { WebSearchTool } from "../tool/websearch"
+import { CodeSearchTool } from "../tool/codesearch"
+import { SkillTool } from "../tool/skill"
+import { LspTool } from "../tool/lsp"
+
+// Core tools that must always be present (using actual tool IDs)
+const REQUIRED_TOOL_IDS = [
+  "bash",
+  "read",
+  "write",
+  "edit",
+  "glob",
+  "grep",
+  "list",
+  "task",
+  "todowrite",
+  "todoread",
+]
+
+// All tools in the registry
+const ALL_TOOLS = [
+  BashTool,
+  ReadTool,
+  WriteTool,
+  EditTool,
+  GlobTool,
+  GrepTool,
+  ListTool,
+  TaskTool,
+  TodoWriteTool,
+  TodoReadTool,
+  WebFetchTool,
+  BatchTool,
+  WebSearchTool,
+  CodeSearchTool,
+  SkillTool,
+  LspTool,
+]
+
+describe("Tool definitions", () => {
+  test("all required tools are present", () => {
+    const toolIds = ALL_TOOLS.map((t) => t.id)
+
+    for (const required of REQUIRED_TOOL_IDS) {
+      expect(toolIds).toContain(required)
+    }
+  })
+
+  test("all tool IDs are unique", () => {
+    const toolIds = ALL_TOOLS.map((t) => t.id)
+    const uniqueIds = new Set(toolIds)
+
+    expect(uniqueIds.size).toBe(toolIds.length)
+  })
+
+  test("all tools have string IDs", () => {
+    for (const tool of ALL_TOOLS) {
+      expect(typeof tool.id).toBe("string")
+      expect(tool.id.length).toBeGreaterThan(0)
+    }
+  })
+
+  test("all tools have init function", () => {
+    for (const tool of ALL_TOOLS) {
+      expect(typeof tool.init).toBe("function")
+    }
+  })
+})
+
+describe("Tool ID verification", () => {
+  test("BashTool has correct id", () => {
+    expect(BashTool.id).toBe("bash")
+  })
+
+  test("ReadTool has correct id", () => {
+    expect(ReadTool.id).toBe("read")
+  })
+
+  test("WriteTool has correct id", () => {
+    expect(WriteTool.id).toBe("write")
+  })
+
+  test("EditTool has correct id", () => {
+    expect(EditTool.id).toBe("edit")
+  })
+
+  test("GlobTool has correct id", () => {
+    expect(GlobTool.id).toBe("glob")
+  })
+
+  test("GrepTool has correct id", () => {
+    expect(GrepTool.id).toBe("grep")
+  })
+
+  test("ListTool has correct id", () => {
+    expect(ListTool.id).toBe("list")
+  })
+
+  test("TaskTool has correct id", () => {
+    expect(TaskTool.id).toBe("task")
+  })
+
+  test("TodoWriteTool has correct id", () => {
+    expect(TodoWriteTool.id).toBe("todowrite")
+  })
+
+  test("TodoReadTool has correct id", () => {
+    expect(TodoReadTool.id).toBe("todoread")
+  })
+
+  test("WebFetchTool has correct id", () => {
+    expect(WebFetchTool.id).toBe("webfetch")
+  })
+
+  test("BatchTool has correct id", () => {
+    expect(BatchTool.id).toBe("batch")
+  })
+
+  test("WebSearchTool has correct id", () => {
+    expect(WebSearchTool.id).toBe("websearch")
+  })
+
+  test("CodeSearchTool has correct id", () => {
+    expect(CodeSearchTool.id).toBe("codesearch")
+  })
+
+  test("SkillTool has correct id", () => {
+    expect(SkillTool.id).toBe("skill")
+  })
+
+  test("LspTool has correct id", () => {
+    expect(LspTool.id).toBe("lsp")
+  })
+})
+
+describe("Tool.Info structure", () => {
+  test("Tool.Info has id property of type string", () => {
+    const tool = Tool.define("test-id", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async () => ({ title: "", output: "", metadata: {} }),
+    })
+
+    expect(typeof tool.id).toBe("string")
+    expect(tool.id).toBe("test-id")
+  })
+
+  test("Tool.Info has init method", () => {
+    const tool = Tool.define("test-init", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async () => ({ title: "", output: "", metadata: {} }),
+    })
+
+    expect(typeof tool.init).toBe("function")
+  })
+})
+
+describe("Tool.define helper", () => {
+  test("creates tool with correct id", () => {
+    const tool = Tool.define("test-tool", {
+      description: "Test tool",
+      parameters: z.object({
+        input: z.string(),
+      }),
+      execute: async () => ({
+        title: "Test",
+        output: "output",
+        metadata: {},
+      }),
+    })
+
+    expect(tool.id).toBe("test-tool")
+  })
+
+  test("created tool has init function", () => {
+    const tool = Tool.define("test-tool-2", {
+      description: "Test tool 2",
+      parameters: z.object({}),
+      execute: async () => ({
+        title: "Test",
+        output: "output",
+        metadata: {},
+      }),
+    })
+
+    expect(typeof tool.init).toBe("function")
+  })
+
+  test("init returns description and parameters", async () => {
+    const tool = Tool.define("test-tool-3", {
+      description: "My description",
+      parameters: z.object({
+        foo: z.string(),
+      }),
+      execute: async () => ({
+        title: "Test",
+        output: "output",
+        metadata: {},
+      }),
+    })
+
+    const toolInfo = await tool.init()
+
+    expect(toolInfo.description).toBe("My description")
+    expect(toolInfo.parameters).toBeDefined()
+  })
+
+  test("init returns execute function", async () => {
+    const tool = Tool.define("test-exec", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async () => ({
+        title: "Test",
+        output: "output",
+        metadata: {},
+      }),
+    })
+
+    const toolInfo = await tool.init()
+    expect(typeof toolInfo.execute).toBe("function")
+  })
+
+  test("tool validates parameters on execute - rejects invalid args", async () => {
+    const tool = Tool.define("validation-test", {
+      description: "Validation test",
+      parameters: z.object({
+        required: z.string(),
+      }),
+      execute: async (args) => ({
+        title: "Test",
+        output: args.required,
+        metadata: {},
+      }),
+    })
+
+    const toolInfo = await tool.init()
+
+    const ctx = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    // Invalid args should throw
+    let threw = false
+    try {
+      await toolInfo.execute({} as any, ctx)
+    } catch (e) {
+      threw = true
+      expect((e as Error).message).toContain("validation-test")
+    }
+    expect(threw).toBe(true)
+  })
+
+  test("tool accepts valid parameters", async () => {
+    const tool = Tool.define("valid-test", {
+      description: "Valid test",
+      parameters: z.object({
+        input: z.string(),
+      }),
+      execute: async (args) => ({
+        title: "Test",
+        output: args.input,
+        metadata: { echo: args.input },
+      }),
+    })
+
+    const toolInfo = await tool.init()
+
+    const ctx = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    const result = await toolInfo.execute({ input: "hello" }, ctx)
+    expect(result.output).toBe("hello")
+    expect(result.metadata.echo).toBe("hello")
+  })
+})
+
+describe("Tool parameters schema structure", () => {
+  test("Tool.define creates ZodObject parameters", async () => {
+    const tool = Tool.define("zod-test", {
+      description: "Test",
+      parameters: z.object({
+        field1: z.string(),
+        field2: z.number().optional(),
+      }),
+      execute: async () => ({ title: "", output: "", metadata: {} }),
+    })
+
+    const toolInfo = await tool.init()
+    expect(toolInfo.parameters instanceof z.ZodType).toBe(true)
+  })
+
+  test("parameters can have descriptions", async () => {
+    const tool = Tool.define("desc-test", {
+      description: "Test",
+      parameters: z.object({
+        path: z.string().describe("The file path"),
+        content: z.string().describe("The file content"),
+      }),
+      execute: async () => ({ title: "", output: "", metadata: {} }),
+    })
+
+    const toolInfo = await tool.init()
+    const shape = (toolInfo.parameters as z.ZodObject<any>).shape
+
+    expect(shape.path).toBeDefined()
+    expect(shape.content).toBeDefined()
+  })
+
+  test("parameters can have optional fields", async () => {
+    const tool = Tool.define("optional-test", {
+      description: "Test",
+      parameters: z.object({
+        required: z.string(),
+        optional: z.number().optional(),
+      }),
+      execute: async (args) => ({
+        title: "",
+        output: args.required,
+        metadata: { hasOptional: args.optional !== undefined },
+      }),
+    })
+
+    const toolInfo = await tool.init()
+
+    const ctx = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    // Works without optional field
+    const result1 = await toolInfo.execute({ required: "test" }, ctx)
+    expect(result1.metadata.hasOptional).toBe(false)
+
+    // Works with optional field
+    const result2 = await toolInfo.execute({ required: "test", optional: 42 }, ctx)
+    expect(result2.metadata.hasOptional).toBe(true)
+  })
+})
+
+describe("Tool execution result structure", () => {
+  test("execute returns title", async () => {
+    const tool = Tool.define("title-test", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async () => ({
+        title: "My Title",
+        output: "",
+        metadata: {},
+      }),
+    })
+
+    const toolInfo = await tool.init()
+    const ctx = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    const result = await toolInfo.execute({}, ctx)
+    expect(result.title).toBe("My Title")
+  })
+
+  test("execute returns output", async () => {
+    const tool = Tool.define("output-test", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async () => ({
+        title: "",
+        output: "This is the output",
+        metadata: {},
+      }),
+    })
+
+    const toolInfo = await tool.init()
+    const ctx = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    const result = await toolInfo.execute({}, ctx)
+    expect(result.output).toBe("This is the output")
+  })
+
+  test("execute returns metadata", async () => {
+    const tool = Tool.define("metadata-test", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async () => ({
+        title: "",
+        output: "",
+        metadata: {
+          custom: "value",
+          count: 42,
+        },
+      }),
+    })
+
+    const toolInfo = await tool.init()
+    const ctx = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    const result = await toolInfo.execute({}, ctx)
+    expect(result.metadata.custom).toBe("value")
+    expect(result.metadata.count).toBe(42)
+  })
+
+  test("execute can return attachments", async () => {
+    const tool = Tool.define("attach-test", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async () => ({
+        title: "",
+        output: "",
+        metadata: {},
+        attachments: [
+          {
+            id: "part1",
+            sessionID: "test",
+            messageID: "msg",
+            type: "file" as const,
+            mime: "image/png",
+            url: "data:image/png;base64,abc",
+          },
+        ],
+      }),
+    })
+
+    const toolInfo = await tool.init()
+    const ctx = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    const result = await toolInfo.execute({}, ctx)
+    expect(result.attachments).toBeDefined()
+    expect(result.attachments?.length).toBe(1)
+    expect(result.attachments?.[0].type).toBe("file")
+  })
+})
+
+describe("Tool context structure", () => {
+  test("context has required fields", async () => {
+    let receivedCtx: any = null
+
+    const tool = Tool.define("ctx-test", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async (_args, ctx) => {
+        receivedCtx = ctx
+        return { title: "", output: "", metadata: {} }
+      },
+    })
+
+    const toolInfo = await tool.init()
+    const ctx = {
+      sessionID: "session123",
+      messageID: "msg456",
+      agent: "plan",
+      abort: AbortSignal.any([]),
+      callID: "call789",
+      metadata: () => {},
+    }
+
+    await toolInfo.execute({}, ctx)
+
+    expect(receivedCtx.sessionID).toBe("session123")
+    expect(receivedCtx.messageID).toBe("msg456")
+    expect(receivedCtx.agent).toBe("plan")
+    expect(receivedCtx.callID).toBe("call789")
+    expect(receivedCtx.abort).toBeDefined()
+    expect(typeof receivedCtx.metadata).toBe("function")
+  })
+
+  test("context extra field is optional", async () => {
+    let receivedCtx: any = null
+
+    const tool = Tool.define("extra-test", {
+      description: "Test",
+      parameters: z.object({}),
+      execute: async (_args, ctx) => {
+        receivedCtx = ctx
+        return { title: "", output: "", metadata: {} }
+      },
+    })
+
+    const toolInfo = await tool.init()
+
+    // Without extra
+    const ctx1 = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    await toolInfo.execute({}, ctx1)
+    expect(receivedCtx.extra).toBeUndefined()
+
+    // With extra
+    const ctx2 = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+      extra: { bypassCwdCheck: true },
+    }
+
+    await toolInfo.execute({}, ctx2)
+    expect(receivedCtx.extra).toBeDefined()
+    expect(receivedCtx.extra.bypassCwdCheck).toBe(true)
+  })
+})
+
+describe("Tool formatValidationError", () => {
+  test("custom validation error formatter is used", async () => {
+    const tool = Tool.define("format-error-test", {
+      description: "Test",
+      parameters: z.object({
+        required: z.string(),
+      }),
+      execute: async () => ({ title: "", output: "", metadata: {} }),
+      formatValidationError: (error) => {
+        // Access issues array which exists on ZodError
+        return `Custom error: ${error.issues.length} validation issues`
+      },
+    })
+
+    const toolInfo = await tool.init()
+    const ctx = {
+      sessionID: "test",
+      messageID: "msg",
+      agent: "act",
+      abort: AbortSignal.any([]),
+      metadata: () => {},
+    }
+
+    let errorMessage = ""
+    try {
+      await toolInfo.execute({} as any, ctx)
+    } catch (e) {
+      errorMessage = (e as Error).message
+    }
+
+    expect(errorMessage).toContain("Custom error:")
+    expect(errorMessage).toContain("validation issues")
+  })
+})