agency-lang 0.0.50 → 0.0.52

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

@@ -1,22 +1,26 @@
 import { SpecialVar } from "../types/specialVar.js";
 import { AgencyComment, AgencyProgram, Assignment, Literal, NewLine, PromptLiteral, TypeAlias, TypeHint, VariableType } from "../types.js";
+import { AwaitStatement } from "../types/await.js";
+import { TimeBlock } from "../types/timeBlock.js";
 import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
 import { GraphNodeDefinition } from "../types/graphNode.js";
+import { IfElse } from "../types/ifElse.js";
 import { ImportNodeStatement, ImportStatement, ImportToolStatement } from "../types/importStatement.js";
 import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
 import { WhileLoop } from "../types/whileLoop.js";
-import { IfElse } from "../types/ifElse.js";
 import { BaseGenerator } from "./baseGenerator.js";
-import { TimeBlock } from "../types/timeBlock.js";
-import { AwaitStatement } from "../types/await.js";
+import { AgencyConfig } from "../config.js";
+import { MessageThread } from "../types/messageThread.js";
 export declare class AgencyGenerator extends BaseGenerator {
     private indentLevel;
     private indentSize;
-    constructor();
+    constructor(args?: {
+        config?: AgencyConfig;
+    });
     private indent;
     private increaseIndent;
     private decreaseIndent;
@@ -40,6 +44,7 @@ export declare class AgencyGenerator extends BaseGenerator {
     protected processAgencyArray(node: AgencyArray): string;
     protected processAgencyObject(node: AgencyObject): string;
     protected processAccessExpression(node: AccessExpression): string;
+    protected asyncAwaitPrefix(code: string, async?: boolean): string;
     protected processDotProperty(node: DotProperty): string;
     protected processIndexAccess(node: IndexAccess): string;
     protected processDotFunctionCall(node: DotFunctionCall): string;
@@ -58,5 +63,6 @@ export declare class AgencyGenerator extends BaseGenerator {
     private indentStr;
     protected processAwaitStatement(node: AwaitStatement): string;
     protected processNewLine(_node: NewLine): string;
+    protected processMessageThread(node: MessageThread): string;
 }
 export declare function generateAgency(program: AgencyProgram): string;

package/dist/lib/backends/agencyGenerator.js

@@ -3,8 +3,8 @@ import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
 export class AgencyGenerator extends BaseGenerator {
     indentLevel = 0;
     indentSize = 2;
-    constructor() {
-        super();
+    constructor(args = {}) {
+        super(args);
     }
     indent(level = this.indentLevel) {
         return " ".repeat(level * this.indentSize);
@@ -89,7 +89,7 @@ export class AgencyGenerator extends BaseGenerator {
             case "multiLineString":
                 return this.generateMultiLineStringLiteral(literal);
             case "prompt":
-                return this.generatePromptLiteral(literal);
+                return this.indentStr(this.generatePromptLiteral(literal));
             default:
                 return "";
         }
@@ -166,8 +166,15 @@ export class AgencyGenerator extends BaseGenerator {
         const returnTypeStr = node.returnType
             ? ": " + variableTypeToString(node.returnType, this.typeAliases)
             : "";
+        let asyncPrefix = "";
+        if (node.async === true) {
+            asyncPrefix = "async ";
+        }
+        else if (node.async === false) {
+            asyncPrefix = "sync ";
+        }
         // Start function definition
-        let result = this.indentStr(`def ${functionName}(${params})${returnTypeStr} {\n`);
+        let result = this.indentStr(`${asyncPrefix}def ${functionName}(${params})${returnTypeStr} {\n`);
         // Process body with increased indentation
         this.increaseIndent();
         if (node.docString) {
@@ -197,7 +204,13 @@ export class AgencyGenerator extends BaseGenerator {
         const args = node.arguments.map((arg) => {
             return this.processNode(arg).trim();
         });
-        const asyncPrefix = node.async ? "async " : "";
+        let asyncPrefix = "";
+        if (node.async === true) {
+            asyncPrefix = "async ";
+        }
+        else if (node.async === false) {
+            asyncPrefix = "await ";
+        }
         return `${asyncPrefix}${node.functionName}(${args.join(", ")})`;
     }
     // Data structures
@@ -222,29 +235,43 @@ export class AgencyGenerator extends BaseGenerator {
     }
     // Access expressions
     processAccessExpression(node) {
+        let code = "";
         switch (node.expression.type) {
             case "dotProperty":
-                return this.processDotProperty(node.expression);
+                code = this.processDotProperty(node.expression);
+                break;
             case "indexAccess":
-                return this.processIndexAccess(node.expression);
+                code = this.processIndexAccess(node.expression);
+                break;
             case "dotFunctionCall":
-                return this.processDotFunctionCall(node.expression);
+                code = this.processDotFunctionCall(node.expression);
+                break;
         }
+        return this.indentStr(this.asyncAwaitPrefix(code, node.async));
+    }
+    asyncAwaitPrefix(code, async) {
+        if (async === true) {
+            return `async ${code}`;
+        }
+        else if (async === false) {
+            return `await ${code}`;
+        }
+        return code;
     }
     processDotProperty(node) {
         let objectCode = this.processNode(node.object);
         objectCode = objectCode.trim();
-        return this.indentStr(`${objectCode}.${node.propertyName}`);
+        return `${objectCode}.${node.propertyName}`;
     }
     processIndexAccess(node) {
         const arrayCode = this.processNode(node.array).trim();
         const indexCode = this.processNode(node.index).trim();
-        return this.indentStr(`${arrayCode}[${indexCode}]`);
+        return `${arrayCode}[${indexCode}]`;
     }
     processDotFunctionCall(node) {
         const objectCode = this.processNode(node.object).trim();
         const functionCallCode = this.generateFunctionCallExpression(node.functionCall);
-        return this.indentStr(`${objectCode}.${functionCallCode}`);
+        return `${objectCode}.${functionCallCode}`;
     }
     // Control flow
     processMatchBlock(node) {
@@ -370,6 +397,17 @@ export class AgencyGenerator extends BaseGenerator {
     processNewLine(_node) {
         return "\n";
     }
+    processMessageThread(node) {
+        this.increaseIndent();
+        const bodyCodes = [];
+        for (const stmt of node.body) {
+            bodyCodes.push(this.processNode(stmt));
+        }
+        this.decreaseIndent();
+        const bodyCodeStr = bodyCodes.join("");
+        const threadType = node.subthread ? "subthread" : "thread";
+        return this.indentStr(`${threadType} {\n${bodyCodeStr}${this.indentStr("}")}`);
+    }
 }
 export function generateAgency(program) {
     const generator = new AgencyGenerator();

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

@@ -12,6 +12,8 @@ import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
 import { WhileLoop } from "../types/whileLoop.js";
+import { AgencyConfig } from "../config.js";
+import { MessageThread } from "../types/messageThread.js";
 type Scope = GlobalScope | FunctionScope | NodeScope;
 type GlobalScope = {
     type: "global";
@@ -40,16 +42,24 @@ export declare class BaseGenerator {
     protected importedTools: ImportToolStatement[];
     protected functionDefinitions: Record<string, FunctionDefinition>;
     protected currentScope: Scope[];
+    protected program: AgencyProgram | null;
+    protected agencyConfig: AgencyConfig;
+    constructor({ config }: {
+        config?: AgencyConfig;
+    });
+    configDefaults(): Partial<AgencyConfig>;
     generate(program: AgencyProgram): {
         output: string;
     };
     addIfNonEmpty(str: string, lines: string[]): void;
+    protected preprocessAST(): void;
     protected generateBuiltins(): string;
     protected processTypeAlias(node: TypeAlias): string;
     protected processTypeHint(node: TypeHint): string;
     protected collectFunctionSignature(node: FunctionDefinition): void;
     protected processGraphNodeName(node: GraphNodeDefinition): void;
     protected processNode(node: AgencyNode): string;
+    protected processMessageThread(node: MessageThread): string;
     protected processNewLine(_node: NewLine): string;
     protected processAwaitStatement(node: AwaitStatement): string;
     protected processTimeBlock(node: TimeBlock, timingVarName: string): string;
@@ -86,6 +96,6 @@ export declare class BaseGenerator {
     protected getScopeVar(): string;
     protected generateScopedVariableName(variableName: string): string;
     protected isImportedTool(functionName: string): boolean;
-    protected isInternalFunction(functionName: string): boolean;
+    protected isAgencyFunction(functionName: string): boolean;
 }
 export {};

package/dist/lib/backends/baseGenerator.js

@@ -1,3 +1,4 @@
+import { mergeDeep } from "../utils.js";
 export class BaseGenerator {
     typeHints = {};
     graphNodes = [];
@@ -18,7 +19,16 @@ export class BaseGenerator {
     // TODO also save return types, check if used as a tool, return type cannot be null/void/undefined
     functionDefinitions = {};
     currentScope = [{ type: "global" }];
+    program = null;
+    agencyConfig = {};
+    constructor({ config }) {
+        this.agencyConfig = mergeDeep(this.configDefaults(), config || {});
+    }
+    configDefaults() {
+        return {};
+    }
     generate(program) {
+        this.program = program;
         // Pass 1: Collect all type aliases
         for (const node of program.nodes) {
             if (node.type === "typeAlias") {
@@ -59,6 +69,12 @@ export class BaseGenerator {
                 this.globalScopedVariables.push(node.variableName);
             }
         }
+        /* For each function, mark whether it is async or not.
+           A function has to be run synchronously if
+           - it or any of its child functions could throw an interrupt
+           - it or any of its child functions performs IO.
+        */
+        this.preprocessAST();
         // Pass 7: Process all nodes and generate code
         for (const node of program.nodes) {
             const result = this.processNode(node);
@@ -81,6 +97,9 @@ export class BaseGenerator {
             lines.push(str);
         }
     }
+    preprocessAST() {
+        // subclasses can implement this if their target language has async functions
+    }
     generateBuiltins() {
         return "";
     }
@@ -150,14 +169,19 @@ export class BaseGenerator {
                 return this.processIndexAccess(node);
             case "timeBlock":
                 return this.processTimeBlock(node, `__defaultTimeblockName`);
-            case "awaitStatement":
-                return this.processAwaitStatement(node);
             case "newLine":
                 return this.processNewLine(node);
+            case "rawCode":
+                return node.value;
+            case "messageThread":
+                return this.processMessageThread(node);
             default:
                 throw new Error(`Unhandled Agency node type: ${node.type}`);
         }
     }
+    processMessageThread(node) {
+        return "processMessageThread not implemented";
+    }
     processNewLine(_node) {
         return "";
     }
@@ -295,10 +319,10 @@ export class BaseGenerator {
             .flat()
             .includes(functionName);
     }
-    /* Internal function means the user defined this function in an Agency file,
+    /* Agency function means the user defined this function in an Agency file,
       as opposed to an external function, which was defined in an external TypeScript file
       and imported into Agency. */
-    isInternalFunction(functionName) {
+    isAgencyFunction(functionName) {
         return (!!this.functionDefinitions[functionName] ||
             this.isImportedTool(functionName));
     }

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

@@ -2,6 +2,7 @@ import { AgencyProgram, FunctionCall, TypeHintMap, VariableType } from "../types
 import { GraphNodeDefinition } from "../types/graphNode.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { TypeScriptGenerator } from "./typescriptGenerator.js";
+import { AgencyConfig } from "../config.js";
 export declare class GraphGenerator extends TypeScriptGenerator {
     protected typeHints: TypeHintMap;
     protected generatedStatements: string[];
@@ -11,7 +12,10 @@ export declare class GraphGenerator extends TypeScriptGenerator {
     protected adjacentNodes: Record<string, string[]>;
     protected currentAdjacentNodes: string[];
     protected isInsideGraphNode: boolean;
-    constructor();
+    constructor(args?: {
+        config?: AgencyConfig;
+    });
+    configDefaults(): Partial<AgencyConfig>;
     protected processReturnStatement(node: ReturnStatement): string;
     protected processGraphNodeName(node: GraphNodeDefinition): void;
     protected processGraphNode(node: GraphNodeDefinition): string;
@@ -23,4 +27,4 @@ export declare class GraphGenerator extends TypeScriptGenerator {
     private agencyFileToDefaultImportName;
     protected postprocess(): string;
 }
-export declare function generateGraph(program: AgencyProgram): string;
+export declare function generateGraph(program: AgencyProgram, config?: AgencyConfig): string;

package/dist/lib/backends/graphGenerator.js

@@ -8,6 +8,7 @@ import * as renderStartNode from "../templates/backends/graphGenerator/startNode
 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 = {};
     generatedStatements = [];
@@ -17,8 +18,21 @@ export class GraphGenerator extends TypeScriptGenerator {
     adjacentNodes = {};
     currentAdjacentNodes = [];
     isInsideGraphNode = false;
-    constructor() {
-        super();
+    constructor(args = {}) {
+        super(args);
+    }
+    configDefaults() {
+        return {
+            log: {
+                host: "https://statelog.adit.io",
+                projectId: "agency-lang",
+                debugMode: false,
+            },
+            client: {
+                logLevel: "warn",
+                defaultModel: "gpt-4o-mini",
+            },
+        };
     }
     processReturnStatement(node) {
         if (!this.isInsideGraphNode) {
@@ -130,9 +144,13 @@ export class GraphGenerator extends TypeScriptGenerator {
       return "generateLiteral not implemented";
     } */
     generateImports() {
-        let arr = [
+        const arr = [
             renderImports.default({
-                nodes: JSON.stringify(this.graphNodes.map((n) => n.nodeName)),
+                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",
             }),
         ];
         arr.push(builtinTools.default({}));
@@ -187,7 +205,9 @@ export class GraphGenerator extends TypeScriptGenerator {
         return lines.join("\n");
     }
 }
-export function generateGraph(program) {
-    const generator = new GraphGenerator();
-    return generator.generate(program).output;
+export function generateGraph(program, config) {
+    const preprocessor = new TypescriptPreprocessor(program, config);
+    const preprocessedProgram = preprocessor.preprocess();
+    const generator = new GraphGenerator({ config });
+    return generator.generate(preprocessedProgram).output;
 }

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

@@ -1,7 +1,3 @@
-/**
- * Maps Agency built-in function names to TypeScript equivalents
- */
-export declare const BUILTIN_FUNCTIONS: Record<string, string>;
 /**
  * Maps an Agency function name to its TypeScript equivalent
  * Returns the original name if not a built-in

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

@@ -1,23 +1,7 @@
 import * as builtinFunctionsInput from "../../templates/backends/typescriptGenerator/builtinFunctions/input.js";
 import * as builtinFunctionsRead from "../../templates/backends/typescriptGenerator/builtinFunctions/read.js";
-import * as builtinFunctionsReadImage from "../../templates/backends/typescriptGenerator/builtinFunctions/readImage.js";
 import * as builtinFunctionsFetchJSON from "../../templates/backends/typescriptGenerator/builtinFunctions/fetchJSON.js";
-import * as builtinFunctionsFetch from "../../templates/backends/typescriptGenerator/builtinFunctions/fetch.js";
-import * as builtinFunctionsSleep from "../../templates/backends/typescriptGenerator/builtinFunctions/sleep.js";
-/**
- * Maps Agency built-in function names to TypeScript equivalents
- */
-export const BUILTIN_FUNCTIONS = {
-    print: "console.log",
-    input: "_builtinInput",
-    read: "_builtinRead",
-    readImage: "_builtinReadImage",
-    write: "fs.writeFileSync",
-    fetch: "_builtinFetch",
-    fetchJSON: "_builtinFetchJSON",
-    fetchJson: "_builtinFetchJSON",
-    sleep: "_builtinSleep",
-};
+import { BUILTIN_FUNCTIONS } from "../../config.js";
 /**
  * Maps an Agency function name to its TypeScript equivalent
  * Returns the original name if not a built-in
@@ -33,26 +17,31 @@ export function generateBuiltinHelpers(functionsUsed) {
     const readFunc = builtinFunctionsRead.default({});
     const fetchJSONFunc = builtinFunctionsFetchJSON.default({});
     const helpers = [];
+    // all included by default, since we don't want to have conditional imports in the generated code
+    /*
     if (functionsUsed.has("input")) {
-        helpers.push(inputFunc);
+      helpers.push(inputFunc);
     }
     if (functionsUsed.has("read")) {
-        helpers.push(readFunc);
+      helpers.push(readFunc);
     }
     if (functionsUsed.has("fetchJSON") || functionsUsed.has("fetchJson")) {
-        helpers.push(fetchJSONFunc);
+      helpers.push(fetchJSONFunc);
     }
     if (functionsUsed.has("fetch")) {
-        const fetchFunc = builtinFunctionsFetch.default({});
-        helpers.push(fetchFunc);
+      const fetchFunc = builtinFunctionsFetch.default({});
+      helpers.push(fetchFunc);
     }
     if (functionsUsed.has("readImage")) {
-        const readImageFunc = builtinFunctionsReadImage.default({});
-        helpers.push(readImageFunc);
-    }
-    if (functionsUsed.has("sleep")) {
+      const readImageFunc = builtinFunctionsReadImage.default({});
+      helpers.push(readImageFunc);
+    } */
+    /*
+    already included by default
+      if (functionsUsed.has("sleep")) {
         const sleepFunc = builtinFunctionsSleep.default({});
         helpers.push(sleepFunc);
-    }
+      }
+     */
     return helpers.join("\n\n");
 }

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

@@ -12,8 +12,13 @@ import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
 import { WhileLoop } from "../types/whileLoop.js";
 import { BaseGenerator } from "./baseGenerator.js";
+import { AgencyConfig } from "../config.js";
+import { MessageThread } from "../types/messageThread.js";
 export declare class TypeScriptGenerator extends BaseGenerator {
-    constructor();
+    protected currentMessageThreadNodeId: string[];
+    constructor(args?: {
+        config?: AgencyConfig;
+    });
     protected generateBuiltins(): string;
     protected processTypeAlias(node: TypeAlias): string;
     protected typeAliasToString(node: TypeAlias): string;
@@ -65,6 +70,7 @@ export declare class TypeScriptGenerator extends BaseGenerator {
     protected processSpecialVar(node: SpecialVar): string;
     protected processTimeBlock(node: TimeBlock, timingVarName: string): string;
     protected processAwaitStatement(node: AwaitStatement): string;
+    protected processMessageThread(node: MessageThread, varName?: string): string;
     protected processBodyAsParts(body: AgencyNode[]): string[];
 }
-export declare function generateTypeScript(program: AgencyProgram): string;
+export declare function generateTypeScript(program: AgencyProgram, config?: AgencyConfig): string;

package/dist/lib/backends/typescriptGenerator.js

@@ -6,6 +6,7 @@ import * as renderFunctionDefinition from "../templates/backends/typescriptGener
 import * as renderInternalFunctionCall from "../templates/backends/typescriptGenerator/internalFunctionCall.js";
 import * as renderFunctionCallAssignment from "../templates/backends/typescriptGenerator/functionCallAssignment.js";
 import * as renderImports from "../templates/backends/typescriptGenerator/imports.js";
+import * as renderMessageThread from "../templates/backends/typescriptGenerator/messageThread.js";
 import * as promptFunction from "../templates/backends/typescriptGenerator/promptFunction.js";
 import * as renderTool from "../templates/backends/typescriptGenerator/tool.js";
 import * as renderToolCall from "../templates/backends/typescriptGenerator/toolCall.js";
@@ -14,10 +15,12 @@ import { BaseGenerator } from "./baseGenerator.js";
 import { generateBuiltinHelpers, mapFunctionName, } from "./typescriptGenerator/builtins.js";
 import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
 import { DEFAULT_SCHEMA, mapTypeToZodSchema, } from "./typescriptGenerator/typeToZodSchema.js";
+import { TypescriptPreprocessor } from "../preprocessors/typescriptPreprocessor.js";
 const DEFAULT_PROMPT_NAME = "__promptVar";
 export class TypeScriptGenerator extends BaseGenerator {
-    constructor() {
-        super();
+    currentMessageThreadNodeId = ["0"];
+    constructor(args = {}) {
+        super(args);
     }
     generateBuiltins() {
         return generateBuiltinHelpers(this.functionsUsed);
@@ -156,6 +159,10 @@ export class TypeScriptGenerator extends BaseGenerator {
             const code = this.processTimeBlock(value, timingVarName);
             return code;
         }
+        else if (value.type === "messageThread") {
+            const varName = `${this.getScopeVar()}.${variableName}`;
+            return this.processMessageThread(value, varName);
+        }
         else {
             // Direct assignment for other literal types
             const code = this.processNode(value);
@@ -276,24 +283,18 @@ export class TypeScriptGenerator extends BaseGenerator {
             if (arg.type === "functionCall") {
                 this.functionsUsed.add(arg.functionName);
                 return this.generateFunctionCallExpression(arg);
-                /*       } else if (arg.type === "accessExpression") {
-                return this.processAccessExpression(arg);
-              } else if (arg.type === "indexAccess") {
-                return this.processIndexAccess(arg);
-         */
             }
             else {
-                //        return this.generateLiteral(arg);
                 return this.processNode(arg);
             }
         });
         let argsString = "";
-        if (this.isInternalFunction(node.functionName)) {
+        if (this.isAgencyFunction(node.functionName)) {
             argsString = parts.join(", ");
             const metadata = `{
         statelogClient,
         graph: __graph,
-        messages: __messages,
+        messages: __self.messages_${this.currentMessageThreadNodeId.at(-1)}.getMessages(),
       }`;
             return renderInternalFunctionCall.default({
                 functionName,
@@ -305,7 +306,8 @@ export class TypeScriptGenerator extends BaseGenerator {
         else {
             // must be a builtin function or imported function
             argsString = parts.join(", ");
-            return `${functionName}(${argsString})`;
+            const awaitStr = node.async ? "await " : "";
+            return `${awaitStr}${functionName}(${argsString})`;
         }
     }
     generateLiteral(literal) {
@@ -393,7 +395,6 @@ export class TypeScriptGenerator extends BaseGenerator {
             value: "string",
         };
         const zodSchema = mapTypeToZodSchema(_variableType, this.typeAliases);
-        //console.log("Generated Zod schema for variable", variableName, "Variable type:", variableType, ":", zodSchema, "aliases:", this.typeAliases, "hints:", this.typeHints);
         const typeString = variableTypeToString(_variableType, this.typeAliases);
         // Build prompt construction code
         const promptCode = this.buildPromptString(prompt.segments, this.typeHints);
@@ -423,7 +424,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             .join("\n");
         const clientConfig = prompt.config ? this.processNode(prompt.config) : "{}";
         const metadataObj = `{
-      messages: __messages,
+      messages: __self.messages_${this.currentMessageThreadNodeId.at(-1)}.getMessages(),
     }`;
         this.toolsUsed = []; // reset after use
         const scopedFunctionArgs = functionArgs.map((arg) => this.generateScopedVariableName(arg));
@@ -440,6 +441,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             clientConfig,
             nodeContext: this.getCurrentScope().type === "node",
             isStreaming: prompt.isStreaming || false,
+            isAsync: prompt.async || false,
         });
     }
     processImportStatement(node) {
@@ -490,7 +492,7 @@ export class TypeScriptGenerator extends BaseGenerator {
                     value,
                 });
             case "messages":
-                return `__messages = ${value};\n`;
+                return `__self.messages_${this.currentMessageThreadNodeId.at(-1)}.setMessages(${value});\n`;
             default:
                 throw new Error(`Unhandled SpecialVar name: ${node.name}`);
         }
@@ -511,6 +513,23 @@ export class TypeScriptGenerator extends BaseGenerator {
         const code = this.processNode(node.expression);
         return `await ${code}`;
     }
+    processMessageThread(node, varName) {
+        this.currentMessageThreadNodeId.push(node.nodeId || "0");
+        const bodyCodes = [];
+        for (const stmt of node.body) {
+            bodyCodes.push(this.processNode(stmt));
+        }
+        const bodyCodeStr = bodyCodes.join("\n");
+        this.currentMessageThreadNodeId.pop();
+        return renderMessageThread.default({
+            bodyCode: bodyCodeStr,
+            hasVar: !!varName,
+            varName,
+            isSubthread: node.subthread,
+            nodeId: node.nodeId || "0",
+            parentNodeId: node.parentNodeId || "0",
+        });
+    }
     /* This generates the body of a node or function separated into multiple parts.
     You can think of a part as roughly corresponding to a single statement
     (although some statements don't need their own parts, such as a newlines or type definitions).
@@ -544,7 +563,9 @@ export class TypeScriptGenerator extends BaseGenerator {
         return bodyCode;
     }
 }
-export function generateTypeScript(program) {
-    const generator = new TypeScriptGenerator();
-    return generator.generate(program).output;
+export function generateTypeScript(program, config) {
+    const preprocessor = new TypescriptPreprocessor(program, config);
+    const preprocessedProgram = preprocessor.preprocess();
+    const generator = new TypeScriptGenerator({ config });
+    return generator.generate(preprocessedProgram).output;
 }

package/dist/lib/config.d.ts

@@ -1,2 +1,48 @@
 import { AgencyNode } from "./types.js";
 export declare const TYPES_THAT_DONT_TRIGGER_NEW_PART: AgencyNode["type"][];
+/**
+ * Maps Agency built-in function names to TypeScript equivalents
+ */
+export declare const BUILTIN_FUNCTIONS: Record<string, string>;
+export declare const BUILTIN_FUNCTIONS_TO_ASYNC: Record<string, boolean>;
+/**
+ * Configuration options for the Agency compiler
+ */
+export interface AgencyConfig {
+    verbose?: boolean;
+    outDir?: string;
+    /**
+     * Array of AST node types to exclude from code generation
+     * Example: ["comment", "typeHint"]
+     */
+    excludeNodeTypes?: string[];
+    /**
+     * Array of built-in function names to exclude from code generation
+     * Example: ["fetch", "write"]
+     */
+    excludeBuiltinFunctions?: string[];
+    /**
+     * Array of domains allowed for fetch operations
+     * If specified, only these domains can be fetched
+     * Example: ["api.example.com", "data.mysite.com"]
+     */
+    allowedFetchDomains?: string[];
+    /**
+     * Array of domains disallowed for fetch operations
+     * These domains will throw an error if fetch is attempted
+     * If both allowed and disallowed are set, takes the intersection
+     * (only allowed domains, minus disallowed ones)
+     * Example: ["malicious.com", "blocked.site.com"]
+     */
+    disallowedFetchDomains?: string[];
+    /** Statelog config */
+    log?: Partial<{
+        host: string;
+        projectId: string;
+        debugMode: boolean;
+    }>;
+    client?: Partial<{
+        logLevel: "error" | "warn" | "info" | "debug";
+        defaultModel: string;
+    }>;
+}