agency-lang 0.0.20 → 0.0.22

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

@@ -66,8 +66,8 @@ describe("matchBlockParserCase", () => {
                 success: true,
                 result: {
                     type: "matchBlockCase",
-                    caseValue: { type: "string", value: "hello" },
-                    body: { type: "string", value: "world" },
+                    caseValue: { type: "string", segments: [{ type: "text", value: "hello" }] },
+                    body: { type: "string", segments: [{ type: "text", value: "world" }] },
                 },
             },
         },
@@ -272,13 +272,13 @@ describe("matchBlockParser", () => {
                     cases: [
                         {
                             type: "matchBlockCase",
-                            caseValue: { type: "string", value: "active" },
-                            body: { type: "string", value: "running" },
+                            caseValue: { type: "string", segments: [{ type: "text", value: "active" }] },
+                            body: { type: "string", segments: [{ type: "text", value: "running" }] },
                         },
                         {
                             type: "matchBlockCase",
-                            caseValue: { type: "string", value: "inactive" },
-                            body: { type: "string", value: "stopped" },
+                            caseValue: { type: "string", segments: [{ type: "text", value: "inactive" }] },
+                            body: { type: "string", segments: [{ type: "text", value: "stopped" }] },
                         },
                     ],
                 },
@@ -300,17 +300,17 @@ describe("matchBlockParser", () => {
                         {
                             type: "matchBlockCase",
                             caseValue: { type: "number", value: "200" },
-                            body: { type: "string", value: "OK" },
+                            body: { type: "string", segments: [{ type: "text", value: "OK" }] },
                         },
                         {
                             type: "matchBlockCase",
                             caseValue: { type: "number", value: "404" },
-                            body: { type: "string", value: "Not Found" },
+                            body: { type: "string", segments: [{ type: "text", value: "Not Found" }] },
                         },
                         {
                             type: "matchBlockCase",
                             caseValue: { type: "number", value: "500" },
-                            body: { type: "string", value: "Error" },
+                            body: { type: "string", segments: [{ type: "text", value: "Error" }] },
                         },
                     ],
                 },
@@ -364,20 +364,20 @@ describe("matchBlockParser", () => {
                     cases: [
                         {
                             type: "matchBlockCase",
-                            caseValue: { type: "string", value: "start" },
+                            caseValue: { type: "string", segments: [{ type: "text", value: "start" }] },
                             body: {
                                 type: "functionCall",
                                 functionName: "print",
-                                arguments: [{ type: "string", value: "Starting" }],
+                                arguments: [{ type: "string", segments: [{ type: "text", value: "Starting" }] }],
                             },
                         },
                         {
                             type: "matchBlockCase",
-                            caseValue: { type: "string", value: "stop" },
+                            caseValue: { type: "string", segments: [{ type: "text", value: "stop" }] },
                             body: {
                                 type: "functionCall",
                                 functionName: "print",
-                                arguments: [{ type: "string", value: "Stopping" }],
+                                arguments: [{ type: "string", segments: [{ type: "text", value: "Stopping" }] }],
                             },
                         },
                     ],
@@ -416,7 +416,7 @@ describe("matchBlockParser", () => {
                         {
                             type: "matchBlockCase",
                             caseValue: { type: "number", value: "42" },
-                            body: { type: "string", value: "found" },
+                            body: { type: "string", segments: [{ type: "text", value: "found" }] },
                         },
                     ],
                 },
@@ -431,11 +431,11 @@ describe("matchBlockParser", () => {
                 success: true,
                 result: {
                     type: "matchBlock",
-                    expression: { type: "string", value: "test" },
+                    expression: { type: "string", segments: [{ type: "text", value: "test" }] },
                     cases: [
                         {
                             type: "matchBlockCase",
-                            caseValue: { type: "string", value: "test" },
+                            caseValue: { type: "string", segments: [{ type: "text", value: "test" }] },
                             body: { type: "number", value: "1" },
                         },
                     ],

package/dist/lib/parsers/newline.d.ts

@@ -0,0 +1,3 @@
+import { NewLine } from "../types.js";
+import { Parser } from "tarsec";
+export declare const newLineParser: Parser<NewLine>;

package/dist/lib/parsers/newline.js

@@ -0,0 +1,2 @@
+import { seqC, set, str } from "tarsec";
+export const newLineParser = seqC(set("type", "newLine"), str("\n"));

package/dist/lib/parsers/parserUtils.d.ts

@@ -1 +1,3 @@
-export declare const optionalSemicolon: import("tarsec").Parser<";" | null>;
+import { Parser } from "tarsec";
+export declare const optionalSemicolon: Parser<";" | null>;
+export declare const oneOfStr: <T extends string>(strs: readonly T[]) => Parser<T>;

package/dist/lib/parsers/parserUtils.js

@@ -1,2 +1,5 @@
-import { char, optional } from "tarsec";
+import { char, optional, or, str } from "tarsec";
 export const optionalSemicolon = optional(char(";"));
+export const oneOfStr = (strs) => {
+    return or(...strs.map((s) => str(s)));
+};

package/dist/lib/parsers/returnStatement.js

@@ -5,4 +5,5 @@ import { optionalSemicolon } from "./parserUtils.js";
 import { optionalSpaces } from "./utils.js";
 import { literalParser } from "./literals.js";
 import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
-export const returnStatementParser = seqC(set("type", "returnStatement"), str("return"), optionalSpaces, capture(or(indexAccessParser, accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value"), optionalSemicolon);
+import { awaitParser } from "./await.js";
+export const returnStatementParser = seqC(set("type", "returnStatement"), str("return"), optionalSpaces, capture(or(awaitParser, indexAccessParser, accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value"), optionalSemicolon);

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

@@ -19,7 +19,7 @@ describe("returnStatementParser", () => {
                 success: true,
                 result: {
                     type: "returnStatement",
-                    value: { type: "string", value: "hello" },
+                    value: { type: "string", segments: [{ type: "text", value: "hello" }] },
                 },
             },
         },
@@ -171,7 +171,7 @@ describe("returnStatementParser", () => {
                         entries: [
                             {
                                 key: "key",
-                                value: { type: "string", value: "value" },
+                                value: { type: "string", segments: [{ type: "text", value: "value" }] },
                             },
                         ],
                     },

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

@@ -11,7 +11,7 @@ describe("specialVar parsers", () => {
                     result: {
                         type: "specialVar",
                         name: "model",
-                        value: { type: "string", value: "gpt-4" },
+                        value: { type: "string", segments: [{ type: "text", value: "gpt-4" }] },
                     },
                 },
             },
@@ -59,7 +59,7 @@ describe("specialVar parsers", () => {
                     result: {
                         type: "specialVar",
                         name: "model",
-                        value: { type: "string", value: "gpt-4" },
+                        value: { type: "string", segments: [{ type: "text", value: "gpt-4" }] },
                     },
                 },
             },
@@ -70,7 +70,7 @@ describe("specialVar parsers", () => {
                     result: {
                         type: "specialVar",
                         name: "model",
-                        value: { type: "string", value: "gpt-4" },
+                        value: { type: "string", segments: [{ type: "text", value: "gpt-4" }] },
                     },
                 },
             },
@@ -99,8 +99,8 @@ describe("specialVar parsers", () => {
                         value: {
                             type: "agencyArray",
                             items: [
-                                { type: "string", value: "gpt-4" },
-                                { type: "string", value: "claude" },
+                                { type: "string", segments: [{ type: "text", value: "gpt-4" }] },
+                                { type: "string", segments: [{ type: "text", value: "claude" }] },
                             ],
                         },
                     },
@@ -133,7 +133,7 @@ describe("specialVar parsers", () => {
                             entries: [
                                 {
                                     key: "name",
-                                    value: { type: "string", value: "gpt-4" },
+                                    value: { type: "string", segments: [{ type: "text", value: "gpt-4" }] },
                                 },
                             ],
                         },
@@ -152,7 +152,7 @@ describe("specialVar parsers", () => {
                             entries: [
                                 {
                                     key: "name",
-                                    value: { type: "string", value: "gpt-4" },
+                                    value: { type: "string", segments: [{ type: "text", value: "gpt-4" }] },
                                 },
                                 {
                                     key: "version",

package/dist/lib/parsers/typeHints.d.ts

@@ -7,7 +7,7 @@ export declare const angleBracketsArrayTypeParser: Parser<ArrayType>;
 export declare const stringLiteralTypeParser: Parser<StringLiteralType>;
 export declare const numberLiteralTypeParser: Parser<NumberLiteralType>;
 export declare const booleanLiteralTypeParser: Parser<BooleanLiteralType>;
-export declare const objectPropertyDelimiter: Parser<"\n" | (string | string[])[]>;
+export declare const objectPropertyDelimiter: Parser<(string | string[])[]>;
 export declare const objectPropertyParser: Parser<ObjectProperty>;
 export declare const objectPropertyDescriptionParser: Parser<{
     description: string;

package/dist/lib/parsers/typeHints.js

@@ -1,10 +1,10 @@
-import { optionalSpaces, varNameChar } from "./utils.js";
+import { optionalSpaces, optionalSpacesOrNewline, varNameChar, } from "./utils.js";
 import { capture, captureCaptures, char, count, digit, many1Till, many1WithJoin, oneOf, or, sepBy, seqC, seqR, set, space, spaces, str, trace, } from "tarsec";
 import { optionalSemicolon } from "./parserUtils.js";
-export const primitiveTypeParser = trace("primitiveTypeParser", seqC(set("type", "primitiveType"), capture(or(str("number"), str("string"), str("boolean"), str("undefined"), str("null")), "value")));
+export const primitiveTypeParser = trace("primitiveTypeParser", seqC(set("type", "primitiveType"), capture(or(str("number"), str("string"), str("boolean"), str("undefined"), str("void"), str("null")), "value")));
 export const typeAliasVariableParser = trace("typeAliasVariableParser", seqC(set("type", "typeAliasVariable"), capture(many1WithJoin(varNameChar), "aliasName")));
 export const arrayTypeParser = (input) => {
-    const parser = trace("arrayTypeParser", seqC(set("type", "arrayType"), capture(or(objectTypeParser, primitiveTypeParser), "elementType"), capture(count(str("[]")), "arrayDepth")));
+    const parser = trace("arrayTypeParser", seqC(set("type", "arrayType"), capture(or(objectTypeParser, primitiveTypeParser, typeAliasVariableParser), "elementType"), capture(count(str("[]")), "arrayDepth")));
     const result = parser(input);
     if (result.success) {
         // Wrap the elementType in ArrayType according to arrayDepth
@@ -23,11 +23,11 @@ export const arrayTypeParser = (input) => {
     }
     return result;
 };
-export const angleBracketsArrayTypeParser = trace("angleBracketsArrayTypeParser", seqC(set("type", "arrayType"), str("array"), char("<"), capture(primitiveTypeParser, "elementType"), char(">")));
+export const angleBracketsArrayTypeParser = trace("angleBracketsArrayTypeParser", seqC(set("type", "arrayType"), str("array"), char("<"), capture(or(primitiveTypeParser, typeAliasVariableParser), "elementType"), char(">")));
 export const stringLiteralTypeParser = trace("stringLiteralTypeParser", seqC(set("type", "stringLiteralType"), char('"'), capture(many1Till(char('"')), "value"), char('"')));
 export const numberLiteralTypeParser = trace("numberLiteralTypeParser", seqC(set("type", "numberLiteralType"), capture(many1WithJoin(or(char("-"), char("."), digit)), "value")));
 export const booleanLiteralTypeParser = trace("booleanLiteralTypeParser", seqC(set("type", "booleanLiteralType"), capture(or(str("true"), str("false")), "value")));
-export const objectPropertyDelimiter = or(char("\n"), seqR(optionalSpaces, oneOf(",;"), optionalSpaces));
+export const objectPropertyDelimiter = seqR(optionalSpaces, oneOf(",;"), optionalSpacesOrNewline);
 export const objectPropertyParser = trace("objectPropertyParser", (input) => {
     const parser = seqC(capture(many1WithJoin(varNameChar), "key"), optionalSpaces, char(":"), optionalSpaces, capture(variableTypeParser, "value"));
     return parser(input);
@@ -35,7 +35,7 @@ export const objectPropertyParser = trace("objectPropertyParser", (input) => {
 export const objectPropertyDescriptionParser = seqC(char("#"), optionalSpaces, capture(many1Till(oneOf(",;\n")), "description"));
 export const objectPropertyWithDescriptionParser = trace("objectPropertyWithDescriptionParser", seqC(captureCaptures(objectPropertyParser), spaces, captureCaptures(objectPropertyDescriptionParser)));
 export const objectTypeParser = trace("objectTypeParser", (input) => {
-    const parser = seqC(set("type", "objectType"), char("{"), optionalSpaces, capture(sepBy(objectPropertyDelimiter, or(objectPropertyWithDescriptionParser, objectPropertyParser)), "properties"), optionalSpaces, char("}"));
+    const parser = seqC(set("type", "objectType"), char("{"), optionalSpacesOrNewline, capture(sepBy(objectPropertyDelimiter, or(objectPropertyWithDescriptionParser, objectPropertyParser)), "properties"), optionalSpacesOrNewline, char("}"));
     return parser(input);
 });
 export const unionItemParser = trace("unionItemParser", or(objectTypeParser, angleBracketsArrayTypeParser, arrayTypeParser, stringLiteralTypeParser, numberLiteralTypeParser, booleanLiteralTypeParser, primitiveTypeParser, typeAliasVariableParser));

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

@@ -123,10 +123,6 @@ describe("arrayTypeParser", () => {
             input: "number",
             expected: { success: false },
         },
-        {
-            input: "invalid[]",
-            expected: { success: false },
-        },
         {
             input: "[]",
             expected: { success: false },
@@ -182,10 +178,6 @@ describe("angleBracketsArrayTypeParser", () => {
                 },
             },
         },
-        {
-            input: "array<invalid>",
-            expected: { success: false },
-        },
         {
             input: "array<>",
             expected: { success: false },

package/dist/lib/parsers/utils.d.ts

@@ -1,4 +1,5 @@
 import { Parser } from "tarsec";
+export declare const optionalSpacesOrNewline: Parser<string[]>;
 export declare const optionalSpaces: Parser<string[]>;
 export declare const backtick: Parser<"`">;
 export declare const comma: Parser<(string[] | ",")[]>;

package/dist/lib/parsers/utils.js

@@ -1,5 +1,6 @@
 import { char, many, oneOf, seqR, space } from "tarsec";
-export const optionalSpaces = many(space);
+export const optionalSpacesOrNewline = many(space);
+export const optionalSpaces = many(oneOf(" \t"));
 export const backtick = char("`");
 export const comma = seqR(optionalSpaces, char(","), optionalSpaces);
 export const varNameChar = oneOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_");

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

@@ -16,6 +16,9 @@ describe("whileLoopParser", () => {
                             variableName: "x",
                             value: { type: "number", value: "1" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -33,6 +36,9 @@ describe("whileLoopParser", () => {
                             variableName: "y",
                             value: { type: "number", value: "2" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -50,6 +56,9 @@ describe("whileLoopParser", () => {
                             variableName: "foo",
                             value: { type: "number", value: "1" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -67,6 +76,9 @@ describe("whileLoopParser", () => {
                             variableName: "x",
                             value: { type: "number", value: "2" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -77,13 +89,16 @@ describe("whileLoopParser", () => {
                 success: true,
                 result: {
                     type: "whileLoop",
-                    condition: { type: "string", value: "running" },
+                    condition: { type: "string", segments: [{ type: "text", value: "running" }] },
                     body: [
                         {
                             type: "assignment",
                             variableName: "x",
                             value: { type: "number", value: "3" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -106,6 +121,9 @@ describe("whileLoopParser", () => {
                             variableName: "x",
                             value: { type: "number", value: "1" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -127,6 +145,9 @@ describe("whileLoopParser", () => {
                             functionName: "process",
                             arguments: [],
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -152,6 +173,9 @@ describe("whileLoopParser", () => {
                             variableName: "x",
                             value: { type: "number", value: "1" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -176,6 +200,9 @@ describe("whileLoopParser", () => {
                             functionName: "tick",
                             arguments: [],
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -206,16 +233,25 @@ describe("whileLoopParser", () => {
                             variableName: "a",
                             value: { type: "number", value: "1" },
                         },
+                        {
+                            type: "newLine",
+                        },
                         {
                             type: "assignment",
                             variableName: "b",
                             value: { type: "number", value: "2" },
                         },
+                        {
+                            type: "newLine",
+                        },
                         {
                             type: "assignment",
                             variableName: "c",
                             value: { type: "number", value: "3" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -234,6 +270,9 @@ describe("whileLoopParser", () => {
                             variableName: "foo",
                             value: { type: "number", value: "1" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -251,6 +290,9 @@ describe("whileLoopParser", () => {
                             variableName: "foo",
                             value: { type: "number", value: "1" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },
@@ -269,6 +311,9 @@ describe("whileLoopParser", () => {
                             variableName: "foo",
                             value: { type: "number", value: "1" },
                         },
+                        {
+                            type: "newLine",
+                        },
                     ],
                 },
             },

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

@@ -1,6 +1,7 @@
-export declare const template = "goToNode(\"{{{nodeName:string}}}\", { messages: state.messages, data: {{{data:string}}} });";
+export declare const template = "goToNode(\"{{{nodeName:string}}}\",\n  {\n    messages: state.messages,\n    {{#hasData}}\n    data: {{{data:string}}}\n    {{/hasData}}\n    {{^hasData}}\n    data: null\n    {{/hasData}}\n  }\n);";
 export type TemplateType = {
     nodeName: string;
+    hasData: boolean;
     data: string;
 };
 declare const render: (args: TemplateType) => string;

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

@@ -2,7 +2,17 @@
 // Source: lib/templates/backends/graphGenerator/goToNode.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `goToNode("{{{nodeName:string}}}", { messages: state.messages, data: {{{data:string}}} });`;
+export const template = `goToNode("{{{nodeName:string}}}",
+  {
+    messages: state.messages,
+    {{#hasData}}
+    data: {{{data:string}}}
+    {{/hasData}}
+    {{^hasData}}
+    data: null
+    {{/hasData}}
+  }
+);`;
 const render = (args) => {
     return apply(template, args);
 };

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

@@ -1,8 +1,8 @@
-export declare const template = "graph.node(\"{{{name}}}\", async (state): Promise<any> => {\n    {{#hasParam}}\n    const {{{paramName}}} = state.data;\n    {{/hasParam}}\n    {{{body}}}\n});\n";
+export declare const template = "graph.node(\"{{{name}}}\", async (state): Promise<any> => {\n    const __messages: Message[] = [];\n    {{#hasParam}}\n    const {{{paramNames}}} = state.data;\n    {{/hasParam}}\n    {{{body}}}\n});\n";
 export type TemplateType = {
     name: string | boolean | number;
     hasParam: boolean;
-    paramName: string | boolean | number;
+    paramNames: string | boolean | number;
     body: string | boolean | number;
 };
 declare const render: (args: TemplateType) => string;

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

@@ -3,8 +3,9 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `graph.node("{{{name}}}", async (state): Promise<any> => {
+    const __messages: Message[] = [];
     {{#hasParam}}
-    const {{{paramName}}} = state.data;
+    const {{{paramNames}}} = state.data;
     {{/hasParam}}
     {{{body}}}
 });

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, 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 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);\n\n// builtins\n\nconst not = (val: any): boolean => !val;\nconst eq = (a: any, b: any): boolean => a === b;\nconst neq = (a: any, b: any): boolean => a !== b;\nconst lt = (a: any, b: any): boolean => a < b;\nconst lte = (a: any, b: any): boolean => a <= b;\nconst gt = (a: any, b: any): boolean => a > b;\nconst gte = (a: any, b: any): boolean => a >= b;\nconst and = (a: any, b: any): boolean => a && b;\nconst or = (a: any, b: any): boolean => a || b;\n";
 export type TemplateType = {
     nodes: string;
 };

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

@@ -55,7 +55,20 @@ const graphConfig = {
 const __nodes = {{{nodes:string}}} as const;
 type Node = (typeof __nodes)[number];
 
-const graph = new PieMachine<State, Node>(__nodes, graphConfig);`;
+const graph = new PieMachine<State, Node>(__nodes, graphConfig);
+
+// builtins
+
+const not = (val: any): boolean => !val;
+const eq = (a: any, b: any): boolean => a === b;
+const neq = (a: any, b: any): boolean => a !== b;
+const lt = (a: any, b: any): boolean => a < b;
+const lte = (a: any, b: any): boolean => a <= b;
+const gt = (a: any, b: any): boolean => a > b;
+const gte = (a: any, b: any): boolean => a >= b;
+const and = (a: any, b: any): boolean => a && b;
+const or = (a: any, b: any): boolean => a || b;
+`;
 const render = (args) => {
     return apply(template, args);
 };

package/dist/lib/templates/backends/typescriptGenerator/builtinFunctions/sleep.d.ts

@@ -0,0 +1,4 @@
+export declare const template = "function _builtinSleep(seconds: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, seconds * 1000);\n  });\n}";
+export type TemplateType = {};
+declare const render: (args: TemplateType) => string;
+export default render;

package/dist/lib/templates/backends/typescriptGenerator/builtinFunctions/sleep.js

@@ -0,0 +1,13 @@
+// THIS FILE WAS AUTO-GENERATED
+// Source: lib/templates/backends/typescriptGenerator/builtinFunctions/sleep.mustache
+// Any manual changes will be lost.
+import { apply } from "typestache";
+export const template = `function _builtinSleep(seconds: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, seconds * 1000);
+  });
+}`;
+const render = (args) => {
+    return apply(template, args);
+};
+export default render;

package/dist/lib/templates/backends/typescriptGenerator/builtinFunctions/time.d.ts

@@ -0,0 +1,7 @@
+export declare const template = "const {{{timingVarName:string}}}_startTime = performance.now();\n{{{bodyCodeStr:string}}}\nconst {{{timingVarName}}}_endTime = performance.now();\nconst {{{timingVarName}}} = {{{timingVarName}}}_endTime - {{{timingVarName}}}_startTime;";
+export type TemplateType = {
+    timingVarName: string;
+    bodyCodeStr: string;
+};
+declare const render: (args: TemplateType) => string;
+export default render;

package/dist/lib/templates/backends/typescriptGenerator/builtinFunctions/time.js

@@ -0,0 +1,12 @@
+// THIS FILE WAS AUTO-GENERATED
+// Source: lib/templates/backends/typescriptGenerator/builtinFunctions/time.mustache
+// Any manual changes will be lost.
+import { apply } from "typestache";
+export const template = `const {{{timingVarName:string}}}_startTime = performance.now();
+{{{bodyCodeStr:string}}}
+const {{{timingVarName}}}_endTime = performance.now();
+const {{{timingVarName}}} = {{{timingVarName}}}_endTime - {{{timingVarName}}}_startTime;`;
+const render = (args) => {
+    return apply(template, args);
+};
+export default render;

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

@@ -1,4 +1,4 @@
-export declare const template = "async function {{{functionName:string}}}({{{args}}}) : Promise<{{{returnType}}}> {\n    {{{functionBody}}}\n}";
+export declare const template = "async function {{{functionName:string}}}({{{args}}}) : Promise<{{{returnType}}}> {\n    const __messages: Message[] = [];\n    {{{functionBody}}}\n}";
 export type TemplateType = {
     functionName: string;
     args: string | boolean | number;

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

@@ -3,6 +3,7 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `async function {{{functionName:string}}}({{{args}}}) : Promise<{{{returnType}}}> {
+    const __messages: Message[] = [];
     {{{functionBody}}}
 }`;
 const render = (args) => {

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, { 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 declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {\n  const __prompt = {{{promptCode:string}}};\n  const startTime = performance.now();\n  __messages.push(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  // not passing tool calls back this time\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 type TemplateType = {
     variableName: string;
     argsStr: string;

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

@@ -6,7 +6,7 @@ export const template = `
 async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {
   const __prompt = {{{promptCode:string}}};
   const startTime = performance.now();
-  const __messages: Message[] = [userMessage(__prompt)];
+  __messages.push(userMessage(__prompt));
   const __tools = {{{tools}}};
 
   {{#hasResponseFormat}}
@@ -77,7 +77,8 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
   }
 
   // Add final assistant response to history
-  __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));
+  // not passing tool calls back this time
+  __messages.push(assistantMessage(responseMessage.output));
   {{#hasResponseFormat}}
   try {
   const result = JSON.parse(responseMessage.output || "");