@aigne/core 1.29.1 → 1.32.0

package/lib/esm/agents/ai-agent.d.ts

@@ -50,6 +50,48 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      * @default true
      */
     catchToolsError?: boolean;
+    /**
+     * Whether to enable structured stream mode
+     *
+     * When enabled, the AI model's streaming response will be processed to extract
+     * structured metadata. The model needs to include specific format metadata tags
+     * (like <metadata></metadata>) in its response, which will be parsed as JSON
+     * objects and passed through the stream.
+     *
+     * This is useful for scenarios that need to extract structured information
+     * (like classifications, scores, tags, etc.) from AI responses.
+     *
+     * @default false
+     */
+    structuredStreamMode?: boolean;
+    /**
+     * Custom structured stream instructions configuration
+     *
+     * Allows customization of structured stream mode behavior, including:
+     * - instructions: Prompt instructions to guide the AI model on how to output structured data
+     * - metadataStart: Metadata start marker (e.g., "<metadata>")
+     * - metadataEnd: Metadata end marker (e.g., "</metadata>")
+     * - parse: Function to parse metadata content, converting raw string to object
+     *
+     * If not provided, the default STRUCTURED_STREAM_INSTRUCTIONS configuration will be used,
+     * which outputs structured data in YAML format within <metadata> tags.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   instructions: "Output metadata in JSON format at the end of response in markdown code block with json language",
+     *   metadataStart: "```json",
+     *   metadataEnd: "```",
+     *   parse: JSON.parse
+     * }
+     * ```
+     */
+    customStructuredStreamInstructions?: {
+        instructions: string | PromptBuilder;
+        metadataStart: string;
+        metadataEnd: string;
+        parse: (raw: string) => object;
+    };
     /**
      * Whether to include memory agents as tools for the AI model
      *
@@ -217,6 +259,38 @@ export declare class AIAgent<I extends Message = any, O extends Message = any> e
      * @default true
      */
     catchToolsError: boolean;
+    /**
+     * Whether to enable structured stream mode
+     *
+     * When enabled, the AI model's streaming response will be processed to extract
+     * structured metadata. The model needs to include specific format metadata tags
+     * (like <metadata></metadata>) in its response, which will be parsed as JSON
+     * objects and passed through the stream.
+     *
+     * This is useful for scenarios that need to extract structured information
+     * (like classifications, scores, tags, etc.) from AI responses.
+     *
+     * @default false
+     */
+    structuredStreamMode?: boolean;
+    /**
+     * Custom structured stream instructions configuration
+     *
+     * Allows customization of structured stream mode behavior, including:
+     * - instructions: Prompt instructions to guide the AI model on how to output structured data
+     * - metadataStart: Metadata start marker (e.g., "<metadata>")
+     * - metadataEnd: Metadata end marker (e.g., "</metadata>")
+     * - parse: Function to parse metadata content, converting raw string to object
+     *
+     * If not provided, the default STRUCTURED_STREAM_INSTRUCTIONS configuration will be used,
+     * which outputs structured data in YAML format within <metadata> tags.
+     */
+    customStructuredStreamInstructions?: {
+        instructions: PromptBuilder;
+        metadataStart: string;
+        metadataEnd: string;
+        parse: (raw: string) => object;
+    };
     /**
      * Process an input message and generate a response
      *

package/lib/esm/agents/ai-agent.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
+import { STRUCTURED_STREAM_INSTRUCTIONS } from "../prompt/prompts/structured-stream-instructions.js";
 import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js";
+import { ExtractMetadataTransform } from "../utils/structured-stream-extractor.js";
 import { checkArguments, isEmpty } from "../utils/type-utils.js";
 import { Agent, agentOptionsSchema, isAgentResponseDelta, } from "./agent.js";
 import { isTransferAgentOutput } from "./types.js";
@@ -112,6 +114,13 @@ export class AIAgent extends Agent {
         this.memoryPromptTemplate = options.memoryPromptTemplate;
         if (typeof options.catchToolsError === "boolean")
             this.catchToolsError = options.catchToolsError;
+        this.structuredStreamMode = options.structuredStreamMode;
+        this.customStructuredStreamInstructions = options.customStructuredStreamInstructions && {
+            ...options.customStructuredStreamInstructions,
+            instructions: typeof options.customStructuredStreamInstructions.instructions === "string"
+                ? PromptBuilder.from(options.customStructuredStreamInstructions.instructions)
+                : options.customStructuredStreamInstructions.instructions,
+        };
         if (!this.inputKey && !this.instructions) {
             throw new Error("AIAgent requires either inputKey or instructions to be set");
         }
@@ -181,6 +190,33 @@ export class AIAgent extends Agent {
      * @default true
      */
     catchToolsError = true;
+    /**
+     * Whether to enable structured stream mode
+     *
+     * When enabled, the AI model's streaming response will be processed to extract
+     * structured metadata. The model needs to include specific format metadata tags
+     * (like <metadata></metadata>) in its response, which will be parsed as JSON
+     * objects and passed through the stream.
+     *
+     * This is useful for scenarios that need to extract structured information
+     * (like classifications, scores, tags, etc.) from AI responses.
+     *
+     * @default false
+     */
+    structuredStreamMode;
+    /**
+     * Custom structured stream instructions configuration
+     *
+     * Allows customization of structured stream mode behavior, including:
+     * - instructions: Prompt instructions to guide the AI model on how to output structured data
+     * - metadataStart: Metadata start marker (e.g., "<metadata>")
+     * - metadataEnd: Metadata end marker (e.g., "</metadata>")
+     * - parse: Function to parse metadata content, converting raw string to object
+     *
+     * If not provided, the default STRUCTURED_STREAM_INSTRUCTIONS configuration will be used,
+     * which outputs structured data in YAML format within <metadata> tags.
+     */
+    customStructuredStreamInstructions;
     /**
      * Process an input message and generate a response
      *
@@ -204,7 +240,11 @@ export class AIAgent extends Agent {
         const outputKey = this.outputKey;
         for (;;) {
             const modelOutput = {};
-            const stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
+            let stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
+            if (this.structuredStreamMode) {
+                const { metadataStart, metadataEnd, parse } = this.customStructuredStreamInstructions || STRUCTURED_STREAM_INSTRUCTIONS;
+                stream = stream.pipeThrough(new ExtractMetadataTransform({ start: metadataStart, end: metadataEnd, parse }));
+            }
             for await (const value of stream) {
                 if (isAgentResponseDelta(value)) {
                     if (value.delta.text?.text) {
@@ -243,7 +283,7 @@ export class AIAgent extends Agent {
                 }
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
-                    toolCallMessages.push(AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => ToolMessageTemplate.from(output, call.id).format()));
+                    toolCallMessages.push(await AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...(await Promise.all(executedToolCalls.map(({ call, output }) => ToolMessageTemplate.from(output, call.id).format()))));
                     continue;
                 }
             }
@@ -251,7 +291,7 @@ export class AIAgent extends Agent {
             if (json) {
                 Object.assign(result, json);
             }
-            else if (text) {
+            if (text) {
                 Object.assign(result, { [outputKey]: text });
             }
             if (!isEmpty(result)) {
@@ -275,7 +315,7 @@ export class AIAgent extends Agent {
      * @protected
      */
     async *_processRouter(input, model, modelInput, options, toolsMap) {
-        const { toolCalls: [call] = [], } = await options.context.invoke(model, modelInput);
+        const { toolCalls: [call] = [] } = await options.context.invoke(model, modelInput);
         if (!call) {
             throw new Error("Router toolChoice requires exactly one tool to be executed");
         }

package/lib/esm/agents/user-agent.js

@@ -1,5 +1,5 @@
 import { toMessagePayload } from "../aigne/message-queue.js";
-import { orArrayToArray } from "../utils/type-utils.js";
+import { flat } from "../utils/type-utils.js";
 import { Agent, } from "./agent.js";
 export class UserAgent extends Agent {
     tag = "UserAgent";
@@ -67,7 +67,7 @@ export class UserAgent extends Agent {
         let subscriptions = [];
         return new ReadableStream({
             start: (controller) => {
-                const subscribeTopic = orArrayToArray(this.subscribeTopic);
+                const subscribeTopic = flat(this.subscribeTopic);
                 subscriptions = subscribeTopic.map((topic) => this.subscribe(topic, (message) => {
                     controller.enqueue({ ...message, topic });
                 }));

package/lib/esm/aigne/context.d.ts

@@ -54,11 +54,15 @@ export interface InvokeOptions<U extends UserContext = UserContext> extends Part
      * @default true
      */
     newContext?: boolean;
+    userContext?: U;
+    memories?: Pick<Memory, "content">[];
 }
 /**
  * @hidden
  */
 export interface UserContext extends Record<string, unknown> {
+    userId?: string;
+    sessionId?: string;
 }
 /**
  * @hidden

package/lib/esm/aigne/context.js

@@ -1,4 +1,4 @@
-import { SpanStatusCode, context, trace } from "@opentelemetry/api";
+import { context, SpanStatusCode, trace } from "@opentelemetry/api";
 import equal from "fast-deep-equal";
 import { Emitter } from "strict-event-emitter";
 import { v7 } from "uuid";
@@ -231,22 +231,12 @@ export class AIGNEContext {
                         span.setAttribute("output", JSON.stringify({}));
                     }
                     span.setStatus({ code: SpanStatusCode.OK });
-                    await this.observer?.traceExporter
-                        ?.upsertInitialSpan?.(span)
-                        .catch((err) => {
-                        logger.error("upsertInitialSpan error", err?.message || err);
-                    });
                     span.end();
                     break;
                 }
                 case "agentFailed": {
                     const { error } = args[0];
                     span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
-                    await this.observer?.traceExporter
-                        ?.upsertInitialSpan?.(span)
-                        .catch((err) => {
-                        logger.error("upsertInitialSpan error", err?.message || err);
-                    });
                     span.end();
                     break;
                 }

package/lib/esm/aigne/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./context.js";
 export * from "./aigne.js";
+export * from "./context.js";
 export * from "./message-queue.js";
 export * from "./usage.js";

package/lib/esm/aigne/index.js

@@ -1,4 +1,4 @@
-export * from "./context.js";
 export * from "./aigne.js";
+export * from "./context.js";
 export * from "./message-queue.js";
 export * from "./usage.js";

package/lib/esm/aigne/message-queue.js

@@ -1,6 +1,6 @@
 import { Emitter } from "strict-event-emitter";
 import { z } from "zod";
-import { checkArguments, isNil, orArrayToArray } from "../utils/type-utils.js";
+import { checkArguments, flat, isNil } from "../utils/type-utils.js";
 /**
  * @hidden
  */
@@ -41,7 +41,7 @@ export class MessageQueue {
             topic,
             payload,
         });
-        for (const t of orArrayToArray(topic)) {
+        for (const t of flat(topic)) {
             this.events.emit(t, payload);
         }
     }
@@ -72,18 +72,18 @@ export class MessageQueue {
             topic,
             listener,
         });
-        for (const t of orArrayToArray(topic)) {
+        for (const t of flat(topic)) {
             this.events.off(t, listener);
         }
     }
 }
 function on(events, event, listener) {
-    orArrayToArray(event).forEach((e) => events.on(e, listener));
-    return () => orArrayToArray(event).forEach((e) => events.off(e, listener));
+    flat(event).forEach((e) => events.on(e, listener));
+    return () => flat(event).forEach((e) => events.off(e, listener));
 }
 function once(events, event, listener) {
-    orArrayToArray(event).forEach((e) => events.once(e, listener));
-    return () => orArrayToArray(event).forEach((e) => events.off(e, listener));
+    flat(event).forEach((e) => events.once(e, listener));
+    return () => flat(event).forEach((e) => events.off(e, listener));
 }
 const subscribeArgsSchema = z.object({
     topic: z.union([z.string(), z.array(z.string())]),

package/lib/esm/loader/agent-js.js

@@ -12,7 +12,7 @@ const agentJsFileSchema = z.object({
     process: z.custom(),
 });
 export async function loadAgentFromJsFile(path) {
-    const { default: agent } = await tryOrThrow(() => import(path), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    const { default: agent } = await tryOrThrow(() => import(/* @vite-ignore */ path), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     if (agent instanceof Agent)
         return agent;
     if (typeof agent !== "function") {

package/lib/esm/loader/index.js

@@ -6,6 +6,7 @@ import { AIAgent } from "../agents/ai-agent.js";
 import { MCPAgent } from "../agents/mcp-agent.js";
 import { TeamAgent } from "../agents/team-agent.js";
 import { TransformAgent } from "../agents/transform-agent.js";
+import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
 import { loadAgentFromYamlFile } from "./agent-yaml.js";
@@ -55,6 +56,8 @@ async function parseAgent(path, agent, options) {
         case "ai": {
             return AIAgent.from({
                 ...agent,
+                instructions: agent.instructions &&
+                    PromptBuilder.from(agent.instructions, { workingDir: nodejs.path.dirname(path) }),
                 memory,
                 skills,
             });

package/lib/esm/prompt/prompt-builder.d.ts

@@ -5,8 +5,9 @@ import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
+    workingDir?: string;
 }
-export interface PromptBuildOptions extends Pick<AgentInvokeOptions, "context"> {
+export interface PromptBuildOptions extends Partial<Pick<AgentInvokeOptions, "context">> {
     agent?: AIAgent;
     input?: Message;
     model?: ChatModel;
@@ -15,11 +16,14 @@ export interface PromptBuildOptions extends Pick<AgentInvokeOptions, "context">
 export declare class PromptBuilder {
     static from(instructions: string | {
         path: string;
-    } | GetPromptResult): PromptBuilder;
+    } | GetPromptResult, { workingDir }?: {
+        workingDir?: string;
+    }): PromptBuilder;
     private static fromFile;
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
     instructions?: string | ChatMessagesTemplate;
+    workingDir?: string;
     build(options: PromptBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;

package/lib/esm/prompt/prompt-builder.js

@@ -1,24 +1,26 @@
 import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import { stringify } from "yaml";
 import { ZodObject } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
 import { Agent } from "../agents/agent.js";
 import { outputSchemaToResponseFormatSchema } from "../utils/json-schema.js";
-import { unique } from "../utils/type-utils.js";
+import { isRecord, unique } from "../utils/type-utils.js";
 import { MEMORY_MESSAGE_TEMPLATE } from "./prompts/memory-message-template.js";
+import { STRUCTURED_STREAM_INSTRUCTIONS } from "./prompts/structured-stream-instructions.js";
 import { AgentMessageTemplate, ChatMessagesTemplate, PromptTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
 export class PromptBuilder {
-    static from(instructions) {
+    static from(instructions, { workingDir } = {}) {
         if (typeof instructions === "string")
-            return new PromptBuilder({ instructions });
+            return new PromptBuilder({ instructions, workingDir: workingDir });
         if (isFromPromptResult(instructions))
             return PromptBuilder.fromMCPPromptResult(instructions);
         if (isFromPath(instructions))
-            return PromptBuilder.fromFile(instructions.path);
+            return PromptBuilder.fromFile(instructions.path, { workingDir });
         throw new Error(`Invalid instructions ${instructions}`);
     }
-    static fromFile(path) {
+    static fromFile(path, { workingDir }) {
         const text = nodejs.fsSync.readFileSync(path, "utf-8");
-        return PromptBuilder.from(text);
+        return PromptBuilder.from(text, { workingDir: workingDir || nodejs.path.dirname(path) });
     }
     static fromMCPPromptResult(result) {
         return new PromptBuilder({
@@ -50,12 +52,16 @@ export class PromptBuilder {
     }
     constructor(options) {
         this.instructions = options?.instructions;
+        this.workingDir = options?.workingDir;
     }
     instructions;
+    workingDir;
     async build(options) {
         return {
             messages: await this.buildMessages(options),
-            responseFormat: this.buildResponseFormat(options),
+            responseFormat: options.agent?.structuredStreamMode
+                ? undefined
+                : this.buildResponseFormat(options),
             ...this.buildTools(options),
         };
     }
@@ -63,18 +69,30 @@ export class PromptBuilder {
         const { input } = options;
         const inputKey = options.agent?.inputKey;
         const message = inputKey && typeof input?.[inputKey] === "string" ? input[inputKey] : undefined;
-        const messages = (typeof this.instructions === "string"
+        const messages = (await (typeof this.instructions === "string"
             ? ChatMessagesTemplate.from([SystemMessageTemplate.from(this.instructions)])
-            : this.instructions)?.format(options.input) ?? [];
+            : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [];
         const memories = [];
-        if (options.agent?.inputKey) {
-            memories.push(...(await options.agent.retrieveMemories({ search: message }, options)));
+        if (options.agent && options.context) {
+            memories.push(...(await options.agent.retrieveMemories({ search: message }, { context: options.context })));
         }
-        if (options.context.memories?.length) {
+        if (options.context?.memories?.length) {
             memories.push(...options.context.memories);
         }
         if (memories.length)
-            messages.push(...this.convertMemoriesToMessages(memories, options));
+            messages.push(...(await this.convertMemoriesToMessages(memories, options)));
+        // if the agent is using structured stream mode, add the instructions
+        const { structuredStreamMode, outputSchema } = options.agent || {};
+        if (structuredStreamMode && outputSchema) {
+            const instructions = options.agent?.customStructuredStreamInstructions?.instructions ||
+                PromptBuilder.from(STRUCTURED_STREAM_INSTRUCTIONS.instructions);
+            messages.push(...(await instructions.buildMessages({
+                input: {
+                    ...input,
+                    outputJsonSchema: zodToJsonSchema(outputSchema),
+                },
+            })));
+        }
         if (message) {
             messages.push({
                 role: "user",
@@ -83,14 +101,25 @@ export class PromptBuilder {
         }
         return messages;
     }
-    convertMemoriesToMessages(memories, options) {
-        const str = stringify(memories.map((i) => i.content));
-        return [
-            {
+    async convertMemoriesToMessages(memories, options) {
+        const messages = [];
+        const other = [];
+        const stringOrStringify = (value) => typeof value === "string" ? value : stringify(value);
+        for (const { content } of memories) {
+            if (isRecord(content) && "input" in content && "output" in content) {
+                messages.push({ role: "user", content: stringOrStringify(content.input) }, { role: "agent", content: stringOrStringify(content.output) });
+            }
+            else {
+                other.push(content);
+            }
+        }
+        if (other.length) {
+            messages.unshift({
                 role: "system",
-                content: PromptTemplate.from(options.agent?.memoryPromptTemplate || MEMORY_MESSAGE_TEMPLATE).format({ memories: str }),
-            },
-        ];
+                content: await PromptTemplate.from(options.agent?.memoryPromptTemplate || MEMORY_MESSAGE_TEMPLATE).format({ memories: stringify(other) }),
+            });
+        }
+        return messages;
     }
     buildResponseFormat(options) {
         const outputSchema = options.outputSchema || options.agent?.outputSchema;

package/lib/esm/prompt/prompts/memory-message-template.d.ts

@@ -1 +1 @@
-export declare const MEMORY_MESSAGE_TEMPLATE = "Here are some useful memories to consider:\n\n<memories>\n{{memories}}\n</memories>\n";
+export declare const MEMORY_MESSAGE_TEMPLATE = "<related-memories>\n{{memories}}\n</related-memories>\n";

package/lib/esm/prompt/prompts/memory-message-template.js

@@ -1,7 +1,5 @@
 export const MEMORY_MESSAGE_TEMPLATE = `\
-Here are some useful memories to consider:
-
-<memories>
+<related-memories>
 {{memories}}
-</memories>
+</related-memories>
 `;

package/lib/esm/prompt/prompts/structured-stream-instructions.d.ts

@@ -0,0 +1,7 @@
+import { parse } from "yaml";
+export declare const STRUCTURED_STREAM_INSTRUCTIONS: {
+    instructions: string;
+    metadataStart: string;
+    metadataEnd: string;
+    parse: typeof parse;
+};

package/lib/esm/prompt/prompts/structured-stream-instructions.js

@@ -0,0 +1,24 @@
+import { parse } from "yaml";
+export const STRUCTURED_STREAM_INSTRUCTIONS = {
+    instructions: `\
+<output-rules>
+- First, output the regular response content.
+- At the end of the response, use <metadata></metadata> tags to output metadata. The metadata should be output in YAML format as structured data, and must conform to the format defined in <metadata-schema></metadata-schema>.
+</output-rules>
+
+<metadata-schema>
+{{outputJsonSchema}}
+</metadata-schema>
+
+<output-example>
+Here is the regular response content
+<metadata>
+foo: bar
+baz: 123
+</metadata>
+</output-example>
+`,
+    metadataStart: "<metadata>",
+    metadataEnd: "</metadata>",
+    parse,
+};

package/lib/esm/prompt/template.d.ts

@@ -1,16 +1,30 @@
+import nunjucks, { type Callback, type LoaderSource } from "nunjucks";
 import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../agents/chat-model.js";
+export interface FormatOptions {
+    workingDir?: string;
+}
 export declare class PromptTemplate {
     template: string;
     static from(template: string): PromptTemplate;
     constructor(template: string);
-    format(variables?: Record<string, unknown>): string;
+    format(variables?: Record<string, unknown>, options?: FormatOptions): Promise<string>;
+}
+export declare class CustomLoader extends nunjucks.Loader {
+    options: {
+        workingDir: string;
+    };
+    constructor(options: {
+        workingDir: string;
+    });
+    async: boolean;
+    getSource(name: string, callback: Callback<Error, LoaderSource>): LoaderSource;
 }
 export declare class ChatMessageTemplate {
     role: "system" | "user" | "agent" | "tool";
     content?: ChatModelInputMessage["content"];
     name?: string | undefined;
     constructor(role: "system" | "user" | "agent" | "tool", content?: ChatModelInputMessage["content"], name?: string | undefined);
-    format(variables?: Record<string, unknown>): ChatModelInputMessage;
+    format(variables?: Record<string, unknown>, options?: FormatOptions): Promise<ChatModelInputMessage>;
 }
 export declare class SystemMessageTemplate extends ChatMessageTemplate {
     static from(content: string, name?: string): SystemMessageTemplate;
@@ -22,19 +36,19 @@ export declare class AgentMessageTemplate extends ChatMessageTemplate {
     toolCalls?: ChatModelOutputToolCall[] | undefined;
     static from(template?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[], name?: string): AgentMessageTemplate;
     constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
-    format(variables?: Record<string, unknown>): {
+    format(variables?: Record<string, unknown>, options?: FormatOptions): Promise<{
         toolCalls: ChatModelOutputToolCall[] | undefined;
         role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCallId?: string;
         name?: string;
-    };
+    }>;
 }
 export declare class ToolMessageTemplate extends ChatMessageTemplate {
     toolCallId: string;
     static from(content: object | string, toolCallId: string, name?: string): ToolMessageTemplate;
     constructor(content: object | string, toolCallId: string, name?: string);
-    format(variables?: Record<string, unknown>): {
+    format(variables?: Record<string, unknown>, options?: FormatOptions): Promise<{
         toolCallId: string;
         role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
@@ -47,12 +61,12 @@ export declare class ToolMessageTemplate extends ChatMessageTemplate {
             };
         }[];
         name?: string;
-    };
+    }>;
 }
 export declare class ChatMessagesTemplate {
     messages: ChatMessageTemplate[];
     static from(messages: ChatMessageTemplate[] | string): ChatMessagesTemplate;
     constructor(messages: ChatMessageTemplate[]);
-    format(variables?: Record<string, unknown>): ChatModelInputMessage[];
+    format(variables?: Record<string, unknown>, options?: FormatOptions): Promise<ChatModelInputMessage[]>;
 }
 export declare function parseChatMessages(messages: unknown): ChatMessageTemplate[] | undefined;