agency-lang 0.0.77 → 0.0.78

package/dist/lib/backends/agencyGenerator.js

@@ -31,17 +31,22 @@ export class AgencyGenerator extends BaseGenerator {
     }
     aliasedTypeToString(aliasedType) {
         if (aliasedType.type === "objectType") {
-            const props = aliasedType.properties
-                .map((prop) => {
-                let str = `${this.indent(this.indentLevel + 1)}`;
-                str += `${prop.key}: ${this.aliasedTypeToString(prop.value)}`;
-                if (prop.description) {
-                    str += ` # ${prop.description}`;
-                }
-                return str;
-            })
-                .join(";\n");
-            return `{\n${props}\n}`;
+            this.increaseIndent();
+            let result = "{\n" +
+                aliasedType.properties
+                    .map((prop) => {
+                    let str = "";
+                    str += this.indentStr(`${prop.key}: ${this.aliasedTypeToString(prop.value)}`);
+                    if (prop.description) {
+                        str += ` # ${prop.description}`;
+                    }
+                    return str;
+                })
+                    .join(";\n") +
+                "\n";
+            this.decreaseIndent();
+            result += this.indentStr("}");
+            return result;
         }
         return variableTypeToString(aliasedType, this.typeAliases);
     }

package/dist/lib/backends/typescriptGenerator/typeToZodSchema.js

@@ -4,6 +4,13 @@ export const DEFAULT_SCHEMA = "z.string()";
  * Maps Agency types to Zod schema strings
  */
 export function mapTypeToZodSchema(variableType, typeAliases) {
+    /* console.log(
+      color.yellow(
+        `Variable type is`,
+        JSON.stringify(variableType),
+      ),
+    );
+   */
     if (variableType.type === "primitiveType") {
         switch (variableType.value.toLowerCase()) {
             case "number":
@@ -12,6 +19,11 @@ export function mapTypeToZodSchema(variableType, typeAliases) {
                 return DEFAULT_SCHEMA;
             case "boolean":
                 return "z.boolean()";
+            case "null":
+                return "z.null()";
+            case "undefined":
+                // Undefined cannot be represented in JSON Schema
+                return "z.null()";
             default:
                 // Default to string for unknown types
                 return DEFAULT_SCHEMA;

package/dist/lib/backends/typescriptGenerator.js

@@ -1,4 +1,5 @@
 import { BUILTIN_FUNCTIONS, BUILTIN_TOOLS, TYPES_THAT_DONT_TRIGGER_NEW_PART, } from "../config.js";
+import { formatTypeHint } from "../cli/util.js";
 import * as renderSpecialVar from "../templates/backends/typescriptGenerator/specialVar.js";
 import * as renderTime from "../templates/backends/typescriptGenerator/builtinFunctions/time.js";
 // builtinTools now handled by runtime library
@@ -325,9 +326,15 @@ export class TypeScriptGenerator extends BaseGenerator {
         this.startScope({ type: "function", functionName: node.functionName });
         const { functionName, body, parameters } = node;
         const args = parameters.map((p) => p.name);
+        const typedArgs = parameters.map((p) => {
+            if (p.typeHint) {
+                return `${p.name}: ${formatTypeHint(p.typeHint)}`;
+            }
+            return `${p.name}: any`;
+        });
         const bodyCode = this.processBodyAsParts(body);
         this.endScope();
-        const paramList = args.length > 0 ? args.join(", ") + ", " : "";
+        const paramList = typedArgs.length > 0 ? typedArgs.join(", ") + ", " : "";
         const paramAssignments = args
             .map((arg) => `__stack.args["${arg}"] = ${arg};`)
             .join("\n    ");
@@ -887,10 +894,17 @@ export class TypeScriptGenerator extends BaseGenerator {
         for (const node of this.graphNodes) {
             const args = node.parameters;
             const argsStr = args.map((arg) => arg.name).join(", ");
+            const typedArgsStr = args.map((arg) => {
+                if (arg.typeHint) {
+                    return `${arg.name}: ${formatTypeHint(arg.typeHint)}`;
+                }
+                return `${arg.name}: any`;
+            }).join(", ");
             lines.push(renderRunNodeFunction.default({
                 nodeName: node.nodeName,
                 hasArgs: args.length > 0,
                 argsStr,
+                typedArgsStr,
             }));
             // Export node parameter names so imported nodes can build correct data objects
             const paramNames = args.map((arg) => `"${arg.name}"`).join(", ");

package/dist/lib/cli/commands.js

@@ -1,6 +1,6 @@
 import { generateAgency } from "../backends/agencyGenerator.js";
-import { generateDeclarations } from "../backends/declarationGenerator.js";
 import { generateTypeScript } from "../index.js";
+import { transformSync } from "esbuild";
 import { TypescriptPreprocessor } from "../preprocessors/typescriptPreprocessor.js";
 import { typeCheck, formatErrors } from "../typeChecker.js";
 import { renderMermaidAscii } from "beautiful-mermaid";
@@ -149,17 +149,18 @@ export function compile(config, inputFile, _outputFile, options) {
             node.modulePath = node.modulePath.replace(".agency", ext);
         }
     });
-    let generatedCode = generateTypeScript(parsedProgram, config);
+    const generatedCode = generateTypeScript(parsedProgram, config);
     if (options?.ts) {
-        generatedCode = "//@ts-nocheck\n" + generatedCode;
+        // TypeScript output — write as-is with proper types
+        fs.writeFileSync(outputFile, generatedCode, "utf-8");
     }
-    fs.writeFileSync(outputFile, generatedCode, "utf-8");
-    // Generate .d.ts declarations if enabled
-    if (config.declarations) {
-        const declarations = generateDeclarations(parsedProgram, config);
-        const dtsFile = outputFile.replace(/\.(js|ts)$/, ".d.ts");
-        fs.writeFileSync(dtsFile, declarations, "utf-8");
-        console.log(`${inputFile} → ${dtsFile}`);
+    else {
+        // JavaScript output — strip types with esbuild
+        const result = transformSync(generatedCode, {
+            loader: "ts",
+            format: "esm",
+        });
+        fs.writeFileSync(outputFile, result.code, "utf-8");
     }
     console.log(`${inputFile} → ${outputFile}`);
     return outputFile;

package/dist/lib/cli/test.js

@@ -38,6 +38,13 @@ function writeTestCase(agencyFilename, nodeName, input, expectedOutput, evaluati
 const onCancel = () => {
     process.exit(0);
 };
+function exitIfSignal(e) {
+    if (e instanceof Error &&
+        "signal" in e &&
+        (e.signal === "SIGINT" || e.signal === "SIGTERM")) {
+        process.exit(1);
+    }
+}
 export async function fixtures(config, target) {
     let { filename, nodeName } = target
         ? parseTarget(target)
@@ -306,6 +313,7 @@ export async function test(config, testFile) {
                     break;
             }
             catch (e) {
+                exitIfSignal(e);
                 console.log(color.red(`  ✗ Test error: ${e}`));
                 testPassed = false;
             }
@@ -390,6 +398,7 @@ export async function testTs(config, inputPaths) {
                 });
             }
             catch (e) {
+                exitIfSignal(e);
                 console.log(color.red(`  ✗ Test script execution failed: ${e}`));
                 failures.push(dir);
                 continue;

package/dist/lib/config.d.ts

@@ -79,10 +79,6 @@ export interface AgencyConfig {
      * If true, type errors are fatal during compilation (implies typeCheck: true).
      */
     typeCheckStrict?: boolean;
-    /**
-     * If true, generate .d.ts declaration files alongside .js output.
-     */
-    declarations?: boolean;
     /**
      * If true, validate that import paths resolve within the project directory.
      * Prevents path traversal attacks via imports like `../../etc/passwd`.

package/dist/lib/parsers/typeHints.js

@@ -31,8 +31,39 @@ export const numberLiteralTypeParser = trace("numberLiteralTypeParser", seqC(set
 export const booleanLiteralTypeParser = trace("booleanLiteralTypeParser", seqC(set("type", "booleanLiteralType"), capture(or(str("true"), str("false")), "value")));
 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);
+    const parser = seqC(capture(many1WithJoin(varNameChar), "key"), optionalSpaces, capture(optional(char("?")), "isOptional"), char(":"), optionalSpaces, capture(variableTypeParser, "value"));
+    const result = parser(input);
+    if (!result.success) {
+        return result;
+    }
+    const { key, isOptional, value } = result.result;
+    if (!isOptional) {
+        return success({
+            key,
+            value,
+        }, result.rest);
+    }
+    if (value.type === "unionType") {
+        // If it's already a union, just add undefined to the list of types
+        return success({
+            key,
+            value: {
+                type: "unionType",
+                types: [
+                    ...value.types,
+                    { type: "primitiveType", value: "undefined" },
+                ],
+            },
+        }, result.rest);
+    }
+    // If it's not a union, create a new union with the original type and undefined
+    return success({
+        key,
+        value: {
+            type: "unionType",
+            types: [value, { type: "primitiveType", value: "undefined" }],
+        },
+    }, result.rest);
 });
 export const objectPropertyDescriptionParser = trace("objectPropertyDescriptionParser", seqC(char("#"), optionalSpaces, capture(many1Till(oneOf(",;\n")), "description")));
 export const objectPropertyWithDescriptionParser = trace("objectPropertyWithDescriptionParser", seqC(captureCaptures(objectPropertyParser), spaces, captureCaptures(objectPropertyDescriptionParser)));

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

@@ -1,3 +1,5 @@
+export type { GraphState, InternalFunctionState } from "./types.js";
+export type { Interrupt } from "./interrupts.js";
 export { RuntimeContext } from "./state/context.js";
 export { StateStack } from "./state/stateStack.js";
 export { MessageThread } from "./state/messageThread.js";

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

@@ -1,4 +1,4 @@
-export declare const template = "async function _builtinFetch(url, args = {}) {\n  const result = await fetch(url, args);\n  try {\n    const text = await result.text();\n    return text;\n  } catch (e) {\n    throw new Error(`Failed to get text from ${url}: ${e}`);\n  }\n}";
+export declare const template = "async function _builtinFetch(url: string, args: RequestInit = {}): Promise<string> {\n  const result = await fetch(url, args);\n  try {\n    const text = await result.text();\n    return text;\n  } catch (e) {\n    throw new Error(`Failed to get text from ${url}: ${e}`);\n  }\n}";
 export type TemplateType = {};
 declare const render: (args: TemplateType) => string;
 export default render;

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

@@ -2,7 +2,7 @@
 // Source: lib/templates/backends/typescriptGenerator/builtinFunctions/fetch.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `async function _builtinFetch(url, args = {}) {
+export const template = `async function _builtinFetch(url: string, args: RequestInit = {}): Promise<string> {
   const result = await fetch(url, args);
   try {
     const text = await result.text();

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

@@ -1,4 +1,4 @@
-export declare const template = "async function _builtinFetchJSON(url, args = {}) {\n  const result = await fetch(url, args);\n  try {\n    const json = await result.json();\n    return json;\n  } catch (e) {\n    throw new Error(`Failed to parse JSON from ${url}: ${e}`);\n  }\n}";
+export declare const template = "async function _builtinFetchJSON(url: string, args: RequestInit = {}): Promise<any> {\n  const result = await fetch(url, args);\n  try {\n    const json = await result.json();\n    return json;\n  } catch (e) {\n    throw new Error(`Failed to parse JSON from ${url}: ${e}`);\n  }\n}";
 export type TemplateType = {};
 declare const render: (args: TemplateType) => string;
 export default render;

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

@@ -2,7 +2,7 @@
 // Source: lib/templates/backends/typescriptGenerator/builtinFunctions/fetchJSON.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `async function _builtinFetchJSON(url, args = {}) {
+export const template = `async function _builtinFetchJSON(url: string, args: RequestInit = {}): Promise<any> {
   const result = await fetch(url, args);
   try {
     const json = await result.json();

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

@@ -1,4 +1,4 @@
-export declare const template = "function _builtinInput(prompt) {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    rl.question(prompt, (answer) => {\n      rl.close();\n      resolve(answer);\n    });\n  });\n}";
+export declare const template = "function _builtinInput(prompt: string): Promise<string> {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout\n  });\n\n  return new Promise((resolve) => {\n    rl.question(prompt, (answer) => {\n      rl.close();\n      resolve(answer);\n    });\n  });\n}";
 export type TemplateType = {};
 declare const render: (args: TemplateType) => string;
 export default render;

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

@@ -2,7 +2,7 @@
 // Source: lib/templates/backends/typescriptGenerator/builtinFunctions/input.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `function _builtinInput(prompt) {
+export const template = `function _builtinInput(prompt: string): Promise<string> {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout

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

@@ -1,4 +1,4 @@
-export declare const template = "function _builtinRead(filename) {\n  const data = fs.readFileSync(filename);\n  const contents = data.toString('utf8');\n  return contents;\n}";
+export declare const template = "function _builtinRead(filename: string): string {\n  const data = fs.readFileSync(filename);\n  const contents = data.toString('utf8');\n  return contents;\n}";
 export type TemplateType = {};
 declare const render: (args: TemplateType) => string;
 export default render;

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

@@ -2,7 +2,7 @@
 // Source: lib/templates/backends/typescriptGenerator/builtinFunctions/read.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `function _builtinRead(filename) {
+export const template = `function _builtinRead(filename: string): string {
   const data = fs.readFileSync(filename);
   const contents = data.toString('utf8');
   return contents;

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

@@ -1,4 +1,4 @@
-export declare const template = "/*\n * @param filePath The absolute or relative path to the image file.\n * @returns The Base64 string, or null if an error occurs.\n */\nfunction _builtinReadImage(filePath) {\n    const data = fs.readFileSync(filePath); // Synchronous file reading\n    const base64String = data.toString('base64');\n    return base64String;\n}";
+export declare const template = "/*\n * @param filePath The absolute or relative path to the image file.\n * @returns The Base64 string, or null if an error occurs.\n */\nfunction _builtinReadImage(filePath: string): string {\n    const data = fs.readFileSync(filePath); // Synchronous file reading\n    const base64String = data.toString('base64');\n    return base64String;\n}";
 export type TemplateType = {};
 declare const render: (args: TemplateType) => string;
 export default render;

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

@@ -6,7 +6,7 @@ export const template = `/*
  * @param filePath The absolute or relative path to the image file.
  * @returns The Base64 string, or null if an error occurs.
  */
-function _builtinReadImage(filePath) {
+function _builtinReadImage(filePath: string): string {
     const data = fs.readFileSync(filePath); // Synchronous file reading
     const base64String = data.toString('base64');
     return base64String;

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

@@ -1,4 +1,4 @@
-export declare const template = "function _builtinSleep(seconds) {\n  return new Promise((resolve) => {\n    setTimeout(resolve, seconds * 1000);\n  });\n}";
+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

@@ -2,7 +2,7 @@
 // Source: lib/templates/backends/typescriptGenerator/builtinFunctions/sleep.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `function _builtinSleep(seconds) {
+export const template = `function _builtinSleep(seconds: number): Promise<void> {
   return new Promise((resolve) => {
     setTimeout(resolve, seconds * 1000);
   });

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

@@ -1,4 +1,4 @@
-export declare const template = "let {{{timingVarName:string}}}_startTime = performance.now();\n{{{bodyCodeStr:string}}}\nlet {{{timingVarName}}}_endTime = performance.now();\nlet {{{timingVarName}}} = {{{timingVarName}}}_endTime - {{{timingVarName}}}_startTime;\n\n{{#printTime}}\nconsole.log(\"Time taken:\", {{{timingVarName}}}, \"ms\");\n{{/printTime}}";
+export declare const template = "let {{{timingVarName:string}}}_startTime: number = performance.now();\n{{{bodyCodeStr:string}}}\nlet {{{timingVarName}}}_endTime: number = performance.now();\nlet {{{timingVarName}}}: number = {{{timingVarName}}}_endTime - {{{timingVarName}}}_startTime;\n\n{{#printTime}}\nconsole.log(\"Time taken:\", {{{timingVarName}}}, \"ms\");\n{{/printTime}}";
 export type TemplateType = {
     timingVarName: string;
     bodyCodeStr: string;

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

@@ -2,10 +2,10 @@
 // Source: lib/templates/backends/typescriptGenerator/builtinFunctions/time.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `let {{{timingVarName:string}}}_startTime = performance.now();
+export const template = `let {{{timingVarName:string}}}_startTime: number = performance.now();
 {{{bodyCodeStr:string}}}
-let {{{timingVarName}}}_endTime = performance.now();
-let {{{timingVarName}}} = {{{timingVarName}}}_endTime - {{{timingVarName}}}_startTime;
+let {{{timingVarName}}}_endTime: number = performance.now();
+let {{{timingVarName}}}: number = {{{timingVarName}}}_endTime - {{{timingVarName}}}_startTime;
 
 {{#printTime}}
 console.log("Time taken:", {{{timingVarName}}}, "ms");

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=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    {{{functionBody}}}\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

@@ -3,7 +3,7 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `
-export async function {{{functionName:string}}}({{{paramList:string}}}__state=undefined) {
+export async function {{{functionName:string}}}({{{paramList:string}}}__state: InternalFunctionState | undefined = undefined) {
     const { stack: __stack, step: __step, self: __self, threads: __threads } =
       setupFunction({ state: __state });
 

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

@@ -1,4 +1,4 @@
-export declare const template = "\ngraph.node(\"{{{name}}}\", async (__state) => {\n    const { stack: __stack, step: __step, self: __self, threads: __threads } =\n      setupNode({ state: __state });\n    const __ctx = __state.ctx;\n    const statelogClient = __ctx.statelogClient;\n    const __graph = __ctx.graph;\n    await callHook({ callbacks: __ctx.callbacks, name: \"onNodeStart\", data: { nodeName: \"{{{name}}}\" } });\n\n    if (__state.isResume) {\n      __globalCtx.stateStack.globals = __state.ctx.stateStack.globals;\n    }\n\n    {{#hasParam}}\n    if (!__state.isResume) {\n      {{{paramAssignments}}}\n    }\n    {{/hasParam}}\n    {{{body}}}\n\n    await callHook({ callbacks: __ctx.callbacks, name: \"onNodeEnd\", data: { nodeName: \"{{{name}}}\", data: undefined } });\n    return { messages: __threads, data: undefined };\n});\n";
+export declare const template = "\ngraph.node(\"{{{name}}}\", async (__state: GraphState) => {\n    const { stack: __stack, step: __step, self: __self, threads: __threads } =\n      setupNode({ state: __state });\n    const __ctx = __state.ctx;\n    const statelogClient = __ctx.statelogClient;\n    const __graph = __ctx.graph;\n    await callHook({ callbacks: __ctx.callbacks, name: \"onNodeStart\", data: { nodeName: \"{{{name}}}\" } });\n\n    if (__state.isResume) {\n      __globalCtx.stateStack.globals = __state.ctx.stateStack.globals;\n    }\n\n    {{#hasParam}}\n    if (!__state.isResume) {\n      {{{paramAssignments}}}\n    }\n    {{/hasParam}}\n    {{{body}}}\n\n    await callHook({ callbacks: __ctx.callbacks, name: \"onNodeEnd\", data: { nodeName: \"{{{name}}}\", data: undefined } });\n    return { messages: __threads, data: undefined };\n});\n";
 export type TemplateType = {
     name: string | boolean | number;
     hasParam: boolean;

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

@@ -3,7 +3,7 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `
-graph.node("{{{name}}}", async (__state) => {
+graph.node("{{{name}}}", async (__state: GraphState) => {
     const { stack: __stack, step: __step, self: __self, threads: __threads } =
       setupNode({ state: __state });
     const __ctx = __state.ctx;

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 {\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) {\n  return _builtinReadRaw({ filename, dirname: __dirname });\n}\nfunction _builtinWrite(filename, content) {\n  return _builtinWriteRaw({ filename, content, dirname: __dirname });\n}\nfunction _builtinReadImage(filename) {\n  return _builtinReadImageRaw({ filename, dirname: __dirname });\n}\nexport function readSkill({filepath}) {\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, r, m) => _respondToInterrupt({ ctx: __globalCtx, interrupt: i, interruptResponse: r, metadata: m });\nexport const approveInterrupt = (i, m) => _approveInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });\nexport const rejectInterrupt = (i, m) => _rejectInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });\nexport const modifyInterrupt = (i, a, m) => _modifyInterrupt({ ctx: __globalCtx, interrupt: i, newArguments: a, metadata: m });\nexport const resolveInterrupt = (i, v, m) => _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  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

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { goToNode, color, nanoid, registerProvider, registerTextModel } from "agency-lang";
 import * as smoltalk from "agency-lang";
 import path from "path";
+import type { GraphState, InternalFunctionState, Interrupt } from "agency-lang/runtime";
 import {
   RuntimeContext, MessageThread, ThreadStore,
   setupNode, setupFunction, runNode, runPrompt, callHook,
@@ -102,26 +103,26 @@ const __globalCtx = new RuntimeContext({
 const graph = __globalCtx.graph;
 
 // Path-dependent builtin wrappers
-function _builtinRead(filename) {
+function _builtinRead(filename: string): string {
   return _builtinReadRaw({ filename, dirname: __dirname });
 }
-function _builtinWrite(filename, content) {
-  return _builtinWriteRaw({ filename, content, dirname: __dirname });
+function _builtinWrite(filename: string, content: string): void {
+  _builtinWriteRaw({ filename, content, dirname: __dirname });
 }
-function _builtinReadImage(filename) {
+function _builtinReadImage(filename: string): string {
   return _builtinReadImageRaw({ filename, dirname: __dirname });
 }
-export function readSkill({filepath}) {
+export function readSkill({filepath}: {filepath: string}): string {
   return _readSkillRaw({ filepath, dirname: __dirname });
 }
 
 // Interrupt re-exports bound to this module's context
 export { interrupt, isInterrupt };
-export const respondToInterrupt = (i, r, m) => _respondToInterrupt({ ctx: __globalCtx, interrupt: i, interruptResponse: r, metadata: m });
-export const approveInterrupt = (i, m) => _approveInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });
-export const rejectInterrupt = (i, m) => _rejectInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });
-export const modifyInterrupt = (i, a, m) => _modifyInterrupt({ ctx: __globalCtx, interrupt: i, newArguments: a, metadata: m });
-export const resolveInterrupt = (i, v, m) => _resolveInterrupt({ ctx: __globalCtx, interrupt: i, value: v, metadata: m });`;
+export const respondToInterrupt = (i: Interrupt, r: any, m?: any) => _respondToInterrupt({ ctx: __globalCtx, interrupt: i, interruptResponse: r, metadata: m });
+export const approveInterrupt = (i: Interrupt, m?: any) => _approveInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });
+export const rejectInterrupt = (i: Interrupt, m?: any) => _rejectInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });
+export const modifyInterrupt = (i: Interrupt, a: any, m?: any) => _modifyInterrupt({ ctx: __globalCtx, interrupt: i, newArguments: a, metadata: m });
+export const resolveInterrupt = (i: Interrupt, v: any, m?: any) => _resolveInterrupt({ ctx: __globalCtx, interrupt: i, value: v, metadata: m });`;
 const render = (args) => {
     return apply(template, args);
 };

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

@@ -1,4 +1,4 @@
-export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}) {\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  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 type TemplateType = {
     variableName: string;
     argsStr: string;

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

@@ -3,7 +3,7 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `
-async function _{{{variableName:string}}}({{{argsStr:string}}}) {
+async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<any> {
   return runPrompt({
     ctx: __ctx,
     prompt: {{{promptCode:string}}},

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

@@ -1,7 +1,8 @@
-export declare const template = "{{#hasArgs}}\nexport async function {{{nodeName:string}}}({{{argsStr:string}}}, { messages, callbacks } = {}) {\n{{/hasArgs}}\n{{^hasArgs}}\nexport async function {{{nodeName:string}}}({ messages, callbacks } = {}) {\n{{/hasArgs}}\n  return runNode({\n    ctx: __globalCtx,\n    nodeName: \"{{{nodeName:string}}}\",\n    data: { {{{argsStr:string}}} },\n    messages,\n    callbacks,\n  });\n}\n";
+export declare const template = "{{#hasArgs}}\nexport async function {{{nodeName:string}}}({{{typedArgsStr:string}}}, { messages, callbacks }: { messages?: any; callbacks?: any } = {}) {\n{{/hasArgs}}\n{{^hasArgs}}\nexport async function {{{nodeName:string}}}({ messages, callbacks }: { messages?: any; callbacks?: any } = {}) {\n{{/hasArgs}}\n  return runNode({\n    ctx: __globalCtx,\n    nodeName: \"{{{nodeName:string}}}\",\n    data: { {{{argsStr:string}}} },\n    messages,\n    callbacks,\n  });\n}\n";
 export type TemplateType = {
     hasArgs: boolean;
     nodeName: string;
+    typedArgsStr: string;
     argsStr: string;
 };
 declare const render: (args: TemplateType) => string;

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

@@ -3,10 +3,10 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `{{#hasArgs}}
-export async function {{{nodeName:string}}}({{{argsStr:string}}}, { messages, callbacks } = {}) {
+export async function {{{nodeName:string}}}({{{typedArgsStr:string}}}, { messages, callbacks }: { messages?: any; callbacks?: any } = {}) {
 {{/hasArgs}}
 {{^hasArgs}}
-export async function {{{nodeName:string}}}({ messages, callbacks } = {}) {
+export async function {{{nodeName:string}}}({ messages, callbacks }: { messages?: any; callbacks?: any } = {}) {
 {{/hasArgs}}
   return runNode({
     ctx: __globalCtx,

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

@@ -1,4 +1,4 @@
-export declare const template = "if (process.argv[1] === fileURLToPath(import.meta.url)) {\n    try {\n      const initialState = { messages: new ThreadStore(), data: {} };\n      await main(initialState);\n    } catch (__error) {\n      console.error(`\nAgent crashed: ${__error.message}`);\n      throw __error;\n    }\n}\n";
+export declare const template = "if (process.argv[1] === fileURLToPath(import.meta.url)) {\n    try {\n      const initialState = { messages: new ThreadStore(), data: {} };\n      await main(initialState);\n    } catch (__error: any) {\n      console.error(`\nAgent crashed: ${__error.message}`);\n      throw __error;\n    }\n}\n";
 export type TemplateType = {};
 declare const render: (args: TemplateType) => string;
 export default render;

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

@@ -6,7 +6,7 @@ export const template = `if (process.argv[1] === fileURLToPath(import.meta.url))
     try {
       const initialState = { messages: new ThreadStore(), data: {} };
       await main(initialState);
-    } catch (__error) {
+    } catch (__error: any) {
       console.error(\`\nAgent crashed: \${__error.message}\`);
       throw __error;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.77",
+  "version": "0.0.78",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -63,6 +63,7 @@
     "cli-highlight": "^2.1.11",
     "commander": "^14.0.3",
     "egonlog": "^0.0.2",
+    "esbuild": "^0.27.4",
     "nanoid": "^5.1.6",
     "ora": "^9.3.0",
     "prompts": "^2.4.2",

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

@@ -1,42 +0,0 @@
-import { AgencyConfig } from "../config.js";
-import { AgencyProgram } from "../types.js";
-/**
- * Generates .d.ts declaration files from Agency AST.
- *
- * Produces TypeScript declarations for:
- * - Type aliases
- * - `def` functions (tool-style: args array + metadata)
- * - `node` graph nodes (wrapper-style: named params + options)
- * - Tool definition exports (__nameTool, __nameToolParams)
- * - The default graph export
- * - Import re-exports
- */
-export declare class DeclarationGenerator {
-    private program;
-    private config;
-    private typeAliases;
-    private lines;
-    constructor(program: AgencyProgram, config?: AgencyConfig);
-    generate(): string;
-    private collectTypeAliases;
-    private emit;
-    private typeToString;
-    private emitHeader;
-    private emitImports;
-    private emitImportStatement;
-    private emitImportNodeStatement;
-    private emitImportToolStatement;
-    private emitRuntimeImports;
-    private emitTypeAliases;
-    private emitReturnObjectType;
-    private emitFunctions;
-    private emitFunction;
-    private emitGraphNodes;
-    private emitGraphNode;
-    private emitToolDefinitions;
-    private emitDefaultExport;
-}
-/**
- * Generate a .d.ts declaration string from an Agency AST.
- */
-export declare function generateDeclarations(program: AgencyProgram, config?: AgencyConfig): string;

package/dist/lib/backends/declarationGenerator.js

@@ -1,233 +0,0 @@
-import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
-/**
- * Generates .d.ts declaration files from Agency AST.
- *
- * Produces TypeScript declarations for:
- * - Type aliases
- * - `def` functions (tool-style: args array + metadata)
- * - `node` graph nodes (wrapper-style: named params + options)
- * - Tool definition exports (__nameTool, __nameToolParams)
- * - The default graph export
- * - Import re-exports
- */
-export class DeclarationGenerator {
-    program;
-    config;
-    typeAliases = {};
-    lines = [];
-    constructor(program, config = {}) {
-        this.program = program;
-        this.config = config;
-    }
-    generate() {
-        this.lines = [];
-        this.collectTypeAliases();
-        this.emitHeader();
-        this.emitImports();
-        this.emitRuntimeImports();
-        this.emitTypeAliases();
-        this.emitReturnObjectType();
-        this.emitFunctions();
-        this.emitGraphNodes();
-        this.emitToolDefinitions();
-        this.emitDefaultExport();
-        return this.lines.join("\n") + "\n";
-    }
-    collectTypeAliases() {
-        for (const node of this.program.nodes) {
-            if (node.type === "typeAlias") {
-                this.typeAliases[node.aliasName] = node.aliasedType;
-            }
-        }
-    }
-    emit(line = "") {
-        this.lines.push(line);
-    }
-    typeToString(vt) {
-        return variableTypeToString(vt, this.typeAliases);
-    }
-    // --- Header ---
-    emitHeader() {
-        this.emit("// Auto-generated by Agency compiler");
-        this.emit("// Do not edit manually");
-        this.emit("");
-    }
-    // --- Imports ---
-    emitImports() {
-        let hasImports = false;
-        for (const node of this.program.nodes) {
-            if (node.type === "importStatement") {
-                this.emitImportStatement(node);
-                hasImports = true;
-            }
-            else if (node.type === "importNodeStatement") {
-                this.emitImportNodeStatement(node);
-                hasImports = true;
-            }
-            else if (node.type === "importToolStatement") {
-                this.emitImportToolStatement(node);
-                hasImports = true;
-            }
-        }
-        if (hasImports) {
-            this.emit("");
-        }
-    }
-    emitImportStatement(node) {
-        // Re-emit the import with .js extension (already transformed by compile pipeline)
-        const parts = [];
-        for (const name of node.importedNames) {
-            if (name.type === "defaultImport") {
-                parts.push(name.importedNames);
-            }
-            else if (name.type === "namedImport") {
-                parts.push(`{ ${name.importedNames.join(", ")} }`);
-            }
-            else if (name.type === "namespaceImport") {
-                parts.push(`* as ${name.importedNames}`);
-            }
-        }
-        const modulePath = node.modulePath.replace(/\.agency$/, ".js");
-        this.emit(`import ${parts.join(", ")} from "${modulePath}";`);
-    }
-    emitImportNodeStatement(node) {
-        const modulePath = node.agencyFile.replace(/\.agency$/, ".js");
-        this.emit(`import { ${node.importedNodes.join(", ")} } from "${modulePath}";`);
-    }
-    emitImportToolStatement(node) {
-        const modulePath = node.agencyFile.replace(/\.agency$/, ".js");
-        const toolExports = node.importedTools
-            .map((t) => `__${t}Tool, __${t}ToolParams`)
-            .join(", ");
-        this.emit(`import { ${toolExports} } from "${modulePath}";`);
-    }
-    // --- Runtime Imports ---
-    emitRuntimeImports() {
-        const hasNodes = this.program.nodes.some((n) => n.type === "graphNode");
-        if (!hasNodes)
-            return;
-        this.emit('import type { AgencyCallbacks } from "agency-lang/runtime";');
-        this.emit("");
-    }
-    // --- Type Aliases ---
-    emitTypeAliases() {
-        const aliases = this.program.nodes.filter((n) => n.type === "typeAlias");
-        if (aliases.length === 0)
-            return;
-        for (const alias of aliases) {
-            this.emit(`export type ${alias.aliasName} = ${this.typeToString(alias.aliasedType)};`);
-        }
-        this.emit("");
-    }
-    // --- ReturnObject type ---
-    emitReturnObjectType() {
-        const hasNodes = this.program.nodes.some((n) => n.type === "graphNode");
-        if (!hasNodes)
-            return;
-        this.emit("export interface TokenStats {");
-        this.emit("  usage: {");
-        this.emit("    inputTokens: number;");
-        this.emit("    outputTokens: number;");
-        this.emit("    cachedInputTokens: number;");
-        this.emit("    totalTokens: number;");
-        this.emit("  };");
-        this.emit("  cost: {");
-        this.emit("    inputCost: number;");
-        this.emit("    outputCost: number;");
-        this.emit("    totalCost: number;");
-        this.emit('    currency: "USD";');
-        this.emit("  };");
-        this.emit("}");
-        this.emit("");
-        this.emit("export interface ReturnObject<T = any> {");
-        this.emit("  messages: any;");
-        this.emit("  data: T;");
-        this.emit("  tokens: TokenStats;");
-        this.emit("}");
-        this.emit("");
-        this.emit("export interface NodeOptions {");
-        this.emit("  messages?: any[];");
-        this.emit("  callbacks?: AgencyCallbacks;");
-        this.emit("}");
-        this.emit("");
-    }
-    // --- `def` functions ---
-    emitFunctions() {
-        const functions = this.program.nodes.filter((n) => n.type === "function");
-        if (functions.length === 0)
-            return;
-        for (const fn of functions) {
-            this.emitFunction(fn);
-        }
-        this.emit("");
-    }
-    emitFunction(fn) {
-        const params = fn.parameters.map((p) => {
-            const type = p.typeHint ? this.typeToString(p.typeHint) : "any";
-            return `${p.name}: ${type}`;
-        });
-        params.push("__metadata?: Record<string, any>");
-        const returnType = fn.returnType
-            ? this.typeToString(fn.returnType)
-            : "any";
-        if (fn.docString) {
-            this.emit(`/** ${fn.docString.value.trim()} */`);
-        }
-        this.emit(`export function ${fn.functionName}(${params.join(", ")}): Promise<${returnType}>;`);
-    }
-    // --- Graph nodes ---
-    emitGraphNodes() {
-        const nodes = this.program.nodes.filter((n) => n.type === "graphNode");
-        if (nodes.length === 0)
-            return;
-        for (const node of nodes) {
-            this.emitGraphNode(node);
-        }
-        this.emit("");
-    }
-    emitGraphNode(node) {
-        // Graph nodes get a public wrapper: export async function name(param1, param2, { messages, callbacks } = {})
-        // Returns ReturnObject<T>
-        const params = node.parameters.map((p) => {
-            const type = p.typeHint ? this.typeToString(p.typeHint) : "any";
-            return `${p.name}: ${type}`;
-        });
-        params.push("options?: NodeOptions");
-        const dataType = node.returnType
-            ? this.typeToString(node.returnType)
-            : "undefined";
-        this.emit(`export function ${node.nodeName}(${params.join(", ")}): Promise<ReturnObject<${dataType}>>;`);
-    }
-    // --- Tool definitions ---
-    emitToolDefinitions() {
-        const functions = this.program.nodes.filter((n) => n.type === "function");
-        if (functions.length === 0)
-            return;
-        for (const fn of functions) {
-            const paramNames = fn.parameters.map((p) => `"${p.name}"`);
-            this.emit("");
-            this.emit(`export const __${fn.functionName}Tool: {`);
-            this.emit(`  name: "${fn.functionName}";`);
-            this.emit("  description: string;");
-            this.emit("  schema: import('zod').ZodType;");
-            this.emit("};");
-            this.emit(`export const __${fn.functionName}ToolParams: [${paramNames.join(", ")}];`);
-        }
-        this.emit("");
-    }
-    // --- Default export ---
-    emitDefaultExport() {
-        const hasNodes = this.program.nodes.some((n) => n.type === "graphNode");
-        if (!hasNodes)
-            return;
-        this.emit("declare const graph: any;");
-        this.emit("export default graph;");
-    }
-}
-/**
- * Generate a .d.ts declaration string from an Agency AST.
- */
-export function generateDeclarations(program, config = {}) {
-    const generator = new DeclarationGenerator(program, config);
-    return generator.generate();
-}

package/dist/lib/backends/declarationGenerator.test.d.ts

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

package/dist/lib/backends/declarationGenerator.test.js

@@ -1,287 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generateDeclarations } from "./declarationGenerator.js";
-describe("DeclarationGenerator", () => {
-    it("should generate declarations for a def function", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "function",
-                    functionName: "add",
-                    parameters: [
-                        {
-                            type: "functionParameter",
-                            name: "x",
-                            typeHint: { type: "primitiveType", value: "number" },
-                        },
-                        {
-                            type: "functionParameter",
-                            name: "y",
-                            typeHint: { type: "primitiveType", value: "number" },
-                        },
-                    ],
-                    body: [],
-                    returnType: { type: "primitiveType", value: "number" },
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).toContain("export function add(x: number, y: number, __metadata?: Record<string, any>): Promise<number>;");
-        expect(result).toContain('export const __addTool:');
-        expect(result).toContain('export const __addToolParams: ["x", "y"];');
-    });
-    it("should generate declarations for a graph node", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "graphNode",
-                    nodeName: "greet",
-                    parameters: [
-                        {
-                            type: "functionParameter",
-                            name: "name",
-                            typeHint: { type: "primitiveType", value: "string" },
-                        },
-                    ],
-                    body: [],
-                    returnType: { type: "primitiveType", value: "string" },
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).toContain("export function greet(name: string, options?: NodeOptions): Promise<ReturnObject<string>>;");
-        expect(result).toContain("export interface ReturnObject<T = any>");
-        expect(result).toContain("export interface NodeOptions");
-        expect(result).toContain("  callbacks?: AgencyCallbacks;");
-        expect(result).toContain("export interface TokenStats");
-        expect(result).toContain('import type { AgencyCallbacks } from "agency-lang/runtime";');
-        expect(result).toContain("export default graph;");
-    });
-    it("should generate declarations for type aliases", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "typeAlias",
-                    aliasName: "UserId",
-                    aliasedType: { type: "primitiveType", value: "string" },
-                },
-                {
-                    type: "typeAlias",
-                    aliasName: "Status",
-                    aliasedType: {
-                        type: "unionType",
-                        types: [
-                            { type: "stringLiteralType", value: "active" },
-                            { type: "stringLiteralType", value: "inactive" },
-                        ],
-                    },
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).toContain("export type UserId = string;");
-        expect(result).toContain('export type Status = "active" | "inactive";');
-    });
-    it("should handle functions without type hints", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "function",
-                    functionName: "doStuff",
-                    parameters: [
-                        { type: "functionParameter", name: "input" },
-                    ],
-                    body: [],
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).toContain("export function doStuff(input: any, __metadata?: Record<string, any>): Promise<any>;");
-    });
-    it("should handle graph nodes without return type", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "graphNode",
-                    nodeName: "main",
-                    parameters: [],
-                    body: [],
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).toContain("export function main(options?: NodeOptions): Promise<ReturnObject<undefined>>;");
-    });
-    it("should handle complex parameter types", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "function",
-                    functionName: "process",
-                    parameters: [
-                        {
-                            type: "functionParameter",
-                            name: "items",
-                            typeHint: {
-                                type: "arrayType",
-                                elementType: { type: "primitiveType", value: "number" },
-                            },
-                        },
-                        {
-                            type: "functionParameter",
-                            name: "mode",
-                            typeHint: {
-                                type: "unionType",
-                                types: [
-                                    { type: "stringLiteralType", value: "fast" },
-                                    { type: "stringLiteralType", value: "slow" },
-                                ],
-                            },
-                        },
-                    ],
-                    body: [],
-                    returnType: {
-                        type: "objectType",
-                        properties: [
-                            {
-                                key: "count",
-                                value: { type: "primitiveType", value: "number" },
-                            },
-                            {
-                                key: "result",
-                                value: { type: "primitiveType", value: "string" },
-                            },
-                        ],
-                    },
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).toContain('export function process(items: number[], mode: "fast" | "slow", __metadata?: Record<string, any>): Promise<{ count: number; result: string }>;');
-    });
-    it("should include docstrings as JSDoc", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "function",
-                    functionName: "greet",
-                    parameters: [
-                        {
-                            type: "functionParameter",
-                            name: "name",
-                            typeHint: { type: "primitiveType", value: "string" },
-                        },
-                    ],
-                    body: [],
-                    docString: { type: "docString", value: "Greets a person by name" },
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).toContain("/** Greets a person by name */");
-    });
-    it("should handle imports", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "importStatement",
-                    importedNames: [
-                        { type: "namedImport", importedNames: ["foo", "bar"] },
-                    ],
-                    modulePath: "./utils.js",
-                },
-                {
-                    type: "importNodeStatement",
-                    importedNodes: ["analyzeData"],
-                    agencyFile: "./analyzer.agency",
-                },
-                {
-                    type: "importToolStatement",
-                    importedTools: ["search"],
-                    agencyFile: "./tools.agency",
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).toContain('import { foo, bar } from "./utils.js";');
-        expect(result).toContain('import { analyzeData } from "./analyzer.js";');
-        expect(result).toContain('import { __searchTool, __searchToolParams } from "./tools.js";');
-    });
-    it("should not emit ReturnObject/NodeOptions/default export when there are no graph nodes", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "function",
-                    functionName: "add",
-                    parameters: [],
-                    body: [],
-                    returnType: { type: "primitiveType", value: "number" },
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        expect(result).not.toContain("ReturnObject");
-        expect(result).not.toContain("NodeOptions");
-        expect(result).not.toContain("AgencyCallbacks");
-        expect(result).not.toContain("export default");
-    });
-    it("should handle a full program with multiple features", () => {
-        const program = {
-            type: "agencyProgram",
-            nodes: [
-                {
-                    type: "typeAlias",
-                    aliasName: "Name",
-                    aliasedType: { type: "primitiveType", value: "string" },
-                },
-                {
-                    type: "function",
-                    functionName: "formatName",
-                    parameters: [
-                        {
-                            type: "functionParameter",
-                            name: "name",
-                            typeHint: { type: "typeAliasVariable", aliasName: "Name" },
-                        },
-                    ],
-                    body: [],
-                    returnType: { type: "primitiveType", value: "string" },
-                    docString: { type: "docString", value: "Formats a name" },
-                },
-                {
-                    type: "graphNode",
-                    nodeName: "main",
-                    parameters: [
-                        {
-                            type: "functionParameter",
-                            name: "input",
-                            typeHint: { type: "primitiveType", value: "string" },
-                        },
-                    ],
-                    body: [],
-                    returnType: { type: "primitiveType", value: "string" },
-                },
-            ],
-        };
-        const result = generateDeclarations(program);
-        // Has type alias
-        expect(result).toContain("export type Name = string;");
-        // Has function with docstring
-        expect(result).toContain("/** Formats a name */");
-        expect(result).toContain("export function formatName(name: Name, __metadata?: Record<string, any>): Promise<string>;");
-        // Has node
-        expect(result).toContain("export function main(input: string, options?: NodeOptions): Promise<ReturnObject<string>>;");
-        // Has tool definition
-        expect(result).toContain("export const __formatNameTool:");
-        // Has default export
-        expect(result).toContain("export default graph;");
-    });
-});