agency-lang 0.0.80 → 0.0.82

package/dist/lib/backends/agencyGenerator.js

@@ -390,8 +390,10 @@ export class AgencyGenerator extends BaseGenerator {
     }
     processImportNameType(node) {
         switch (node.type) {
-            case "namedImport":
-                return `{ ${node.importedNames.join(", ")} }`;
+            case "namedImport": {
+                const names = node.importedNames.map((name) => node.safeNames?.includes(name) ? `safe ${name}` : name);
+                return `{ ${names.join(", ")} }`;
+            }
             case "namespaceImport":
                 return `* as ${node.importedNames}`;
             case "defaultImport":

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

@@ -24,6 +24,8 @@ export declare class TypeScriptGenerator extends BaseGenerator {
     protected isInsideGraphNode: boolean;
     private parallelThreadVars;
     private loopVars;
+    protected safeFunctions: Record<string, boolean>;
+    protected importedFunctions: Record<string, boolean>;
     constructor(args?: {
         config?: AgencyConfig;
     });
@@ -104,6 +106,15 @@ export declare class TypeScriptGenerator extends BaseGenerator {
     private agencyFileToDefaultImportName;
     protected preprocess(): string;
     protected postprocess(): string;
+    /**
+     * Check if a function name refers to an impure imported function
+     * (imported from TS, not marked safe).
+     */
+    protected isImpureImportedFunction(functionName: string): boolean;
+    /**
+     * Check if an AST node (or its children) contains a call to an impure imported function.
+     */
+    protected containsImpureCall(node: AgencyNode): boolean;
     protected processBodyAsParts(body: AgencyNode[]): string[];
     protected processKeyword(node: Keyword): string;
     protected scopetoString(scope: ScopeType, varName?: string): string;

package/dist/lib/backends/typescriptGenerator.js

@@ -34,6 +34,8 @@ export class TypeScriptGenerator extends BaseGenerator {
     isInsideGraphNode = false;
     parallelThreadVars = {};
     loopVars = [];
+    safeFunctions = {};
+    importedFunctions = {};
     constructor(args = {}) {
         super(args);
     }
@@ -629,6 +631,19 @@ export class TypeScriptGenerator extends BaseGenerator {
         });
     }
     processImportStatement(node) {
+        // Track safe and imported functions from named imports
+        for (const nameType of node.importedNames) {
+            if (nameType.type === "namedImport") {
+                for (const name of nameType.importedNames) {
+                    this.importedFunctions[name] = true;
+                }
+                if (nameType.safeNames) {
+                    for (const safeName of nameType.safeNames) {
+                        this.safeFunctions[safeName] = true;
+                    }
+                }
+            }
+        }
         const importedNames = node.importedNames.map((name) => this.processImportNameType(name));
         return `import ${importedNames.join(", ")} from "${node.modulePath.replace(/\.agency$/, ".js")}";`;
     }
@@ -918,6 +933,30 @@ export class TypeScriptGenerator extends BaseGenerator {
         lines.push("export default graph;");
         return lines.join("\n");
     }
+    /**
+     * Check if a function name refers to an impure imported function
+     * (imported from TS, not marked safe).
+     */
+    isImpureImportedFunction(functionName) {
+        return (!!this.importedFunctions[functionName] &&
+            !this.safeFunctions[functionName]);
+    }
+    /**
+     * Check if an AST node (or its children) contains a call to an impure imported function.
+     */
+    containsImpureCall(node) {
+        if (node.type === "functionCall") {
+            if (this.isImpureImportedFunction(node.functionName)) {
+                return true;
+            }
+        }
+        if (node.type === "assignment" && node.value) {
+            if (this.containsImpureCall(node.value)) {
+                return true;
+            }
+        }
+        return false;
+    }
     /* This generates the body of a node or function separated into multiple parts.
     You can think of a part as roughly corresponding to a single statement
     (although some statements don't need their own parts, such as a newlines or type definitions).
@@ -934,6 +973,10 @@ export class TypeScriptGenerator extends BaseGenerator {
             if (!TYPES_THAT_DONT_TRIGGER_NEW_PART.includes(stmt.type)) {
                 parts.push([]);
             }
+            // Inject __self.__retryable = false before impure imported function calls
+            if (this.containsImpureCall(stmt)) {
+                parts[parts.length - 1].push("__self.__retryable = false;\n");
+            }
             parts[parts.length - 1].push(this.processStatement(stmt));
         }
         const bodyCode = [];

package/dist/lib/parsers/importStatement.js

@@ -7,7 +7,24 @@ const singleQuotedPath = seqC(char("'"), capture(many1Till(char("'")), "path"),
 const quotedPath = map(or(doubleQuotedPath, singleQuotedPath), (res) => res.path);
 export const importNodeStatmentParser = trace("importNodeStatement", seqC(set("type", "importNodeStatement"), str("import"), spaces, or(str("nodes"), str("node")), captureCaptures(parseError("expected a statement of the form `import nodes { x, y } from 'filename.agency'`", spaces, char("{"), optionalSpaces, capture(sepBy1(comma, many1WithJoin(alphanum)), "importedNodes"), optionalSpaces, char("}"), spaces, str("from"), spaces, capture(quotedPath, "agencyFile"), optionalSemicolon, optional(newline)))));
 export const importToolStatmentParser = trace("importToolStatement", seqC(set("type", "importToolStatement"), str("import"), spaces, or(str("tools"), str("tool")), captureCaptures(parseError("expected a statement of the form `import tools { x, y } from 'filename.agency'`", spaces, char("{"), optionalSpaces, capture(sepBy1(comma, many1WithJoin(alphanum)), "importedTools"), optionalSpaces, char("}"), spaces, str("from"), spaces, capture(quotedPath, "agencyFile"), optionalSemicolon, optional(newline)))));
-const namedImportParser = trace("namedImportParser", seqC(char("{"), optionalSpaces, capture(sepBy1(comma, many1WithJoin(alphanum)), "importedNames"), optionalSpaces, char("}"), set("type", "namedImport")));
+const safeNameItem = or(map(seqC(str("safe "), capture(many1WithJoin(alphanum), "name")), (r) => ({
+    name: r.name,
+    isSafe: true,
+})), map(seqC(capture(many1WithJoin(alphanum), "name")), (r) => ({
+    name: r.name,
+    isSafe: false,
+})));
+const namedImportParser = trace("namedImportParser", map(seqC(char("{"), optionalSpaces, capture(sepBy1(comma, safeNameItem), "items"), optionalSpaces, char("}")), (result) => {
+    const importedNames = [];
+    const safeNames = [];
+    for (const item of result.items) {
+        importedNames.push(item.name);
+        if (item.isSafe) {
+            safeNames.push(item.name);
+        }
+    }
+    return { type: "namedImport", importedNames, safeNames };
+}));
 const namespaceImportParser = trace("namespaceImportParser", seqC(many1Till(spaces), spaces, str("as"), spaces, capture(many1WithJoin(alphanum), "importedNames"), set("type", "namespaceImport")));
 const defaultImportParser = trace("defaultImportParser", seqC(capture(many1WithJoin(alphanum), "importedNames"), set("type", "defaultImport")));
 const importNameTypeParser = sepBy(comma, or(namedImportParser, namespaceImportParser, defaultImportParser));

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

@@ -20,7 +20,9 @@ describe("importStatmentParser", () => {
         if (result.success) {
             expect(result.result).toEqual({
                 type: "importStatement",
-                importedNames: [{ type: "namedImport", importedNames: ["foo"] }],
+                importedNames: [
+                    { type: "namedImport", importedNames: ["foo"], safeNames: [] },
+                ],
                 modulePath: "./foo.ts",
             });
         }
@@ -34,7 +36,7 @@ describe("importStatmentParser", () => {
                 type: "importStatement",
                 importedNames: [
                     { type: "defaultImport", importedNames: "foo" },
-                    { type: "namedImport", importedNames: ["bar"] },
+                    { type: "namedImport", importedNames: ["bar"], safeNames: [] },
                 ],
                 modulePath: "./foo.ts",
             });
@@ -85,7 +87,9 @@ describe("importStatmentParser", () => {
         if (result.success) {
             expect(result.result).toEqual({
                 type: "importStatement",
-                importedNames: [{ type: "namedImport", importedNames: ["foo"] }],
+                importedNames: [
+                    { type: "namedImport", importedNames: ["foo"], safeNames: [] },
+                ],
                 modulePath: "./foo.agency",
             });
         }
@@ -105,12 +109,68 @@ describe("importStatmentParser", () => {
             expect(result.result).toEqual({
                 type: "importStatement",
                 importedNames: [
-                    { type: "namedImport", importedNames: ["foo", "bar", "baz"] },
+                    {
+                        type: "namedImport",
+                        importedNames: ["foo", "bar", "baz"],
+                        safeNames: [],
+                    },
                 ],
                 modulePath: "myModule",
             });
         }
     });
+    // Safe imports
+    it('should parse: import { safe foo, bar } from "./tools.js"', () => {
+        const result = importStatmentParser('import { safe foo, bar } from "./tools.js"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [
+                    {
+                        type: "namedImport",
+                        importedNames: ["foo", "bar"],
+                        safeNames: ["foo"],
+                    },
+                ],
+                modulePath: "./tools.js",
+            });
+        }
+    });
+    it('should parse: import { safe foo, safe bar, baz } from "./tools.js"', () => {
+        const result = importStatmentParser('import { safe foo, safe bar, baz } from "./tools.js"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [
+                    {
+                        type: "namedImport",
+                        importedNames: ["foo", "bar", "baz"],
+                        safeNames: ["foo", "bar"],
+                    },
+                ],
+                modulePath: "./tools.js",
+            });
+        }
+    });
+    it('should parse: import { safe foo } from "./tools.js"', () => {
+        const result = importStatmentParser('import { safe foo } from "./tools.js"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [
+                    {
+                        type: "namedImport",
+                        importedNames: ["foo"],
+                        safeNames: ["foo"],
+                    },
+                ],
+                modulePath: "./tools.js",
+            });
+        }
+    });
     // With semicolons
     it('should parse imports with semicolons', () => {
         const result = importStatmentParser('import foo from "./foo.ts";');

package/dist/lib/runtime/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class ToolCallError extends Error {
+    retryable: boolean;
+    originalError: unknown;
+    constructor(error: unknown, opts: {
+        retryable: boolean;
+    });
+}

package/dist/lib/runtime/errors.js

@@ -0,0 +1,12 @@
+export class ToolCallError extends Error {
+    retryable;
+    originalError;
+    constructor(error, opts) {
+        super(error instanceof Error ? error.message : String(error));
+        this.originalError = error;
+        this.retryable = opts.retryable;
+        if (error instanceof Error && error.stack) {
+            this.stack = error.stack;
+        }
+    }
+}

package/dist/lib/runtime/index.d.ts

@@ -13,4 +13,5 @@ export { interrupt, isInterrupt, respondToInterrupt, approveInterrupt, rejectInt
 export { isGenerator, handleStreamingResponse } from "./streaming.js";
 export { runPrompt } from "./prompt.js";
 export type { ToolHandler } from "./prompt.js";
+export { ToolCallError } from "./errors.js";
 export { setupNode, setupFunction, runNode } from "./node.js";

package/dist/lib/runtime/index.js

@@ -9,4 +9,5 @@ export { readSkillTool, readSkillToolParams, printTool, printToolParams, printJS
 export { interrupt, isInterrupt, respondToInterrupt, approveInterrupt, rejectInterrupt, modifyInterrupt, resolveInterrupt, resumeFromState, } from "./interrupts.js";
 export { isGenerator, handleStreamingResponse } from "./streaming.js";
 export { runPrompt } from "./prompt.js";
+export { ToolCallError } from "./errors.js";
 export { setupNode, setupFunction, runNode } from "./node.js";

package/dist/lib/runtime/prompt.d.ts

@@ -25,5 +25,6 @@ export declare function runPrompt(args: {
     stream?: boolean;
     maxToolCallRounds?: number;
     interruptData?: InterruptData;
+    removedTools?: string[];
 }): Promise<any>;
 export {};

package/dist/lib/runtime/prompt.js

@@ -5,6 +5,7 @@ import { updateTokenStats, extractResponse } from "./utils.js";
 import { callHook } from "./hooks.js";
 import { handleStreamingResponse } from "./streaming.js";
 import { ThreadStore } from "./state/threadStore.js";
+import { ToolCallError } from "./errors.js";
 async function _runPrompt({ ctx, messages, tools, prompt, responseFormat, stream, clientConfig, }) {
     const startTime = performance.now();
     const startHookResult = await callHook({
@@ -92,7 +93,7 @@ async function _runPrompt({ ctx, messages, tools, prompt, responseFormat, stream
     }
     return { messages, toolCalls };
 }
-async function executeToolCalls({ toolCalls, toolHandlers, messages, ctx, clientConfig, interruptData, }) {
+async function executeToolCalls({ toolCalls, toolHandlers, messages, ctx, clientConfig, interruptData, removedTools, toolErrorCounts, }) {
     for (const toolCall of toolCalls) {
         const handler = toolHandlers.find((h) => h.name === toolCall.name);
         if (!handler) {
@@ -141,7 +142,35 @@ async function executeToolCalls({ toolCalls, toolHandlers, messages, ctx, client
                 isToolCall: true,
             });
             const toolCallStartTime = performance.now();
-            result = await handler.execute(...params);
+            try {
+                result = await handler.execute(...params);
+            }
+            catch (error) {
+                const retryable = error instanceof ToolCallError ? error.retryable : false;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                toolErrorCounts[handler.name] = (toolErrorCounts[handler.name] || 0) + 1;
+                if (retryable && toolErrorCounts[handler.name] < 5) {
+                    messages.push(smoltalk.toolMessage(`Error: ${errorMessage}. You may retry this tool call with corrected arguments.`, {
+                        tool_call_id: toolCall.id,
+                        name: toolCall.name,
+                    }));
+                }
+                else if (retryable) {
+                    messages.push(smoltalk.toolMessage(`Error: ${errorMessage}. This tool has failed too many times and can no longer be called.`, {
+                        tool_call_id: toolCall.id,
+                        name: toolCall.name,
+                    }));
+                    removedTools.push(handler.name);
+                }
+                else {
+                    messages.push(smoltalk.toolMessage(`Error: ${errorMessage}. This tool failed after performing side effects and cannot be retried.`, {
+                        tool_call_id: toolCall.id,
+                        name: toolCall.name,
+                    }));
+                    removedTools.push(handler.name);
+                }
+                continue;
+            }
             result =
                 result || `${handler.name} ran successfully but did not return a value`;
             const toolCallEndTime = performance.now();
@@ -183,7 +212,9 @@ async function executeToolCalls({ toolCalls, toolHandlers, messages, ctx, client
     return { isInterrupt: false, messages };
 }
 export async function runPrompt(args) {
-    const { ctx, prompt, responseFormat, tools, toolHandlers = [], stream = false, maxToolCallRounds = 10, } = args;
+    const { ctx, prompt, responseFormat, stream = false, maxToolCallRounds = 10, removedTools = [], } = args;
+    let tools = (args.tools || []).filter((t) => !removedTools.includes(t.name));
+    let toolHandlers = (args.toolHandlers || []).filter((h) => !removedTools.includes(h.name));
     const clientConfig = ctx.getSmoltalkConfig(args.clientConfig || {});
     // console.log(color.magenta(JSON.stringify(clientConfig, null, 2)) + "\n");
     /* in order, either:
@@ -228,6 +259,7 @@ export async function runPrompt(args) {
         toolCalls = [args.interruptData.toolCall];
     }
     // Handle tool calls
+    const toolErrorCounts = {};
     let toolCallRound = 0;
     while (toolCalls.length > 0) {
         if (toolCallRound++ >= maxToolCallRounds) {
@@ -240,8 +272,15 @@ export async function runPrompt(args) {
             ctx,
             clientConfig,
             interruptData: args.interruptData,
+            removedTools,
+            toolErrorCounts,
         });
         messages = executeToolCallsResult.messages;
+        // Filter out tools that failed after side effects
+        if (removedTools.length > 0) {
+            tools = tools.filter((t) => !removedTools.includes(t.name));
+            toolHandlers = toolHandlers.filter((h) => !removedTools.includes(h.name));
+        }
         if (executeToolCallsResult.isInterrupt) {
             const { interrupt } = executeToolCallsResult;
             ctx.statelogClient.debug(`Tool call interrupted execution.`, {

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

@@ -1,4 +1,4 @@
-export declare const template = "\nexport async function {{{functionName:string}}}({{{paramList:string}}}__state: InternalFunctionState | undefined = undefined) {\n    const { stack: __stack, step: __step, self: __self, threads: __threads } =\n      setupFunction({ state: __state });\n\n    // __state will be undefined if this function is\n    // being called as a tool by an llm\n    const __ctx = __state?.ctx || __globalCtx;\n    const statelogClient = __ctx.statelogClient;\n    const __graph = __ctx.graph;\n    const __funcStartTime = performance.now();\n    await callHook({ callbacks: __ctx.callbacks, name: \"onFunctionStart\", data: { functionName: \"{{{functionName}}}\", args: {{{argsObject:string}}}, isBuiltin: false } });\n\n    // put all args on the state stack\n    {{{paramAssignments:string}}}\n\n    {{{functionBody}}}\n\n    await callHook({ callbacks: __ctx.callbacks, name: \"onFunctionEnd\", data: { functionName: \"{{{functionName}}}\", timeTaken: performance.now() - __funcStartTime } });\n}\n";
+export declare const template = "\nexport async function {{{functionName:string}}}({{{paramList:string}}}__state: InternalFunctionState | undefined = undefined) {\n    const { stack: __stack, step: __step, self: __self, threads: __threads } =\n      setupFunction({ state: __state });\n\n    // __state will be undefined if this function is\n    // being called as a tool by an llm\n    const __ctx = __state?.ctx || __globalCtx;\n    const statelogClient = __ctx.statelogClient;\n    const __graph = __ctx.graph;\n    const __funcStartTime = performance.now();\n    await callHook({ callbacks: __ctx.callbacks, name: \"onFunctionStart\", data: { functionName: \"{{{functionName}}}\", args: {{{argsObject:string}}}, isBuiltin: false } });\n\n    // put all args on the state stack\n    {{{paramAssignments:string}}}\n\n    __self.__retryable = __self.__retryable ?? true;\n\n    try {\n    {{{functionBody}}}\n    } catch (__error) {\n      if (__error instanceof ToolCallError) throw __error;\n      throw new ToolCallError(__error, { retryable: __self.__retryable });\n    }\n\n    await callHook({ callbacks: __ctx.callbacks, name: \"onFunctionEnd\", data: { functionName: \"{{{functionName}}}\", timeTaken: performance.now() - __funcStartTime } });\n}\n";
 export type TemplateType = {
     functionName: string;
     paramList: string;

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

@@ -18,7 +18,14 @@ export async function {{{functionName:string}}}({{{paramList:string}}}__state: I
     // put all args on the state stack
     {{{paramAssignments:string}}}
 
+    __self.__retryable = __self.__retryable ?? true;
+
+    try {
     {{{functionBody}}}
+    } catch (__error) {
+      if (__error instanceof ToolCallError) throw __error;
+      throw new ToolCallError(__error, { retryable: __self.__retryable });
+    }
 
     await callHook({ callbacks: __ctx.callbacks, name: "onFunctionEnd", data: { functionName: "{{{functionName}}}", timeTaken: performance.now() - __funcStartTime } });
 }

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

@@ -1,4 +1,4 @@
-export declare const template = "import { fileURLToPath } from \"url\";\nimport process from \"process\";\nimport { readFileSync, writeFileSync } from \"fs\";\nimport { z } from \"zod\";\nimport { goToNode, color, nanoid, registerProvider, registerTextModel } from \"agency-lang\";\nimport * as smoltalk from \"agency-lang\";\nimport path from \"path\";\nimport type { GraphState, InternalFunctionState, Interrupt } from \"agency-lang/runtime\";\nimport {\n  RuntimeContext, MessageThread, ThreadStore,\n  setupNode, setupFunction, runNode, runPrompt, callHook,\n  interrupt, isInterrupt,\n  respondToInterrupt as _respondToInterrupt,\n  approveInterrupt as _approveInterrupt,\n  rejectInterrupt as _rejectInterrupt,\n  resolveInterrupt as _resolveInterrupt,\n  modifyInterrupt as _modifyInterrupt,\n  resumeFromState as _resumeFromState,\n  deepClone as __deepClone,\n  not, eq, neq, lt, lte, gt, gte, and, or,\n  head, tail, empty,\n  builtinFetch as _builtinFetch,\n  builtinFetchJSON as _builtinFetchJSON,\n  builtinInput as _builtinInput,\n  builtinRead as _builtinReadRaw,\n  builtinWrite as _builtinWriteRaw,\n  builtinReadImage as _builtinReadImageRaw,\n  builtinSleep as _builtinSleep,\n  builtinRound as _builtinRound,\n  printJSON as _printJSON,\n  print as _print,\n  readSkill as _readSkillRaw,\n  readSkillTool as __readSkillTool,\n  readSkillToolParams as __readSkillToolParams,\n  printTool as __printTool,\n  printToolParams as __printToolParams,\n  printJSONTool as __printJSONTool,\n  printJSONToolParams as __printJSONToolParams,\n  inputTool as __inputTool,\n  inputToolParams as __inputToolParams,\n  readTool as __readTool,\n  readToolParams as __readToolParams,\n  readImageTool as __readImageTool,\n  readImageToolParams as __readImageToolParams,\n  writeTool as __writeTool,\n  writeToolParams as __writeToolParams,\n  fetchTool as __fetchTool,\n  fetchToolParams as __fetchToolParams,\n  fetchJSONTool as __fetchJSONTool,\n  fetchJSONToolParams as __fetchJSONToolParams,\n  fetchJsonTool as __fetchJsonTool,\n  fetchJsonToolParams as __fetchJsonToolParams,\n  sleepTool as __sleepTool,\n  sleepToolParams as __sleepToolParams,\n  roundTool as __roundTool,\n  roundToolParams as __roundToolParams,\n} from \"agency-lang/runtime\";\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\nconst __cwd = process.cwd();\n\nconst __globalCtx = new RuntimeContext({\n  statelogConfig: {\n    host: \"{{{logHost:string}}}\",\n    {{#hasApiKey}}\n    apiKey: \"{{{logApiKey?:string}}}\",\n    {{/hasApiKey}}\n    {{^hasApiKey}}\n    apiKey: process.env.STATELOG_API_KEY || \"\",\n    {{/hasApiKey}}\n    projectId: \"{{{logProjectId:string}}}\",\n    debugMode: {{{logDebugMode:boolean}}},\n  },\n  smoltalkDefaults: {\n    {{#hasOpenAiApiKey}}\n    openAiApiKey: \"{{{clientOpenAiApiKey?:string}}}\",\n    {{/hasOpenAiApiKey}}\n    {{^hasOpenAiApiKey}}\n    openAiApiKey: process.env.OPENAI_API_KEY || \"\",\n    {{/hasOpenAiApiKey}}\n    {{#hasGoogleApiKey}}\n    googleApiKey: \"{{{clientGoogleApiKey?:string}}}\",\n    {{/hasGoogleApiKey}}\n    {{^hasGoogleApiKey}}\n    googleApiKey: process.env.GEMINI_API_KEY || \"\",\n    {{/hasGoogleApiKey}}\n    model: \"{{{clientDefaultModel:string}}}\",\n    logLevel: \"{{{clientLogLevel:string}}}\",\n    statelog: { \n      host: \"{{{clientStatelogHost:string}}}\",\n      projectId: \"{{{clientStatelogProjectId:string}}}\",\n      apiKey: process.env.STATELOG_SMOLTALK_API_KEY || \"\",\n      traceId: nanoid()\n    }\n  },\n  dirname: __dirname,\n});\nconst graph = __globalCtx.graph;\n\n// Path-dependent builtin wrappers\nfunction _builtinRead(filename: string): string {\n  return _builtinReadRaw({ filename, dirname: __dirname });\n}\nfunction _builtinWrite(filename: string, content: string): void {\n  _builtinWriteRaw({ filename, content, dirname: __dirname });\n}\nfunction _builtinReadImage(filename: string): string {\n  return _builtinReadImageRaw({ filename, dirname: __dirname });\n}\nexport function readSkill({filepath}: {filepath: string}): string {\n  return _readSkillRaw({ filepath, dirname: __dirname });\n}\n\n// Interrupt re-exports bound to this module's context\nexport { interrupt, isInterrupt };\nexport const respondToInterrupt = (i: Interrupt, r: any, m?: any) => _respondToInterrupt({ ctx: __globalCtx, interrupt: i, interruptResponse: r, metadata: m });\nexport const approveInterrupt = (i: Interrupt, m?: any) => _approveInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });\nexport const rejectInterrupt = (i: Interrupt, m?: any) => _rejectInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });\nexport const modifyInterrupt = (i: Interrupt, a: any, m?: any) => _modifyInterrupt({ ctx: __globalCtx, interrupt: i, newArguments: a, metadata: m });\nexport const resolveInterrupt = (i: Interrupt, v: any, m?: any) => _resolveInterrupt({ ctx: __globalCtx, interrupt: i, value: v, metadata: m });";
+export declare const template = "import { fileURLToPath } from \"url\";\nimport process from \"process\";\nimport { readFileSync, writeFileSync } from \"fs\";\nimport { z } from \"zod\";\nimport { goToNode, color, nanoid, registerProvider, registerTextModel } from \"agency-lang\";\nimport * as smoltalk from \"agency-lang\";\nimport path from \"path\";\nimport type { GraphState, InternalFunctionState, Interrupt } from \"agency-lang/runtime\";\nimport {\n  RuntimeContext, MessageThread, ThreadStore,\n  setupNode, setupFunction, runNode, runPrompt, callHook,\n  interrupt, isInterrupt,\n  respondToInterrupt as _respondToInterrupt,\n  approveInterrupt as _approveInterrupt,\n  rejectInterrupt as _rejectInterrupt,\n  resolveInterrupt as _resolveInterrupt,\n  modifyInterrupt as _modifyInterrupt,\n  resumeFromState as _resumeFromState,\n  ToolCallError,\n  deepClone as __deepClone,\n  not, eq, neq, lt, lte, gt, gte, and, or,\n  head, tail, empty,\n  builtinFetch as _builtinFetch,\n  builtinFetchJSON as _builtinFetchJSON,\n  builtinInput as _builtinInput,\n  builtinRead as _builtinReadRaw,\n  builtinWrite as _builtinWriteRaw,\n  builtinReadImage as _builtinReadImageRaw,\n  builtinSleep as _builtinSleep,\n  builtinRound as _builtinRound,\n  printJSON as _printJSON,\n  print as _print,\n  readSkill as _readSkillRaw,\n  readSkillTool as __readSkillTool,\n  readSkillToolParams as __readSkillToolParams,\n  printTool as __printTool,\n  printToolParams as __printToolParams,\n  printJSONTool as __printJSONTool,\n  printJSONToolParams as __printJSONToolParams,\n  inputTool as __inputTool,\n  inputToolParams as __inputToolParams,\n  readTool as __readTool,\n  readToolParams as __readToolParams,\n  readImageTool as __readImageTool,\n  readImageToolParams as __readImageToolParams,\n  writeTool as __writeTool,\n  writeToolParams as __writeToolParams,\n  fetchTool as __fetchTool,\n  fetchToolParams as __fetchToolParams,\n  fetchJSONTool as __fetchJSONTool,\n  fetchJSONToolParams as __fetchJSONToolParams,\n  fetchJsonTool as __fetchJsonTool,\n  fetchJsonToolParams as __fetchJsonToolParams,\n  sleepTool as __sleepTool,\n  sleepToolParams as __sleepToolParams,\n  roundTool as __roundTool,\n  roundToolParams as __roundToolParams,\n} from \"agency-lang/runtime\";\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\nconst __cwd = process.cwd();\n\nconst __globalCtx = new RuntimeContext({\n  statelogConfig: {\n    host: \"{{{logHost:string}}}\",\n    {{#hasApiKey}}\n    apiKey: \"{{{logApiKey?:string}}}\",\n    {{/hasApiKey}}\n    {{^hasApiKey}}\n    apiKey: process.env.STATELOG_API_KEY || \"\",\n    {{/hasApiKey}}\n    projectId: \"{{{logProjectId:string}}}\",\n    debugMode: {{{logDebugMode:boolean}}},\n  },\n  smoltalkDefaults: {\n    {{#hasOpenAiApiKey}}\n    openAiApiKey: \"{{{clientOpenAiApiKey?:string}}}\",\n    {{/hasOpenAiApiKey}}\n    {{^hasOpenAiApiKey}}\n    openAiApiKey: process.env.OPENAI_API_KEY || \"\",\n    {{/hasOpenAiApiKey}}\n    {{#hasGoogleApiKey}}\n    googleApiKey: \"{{{clientGoogleApiKey?:string}}}\",\n    {{/hasGoogleApiKey}}\n    {{^hasGoogleApiKey}}\n    googleApiKey: process.env.GEMINI_API_KEY || \"\",\n    {{/hasGoogleApiKey}}\n    model: \"{{{clientDefaultModel:string}}}\",\n    logLevel: \"{{{clientLogLevel:string}}}\",\n    statelog: { \n      host: \"{{{clientStatelogHost:string}}}\",\n      projectId: \"{{{clientStatelogProjectId:string}}}\",\n      apiKey: process.env.STATELOG_SMOLTALK_API_KEY || \"\",\n      traceId: nanoid()\n    }\n  },\n  dirname: __dirname,\n});\nconst graph = __globalCtx.graph;\n\n// Path-dependent builtin wrappers\nfunction _builtinRead(filename: string): string {\n  return _builtinReadRaw({ filename, dirname: __dirname });\n}\nfunction _builtinWrite(filename: string, content: string): void {\n  _builtinWriteRaw({ filename, content, dirname: __dirname });\n}\nfunction _builtinReadImage(filename: string): string {\n  return _builtinReadImageRaw({ filename, dirname: __dirname });\n}\nexport function readSkill({filepath}: {filepath: string}): string {\n  return _readSkillRaw({ filepath, dirname: __dirname });\n}\n\n// Interrupt re-exports bound to this module's context\nexport { interrupt, isInterrupt };\nexport const respondToInterrupt = (i: Interrupt, r: any, m?: any) => _respondToInterrupt({ ctx: __globalCtx, interrupt: i, interruptResponse: r, metadata: m });\nexport const approveInterrupt = (i: Interrupt, m?: any) => _approveInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });\nexport const rejectInterrupt = (i: Interrupt, m?: any) => _rejectInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });\nexport const modifyInterrupt = (i: Interrupt, a: any, m?: any) => _modifyInterrupt({ ctx: __globalCtx, interrupt: i, newArguments: a, metadata: m });\nexport const resolveInterrupt = (i: Interrupt, v: any, m?: any) => _resolveInterrupt({ ctx: __globalCtx, interrupt: i, value: v, metadata: m });";
 export type TemplateType = {
     logHost: string;
     hasApiKey: boolean;

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

@@ -20,6 +20,7 @@ import {
   resolveInterrupt as _resolveInterrupt,
   modifyInterrupt as _modifyInterrupt,
   resumeFromState as _resumeFromState,
+  ToolCallError,
   deepClone as __deepClone,
   not, eq, neq, lt, lte, gt, gte, and, or,
   head, tail, empty,

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

@@ -1,4 +1,4 @@
-export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<any> {\n  return runPrompt({\n    ctx: __ctx,\n    prompt: {{{promptCode:string}}},\n    messages: __metadata?.messages || new MessageThread(),\n    {{#hasResponseFormat}}\n    responseFormat: z.object({\n      response: {{{zodSchema:string}}}\n    }),\n    {{/hasResponseFormat}}\n    tools: {{{tools}}},\n    toolHandlers: [{{{toolHandlers:string}}}],\n    clientConfig: {{{clientConfig:string}}},\n    stream: {{{isStreaming:boolean}}},\n    maxToolCallRounds: {{{maxToolCallRounds:number}}},\n    interruptData: __state?.interruptData\n  });\n}\n\n{{#isAsync}}\n__self.{{{variableName:string}}} = _{{{variableName:string}}}({{{funcCallParams:string}}});\n{{/isAsync}}\n\n{{^isAsync}}\n__self.{{{variableName:string}}} = await _{{{variableName:string}}}({{{funcCallParams:string}}});\n\n// return early from node if this is an interrupt\nif (isInterrupt(__self.{{{variableName:string}}})) {\n  {{#nodeContext}}\n  return { messages: __threads, data: __self.{{{variableName:string}}} };\n  {{/nodeContext}}\n   {{^nodeContext}}\n   return  __self.{{{variableName:string}}};\n   {{/nodeContext}}\n}\n{{/isAsync}}";
+export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<any> {\n  __self.__removedTools = __self.__removedTools || [];\n  return runPrompt({\n    ctx: __ctx,\n    prompt: {{{promptCode:string}}},\n    messages: __metadata?.messages || new MessageThread(),\n    {{#hasResponseFormat}}\n    responseFormat: z.object({\n      response: {{{zodSchema:string}}}\n    }),\n    {{/hasResponseFormat}}\n    tools: {{{tools}}},\n    toolHandlers: [{{{toolHandlers:string}}}],\n    clientConfig: {{{clientConfig:string}}},\n    stream: {{{isStreaming:boolean}}},\n    maxToolCallRounds: {{{maxToolCallRounds:number}}},\n    interruptData: __state?.interruptData,\n    removedTools: __self.__removedTools,\n  });\n}\n\n{{#isAsync}}\n__self.{{{variableName:string}}} = _{{{variableName:string}}}({{{funcCallParams:string}}});\n{{/isAsync}}\n\n{{^isAsync}}\n__self.{{{variableName:string}}} = await _{{{variableName:string}}}({{{funcCallParams:string}}});\n\n// return early from node if this is an interrupt\nif (isInterrupt(__self.{{{variableName:string}}})) {\n  {{#nodeContext}}\n  return { messages: __threads, data: __self.{{{variableName:string}}} };\n  {{/nodeContext}}\n   {{^nodeContext}}\n   return  __self.{{{variableName:string}}};\n   {{/nodeContext}}\n}\n{{/isAsync}}";
 export type TemplateType = {
     variableName: string;
     argsStr: string;

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

@@ -4,6 +4,7 @@
 import { apply } from "typestache";
 export const template = `
 async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<any> {
+  __self.__removedTools = __self.__removedTools || [];
   return runPrompt({
     ctx: __ctx,
     prompt: {{{promptCode:string}}},
@@ -18,7 +19,8 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<any> {
     clientConfig: {{{clientConfig:string}}},
     stream: {{{isStreaming:boolean}}},
     maxToolCallRounds: {{{maxToolCallRounds:number}}},
-    interruptData: __state?.interruptData
+    interruptData: __state?.interruptData,
+    removedTools: __self.__removedTools,
   });
 }
 

package/dist/lib/types/importStatement.d.ts

@@ -7,6 +7,7 @@ export type ImportNameType = NamedImport | NamespaceImport | DefaultImport;
 export type NamedImport = {
     type: "namedImport";
     importedNames: string[];
+    safeNames: string[];
 };
 export type NamespaceImport = {
     type: "namespaceImport";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -67,7 +67,7 @@
     "nanoid": "^5.1.6",
     "ora": "^9.3.0",
     "prompts": "^2.4.2",
-    "smoltalk": "^0.0.63",
+    "smoltalk": "^0.0.64",
     "tarsec": "^0.1.8",
     "termcolors": "github:egonSchiele/termcolors",
     "typestache": "^0.4.4",