agency-lang 0.0.32 → 0.0.34

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

@@ -31,6 +31,7 @@ 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

@@ -103,9 +103,28 @@ export class AgencyGenerator extends BaseGenerator {
                 result += `\${${segment.variableName}}`;
             }
         }
+        if (node.config) {
+            result += `", ${this.renderObjectLiteral(node.config)}`;
+        }
         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) {
@@ -196,14 +215,17 @@ export class AgencyGenerator extends BaseGenerator {
         return `[${items.join(", ")}]`;
     }
     processAgencyObject(node) {
+        this.increaseIndent();
         const entries = node.entries.map((entry) => {
             const valueCode = this.processNode(entry.value).trim();
-            return `${entry.key}: ${valueCode}`;
+            return this.indentStr(`${entry.key}: ${valueCode}`);
         });
+        this.decreaseIndent();
         if (entries.length === 0) {
             return `{}`;
         }
-        return `{ ${entries.join(", ")} }`;
+        let entriesStr = "\n" + entries.join(",\n") + "\n";
+        return `{ ${entriesStr}` + this.indentStr("}");
     }
     // Access expressions
     processAccessExpression(node) {
@@ -286,12 +308,12 @@ export class AgencyGenerator extends BaseGenerator {
             this.decreaseIndent();
             lines.push(elseBodyLines.join("").trimEnd() + "\n");
         }
-        lines.push(this.indentStr(`}\n\n`));
+        lines.push(this.indentStr(`}`));
         return lines.join("");
     }
     processReturnStatement(node) {
         const valueCode = this.processNode(node.value).trim();
-        return this.indentStr(`return ${valueCode}\n`);
+        return this.indentStr(`return ${valueCode}`);
     }
     // Utility methods
     processComment(node) {
@@ -337,7 +359,7 @@ export class AgencyGenerator extends BaseGenerator {
         return this.indentStr(`+${node.toolName}`);
     }
     processSpecialVar(node) {
-        return this.indentStr(`@${node.name} = ${this.processNode(node.value).trim()}\n`);
+        return this.indentStr(`@${node.name} = ${this.processNode(node.value).trim()}`);
     }
     indentStr(str) {
         return `${this.indent()}${str}`;

package/dist/lib/backends/typescriptGenerator.js

@@ -119,6 +119,25 @@ 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];
+                if (promptArg.type !== "string") {
+                    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.segments,
+                    config: promptConfig,
+                });
+            }
             // Direct assignment for other literal types
             const code = this.processNode(value);
             return (`const ${variableName}${typeAnnotation} = await ${code.trim()};` + "\n");
@@ -163,7 +182,8 @@ export class TypeScriptGenerator extends BaseGenerator {
         //this.generatedStatements.push(functionCode);
         const argsStr = [...interpolatedVars, "__messages"].join(", ");
         // Generate the function call
-        return `${functionCode}\nconst ${variableName} = await _${variableName}(${argsStr});` + "\n";
+        return (`${functionCode}\nconst ${variableName} = await _${variableName}(${argsStr});` +
+            "\n");
     }
     processTool(node) {
         const { functionName, body, parameters } = node;
@@ -364,6 +384,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             });
         })
             .join("\n");
+        const clientConfig = prompt.config ? this.processNode(prompt.config) : "{}";
         this.toolsUsed = []; // reset after use
         return promptFunction.default({
             variableName,
@@ -374,6 +395,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             zodSchema,
             tools,
             functionCalls,
+            clientConfig,
         });
     }
     processImportStatement(node) {

package/dist/lib/parsers/dataStructures.js

@@ -2,7 +2,7 @@ import { capture, char, manyWithJoin, noneOf, optional, or, sepBy, seqC, set, su
 import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { functionCallParser } from "./functionCall.js";
 import { literalParser } from "./literals.js";
-import { comma, optionalSpaces, optionalSpacesOrNewline } from "./utils.js";
+import { comma, commaWithNewline, optionalSpaces, optionalSpacesOrNewline, } from "./utils.js";
 export const agencyArrayParser = (input) => {
     const parser = trace("agencyArrayParser", seqC(set("type", "agencyArray"), char("["), capture(sepBy(comma, or(indexAccessParser, accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser)), "items"), char("]")));
     return parser(input);
@@ -11,4 +11,4 @@ export const agencyObjectKVParser = (input) => {
     const parser = trace("agencyObjectKVParser", seqC(optionalSpaces, optional(char('"')), capture(manyWithJoin(noneOf('":\n\t ')), "key"), optional(char('"')), optionalSpaces, char(":"), optionalSpaces, capture(or(indexAccessParser, accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value")));
     return parser(input);
 };
-export const agencyObjectParser = seqC(set("type", "agencyObject"), char("{"), optionalSpacesOrNewline, capture(or(sepBy(comma, agencyObjectKVParser), succeed([])), "entries"), optional(char(",")), optionalSpacesOrNewline, char("}"));
+export const agencyObjectParser = seqC(set("type", "agencyObject"), char("{"), optionalSpacesOrNewline, capture(or(sepBy(commaWithNewline, agencyObjectKVParser), succeed([])), "entries"), optional(char(",")), optionalSpacesOrNewline, char("}"));

package/dist/lib/parsers/functionCall.js

@@ -1,10 +1,9 @@
-import { capture, char, many1WithJoin, or, sepBy, seqC, seqR, set, } from "tarsec";
+import { capture, char, many1WithJoin, or, sepBy, seqC, set, } from "tarsec";
 import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { literalParser } from "./literals.js";
 import { optionalSemicolon } from "./parserUtils.js";
-import { optionalSpaces, varNameChar } from "./utils.js";
+import { comma, optionalSpaces, varNameChar } from "./utils.js";
 import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
-const comma = seqR(optionalSpaces, char(","), optionalSpaces);
 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);

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

@@ -5,7 +5,6 @@ export declare const stringTextSegmentParser: Parser<TextSegment>;
 export declare const multiLineStringTextSegmentParser: Parser<TextSegment>;
 export declare const interpolationSegmentParser: Parser<InterpolationSegment>;
 export declare const promptParserBackticks: Parser<PromptLiteral>;
-export declare const promptParserLlmFunction: Parser<PromptLiteral>;
 export declare const promptParser: Parser<PromptLiteral>;
 export declare const numberParser: Parser<NumberLiteral>;
 export declare const stringParser: Parser<StringLiteral>;

package/dist/lib/parsers/literals.js

@@ -1,5 +1,5 @@
-import { backtick, optionalSpaces, varNameChar } from "./utils.js";
-import { capture, char, digit, letter, many, many1Till, many1WithJoin, manyTillStr, manyWithJoin, map, or, seq, seqC, set, str, } from "tarsec";
+import { backtick, commaWithNewline, optionalSpaces, optionalSpacesOrNewline, varNameChar, } from "./utils.js";
+import { capture, char, digit, letter, many, many1Till, many1WithJoin, manyTillStr, manyWithJoin, map, noneOf, optional, or, sepBy, seq, seqC, set, str, trace, } from "tarsec";
 export const textSegmentParser = map(many1Till(or(backtick, char("$"))), (text) => ({
     type: "text",
     value: text,
@@ -14,11 +14,70 @@ export const multiLineStringTextSegmentParser = map(many1Till(or(str('"""'), cha
 }));
 export const interpolationSegmentParser = seqC(set("type", "interpolation"), char("$"), char("{"), capture(manyTillStr("}"), "variableName"), char("}"));
 export const promptParserBackticks = seqC(set("type", "prompt"), backtick, capture(many(or(textSegmentParser, interpolationSegmentParser)), "segments"), backtick);
-export const promptParserLlmFunction = (input) => {
-    const parser = seqC(set("type", "prompt"), str("llm("), optionalSpaces, capture(map(stringParser, (str) => str.segments), "segments"), optionalSpaces, char(")"));
+const objectParser = (input) => {
+    const kvParser = trace("objectKVParser", seqC(optionalSpaces, optional(char('"')), capture(manyWithJoin(noneOf('":\n\t ')), "key"), optional(char('"')), optionalSpaces, char(":"), optionalSpaces, capture(or(literalParser, objectParser), 
+    // arrayParser,
+    "value")));
+    const arrayToObj = (arr) => {
+        const obj = {};
+        arr.forEach(({ key, value }) => {
+            obj[key] = value;
+        });
+        return obj;
+    };
+    const parser = seq([
+        char("{"),
+        optionalSpacesOrNewline,
+        capture(map(sepBy(commaWithNewline, kvParser), arrayToObj), "entries"),
+        optionalSpacesOrNewline,
+        char("}"),
+    ], (_, captures) => {
+        return captures.entries;
+    });
     return parser(input);
 };
-export const promptParser = or(promptParserBackticks, promptParserLlmFunction);
+/* export const promptParserLlmFunctionWithConfig: Parser<PromptLiteral> = (
+  input: string,
+) => {
+  const parser = seqC(
+    set("type", "prompt"),
+    str("llm("),
+    optionalSpaces,
+    capture(
+      map(stringParser, (str) => str.segments),
+      "segments",
+    ),
+    optionalSpaces,
+    char(","),
+    capture(objectParser, "config"),
+    optionalSpaces,
+    char(")"),
+  );
+  return parser(input);
+};
+
+export const promptParserLlmFunction: Parser<PromptLiteral> = (
+  input: string,
+) => {
+  const parser = seqC(
+    set("type", "prompt"),
+    str("llm("),
+    optionalSpaces,
+    capture(
+      map(stringParser, (str) => str.segments),
+      "segments",
+    ),
+    optionalSpaces,
+    char(")"),
+  );
+  return parser(input);
+};
+ */
+export const promptParser = promptParserBackticks; /* or(
+  promptParserBackticks,
+  promptParserLlmFunctionWithConfig,
+  promptParserLlmFunction,
+); */
 export const numberParser = seqC(set("type", "number"), capture(many1WithJoin(or(char("-"), char("."), digit)), "value"));
 export const stringParser = seqC(set("type", "string"), char('"'), capture(many(or(stringTextSegmentParser, interpolationSegmentParser)), "segments"), char('"'));
 export const multiLineStringParser = seqC(set("type", "multiLineString"), str('"""'), capture(many(or(multiLineStringTextSegmentParser, interpolationSegmentParser)), "segments"), str('"""'));

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

@@ -3,4 +3,5 @@ export declare const optionalSpacesOrNewline: Parser<string[]>;
 export declare const optionalSpaces: Parser<string[]>;
 export declare const backtick: Parser<"`">;
 export declare const comma: Parser<(string[] | ",")[]>;
+export declare const commaWithNewline: Parser<(string[] | ",")[]>;
 export declare const varNameChar: Parser<string>;

package/dist/lib/parsers/utils.js

@@ -3,4 +3,5 @@ export const optionalSpacesOrNewline = many(space);
 export const optionalSpaces = many(oneOf(" \t"));
 export const backtick = char("`");
 export const comma = seqR(optionalSpaces, char(","), optionalSpaces);
+export const commaWithNewline = seqR(optionalSpacesOrNewline, char(","), optionalSpacesOrNewline);
 export const varNameChar = oneOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_");

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

@@ -1,4 +1,4 @@
-export declare const template = "import { z } from \"zod\";\nimport * as readline from \"readline\";\nimport fs from \"fs\";\nimport { PieMachine, goToNode } from \"piemachine\";\nimport { StatelogClient } from \"statelog-client\";\nimport { nanoid } from \"nanoid\";\nimport { assistantMessage, getClient, userMessage, toolMessage } from \"smoltalk\";\n\nconst statelogHost = \"https://statelog.adit.io\";\nconst traceId = nanoid();\nconst statelogConfig = {\n    host: statelogHost,\n    traceId: traceId,\n    apiKey: process.env.STATELOG_API_KEY || \"\",\n    projectId: \"agency-lang\",\n    debugMode: false,\n  };\nconst statelogClient = new StatelogClient(statelogConfig);\nconst __model: ModelName = \"gpt-4o-mini\";\n\n\nconst getClientWithConfig = (config = {}) => {\n  const defaultConfig = {\n    openAiApiKey: process.env.OPENAI_API_KEY || \"\",\n    googleApiKey: process.env.GEMINI_API_KEY || \"\",\n    model: __model,\n    logLevel: \"warn\",\n  };\n\n  return getClient({ ...defaultConfig, ...config });\n};\n\nlet __client = getClientWithConfig();\n\ntype State = {\n  messages: string[];\n  data: any;\n}\n\n// enable debug logging\nconst graphConfig = {\n  debug: {\n    log: true,\n    logData: true,\n  },\n  statelog: statelogConfig,\n};\n\n// Define the names of the nodes in the graph\n// Useful for type safety\nconst __nodes = {{{nodes:string}}} as const;\ntype Node = (typeof __nodes)[number];\n\nconst graph = new PieMachine<State, Node>(__nodes, graphConfig);\n\n// builtins\n\nconst not = (val: any): boolean => !val;\nconst eq = (a: any, b: any): boolean => a === b;\nconst neq = (a: any, b: any): boolean => a !== b;\nconst lt = (a: any, b: any): boolean => a < b;\nconst lte = (a: any, b: any): boolean => a <= b;\nconst gt = (a: any, b: any): boolean => a > b;\nconst gte = (a: any, b: any): boolean => a >= b;\nconst and = (a: any, b: any): boolean => a && b;\nconst or = (a: any, b: any): boolean => a || b;\nconst head = <T>(arr: T[]): T | undefined => arr[0];\nconst tail = <T>(arr: T[]): T[] => arr.slice(1);";
+export declare const template = "import { z } from \"zod\";\nimport * as readline from \"readline\";\nimport fs from \"fs\";\nimport { PieMachine, goToNode } from \"piemachine\";\nimport { StatelogClient } from \"statelog-client\";\nimport { nanoid } from \"nanoid\";\nimport { assistantMessage, getClient, userMessage, toolMessage } from \"smoltalk\";\n\nconst statelogHost = \"https://statelog.adit.io\";\nconst traceId = nanoid();\nconst statelogConfig = {\n    host: statelogHost,\n    traceId: traceId,\n    apiKey: process.env.STATELOG_API_KEY || \"\",\n    projectId: \"agency-lang\",\n    debugMode: false,\n  };\nconst statelogClient = new StatelogClient(statelogConfig);\nconst __model: ModelName = \"gpt-4o-mini\";\n\n\nconst getClientWithConfig = (config = {}) => {\n  const defaultConfig = {\n    openAiApiKey: process.env.OPENAI_API_KEY || \"\",\n    googleApiKey: process.env.GEMINI_API_KEY || \"\",\n    model: __model,\n    logLevel: \"warn\",\n  };\n\n  return getClient({ ...defaultConfig, ...config });\n};\n\nlet __client = getClientWithConfig();\n\ntype State = {\n  messages: string[];\n  data: any;\n}\n\n// enable debug logging\nconst graphConfig = {\n  debug: {\n    log: true,\n    logData: true,\n  },\n  statelog: statelogConfig,\n};\n\n// Define the names of the nodes in the graph\n// Useful for type safety\nconst __nodes = {{{nodes:string}}} as const;\ntype Node = (typeof __nodes)[number];\n\nconst graph = new PieMachine<State, Node>(__nodes, graphConfig);\n\n// builtins\n\nconst not = (val: any): boolean => !val;\nconst eq = (a: any, b: any): boolean => a === b;\nconst neq = (a: any, b: any): boolean => a !== b;\nconst lt = (a: any, b: any): boolean => a < b;\nconst lte = (a: any, b: any): boolean => a <= b;\nconst gt = (a: any, b: any): boolean => a > b;\nconst gte = (a: any, b: any): boolean => a >= b;\nconst and = (a: any, b: any): boolean => a && b;\nconst or = (a: any, b: any): boolean => a || b;\nconst head = <T>(arr: T[]): T | undefined => arr[0];\nconst tail = <T>(arr: T[]): T[] => arr.slice(1);\nconst empty = <T>(arr: T[]): boolean => arr.length === 0;";
 export type TemplateType = {
     nodes: string;
 };

package/dist/lib/templates/backends/graphGenerator/imports.js

@@ -69,7 +69,8 @@ const gte = (a: any, b: any): boolean => a >= b;
 const and = (a: any, b: any): boolean => a && b;
 const or = (a: any, b: any): boolean => a || b;
 const head = <T>(arr: T[]): T | undefined => arr[0];
-const tail = <T>(arr: T[]): T[] => arr.slice(1);`;
+const tail = <T>(arr: T[]): T[] => arr.slice(1);
+const empty = <T>(arr: T[]): boolean => arr.length === 0;`;
 const render = (args) => {
     return apply(template, args);
 };

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

@@ -1,4 +1,4 @@
-export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {\n  const __prompt = {{{promptCode:string}}};\n  const startTime = performance.now();\n  __messages.push(userMessage(__prompt));\n  const __tools = {{{tools}}};\n\n  {{#hasResponseFormat}}\n  // Need to make sure this is always an object\n  const __responseFormat = z.object({\n     response: {{{zodSchema:string}}}\n  });\n  {{/hasResponseFormat}}\n  {{^hasResponseFormat}}\n  const __responseFormat = undefined;\n  {{/hasResponseFormat}}\n\n  let __completion = await __client.text({\n    messages: __messages,\n    tools: __tools,\n    responseFormat: __responseFormat,\n  });\n\n  const endTime = performance.now();\n  statelogClient.promptCompletion({\n    messages: __messages,\n    completion: __completion,\n    model: __client.getModel(),\n    timeTaken: endTime - startTime,\n  });\n\n  if (!__completion.success) {\n    throw new Error(\n      `Error getting response from ${__model}: ${__completion.error}`\n    );\n  }\n\n  let responseMessage = __completion.value;\n\n  // Handle function calls\n  while (responseMessage.toolCalls.length > 0) {\n    // Add assistant's response with tool calls to message history\n    __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));\n    let toolCallStartTime, toolCallEndTime;\n\n    // Process each tool call\n    for (const toolCall of responseMessage.toolCalls) {\n      {{{functionCalls:string}}}\n    }\n  \n    const nextStartTime = performance.now();\n    let __completion = await __client.text({\n      messages: __messages,\n      tools: __tools,\n      responseFormat: __responseFormat,\n    });\n\n    const nextEndTime = performance.now();\n\n    statelogClient.promptCompletion({\n      messages: __messages,\n      completion: __completion,\n      model: __client.getModel(),\n      timeTaken: nextEndTime - nextStartTime,\n    });\n\n    if (!__completion.success) {\n      throw new Error(\n        `Error getting response from ${__model}: ${__completion.error}`\n      );\n    }\n    responseMessage = __completion.value;\n  }\n\n  // Add final assistant response to history\n  // not passing tool calls back this time\n  __messages.push(assistantMessage(responseMessage.output));\n  {{#hasResponseFormat}}\n  try {\n  const result = JSON.parse(responseMessage.output || \"\");\n  return result.response;\n  } catch (e) {\n    return responseMessage.output;\n    // console.error(\"Error parsing response for variable '{{{variableName:string}}}':\", e);\n    // console.error(\"Full completion response:\", JSON.stringify(__completion, null, 2));\n    // throw e;\n  }\n  {{/hasResponseFormat}}\n\n  {{^hasResponseFormat}}\n  return responseMessage.output;\n  {{/hasResponseFormat}}\n}\n";
+export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {\n  const __prompt = {{{promptCode:string}}};\n  const startTime = performance.now();\n  __messages.push(userMessage(__prompt));\n  const __tools = {{{tools}}};\n\n  {{#hasResponseFormat}}\n  // Need to make sure this is always an object\n  const __responseFormat = z.object({\n     response: {{{zodSchema:string}}}\n  });\n  {{/hasResponseFormat}}\n  {{^hasResponseFormat}}\n  const __responseFormat = undefined;\n  {{/hasResponseFormat}}\n\n  const __client = getClientWithConfig({{{clientConfig:string}}});\n\n  let __completion = await __client.text({\n    messages: __messages,\n    tools: __tools,\n    responseFormat: __responseFormat,\n  });\n\n  const endTime = performance.now();\n  statelogClient.promptCompletion({\n    messages: __messages,\n    completion: __completion,\n    model: __client.getModel(),\n    timeTaken: endTime - startTime,\n  });\n\n  if (!__completion.success) {\n    throw new Error(\n      `Error getting response from ${__model}: ${__completion.error}`\n    );\n  }\n\n  let responseMessage = __completion.value;\n\n  // Handle function calls\n  while (responseMessage.toolCalls.length > 0) {\n    // Add assistant's response with tool calls to message history\n    __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));\n    let toolCallStartTime, toolCallEndTime;\n\n    // Process each tool call\n    for (const toolCall of responseMessage.toolCalls) {\n      {{{functionCalls:string}}}\n    }\n  \n    const nextStartTime = performance.now();\n    let __completion = await __client.text({\n      messages: __messages,\n      tools: __tools,\n      responseFormat: __responseFormat,\n    });\n\n    const nextEndTime = performance.now();\n\n    statelogClient.promptCompletion({\n      messages: __messages,\n      completion: __completion,\n      model: __client.getModel(),\n      timeTaken: nextEndTime - nextStartTime,\n    });\n\n    if (!__completion.success) {\n      throw new Error(\n        `Error getting response from ${__model}: ${__completion.error}`\n      );\n    }\n    responseMessage = __completion.value;\n  }\n\n  // Add final assistant response to history\n  // not passing tool calls back this time\n  __messages.push(assistantMessage(responseMessage.output));\n  {{#hasResponseFormat}}\n  try {\n  const result = JSON.parse(responseMessage.output || \"\");\n  return result.response;\n  } catch (e) {\n    return responseMessage.output;\n    // console.error(\"Error parsing response for variable '{{{variableName:string}}}':\", e);\n    // console.error(\"Full completion response:\", JSON.stringify(__completion, null, 2));\n    // throw e;\n  }\n  {{/hasResponseFormat}}\n\n  {{^hasResponseFormat}}\n  return responseMessage.output;\n  {{/hasResponseFormat}}\n}\n";
 export type TemplateType = {
     variableName: string;
     argsStr: string;
@@ -7,6 +7,7 @@ export type TemplateType = {
     tools: string | boolean | number;
     hasResponseFormat: boolean;
     zodSchema: string;
+    clientConfig: string;
     functionCalls: string;
 };
 declare const render: (args: TemplateType) => string;

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

@@ -19,6 +19,8 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
   const __responseFormat = undefined;
   {{/hasResponseFormat}}
 
+  const __client = getClientWithConfig({{{clientConfig:string}}});
+
   let __completion = await __client.text({
     messages: __messages,
     tools: __tools,

package/dist/lib/types/literals.d.ts

@@ -1,3 +1,4 @@
+import { AgencyObject } from "./dataStructures.js";
 export type Literal = NumberLiteral | MultiLineStringLiteral | StringLiteral | VariableNameLiteral | PromptLiteral;
 export type NumberLiteral = {
     type: "number";
@@ -27,4 +28,5 @@ export type InterpolationSegment = {
 export type PromptLiteral = {
     type: "prompt";
     segments: PromptSegment[];
+    config?: AgencyObject;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -41,7 +41,7 @@
   "homepage": "https://github.com/egonSchiele/agency-lang#readme",
   "dependencies": {
     "egonlog": "^0.0.2",
-    "smoltalk": "^0.0.11",
+    "smoltalk": "^0.0.12",
     "tarsec": "^0.1.1",
     "typestache": "^0.4.4",
     "zod": "^4.3.5"
@@ -56,4 +56,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   }
-}
+}