agency-lang 0.0.14 → 0.0.16

package/dist/lib/parsers/returnStatement.test.js

@@ -0,0 +1,268 @@
+import { describe, it, expect } from "vitest";
+import { returnStatementParser } from "./returnStatement.js";
+describe("returnStatementParser", () => {
+    const testCases = [
+        // Happy path - returning literals
+        {
+            input: "return 42",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "42" },
+                },
+            },
+        },
+        {
+            input: 'return "hello"',
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "string", value: "hello" },
+                },
+            },
+        },
+        {
+            input: "return `say hello`",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "prompt",
+                        segments: [{ type: "text", value: "say hello" }],
+                    },
+                },
+            },
+        },
+        {
+            input: "return myVar",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "variableName", value: "myVar" },
+                },
+            },
+        },
+        // With optional semicolon
+        {
+            input: "return 123;",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "123" },
+                },
+            },
+        },
+        // With optional spaces
+        {
+            input: "return  42  ",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "42" },
+                },
+            },
+        },
+        {
+            input: "return 42",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "42" },
+                },
+            },
+        },
+        // Return function call
+        {
+            input: "return foo()",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "functionCall",
+                        functionName: "foo",
+                        arguments: [],
+                    },
+                },
+            },
+        },
+        {
+            input: "return calculate(1, 2)",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "functionCall",
+                        functionName: "calculate",
+                        arguments: [
+                            { type: "number", value: "1" },
+                            { type: "number", value: "2" },
+                        ],
+                    },
+                },
+            },
+        },
+        // Return access expression
+        {
+            input: "return obj.property",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "accessExpression",
+                        expression: {
+                            type: "dotProperty",
+                            object: { type: "variableName", value: "obj" },
+                            propertyName: "property",
+                        },
+                    },
+                },
+            },
+        },
+        // Return array
+        {
+            input: "return [1, 2, 3]",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyArray",
+                        items: [
+                            { type: "number", value: "1" },
+                            { type: "number", value: "2" },
+                            { type: "number", value: "3" },
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            input: "return []",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyArray",
+                        items: [],
+                    },
+                },
+            },
+        },
+        // Return object
+        {
+            input: 'return { key: "value" }',
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyObject",
+                        entries: [
+                            {
+                                key: "key",
+                                value: { type: "string", value: "value" },
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            input: "return {}",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyObject",
+                        entries: [],
+                    },
+                },
+            },
+        },
+        {
+            input: 'return { x: 1, y: 2 }',
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyObject",
+                        entries: [
+                            { key: "x", value: { type: "number", value: "1" } },
+                            { key: "y", value: { type: "number", value: "2" } },
+                        ],
+                    },
+                },
+            },
+        },
+        // Negative numbers
+        {
+            input: "return -100",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "-100" },
+                },
+            },
+        },
+        // Decimal numbers
+        {
+            input: "return 3.14159",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "3.14159" },
+                },
+            },
+        },
+        // With semicolon and spaces
+        {
+            input: "return  someValue  ;",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "variableName", value: "someValue" },
+                },
+            },
+        },
+        // Failure cases
+        { input: "return", expected: { success: false } },
+        { input: "return;", expected: { success: false } },
+        { input: "return ", expected: { success: false } },
+        { input: "retur 5", expected: { success: false } },
+        { input: "", expected: { success: false } },
+        { input: "42", expected: { success: false } },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        if (expected.success) {
+            it(`should parse "${input}" successfully`, () => {
+                const result = returnStatementParser(input);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.result).toEqual(expected.result);
+                }
+            });
+        }
+        else {
+            it(`should fail to parse "${input}"`, () => {
+                const result = returnStatementParser(input);
+                expect(result.success).toBe(false);
+            });
+        }
+    });
+});

package/dist/lib/parsers/specialVar.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/parsers/specialVar.test.js

@@ -0,0 +1,219 @@
+import { describe, it, expect } from "vitest";
+import { specialVarParser } from "./specialVar.js";
+describe("specialVar parsers", () => {
+    describe("specialVarParser", () => {
+        const testCases = [
+            // Happy path - assigning literals to special vars
+            {
+                input: '@model = "gpt-4"',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "string", value: "gpt-4" },
+                    },
+                },
+            },
+            {
+                input: "@model = 42",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "number", value: "42" },
+                    },
+                },
+            },
+            {
+                input: "@model = `the best model`",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "prompt",
+                            segments: [{ type: "text", value: "the best model" }],
+                        },
+                    },
+                },
+            },
+            {
+                input: "@model = myVariable",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "variableName", value: "myVariable" },
+                    },
+                },
+            },
+            // With optional semicolon
+            {
+                input: '@model = "gpt-4";',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "string", value: "gpt-4" },
+                    },
+                },
+            },
+            {
+                input: '@model="gpt-4"',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "string", value: "gpt-4" },
+                    },
+                },
+            },
+            // Assigning arrays to special vars
+            {
+                input: "@model = []",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyArray",
+                            items: [],
+                        },
+                    },
+                },
+            },
+            {
+                input: '@model = ["gpt-4", "claude"]',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyArray",
+                            items: [
+                                { type: "string", value: "gpt-4" },
+                                { type: "string", value: "claude" },
+                            ],
+                        },
+                    },
+                },
+            },
+            // Assigning objects to special vars
+            {
+                input: "@model = {}",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyObject",
+                            entries: [],
+                        },
+                    },
+                },
+            },
+            {
+                input: '@model = { name: "gpt-4" }',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "name",
+                                    value: { type: "string", value: "gpt-4" },
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+            {
+                input: '@model = { name: "gpt-4", version: 4 }',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "name",
+                                    value: { type: "string", value: "gpt-4" },
+                                },
+                                {
+                                    key: "version",
+                                    value: { type: "number", value: "4" },
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+            // Negative numbers
+            {
+                input: "@model = -100",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "number", value: "-100" },
+                    },
+                },
+            },
+            // Decimal numbers
+            {
+                input: "@model = 3.14",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "number", value: "3.14" },
+                    },
+                },
+            },
+            // Failure cases
+            { input: "@model =", expected: { success: false } },
+            { input: '@notSpecial = "value"', expected: { success: false } },
+            { input: 'model = "value"', expected: { success: false } }, // missing @
+            { input: '@Model = "value"', expected: { success: false } }, // wrong case
+            { input: '@ model = "value"', expected: { success: false } }, // space after @
+            { input: "", expected: { success: false } },
+            { input: "@", expected: { success: false } },
+            { input: "@model", expected: { success: false } },
+            { input: '@"model" = "value"', expected: { success: false } },
+        ];
+        testCases.forEach(({ input, expected }) => {
+            if (expected.success) {
+                it(`should parse "${input}" successfully`, () => {
+                    const result = specialVarParser(input);
+                    expect(result.success).toBe(true);
+                    if (result.success) {
+                        expect(result.result).toEqual(expected.result);
+                    }
+                });
+            }
+            else {
+                it(`should fail to parse "${input}"`, () => {
+                    const result = specialVarParser(input);
+                    expect(result.success).toBe(false);
+                });
+            }
+        });
+    });
+});

package/dist/lib/templates/backends/graphGenerator/builtinTools.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "function add({a, b}: {a:number, b:number}):number {\n  return a + b;\n}\n\n// Define the function tool for OpenAI\nconst addTool = {\n    type: \"function\" as const,\n    function: {\n      name: \"add\",\n      description:\n        \"Adds two numbers together and returns the result.\",\n      parameters: {\n        type: \"object\",\n        properties: {\n          a: {\n            type: \"number\",\n            description: \"The first number to add\",\n          },\n          b: {\n            type: \"number\",\n            description: \"The second number to add\",\n          },\n        },\n        required: [\"a\", \"b\"],\n        additionalProperties: false,\n      },\n    },\n  };";
+export declare const template = "function add({a, b}: {a:number, b:number}):number {\n  return a + b;\n}\n\nconst addTool = {\n  name: \"add\",\n  description: \"Adds two numbers together and returns the result.\",\n  schema: z.object({\n    a: z.number().describe(\"The first number to add\"),\n    b: z.number().describe(\"The second number to add\"),\n  }),\n};\n";
 export type TemplateType = {};
 declare const render: (args: TemplateType) => string;
 export default render;

package/dist/lib/templates/backends/graphGenerator/builtinTools.js

@@ -6,30 +6,15 @@ export const template = `function add({a, b}: {a:number, b:number}):number {
   return a + b;
 }
 
-// Define the function tool for OpenAI
 const addTool = {
-    type: "function" as const,
-    function: {
-      name: "add",
-      description:
-        "Adds two numbers together and returns the result.",
-      parameters: {
-        type: "object",
-        properties: {
-          a: {
-            type: "number",
-            description: "The first number to add",
-          },
-          b: {
-            type: "number",
-            description: "The second number to add",
-          },
-        },
-        required: ["a", "b"],
-        additionalProperties: false,
-      },
-    },
-  };`;
+  name: "add",
+  description: "Adds two numbers together and returns the result.",
+  schema: z.object({
+    a: z.number().describe("The first number to add"),
+    b: z.number().describe("The second number to add"),
+  }),
+};
+`;
 const render = (args) => {
     return apply(template, args);
 };

package/dist/lib/templates/backends/graphGenerator/imports.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "import { z } from \"zod\";\nimport * as readline from \"readline\";\nimport fs from \"fs\";\nimport { PieMachine, goToNode } from \"piemachine\";\nimport { StatelogClient } from \"statelog-client\";\nimport { nanoid } from \"nanoid\";\nimport { assistantMessage, getClient, userMessage } from \"smoltalk\";\n\nconst statelogHost = \"https://statelog.adit.io\";\nconst traceId = nanoid();\nconst statelogConfig = {\n    host: statelogHost,\n    traceId: traceId,\n    apiKey: process.env.STATELOG_API_KEY || \"\",\n    projectId: \"agency-lang\",\n    debugMode: false,\n  };\nconst statelogClient = new StatelogClient(statelogConfig);\nconst __model: ModelName = \"gpt-4o-mini\";\n\n\nconst getClientWithConfig = (config = {}) => {\n  const defaultConfig = {\n    openAiApiKey: process.env.OPENAI_API_KEY || \"\",\n    googleApiKey: process.env.GEMINI_API_KEY || \"\",\n    model: __model,\n    logLevel: \"warn\",\n  };\n\n  return getClient({ ...defaultConfig, ...config });\n};\n\nlet __client = getClientWithConfig();\n\ntype State = {\n  messages: string[];\n  data: any;\n}\n\n// enable debug logging\nconst graphConfig = {\n  debug: {\n    log: true,\n    logData: true,\n  },\n  statelog: statelogConfig,\n};\n\n// Define the names of the nodes in the graph\n// Useful for type safety\nconst __nodes = {{{nodes:string}}} as const;\ntype Node = (typeof __nodes)[number];\n\nconst graph = new PieMachine<State, Node>(__nodes, graphConfig);";
+export declare const template = "import { z } from \"zod\";\nimport * as readline from \"readline\";\nimport fs from \"fs\";\nimport { PieMachine, goToNode } from \"piemachine\";\nimport { StatelogClient } from \"statelog-client\";\nimport { nanoid } from \"nanoid\";\nimport { assistantMessage, getClient, userMessage, toolMessage } from \"smoltalk\";\n\nconst statelogHost = \"https://statelog.adit.io\";\nconst traceId = nanoid();\nconst statelogConfig = {\n    host: statelogHost,\n    traceId: traceId,\n    apiKey: process.env.STATELOG_API_KEY || \"\",\n    projectId: \"agency-lang\",\n    debugMode: false,\n  };\nconst statelogClient = new StatelogClient(statelogConfig);\nconst __model: ModelName = \"gpt-4o-mini\";\n\n\nconst getClientWithConfig = (config = {}) => {\n  const defaultConfig = {\n    openAiApiKey: process.env.OPENAI_API_KEY || \"\",\n    googleApiKey: process.env.GEMINI_API_KEY || \"\",\n    model: __model,\n    logLevel: \"warn\",\n  };\n\n  return getClient({ ...defaultConfig, ...config });\n};\n\nlet __client = getClientWithConfig();\n\ntype State = {\n  messages: string[];\n  data: any;\n}\n\n// enable debug logging\nconst graphConfig = {\n  debug: {\n    log: true,\n    logData: true,\n  },\n  statelog: statelogConfig,\n};\n\n// Define the names of the nodes in the graph\n// Useful for type safety\nconst __nodes = {{{nodes:string}}} as const;\ntype Node = (typeof __nodes)[number];\n\nconst graph = new PieMachine<State, Node>(__nodes, graphConfig);";
 export type TemplateType = {
     nodes: string;
 };

package/dist/lib/templates/backends/graphGenerator/imports.js

@@ -8,7 +8,7 @@ import fs from "fs";
 import { PieMachine, goToNode } from "piemachine";
 import { StatelogClient } from "statelog-client";
 import { nanoid } from "nanoid";
-import { assistantMessage, getClient, userMessage } from "smoltalk";
+import { assistantMessage, getClient, userMessage, toolMessage } from "smoltalk";
 
 const statelogHost = "https://statelog.adit.io";
 const traceId = nanoid();

package/dist/lib/templates/backends/typescriptGenerator/promptFunction.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {\n  const __prompt = {{{promptCode:string}}};\n  const startTime = performance.now();\n  const __messages: Message[] = [userMessage(__prompt)];\n  const __tools = {{{tools}}};\n\n  {{#hasResponseFormat}}\n  // Need to make sure this is always an object\n  const __responseFormat = z.object({\n     response: {{{zodSchema:string}}}\n  });\n  {{/hasResponseFormat}}\n  {{^hasResponseFormat}}\n  const __responseFormat = undefined;\n  {{/hasResponseFormat}}\n\n  let __completion = await __client.text({\n    messages: __messages,\n    tools: __tools,\n    responseFormat: __responseFormat,\n  });\n\n  const endTime = performance.now();\n  statelogClient.promptCompletion({\n    messages: __messages,\n    completion: __completion,\n    model: __client.getModel(),\n    timeTaken: endTime - startTime,\n  });\n\n  if (!__completion.success) {\n    throw new Error(\n      `Error getting response from ${__model}: ${__completion.error}`\n    );\n  }\n\n  let responseMessage = __completion.value;\n\n  // Handle function calls\n  while (responseMessage.toolCalls.length > 0) {\n    // Add assistant's response with tool calls to message history\n    __messages.push(assistantMessage(responseMessage.output));\n    let toolCallStartTime, toolCallEndTime;\n\n    // Process each tool call\n    for (const toolCall of responseMessage.toolCalls) {\n      {{{functionCalls:string}}}\n    }\n  \n    const nextStartTime = performance.now();\n    let __completion = await __client.text({\n      messages: __messages,\n      tools: __tools,\n      responseFormat: __responseFormat,\n    });\n\n    const nextEndTime = performance.now();\n\n    statelogClient.promptCompletion({\n      messages: __messages,\n      completion: __completion,\n      model: __client.getModel(),\n      timeTaken: nextEndTime - nextStartTime,\n    });\n\n    if (!__completion.success) {\n      throw new Error(\n        `Error getting response from ${__model}: ${__completion.error}`\n      );\n    }\n    responseMessage = __completion.value;\n  }\n\n  // Add final assistant response to history\n  __messages.push(assistantMessage(responseMessage.output));\n  {{#hasResponseFormat}}\n  try {\n  const result = JSON.parse(responseMessage.output || \"\");\n  return result.response;\n  } catch (e) {\n    return responseMessage.output;\n    // console.error(\"Error parsing response for variable '{{{variableName:string}}}':\", e);\n    // console.error(\"Full completion response:\", JSON.stringify(__completion, null, 2));\n    // throw e;\n  }\n  {{/hasResponseFormat}}\n\n  {{^hasResponseFormat}}\n  return responseMessage.output;\n  {{/hasResponseFormat}}\n}\n";
+export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {\n  const __prompt = {{{promptCode:string}}};\n  const startTime = performance.now();\n  const __messages: Message[] = [userMessage(__prompt)];\n  const __tools = {{{tools}}};\n\n  {{#hasResponseFormat}}\n  // Need to make sure this is always an object\n  const __responseFormat = z.object({\n     response: {{{zodSchema:string}}}\n  });\n  {{/hasResponseFormat}}\n  {{^hasResponseFormat}}\n  const __responseFormat = undefined;\n  {{/hasResponseFormat}}\n\n  let __completion = await __client.text({\n    messages: __messages,\n    tools: __tools,\n    responseFormat: __responseFormat,\n  });\n\n  const endTime = performance.now();\n  statelogClient.promptCompletion({\n    messages: __messages,\n    completion: __completion,\n    model: __client.getModel(),\n    timeTaken: endTime - startTime,\n  });\n\n  if (!__completion.success) {\n    throw new Error(\n      `Error getting response from ${__model}: ${__completion.error}`\n    );\n  }\n\n  let responseMessage = __completion.value;\n\n  // Handle function calls\n  while (responseMessage.toolCalls.length > 0) {\n    // Add assistant's response with tool calls to message history\n    __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));\n    let toolCallStartTime, toolCallEndTime;\n\n    // Process each tool call\n    for (const toolCall of responseMessage.toolCalls) {\n      {{{functionCalls:string}}}\n    }\n  \n    const nextStartTime = performance.now();\n    let __completion = await __client.text({\n      messages: __messages,\n      tools: __tools,\n      responseFormat: __responseFormat,\n    });\n\n    const nextEndTime = performance.now();\n\n    statelogClient.promptCompletion({\n      messages: __messages,\n      completion: __completion,\n      model: __client.getModel(),\n      timeTaken: nextEndTime - nextStartTime,\n    });\n\n    if (!__completion.success) {\n      throw new Error(\n        `Error getting response from ${__model}: ${__completion.error}`\n      );\n    }\n    responseMessage = __completion.value;\n  }\n\n  // Add final assistant response to history\n  __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));\n  {{#hasResponseFormat}}\n  try {\n  const result = JSON.parse(responseMessage.output || \"\");\n  return result.response;\n  } catch (e) {\n    return responseMessage.output;\n    // console.error(\"Error parsing response for variable '{{{variableName:string}}}':\", e);\n    // console.error(\"Full completion response:\", JSON.stringify(__completion, null, 2));\n    // throw e;\n  }\n  {{/hasResponseFormat}}\n\n  {{^hasResponseFormat}}\n  return responseMessage.output;\n  {{/hasResponseFormat}}\n}\n";
 export type TemplateType = {
     variableName: string;
     argsStr: string;

package/dist/lib/templates/backends/typescriptGenerator/promptFunction.js

@@ -44,7 +44,7 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
   // Handle function calls
   while (responseMessage.toolCalls.length > 0) {
     // Add assistant's response with tool calls to message history
-    __messages.push(assistantMessage(responseMessage.output));
+    __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));
     let toolCallStartTime, toolCallEndTime;
 
     // Process each tool call
@@ -77,7 +77,7 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
   }
 
   // Add final assistant response to history
-  __messages.push(assistantMessage(responseMessage.output));
+  __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));
   {{#hasResponseFormat}}
   try {
   const result = JSON.parse(responseMessage.output || "");

package/dist/lib/templates/backends/typescriptGenerator/tool.d.ts

@@ -1,9 +1,8 @@
-export declare const template = "const {{{name:string}}}Tool: OpenAI.Chat.Completions.ChatCompletionTool = {\n    type: \"function\",\n    function: {\n      name: \"{{{name:string}}}\",\n      description:\n        \"{{{description:string}}}\",\n      parameters: {\n        type: \"object\",\n        properties: {{{properties:string}}},\n        required: [{{{requiredParameters:string}}}],\n        additionalProperties: false,\n      },\n    },\n  };\n";
+export declare const template = "const {{{name:string}}}Tool = {\n  name: \"{{{name:string}}}\",\n  description: \"{{{description:string}}}\",\n  schema: z.object({{{schema:string}}})\n};\n";
 export type TemplateType = {
     name: string;
     description: string;
-    properties: string;
-    requiredParameters: string;
+    schema: string;
 };
 declare const render: (args: TemplateType) => string;
 export default render;

package/dist/lib/templates/backends/typescriptGenerator/tool.js

@@ -2,20 +2,11 @@
 // Source: lib/templates/backends/typescriptGenerator/tool.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `const {{{name:string}}}Tool: OpenAI.Chat.Completions.ChatCompletionTool = {
-    type: "function",
-    function: {
-      name: "{{{name:string}}}",
-      description:
-        "{{{description:string}}}",
-      parameters: {
-        type: "object",
-        properties: {{{properties:string}}},
-        required: [{{{requiredParameters:string}}}],
-        additionalProperties: false,
-      },
-    },
-  };
+export const template = `const {{{name:string}}}Tool = {
+  name: "{{{name:string}}}",
+  description: "{{{description:string}}}",
+  schema: z.object({{{schema:string}}})
+};
 `;
 const render = (args) => {
     return apply(template, args);

package/dist/lib/templates/backends/typescriptGenerator/toolCall.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "if (toolCall.type === \"function\" &&\n  toolCall.function.name === \"{{{name:string}}}\"\n) {\n  const args = JSON.parse(toolCall.function.arguments);\n\n  toolCallStartTime = performance.now();\n  const result = await {{{name}}}(args);\n  toolCallEndTime = performance.now();\n\n  console.log(\"Tool '{{{name:string}}}' called with arguments:\", args);\n  console.log(\"Tool '{{{name:string}}}' returned result:\", result);\n\nstatelogClient.toolCall({\n    toolName: \"{{{name:string}}}\",\n    args,\n    output: result,\n    model: __client.getModel(),\n    timeTaken: toolCallEndTime - toolCallStartTime,\n  });\n\n  // Add function result to messages\n  __messages.push({\n    role: \"tool\",\n    tool_call_id: toolCall.id,\n    content: JSON.stringify(result),\n  });\n}";
+export declare const template = "if (\n  toolCall.name === \"{{{name:string}}}\"\n) {\n  const args = toolCall.arguments;\n\n  toolCallStartTime = performance.now();\n  const result = await {{{name}}}(args);\n  toolCallEndTime = performance.now();\n\n  console.log(\"Tool '{{{name:string}}}' called with arguments:\", args);\n  console.log(\"Tool '{{{name:string}}}' returned result:\", result);\n\nstatelogClient.toolCall({\n    toolName: \"{{{name:string}}}\",\n    args,\n    output: result,\n    model: __client.getModel(),\n    timeTaken: toolCallEndTime - toolCallStartTime,\n  });\n\n  // Add function result to messages\n  __messages.push(toolMessage(result, {\n            tool_call_id: toolCall.id,\n            name: toolCall.name,\n      }));\n}";
 export type TemplateType = {
     name: string;
 };