agency-lang 0.0.21 → 0.0.22

package/dist/lib/backends/graphGenerator.js

@@ -1,7 +1,7 @@
 import * as builtinTools from "../templates/backends/graphGenerator/builtinTools.js";
 import * as renderConditionalEdge from "../templates/backends/graphGenerator/conditionalEdge.js";
 import * as goToNode from "../templates/backends/graphGenerator/goToNode.js";
-import * as graphNode from "../templates/backends/graphGenerator/graphNode.js";
+import * as renderGraphNode from "../templates/backends/graphGenerator/graphNode.js";
 import * as renderImports from "../templates/backends/graphGenerator/imports.js";
 import * as renderStartNode from "../templates/backends/graphGenerator/startNode.js";
 import * as renderRunNodeFunction from "../templates/backends/graphGenerator/runNodeFunction.js";
@@ -20,183 +20,6 @@ export class GraphGenerator extends TypeScriptGenerator {
     constructor() {
         super();
     }
-    /*
-    protected generateBuiltins(): string {
-      return "";
-    }
-  
-    protected processTypeAlias(node: TypeAlias): void {
-      // subclasses implement this
-    }
-  
-    protected processTypeHint(node: TypeHint): void {
-      // subclasses implement this
-    }
-  
-    protected processNode(node: AgencyNode): string {
-      switch (node.type) {
-        case "typeHint":
-        case "typeAlias":
-          return "";
-        case "assignment":
-          return this.processAssignment(node);
-        case "function":
-          return this.processFunctionDefinition(node);
-        case "functionCall":
-          return this.processFunctionCall(node);
-        case "accessExpression":
-          return this.processAccessExpression(node);
-        case "comment":
-          return this.processComment(node);
-        case "matchBlock":
-          return this.processMatchBlock(node);
-        case "number":
-        case "string":
-        case "variableName":
-        case "prompt":
-          // Standalone literals at top level
-          return this.generateLiteral(node);
-        case "returnStatement":
-          return this.processReturnStatement(node);
-        case "agencyArray":
-          return this.processAgencyArray(node);
-        case "agencyObject":
-          return this.processAgencyObject(node);
-      }
-    }
-  
-    protected processAgencyObject(node: AgencyObject): string {
-      return "<processAgencyObject not implemented>";
-    }
-  
-    protected processAgencyArray(node: AgencyArray): string {
-      return "<processAgencyArray not implemented>";
-    }
-  
-    protected processComment(node: AgencyComment): string {
-      return "processComment not implemented";
-    }
-  
-    
-  
-    protected processAccessExpression(node: AccessExpression): string {
-      switch (node.expression.type) {
-        case "dotProperty":
-          return this.processDotProperty(node.expression);
-        case "indexAccess":
-          return this.processIndexAccess(node.expression);
-        case "dotFunctionCall":
-          return this.processDotFunctionCall(node.expression);
-      }
-    }
-  
-    protected processMatchBlock(node: MatchBlock): string {
-      return "processMatchBlock not implemented";
-    }
-  
-    protected processDotProperty(node: DotProperty): string {
-      return "processDotProperty not implemented";
-    }
-  
-    protected processDotFunctionCall(node: DotFunctionCall): string {
-      return "processDotFunctionCall not implemented";
-    }
-  
-    protected processIndexAccess(node: IndexAccess): string {
-      return "processIndexAccess not implemented";
-    } */
-    /*   protected processAssignment(node: Assignment): string {
-      switch (node.value.type) {
-        case "prompt":
-          return this.processPromptLiteral(node.variableName, node.value);
-        default:
-          return this.createNode(
-            node.variableName,
-            this.processNode(wrapInReturn(node.value))
-          );
-      }
-    }
-  
-    protected createNode(name: string, body: string): string {
-      this.graphNodes.push(name);
-      return renderNode.default({
-        name,
-        body,
-      });
-    }
-  
-    protected processPromptLiteral(
-      variableName: string,
-      node: PromptLiteral
-    ): string {
-      this.graphNodes.push(variableName);
-  
-      // Validate all interpolated variables are in scope
-      const interpolatedVars = node.segments
-        .filter((s) => s.type === "interpolation")
-        .map((s) => (s as InterpolationSegment).variableName);
-  
-      for (const varName of interpolatedVars) {
-        if (!this.graphNodes.includes(varName)) {
-          throw new Error(
-            `Variable '${varName}' used in prompt interpolation but not defined. ` +
-              `Referenced in assignment to '${variableName}'.`
-          );
-        }
-      }
-  
-      const promptFunction = this.generatePromptFunction({
-        variableName,
-        functionArgs: interpolatedVars,
-        prompt: node,
-      });
-      const argsStr = interpolatedVars.join(", ");
-  
-      return promptNode.default({
-        name: variableName,
-        promptFunction,
-        argsStr,
-      });
-    }
-  
-    generatePromptFunction({
-      variableName,
-      functionArgs = [],
-      prompt,
-    }: {
-      variableName: string;
-      functionArgs: string[];
-      prompt: PromptLiteral;
-    }): string {
-      // Generate async function for prompt-based assignment
-      const variableType = this.typeHints[variableName] || {
-        type: "primitiveType" as const,
-        value: "string",
-      };
-  
-      const zodSchema = mapTypeToZodSchema(variableType, this.typeAliases);
-      const typeString = variableTypeToString(variableType, this.typeAliases);
-  
-      // Build prompt construction code
-      const promptCode = this.buildPromptString(prompt.segments, this.typeHints);
-      const argsStr = functionArgs
-        .map(
-          (arg) =>
-            `${arg}: ${variableTypeToString(
-              this.typeHints[arg] || { type: "primitiveType", value: "string" },
-              this.typeAliases
-            )}`
-        )
-        .join(", ");
-      return promptFunction.default({
-        variableName,
-        argsStr,
-        typeString,
-        promptCode,
-        zodSchema,
-      });
-    }
-   */
     processReturnStatement(node) {
         if (!this.isInsideGraphNode) {
             return super.processReturnStatement(node);
@@ -216,15 +39,17 @@ export class GraphGenerator extends TypeScriptGenerator {
     }
     processGraphNode(node) {
         const { nodeName, body, parameters } = node;
-        if (parameters.length > 1) {
-            throw new Error(`Graph node '${nodeName}' has more than one parameter. Only one parameter is supported for now.`);
-        }
+        /* if (parameters.length > 1) {
+          throw new Error(
+            `Graph node '${nodeName}' has more than one parameter. Only one parameter is supported for now.`,
+          );
+        } */
         this.adjacentNodes[nodeName] = [];
         this.currentAdjacentNodes = [];
         this.functionScopedVariables = [];
         this.isInsideGraphNode = true;
-        if (parameters.length > 0) {
-            this.functionScopedVariables.push(parameters[0]);
+        for (const param of parameters) {
+            this.functionScopedVariables.push(param.name);
         }
         const bodyCode = [];
         for (const stmt of body) {
@@ -233,14 +58,15 @@ export class GraphGenerator extends TypeScriptGenerator {
         this.functionScopedVariables = [];
         this.adjacentNodes[nodeName] = [...this.currentAdjacentNodes];
         this.isInsideGraphNode = false;
-        return graphNode.default({
+        const paramNames = "{" + parameters.map((p) => p.name).join(", ") + "}";
+        return renderGraphNode.default({
             name: nodeName,
             /* returnType: node.returnType
               ? variableTypeToString(node.returnType, this.typeAliases)
               : "any", */
             body: bodyCode.join("\n"),
             hasParam: parameters.length > 0,
-            paramName: parameters[0] || "input",
+            paramNames,
         });
     }
     processFunctionCall(node) {
@@ -272,9 +98,16 @@ export class GraphGenerator extends TypeScriptGenerator {
                 //        return this.generateLiteral(arg);
             }
         });
-        const argsString = parts.join(", ");
+        const argNames = this.graphNodes
+            .find((n) => n.nodeName === node.functionName)
+            ?.parameters.map((p) => p.name) || [];
+        const pairedArgs = argNames.map((name, index) => {
+            return `${name}: ${parts[index]}`;
+        });
+        const argsString = "{" + pairedArgs.join(", ") + "}";
         return goToNode.default({
             nodeName: functionName,
+            hasData: parts.length > 0,
             data: argsString,
         });
     } /*

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

@@ -3,6 +3,7 @@ import * as builtinFunctionsRead from "../../templates/backends/typescriptGenera
 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
  */
@@ -15,6 +16,7 @@ export const BUILTIN_FUNCTIONS = {
     fetch: "_builtinFetch",
     fetchJSON: "_builtinFetchJSON",
     fetchJson: "_builtinFetchJSON",
+    sleep: "_builtinSleep",
 };
 /**
  * Maps an Agency function name to its TypeScript equivalent
@@ -48,5 +50,9 @@ export function generateBuiltinHelpers(functionsUsed) {
         const readImageFunc = builtinFunctionsReadImage.default({});
         helpers.push(readImageFunc);
     }
+    if (functionsUsed.has("sleep")) {
+        const sleepFunc = builtinFunctionsSleep.default({});
+        helpers.push(sleepFunc);
+    }
     return helpers.join("\n\n");
 }

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

@@ -1,4 +1,4 @@
-import { AgencyComment, AgencyProgram, Assignment, Literal, PromptLiteral, PromptSegment, TypeAlias, TypeHint, TypeHintMap } from "../types.js";
+import { AgencyComment, AgencyProgram, Assignment, Literal, PromptLiteral, PromptSegment, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
 import { SpecialVar } from "../types/specialVar.js";
 import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
@@ -8,7 +8,10 @@ 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";
 export declare class TypeScriptGenerator extends BaseGenerator {
     constructor();
     protected generateBuiltins(): string;
@@ -25,7 +28,7 @@ export declare class TypeScriptGenerator extends BaseGenerator {
     protected processDotFunctionCall(node: DotFunctionCall): string;
     protected processIndexAccess(node: IndexAccess): string;
     protected processAssignment(node: Assignment): string;
-    protected processPromptLiteral(variableName: string, node: PromptLiteral): string;
+    protected processPromptLiteral(variableName: string, variableType: VariableType | undefined, node: PromptLiteral): string;
     protected processTool(node: FunctionDefinition): string;
     protected processUsesTool(node: UsesTool): string;
     /**
@@ -43,16 +46,21 @@ export declare class TypeScriptGenerator extends BaseGenerator {
     protected generateLiteral(literal: Literal): string;
     protected generateImports(): string;
     buildPromptString(segments: PromptSegment[], typeHints: TypeHintMap): string;
+    generateStringLiteral(segments: PromptSegment[]): string;
     /**
      * Generates an async for prompt-based assignments
      */
-    generatePromptFunction({ variableName, functionArgs, prompt, }: {
+    generatePromptFunction({ variableName, variableType, functionArgs, prompt, }: {
         variableName: string;
+        variableType: VariableType | undefined;
         functionArgs: string[];
         prompt: PromptLiteral;
     }): string;
     protected processImportStatement(node: ImportStatement): string;
     protected processWhileLoop(node: WhileLoop): string;
+    protected processIfElse(node: IfElse): string;
     protected processSpecialVar(node: SpecialVar): string;
+    protected processTimeBlock(node: TimeBlock, timingVarName: string): string;
+    protected processAwaitStatement(node: AwaitStatement): string;
 }
 export declare function generateTypeScript(program: AgencyProgram): string;

package/dist/lib/backends/typescriptGenerator.js

@@ -4,8 +4,9 @@ import * as renderFunctionDefinition from "../templates/backends/typescriptGener
 import * as renderImports from "../templates/backends/typescriptGenerator/imports.js";
 import * as promptFunction from "../templates/backends/typescriptGenerator/promptFunction.js";
 import * as renderTool from "../templates/backends/typescriptGenerator/tool.js";
+import * as renderTime from "../templates/backends/typescriptGenerator/builtinFunctions/time.js";
 import * as renderToolCall from "../templates/backends/typescriptGenerator/toolCall.js";
-import { escape, zip } from "../utils.js";
+import { escape, uniq, zip } from "../utils.js";
 import { BaseGenerator } from "./baseGenerator.js";
 import { generateBuiltinHelpers, mapFunctionName, } from "./typescriptGenerator/builtins.js";
 import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
@@ -108,46 +109,59 @@ export class TypeScriptGenerator extends BaseGenerator {
         return accessCode;
     }
     processAssignment(node) {
-        const { variableName, value } = node;
+        const { variableName, typeHint, value } = node;
         // Track this variable as in scope
         this.functionScopedVariables.push(variableName);
+        const typeAnnotation = typeHint
+            ? `: ${variableTypeToString(typeHint, this.typeAliases)}`
+            : "";
         if (value.type === "prompt") {
-            return this.processPromptLiteral(variableName, value);
+            return this.processPromptLiteral(variableName, typeHint, value);
         }
         else if (value.type === "functionCall") {
             // Direct assignment for other literal types
             const code = this.processNode(value);
-            return `const ${variableName} = await ${code.trim()};` + "\n";
+            return (`const ${variableName}${typeAnnotation} = await ${code.trim()};` + "\n");
+        }
+        else if (value.type === "timeBlock") {
+            const timingVarName = variableName;
+            const code = this.processTimeBlock(value, timingVarName);
+            return code;
         }
         else {
             // Direct assignment for other literal types
             const code = this.processNode(value);
-            return `const ${variableName} = ${code.trim()};` + "\n";
+            return `const ${variableName}${typeAnnotation} = ${code.trim()};` + "\n";
         }
     }
     /*
     protected processAgencyArray(node: AgencyArray): string {
       const itemCodes = node.items.map((item) => {
         if (item.type === "functionCall") { */
-    processPromptLiteral(variableName, node) {
+    processPromptLiteral(variableName, variableType, node) {
         // Validate all interpolated variables are in scope
-        const interpolatedVars = node.segments
+        const interpolatedVars = uniq(node.segments
             .filter((s) => s.type === "interpolation")
-            .map((s) => s.variableName);
-        for (const varName of interpolatedVars) {
-            if (!this.functionScopedVariables.includes(varName) &&
-                !this.globalScopedVariables.includes(varName)) {
-                throw new Error(`Variable '${varName}' used in prompt interpolation but not defined. ` +
-                    `Referenced in assignment to '${variableName}'.`);
-            }
-        }
+            .map((s) => s.variableName));
+        /*     for (const varName of interpolatedVars) {
+          if (
+            !this.functionScopedVariables.includes(varName) &&
+            !this.globalScopedVariables.includes(varName)
+          ) {
+            throw new Error(
+              `Variable '${varName}' used in prompt interpolation but not defined. ` +
+                `Referenced in assignment to '${variableName}'.`,
+            );
+          }
+        } */
         const functionCode = this.generatePromptFunction({
             variableName,
+            variableType,
             functionArgs: interpolatedVars,
             prompt: node,
         });
         this.generatedStatements.push(functionCode);
-        const argsStr = interpolatedVars.join(", ");
+        const argsStr = [...interpolatedVars, "__messages"].join(", ");
         // Generate the function call
         return `const ${variableName} = await _${variableName}(${argsStr});` + "\n";
     }
@@ -176,6 +190,10 @@ export class TypeScriptGenerator extends BaseGenerator {
         });
     }
     processUsesTool(node) {
+        const functionDef = this.functionDefinitions[node.toolName];
+        if (functionDef && functionDef.returnType == null) {
+            throw new Error(`Function '${node.toolName}' is being used as a tool but has no return type. Tools must have a return type.`);
+        }
         this.toolsUsed.push(node.toolName);
         return "";
     }
@@ -211,6 +229,12 @@ export class TypeScriptGenerator extends BaseGenerator {
         }
      */ this.functionsUsed.add(node.functionName);
         const functionCallCode = this.generateFunctionCallExpression(node);
+        // Check if this is a built-in function that needs await
+        const mappedName = mapFunctionName(node.functionName);
+        const isBuiltinFunction = mappedName !== node.functionName;
+        if (isBuiltinFunction) {
+            return `await ${functionCallCode}`;
+        }
         return functionCallCode;
     }
     /**
@@ -235,7 +259,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             }
         });
         let argsString = "";
-        const paramNames = this.functionSignatures[node.functionName];
+        const paramNames = this.functionDefinitions[node.functionName]?.parameters.map((p) => p.name) || null;
         if (paramNames) {
             const partsWithNames = zip(paramNames, parts).map(([paramName, part]) => {
                 return `${paramName}: ${part}`;
@@ -256,7 +280,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             case "number":
                 return literal.value;
             case "string":
-                return `"${escape(literal.value)}"`;
+                return this.generateStringLiteral(literal.segments);
             case "multiLineString":
                 return `\`${escape(literal.value)}\``;
             case "variableName":
@@ -284,7 +308,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             }
             else {
                 // Interpolation segment
-                const varName = segment.variableName;
+                const varName = segment.variableName.replace(".", "_");
                 const varType = typeHints[varName];
                 // Serialize complex types to JSON
                 if (varType && varType.type === "arrayType") {
@@ -297,23 +321,38 @@ export class TypeScriptGenerator extends BaseGenerator {
         }
         return "`" + promptParts.join("") + "`";
     }
+    generateStringLiteral(segments) {
+        const stringParts = [];
+        for (const segment of segments) {
+            if (segment.type === "text") {
+                const escaped = escape(segment.value);
+                stringParts.push(escaped);
+            }
+            else {
+                // Interpolation segment
+                stringParts.push(`\${${segment.variableName}}`);
+            }
+        }
+        return "`" + stringParts.join("") + "`";
+    }
     /**
      * Generates an async for prompt-based assignments
      */
-    generatePromptFunction({ variableName, functionArgs = [], prompt, }) {
+    generatePromptFunction({ variableName, variableType, functionArgs = [], prompt, }) {
         // Generate async function for prompt-based assignment
-        const variableType = this.typeHints[variableName] || {
+        const _variableType = variableType ||
+            this.typeHints[variableName] || {
             type: "primitiveType",
             value: "string",
         };
-        const zodSchema = mapTypeToZodSchema(variableType, this.typeAliases);
+        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);
+        const typeString = variableTypeToString(_variableType, this.typeAliases);
         // Build prompt construction code
         const promptCode = this.buildPromptString(prompt.segments, this.typeHints);
-        const argsStr = functionArgs
-            .map((arg) => `${arg}: ${variableTypeToString(this.typeHints[arg] || { type: "primitiveType", value: "string" }, this.typeAliases)}`)
-            .join(", ");
+        const parts = functionArgs.map((arg) => `${arg.replace(".", "_")}: ${variableTypeToString(this.typeHints[arg] || { type: "primitiveType", value: "string" }, this.typeAliases)}`);
+        parts.push("__messages: Message[] = []");
+        const argsStr = parts.join(", ");
         const _tools = this.toolsUsed
             .map((toolName) => `${toolName}Tool`)
             .join(", ");
@@ -349,6 +388,24 @@ export class TypeScriptGenerator extends BaseGenerator {
         const bodyCodeStr = bodyCodes.join("\n");
         return `while (${conditionCode}) {\n${bodyCodeStr}\n}\n`;
     }
+    processIfElse(node) {
+        const conditionCode = this.processNode(node.condition);
+        const thenBodyCodes = [];
+        for (const stmt of node.thenBody) {
+            thenBodyCodes.push(this.processNode(stmt));
+        }
+        const thenBodyStr = thenBodyCodes.join("\n");
+        let result = `if (${conditionCode}) {\n${thenBodyStr}\n}`;
+        if (node.elseBody && node.elseBody.length > 0) {
+            const elseBodyCodes = [];
+            for (const stmt of node.elseBody) {
+                elseBodyCodes.push(this.processNode(stmt));
+            }
+            const elseBodyStr = elseBodyCodes.join("\n");
+            result += ` else {\n${elseBodyStr}\n}`;
+        }
+        return result + "\n";
+    }
     processSpecialVar(node) {
         const value = this.processNode(node.value);
         switch (node.name) {
@@ -361,6 +418,21 @@ export class TypeScriptGenerator extends BaseGenerator {
                 throw new Error(`Unhandled SpecialVar name: ${node.name}`);
         }
     }
+    processTimeBlock(node, timingVarName) {
+        const bodyCodes = [];
+        for (const stmt of node.body) {
+            bodyCodes.push(this.processNode(stmt));
+        }
+        const bodyCodeStr = bodyCodes.join("\n");
+        return renderTime.default({
+            timingVarName,
+            bodyCodeStr,
+        });
+    }
+    processAwaitStatement(node) {
+        const code = this.processNode(node.expression);
+        return `await ${code}`;
+    }
 }
 export function generateTypeScript(program) {
     const generator = new TypeScriptGenerator();

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

@@ -1,4 +1,4 @@
 import { AccessExpression, FunctionCall, Literal } from "../types.js";
-import { AgencyObject, AgencyArray } from "../types/dataStructures.js";
+import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 export declare const wrapInReturn: (node: AccessExpression | FunctionCall | Literal | AgencyObject | AgencyArray) => ReturnStatement;

package/dist/lib/parser.js

@@ -1,9 +1,8 @@
 import { typeAliasParser, typeHintParser } from "./parsers/typeHints.js";
-import { anyChar, between, capture, eof, or, search, sepBy, seqC, set, spaces, str, success, trace, } from "tarsec";
+import { anyChar, between, capture, eof, many, or, search, seqC, set, str, success, trace, } from "tarsec";
 import { accessExpressionParser } from "./parsers/access.js";
-import { assignmentParser } from "./parsers/assignment.js";
 import { commentParser } from "./parsers/comment.js";
-import { functionParser, graphNodeParser, whileLoopParser, } from "./parsers/function.js";
+import { assignmentParser, functionParser, graphNodeParser, ifParser, timeBlockParser, whileLoopParser, } from "./parsers/function.js";
 import { functionCallParser } from "./parsers/functionCall.js";
 import { importStatmentParser } from "./parsers/importStatement.js";
 import { matchBlockParser } from "./parsers/matchBlock.js";
@@ -11,8 +10,10 @@ import { returnStatementParser } from "./parsers/returnStatement.js";
 import { usesToolParser } from "./parsers/tools.js";
 import { EgonLog } from "egonlog";
 import { specialVarParser } from "./parsers/specialVar.js";
+import { awaitParser } from "./parsers/await.js";
+import { newLineParser } from "./parsers/newline.js";
 export const agencyNode = (input) => {
-    const parser = sepBy(spaces, trace("agencyParser", or(usesToolParser, importStatmentParser, graphNodeParser, typeAliasParser, whileLoopParser, typeHintParser, matchBlockParser, functionParser, returnStatementParser, specialVarParser, accessExpressionParser, assignmentParser, functionCallParser, commentParser)));
+    const parser = many(trace("agencyParser", or(usesToolParser, importStatmentParser, graphNodeParser, typeAliasParser, ifParser, whileLoopParser, typeHintParser, matchBlockParser, timeBlockParser, awaitParser, functionParser, returnStatementParser, specialVarParser, accessExpressionParser, assignmentParser, functionCallParser, commentParser, newLineParser)));
     return parser(input);
 };
 export const agencyParser = seqC(set("type", "agencyProgram"), capture(agencyNode, "nodes"), eof);
@@ -33,7 +34,6 @@ export function parseAgency(input, verbose = false) {
         .map((line) => {
         return line.trim();
     })
-        .filter((l) => l.length > 0)
         .join("\n");
     if (normalized.trim().length === 0) {
         return success({