agency-lang 0.0.104 → 0.0.105

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

@@ -66,16 +66,14 @@ export declare class TypeScriptBuilder {
     private checkpointOpts;
     private getVisibleTypeAliases;
     private forkBranchSetup;
-    private static TEMPLATE_FUNCTIONS;
+    private static DIRECT_CALL_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).
+     * Returns true if a function call should have interrupt-checking boilerplate.
+     * Everything gets interrupt handling UNLESS it's a known non-Agency function.
      */
-    private isAgencyFunction;
+    private shouldHandleInterrupts;
     private _plainTsImportNames;
     private _agencyImportNames;
-    private isPlainTsImport;
     private _buildImportNameSets;
     private isGraphNode;
     private isImpureImportedFunction;
@@ -129,9 +127,11 @@ export declare class TypeScriptBuilder {
      */
     private isKnownClassMethod;
     /**
-     * Build the __state config object for method calls on Agency class instances.
+     * Build the standard state config for __call/__callMethod dispatch.
+     * During global init, only ctx is available; otherwise includes threads
+     * and interruptData.
      */
-    private buildMethodCallConfig;
+    private buildStateConfig;
     /**
      * Collect all fields for a class, walking the inheritance chain.
      * Returns parent fields first, then own fields.
@@ -179,7 +179,7 @@ export declare class TypeScriptBuilder {
     private processFunctionCallAsStatement;
     private processFunctionCall;
     private generateFunctionCallExpression;
-    private emitAgencyFunctionCall;
+    private emitRuntimeDispatchCall;
     private emitDirectFunctionCall;
     /**
      * Build a CallType descriptor TsNode for an Agency function call.

package/dist/lib/backends/typescriptBuilder.js

@@ -201,43 +201,29 @@ export class TypeScriptBuilder {
             ts.assign(branchWithBranchKey, ts.obj({ stack: forked })),
         ];
     }
-    // Plain JS functions defined in the imports template or runtime that are NOT
-    // AgencyFunction instances. Keep this list small — prefer wrapping as AgencyFunction.
-    static TEMPLATE_FUNCTIONS = new Set([
+    // Plain JS functions that bypass __call dispatch and are called directly.
+    // These are NOT AgencyFunction instances.
+    static DIRECT_CALL_FUNCTIONS = new Set([
         "approve", "reject", "propagate",
         "success", "failure",
         "isInterrupt", "isDebugger", "isRejected", "isApproved",
         "isSuccess", "isFailure", "mcp"
     ]);
     /**
-     * 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).
+     * Returns true if a function call should have interrupt-checking boilerplate.
+     * Everything gets interrupt handling UNLESS it's a known non-Agency function.
      */
-    isAgencyFunction(functionName, context) {
-        if (context === "valueAccess") {
-            return false;
-        }
-        // Internal machinery (builder-emitted helpers like __deepClone, __validateType, etc.)
+    shouldHandleInterrupts(functionName) {
         if (functionName.startsWith("__"))
             return false;
-        // Template-defined plain JS functions
-        if (TypeScriptBuilder.TEMPLATE_FUNCTIONS.has(functionName))
+        if (TypeScriptBuilder.DIRECT_CALL_FUNCTIONS.has(functionName))
             return false;
-        // Plain TS imports (not from .agency files)
-        if (this.isPlainTsImport(functionName))
+        if (this.isGraphNode(functionName))
             return false;
-        // Everything else is (or might be) an AgencyFunction
         return true;
     }
     _plainTsImportNames = null;
     _agencyImportNames = null;
-    isPlainTsImport(functionName) {
-        if (!this._plainTsImportNames) {
-            this._buildImportNameSets();
-        }
-        return this._plainTsImportNames.has(functionName);
-    }
     _buildImportNameSets() {
         this._plainTsImportNames = new Set();
         this._agencyImportNames = new Set();
@@ -739,30 +725,19 @@ export class TypeScriptBuilder {
                 }
                 case "methodCall": {
                     const isLastInChain = element === node.chain[node.chain.length - 1];
-                    const callNode = this.generateFunctionCallExpression(element.functionCall, "valueAccess");
-                    // The call node is ts.call(ts.id(name), args) — extract callee name and args
-                    if (callNode.kind === "call" &&
-                        callNode.callee.kind === "identifier") {
-                        const isClassMethod = this.isKnownClassMethod(callNode.callee.name);
-                        const args = isClassMethod
-                            ? [...callNode.arguments, this.buildMethodCallConfig()]
-                            : callNode.arguments;
-                        const propNode = ts.prop(result, callNode.callee.name, { optional: element.optional });
-                        const callExpr = ts.call(propNode, args);
-                        // Parenthesize awaited calls when more chain elements follow,
-                        // so .next() runs on the resolved value, not the Promise.
-                        result = isLastInChain
-                            ? ts.await(callExpr)
-                            : ts.raw(`(${this.str(ts.await(callExpr))})`);
-                    }
-                    else {
-                        // Fallback for complex cases (e.g. await-wrapped)
-                        const dot = element.optional ? "?." : ".";
-                        const awaited = `await ${this.str(result)}${dot}${this.str(callNode)}`;
-                        result = isLastInChain
-                            ? ts.raw(awaited)
-                            : ts.raw(`(${awaited})`);
+                    const fnCall = element.functionCall;
+                    // Build descriptor from the method call's arguments
+                    const descriptor = this.buildCallDescriptor(fnCall);
+                    const configObj = this.buildStateConfig();
+                    const propArg = ts.str(fnCall.functionName);
+                    const callArgs = [result, propArg, descriptor, configObj];
+                    if (element.optional) {
+                        callArgs.push(ts.bool(true));
                     }
+                    const callExpr = ts.call(ts.id("__callMethod"), callArgs);
+                    result = isLastInChain
+                        ? ts.await(callExpr)
+                        : ts.raw(`(${this.str(ts.await(callExpr))})`);
                     break;
                 }
             }
@@ -856,16 +831,22 @@ export class TypeScriptBuilder {
         return false;
     }
     /**
-     * Build the __state config object for method calls on Agency class instances.
+     * Build the standard state config for __call/__callMethod dispatch.
+     * During global init, only ctx is available; otherwise includes threads
+     * and interruptData.
      */
-    buildMethodCallConfig() {
-        return this.insideGlobalInit
-            ? ts.functionCallConfig({ ctx: ts.runtime.ctx })
-            : ts.functionCallConfig({
-                ctx: ts.runtime.ctx,
-                threads: ts.runtime.threads,
-                interruptData: ts.raw("__state?.interruptData"),
-            });
+    buildStateConfig(opts) {
+        if (this.insideGlobalInit) {
+            return ts.functionCallConfig({ ctx: ts.runtime.ctx });
+        }
+        return ts.functionCallConfig({
+            ctx: ts.runtime.ctx,
+            threads: ts.runtime.threads,
+            interruptData: ts.raw("__state?.interruptData"),
+            stateStack: opts?.stateStack,
+            isForked: opts?.isForked,
+            ...opts?.extra,
+        });
     }
     /**
      * Collect all fields for a class, walking the inheritance chain.
@@ -1396,14 +1377,12 @@ export class TypeScriptBuilder {
         }
         const callNode = this.processFunctionCall(node);
         const scope = this.getCurrentScope();
-        if (this.isAgencyFunction(node.functionName, "topLevelStatement") &&
-            !this.isGraphNode(node.functionName) &&
+        if (this.shouldHandleInterrupts(node.functionName) &&
             scope.type !== "global") {
             // Async unassigned calls: register with pending promise store, no interrupt check
             if (node.async) {
-                // For agency functions, fork the stack for per-thread isolation
-                if (this.isAgencyFunction(node.functionName, "topLevelStatement") &&
-                    !this.isGraphNode(node.functionName)) {
+                // Fork the stack for per-thread isolation
+                if (this.shouldHandleInterrupts(node.functionName)) {
                     this._asyncBranchCheckNeeded = true;
                     const branchKey = this._subStepPath.join(".");
                     let statements = ts.statements(this.forkBranchSetup(branchKey));
@@ -1488,49 +1467,40 @@ export class TypeScriptBuilder {
         const functionName = context === "valueAccess"
             ? node.functionName
             : mapFunctionName(node.functionName);
-        const isAgency = this.isAgencyFunction(node.functionName, context);
         const shouldAwait = !node.async && context !== "valueAccess";
-        if (isAgency) {
-            return this.emitAgencyFunctionCall(node, functionName, shouldAwait, options);
-        }
-        else if (node.functionName === "system") {
+        // system() is a builder macro — not a real function call
+        if (node.functionName === "system") {
             const argNodes = node.arguments.map((a) => this.processCallArg(a));
             return $(ts.threads.active())
                 .prop("push")
                 .call([ts.smoltalkSystemMessage(argNodes)])
                 .done();
         }
-        else {
+        // __-prefixed helpers and DIRECT_CALL_FUNCTIONS: emit plain direct call
+        if (functionName.startsWith("__") ||
+            TypeScriptBuilder.DIRECT_CALL_FUNCTIONS.has(node.functionName)) {
             return this.emitDirectFunctionCall(node, functionName, shouldAwait);
         }
+        // Everything else goes through __call runtime dispatch
+        return this.emitRuntimeDispatchCall(node, functionName, shouldAwait, options);
     }
-    emitAgencyFunctionCall(node, functionName, shouldAwait, options) {
+    emitRuntimeDispatchCall(node, functionName, shouldAwait, options) {
         const descriptor = this.buildCallDescriptor(node);
         const locationOpts = node.functionName === "checkpoint" ? {
             moduleId: ts.str(this.moduleId),
             scopeName: ts.str(this.currentScopeName()),
             stepPath: ts.str(this._subStepPath.join(".")),
-        } : {};
-        const configObj = this.insideGlobalInit
-            ? ts.functionCallConfig({
-                ctx: ts.runtime.ctx,
-            })
-            : ts.functionCallConfig({
-                ctx: ts.runtime.ctx,
-                threads: ts.runtime.threads,
-                interruptData: ts.raw("__state?.interruptData"),
-                stateStack: options?.stateStack,
-                isForked: node.async,
-                ...locationOpts,
-            });
+        } : undefined;
+        const configObj = this.buildStateConfig({
+            stateStack: options?.stateStack,
+            isForked: node.async,
+            extra: locationOpts,
+        });
         const callee = node.scope
             ? ts.scopedVar(functionName, node.scope, this.moduleId)
             : ts.id(functionName);
-        const invokeCall = $(callee)
-            .prop("invoke")
-            .call([descriptor, configObj])
-            .done();
-        return shouldAwait ? ts.await(invokeCall) : invokeCall;
+        const callExpr = ts.call(ts.id("__call"), [callee, descriptor, configObj]);
+        return shouldAwait ? ts.await(callExpr) : callExpr;
     }
     emitDirectFunctionCall(node, functionName, shouldAwait) {
         const argNodes = node.arguments.map((a) => this.processCallArg(a));
@@ -1834,9 +1804,8 @@ export class TypeScriptBuilder {
                 this.scopedAssign(node.scope, variableName, this.processNode(value), node.accessChain),
             ];
             if (value.async) {
-                // For agency functions, fork the stack for per-thread isolation
-                if (this.isAgencyFunction(value.functionName, "topLevelStatement") &&
-                    !this.isGraphNode(value.functionName)) {
+                // Fork the stack for per-thread isolation
+                if (this.shouldHandleInterrupts(value.functionName)) {
                     this._asyncBranchCheckNeeded = true;
                     const branchKey = this._subStepPath.join(".");
                     stmts.unshift(...this.forkBranchSetup(branchKey));
@@ -1888,22 +1857,11 @@ export class TypeScriptBuilder {
                     result = ts.index(result, this.processNode(el.index));
                     break;
                 case "methodCall": {
-                    const callNode = this.generateFunctionCallExpression(el.functionCall, "valueAccess");
-                    if (callNode.kind === "call" &&
-                        callNode.callee.kind === "identifier") {
-                        const isClassMethod = this.isKnownClassMethod(callNode.callee.name);
-                        const args = isClassMethod
-                            ? [...callNode.arguments, this.buildMethodCallConfig()]
-                            : callNode.arguments;
-                        const call2 = $(result)
-                            .prop(callNode.callee.name)
-                            .call(args)
-                            .done();
-                        result = isClassMethod ? ts.await(call2) : call2;
-                    }
-                    else {
-                        result = ts.raw(`${this.str(result)}.${this.str(callNode)}`);
-                    }
+                    const fnCall = el.functionCall;
+                    const descriptor = this.buildCallDescriptor(fnCall);
+                    const configObj = this.buildStateConfig();
+                    const callExpr = ts.call(ts.id("__callMethod"), [result, ts.str(fnCall.functionName), descriptor, configObj]);
+                    result = ts.await(callExpr);
                     break;
                 }
             }
@@ -2083,20 +2041,17 @@ export class TypeScriptBuilder {
     }
     buildHandlerArrow(handlerName) {
         const args = handlerName === "propagate" ? [] : [ts.id("__data")];
-        if (TypeScriptBuilder.TEMPLATE_FUNCTIONS.has(handlerName)) {
+        if (TypeScriptBuilder.DIRECT_CALL_FUNCTIONS.has(handlerName)) {
             // Built-in handler (approve/reject/propagate): plain JS function, call directly
             return ts.arrowFn([{ name: "__data", typeAnnotation: "any" }], ts.call(ts.id(handlerName), args), { async: true });
         }
-        // User-defined Agency function handler: use .invoke()
+        // User-defined function handler: use __call
         const descriptor = ts.obj({
             type: ts.str("positional"),
             args: ts.arr(args),
         });
-        const invokeCall = $(ts.id(handlerName))
-            .prop("invoke")
-            .call([descriptor])
-            .done();
-        return ts.arrowFn([{ name: "__data", typeAnnotation: "any" }], ts.await(invokeCall), { async: true });
+        const callExpr = ts.call(ts.id("__call"), [ts.id(handlerName), descriptor, this.buildStateConfig()]);
+        return ts.arrowFn([{ name: "__data", typeAnnotation: "any" }], ts.await(callExpr), { async: true });
     }
     processHandleBlockWithSteps(node) {
         const id = this._subStepPath[this._subStepPath.length - 1];
@@ -2223,78 +2178,49 @@ export class TypeScriptBuilder {
                     if (placeholderCount !== 1) {
                         throw new Error(`Method call on right side of |> must contain exactly one ? placeholder, got ${placeholderCount}`);
                     }
-                    // Build the receiver: base + all chain elements except the last method call
                     const receiver = this.processValueAccessPartial(stage);
-                    const args = methodArgs.map((a) => a.type === "placeholder" ? pipeArg : this.processNode(a));
+                    const argNodes = methodArgs.map((a) => a.type === "placeholder" ? pipeArg : this.processNode(a));
                     const methodName = lastElement.functionCall.functionName;
-                    const callExpr = $(receiver).prop(methodName).call(args).done();
-                    return ts.arrowFn([{ name: "__pipeArg" }], callExpr, {
-                        async: true,
-                    });
+                    const descriptor = ts.obj({ type: ts.str("positional"), args: ts.arr(argNodes) });
+                    const callExpr = ts.call(ts.id("__callMethod"), [receiver, ts.str(methodName), descriptor, this.buildStateConfig()]);
+                    return ts.arrowFn([{ name: "__pipeArg" }], ts.await(callExpr), { async: true });
                 }
             }
-            // No placeholder: treat as a bare method/property reference
+            // No placeholder: bare method/property reference — use __callMethod to preserve `this`
+            const receiver = this.processValueAccessPartial(stage);
+            const lastEl = stage.chain[stage.chain.length - 1];
+            const propName = lastEl.kind === "property" ? lastEl.name
+                : lastEl.kind === "methodCall" ? lastEl.functionCall.functionName
+                    : null;
+            if (propName) {
+                const descriptor = ts.obj({ type: ts.str("positional"), args: ts.arr([pipeArg]) });
+                const callExpr = ts.call(ts.id("__callMethod"), [receiver, ts.str(propName), descriptor, this.buildStateConfig()]);
+                return ts.arrowFn([{ name: "__pipeArg" }], ts.await(callExpr), { async: true });
+            }
+            // Fallback for non-property access (e.g. index): use __call
             const callee = this.processNode(stage);
-            const args = [pipeArg];
-            return ts.arrowFn([{ name: "__pipeArg" }], ts.call(callee, args), {
-                async: true,
-            });
+            const descriptor = ts.obj({ type: ts.str("positional"), args: ts.arr([pipeArg]) });
+            const callExpr = ts.call(ts.id("__call"), [callee, descriptor, this.buildStateConfig()]);
+            return ts.arrowFn([{ name: "__pipeArg" }], ts.await(callExpr), { async: true });
         }
         if (stage.type === "variableName") {
-            const isAgency = this.isAgencyFunction(stage.value, "topLevelStatement");
-            if (isAgency) {
-                // value |> fn → async (__pipeArg) => await fn.invoke({ type: "positional", args: [__pipeArg] }, __state)
-                const callee = this.processNode(stage);
-                const descriptor = ts.obj({
-                    type: ts.str("positional"),
-                    args: ts.arr([pipeArg]),
-                });
-                const stateConfig = ts.functionCallConfig({
-                    ctx: ts.runtime.ctx,
-                    threads: ts.runtime.threads,
-                    interruptData: ts.raw("__state?.interruptData"),
-                });
-                const invokeCall = $(callee).prop("invoke").call([descriptor, stateConfig]).done();
-                return ts.arrowFn([{ name: "__pipeArg" }], ts.await(invokeCall), {
-                    async: true,
-                });
-            }
-            // Non-agency: direct call
             const callee = this.processNode(stage);
-            return ts.arrowFn([{ name: "__pipeArg" }], ts.call(callee, [pipeArg]), {
-                async: true,
-            });
+            const descriptor = ts.obj({ type: ts.str("positional"), args: ts.arr([pipeArg]) });
+            const callExpr = ts.call(ts.id("__call"), [callee, descriptor, this.buildStateConfig()]);
+            return ts.arrowFn([{ name: "__pipeArg" }], ts.await(callExpr), { async: true });
         }
         if (stage.type === "functionCall") {
             const placeholderCount = stage.arguments.filter((a) => a.type === "placeholder").length;
             if (placeholderCount !== 1) {
                 throw new Error(`Function call on right side of |> must contain exactly one ? placeholder, got ${placeholderCount}`);
             }
-            const isAgency = this.isAgencyFunction(stage.functionName, "topLevelStatement");
-            if (isAgency) {
-                // value |> fn(10, ?) → async (__pipeArg) => await fn.invoke({ type: "positional", args: [10, __pipeArg] }, __state)
-                const argNodes = stage.arguments.map((a) => a.type === "placeholder" ? pipeArg : this.processNode(a));
-                const callee = stage.scope
-                    ? ts.scopedVar(mapFunctionName(stage.functionName), stage.scope, this.moduleId)
-                    : ts.raw(mapFunctionName(stage.functionName));
-                const descriptor = ts.obj({
-                    type: ts.str("positional"),
-                    args: ts.arr(argNodes),
-                });
-                const stateConfig = ts.functionCallConfig({
-                    ctx: ts.runtime.ctx,
-                    threads: ts.runtime.threads,
-                    interruptData: ts.raw("__state?.interruptData"),
-                });
-                const invokeCall = $(callee).prop("invoke").call([descriptor, stateConfig]).done();
-                return ts.arrowFn([{ name: "__pipeArg" }], ts.await(invokeCall), {
-                    async: true,
-                });
-            }
-            // Non-agency: direct call
-            const rawArgs = stage.arguments.map((a) => a.type === "placeholder" ? pipeArg : this.processNode(a));
-            const callee = ts.raw(mapFunctionName(stage.functionName));
-            return ts.arrowFn([{ name: "__pipeArg" }], ts.call(callee, rawArgs), { async: true });
+            const argNodes = stage.arguments.map((a) => a.type === "placeholder" ? pipeArg : this.processNode(a));
+            const callee = stage.scope
+                ? ts.scopedVar(mapFunctionName(stage.functionName), stage.scope, this.moduleId)
+                : ts.raw(mapFunctionName(stage.functionName));
+            const descriptor = ts.obj({ type: ts.str("positional"), args: ts.arr(argNodes) });
+            const callExpr = ts.call(ts.id("__call"), [callee, descriptor, this.buildStateConfig()]);
+            return ts.arrowFn([{ name: "__pipeArg" }], ts.await(callExpr), { async: true });
         }
         throw new Error(`Invalid pipe stage type: ${stage.type}`);
     }

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

@@ -0,0 +1,3 @@
+import type { CallType } from "./agencyFunction.js";
+export declare function __call(target: unknown, descriptor: CallType, state?: unknown): Promise<unknown>;
+export declare function __callMethod(obj: unknown, prop: string | number, descriptor: CallType, state?: unknown, optional?: boolean): Promise<unknown>;

package/dist/lib/runtime/call.js

@@ -0,0 +1,30 @@
+import { AgencyFunction } from "./agencyFunction.js";
+export async function __call(target, descriptor, state) {
+    if (AgencyFunction.isAgencyFunction(target)) {
+        return target.invoke(descriptor, state);
+    }
+    if (typeof target !== "function") {
+        throw new Error(`Cannot call non-function value: ${String(target)}`);
+    }
+    if (descriptor.type === "named") {
+        throw new Error(`Named arguments are not supported for non-Agency function '${target.name || "(anonymous)"}'`);
+    }
+    return target(...descriptor.args);
+}
+export async function __callMethod(obj, prop, descriptor, state, optional) {
+    if (optional && (obj === null || obj === undefined)) {
+        return undefined;
+    }
+    const target = obj[prop];
+    if (AgencyFunction.isAgencyFunction(target)) {
+        return target.invoke(descriptor, state);
+    }
+    if (typeof target !== "function") {
+        throw new Error(`Cannot call non-function value at property '${String(prop)}': ${String(target)}`);
+    }
+    if (descriptor.type === "named") {
+        throw new Error(`Named arguments are not supported for non-Agency function '${String(prop)}'`);
+    }
+    // Reuse the single property lookup while preserving `this` binding.
+    return Reflect.apply(target, obj, descriptor.args);
+}

package/dist/lib/runtime/call.test.d.ts

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

package/dist/lib/runtime/call.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { __call, __callMethod } from "./call.js";
+import { AgencyFunction } from "./agencyFunction.js";
+function makeAgencyFn(fn, name = "testFn") {
+    return new AgencyFunction({
+        name,
+        module: "test.agency",
+        fn,
+        params: [{ name: "x", hasDefault: false, defaultValue: undefined, variadic: false }],
+        toolDefinition: null,
+    });
+}
+describe("__call", () => {
+    it("calls AgencyFunction via .invoke() with descriptor and state", async () => {
+        const fn = makeAgencyFn(async (x, state) => ({ x, state }));
+        const result = await __call(fn, { type: "positional", args: [42] }, "myState");
+        expect(result).toEqual({ x: 42, state: "myState" });
+    });
+    it("calls plain TS function by spreading positional args", async () => {
+        const fn = (a, b) => a + b;
+        const result = await __call(fn, { type: "positional", args: [3, 4] });
+        expect(result).toBe(7);
+    });
+    it("throws on named args to a TS function", async () => {
+        const fn = (a) => a;
+        await expect(__call(fn, { type: "named", positionalArgs: [], namedArgs: { a: 1 } })).rejects.toThrow("Named arguments are not supported");
+    });
+    it("throws on non-callable target", async () => {
+        await expect(__call(42, { type: "positional", args: [] })).rejects.toThrow("Cannot call non-function value");
+    });
+});
+describe("__callMethod", () => {
+    it("calls AgencyFunction stored as object property via .invoke()", async () => {
+        const fn = makeAgencyFn(async (x, state) => x * 2);
+        const obj = { myFunc: fn };
+        const result = await __callMethod(obj, "myFunc", { type: "positional", args: [5] });
+        expect(result).toBe(10);
+    });
+    it("calls TS method preserving this binding", async () => {
+        const s = new Set();
+        await __callMethod(s, "add", { type: "positional", args: [42] });
+        expect(s.has(42)).toBe(true);
+    });
+    it("calls AgencyFunction stored in array by index", async () => {
+        const fn = makeAgencyFn(async (x, state) => x + 1);
+        const arr = [fn];
+        const result = await __callMethod(arr, 0, { type: "positional", args: [10] });
+        expect(result).toBe(11);
+    });
+    it("short-circuits to undefined when optional and obj is null", async () => {
+        const result = await __callMethod(null, "foo", { type: "positional", args: [] }, undefined, true);
+        expect(result).toBeUndefined();
+    });
+    it("short-circuits to undefined when optional and obj is undefined", async () => {
+        const result = await __callMethod(undefined, "foo", { type: "positional", args: [] }, undefined, true);
+        expect(result).toBeUndefined();
+    });
+    it("calls normally when optional and obj is non-nullish", async () => {
+        const obj = { greet: (name) => `hi ${name}` };
+        const result = await __callMethod(obj, "greet", { type: "positional", args: ["Bob"] }, undefined, true);
+        expect(result).toBe("hi Bob");
+    });
+    it("throws on named args to a TS method", async () => {
+        const obj = { fn: (a) => a };
+        await expect(__callMethod(obj, "fn", { type: "named", positionalArgs: [], namedArgs: { a: 1 } })).rejects.toThrow("Named arguments are not supported");
+    });
+});

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

@@ -15,6 +15,7 @@ export { deepClone, extractResponse, createReturnObject, updateTokenStats, } fro
 export { functionRefReviver } from "./revivers/index.js";
 export { AgencyFunction, UNSET } from "./agencyFunction.js";
 export type { FuncParam, CallType, ToolDefinition, AgencyFunctionOpts } from "./agencyFunction.js";
+export { __call, __callMethod } from "./call.js";
 export { callHook } from "./hooks.js";
 export type { AgencyCallbacks, CallbackMap, CallbackReturn } from "./hooks.js";
 export { not, eq, neq, lt, lte, gt, gte, and, or, head, tail, empty, builtinRead, builtinSleep, readSkill, } from "./builtins.js";

package/dist/lib/runtime/index.js

@@ -10,6 +10,7 @@ export { FileSink, CallbackSink } from "./trace/sinks.js";
 export { deepClone, extractResponse, createReturnObject, updateTokenStats, } from "./utils.js";
 export { functionRefReviver } from "./revivers/index.js";
 export { AgencyFunction, UNSET } from "./agencyFunction.js";
+export { __call, __callMethod } from "./call.js";
 export { callHook } from "./hooks.js";
 export { not, eq, neq, lt, lte, gt, gte, and, or, head, tail, empty, builtinRead, builtinSleep, readSkill, } from "./builtins.js";
 export { readSkillTool, readSkillToolParams } from "./builtinTools.js";

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 } from \"agency-lang\";\nimport { smoltalk } from \"agency-lang\";\nimport path from \"path\";\nimport type { GraphState, InternalFunctionState, Interrupt, InterruptResponse, RewindCheckpoint } from \"agency-lang/runtime\";\nimport {\n  RuntimeContext, MessageThread, ThreadStore, Runner, McpManager,\n  setupNode, setupFunction, runNode, runPrompt, callHook,\n  checkpoint as __checkpoint_impl, getCheckpoint as __getCheckpoint_impl, restore as __restore_impl,\n  interrupt, isInterrupt, isDebugger, isRejected, isApproved, interruptWithHandlers, debugStep,\n  respondToInterrupt as _respondToInterrupt,\n  approveInterrupt as _approveInterrupt,\n  rejectInterrupt as _rejectInterrupt,\n  resolveInterrupt as _resolveInterrupt,\n  modifyInterrupt as _modifyInterrupt,\n  rewindFrom as _rewindFrom,\n  RestoreSignal,\n  deepClone as __deepClone,\n  not, eq, neq, lt, lte, gt, gte, and, or,\n  head, tail, empty,\n  success, failure, isSuccess, isFailure, __pipeBind, __tryCall, __catchResult,\n  Schema, __validateType,\n  readSkill as _readSkillRaw,\n  readSkillTool as __readSkillTool,\n  readSkillToolParams as __readSkillToolParams,\n  AgencyFunction as __AgencyFunction, UNSET as __UNSET,\n  functionRefReviver as __functionRefReviver,\n} from \"agency-lang/runtime\";\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\nconst __cwd = __process.cwd();\n\nconst getDirname = () => __dirname;\n\n{{{runtimeContextCode:string}}}\n\n// Path-dependent builtin wrappers\nexport function readSkill({filepath}: {filepath: string}): string {\n  return _readSkillRaw({ filepath, dirname: __dirname });\n}\n\n// Handler result builtins\nfunction approve(value?: any) { return { type: \"approved\" as const, value }; }\nfunction reject(value?: any) { return { type: \"rejected\" as const, value }; }\nfunction propagate() { return { type: \"propagated\" as const }; }\n\n// Interrupt and rewind re-exports bound to this module's context\nexport { interrupt, isInterrupt, isDebugger };\nexport const respondToInterrupt = (interrupt: Interrupt, response: InterruptResponse, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _respondToInterrupt({ ctx: __globalCtx, interrupt, interruptResponse: response, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const approveInterrupt = (interrupt: Interrupt, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _approveInterrupt({ ctx: __globalCtx, interrupt, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const rejectInterrupt = (interrupt: Interrupt, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _rejectInterrupt({ ctx: __globalCtx, interrupt, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const modifyInterrupt = (interrupt: Interrupt, newArguments: Record<string, any>, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _modifyInterrupt({ ctx: __globalCtx, interrupt, newArguments, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const resolveInterrupt = (interrupt: Interrupt, value: any, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _resolveInterrupt({ ctx: __globalCtx, interrupt, value, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const rewindFrom = (checkpoint: RewindCheckpoint, overrides: Record<string, unknown>, opts?: { metadata?: Record<string, any> }) => _rewindFrom({ ctx: __globalCtx, checkpoint, overrides, metadata: opts?.metadata });\n\nexport const __setDebugger = (dbg: any) => { __globalCtx.debuggerState = dbg; };\nexport const __setTraceWriter = (tw: any) => { __globalCtx.traceWriter = tw; };\nexport const __getCheckpoints = () => __globalCtx.checkpoints;\n\nconst __toolRegistry: Record<string, any> = {};\n\nfunction __registerTool(value: unknown, name?: string) {\n  if (__AgencyFunction.isAgencyFunction(value)) {\n    __toolRegistry[name ?? value.name] = value;\n  }\n}\n\n// Wrap stateful runtime functions as AgencyFunction instances\nconst checkpoint = __AgencyFunction.create({ name: \"checkpoint\", module: \"__runtime\", fn: __checkpoint_impl, params: [], toolDefinition: null }, __toolRegistry);\nconst getCheckpoint = __AgencyFunction.create({ name: \"getCheckpoint\", module: \"__runtime\", fn: __getCheckpoint_impl, params: [{ name: \"checkpointId\", hasDefault: false, defaultValue: undefined, variadic: false }], toolDefinition: null }, __toolRegistry);\nconst restore = __AgencyFunction.create({ name: \"restore\", module: \"__runtime\", fn: __restore_impl, params: [{ name: \"checkpointIdOrCheckpoint\", hasDefault: false, defaultValue: undefined, variadic: false }, { name: \"options\", hasDefault: false, defaultValue: undefined, variadic: false }], toolDefinition: null }, __toolRegistry);";
+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 } from \"agency-lang\";\nimport { smoltalk } from \"agency-lang\";\nimport path from \"path\";\nimport type { GraphState, InternalFunctionState, Interrupt, InterruptResponse, RewindCheckpoint } from \"agency-lang/runtime\";\nimport {\n  RuntimeContext, MessageThread, ThreadStore, Runner, McpManager,\n  setupNode, setupFunction, runNode, runPrompt, callHook,\n  checkpoint as __checkpoint_impl, getCheckpoint as __getCheckpoint_impl, restore as __restore_impl,\n  interrupt, isInterrupt, isDebugger, isRejected, isApproved, interruptWithHandlers, debugStep,\n  respondToInterrupt as _respondToInterrupt,\n  approveInterrupt as _approveInterrupt,\n  rejectInterrupt as _rejectInterrupt,\n  resolveInterrupt as _resolveInterrupt,\n  modifyInterrupt as _modifyInterrupt,\n  rewindFrom as _rewindFrom,\n  RestoreSignal,\n  deepClone as __deepClone,\n  not, eq, neq, lt, lte, gt, gte, and, or,\n  head, tail, empty,\n  success, failure, isSuccess, isFailure, __pipeBind, __tryCall, __catchResult,\n  Schema, __validateType,\n  readSkill as _readSkillRaw,\n  readSkillTool as __readSkillTool,\n  readSkillToolParams as __readSkillToolParams,\n  AgencyFunction as __AgencyFunction, UNSET as __UNSET,\n  __call, __callMethod,\n  functionRefReviver as __functionRefReviver,\n} from \"agency-lang/runtime\";\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\nconst __cwd = __process.cwd();\n\nconst getDirname = () => __dirname;\n\n{{{runtimeContextCode:string}}}\n\n// Path-dependent builtin wrappers\nexport function readSkill({filepath}: {filepath: string}): string {\n  return _readSkillRaw({ filepath, dirname: __dirname });\n}\n\n// Handler result builtins\nfunction approve(value?: any) { return { type: \"approved\" as const, value }; }\nfunction reject(value?: any) { return { type: \"rejected\" as const, value }; }\nfunction propagate() { return { type: \"propagated\" as const }; }\n\n// Interrupt and rewind re-exports bound to this module's context\nexport { interrupt, isInterrupt, isDebugger };\nexport const respondToInterrupt = (interrupt: Interrupt, response: InterruptResponse, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _respondToInterrupt({ ctx: __globalCtx, interrupt, interruptResponse: response, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const approveInterrupt = (interrupt: Interrupt, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _approveInterrupt({ ctx: __globalCtx, interrupt, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const rejectInterrupt = (interrupt: Interrupt, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _rejectInterrupt({ ctx: __globalCtx, interrupt, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const modifyInterrupt = (interrupt: Interrupt, newArguments: Record<string, any>, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _modifyInterrupt({ ctx: __globalCtx, interrupt, newArguments, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const resolveInterrupt = (interrupt: Interrupt, value: any, opts?: { overrides?: Record<string, unknown>; metadata?: Record<string, any> }) => _resolveInterrupt({ ctx: __globalCtx, interrupt, value, overrides: opts?.overrides, metadata: opts?.metadata });\nexport const rewindFrom = (checkpoint: RewindCheckpoint, overrides: Record<string, unknown>, opts?: { metadata?: Record<string, any> }) => _rewindFrom({ ctx: __globalCtx, checkpoint, overrides, metadata: opts?.metadata });\n\nexport const __setDebugger = (dbg: any) => { __globalCtx.debuggerState = dbg; };\nexport const __setTraceWriter = (tw: any) => { __globalCtx.traceWriter = tw; };\nexport const __getCheckpoints = () => __globalCtx.checkpoints;\n\nconst __toolRegistry: Record<string, any> = {};\n\nfunction __registerTool(value: unknown, name?: string) {\n  if (__AgencyFunction.isAgencyFunction(value)) {\n    __toolRegistry[name ?? value.name] = value;\n  }\n}\n\n// Wrap stateful runtime functions as AgencyFunction instances\nconst checkpoint = __AgencyFunction.create({ name: \"checkpoint\", module: \"__runtime\", fn: __checkpoint_impl, params: [], toolDefinition: null }, __toolRegistry);\nconst getCheckpoint = __AgencyFunction.create({ name: \"getCheckpoint\", module: \"__runtime\", fn: __getCheckpoint_impl, params: [{ name: \"checkpointId\", hasDefault: false, defaultValue: undefined, variadic: false }], toolDefinition: null }, __toolRegistry);\nconst restore = __AgencyFunction.create({ name: \"restore\", module: \"__runtime\", fn: __restore_impl, params: [{ name: \"checkpointIdOrCheckpoint\", hasDefault: false, defaultValue: undefined, variadic: false }, { name: \"options\", hasDefault: false, defaultValue: undefined, variadic: false }], toolDefinition: null }, __toolRegistry);";
 export type TemplateType = {
     runtimeContextCode: string;
 };

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

@@ -31,6 +31,7 @@ import {
   readSkillTool as __readSkillTool,
   readSkillToolParams as __readSkillToolParams,
   AgencyFunction as __AgencyFunction, UNSET as __UNSET,
+  __call, __callMethod,
   functionRefReviver as __functionRefReviver,
 } from "agency-lang/runtime";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.104",
+  "version": "0.0.105",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {