@aigne/core 1.57.5 → 1.58.0

package/lib/esm/agents/chat-model.d.ts

@@ -104,6 +104,10 @@ export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelO
      * @returns A promise or direct value containing the model's response
      */
     abstract process(input: ChatModelInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    transformFileOutput(input: ChatModelInput, data: FileUnionContent, options: AgentInvokeOptions): Promise<FileUnionContent>;
+    static getFileExtension(type: string): string | undefined;
+    static getMimeType(filename: string): string | undefined;
+    protected downloadFile(url: string): Promise<Response>;
 }
 /**
  * Input message format for ChatModel
@@ -128,6 +132,7 @@ export interface ChatModelInput extends Message {
      * Specifies the expected response format
      */
     responseFormat?: ChatModelInputResponseFormat;
+    fileOutputType?: FileOutputType;
     /**
      * List of tools available for the model to use
      */
@@ -190,7 +195,7 @@ export interface ChatModelInputMessage {
  *
  * Can be a simple string, or a mixed array of text and image content
  */
-export type ChatModelInputMessageContent = string | (TextContent | ImageUrlContent)[];
+export type ChatModelInputMessageContent = string | UnionContent[];
 /**
  * Text content type
  *
@@ -200,15 +205,304 @@ export type TextContent = {
     type: "text";
     text: string;
 };
+export declare const textContentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    text: string;
+}, {
+    type: "text";
+    text: string;
+}>;
+export interface FileContentBase {
+    filename?: string;
+    mimeType?: string;
+}
+export declare const fileContentBaseSchema: z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+}, "strip", z.ZodTypeAny, {
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>;
 /**
  * Image URL content type
  *
  * Used for image parts of message content, referencing images via URL
  */
-export type ImageUrlContent = {
-    type: "image_url";
+export interface UrlContent extends FileContentBase {
+    type: "url";
     url: string;
-};
+}
+export declare const urlContentSchema: z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>;
+export interface FileContent extends FileContentBase {
+    type: "file";
+    data: string;
+}
+export declare const fileContentSchema: z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"file">;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>;
+export interface LocalContent extends FileContentBase {
+    type: "local";
+    path: string;
+}
+export declare const localContentSchema: z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"local">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>;
+export type FileUnionContent = LocalContent | UrlContent | FileContent;
+export declare const fileUnionContentSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"local">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"file">;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>]>;
+export declare const fileUnionContentsSchema: z.ZodUnion<[z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"local">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"file">;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>]>, z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"local">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"file">;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>]>, "many">]>;
+export type UnionContent = TextContent | FileUnionContent;
+export declare const unionContentSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    text: string;
+}, {
+    type: "text";
+    text: string;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"local">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    path: string;
+    type: "local";
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "url";
+    url: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>, z.ZodObject<{
+    filename: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+} & {
+    type: z.ZodLiteral<"file">;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}, {
+    type: "file";
+    data: string;
+    filename?: string | undefined;
+    mimeType?: string | undefined;
+}>]>;
 /**
  * Model response format settings
  *
@@ -277,6 +571,7 @@ export type ChatModelInputToolChoice = "auto" | "none" | "required" | {
         description?: string;
     };
 };
+export type Modality = "text" | "image" | "audio";
 /**
  * Model-specific configuration options
  *
@@ -307,6 +602,7 @@ export interface ChatModelOptions {
      * Whether to allow parallel tool calls
      */
     parallelToolCalls?: boolean;
+    modalities?: Modality[];
 }
 /**
  * Output message format for ChatModel
@@ -342,6 +638,11 @@ export interface ChatModelOutput extends Message {
      * Model name or version used
      */
     model?: string;
+    files?: FileUnionContent[];
+}
+export declare enum FileOutputType {
+    local = "local",
+    file = "file"
 }
 /**
  * Tool call information in model output

package/lib/esm/agents/chat-model.js

@@ -1,6 +1,10 @@
+import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import { Ajv } from "ajv";
+import mime from "mime";
+import { v7 } from "uuid";
 import { z } from "zod";
-import { checkArguments } from "../utils/type-utils.js";
+import { optionalize } from "../loader/schema.js";
+import { checkArguments, pick } from "../utils/type-utils.js";
 import { Agent, agentOptionsSchema, } from "./agent.js";
 const CHAT_MODEL_DEFAULT_RETRY_OPTIONS = {
     retries: 3,
@@ -170,18 +174,100 @@ export class ChatModel extends Agent {
                 options.context.usage.aigneHubCredits += usage.aigneHubCredits;
         }
     }
+    async transformFileOutput(input, data, options) {
+        const fileOutputType = input.fileOutputType || FileOutputType.local;
+        if (fileOutputType === data.type)
+            return data;
+        const common = pick(data, "filename", "mimeType");
+        switch (fileOutputType) {
+            case FileOutputType.local: {
+                const dir = nodejs.path.join(nodejs.os.tmpdir(), options.context.id);
+                await nodejs.fs.mkdir(dir, { recursive: true });
+                const ext = ChatModel.getFileExtension(data.mimeType || data.filename || "");
+                const id = v7();
+                const filename = ext ? `${id}.${ext}` : id;
+                const path = nodejs.path.join(dir, filename);
+                if (data.type === "file") {
+                    await nodejs.fs.writeFile(path, data.data, "base64");
+                }
+                else if (data.type === "url") {
+                    await this.downloadFile(data.url)
+                        .then((res) => res.body)
+                        .then((body) => body && nodejs.fs.writeFile(path, body));
+                }
+                else {
+                    throw new Error(`Unexpected file type: ${data.type}`);
+                }
+                return { ...common, type: "local", path };
+            }
+            case FileOutputType.file: {
+                let base64;
+                if (data.type === "local") {
+                    base64 = await nodejs.fs.readFile(data.path, "base64");
+                }
+                else if (data.type === "url") {
+                    base64 = Buffer.from(await (await this.downloadFile(data.url)).arrayBuffer()).toString("base64");
+                }
+                else {
+                    throw new Error(`Unexpected file type: ${data.type}`);
+                }
+                return { ...common, type: "file", data: base64 };
+            }
+        }
+    }
+    static getFileExtension(type) {
+        return mime.getExtension(type) || undefined;
+    }
+    static getMimeType(filename) {
+        return mime.getType(filename) || undefined;
+    }
+    async downloadFile(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            const text = await response.text().catch(() => null);
+            throw new Error(`Failed to download content from ${url}, ${response.status} ${response.statusText} ${text}`);
+        }
+        return response;
+    }
 }
+export const textContentSchema = z.object({
+    type: z.literal("text"),
+    text: z.string(),
+});
+export const fileContentBaseSchema = z.object({
+    filename: optionalize(z.string()),
+    mimeType: optionalize(z.string()),
+});
+export const urlContentSchema = fileContentBaseSchema.extend({
+    type: z.literal("url"),
+    url: z.string(),
+});
+export const fileContentSchema = fileContentBaseSchema.extend({
+    type: z.literal("file"),
+    data: z.string(),
+});
+export const localContentSchema = fileContentBaseSchema.extend({
+    type: z.literal("local"),
+    path: z.string(),
+});
+export const fileUnionContentSchema = z.discriminatedUnion("type", [
+    localContentSchema,
+    urlContentSchema,
+    fileContentSchema,
+]);
+export const fileUnionContentsSchema = z.union([
+    fileUnionContentSchema,
+    z.array(fileUnionContentSchema),
+]);
+export const unionContentSchema = z.discriminatedUnion("type", [
+    textContentSchema,
+    localContentSchema,
+    urlContentSchema,
+    fileContentSchema,
+]);
 const chatModelInputMessageSchema = z.object({
     role: z.union([z.literal("system"), z.literal("user"), z.literal("agent"), z.literal("tool")]),
-    content: z
-        .union([
-        z.string(),
-        z.array(z.union([
-            z.object({ type: z.literal("text"), text: z.string() }),
-            z.object({ type: z.literal("image_url"), url: z.string() }),
-        ])),
-    ])
-        .optional(),
+    content: z.union([z.string(), z.array(unionContentSchema)]).optional(),
     toolCalls: z
         .array(z.object({
         id: z.string(),
@@ -228,6 +314,7 @@ const chatModelOptionsSchema = z.object({
     frequencyPenalty: z.number().optional(),
     presencePenalty: z.number().optional(),
     parallelToolCalls: z.boolean().optional().default(true),
+    modalities: z.array(z.enum(["text", "image", "audio"])).optional(),
 });
 const chatModelInputSchema = z.object({
     messages: z.array(chatModelInputMessageSchema),
@@ -236,6 +323,11 @@ const chatModelInputSchema = z.object({
     toolChoice: chatModelInputToolChoiceSchema.optional(),
     modelOptions: chatModelOptionsSchema.optional(),
 });
+export var FileOutputType;
+(function (FileOutputType) {
+    FileOutputType["local"] = "local";
+    FileOutputType["file"] = "file";
+})(FileOutputType || (FileOutputType = {}));
 const chatModelOutputToolCallSchema = z.object({
     id: z.string(),
     type: z.literal("function"),
@@ -255,4 +347,5 @@ const chatModelOutputSchema = z.object({
     toolCalls: z.array(chatModelOutputToolCallSchema).optional(),
     usage: chatModelOutputUsageSchema.optional(),
     model: z.string().optional(),
+    files: z.array(fileUnionContentSchema).optional(),
 });

package/lib/esm/agents/image-model.d.ts

@@ -32,13 +32,13 @@ export declare const imageModelInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     model?: string | undefined;
-    responseFormat?: "url" | "base64" | undefined;
+    responseFormat?: "base64" | "url" | undefined;
     image?: string | string[] | undefined;
     n?: number | undefined;
 }, {
     prompt: string;
     model?: string | undefined;
-    responseFormat?: "url" | "base64" | undefined;
+    responseFormat?: "base64" | "url" | undefined;
     image?: string | string[] | undefined;
     n?: number | undefined;
 }>;

package/lib/esm/aigne/context.js

@@ -196,6 +196,8 @@ export class AIGNEContext {
         return this.internal.events.emit(eventName, ...newArgs);
     }
     async trace(eventName, args, b) {
+        if (process.env.AIGNE_OBSERVABILITY_DISABLED)
+            return;
         const span = this.span;
         if (!span)
             return;

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

@@ -1,7 +1,7 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
 import { Agent, type AgentInvokeOptions, type Message } from "../agents/agent.js";
-import type { AIAgent } from "../agents/ai-agent.js";
-import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
+import { type AIAgent } from "../agents/ai-agent.js";
+import { type ChatModel, type ChatModelInput } from "../agents/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;

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

@@ -3,8 +3,11 @@ import { stringify } from "yaml";
 import { ZodObject } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { Agent } from "../agents/agent.js";
+import { DEFAULT_FILE_OUTPUT_KEY, DEFAULT_OUTPUT_KEY } from "../agents/ai-agent.js";
+import { fileUnionContentsSchema, } from "../agents/chat-model.js";
+import { optionalize } from "../loader/schema.js";
 import { outputSchemaToResponseFormatSchema } from "../utils/json-schema.js";
-import { isNil, isRecord, unique } from "../utils/type-utils.js";
+import { checkArguments, flat, 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";
@@ -34,11 +37,11 @@ export class PromptBuilder {
                         content = resource.text;
                     }
                     else if (typeof resource.blob === "string") {
-                        content = [{ type: "image_url", url: resource.blob }];
+                        content = [{ type: "url", url: resource.blob }];
                     }
                 }
                 else if (i.content.type === "image") {
-                    content = [{ type: "image_url", url: i.content.data }];
+                    content = [{ type: "url", url: i.content.data }];
                 }
                 if (!content)
                     throw new Error(`Unsupported content type ${i.content.type}`);
@@ -62,6 +65,7 @@ export class PromptBuilder {
             responseFormat: options.agent?.structuredStreamMode
                 ? undefined
                 : this.buildResponseFormat(options),
+            fileOutputType: options.agent?.fileOutputType,
             ...this.buildTools(options),
         };
     }
@@ -80,6 +84,10 @@ export class PromptBuilder {
         const messages = (await (typeof this.instructions === "string"
             ? ChatMessagesTemplate.from([SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [];
+        const fileInputKey = options.agent?.fileInputKey;
+        const files = flat(fileInputKey
+            ? checkArguments("Check input files", optionalize(fileUnionContentsSchema), input?.[fileInputKey])
+            : null);
         const memories = [];
         if (options.agent && options.context) {
             memories.push(...(await options.agent.retrieveMemories({ search: message }, { context: options.context })));
@@ -101,26 +109,68 @@ export class PromptBuilder {
                 },
             })));
         }
-        if (message) {
-            messages.push({
-                role: "user",
-                content: message,
-            });
+        if (message || files.length) {
+            const content = [];
+            if (message)
+                content.push({ type: "text", text: message });
+            if (files.length)
+                content.push(...files);
+            messages.push({ role: "user", content });
         }
         return messages;
     }
     async convertMemoriesToMessages(memories, options) {
         const messages = [];
         const other = [];
+        const inputKey = options.agent?.inputKey;
+        const fileInputKey = options.agent?.fileInputKey;
+        const outputKey = options.agent?.outputKey || DEFAULT_OUTPUT_KEY;
+        const fileOutputKey = options.agent?.fileOutputKey || DEFAULT_FILE_OUTPUT_KEY;
         const stringOrStringify = (value) => typeof value === "string" ? value : stringify(value);
-        for (const { content } of memories) {
-            if (isRecord(content) && "input" in content && "output" in content) {
-                if (!isNil(content.input) && content.input !== "") {
-                    messages.push({ role: "user", content: stringOrStringify(content.input) });
+        const convertMemoryToMessage = async (content) => {
+            const { input, output } = content;
+            if (!input || !output)
+                return [];
+            const result = [];
+            const userMessageContent = [];
+            if (typeof input === "object") {
+                const inputMessage = inputKey ? Reflect.get(input, inputKey) : undefined;
+                const inputFiles = fileInputKey ? Reflect.get(input, fileInputKey) : undefined;
+                if (inputMessage) {
+                    userMessageContent.push({ type: "text", text: stringOrStringify(inputMessage) });
                 }
-                if (!isNil(content.output) && content.output !== "") {
-                    messages.push({ role: "agent", content: stringOrStringify(content.output) });
+                if (inputFiles) {
+                    userMessageContent.push(...flat(checkArguments("Check memory input files", optionalize(fileUnionContentsSchema), inputFiles)));
+                }
+            }
+            if (!userMessageContent.length) {
+                userMessageContent.push({ type: "text", text: stringOrStringify(input) });
+            }
+            result.push({ role: "user", content: userMessageContent });
+            const agentMessageContent = [];
+            if (typeof output === "object") {
+                const outputMessage = Reflect.get(output, outputKey);
+                const outputFiles = Reflect.get(output, fileOutputKey);
+                if (outputMessage) {
+                    agentMessageContent.push({ type: "text", text: stringOrStringify(outputMessage) });
                 }
+                if (outputFiles) {
+                    agentMessageContent.push(...flat(checkArguments("Check memory output files", optionalize(fileUnionContentsSchema), outputFiles)));
+                }
+            }
+            if (!agentMessageContent.length) {
+                agentMessageContent.push({ type: "text", text: stringOrStringify(output) });
+            }
+            result.push({ role: "agent", content: agentMessageContent });
+            return result;
+        };
+        for (const { content } of memories) {
+            if (isRecord(content) &&
+                "input" in content &&
+                content.input &&
+                "output" in content &&
+                content.output) {
+                messages.push(...(await convertMemoryToMessage(content)));
             }
             else {
                 other.push(content);