@aigne/core 1.29.1 → 1.32.0

package/CHANGELOG.md

@@ -12,6 +12,58 @@
   * dependencies
     * @aigne/observability bumped to 0.1.0
 
+## [1.32.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.31.0...core-v1.32.0) (2025-07-08)
+
+
+### Features
+
+* **core:** add jinja syntax support for prompt builder ([#230](https://github.com/AIGNE-io/aigne-framework/issues/230)) ([74436a7](https://github.com/AIGNE-io/aigne-framework/commit/74436a7faac0c59a32b0153481386162649f4357))
+* support setting component id to different component data ([#226](https://github.com/AIGNE-io/aigne-framework/issues/226)) ([c7b3224](https://github.com/AIGNE-io/aigne-framework/commit/c7b32240e6660f34974615bcb9b91978a1191e3e))
+
+
+### Bug Fixes
+
+* **core:** ensure output is a record type ([#228](https://github.com/AIGNE-io/aigne-framework/issues/228)) ([dfd9104](https://github.com/AIGNE-io/aigne-framework/commit/dfd910451e5f1f9edd94a719857e36d34fadbe45))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/observability-api bumped to 0.6.0
+
+## [1.31.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.30.0...core-v1.31.0) (2025-07-04)
+
+
+### Features
+
+* **core:** add standard userId/sessionId in userContext ([#219](https://github.com/AIGNE-io/aigne-framework/issues/219)) ([58e5804](https://github.com/AIGNE-io/aigne-framework/commit/58e5804cf08b1d2fa6e232646fadd70b5db2e007))
+* **core:** add strucutredStreamMode option for AIAgent to support text and json output in one-shot ([#222](https://github.com/AIGNE-io/aigne-framework/issues/222)) ([c0af92b](https://github.com/AIGNE-io/aigne-framework/commit/c0af92b6a020453b047e5bb3782239795839baa8))
+* **memory:** add support for AgenticMemory & some improvements for DefaultMemory ([#224](https://github.com/AIGNE-io/aigne-framework/issues/224)) ([f4a08af](https://github.com/AIGNE-io/aigne-framework/commit/f4a08aff935205c62615c060763c835a9579607d))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/observability-api bumped to 0.5.0
+    * @aigne/platform-helpers bumped to 0.3.0
+
+## [1.30.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.29.1...core-v1.30.0) (2025-07-03)
+
+
+### Features
+
+* upgrade dependencies and adapt code to breaking changes ([#216](https://github.com/AIGNE-io/aigne-framework/issues/216)) ([f215ced](https://github.com/AIGNE-io/aigne-framework/commit/f215cedc1a57e321164064c33316e496eae8d25f))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/observability-api bumped to 0.4.0
+    * @aigne/platform-helpers bumped to 0.2.0
+
 ## [1.29.1](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.29.0...core-v1.29.1) (2025-07-02)
 
 

package/lib/cjs/agents/agent.d.ts

@@ -137,8 +137,6 @@ export interface AgentInvokeOptions<U extends UserContext = UserContext> {
      * and returns the final JSON result
      */
     streaming?: boolean;
-    userContext?: U;
-    memories?: Pick<Memory, "content">[];
 }
 /**
  * Agent is the base class for all agents.

package/lib/cjs/agents/agent.js

@@ -267,7 +267,7 @@ class Agent {
         this.subscribeToTopics(context);
     }
     subscribeToTopics(context) {
-        for (const topic of (0, type_utils_js_1.orArrayToArray)(this.subscribeTopic).concat(this.topic)) {
+        for (const topic of (0, type_utils_js_1.flat)(this.subscribeTopic).concat(this.topic)) {
             this.subscriptions.push(context.subscribe(topic, (payload) => this.onMessage(payload)));
         }
     }
@@ -336,14 +336,6 @@ class Agent {
             ...options,
             context: options.context ?? (await this.newDefaultContext()),
         };
-        if (options.userContext) {
-            Object.assign(opts.context.userContext, options.userContext);
-            options.userContext = undefined;
-        }
-        if (options.memories?.length) {
-            opts.context.memories.push(...options.memories);
-            options.memories = undefined;
-        }
         logger_js_1.logger.debug("Invoke agent %s started with input: %O", this.name, input);
         if (!this.disableEvents)
             opts.context.emit("agentStarted", { agent: this, input });
@@ -402,6 +394,9 @@ class Agent {
      */
     async processAgentOutput(input, output, options) {
         const { context } = options;
+        if (!(0, type_utils_js_1.isRecord)(output)) {
+            throw new Error(`expect to return a record type such as {result: ...}, but got (${typeof output}): ${output}`);
+        }
         const parsedOutput = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} output`, this.outputSchema, output);
         const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
         await this.postprocess(input, finalOutput, options);

package/lib/cjs/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/cjs/agents/ai-agent.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIAgent = exports.aiAgentOptionsSchema = exports.aiAgentToolChoiceSchema = exports.AIAgentToolChoice = exports.DEFAULT_OUTPUT_KEY = void 0;
 const zod_1 = require("zod");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
+const structured_stream_instructions_js_1 = require("../prompt/prompts/structured-stream-instructions.js");
 const template_js_1 = require("../prompt/template.js");
+const structured_stream_extractor_js_1 = require("../utils/structured-stream-extractor.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
 const types_js_1 = require("./types.js");
@@ -115,6 +117,13 @@ class AIAgent extends agent_js_1.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"
+                ? prompt_builder_js_1.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");
         }
@@ -184,6 +193,33 @@ class AIAgent extends agent_js_1.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
      *
@@ -207,7 +243,11 @@ class AIAgent extends agent_js_1.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_js_1.STRUCTURED_STREAM_INSTRUCTIONS;
+                stream = stream.pipeThrough(new structured_stream_extractor_js_1.ExtractMetadataTransform({ start: metadataStart, end: metadataEnd, parse }));
+            }
             for await (const value of stream) {
                 if ((0, agent_js_1.isAgentResponseDelta)(value)) {
                     if (value.delta.text?.text) {
@@ -246,7 +286,7 @@ class AIAgent extends agent_js_1.Agent {
                 }
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
-                    toolCallMessages.push(template_js_1.AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => template_js_1.ToolMessageTemplate.from(output, call.id).format()));
+                    toolCallMessages.push(await template_js_1.AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...(await Promise.all(executedToolCalls.map(({ call, output }) => template_js_1.ToolMessageTemplate.from(output, call.id).format()))));
                     continue;
                 }
             }
@@ -254,7 +294,7 @@ class AIAgent extends agent_js_1.Agent {
             if (json) {
                 Object.assign(result, json);
             }
-            else if (text) {
+            if (text) {
                 Object.assign(result, { [outputKey]: text });
             }
             if (!(0, type_utils_js_1.isEmpty)(result)) {
@@ -278,7 +318,7 @@ class AIAgent extends agent_js_1.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/cjs/agents/user-agent.js

@@ -70,7 +70,7 @@ class UserAgent extends agent_js_1.Agent {
         let subscriptions = [];
         return new ReadableStream({
             start: (controller) => {
-                const subscribeTopic = (0, type_utils_js_1.orArrayToArray)(this.subscribeTopic);
+                const subscribeTopic = (0, type_utils_js_1.flat)(this.subscribeTopic);
                 subscriptions = subscribeTopic.map((topic) => this.subscribe(topic, (message) => {
                     controller.enqueue({ ...message, topic });
                 }));

package/lib/cjs/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/cjs/aigne/context.js

@@ -237,22 +237,12 @@ class AIGNEContext {
                         span.setAttribute("output", JSON.stringify({}));
                     }
                     span.setStatus({ code: api_1.SpanStatusCode.OK });
-                    await this.observer?.traceExporter
-                        ?.upsertInitialSpan?.(span)
-                        .catch((err) => {
-                        logger_js_1.logger.error("upsertInitialSpan error", err?.message || err);
-                    });
                     span.end();
                     break;
                 }
                 case "agentFailed": {
                     const { error } = args[0];
                     span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
-                    await this.observer?.traceExporter
-                        ?.upsertInitialSpan?.(span)
-                        .catch((err) => {
-                        logger_js_1.logger.error("upsertInitialSpan error", err?.message || err);
-                    });
                     span.end();
                     break;
                 }

package/lib/cjs/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/cjs/aigne/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./context.js"), exports);
 __exportStar(require("./aigne.js"), exports);
+__exportStar(require("./context.js"), exports);
 __exportStar(require("./message-queue.js"), exports);
 __exportStar(require("./usage.js"), exports);

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

@@ -45,7 +45,7 @@ class MessageQueue {
             topic,
             payload,
         });
-        for (const t of (0, type_utils_js_1.orArrayToArray)(topic)) {
+        for (const t of (0, type_utils_js_1.flat)(topic)) {
             this.events.emit(t, payload);
         }
     }
@@ -76,19 +76,19 @@ class MessageQueue {
             topic,
             listener,
         });
-        for (const t of (0, type_utils_js_1.orArrayToArray)(topic)) {
+        for (const t of (0, type_utils_js_1.flat)(topic)) {
             this.events.off(t, listener);
         }
     }
 }
 exports.MessageQueue = MessageQueue;
 function on(events, event, listener) {
-    (0, type_utils_js_1.orArrayToArray)(event).forEach((e) => events.on(e, listener));
-    return () => (0, type_utils_js_1.orArrayToArray)(event).forEach((e) => events.off(e, listener));
+    (0, type_utils_js_1.flat)(event).forEach((e) => events.on(e, listener));
+    return () => (0, type_utils_js_1.flat)(event).forEach((e) => events.off(e, listener));
 }
 function once(events, event, listener) {
-    (0, type_utils_js_1.orArrayToArray)(event).forEach((e) => events.once(e, listener));
-    return () => (0, type_utils_js_1.orArrayToArray)(event).forEach((e) => events.off(e, listener));
+    (0, type_utils_js_1.flat)(event).forEach((e) => events.once(e, listener));
+    return () => (0, type_utils_js_1.flat)(event).forEach((e) => events.off(e, listener));
 }
 const subscribeArgsSchema = zod_1.z.object({
     topic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),

package/lib/cjs/loader/index.js

@@ -12,6 +12,7 @@ const ai_agent_js_1 = require("../agents/ai-agent.js");
 const mcp_agent_js_1 = require("../agents/mcp-agent.js");
 const team_agent_js_1 = require("../agents/team-agent.js");
 const transform_agent_js_1 = require("../agents/transform-agent.js");
+const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_js_1 = require("./agent-js.js");
 const agent_yaml_js_1 = require("./agent-yaml.js");
@@ -61,6 +62,8 @@ async function parseAgent(path, agent, options) {
         case "ai": {
             return ai_agent_js_1.AIAgent.from({
                 ...agent,
+                instructions: agent.instructions &&
+                    prompt_builder_js_1.PromptBuilder.from(agent.instructions, { workingDir: index_js_1.nodejs.path.dirname(path) }),
                 memory,
                 skills,
             });

package/lib/cjs/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/cjs/prompt/prompt-builder.js

@@ -4,24 +4,26 @@ exports.PromptBuilder = void 0;
 const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
 const yaml_1 = require("yaml");
 const zod_1 = require("zod");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
 const agent_js_1 = require("../agents/agent.js");
 const json_schema_js_1 = require("../utils/json-schema.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const memory_message_template_js_1 = require("./prompts/memory-message-template.js");
+const structured_stream_instructions_js_1 = require("./prompts/structured-stream-instructions.js");
 const template_js_1 = require("./template.js");
 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 = index_js_1.nodejs.fsSync.readFileSync(path, "utf-8");
-        return PromptBuilder.from(text);
+        return PromptBuilder.from(text, { workingDir: workingDir || index_js_1.nodejs.path.dirname(path) });
     }
     static fromMCPPromptResult(result) {
         return new PromptBuilder({
@@ -53,12 +55,16 @@ 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),
         };
     }
@@ -66,18 +72,30 @@ 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"
             ? template_js_1.ChatMessagesTemplate.from([template_js_1.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_js_1.STRUCTURED_STREAM_INSTRUCTIONS.instructions);
+            messages.push(...(await instructions.buildMessages({
+                input: {
+                    ...input,
+                    outputJsonSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(outputSchema),
+                },
+            })));
+        }
         if (message) {
             messages.push({
                 role: "user",
@@ -86,14 +104,25 @@ class PromptBuilder {
         }
         return messages;
     }
-    convertMemoriesToMessages(memories, options) {
-        const str = (0, yaml_1.stringify)(memories.map((i) => i.content));
-        return [
-            {
+    async convertMemoriesToMessages(memories, options) {
+        const messages = [];
+        const other = [];
+        const stringOrStringify = (value) => typeof value === "string" ? value : (0, yaml_1.stringify)(value);
+        for (const { content } of memories) {
+            if ((0, type_utils_js_1.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: template_js_1.PromptTemplate.from(options.agent?.memoryPromptTemplate || memory_message_template_js_1.MEMORY_MESSAGE_TEMPLATE).format({ memories: str }),
-            },
-        ];
+                content: await template_js_1.PromptTemplate.from(options.agent?.memoryPromptTemplate || memory_message_template_js_1.MEMORY_MESSAGE_TEMPLATE).format({ memories: (0, yaml_1.stringify)(other) }),
+            });
+        }
+        return messages;
     }
     buildResponseFormat(options) {
         const outputSchema = options.outputSchema || options.agent?.outputSchema;

package/lib/cjs/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/cjs/prompt/prompts/memory-message-template.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MEMORY_MESSAGE_TEMPLATE = void 0;
 exports.MEMORY_MESSAGE_TEMPLATE = `\
-Here are some useful memories to consider:
-
-<memories>
+<related-memories>
 {{memories}}
-</memories>
+</related-memories>
 `;

package/lib/cjs/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/cjs/prompt/prompts/structured-stream-instructions.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRUCTURED_STREAM_INSTRUCTIONS = void 0;
+const yaml_1 = require("yaml");
+exports.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: yaml_1.parse,
+};