agency-lang 0.0.102 → 0.0.104

package/dist/lib/agents/agency-agent/agent.agency

@@ -1,6 +1,6 @@
-import tool { addTask, listTasks, markTaskDone } from "./subagents/task.agency"
-import tool { writeToPlan, readPlan } from "./subagents/plan.agency"
-import tool { writeCode, appendCode, readCode } from "./subagents/code.agency"
+import { addTask, listTasks, markTaskDone } from "./subagents/task.agency"
+import { writeToPlan, readPlan } from "./subagents/plan.agency"
+import { writeCode, appendCode, readCode } from "./subagents/code.agency"
 import { syntaxHighlight } from "../../utils/agentUtils.js"
 // todo allow this
 // import { Plan } from "./subagents/plan.agency"
@@ -130,8 +130,7 @@ node plan(mode, existingCode, existingFilename: string | null) {
       type: "start"
     }
     while (nextAction.type != "done") {
-      uses writeToPlan, readPlan, print
-      nextAction: NextAction = llm("${userMsg}", config)
+      nextAction: NextAction = llm("${userMsg}", { ...config, tools: [writeToPlan, readPlan, print] })
       if (nextAction.type == "askUser") {
         userMsg = input("${nextAction.question} ")
       }

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

@@ -4,10 +4,9 @@ import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
 import { GraphNodeDefinition, Visibility } from "../types/graphNode.js";
 import { IfElse } from "../types/ifElse.js";
-import { ImportNameType, ImportNodeStatement, ImportStatement, ImportToolStatement } from "../types/importStatement.js";
+import { ImportNameType, ImportNodeStatement, ImportStatement } from "../types/importStatement.js";
 import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
-import { UsesTool } from "../types/tools.js";
 import { ForLoop } from "../types/forLoop.js";
 import { WhileLoop } from "../types/whileLoop.js";
 import { AgencyConfig } from "../config.js";
@@ -26,7 +25,6 @@ export declare class AgencyGenerator {
     protected functionsUsed: Set<string>;
     protected importStatements: string[];
     protected importedNodes: ImportNodeStatement[];
-    protected importedTools: ImportToolStatement[];
     protected functionDefinitions: Record<string, FunctionDefinition>;
     protected currentScope: Scope[];
     protected program: AgencyProgram | null;
@@ -54,7 +52,6 @@ export declare class AgencyGenerator {
     protected startScope(scope: Scope): void;
     protected endScope(): void;
     protected getCurrentScope(): Scope;
-    protected isImportedTool(functionName: string): boolean;
     protected isAgencyFunction(functionName: string, context: "valueAccess" | "functionArg" | "topLevelStatement"): boolean;
     private indent;
     private increaseIndent;
@@ -88,13 +85,11 @@ export declare class AgencyGenerator {
     protected processImportStatement(node: ImportStatement): string;
     protected processImportNameType(node: ImportNameType): string;
     protected processImportNodeStatement(node: ImportNodeStatement): string;
-    protected processImportToolStatement(node: ImportToolStatement): string;
     protected visibilityToString(vis: Visibility): string;
     protected processGraphNode(node: GraphNodeDefinition): string;
     protected processClassDefinition(node: ClassDefinition): string;
     protected processNewExpression(node: NewExpression): string;
     protected processTool(node: FunctionDefinition): string;
-    protected processUsesTool(node: UsesTool): string;
     protected processNewLine(_node: NewLine): string;
     protected processMessageThread(node: MessageThread): string;
     protected processHandleBlock(node: HandleBlock): string;

package/dist/lib/backends/agencyGenerator.js

@@ -1,4 +1,3 @@
-import { getImportedToolNames, } from "../types/importStatement.js";
 import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
 import { mergeDeep } from "../utils.js";
 import { PRECEDENCE, } from "../types/binop.js";
@@ -11,7 +10,6 @@ export class AgencyGenerator {
     functionsUsed = new Set();
     importStatements = [];
     importedNodes = [];
-    importedTools = [];
     functionDefinitions = {};
     currentScope = [{ type: "global" }];
     program = null;
@@ -41,14 +39,11 @@ export class AgencyGenerator {
                 this.processGraphNodeName(node);
             }
         }
-        // Pass 3: Collect all node and tool imports
+        // Pass 3: Collect all node imports
         for (const node of program.nodes) {
             if (node.type === "importNodeStatement") {
                 this.importedNodes.push(node);
             }
-            else if (node.type === "importToolStatement") {
-                this.importedTools.push(node);
-            }
         }
         // Pass 4: Generate code for tools
         for (const node of program.nodes) {
@@ -152,17 +147,12 @@ export class AgencyGenerator {
                 return this.processAgencyObject(node);
             case "graphNode":
                 return this.processGraphNode(node);
-            case "usesTool":
-                return this.processUsesTool(node);
             case "importStatement":
                 this.importStatements.push(this.processImportStatement(node));
                 return "";
             case "importNodeStatement":
                 this.importStatements.push(this.processImportNodeStatement(node));
                 return "";
-            case "importToolStatement":
-                this.importStatements.push(this.processImportToolStatement(node));
-                return "";
             case "forLoop":
                 return this.processForLoop(node);
             case "whileLoop":
@@ -226,17 +216,11 @@ export class AgencyGenerator {
     getCurrentScope() {
         return this.currentScope[this.currentScope.length - 1];
     }
-    isImportedTool(functionName) {
-        return this.importedTools
-            .flatMap(getImportedToolNames)
-            .includes(functionName);
-    }
     isAgencyFunction(functionName, context) {
         if (context === "valueAccess") {
             return false;
         }
-        return (!!this.functionDefinitions[functionName] ||
-            this.isImportedTool(functionName));
+        return !!this.functionDefinitions[functionName];
     }
     // Indent helpers
     indent(level = this.indentLevel) {
@@ -648,13 +632,6 @@ export class AgencyGenerator {
     processImportNodeStatement(node) {
         return `import node { ${node.importedNodes.join(", ")} } from "${node.agencyFile}"`;
     }
-    processImportToolStatement(node) {
-        const toolNames = node.importedTools.flatMap((n) => n.importedNames.map((name) => {
-            const alias = n.aliases[name];
-            return alias ? `${name} as ${alias}` : name;
-        }));
-        return `import tool { ${toolNames.join(", ")} } from "${node.agencyFile}"`;
-    }
     visibilityToString(vis) {
         switch (vis) {
             case "public":
@@ -748,9 +725,6 @@ export class AgencyGenerator {
     processTool(node) {
         return "";
     }
-    processUsesTool(node) {
-        return this.indentStr(`uses ${node.toolNames.join(", ")}`);
-    }
     processNewLine(_node) {
         return "";
     }

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

@@ -6,6 +6,7 @@ export declare class TypeScriptBuilder {
     private generatedStatements;
     private generatedTypeAliases;
     private importStatements;
+    private toolRegistrations;
     private functionsUsed;
     private currentScope;
     private agencyConfig;
@@ -65,9 +66,17 @@ export declare class TypeScriptBuilder {
     private checkpointOpts;
     private getVisibleTypeAliases;
     private forkBranchSetup;
-    private isImportedTool;
-    private static RUNTIME_STATEFUL_FUNCTIONS;
+    private static TEMPLATE_FUNCTIONS;
+    /**
+     * Returns true if the function should be called via .invoke() (AgencyFunction).
+     * The default is true — everything goes through .invoke() UNLESS it's a known
+     * non-Agency function (TS import, internal __ prefixed helper, or template function).
+     */
     private isAgencyFunction;
+    private _plainTsImportNames;
+    private _agencyImportNames;
+    private isPlainTsImport;
+    private _buildImportNameSets;
     private isGraphNode;
     private isImpureImportedFunction;
     private containsImpureCall;
@@ -98,8 +107,6 @@ export declare class TypeScriptBuilder {
      * 1. Pad omitted optional args (those with defaults) with null
      * 2. Wrap extra args into an array for variadic params
      */
-    private getCalleeParams;
-    private adjustCallArgs;
     private processNode;
     private processKeyword;
     private processTypeAlias;
@@ -139,13 +146,20 @@ export declare class TypeScriptBuilder {
     private processMatchBlockWithSteps;
     private processImportStatement;
     private processImportNodeStatement;
-    private processImportToolStatement;
-    private processUsesTool;
-    private processTool;
-    private buildToolRegistryEntry;
     /**
-     * Generate __toolRegistry mapping function names to their tool definitions and handlers.
-     * The tool() function is defined in imports.mustache and closes over __toolRegistry.
+     * Process a block argument into a wrapped AgencyFunction TsNode.
+     * Shared by generateFunctionCallExpression and buildCallDescriptor.
+     */
+    private processBlockArgument;
+    /**
+     * Build a tool definition TsNode for an Agency function.
+     * Returns ts.id("null") if the function has no parameters (no schema needed for tools).
+     */
+    private buildToolDefinition;
+    /**
+     * Generate __toolRegistry as an empty object. AgencyFunction.create() calls
+     * register local functions into it. Imported and builtin tools are registered
+     * here directly. The reviver is bound at the end.
      */
     private generateToolRegistry;
     /**
@@ -165,6 +179,13 @@ export declare class TypeScriptBuilder {
     private processFunctionCallAsStatement;
     private processFunctionCall;
     private generateFunctionCallExpression;
+    private emitAgencyFunctionCall;
+    private emitDirectFunctionCall;
+    /**
+     * Build a CallType descriptor TsNode for an Agency function call.
+     * Determines whether to emit positional or named call type based on arguments.
+     */
+    private buildCallDescriptor;
     private processForkCall;
     private generateNodeCallExpression;
     private processGraphNode;
@@ -185,7 +206,7 @@ export declare class TypeScriptBuilder {
     private processMessageThread;
     private processBlockPlain;
     private processNodeInGlobalInit;
-    private buildBuiltinHandlerArrow;
+    private buildHandlerArrow;
     private processHandleBlockWithSteps;
     private processWithModifier;
     /** In debugger mode, insert debuggerStatement nodes before each
@@ -211,7 +232,6 @@ export declare class TypeScriptBuilder {
      * Used by pipe to get the receiver for a method call.
      */
     private processValueAccessPartial;
-    private buildPipeStateArgs;
     private processBodyAsParts;
     private generateBuiltins;
     private generateImports;

package/dist/lib/backends/typescriptBuilder.integration.test.js

@@ -94,21 +94,23 @@ describe("TypeScript Builder Integration Tests", () => {
     });
 });
 describe("Named argument validation", () => {
-    it("should throw when skipping a required argument", () => {
+    // Named arg validation is now done at runtime by AgencyFunction.invoke(),
+    // not at compile time. These tests verify the builder compiles successfully.
+    it("should compile when skipping a required argument (validated at runtime)", () => {
         expect(() => generateWithBuilder(`
 def greet(name: string, greeting: string = "Hello") {
   print(name)
 }
 greet(greeting: "Hi")
-`)).toThrow("Missing required argument 'name' in call to 'greet'");
+`)).not.toThrow();
     });
-    it("should throw on unknown named argument", () => {
+    it("should compile with unknown named argument (validated at runtime)", () => {
         expect(() => generateWithBuilder(`
 def foo(a: string) {
   print(a)
 }
 foo(a: "hi", extra: "oops")
-`)).toThrow("Unknown named argument 'extra' in call to 'foo'");
+`)).not.toThrow();
     });
     it("should accept correct named arguments", () => {
         expect(() => generateWithBuilder(`
@@ -126,21 +128,21 @@ def greet(name: string, greeting: string = "Hello") {
 greet(greeting: "Hi", name: "world")
 `)).not.toThrow();
     });
-    it("should throw on positional after named", () => {
+    it("should compile with positional after named (validated at runtime)", () => {
         expect(() => generateWithBuilder(`
 def greet(name: string, greeting: string = "Hello") {
   print(name)
 }
 greet(name: "world", "Hi")
-`)).toThrow("Positional argument cannot follow a named argument");
+`)).not.toThrow();
     });
-    it("should throw on duplicate named argument", () => {
+    it("should compile with duplicate named argument (validated at runtime)", () => {
         expect(() => generateWithBuilder(`
 def greet(name: string, greeting: string = "Hello") {
   print(name)
 }
 greet(name: "world", name: "other")
-`)).toThrow("Duplicate named argument 'name' in call to 'greet'");
+`)).not.toThrow();
     });
     it("should accept named args with block parameters", () => {
         expect(() => generateWithBuilder(`
@@ -203,7 +205,7 @@ ${safeKeyword}def ${funcName}(id: string, shouldSave: boolean, items: string[]):
 }
 `;
         const output = generateWithBuilder(code);
-        const funcMatch = output.match(new RegExp(`async function ${funcName}\\([\\s\\S]*?finally`));
+        const funcMatch = output.match(new RegExp(`async function __${funcName}_impl\\([\\s\\S]*?finally`));
         expect(funcMatch).toBeTruthy();
         if (emitsRetryableFalse) {
             expect(funcMatch[0]).toContain("__retryable = false");