agency-lang 0.0.53 → 0.0.56

package/dist/lib/agents/judge.agency

@@ -0,0 +1,18 @@
+type JudgeResult = {
+  score: number # a score from 0 to 100 where 100 means perfect match;
+  reasoning: string # brief explanation for the score
+}
+
+node judge(actualOutput: string, expectedOutput: string, judgePrompt: string): JudgeResult {
+  result: JudgeResult = llm("You are an evaluation judge. Score how well the actual output matches what was expected.
+
+Judge prompt (evaluation criteria): ${judgePrompt}
+
+Expected output: ${expectedOutput}
+
+Actual output: ${actualOutput}
+
+Provide a score from 0 to 100 where 100 means perfect match and 0 means completely wrong. Also provide brief reasoning.")
+
+  return result
+}

package/dist/lib/backends/baseGenerator.js

@@ -21,6 +21,9 @@ export class BaseGenerator {
     agencyConfig = {};
     constructor({ config }) {
         this.agencyConfig = mergeDeep(this.configDefaults(), config || {});
+        if (this.agencyConfig.verbose) {
+            console.log("Generator config:", this.agencyConfig);
+        }
     }
     configDefaults() {
         return {};

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

@@ -4,7 +4,7 @@ import { generateGraph } from "./graphGenerator.js";
 import fs from "fs";
 import path from "path";
 /**
- * Recursively discovers all .agency/.mts fixture pairs in a directory
+ * Recursively discovers all .agency/.mjs fixture pairs in a directory
  */
 function discoverFixtures(fixtureDir) {
     const fixtures = [];
@@ -20,9 +20,9 @@ function discoverFixtures(fixtureDir) {
                 scanDirectory(fullPath, relPath);
             }
             else if (entry.isFile() && entry.name.endsWith(".agency")) {
-                // Found an Agency file - look for corresponding .mts
+                // Found an Agency file - look for corresponding .mjs
                 const baseName = entry.name.replace(".agency", "");
-                const mtsPath = path.join(dir, `${baseName}.mts`);
+                const mtsPath = path.join(dir, `${baseName}.mjs`);
                 if (fs.existsSync(mtsPath)) {
                     const nameWithoutExt = relativePath
                         ? `${relativePath}/${baseName}`
@@ -41,7 +41,7 @@ function discoverFixtures(fixtureDir) {
                     }
                 }
                 else {
-                    console.warn(`Warning: No corresponding .mts file for ${fullPath}`);
+                    console.warn(`Warning: No corresponding .mjs file for ${fullPath}`);
                 }
             }
         }

package/dist/lib/backends/graphGenerator.js

@@ -7,7 +7,6 @@ import * as renderRunNodeFunction from "../templates/backends/graphGenerator/run
 import * as renderStartNode from "../templates/backends/graphGenerator/startNode.js";
 import { TypeScriptGenerator } from "./typescriptGenerator.js";
 import { mapFunctionName } from "./typescriptGenerator/builtins.js";
-import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
 import { TypescriptPreprocessor } from "../preprocessors/typescriptPreprocessor.js";
 export class GraphGenerator extends TypeScriptGenerator {
     typeHints = {};
@@ -144,24 +143,22 @@ export class GraphGenerator extends TypeScriptGenerator {
       return "generateLiteral not implemented";
     } */
     generateImports() {
-        const arr = [
-            renderImports.default({
-                logHost: this.agencyConfig.log?.host || "",
-                logProjectId: this.agencyConfig.log?.projectId || "",
-                logDebugMode: this.agencyConfig.log?.debugMode || false,
-                clientLogLevel: this.agencyConfig.client?.logLevel || "warn",
-                clientDefaultModel: this.agencyConfig.client?.defaultModel || "gpt-4o-mini",
-            }),
-        ];
+        const args = {
+            logHost: this.agencyConfig.log?.host || "",
+            logProjectId: this.agencyConfig.log?.projectId || "",
+            logDebugMode: this.agencyConfig.log?.debugMode || false,
+            clientLogLevel: this.agencyConfig.client?.logLevel || "warn",
+            clientDefaultModel: this.agencyConfig.client?.defaultModel || "gpt-4o-mini",
+        };
+        const arr = [renderImports.default(args)];
         arr.push(builtinTools.default({}));
         return arr.join("\n");
     }
     preprocess() {
         const lines = [];
-        lines.push("// @ts-nocheck\n");
         this.importedNodes.forEach((importNode) => {
             const defaultImportName = this.agencyFileToDefaultImportName(importNode.agencyFile);
-            lines.push(`import ${defaultImportName} from "${importNode.agencyFile.replace(".agency", ".ts")}";`);
+            lines.push(`import ${defaultImportName} from "${importNode.agencyFile.replace(".agency", ".js")}";`);
         });
         return lines.join("\n");
     }
@@ -196,9 +193,6 @@ export class GraphGenerator extends TypeScriptGenerator {
                 nodeName: node.nodeName,
                 hasArgs: args.length > 0,
                 argsStr,
-                returnType: node.returnType
-                    ? variableTypeToString(node.returnType, this.typeAliases)
-                    : "any",
             }));
         }
         lines.push("export default graph;");

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

@@ -4,7 +4,7 @@ import { generateTypeScript } from "./typescriptGenerator.js";
 import fs from "fs";
 import path from "path";
 /**
- * Recursively discovers all .agency/.mts fixture pairs in a directory
+ * Recursively discovers all .agency/.mjs fixture pairs in a directory
  */
 function discoverFixtures(fixtureDir) {
     const fixtures = [];
@@ -20,9 +20,9 @@ function discoverFixtures(fixtureDir) {
                 scanDirectory(fullPath, relPath);
             }
             else if (entry.isFile() && entry.name.endsWith(".agency")) {
-                // Found an Agency file - look for corresponding .mts
+                // Found an Agency file - look for corresponding .mjs
                 const baseName = entry.name.replace(".agency", "");
-                const mtsPath = path.join(dir, `${baseName}.mts`);
+                const mtsPath = path.join(dir, `${baseName}.mjs`);
                 if (fs.existsSync(mtsPath)) {
                     const nameWithoutExt = relativePath
                         ? `${relativePath}/${baseName}`
@@ -41,7 +41,7 @@ function discoverFixtures(fixtureDir) {
                     }
                 }
                 else {
-                    console.warn(`Warning: No corresponding .mts file for ${fullPath}`);
+                    console.warn(`Warning: No corresponding .mjs file for ${fullPath}`);
                 }
             }
         }

package/dist/lib/backends/typescriptGenerator.js

@@ -37,7 +37,7 @@ export class TypeScriptGenerator extends BaseGenerator {
     }
     typeAliasToString(node) {
         const aliasedTypeStr = variableTypeToString(node.aliasedType, this.typeAliases);
-        return `type ${node.aliasName} = ${aliasedTypeStr};`;
+        return "";
     }
     processTypeHint(node) {
         if (node.variableType.type === "typeAliasVariable") {
@@ -139,9 +139,7 @@ export class TypeScriptGenerator extends BaseGenerator {
         else {
             this.functionScopedVariables.push(variableName);
         }
-        const typeAnnotation = typeHint
-            ? `: ${variableTypeToString(typeHint, this.typeAliases)}`
-            : "";
+        const typeAnnotation = "";
         if (value.type === "prompt") {
             return this.processPromptLiteral(variableName, typeHint, value);
         }
@@ -150,7 +148,6 @@ export class TypeScriptGenerator extends BaseGenerator {
             const code = this.processNode(value);
             return renderFunctionCallAssignment.default({
                 variableName: `${this.getScopeVar()}.${variableName}`,
-                typeAnnotation,
                 functionCode: code.trim(),
                 nodeContext: this.getCurrentScope().type === "node",
                 globalScope: this.getCurrentScope().type === "global",
@@ -253,9 +250,6 @@ export class TypeScriptGenerator extends BaseGenerator {
         return renderFunctionDefinition.default({
             functionName,
             argsStr,
-            returnType: node.returnType
-                ? variableTypeToString(node.returnType, this.typeAliases)
-                : "any",
             functionBody: bodyCode.join("\n"),
         });
     }
@@ -415,15 +409,14 @@ export class TypeScriptGenerator extends BaseGenerator {
             value: "string",
         };
         const zodSchema = mapTypeToZodSchema(_variableType, this.typeAliases);
-        const typeString = variableTypeToString(_variableType, this.typeAliases);
         // Build prompt construction code
         const promptCode = this.buildPromptString({
             segments: prompt.segments,
             typeHints: this.typeHints,
             skills: prompt.skills || [],
         });
-        const parts = functionArgs.map((arg) => `${arg.replace(".", "_")}: ${variableTypeToString(this.typeHints[arg] || { type: "primitiveType", value: "string" }, this.typeAliases)}`);
-        parts.push("__metadata?: Record<string, any>");
+        const parts = functionArgs.map((arg) => arg.replace(".", "_"));
+        parts.push("__metadata");
         const argsStr = parts.join(", ");
         let _tools = "";
         if (prompt.tools) {
@@ -453,7 +446,7 @@ export class TypeScriptGenerator extends BaseGenerator {
     I'll probably need to do that for supporting type checking anyway.
     */
         const functionCalls = (prompt.tools || { type: "usesTool", toolNames: [] }).toolNames
-            .filter((t) => BUILTIN_TOOLS.includes(t))
+            .filter((t) => !BUILTIN_TOOLS.includes(t))
             .map((toolName) => {
             if (!this.functionDefinitions[toolName] &&
                 !this.isImportedTool(toolName)) {
@@ -473,7 +466,6 @@ export class TypeScriptGenerator extends BaseGenerator {
             variableName,
             argsStr,
             funcCallParams: [...scopedFunctionArgs, metadataObj].join(", "),
-            typeString,
             promptCode,
             hasResponseFormat: zodSchema !== DEFAULT_SCHEMA,
             zodSchema,
@@ -487,7 +479,7 @@ export class TypeScriptGenerator extends BaseGenerator {
         });
     }
     processImportStatement(node) {
-        return `import ${node.importedNames} from "${node.modulePath.replace(/\.agency$/, ".ts")}";`;
+        return `import ${node.importedNames} from "${node.modulePath.replace(/\.agency$/, ".js")}";`;
     }
     processImportNodeStatement(node) {
         return ""; // handled in preprocess in graphgenerator
@@ -500,7 +492,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             `__${toolName}ToolParams`,
         ])
             .flat();
-        return `import { ${importNames.join(", ")} } from "${node.agencyFile.replace(/\.agency$/, ".ts")}";`;
+        return `import { ${importNames.join(", ")} } from "${node.agencyFile.replace(/\.agency$/, ".js")}";`;
     }
     processWhileLoop(node) {
         const conditionCode = this.processNode(node.condition);

package/dist/lib/cli/commands.d.ts

@@ -1,6 +1,6 @@
 import { AgencyConfig } from "../config.js";
 import { AgencyProgram } from "../index.js";
-export declare function loadConfig(configPath?: string): AgencyConfig;
+export declare function loadConfig(configPath?: string, verbose?: boolean): AgencyConfig;
 export declare function readStdin(): Promise<string>;
 export declare function parse(contents: string, config: AgencyConfig): AgencyProgram;
 export declare function readFile(inputFile: string): string;

package/dist/lib/cli/commands.js

@@ -7,11 +7,14 @@ import * as fs from "fs";
 import * as path from "path";
 import { parseAgency } from "../parser.js";
 // Load configuration from agency.json
-export function loadConfig(configPath) {
+export function loadConfig(configPath, verbose = false) {
     let config = {};
     // Determine config file path
     const defaultConfigPath = path.join(process.cwd(), "agency.json");
     const finalConfigPath = configPath || defaultConfigPath;
+    if (verbose) {
+        console.log(`Looking for config at: ${finalConfigPath}`);
+    }
     // Check if config file exists
     if (fs.existsSync(finalConfigPath)) {
         try {
@@ -45,7 +48,7 @@ export function readStdin() {
 }
 export function parse(contents, config) {
     const verbose = config.verbose ?? false;
-    const parseResult = parseAgency(contents, verbose);
+    const parseResult = parseAgency(contents, config);
     // Check if parsing was successful
     if (!parseResult.success) {
         console.error("Parse error:");
@@ -121,7 +124,7 @@ export function compile(config, inputFile, _outputFile) {
     }
     // Resolve the absolute path of the input file to avoid duplicates
     const absoluteInputFile = path.resolve(inputFile);
-    let outputFile = _outputFile || inputFile.replace(".agency", ".ts");
+    let outputFile = _outputFile || inputFile.replace(".agency", ".js");
     if (config.outDir && !_outputFile) {
         const outputDir = path.resolve(config.outDir);
         if (!fs.existsSync(outputDir)) {
@@ -145,7 +148,7 @@ export function compile(config, inputFile, _outputFile) {
     // Update the import path in the AST to reference the new .ts file
     parsedProgram.nodes.forEach((node) => {
         if (node.type === "importStatement") {
-            node.modulePath = node.modulePath.replace(".agency", ".ts");
+            node.modulePath = node.modulePath.replace(".agency", ".js");
         }
     });
     const generatedCode = generateGraph(parsedProgram, config);

package/dist/lib/cli/evaluate.js

@@ -162,7 +162,7 @@ export async function evaluate(target, argsFilePath, resultsFilePath) {
         const argsString = hasArgs
             ? argsRecordToString(c.args, selectedNode.parameters)
             : "";
-        const json = executeNode(filename, nodeName, hasArgs, argsString);
+        const json = executeNode(filename, nodeName, hasArgs, argsString, undefined);
         console.log("\nOutput:");
         console.log(JSON.stringify(json.data, null, 2));
         const ratingResponse = await prompts({

package/dist/lib/cli/test.js

@@ -2,14 +2,15 @@ import { parseAgency } from "../parser.js";
 import { getNodesOfType } from "../utils/node.js";
 import fs from "fs";
 import prompts from "prompts";
-import { executeNode, parseTarget, pickANode, promptForArgs, promptForTarget, } from "./util.js";
+import { executeJudge, executeNode, parseTarget, pickANode, promptForArgs, promptForTarget, } from "./util.js";
+import { color } from "termcolors";
 function readFile(filename) {
     console.log("Trying to read file", filename, "...");
     const data = fs.readFileSync(filename);
     const contents = data.toString("utf8");
     return contents;
 }
-function writeTestCase(agencyFilename, nodeName, input, expectedOutput, evaluationCriteria) {
+function writeTestCase(agencyFilename, nodeName, input, expectedOutput, evaluationCriteria, interruptHandlers) {
     const testFilePath = agencyFilename.replace(".agency", ".test.json");
     let tests;
     if (fs.existsSync(testFilePath)) {
@@ -18,7 +19,16 @@ function writeTestCase(agencyFilename, nodeName, input, expectedOutput, evaluati
     else {
         tests = { sourceFile: agencyFilename, tests: [] };
     }
-    tests.tests.push({ nodeName, input, expectedOutput, evaluationCriteria });
+    const testCase = {
+        nodeName,
+        input,
+        expectedOutput,
+        evaluationCriteria,
+    };
+    if (interruptHandlers && interruptHandlers.length > 0) {
+        testCase.interruptHandlers = interruptHandlers;
+    }
+    tests.tests.push(testCase);
     fs.writeFileSync(testFilePath, JSON.stringify(tests, null, 2));
     return testFilePath;
 }
@@ -46,8 +56,58 @@ export async function fixtures(target) {
     const selectedNode = nodes.find((n) => n.nodeName === nodeName);
     let { hasArgs, argsString } = await promptForArgs(selectedNode);
     console.log("Running program from entrypoint", nodeName);
-    const json = executeNode(filename, nodeName, hasArgs, argsString);
-    console.log("\nOutput:");
+    let json = executeNode(filename, nodeName, hasArgs, argsString);
+    // Handle interrupt discovery
+    const interruptHandlers = [];
+    while (json.data &&
+        typeof json.data === "object" &&
+        json.data.type === "interrupt") {
+        console.log(`\n⚠️  Interrupt detected: "${json.data.data}"`);
+        const actionResponse = await prompts({
+            type: "select",
+            name: "action",
+            message: "How should the test handle this interrupt?",
+            choices: [
+                { title: "Approve", value: "approve" },
+                { title: "Reject", value: "reject" },
+                { title: "Modify arguments", value: "modify" },
+            ],
+        });
+        if (!actionResponse.action) {
+            console.log("Interrupt handling cancelled.");
+            return;
+        }
+        const handler = {
+            action: actionResponse.action,
+            expectedMessage: json.data.data, // Capture the actual message
+        };
+        if (actionResponse.action === "modify") {
+            let invalidJSON = true;
+            while (invalidJSON) {
+                const modifyResponse = await prompts({
+                    type: "text",
+                    name: "args",
+                    message: "Enter modified arguments as JSON object:",
+                });
+                if (!modifyResponse.args) {
+                    console.log("Interrupt handling cancelled.");
+                    return;
+                }
+                try {
+                    handler.modifiedArgs = JSON.parse(modifyResponse.args);
+                    invalidJSON = false;
+                }
+                catch (e) {
+                    console.error("Invalid JSON:", e);
+                    return;
+                }
+            }
+        }
+        interruptHandlers.push(handler);
+        // Continue execution with this handler to see if there are more interrupts
+        json = executeNode(filename, nodeName, hasArgs, argsString, interruptHandlers);
+    }
+    console.log("\nFinal Output:");
     console.log(JSON.stringify(json.data, null, 2));
     const correctResponse = await prompts({
         type: "confirm",
@@ -103,7 +163,7 @@ export async function fixtures(target) {
         ];
     }
     const inputStr = hasArgs ? argsString : "";
-    const testFilePath = writeTestCase(filename, nodeName, inputStr, expectedOutput, criteria);
+    const testFilePath = writeTestCase(filename, nodeName, inputStr, expectedOutput, criteria, interruptHandlers.length > 0 ? interruptHandlers : undefined);
     console.log(`Test case saved to ${testFilePath}`);
 }
 export async function test(testFile) {
@@ -139,24 +199,47 @@ export async function test(testFile) {
     for (let i = 0; i < total; i++) {
         const testCase = tests.tests[i];
         const hasArgs = testCase.input !== "";
-        console.log(`\nTest ${i + 1}/${total}: node=${testCase.nodeName} input=${testCase.input || "(none)"}`);
-        const result = executeNode(tests.sourceFile, testCase.nodeName, hasArgs, testCase.input);
+        const interruptInfo = testCase.interruptHandlers
+            ? ` interrupts=${testCase.interruptHandlers.length}`
+            : "";
+        const testNum = color.cyan(`Test ${i + 1}/${total}:`);
+        console.log(`\n${testNum} node=${testCase.nodeName} input=${testCase.input || "(none)"}${interruptInfo}`);
+        if (testCase.description) {
+            console.log(color.cyan("Description:", testCase.description), "\n");
+        }
+        const result = executeNode(tests.sourceFile, testCase.nodeName, hasArgs, testCase.input, testCase.interruptHandlers);
         let testPassed = true;
         for (const criterion of testCase.evaluationCriteria) {
             if (criterion.type === "exact") {
                 const actual = JSON.stringify(result.data);
                 if (actual === testCase.expectedOutput) {
-                    console.log("  ✓ Exact match passed");
+                    console.log(color.green("  ✓ Exact match passed"));
                 }
                 else {
-                    console.log("  ✗ Exact match failed");
+                    console.log(color.red("  ✗ Exact match failed"));
                     console.log("    Expected:", testCase.expectedOutput);
                     console.log("    Actual:  ", actual);
                     testPassed = false;
                 }
             }
             else if (criterion.type === "llmJudge") {
-                console.log("  ⚠ LLM Judge evaluation not yet supported, skipping");
+                const actual = JSON.stringify(result.data);
+                try {
+                    const judgeResult = executeJudge(actual, testCase.expectedOutput, criterion.judgePrompt);
+                    if (judgeResult.score >= criterion.desiredAccuracy) {
+                        console.log(color.green(`  ✓ LLM Judge passed (score: ${judgeResult.score}/${criterion.desiredAccuracy})`));
+                        console.log(`    Reasoning: ${judgeResult.reasoning}`);
+                    }
+                    else {
+                        console.log(color.red(`  ✗ LLM Judge failed (score: ${judgeResult.score}/${criterion.desiredAccuracy})`));
+                        console.log(`    Reasoning: ${judgeResult.reasoning}`);
+                        testPassed = false;
+                    }
+                }
+                catch (e) {
+                    console.log(color.red(`  ✗ LLM Judge error: ${e}`));
+                    testPassed = false;
+                }
             }
         }
         if (testPassed)

package/dist/lib/cli/util.d.ts

@@ -12,8 +12,20 @@ export declare function promptForArgs(selectedNode: GraphNodeDefinition): Promis
     hasArgs: boolean;
     argsString: string;
 }>;
-export declare function executeNode(agencyFile: string, nodeName: string, hasArgs: boolean, argsString: string): {
+export declare function executeNode(agencyFile: string, nodeName: string, hasArgs: boolean, argsString: string, interruptHandlers?: Array<{
+    action: "approve" | "reject" | "modify";
+    modifiedArgs?: Record<string, any>;
+    expectedMessage?: string;
+}>): {
     data: any;
     [key: string]: any;
 };
 export declare function formatTypeHint(vt: VariableType): string;
+export declare function executeJudge(actualOutput: string, expectedOutput: string, judgePrompt: string, interruptHandlers?: Array<{
+    action: "approve" | "reject" | "modify";
+    modifiedArgs?: Record<string, any>;
+    expectedMessage?: string;
+}>): {
+    score: number;
+    reasoning: string;
+};

package/dist/lib/cli/util.js

@@ -1,7 +1,9 @@
 import prompts from "prompts";
 import fs, { readFileSync } from "fs";
+import path from "path";
 import { execSync } from "child_process";
 import renderEvaluate from "../templates/cli/evaluate.js";
+import renderJudgeEvaluate from "../templates/cli/judgeEvaluate.js";
 import { compile } from "./commands.js";
 export function parseTarget(target) {
     const colonIndex = target.lastIndexOf(":");
@@ -87,18 +89,22 @@ export async function promptForArgs(selectedNode) {
     }
     return { hasArgs, argsString };
 }
-export function executeNode(agencyFile, nodeName, hasArgs, argsString) {
-    const outFile = agencyFile.replace(".agency", ".ts");
+export function executeNode(agencyFile, nodeName, hasArgs, argsString, interruptHandlers) {
+    const outFile = agencyFile.replace(".agency", ".js");
     compile({}, agencyFile, outFile);
     const evaluateScript = renderEvaluate({
         filename: outFile,
         nodeName,
         hasArgs,
         args: argsString,
+        hasInterruptHandlers: !!interruptHandlers,
+        interruptHandlersJSON: interruptHandlers
+            ? JSON.stringify(interruptHandlers)
+            : undefined,
     });
-    const evaluateFile = "__evaluate.ts";
+    const evaluateFile = "__evaluate.js";
     fs.writeFileSync(evaluateFile, evaluateScript);
-    execSync(`npx tsx ${evaluateFile}`, { stdio: "inherit" });
+    execSync(`node ${evaluateFile}`, { stdio: "inherit" });
     const results = readFileSync("__evaluate.json", "utf-8");
     return JSON.parse(results);
 }
@@ -130,3 +136,25 @@ function serializeArgValue(value) {
         return value;
     return JSON.stringify(value);
 }
+export function executeJudge(actualOutput, expectedOutput, judgePrompt, interruptHandlers) {
+    // Resolve the judge.agency file bundled in dist/lib/agents/
+    const currentDir = path.dirname(new URL(import.meta.url).pathname);
+    const judgeAgencyFile = path.resolve(currentDir, "../agents/judge.agency");
+    const judgeOutFile = "__judge.js";
+    compile({}, judgeAgencyFile, judgeOutFile);
+    const judgeScript = renderJudgeEvaluate({
+        judgeFilename: judgeOutFile,
+        actualOutput: JSON.stringify(actualOutput),
+        expectedOutput: JSON.stringify(expectedOutput),
+        judgePrompt: JSON.stringify(judgePrompt),
+        hasInterruptHandlers: !!interruptHandlers,
+        interruptHandlersJSON: interruptHandlers
+            ? JSON.stringify(interruptHandlers)
+            : undefined,
+    });
+    const judgeEvaluateFile = "__judge_evaluate.js";
+    fs.writeFileSync(judgeEvaluateFile, judgeScript);
+    execSync(`node ${judgeEvaluateFile}`, { stdio: "inherit" });
+    const results = readFileSync("__judge_evaluate.json", "utf-8");
+    return JSON.parse(results).data;
+}

package/dist/lib/config.d.ts

@@ -36,6 +36,10 @@ export interface AgencyConfig {
      * Example: ["malicious.com", "blocked.site.com"]
      */
     disallowedFetchDomains?: string[];
+    /**
+     * Optionally specify a custom host for tarsec trace collection
+     */
+    tarsecTraceHost?: string;
     /** Statelog config */
     log?: Partial<{
         host: string;
@@ -46,4 +50,9 @@ export interface AgencyConfig {
         logLevel: "error" | "warn" | "info" | "debug";
         defaultModel: string;
     }>;
+    /**
+     * If true, untyped variables are errors.
+     * If false (default), untyped variables are implicitly `any`.
+     */
+    strictTypes?: boolean;
 }

package/dist/lib/parser.d.ts

@@ -1,9 +1,10 @@
 import { Parser, ParserResult } from "tarsec";
 import { AgencyNode, AgencyProgram } from "./types.js";
+import { AgencyConfig } from "./config.js";
 export declare const agencyNode: Parser<AgencyNode[]>;
 export declare const agencyParser: Parser<AgencyProgram>;
 export declare const _multilineCommentParser: Parser<string[]>;
 export declare const multilineCommentParser: Parser<string[][]>;
 export declare const normalizeCode: (code: string) => string;
-export declare function _parseAgency(input: string, verbose?: boolean): ParserResult<AgencyProgram>;
-export declare function parseAgency(input: string, verbose?: boolean): ParserResult<AgencyProgram>;
+export declare function _parseAgency(input: string, config?: AgencyConfig): ParserResult<AgencyProgram>;
+export declare function parseAgency(input: string, config?: AgencyConfig): ParserResult<AgencyProgram>;

package/dist/lib/parser.js

@@ -1,4 +1,4 @@
-import { anyChar, between, capture, eof, many, or, search, seqC, set, str, success, trace, setInputStr, TarsecError, failure, } from "tarsec";
+import { anyChar, between, capture, eof, many, or, search, seqC, set, str, success, trace, setInputStr, TarsecError, failure, setTraceHost, setTraceId, } from "tarsec";
 import { accessExpressionParser } from "./parsers/access.js";
 import { commentParser } from "./parsers/comment.js";
 import { assignmentParser, functionParser, graphNodeParser, ifParser, messageThreadParser, timeBlockParser, whileLoopParser, } from "./parsers/function.js";
@@ -11,6 +11,7 @@ import { specialVarParser } from "./parsers/specialVar.js";
 import { usesToolParser } from "./parsers/tools.js";
 import { typeAliasParser, typeHintParser } from "./parsers/typeHints.js";
 import { skillParser } from "./parsers/skill.js";
+import { nanoid } from "nanoid";
 export const agencyNode = (input) => {
     const parser = many(trace("agencyParser", or(usesToolParser, importNodeStatmentParser, importToolStatmentParser, importStatmentParser, graphNodeParser, typeAliasParser, ifParser, whileLoopParser, typeHintParser, matchBlockParser, timeBlockParser, messageThreadParser, skillParser, streamingPromptLiteralParser, functionParser, returnStatementParser, specialVarParser, accessExpressionParser, assignmentParser, llmPromptFunctionCallParser, functionCallParser, commentParser, newLineParser)));
     return parser(input);
@@ -28,7 +29,7 @@ export const normalizeCode = (code) => {
         .map((line) => line.trim())
         .join("\n");
 };
-export function _parseAgency(input, verbose = false) {
+export function _parseAgency(input, config = {}) {
     // get rid of all multiline comments
     const normalized = normalizeCode(input);
     if (normalized.trim().length === 0) {
@@ -38,12 +39,16 @@ export function _parseAgency(input, verbose = false) {
         }, "");
     }
     setInputStr(normalized);
+    if (config.tarsecTraceHost) {
+        setTraceHost("http://localhost:1465");
+        setTraceId(nanoid());
+    }
     const result = agencyParser(normalized);
     return result;
 }
-export function parseAgency(input, verbose = false) {
+export function parseAgency(input, config = {}) {
     try {
-        return _parseAgency(input, verbose);
+        return _parseAgency(input, config);
     }
     catch (error) {
         if (error instanceof TarsecError) {

package/dist/lib/parsers/function.js

@@ -1,4 +1,4 @@
-import { capture, captureCaptures, char, debug, many, many1, many1Till, many1WithJoin, map, optional, or, sepBy, seqC, set, space, spaces, str, succeed, trace, } from "tarsec";
+import { capture, captureCaptures, char, debug, fail, many, parseError, many1, many1Till, many1WithJoin, map, optional, or, sepBy, seqC, set, space, spaces, str, succeed, trace, } from "tarsec";
 import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { commentParser } from "./comment.js";
 import { functionCallParser, llmPromptFunctionCallParser, streamingPromptLiteralParser, } from "./functionCall.js";
@@ -81,8 +81,8 @@ export const ifParser = (input) => {
 export const whileLoopParser = trace("whileLoopParser", seqC(set("type", "whileLoop"), str("while"), optionalSpaces, char("("), optionalSpaces, capture(or(indexAccessParser, functionCallParser, accessExpressionParser, literalParser), "condition"), optionalSpaces, char(")"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpaces, char("}")));
 export const functionParameterParserWithTypeHint = trace("functionParameterParserWithTypeHint", seqC(set("type", "functionParameter"), capture(many1WithJoin(varNameChar), "name"), optionalSpaces, char(":"), optionalSpaces, capture(variableTypeParser, "typeHint")));
 export const functionParameterParser = trace("functionParameterParser", seqC(set("type", "functionParameter"), capture(many1WithJoin(varNameChar), "name")));
-export const functionReturnTypeParser = trace("functionReturnTypeParser", seqC(char(":"), optionalSpaces, captureCaptures(variableTypeParser)));
-export const _functionParser = trace("_functionParser", seqC(set("type", "function"), str("def"), many1(space), capture(many1Till(char("(")), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpacesOrNewline, capture(or(docStringParser, succeed(undefined)), "docString"), optionalSpacesOrNewline, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
+export const functionReturnTypeParser = trace("functionReturnTypeParser", seqC(char(":"), optionalSpaces, captureCaptures(or(variableTypeParser, parseError("Invalid return type", fail("error"))))));
+export const _functionParser = trace("_functionParser", seqC(set("type", "function"), str("def"), many1(space), capture(many1Till(char("(")), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), captureCaptures(parseError("Expected function body", optionalSpaces, char("{"), optionalSpacesOrNewline, capture(or(docStringParser, succeed(undefined)), "docString"), optionalSpacesOrNewline, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon))));
 export const asyncFunctionParser = (input) => {
     const parser = trace("asyncFunctionParser", seqC(str("async"), spaces, captureCaptures(_functionParser)));
     const mappedParser = map(parser, (result) => ({