agency-lang 0.0.48 → 0.0.50

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

@@ -31,7 +31,6 @@ export declare class AgencyGenerator extends BaseGenerator {
     protected processTimeBlock(node: TimeBlock): string;
     protected generateLiteral(literal: Literal): string;
     private generatePromptLiteral;
-    private renderObjectLiteral;
     private generateStringLiteral;
     private generateMultiLineStringLiteral;
     protected processPromptLiteral(variableName: string, variableType: VariableType | undefined, node: PromptLiteral): string;

package/dist/lib/backends/agencyGenerator.js

@@ -75,7 +75,8 @@ export class AgencyGenerator extends BaseGenerator {
         }
         this.decreaseIndent();
         const bodyCodeStr = bodyCodes.join("");
-        return `time {\n${bodyCodeStr}${this.indentStr("}")}\n`;
+        const timeBlockName = node.printTime ? "printTime" : "time";
+        return this.indentStr(`${timeBlockName} {\n${bodyCodeStr}${this.indentStr("}")}`);
     }
     generateLiteral(literal) {
         switch (literal.type) {
@@ -94,7 +95,11 @@ export class AgencyGenerator extends BaseGenerator {
         }
     }
     generatePromptLiteral(node) {
-        let result = 'llm("';
+        let result = "";
+        if (node.isStreaming) {
+            result += "stream ";
+        }
+        result += 'llm("';
         for (const segment of node.segments) {
             if (segment.type === "text") {
                 result += segment.value;
@@ -104,27 +109,14 @@ export class AgencyGenerator extends BaseGenerator {
             }
         }
         if (node.config) {
-            result += `", ${this.renderObjectLiteral(node.config)}`;
+            const objCode = this.processAgencyObject(node.config);
+            result += `", ${objCode})`;
+        }
+        else {
+            result += `")`;
         }
-        result += `")`;
         return result;
     }
-    renderObjectLiteral(obj) {
-        const entries = Object.entries(obj).map(([key, value]) => {
-            let valueStr;
-            if (typeof value === "string") {
-                valueStr = `"${value}"`;
-            }
-            else if (typeof value === "object") {
-                valueStr = this.renderObjectLiteral(value);
-            }
-            else {
-                valueStr = String(value);
-            }
-            return `${key}: ${valueStr}`;
-        });
-        return `{ ${entries.join(", ")} }`;
-    }
     generateStringLiteral(node) {
         let result = '"';
         for (const segment of node.segments) {
@@ -205,7 +197,8 @@ export class AgencyGenerator extends BaseGenerator {
         const args = node.arguments.map((arg) => {
             return this.processNode(arg).trim();
         });
-        return `${node.functionName}(${args.join(", ")})`;
+        const asyncPrefix = node.async ? "async " : "";
+        return `${asyncPrefix}${node.functionName}(${args.join(", ")})`;
     }
     // Data structures
     processAgencyArray(node) {
@@ -361,8 +354,8 @@ export class AgencyGenerator extends BaseGenerator {
     }
     processUsesTool(node) {
         // Track tool usage but don't generate code
-        this.toolsUsed.push(node.toolName);
-        return this.indentStr(`+${node.toolName}`);
+        this.toolsUsed.push(...node.toolNames);
+        return this.indentStr(`uses ${node.toolNames.join(", ")}`);
     }
     processSpecialVar(node) {
         return this.indentStr(`@${node.name} = ${this.processNode(node.value).trim()}`);

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

@@ -12,7 +12,18 @@ import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
 import { WhileLoop } from "../types/whileLoop.js";
-type Scope = "global" | "function" | "node";
+type Scope = GlobalScope | FunctionScope | NodeScope;
+type GlobalScope = {
+    type: "global";
+};
+type FunctionScope = {
+    type: "function";
+    functionName: string;
+};
+type NodeScope = {
+    type: "node";
+    nodeName: string;
+};
 export declare class BaseGenerator {
     protected typeHints: TypeHintMap;
     protected graphNodes: GraphNodeDefinition[];

package/dist/lib/backends/baseGenerator.js

@@ -17,7 +17,7 @@ export class BaseGenerator {
     // collect function signatures so we can implement named args
     // TODO also save return types, check if used as a tool, return type cannot be null/void/undefined
     functionDefinitions = {};
-    currentScope = ["global"];
+    currentScope = [{ type: "global" }];
     generate(program) {
         // Pass 1: Collect all type aliases
         for (const node of program.nodes) {
@@ -149,7 +149,7 @@ export class BaseGenerator {
             case "indexAccess":
                 return this.processIndexAccess(node);
             case "timeBlock":
-                throw new Error(`Time block needs to be assigned to a variable: ${JSON.stringify(node)}`);
+                return this.processTimeBlock(node, `__defaultTimeblockName`);
             case "awaitStatement":
                 return this.processAwaitStatement(node);
             case "newLine":
@@ -268,8 +268,8 @@ export class BaseGenerator {
     should be assigned on local or global scope. There's a related function `generateScopedVariableName`,
     which is used when retrieving the value of a variable. */
     getScopeVar() {
-        const currentScope = this.currentScope[this.currentScope.length - 1];
-        switch (currentScope) {
+        const currentScope = this.getCurrentScope();
+        switch (currentScope.type) {
             case "global":
                 return "__stateStack.globals";
             case "function":

package/dist/lib/backends/graphGenerator.js

@@ -39,7 +39,7 @@ export class GraphGenerator extends TypeScriptGenerator {
         this.graphNodes.push(node);
     }
     processGraphNode(node) {
-        this.startScope("node");
+        this.startScope({ type: "node", nodeName: node.nodeName });
         const { nodeName, body, parameters } = node;
         /* if (parameters.length > 1) {
           throw new Error(

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

@@ -44,6 +44,7 @@ export declare class TypeScriptGenerator extends BaseGenerator {
      */
     protected generateFunctionCallExpression(node: FunctionCall): string;
     protected generateLiteral(literal: Literal): string;
+    protected getScopeReturnType(): VariableType | undefined;
     protected generateImports(): string;
     buildPromptString(segments: PromptSegment[], typeHints: TypeHintMap): string;
     generateStringLiteral(segments: PromptSegment[]): string;

package/dist/lib/backends/typescriptGenerator.js

@@ -14,6 +14,7 @@ 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";
+const DEFAULT_PROMPT_NAME = "__promptVar";
 export class TypeScriptGenerator extends BaseGenerator {
     constructor() {
         super();
@@ -69,6 +70,9 @@ export class TypeScriptGenerator extends BaseGenerator {
             interrupt. */
             return `__stack.step++;\nreturn ${returnCode}\n`;
         }
+        else if (node.value.type === "prompt") {
+            return `${returnCode}\n__stateStack.pop();\nreturn __self.${DEFAULT_PROMPT_NAME};\n`;
+        }
         /* Pop the state off the stack, we won't be coming back.
         Doesn't matter if we update the step or not, since we won't be coming back here. */
         return `__stateStack.pop();\nreturn ${returnCode}\n`;
@@ -124,7 +128,7 @@ export class TypeScriptGenerator extends BaseGenerator {
     processAssignment(node) {
         const { variableName, typeHint, value } = node;
         const _currentScope = this.getCurrentScope();
-        if (_currentScope === "global") {
+        if (_currentScope.type === "global") {
             this.globalScopedVariables.push(variableName);
         }
         else {
@@ -137,43 +141,14 @@ export class TypeScriptGenerator extends BaseGenerator {
             return this.processPromptLiteral(variableName, typeHint, value);
         }
         else if (value.type === "functionCall") {
-            if (value.functionName === "llm") {
-                const args = value.arguments;
-                if (args.length === 0) {
-                    throw new Error(`llm function call must have at least one argument for the prompt.`);
-                }
-                const promptArg = args[0];
-                const promptArgIsPrompt = promptArg.type === "prompt" ||
-                    promptArg.type === "string" ||
-                    promptArg.type === "multiLineString" ||
-                    promptArg.type === "variableName"; // if variable name, assume its a string
-                if (!promptArgIsPrompt) {
-                    throw new Error(`First argument to llm function must be a prompt literal.`);
-                }
-                const promptConfig = args[1];
-                if (promptConfig && promptConfig.type !== "agencyObject") {
-                    throw new Error(`Second argument to llm function must be an object literal for configuration.`);
-                }
-                return this.processPromptLiteral(variableName, typeHint, {
-                    type: "prompt",
-                    segments: promptArg.type === "variableName"
-                        ? [
-                            {
-                                type: "interpolation",
-                                variableName: promptArg.value,
-                            },
-                        ]
-                        : promptArg.segments,
-                    config: promptConfig,
-                });
-            }
             // Direct assignment for other literal types
             const code = this.processNode(value);
             return renderFunctionCallAssignment.default({
                 variableName: `${this.getScopeVar()}.${variableName}`,
                 typeAnnotation,
                 functionCode: code.trim(),
-                nodeContext: this.getCurrentScope() === "node",
+                nodeContext: this.getCurrentScope().type === "node",
+                globalScope: this.getCurrentScope().type === "global",
             });
         }
         else if (value.type === "timeBlock") {
@@ -214,13 +189,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             functionArgs: interpolatedVars,
             prompt: node,
         });
-        //this.generatedStatements.push(functionCode);
-        //const argsStr = [...interpolatedVars, "__messages"].join(", ");
-        // Generate the function call
-        return functionCode; /* (
-          `${functionCode}\nconst __self.${variableName} = await _${variableName}(${argsStr});` +
-          "\n"
-        ); */
+        return functionCode;
     }
     processTool(node) {
         const { functionName, body, parameters } = node;
@@ -247,18 +216,19 @@ 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);
+        node.toolNames.forEach((toolName) => {
+            if (!this.functionDefinitions[toolName]) {
+                throw new Error(`Tool '${toolName}' is being used but no function definition found for it. Make sure to define a function for this tool.`);
+            }
+        });
+        this.toolsUsed.push(...node.toolNames);
         return "";
     }
     /**
      * Process a function definition node
      */
     processFunctionDefinition(node) {
-        this.startScope("function");
+        this.startScope({ type: "function", functionName: node.functionName });
         const { functionName, body, parameters } = node;
         const args = parameters.map((p) => p.name);
         this.functionScopedVariables = [...parameters.map((p) => p.name)];
@@ -329,6 +299,7 @@ export class TypeScriptGenerator extends BaseGenerator {
                 functionName,
                 argsString,
                 metadata,
+                awaitPrefix: node.async ? "" : "await ",
             });
         }
         else {
@@ -348,12 +319,26 @@ export class TypeScriptGenerator extends BaseGenerator {
             case "variableName":
                 return this.generateScopedVariableName(literal.value);
             case "prompt":
-                //return this.processPromptLiteral("asd", literal).trim();
-                // Reconstruct text for comment from segments
-                const text = literal.segments
-                    .map((s) => (s.type === "text" ? s.value : `#{${s.variableName}}`))
-                    .join("");
-                return `/* prompt for: ${text} */`;
+                return this.processPromptLiteral(DEFAULT_PROMPT_NAME, this.getScopeReturnType(), literal);
+        }
+    }
+    getScopeReturnType() {
+        const currentScope = this.getCurrentScope();
+        switch (currentScope.type) {
+            case "global":
+                return undefined;
+            case "function":
+                const funcDef = this.functionDefinitions[currentScope.functionName];
+                if (funcDef && funcDef.returnType) {
+                    return funcDef.returnType;
+                }
+                return undefined;
+            case "node":
+                const graphNode = this.graphNodes.find((n) => n.nodeName === currentScope.nodeName);
+                if (graphNode && graphNode.returnType) {
+                    return graphNode.returnType;
+                }
+                return undefined;
         }
     }
     generateImports() {
@@ -453,7 +438,8 @@ export class TypeScriptGenerator extends BaseGenerator {
             tools,
             functionCalls,
             clientConfig,
-            nodeContext: this.getCurrentScope() === "node",
+            nodeContext: this.getCurrentScope().type === "node",
+            isStreaming: prompt.isStreaming || false,
         });
     }
     processImportStatement(node) {
@@ -503,6 +489,8 @@ export class TypeScriptGenerator extends BaseGenerator {
                     name: "model",
                     value,
                 });
+            case "messages":
+                return `__messages = ${value};\n`;
             default:
                 throw new Error(`Unhandled SpecialVar name: ${node.name}`);
         }
@@ -516,6 +504,7 @@ export class TypeScriptGenerator extends BaseGenerator {
         return renderTime.default({
             timingVarName,
             bodyCodeStr,
+            printTime: node.printTime || false,
         });
     }
     processAwaitStatement(node) {

package/dist/lib/parser.js

@@ -3,7 +3,7 @@ import { anyChar, between, capture, eof, many, or, search, seqC, set, str, succe
 import { accessExpressionParser } from "./parsers/access.js";
 import { commentParser } from "./parsers/comment.js";
 import { assignmentParser, functionParser, graphNodeParser, ifParser, timeBlockParser, whileLoopParser, } from "./parsers/function.js";
-import { functionCallParser } from "./parsers/functionCall.js";
+import { functionCallParser, llmPromptFunctionCallParser, streamingPromptLiteralParser, } from "./parsers/functionCall.js";
 import { importNodeStatmentParser, importStatmentParser, importToolStatmentParser, } from "./parsers/importStatement.js";
 import { matchBlockParser } from "./parsers/matchBlock.js";
 import { returnStatementParser } from "./parsers/returnStatement.js";
@@ -13,7 +13,7 @@ import { specialVarParser } from "./parsers/specialVar.js";
 import { awaitParser } from "./parsers/await.js";
 import { newLineParser } from "./parsers/newline.js";
 export const agencyNode = (input) => {
-    const parser = many(trace("agencyParser", or(usesToolParser, importNodeStatmentParser, importToolStatmentParser, importStatmentParser, graphNodeParser, typeAliasParser, ifParser, whileLoopParser, typeHintParser, matchBlockParser, timeBlockParser, awaitParser, functionParser, returnStatementParser, specialVarParser, accessExpressionParser, assignmentParser, functionCallParser, commentParser, newLineParser)));
+    const parser = many(trace("agencyParser", or(usesToolParser, importNodeStatmentParser, importToolStatmentParser, importStatmentParser, graphNodeParser, typeAliasParser, ifParser, whileLoopParser, typeHintParser, matchBlockParser, timeBlockParser, awaitParser, streamingPromptLiteralParser, functionParser, returnStatementParser, specialVarParser, accessExpressionParser, assignmentParser, llmPromptFunctionCallParser, functionCallParser, commentParser, newLineParser)));
     return parser(input);
 };
 export const agencyParser = seqC(set("type", "agencyProgram"), capture(agencyNode, "nodes"), eof);

package/dist/lib/parsers/await.js

@@ -8,11 +8,11 @@ export const usesToolParser: Parser<UsesTool> = seqC(
   capture(many1WithJoin(varNameChar), "toolName")
 );
  */
-import { capture, or, seqC, set, spaces, str } from "tarsec";
+import { capture, or, seqC, set, spaces, str, } from "tarsec";
 import { accessExpressionParser } from "./access.js";
-import { functionCallParser } from "./functionCall.js";
+import { functionCallParser, llmPromptFunctionCallParser, } from "./functionCall.js";
 import { literalParser } from "./literals.js";
 export const awaitParser = (input) => {
-    const parser = seqC(set("type", "awaitStatement"), str("await"), spaces, capture(or(accessExpressionParser, functionCallParser, literalParser), "expression"));
+    const parser = seqC(set("type", "awaitStatement"), str("await"), spaces, capture(or(accessExpressionParser, llmPromptFunctionCallParser, functionCallParser, literalParser), "expression"));
     return parser(input);
 };

package/dist/lib/parsers/function.d.ts

@@ -7,6 +7,8 @@ import { IfElse } from "../types/ifElse.js";
 export declare const assignmentParser: Parser<Assignment>;
 export declare const docStringParser: Parser<DocString>;
 export declare const bodyParser: (input: string) => ParserResult<AgencyNode[]>;
+export declare const _timeBlockParser: Parser<TimeBlock>;
+export declare const printTimeBlockParser: Parser<TimeBlock>;
 export declare const timeBlockParser: Parser<TimeBlock>;
 export declare const ifParser: Parser<IfElse>;
 export declare const whileLoopParser: Parser<WhileLoop>;

package/dist/lib/parsers/function.js

@@ -1,7 +1,7 @@
 import { capture, captureCaptures, char, debug, many, 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 } from "./functionCall.js";
+import { asyncFunctionCallParser, functionCallParser, llmPromptFunctionCallParser, streamingPromptLiteralParser, } from "./functionCall.js";
 import { literalParser, promptParser } from "./literals.js";
 import { matchBlockParser } from "./matchBlock.js";
 import { optionalSemicolon } from "./parserUtils.js";
@@ -14,16 +14,21 @@ import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
 import { awaitParser } from "./await.js";
 import { newLineParser } from "./newline.js";
 export const assignmentParser = (input) => {
-    const parser = trace("assignmentParser", seqC(set("type", "assignment"), optionalSpaces, capture(many1WithJoin(varNameChar), "variableName"), optionalSpaces, optional(captureCaptures(seqC(char(":"), optionalSpaces, capture(variableTypeParser, "typeHint")))), optionalSpaces, char("="), optionalSpaces, capture(or(timeBlockParser, awaitParser, promptParser, functionCallParser, indexAccessParser, accessExpressionParser, agencyArrayParser, agencyObjectParser, literalParser), "value"), optionalSemicolon));
+    const parser = trace("assignmentParser", seqC(set("type", "assignment"), optionalSpaces, capture(many1WithJoin(varNameChar), "variableName"), optionalSpaces, optional(captureCaptures(seqC(char(":"), optionalSpaces, capture(variableTypeParser, "typeHint")))), optionalSpaces, char("="), optionalSpaces, capture(or(timeBlockParser, awaitParser, asyncFunctionCallParser, promptParser, streamingPromptLiteralParser, llmPromptFunctionCallParser, functionCallParser, indexAccessParser, accessExpressionParser, agencyArrayParser, agencyObjectParser, literalParser), "value"), optionalSemicolon));
     return parser(input);
 };
 const trim = (s) => s.trim();
 export const docStringParser = trace("docStringParser", seqC(set("type", "docString"), str('"""'), capture(map(many1Till(str('"""')), trim), "value"), str('"""')));
 export const bodyParser = (input) => {
-    const parser = trace("functionBodyParser", many(or(usesToolParser, debug(typeAliasParser, "error in typeAliasParser"), debug(typeHintParser, "error in typeHintParser"), specialVarParser, returnStatementParser, whileLoopParser, matchBlockParser, awaitParser, ifParser, functionParser, accessExpressionParser, assignmentParser, functionCallParser, literalParser, commentParser, newLineParser)));
+    const parser = trace("functionBodyParser", many(or(usesToolParser, debug(typeAliasParser, "error in typeAliasParser"), debug(typeHintParser, "error in typeHintParser"), specialVarParser, returnStatementParser, whileLoopParser, matchBlockParser, awaitParser, asyncFunctionCallParser, streamingPromptLiteralParser, ifParser, timeBlockParser, functionParser, accessExpressionParser, assignmentParser, llmPromptFunctionCallParser, functionCallParser, literalParser, commentParser, newLineParser)));
     return parser(input);
 };
-export const timeBlockParser = trace("timeBlockParser", seqC(set("type", "timeBlock"), str("time"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpaces, char("}")));
+export const _timeBlockParser = trace("timeBlockParser", seqC(set("type", "timeBlock"), str("time"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpacesOrNewline, char("}")));
+export const printTimeBlockParser = trace("timeBlockParser", map(seqC(set("type", "timeBlock"), str("printTime"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpacesOrNewline, char("}")), (result) => ({
+    ...result,
+    printTime: true,
+})));
+export const timeBlockParser = or(printTimeBlockParser, _timeBlockParser);
 /* const elseClauseParser: Parser<AgencyNode[]> = seqC(
   str("else"),
   optionalSpaces,

package/dist/lib/parsers/functionCall.d.ts

@@ -1,3 +1,6 @@
-import { FunctionCall } from "../types.js";
+import { FunctionCall, PromptLiteral } from "../types.js";
 import { Parser } from "tarsec";
 export declare const functionCallParser: Parser<FunctionCall>;
+export declare const asyncFunctionCallParser: Parser<FunctionCall>;
+export declare const llmPromptFunctionCallParser: Parser<PromptLiteral>;
+export declare const streamingPromptLiteralParser: Parser<PromptLiteral>;

package/dist/lib/parsers/functionCall.js

@@ -1,6 +1,6 @@
-import { capture, char, many1WithJoin, or, sepBy, seqC, set, } from "tarsec";
+import { capture, char, failure, many1WithJoin, or, sepBy, seqC, set, spaces, str, success, } from "tarsec";
 import { accessExpressionParser, indexAccessParser } from "./access.js";
-import { literalParser } from "./literals.js";
+import { literalParser, promptParser } from "./literals.js";
 import { optionalSemicolon } from "./parserUtils.js";
 import { comma, optionalSpaces, varNameChar } from "./utils.js";
 import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
@@ -8,3 +8,59 @@ export const functionCallParser = (input) => {
     const parser = seqC(set("type", "functionCall"), capture(many1WithJoin(varNameChar), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(agencyArrayParser, agencyObjectParser, indexAccessParser, functionCallParser, accessExpressionParser, literalParser)), "arguments"), optionalSpaces, char(")"), optionalSemicolon);
     return parser(input);
 };
+export const asyncFunctionCallParser = (input) => {
+    const parser = seqC(str("async"), spaces, capture(functionCallParser, "functionCall"));
+    const result = parser(input);
+    if (!result.success) {
+        return result;
+    }
+    const { functionCall } = result.result;
+    return success({ ...functionCall, async: true }, result.rest);
+};
+export const llmPromptFunctionCallParser = (input) => {
+    const parser = functionCallParser;
+    const result = parser(input);
+    if (!result.success) {
+        return result;
+    }
+    const { functionName, arguments: args } = result.result;
+    if (functionName !== "llm") {
+        return failure(`Expected function name "llm", got "${functionName}"`, input);
+    }
+    if (args.length === 0) {
+        throw new Error(`llm function call must have at least one argument for the prompt.`);
+    }
+    const promptArg = args[0];
+    const promptArgIsPrompt = promptArg.type === "prompt" ||
+        promptArg.type === "string" ||
+        promptArg.type === "multiLineString" ||
+        promptArg.type === "variableName"; // if variable name, assume its a string
+    if (!promptArgIsPrompt) {
+        throw new Error(`First argument to llm function must be a prompt literal.`);
+    }
+    const promptConfig = args[1];
+    if (promptConfig && promptConfig.type !== "agencyObject") {
+        throw new Error(`Second argument to llm function must be an object literal for configuration.`);
+    }
+    return success({
+        type: "prompt",
+        segments: promptArg.type === "variableName"
+            ? [
+                {
+                    type: "interpolation",
+                    variableName: promptArg.value,
+                },
+            ]
+            : promptArg.segments,
+        config: promptConfig,
+    }, result.rest);
+};
+export const streamingPromptLiteralParser = (input) => {
+    const parser = seqC(or(str("streaming"), str("stream")), spaces, capture(or(promptParser, llmPromptFunctionCallParser), "prompt"));
+    const result = parser(input);
+    if (!result.success) {
+        return result;
+    }
+    const { prompt } = result.result;
+    return success({ ...prompt, isStreaming: true }, result.rest);
+};