@livekit/agents 0.0.0-20260120144724

package/dist/llm/tool_context.test.js

@@ -0,0 +1,336 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import * as z3 from "zod/v3";
+import * as z4 from "zod/v4";
+import { tool } from "./tool_context.js";
+import { createToolOptions, oaiParams } from "./utils.js";
+describe("Tool Context", () => {
+  describe("oaiParams", () => {
+    it("should handle basic object schema", () => {
+      const schema = z.object({
+        name: z.string().describe("The user name"),
+        age: z.number().describe("The user age")
+      });
+      const result = oaiParams(schema);
+      expect(result).toMatchSnapshot();
+    });
+    it("should handle enum fields", () => {
+      const schema = z.object({
+        color: z.enum(["red", "blue", "green"]).describe("Choose a color")
+      });
+      const result = oaiParams(schema);
+      expect(result).toMatchSnapshot();
+    });
+    it("should handle array fields", () => {
+      const schema = z.object({
+        tags: z.array(z.string()).describe("List of tags")
+      });
+      const result = oaiParams(schema);
+      expect(result).toMatchSnapshot();
+    });
+    it("should handle array of enums", () => {
+      const schema = z.object({
+        colors: z.array(z.enum(["red", "blue", "green"])).describe("List of colors")
+      });
+      const result = oaiParams(schema);
+      expect(result).toMatchSnapshot();
+    });
+    it("should handle optional fields", () => {
+      const schema = z.object({
+        name: z.string().describe("The user name"),
+        age: z.number().optional().describe("The user age")
+      });
+      const result = oaiParams(schema);
+      expect(result).toMatchSnapshot();
+    });
+    it("should handle fields without descriptions", () => {
+      const schema = z.object({
+        name: z.string(),
+        age: z.number()
+      });
+      const result = oaiParams(schema);
+      expect(result).toMatchSnapshot();
+    });
+  });
+  describe("tool", () => {
+    it("should create and execute a basic core tool", async () => {
+      const getWeather = tool({
+        description: "Get the weather for a given location",
+        parameters: z.object({
+          location: z.string()
+        }),
+        execute: async ({ location }, { ctx }) => {
+          return `The weather in ${location} is sunny, ${ctx.userData.name}`;
+        }
+      });
+      const result = await getWeather.execute(
+        { location: "San Francisco" },
+        createToolOptions("123", { name: "John" })
+      );
+      expect(result).toBe("The weather in San Francisco is sunny, John");
+    });
+    it("should properly type a callable function", async () => {
+      const testFunction = tool({
+        description: "Test function",
+        parameters: z.object({
+          name: z.string().describe("The user name"),
+          age: z.number().describe("The user age")
+        }),
+        execute: async (args) => {
+          return `${args.name} is ${args.age} years old`;
+        }
+      });
+      const result = await testFunction.execute(
+        { name: "John", age: 30 },
+        createToolOptions("123")
+      );
+      expect(result).toBe("John is 30 years old");
+    });
+    it("should handle async execution", async () => {
+      const testFunction = tool({
+        description: "Async test function",
+        parameters: z.object({
+          delay: z.number().describe("Delay in milliseconds")
+        }),
+        execute: async (args) => {
+          await new Promise((resolve) => setTimeout(resolve, args.delay));
+          return args.delay;
+        }
+      });
+      const start = Date.now();
+      const result = await testFunction.execute({ delay: 100 }, createToolOptions("123"));
+      const duration = Date.now() - start;
+      expect(result).toBe(100);
+      expect(duration).toBeGreaterThanOrEqual(95);
+    });
+    describe("nested array support", () => {
+      it("should handle nested array fields", () => {
+        const schema = z.object({
+          items: z.array(
+            z.object({
+              name: z.string().describe("the item name"),
+              modifiers: z.array(
+                z.object({
+                  modifier_name: z.string(),
+                  modifier_value: z.string()
+                })
+              ).describe("list of the modifiers applied on this item, such as size")
+            })
+          )
+        });
+        const result = oaiParams(schema);
+        expect(result).toMatchSnapshot();
+      });
+    });
+    describe("optional parameters", () => {
+      it("should create a tool without parameters", async () => {
+        const simpleAction = tool({
+          description: "Perform a simple action",
+          execute: async () => {
+            return "Action performed";
+          }
+        });
+        expect(simpleAction.type).toBe("function");
+        expect(simpleAction.description).toBe("Perform a simple action");
+        expect(simpleAction.parameters).toBeDefined();
+        expect(simpleAction.parameters._def.typeName).toBe("ZodObject");
+        const result = await simpleAction.execute({}, createToolOptions("123"));
+        expect(result).toBe("Action performed");
+      });
+      it("should support .optional() fields in tool parameters", async () => {
+        const weatherTool = tool({
+          description: "Get weather information",
+          parameters: z.object({
+            location: z.string().describe("The city or location").optional(),
+            units: z.enum(["celsius", "fahrenheit"]).describe("Temperature units").optional()
+          }),
+          execute: async ({ location, units }) => {
+            const loc = location ?? "Unknown";
+            const unit = units ?? "celsius";
+            return `Weather in ${loc} (${unit})`;
+          }
+        });
+        expect(weatherTool.type).toBe("function");
+        expect(weatherTool.description).toBe("Get weather information");
+        const result1 = await weatherTool.execute(
+          { location: "London", units: "celsius" },
+          createToolOptions("123")
+        );
+        expect(result1).toBe("Weather in London (celsius)");
+        const result2 = await weatherTool.execute({}, createToolOptions("123"));
+        expect(result2).toBe("Weather in Unknown (celsius)");
+        const result3 = await weatherTool.execute({ location: "Paris" }, createToolOptions("123"));
+        expect(result3).toBe("Weather in Paris (celsius)");
+      });
+      it("should handle tools with context but no parameters", async () => {
+        const greetUser = tool({
+          description: "Greet the current user",
+          execute: async (_, { ctx }) => {
+            return `Hello, ${ctx.userData.username}!`;
+          }
+        });
+        const result = await greetUser.execute({}, createToolOptions("123", { username: "Alice" }));
+        expect(result).toBe("Hello, Alice!");
+      });
+      it("should create a tool that accesses tool call id without parameters", async () => {
+        const getCallId = tool({
+          description: "Get the current tool call ID",
+          execute: async (_, { toolCallId }) => {
+            return `Tool call ID: ${toolCallId}`;
+          }
+        });
+        const result = await getCallId.execute({}, createToolOptions("test-id-456"));
+        expect(result).toBe("Tool call ID: test-id-456");
+      });
+    });
+    describe("Zod v3 and v4 compatibility", () => {
+      it("should work with Zod v3 schemas", async () => {
+        const v3Tool = tool({
+          description: "A tool using Zod v3 schema",
+          parameters: z3.object({
+            name: z3.string(),
+            count: z3.number()
+          }),
+          execute: async ({ name, count }) => {
+            return `${name}: ${count}`;
+          }
+        });
+        const result = await v3Tool.execute(
+          { name: "Test", count: 42 },
+          createToolOptions("v3-test")
+        );
+        expect(result).toBe("Test: 42");
+      });
+      it("should work with Zod v4 schemas", async () => {
+        const v4Tool = tool({
+          description: "A tool using Zod v4 schema",
+          parameters: z4.object({
+            name: z4.string(),
+            count: z4.number()
+          }),
+          execute: async ({ name, count }) => {
+            return `${name}: ${count}`;
+          }
+        });
+        const result = await v4Tool.execute(
+          { name: "Test", count: 42 },
+          createToolOptions("v4-test")
+        );
+        expect(result).toBe("Test: 42");
+      });
+      it("should handle v4 schemas with optional fields", async () => {
+        const v4Tool = tool({
+          description: "Tool with optional field using v4",
+          parameters: z4.object({
+            required: z4.string(),
+            optional: z4.string().optional()
+          }),
+          execute: async ({ required, optional }) => {
+            return optional ? `${required} - ${optional}` : required;
+          }
+        });
+        const result1 = await v4Tool.execute({ required: "Hello" }, createToolOptions("test-1"));
+        expect(result1).toBe("Hello");
+        const result2 = await v4Tool.execute(
+          { required: "Hello", optional: "World" },
+          createToolOptions("test-2")
+        );
+        expect(result2).toBe("Hello - World");
+      });
+      it("should handle v4 enum schemas", async () => {
+        const v4Tool = tool({
+          description: "Tool with enum using v4",
+          parameters: z4.object({
+            color: z4.enum(["red", "blue", "green"])
+          }),
+          execute: async ({ color }) => {
+            return `Selected color: ${color}`;
+          }
+        });
+        const result = await v4Tool.execute({ color: "blue" }, createToolOptions("test-enum"));
+        expect(result).toBe("Selected color: blue");
+      });
+      it("should handle v4 array schemas", async () => {
+        const v4Tool = tool({
+          description: "Tool with array using v4",
+          parameters: z4.object({
+            tags: z4.array(z4.string())
+          }),
+          execute: async ({ tags }) => {
+            return `Tags: ${tags.join(", ")}`;
+          }
+        });
+        const result = await v4Tool.execute(
+          { tags: ["nodejs", "typescript", "testing"] },
+          createToolOptions("test-array")
+        );
+        expect(result).toBe("Tags: nodejs, typescript, testing");
+      });
+      it("should handle v4 nested object schemas", async () => {
+        const v4Tool = tool({
+          description: "Tool with nested object using v4",
+          parameters: z4.object({
+            user: z4.object({
+              name: z4.string(),
+              email: z4.string()
+            })
+          }),
+          execute: async ({ user }) => {
+            return `${user.name} (${user.email})`;
+          }
+        });
+        const result = await v4Tool.execute(
+          { user: { name: "John Doe", email: "john@example.com" } },
+          createToolOptions("test-nested")
+        );
+        expect(result).toBe("John Doe (john@example.com)");
+      });
+    });
+    describe("oaiParams with v4 schemas", () => {
+      it("should convert v4 basic object schema", () => {
+        const schema = z4.object({
+          name: z4.string().describe("User name"),
+          age: z4.number().describe("User age")
+        });
+        const result = oaiParams(schema);
+        expect(result.type).toBe("object");
+        expect(result.properties).toHaveProperty("name");
+        expect(result.properties).toHaveProperty("age");
+        expect(result.required).toContain("name");
+        expect(result.required).toContain("age");
+      });
+      it("should handle v4 optional fields", () => {
+        const schema = z4.object({
+          required: z4.string(),
+          optional: z4.string().optional()
+        });
+        const result = oaiParams(schema);
+        expect(result.required).toContain("required");
+        expect(result.required).not.toContain("optional");
+      });
+      it("should handle v4 enum fields", () => {
+        var _a;
+        const schema = z4.object({
+          status: z4.enum(["pending", "approved", "rejected"])
+        });
+        const result = oaiParams(schema);
+        const properties = result.properties;
+        expect((_a = properties.status) == null ? void 0 : _a.enum).toEqual(["pending", "approved", "rejected"]);
+      });
+      it("should handle v4 array fields", () => {
+        const schema = z4.object({
+          items: z4.array(z4.string())
+        });
+        const result = oaiParams(schema);
+        const properties = result.properties;
+        expect(
+          properties.items && typeof properties.items === "object" ? properties.items.type : void 0
+        ).toBe("array");
+        expect(
+          properties.items && properties.items.items && typeof properties.items.items === "object" ? properties.items.items.type : void 0
+        ).toBe("string");
+      });
+    });
+  });
+});
+//# sourceMappingURL=tool_context.test.js.map

package/dist/llm/tool_context.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/llm/tool_context.test.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { describe, expect, it } from 'vitest';\nimport { z } from 'zod';\nimport * as z3 from 'zod/v3';\nimport * as z4 from 'zod/v4';\nimport { type ToolOptions, tool } from './tool_context.js';\nimport { createToolOptions, oaiParams } from './utils.js';\n\ndescribe('Tool Context', () => {\n  describe('oaiParams', () => {\n    it('should handle basic object schema', () => {\n      const schema = z.object({\n        name: z.string().describe('The user name'),\n        age: z.number().describe('The user age'),\n      });\n\n      const result = oaiParams(schema);\n\n      expect(result).toMatchSnapshot();\n    });\n\n    it('should handle enum fields', () => {\n      const schema = z.object({\n        color: z.enum(['red', 'blue', 'green']).describe('Choose a color'),\n      });\n\n      const result = oaiParams(schema);\n\n      expect(result).toMatchSnapshot();\n    });\n\n    it('should handle array fields', () => {\n      const schema = z.object({\n        tags: z.array(z.string()).describe('List of tags'),\n      });\n\n      const result = oaiParams(schema);\n\n      expect(result).toMatchSnapshot();\n    });\n\n    it('should handle array of enums', () => {\n      const schema = z.object({\n        colors: z.array(z.enum(['red', 'blue', 'green'])).describe('List of colors'),\n      });\n\n      const result = oaiParams(schema);\n\n      expect(result).toMatchSnapshot();\n    });\n\n    it('should handle optional fields', () => {\n      const schema = z.object({\n        name: z.string().describe('The user name'),\n        age: z.number().optional().describe('The user age'),\n      });\n\n      const result = oaiParams(schema);\n\n      expect(result).toMatchSnapshot();\n    });\n\n    it('should handle fields without descriptions', () => {\n      const schema = z.object({\n        name: z.string(),\n        age: z.number(),\n      });\n\n      const result = oaiParams(schema);\n\n      expect(result).toMatchSnapshot();\n    });\n  });\n\n  describe('tool', () => {\n    it('should create and execute a basic core tool', async () => {\n      const getWeather = tool({\n        description: 'Get the weather for a given location',\n        parameters: z.object({\n          location: z.string(),\n        }),\n        execute: async ({ location }, { ctx }: ToolOptions<{ name: string }>) => {\n          return `The weather in ${location} is sunny, ${ctx.userData.name}`;\n        },\n      });\n\n      const result = await getWeather.execute(\n        { location: 'San Francisco' },\n        createToolOptions('123', { name: 'John' }),\n      );\n      expect(result).toBe('The weather in San Francisco is sunny, John');\n    });\n\n    it('should properly type a callable function', async () => {\n      const testFunction = tool({\n        description: 'Test function',\n        parameters: z.object({\n          name: z.string().describe('The user name'),\n          age: z.number().describe('The user age'),\n        }),\n        execute: async (args) => {\n          return `${args.name} is ${args.age} years old`;\n        },\n      });\n\n      const result = await testFunction.execute(\n        { name: 'John', age: 30 },\n        createToolOptions('123'),\n      );\n      expect(result).toBe('John is 30 years old');\n    });\n\n    it('should handle async execution', async () => {\n      const testFunction = tool({\n        description: 'Async test function',\n        parameters: z.object({\n          delay: z.number().describe('Delay in milliseconds'),\n        }),\n        execute: async (args) => {\n          await new Promise((resolve) => setTimeout(resolve, args.delay));\n          return args.delay;\n        },\n      });\n\n      const start = Date.now();\n      const result = await testFunction.execute({ delay: 100 }, createToolOptions('123'));\n      const duration = Date.now() - start;\n\n      expect(result).toBe(100);\n      expect(duration).toBeGreaterThanOrEqual(95); // Allow for small timing variations\n    });\n\n    describe('nested array support', () => {\n      it('should handle nested array fields', () => {\n        const schema = z.object({\n          items: z.array(\n            z.object({\n              name: z.string().describe('the item name'),\n              modifiers: z\n                .array(\n                  z.object({\n                    modifier_name: z.string(),\n                    modifier_value: z.string(),\n                  }),\n                )\n                .describe('list of the modifiers applied on this item, such as size'),\n            }),\n          ),\n        });\n        const result = oaiParams(schema);\n        expect(result).toMatchSnapshot();\n      });\n    });\n\n    describe('optional parameters', () => {\n      it('should create a tool without parameters', async () => {\n        const simpleAction = tool({\n          description: 'Perform a simple action',\n          execute: async () => {\n            return 'Action performed';\n          },\n        });\n\n        expect(simpleAction.type).toBe('function');\n        expect(simpleAction.description).toBe('Perform a simple action');\n        expect(simpleAction.parameters).toBeDefined();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        expect((simpleAction.parameters as any)._def.typeName).toBe('ZodObject');\n\n        const result = await simpleAction.execute({}, createToolOptions('123'));\n        expect(result).toBe('Action performed');\n      });\n\n      it('should support .optional() fields in tool parameters', async () => {\n        const weatherTool = tool({\n          description: 'Get weather information',\n          parameters: z.object({\n            location: z.string().describe('The city or location').optional(),\n            units: z.enum(['celsius', 'fahrenheit']).describe('Temperature units').optional(),\n          }),\n          execute: async ({ location, units }) => {\n            const loc = location ?? 'Unknown';\n            const unit = units ?? 'celsius';\n            return `Weather in ${loc} (${unit})`;\n          },\n        });\n\n        expect(weatherTool.type).toBe('function');\n        expect(weatherTool.description).toBe('Get weather information');\n\n        const result1 = await weatherTool.execute(\n          { location: 'London', units: 'celsius' },\n          createToolOptions('123'),\n        );\n        expect(result1).toBe('Weather in London (celsius)');\n\n        const result2 = await weatherTool.execute({}, createToolOptions('123'));\n        expect(result2).toBe('Weather in Unknown (celsius)');\n\n        const result3 = await weatherTool.execute({ location: 'Paris' }, createToolOptions('123'));\n        expect(result3).toBe('Weather in Paris (celsius)');\n      });\n\n      it('should handle tools with context but no parameters', async () => {\n        const greetUser = tool({\n          description: 'Greet the current user',\n          execute: async (_, { ctx }: ToolOptions<{ username: string }>) => {\n            return `Hello, ${ctx.userData.username}!`;\n          },\n        });\n\n        const result = await greetUser.execute({}, createToolOptions('123', { username: 'Alice' }));\n        expect(result).toBe('Hello, Alice!');\n      });\n\n      it('should create a tool that accesses tool call id without parameters', async () => {\n        const getCallId = tool({\n          description: 'Get the current tool call ID',\n          execute: async (_, { toolCallId }) => {\n            return `Tool call ID: ${toolCallId}`;\n          },\n        });\n\n        const result = await getCallId.execute({}, createToolOptions('test-id-456'));\n        expect(result).toBe('Tool call ID: test-id-456');\n      });\n    });\n\n    describe('Zod v3 and v4 compatibility', () => {\n      it('should work with Zod v3 schemas', async () => {\n        const v3Tool = tool({\n          description: 'A tool using Zod v3 schema',\n          parameters: z3.object({\n            name: z3.string(),\n            count: z3.number(),\n          }),\n          execute: async ({ name, count }) => {\n            return `${name}: ${count}`;\n          },\n        });\n\n        const result = await v3Tool.execute(\n          { name: 'Test', count: 42 },\n          createToolOptions('v3-test'),\n        );\n        expect(result).toBe('Test: 42');\n      });\n\n      it('should work with Zod v4 schemas', async () => {\n        const v4Tool = tool({\n          description: 'A tool using Zod v4 schema',\n          parameters: z4.object({\n            name: z4.string(),\n            count: z4.number(),\n          }),\n          execute: async ({ name, count }) => {\n            return `${name}: ${count}`;\n          },\n        });\n\n        const result = await v4Tool.execute(\n          { name: 'Test', count: 42 },\n          createToolOptions('v4-test'),\n        );\n        expect(result).toBe('Test: 42');\n      });\n\n      it('should handle v4 schemas with optional fields', async () => {\n        const v4Tool = tool({\n          description: 'Tool with optional field using v4',\n          parameters: z4.object({\n            required: z4.string(),\n            optional: z4.string().optional(),\n          }),\n          execute: async ({ required, optional }) => {\n            return optional ? `${required} - ${optional}` : required;\n          },\n        });\n\n        const result1 = await v4Tool.execute({ required: 'Hello' }, createToolOptions('test-1'));\n        expect(result1).toBe('Hello');\n\n        const result2 = await v4Tool.execute(\n          { required: 'Hello', optional: 'World' },\n          createToolOptions('test-2'),\n        );\n        expect(result2).toBe('Hello - World');\n      });\n\n      it('should handle v4 enum schemas', async () => {\n        const v4Tool = tool({\n          description: 'Tool with enum using v4',\n          parameters: z4.object({\n            color: z4.enum(['red', 'blue', 'green']),\n          }),\n          execute: async ({ color }) => {\n            return `Selected color: ${color}`;\n          },\n        });\n\n        const result = await v4Tool.execute({ color: 'blue' }, createToolOptions('test-enum'));\n        expect(result).toBe('Selected color: blue');\n      });\n\n      it('should handle v4 array schemas', async () => {\n        const v4Tool = tool({\n          description: 'Tool with array using v4',\n          parameters: z4.object({\n            tags: z4.array(z4.string()),\n          }),\n          execute: async ({ tags }) => {\n            return `Tags: ${tags.join(', ')}`;\n          },\n        });\n\n        const result = await v4Tool.execute(\n          { tags: ['nodejs', 'typescript', 'testing'] },\n          createToolOptions('test-array'),\n        );\n        expect(result).toBe('Tags: nodejs, typescript, testing');\n      });\n\n      it('should handle v4 nested object schemas', async () => {\n        const v4Tool = tool({\n          description: 'Tool with nested object using v4',\n          parameters: z4.object({\n            user: z4.object({\n              name: z4.string(),\n              email: z4.string(),\n            }),\n          }),\n          execute: async ({ user }) => {\n            return `${user.name} (${user.email})`;\n          },\n        });\n\n        const result = await v4Tool.execute(\n          { user: { name: 'John Doe', email: 'john@example.com' } },\n          createToolOptions('test-nested'),\n        );\n        expect(result).toBe('John Doe (john@example.com)');\n      });\n    });\n\n    describe('oaiParams with v4 schemas', () => {\n      it('should convert v4 basic object schema', () => {\n        const schema = z4.object({\n          name: z4.string().describe('User name'),\n          age: z4.number().describe('User age'),\n        });\n\n        const result = oaiParams(schema);\n\n        expect(result.type).toBe('object');\n        expect(result.properties).toHaveProperty('name');\n        expect(result.properties).toHaveProperty('age');\n        expect(result.required).toContain('name');\n        expect(result.required).toContain('age');\n      });\n\n      it('should handle v4 optional fields', () => {\n        const schema = z4.object({\n          required: z4.string(),\n          optional: z4.string().optional(),\n        });\n\n        const result = oaiParams(schema);\n\n        expect(result.required).toContain('required');\n        expect(result.required).not.toContain('optional');\n      });\n\n      it('should handle v4 enum fields', () => {\n        const schema = z4.object({\n          status: z4.enum(['pending', 'approved', 'rejected']),\n        });\n\n        const result = oaiParams(schema);\n\n        const properties = result.properties as Record<string, Record<string, unknown>>;\n        expect(properties.status?.enum).toEqual(['pending', 'approved', 'rejected']);\n      });\n\n      it('should handle v4 array fields', () => {\n        const schema = z4.object({\n          items: z4.array(z4.string()),\n        });\n\n        const result = oaiParams(schema);\n\n        const properties = result.properties as Record<string, any>;\n        expect(\n          properties.items && typeof properties.items === 'object'\n            ? properties.items.type\n            : undefined,\n        ).toBe('array');\n        expect(\n          properties.items && properties.items.items && typeof properties.items.items === 'object'\n            ? properties.items.items.type\n            : undefined,\n        ).toBe('string');\n      });\n    });\n  });\n});\n"],"mappings":"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","names":[]}

package/dist/llm/tool_context.type.test.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_zod = require("zod");
+var import_index = require("./index.cjs");
+(0, import_vitest.describe)("tool type inference", () => {
+  (0, import_vitest.it)("should infer argument type from zod schema", () => {
+    const toolType = (0, import_index.tool)({
+      description: "test",
+      parameters: import_zod.z.object({ number: import_zod.z.number() }),
+      execute: async () => "test"
+    });
+    (0, import_vitest.expectTypeOf)(toolType).toEqualTypeOf();
+  });
+  (0, import_vitest.it)("should infer provider defined tool type", () => {
+    const toolType = (0, import_index.tool)({
+      id: "code-interpreter",
+      config: {
+        language: "python"
+      }
+    });
+    (0, import_vitest.expectTypeOf)(toolType).toEqualTypeOf();
+  });
+  (0, import_vitest.it)("should infer run context type", () => {
+    const toolType = (0, import_index.tool)({
+      description: "test",
+      parameters: import_zod.z.object({ number: import_zod.z.number() }),
+      execute: async ({ number }, { ctx }) => {
+        return `The number is ${number}, ${ctx.userData.name}`;
+      }
+    });
+    (0, import_vitest.expectTypeOf)(toolType).toEqualTypeOf();
+  });
+  (0, import_vitest.it)("should not accept primitive zod schemas", () => {
+    (0, import_vitest.expect)(() => {
+      (0, import_index.tool)({
+        name: "test",
+        description: "test",
+        parameters: import_zod.z.string(),
+        execute: async () => "test"
+      });
+    }).toThrowError("Tool parameters must be a Zod object schema (z.object(...))");
+  });
+  (0, import_vitest.it)("should not accept array schemas", () => {
+    (0, import_vitest.expect)(() => {
+      (0, import_index.tool)({
+        name: "test",
+        description: "test",
+        parameters: import_zod.z.array(import_zod.z.string()),
+        execute: async () => "test"
+      });
+    }).toThrowError("Tool parameters must be a Zod object schema (z.object(...))");
+  });
+  (0, import_vitest.it)("should not accept union schemas", () => {
+    (0, import_vitest.expect)(() => {
+      (0, import_index.tool)({
+        name: "test",
+        description: "test",
+        parameters: import_zod.z.union([import_zod.z.object({ a: import_zod.z.string() }), import_zod.z.object({ b: import_zod.z.number() })]),
+        execute: async () => "test"
+      });
+    }).toThrowError("Tool parameters must be a Zod object schema (z.object(...))");
+  });
+  (0, import_vitest.it)("should not accept non-Zod values as parameters", () => {
+    (0, import_vitest.expect)(() => {
+      (0, import_index.tool)({
+        name: "test",
+        description: "test",
+        parameters: "invalid schema",
+        execute: async () => "test"
+      });
+    }).toThrowError("Tool parameters must be a Zod object schema or a raw JSON schema");
+  });
+  (0, import_vitest.it)("should infer empty object type when parameters are omitted", () => {
+    const toolType = (0, import_index.tool)({
+      description: "Simple action without parameters",
+      execute: async () => "done"
+    });
+    (0, import_vitest.expectTypeOf)(toolType).toEqualTypeOf();
+  });
+  (0, import_vitest.it)("should infer correct types with context but no parameters", () => {
+    const toolType = (0, import_index.tool)({
+      description: "Action with context",
+      execute: async (args, { ctx }) => {
+        (0, import_vitest.expectTypeOf)(args).toEqualTypeOf();
+        (0, import_vitest.expectTypeOf)(ctx.userData.userId).toEqualTypeOf();
+        return ctx.userData.userId;
+      }
+    });
+    (0, import_vitest.expectTypeOf)(toolType).toEqualTypeOf();
+  });
+});
+//# sourceMappingURL=tool_context.type.test.cjs.map

package/dist/llm/tool_context.type.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/llm/tool_context.type.test.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { describe, expect, expectTypeOf, it } from 'vitest';\nimport { z } from 'zod';\nimport { type FunctionTool, type ProviderDefinedTool, type ToolOptions, tool } from './index.js';\n\ndescribe('tool type inference', () => {\n  it('should infer argument type from zod schema', () => {\n    const toolType = tool({\n      description: 'test',\n      parameters: z.object({ number: z.number() }),\n      execute: async () => 'test' as const,\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<FunctionTool<{ number: number }, unknown, 'test'>>();\n  });\n\n  it('should infer provider defined tool type', () => {\n    const toolType = tool({\n      id: 'code-interpreter',\n      config: {\n        language: 'python',\n      },\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<ProviderDefinedTool>();\n  });\n\n  it('should infer run context type', () => {\n    const toolType = tool({\n      description: 'test',\n      parameters: z.object({ number: z.number() }),\n      execute: async ({ number }, { ctx }: ToolOptions<{ name: string }>) => {\n        return `The number is ${number}, ${ctx.userData.name}`;\n      },\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<\n      FunctionTool<{ number: number }, { name: string }, string>\n    >();\n  });\n\n  it('should not accept primitive zod schemas', () => {\n    expect(() => {\n      // @ts-expect-error - Testing that non-object schemas are rejected\n      tool({\n        name: 'test',\n        description: 'test',\n        parameters: z.string(),\n        execute: async () => 'test' as const,\n      });\n    }).toThrowError('Tool parameters must be a Zod object schema (z.object(...))');\n  });\n\n  it('should not accept array schemas', () => {\n    expect(() => {\n      // @ts-expect-error - Testing that array schemas are rejected\n      tool({\n        name: 'test',\n        description: 'test',\n        parameters: z.array(z.string()),\n        execute: async () => 'test' as const,\n      });\n    }).toThrowError('Tool parameters must be a Zod object schema (z.object(...))');\n  });\n\n  it('should not accept union schemas', () => {\n    expect(() => {\n      // @ts-expect-error - Testing that union schemas are rejected\n      tool({\n        name: 'test',\n        description: 'test',\n        parameters: z.union([z.object({ a: z.string() }), z.object({ b: z.number() })]),\n        execute: async () => 'test' as const,\n      });\n    }).toThrowError('Tool parameters must be a Zod object schema (z.object(...))');\n  });\n\n  it('should not accept non-Zod values as parameters', () => {\n    expect(() => {\n      // @ts-expect-error - Testing that non-Zod values are rejected\n      tool({\n        name: 'test',\n        description: 'test',\n        parameters: 'invalid schema',\n        execute: async () => 'test' as const,\n      });\n    }).toThrowError('Tool parameters must be a Zod object schema or a raw JSON schema');\n  });\n\n  it('should infer empty object type when parameters are omitted', () => {\n    const toolType = tool({\n      description: 'Simple action without parameters',\n      execute: async () => 'done' as const,\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<FunctionTool<Record<string, never>, unknown, 'done'>>();\n  });\n\n  it('should infer correct types with context but no parameters', () => {\n    const toolType = tool({\n      description: 'Action with context',\n      execute: async (args, { ctx }: ToolOptions<{ userId: number }>) => {\n        expectTypeOf(args).toEqualTypeOf<Record<string, never>>();\n        expectTypeOf(ctx.userData.userId).toEqualTypeOf<number>();\n        return ctx.userData.userId;\n      },\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<\n      FunctionTool<Record<string, never>, { userId: number }, number>\n    >();\n  });\n});\n"],"mappings":";AAGA,oBAAmD;AACnD,iBAAkB;AAClB,mBAAoF;AAAA,IAEpF,wBAAS,uBAAuB,MAAM;AACpC,wBAAG,8CAA8C,MAAM;AACrD,UAAM,eAAW,mBAAK;AAAA,MACpB,aAAa;AAAA,MACb,YAAY,aAAE,OAAO,EAAE,QAAQ,aAAE,OAAO,EAAE,CAAC;AAAA,MAC3C,SAAS,YAAY;AAAA,IACvB,CAAC;AAED,oCAAa,QAAQ,EAAE,cAAiE;AAAA,EAC1F,CAAC;AAED,wBAAG,2CAA2C,MAAM;AAClD,UAAM,eAAW,mBAAK;AAAA,MACpB,IAAI;AAAA,MACJ,QAAQ;AAAA,QACN,UAAU;AAAA,MACZ;AAAA,IACF,CAAC;AAED,oCAAa,QAAQ,EAAE,cAAmC;AAAA,EAC5D,CAAC;AAED,wBAAG,iCAAiC,MAAM;AACxC,UAAM,eAAW,mBAAK;AAAA,MACpB,aAAa;AAAA,MACb,YAAY,aAAE,OAAO,EAAE,QAAQ,aAAE,OAAO,EAAE,CAAC;AAAA,MAC3C,SAAS,OAAO,EAAE,OAAO,GAAG,EAAE,IAAI,MAAqC;AACrE,eAAO,iBAAiB,MAAM,KAAK,IAAI,SAAS,IAAI;AAAA,MACtD;AAAA,IACF,CAAC;AAED,oCAAa,QAAQ,EAAE,cAErB;AAAA,EACJ,CAAC;AAED,wBAAG,2CAA2C,MAAM;AAClD,8BAAO,MAAM;AAEX,6BAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,QACb,YAAY,aAAE,OAAO;AAAA,QACrB,SAAS,YAAY;AAAA,MACvB,CAAC;AAAA,IACH,CAAC,EAAE,aAAa,6DAA6D;AAAA,EAC/E,CAAC;AAED,wBAAG,mCAAmC,MAAM;AAC1C,8BAAO,MAAM;AAEX,6BAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,QACb,YAAY,aAAE,MAAM,aAAE,OAAO,CAAC;AAAA,QAC9B,SAAS,YAAY;AAAA,MACvB,CAAC;AAAA,IACH,CAAC,EAAE,aAAa,6DAA6D;AAAA,EAC/E,CAAC;AAED,wBAAG,mCAAmC,MAAM;AAC1C,8BAAO,MAAM;AAEX,6BAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,QACb,YAAY,aAAE,MAAM,CAAC,aAAE,OAAO,EAAE,GAAG,aAAE,OAAO,EAAE,CAAC,GAAG,aAAE,OAAO,EAAE,GAAG,aAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AAAA,QAC9E,SAAS,YAAY;AAAA,MACvB,CAAC;AAAA,IACH,CAAC,EAAE,aAAa,6DAA6D;AAAA,EAC/E,CAAC;AAED,wBAAG,kDAAkD,MAAM;AACzD,8BAAO,MAAM;AAEX,6BAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,SAAS,YAAY;AAAA,MACvB,CAAC;AAAA,IACH,CAAC,EAAE,aAAa,kEAAkE;AAAA,EACpF,CAAC;AAED,wBAAG,8DAA8D,MAAM;AACrE,UAAM,eAAW,mBAAK;AAAA,MACpB,aAAa;AAAA,MACb,SAAS,YAAY;AAAA,IACvB,CAAC;AAED,oCAAa,QAAQ,EAAE,cAAoE;AAAA,EAC7F,CAAC;AAED,wBAAG,6DAA6D,MAAM;AACpE,UAAM,eAAW,mBAAK;AAAA,MACpB,aAAa;AAAA,MACb,SAAS,OAAO,MAAM,EAAE,IAAI,MAAuC;AACjE,wCAAa,IAAI,EAAE,cAAqC;AACxD,wCAAa,IAAI,SAAS,MAAM,EAAE,cAAsB;AACxD,eAAO,IAAI,SAAS;AAAA,MACtB;AAAA,IACF,CAAC;AAED,oCAAa,QAAQ,EAAE,cAErB;AAAA,EACJ,CAAC;AACH,CAAC;","names":[]}

package/dist/llm/tool_context.type.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { z } from "zod";
+import { tool } from "./index.js";
+describe("tool type inference", () => {
+  it("should infer argument type from zod schema", () => {
+    const toolType = tool({
+      description: "test",
+      parameters: z.object({ number: z.number() }),
+      execute: async () => "test"
+    });
+    expectTypeOf(toolType).toEqualTypeOf();
+  });
+  it("should infer provider defined tool type", () => {
+    const toolType = tool({
+      id: "code-interpreter",
+      config: {
+        language: "python"
+      }
+    });
+    expectTypeOf(toolType).toEqualTypeOf();
+  });
+  it("should infer run context type", () => {
+    const toolType = tool({
+      description: "test",
+      parameters: z.object({ number: z.number() }),
+      execute: async ({ number }, { ctx }) => {
+        return `The number is ${number}, ${ctx.userData.name}`;
+      }
+    });
+    expectTypeOf(toolType).toEqualTypeOf();
+  });
+  it("should not accept primitive zod schemas", () => {
+    expect(() => {
+      tool({
+        name: "test",
+        description: "test",
+        parameters: z.string(),
+        execute: async () => "test"
+      });
+    }).toThrowError("Tool parameters must be a Zod object schema (z.object(...))");
+  });
+  it("should not accept array schemas", () => {
+    expect(() => {
+      tool({
+        name: "test",
+        description: "test",
+        parameters: z.array(z.string()),
+        execute: async () => "test"
+      });
+    }).toThrowError("Tool parameters must be a Zod object schema (z.object(...))");
+  });
+  it("should not accept union schemas", () => {
+    expect(() => {
+      tool({
+        name: "test",
+        description: "test",
+        parameters: z.union([z.object({ a: z.string() }), z.object({ b: z.number() })]),
+        execute: async () => "test"
+      });
+    }).toThrowError("Tool parameters must be a Zod object schema (z.object(...))");
+  });
+  it("should not accept non-Zod values as parameters", () => {
+    expect(() => {
+      tool({
+        name: "test",
+        description: "test",
+        parameters: "invalid schema",
+        execute: async () => "test"
+      });
+    }).toThrowError("Tool parameters must be a Zod object schema or a raw JSON schema");
+  });
+  it("should infer empty object type when parameters are omitted", () => {
+    const toolType = tool({
+      description: "Simple action without parameters",
+      execute: async () => "done"
+    });
+    expectTypeOf(toolType).toEqualTypeOf();
+  });
+  it("should infer correct types with context but no parameters", () => {
+    const toolType = tool({
+      description: "Action with context",
+      execute: async (args, { ctx }) => {
+        expectTypeOf(args).toEqualTypeOf();
+        expectTypeOf(ctx.userData.userId).toEqualTypeOf();
+        return ctx.userData.userId;
+      }
+    });
+    expectTypeOf(toolType).toEqualTypeOf();
+  });
+});
+//# sourceMappingURL=tool_context.type.test.js.map

package/dist/llm/tool_context.type.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/llm/tool_context.type.test.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { describe, expect, expectTypeOf, it } from 'vitest';\nimport { z } from 'zod';\nimport { type FunctionTool, type ProviderDefinedTool, type ToolOptions, tool } from './index.js';\n\ndescribe('tool type inference', () => {\n  it('should infer argument type from zod schema', () => {\n    const toolType = tool({\n      description: 'test',\n      parameters: z.object({ number: z.number() }),\n      execute: async () => 'test' as const,\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<FunctionTool<{ number: number }, unknown, 'test'>>();\n  });\n\n  it('should infer provider defined tool type', () => {\n    const toolType = tool({\n      id: 'code-interpreter',\n      config: {\n        language: 'python',\n      },\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<ProviderDefinedTool>();\n  });\n\n  it('should infer run context type', () => {\n    const toolType = tool({\n      description: 'test',\n      parameters: z.object({ number: z.number() }),\n      execute: async ({ number }, { ctx }: ToolOptions<{ name: string }>) => {\n        return `The number is ${number}, ${ctx.userData.name}`;\n      },\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<\n      FunctionTool<{ number: number }, { name: string }, string>\n    >();\n  });\n\n  it('should not accept primitive zod schemas', () => {\n    expect(() => {\n      // @ts-expect-error - Testing that non-object schemas are rejected\n      tool({\n        name: 'test',\n        description: 'test',\n        parameters: z.string(),\n        execute: async () => 'test' as const,\n      });\n    }).toThrowError('Tool parameters must be a Zod object schema (z.object(...))');\n  });\n\n  it('should not accept array schemas', () => {\n    expect(() => {\n      // @ts-expect-error - Testing that array schemas are rejected\n      tool({\n        name: 'test',\n        description: 'test',\n        parameters: z.array(z.string()),\n        execute: async () => 'test' as const,\n      });\n    }).toThrowError('Tool parameters must be a Zod object schema (z.object(...))');\n  });\n\n  it('should not accept union schemas', () => {\n    expect(() => {\n      // @ts-expect-error - Testing that union schemas are rejected\n      tool({\n        name: 'test',\n        description: 'test',\n        parameters: z.union([z.object({ a: z.string() }), z.object({ b: z.number() })]),\n        execute: async () => 'test' as const,\n      });\n    }).toThrowError('Tool parameters must be a Zod object schema (z.object(...))');\n  });\n\n  it('should not accept non-Zod values as parameters', () => {\n    expect(() => {\n      // @ts-expect-error - Testing that non-Zod values are rejected\n      tool({\n        name: 'test',\n        description: 'test',\n        parameters: 'invalid schema',\n        execute: async () => 'test' as const,\n      });\n    }).toThrowError('Tool parameters must be a Zod object schema or a raw JSON schema');\n  });\n\n  it('should infer empty object type when parameters are omitted', () => {\n    const toolType = tool({\n      description: 'Simple action without parameters',\n      execute: async () => 'done' as const,\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<FunctionTool<Record<string, never>, unknown, 'done'>>();\n  });\n\n  it('should infer correct types with context but no parameters', () => {\n    const toolType = tool({\n      description: 'Action with context',\n      execute: async (args, { ctx }: ToolOptions<{ userId: number }>) => {\n        expectTypeOf(args).toEqualTypeOf<Record<string, never>>();\n        expectTypeOf(ctx.userData.userId).toEqualTypeOf<number>();\n        return ctx.userData.userId;\n      },\n    });\n\n    expectTypeOf(toolType).toEqualTypeOf<\n      FunctionTool<Record<string, never>, { userId: number }, number>\n    >();\n  });\n});\n"],"mappings":"AAGA,SAAS,UAAU,QAAQ,cAAc,UAAU;AACnD,SAAS,SAAS;AAClB,SAAwE,YAAY;AAEpF,SAAS,uBAAuB,MAAM;AACpC,KAAG,8CAA8C,MAAM;AACrD,UAAM,WAAW,KAAK;AAAA,MACpB,aAAa;AAAA,MACb,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AAAA,MAC3C,SAAS,YAAY;AAAA,IACvB,CAAC;AAED,iBAAa,QAAQ,EAAE,cAAiE;AAAA,EAC1F,CAAC;AAED,KAAG,2CAA2C,MAAM;AAClD,UAAM,WAAW,KAAK;AAAA,MACpB,IAAI;AAAA,MACJ,QAAQ;AAAA,QACN,UAAU;AAAA,MACZ;AAAA,IACF,CAAC;AAED,iBAAa,QAAQ,EAAE,cAAmC;AAAA,EAC5D,CAAC;AAED,KAAG,iCAAiC,MAAM;AACxC,UAAM,WAAW,KAAK;AAAA,MACpB,aAAa;AAAA,MACb,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AAAA,MAC3C,SAAS,OAAO,EAAE,OAAO,GAAG,EAAE,IAAI,MAAqC;AACrE,eAAO,iBAAiB,MAAM,KAAK,IAAI,SAAS,IAAI;AAAA,MACtD;AAAA,IACF,CAAC;AAED,iBAAa,QAAQ,EAAE,cAErB;AAAA,EACJ,CAAC;AAED,KAAG,2CAA2C,MAAM;AAClD,WAAO,MAAM;AAEX,WAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,QACb,YAAY,EAAE,OAAO;AAAA,QACrB,SAAS,YAAY;AAAA,MACvB,CAAC;AAAA,IACH,CAAC,EAAE,aAAa,6DAA6D;AAAA,EAC/E,CAAC;AAED,KAAG,mCAAmC,MAAM;AAC1C,WAAO,MAAM;AAEX,WAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,QACb,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC;AAAA,QAC9B,SAAS,YAAY;AAAA,MACvB,CAAC;AAAA,IACH,CAAC,EAAE,aAAa,6DAA6D;AAAA,EAC/E,CAAC;AAED,KAAG,mCAAmC,MAAM;AAC1C,WAAO,MAAM;AAEX,WAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,QACb,YAAY,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AAAA,QAC9E,SAAS,YAAY;AAAA,MACvB,CAAC;AAAA,IACH,CAAC,EAAE,aAAa,6DAA6D;AAAA,EAC/E,CAAC;AAED,KAAG,kDAAkD,MAAM;AACzD,WAAO,MAAM;AAEX,WAAK;AAAA,QACH,MAAM;AAAA,QACN,aAAa;AAAA,QACb,YAAY;AAAA,QACZ,SAAS,YAAY;AAAA,MACvB,CAAC;AAAA,IACH,CAAC,EAAE,aAAa,kEAAkE;AAAA,EACpF,CAAC;AAED,KAAG,8DAA8D,MAAM;AACrE,UAAM,WAAW,KAAK;AAAA,MACpB,aAAa;AAAA,MACb,SAAS,YAAY;AAAA,IACvB,CAAC;AAED,iBAAa,QAAQ,EAAE,cAAoE;AAAA,EAC7F,CAAC;AAED,KAAG,6DAA6D,MAAM;AACpE,UAAM,WAAW,KAAK;AAAA,MACpB,aAAa;AAAA,MACb,SAAS,OAAO,MAAM,EAAE,IAAI,MAAuC;AACjE,qBAAa,IAAI,EAAE,cAAqC;AACxD,qBAAa,IAAI,SAAS,MAAM,EAAE,cAAsB;AACxD,eAAO,IAAI,SAAS;AAAA,MACtB;AAAA,IACF,CAAC;AAED,iBAAa,QAAQ,EAAE,cAErB;AAAA,EACJ,CAAC;AACH,CAAC;","names":[]}