@aigne/core 1.1.0-beta.6 → 1.3.1

package/lib/cjs/models/claude-chat-model.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeChatModel = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const lodash_es_1 = require("lodash-es");
+const json_schema_js_1 = require("../utils/json-schema.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const chat_model_js_1 = require("./chat-model.js");
+const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+class ClaudeChatModel extends chat_model_js_1.ChatModel {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    _client;
+    get client() {
+        if (!this.config?.apiKey)
+            throw new Error("Api Key is required for ClaudeChatModel");
+        this._client ??= new sdk_1.default({ apiKey: this.config.apiKey });
+        return this._client;
+    }
+    async process(input) {
+        const model = this.config?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL;
+        const body = {
+            model,
+            temperature: input.modelOptions?.temperature,
+            top_p: input.modelOptions?.topP,
+            // TODO: make dynamic based on model https://docs.anthropic.com/en/docs/about-claude/models/all-models
+            max_tokens: /claude-3-[5|7]/.test(model) ? 8192 : 4096,
+            ...convertMessages(input),
+            ...convertTools(input),
+        };
+        const stream = this.client.messages.stream({
+            ...body,
+            stream: true,
+        });
+        const result = await this.extractResultFromClaudeStream(stream);
+        // Claude doesn't support json_schema response and tool calls in the same request,
+        // so we need to make a separate request for json_schema response when the tool calls is empty
+        if (!result.toolCalls?.length && input.responseFormat?.type === "json_schema") {
+            return this.requestStructuredOutput(body, input.responseFormat);
+        }
+        return result;
+    }
+    async extractResultFromClaudeStream(stream) {
+        let text = "";
+        const toolCalls = [];
+        for await (const chunk of stream) {
+            // handle streaming text
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                text += chunk.delta.text;
+            }
+            if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+                toolCalls[chunk.index] = {
+                    type: "function",
+                    id: chunk.content_block.id,
+                    function: {
+                        name: chunk.content_block.name,
+                        arguments: {},
+                    },
+                    args: "",
+                };
+            }
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+                const call = toolCalls[chunk.index];
+                if (!call)
+                    throw new Error("Tool call not found");
+                call.args += chunk.delta.partial_json;
+            }
+        }
+        const result = { text };
+        if (toolCalls.length) {
+            result.toolCalls = toolCalls
+                .map(({ args, ...c }) => ({
+                ...c,
+                function: { ...c.function, arguments: (0, json_schema_js_1.parseJSON)(args) },
+            }))
+                .filter(type_utils_js_1.isNonNullable);
+        }
+        return result;
+    }
+    async requestStructuredOutput(body, responseFormat) {
+        if (responseFormat?.type !== "json_schema") {
+            throw new Error("Expected json_schema response format");
+        }
+        const result = await this.client.messages.create({
+            ...body,
+            tools: [
+                {
+                    name: "generate_json",
+                    description: "Generate a json result by given context",
+                    input_schema: responseFormat.jsonSchema.schema,
+                },
+            ],
+            tool_choice: {
+                type: "tool",
+                name: "generate_json",
+                disable_parallel_tool_use: true,
+            },
+            stream: false,
+        });
+        const jsonTool = result.content.find((i) => i.type === "tool_use" && i.name === "generate_json");
+        if (!jsonTool)
+            throw new Error("Json tool not found");
+        return {
+            json: jsonTool.input,
+        };
+    }
+}
+exports.ClaudeChatModel = ClaudeChatModel;
+function convertMessages({ messages, responseFormat }) {
+    const systemMessages = [];
+    const msgs = [];
+    for (const msg of messages) {
+        if (msg.role === "system") {
+            if (typeof msg.content !== "string")
+                throw new Error("System message must have content");
+            systemMessages.push(msg.content);
+        }
+        else if (msg.role === "tool") {
+            if (!msg.toolCallId)
+                throw new Error("Tool message must have toolCallId");
+            if (typeof msg.content !== "string")
+                throw new Error("Tool message must have string content");
+            msgs.push({
+                role: "user",
+                content: [{ type: "tool_result", tool_use_id: msg.toolCallId, content: msg.content }],
+            });
+        }
+        else if (msg.role === "user") {
+            if (!msg.content)
+                throw new Error("User message must have content");
+            msgs.push({ role: "user", content: convertContent(msg.content) });
+        }
+        else if (msg.role === "agent") {
+            if (msg.toolCalls?.length) {
+                msgs.push({
+                    role: "assistant",
+                    content: msg.toolCalls.map((i) => ({
+                        type: "tool_use",
+                        id: i.id,
+                        name: i.function.name,
+                        input: i.function.arguments,
+                    })),
+                });
+            }
+            else if (msg.content) {
+                msgs.push({ role: "assistant", content: convertContent(msg.content) });
+            }
+            else {
+                throw new Error("Agent message must have content or toolCalls");
+            }
+        }
+    }
+    if (responseFormat?.type === "json_schema") {
+        systemMessages.push(`You should provide a json response with schema: ${JSON.stringify(responseFormat.jsonSchema.schema)}`);
+    }
+    const system = systemMessages.join("\n").trim() || undefined;
+    // Claude requires at least one message, so we add a system message if there are no messages
+    if (msgs.length === 0) {
+        if (!system)
+            throw new Error("No messages provided");
+        return { messages: [{ role: "user", content: system }] };
+    }
+    return { messages: msgs, system };
+}
+function convertContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((item) => item.type === "image_url"
+            ? { type: "image", source: { type: "url", url: item.url } }
+            : { type: "text", text: item.text });
+    }
+    throw new Error("Invalid chat message content");
+}
+function convertTools({ tools, toolChoice, }) {
+    let choice;
+    if (typeof toolChoice === "object" && "type" in toolChoice && toolChoice.type === "function") {
+        choice = {
+            type: "tool",
+            name: toolChoice.function.name,
+        };
+    }
+    else if (toolChoice === "required") {
+        choice = { type: "any" };
+    }
+    else if (toolChoice === "auto") {
+        choice = { type: "auto" };
+    }
+    else if (toolChoice === "none") {
+        choice = { type: "none" };
+    }
+    return {
+        tools: tools?.length
+            ? tools.map((i) => ({
+                name: i.function.name,
+                description: i.function.description,
+                input_schema: (0, lodash_es_1.isEmpty)(i.function.parameters)
+                    ? { type: "object" }
+                    : i.function.parameters,
+            }))
+            : undefined,
+        tool_choice: choice,
+    };
+}

package/lib/cjs/models/{chat-openai.d.ts → openai-chat-model.d.ts}

@@ -1,5 +1,5 @@
-import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat";
-export declare class ChatModelOpenAI extends ChatModel {
+import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat-model.js";
+export declare class OpenAIChatModel extends ChatModel {
     config?: {
         apiKey?: string;
         model?: string;

package/lib/cjs/models/{chat-openai.js → openai-chat-model.js}

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatModelOpenAI = void 0;
+exports.OpenAIChatModel = void 0;
 const nanoid_1 = require("nanoid");
 const openai_1 = __importDefault(require("openai"));
-const type_utils_1 = require("../utils/type-utils");
-const chat_1 = require("./chat");
+const json_schema_js_1 = require("../utils/json-schema.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const chat_model_js_1 = require("./chat-model.js");
 const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
-class ChatModelOpenAI extends chat_1.ChatModel {
+class OpenAIChatModel extends chat_model_js_1.ChatModel {
     config;
     constructor(config) {
         super();
@@ -18,7 +19,7 @@ class ChatModelOpenAI extends chat_1.ChatModel {
     _client;
     get client() {
         if (!this.config?.apiKey)
-            throw new Error("Api Key is required for ChatModelOpenAI");
+            throw new Error("Api Key is required for OpenAIChatModel");
         this._client ??= new openai_1.default({ apiKey: this.config.apiKey });
         return this._client;
     }
@@ -68,8 +69,8 @@ class ChatModelOpenAI extends chat_1.ChatModel {
                 text += choice.delta.content;
         }
         const result = {};
-        if (input.responseFormat?.type === "json_schema") {
-            result.json = JSON.parse(text);
+        if (input.responseFormat?.type === "json_schema" && text) {
+            result.json = (0, json_schema_js_1.parseJSON)(text);
         }
         else {
             result.text = text;
@@ -77,13 +78,13 @@ class ChatModelOpenAI extends chat_1.ChatModel {
         if (toolCalls.length) {
             result.toolCalls = toolCalls.map(({ args, ...c }) => ({
                 ...c,
-                function: { ...c.function, arguments: JSON.parse(args) },
+                function: { ...c.function, arguments: (0, json_schema_js_1.parseJSON)(args) },
             }));
         }
         return result;
     }
 }
-exports.ChatModelOpenAI = ChatModelOpenAI;
+exports.OpenAIChatModel = OpenAIChatModel;
 const ROLE_MAP = {
     system: "system",
     user: "user",
@@ -107,7 +108,7 @@ async function contentsFromInputMessages(messages) {
                     };
                 }
             })
-                .filter(type_utils_1.isNonNullable),
+                .filter(type_utils_js_1.isNonNullable),
         tool_calls: i.toolCalls?.map((i) => ({
             ...i,
             function: {

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

@@ -1,22 +1,24 @@
-import type { GetPromptResult } from "@modelcontextprotocol/sdk/types";
-import { Agent, type AgentInput } from "../agents/agent";
-import type { AIAgent } from "../agents/ai-agent";
-import type { Context } from "../execution-engine/context";
-import type { ChatModel, ChatModelInput, ChatModelInputMessage } from "../models/chat";
-import { ChatMessagesTemplate } from "./template";
-export declare const USER_INPUT_MESSAGE_KEY = "$user_input_message";
-export declare function userInput(message: string | object): AgentInput;
-export declare function addMessagesToInput(input: AgentInput, messages: ChatModelInputMessage[]): AgentInput;
+import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
+import { Agent, type AgentOptions, type Message } from "../agents/agent.js";
+import type { AIAgent } from "../agents/ai-agent.js";
+import type { AgentMemory } from "../agents/memory.js";
+import type { Context } from "../execution-engine/context.js";
+import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
+import { ChatMessagesTemplate } from "./template.js";
+export declare const MESSAGE_KEY = "$message";
+export declare const DEFAULT_MAX_HISTORY_MESSAGES = 10;
+export declare function createMessage(message: string | object): Message;
+export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
 export interface PromptBuilderBuildOptions {
-    enableHistory?: boolean;
-    maxHistoryMessages?: number;
+    memory?: AgentMemory;
     context?: Context;
     agent?: AIAgent;
-    input?: AgentInput;
+    input?: Message;
     model?: ChatModel;
+    outputSchema?: AgentOptions["outputSchema"];
 }
 export declare class PromptBuilder {
     static from(instructions: string): PromptBuilder;
@@ -31,8 +33,6 @@ export declare class PromptBuilder {
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
     instructions?: string | ChatMessagesTemplate;
-    histories: ChatModelInputMessage[];
-    addHistory(...messages: ChatModelInputMessage[]): void;
     build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;

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

@@ -1,39 +1,26 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptBuilder = exports.USER_INPUT_MESSAGE_KEY = void 0;
-exports.userInput = userInput;
-exports.addMessagesToInput = addMessagesToInput;
+exports.PromptBuilder = exports.DEFAULT_MAX_HISTORY_MESSAGES = exports.MESSAGE_KEY = void 0;
+exports.createMessage = createMessage;
+exports.getMessage = getMessage;
 const promises_1 = require("node:fs/promises");
-const lodash_1 = require("lodash");
+const lodash_es_1 = require("lodash-es");
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
-const agent_1 = require("../agents/agent");
-const template_1 = require("./template");
-exports.USER_INPUT_MESSAGE_KEY = "$user_input_message";
-function userInput(message) {
-    return { [exports.USER_INPUT_MESSAGE_KEY]: message };
+const agent_js_1 = require("../agents/agent.js");
+const json_schema_js_1 = require("../utils/json-schema.js");
+const template_js_1 = require("./template.js");
+exports.MESSAGE_KEY = "$message";
+exports.DEFAULT_MAX_HISTORY_MESSAGES = 10;
+function createMessage(message) {
+    return { [exports.MESSAGE_KEY]: message };
 }
-function addMessagesToInput(input, messages) {
-    const originalUserInputMessages = input[exports.USER_INPUT_MESSAGE_KEY];
-    const newMessages = [];
-    if (typeof originalUserInputMessages === "string") {
-        newMessages.push({ role: "user", content: originalUserInputMessages });
-    }
-    else {
-        const messages = (0, template_1.parseChatMessages)(originalUserInputMessages);
-        if (messages)
-            newMessages.push(...messages);
-        else
-            newMessages.push({
-                role: "user",
-                content: JSON.stringify(originalUserInputMessages),
-            });
-    }
-    newMessages.push(...messages);
-    return { ...input, [exports.USER_INPUT_MESSAGE_KEY]: newMessages };
+function getMessage(input) {
+    const userInputMessage = input[exports.MESSAGE_KEY];
+    if (typeof userInputMessage === "string")
+        return userInputMessage;
+    if (!(0, lodash_es_1.isNil)(userInputMessage))
+        return JSON.stringify(userInputMessage);
+    return undefined;
 }
 class PromptBuilder {
     static from(instructions) {
@@ -51,13 +38,28 @@ class PromptBuilder {
     }
     static fromMCPPromptResult(result) {
         return new PromptBuilder({
-            instructions: template_1.ChatMessagesTemplate.from(result.messages.map((i) => {
-                if (i.content.type !== "text")
+            instructions: template_js_1.ChatMessagesTemplate.from(result.messages.map((i) => {
+                let content;
+                if (i.content.type === "text")
+                    content = i.content.text;
+                else if (i.content.type === "resource") {
+                    const { resource } = i.content;
+                    if (typeof resource.text === "string") {
+                        content = resource.text;
+                    }
+                    else if (typeof resource.blob === "string") {
+                        content = [{ type: "image_url", url: resource.blob }];
+                    }
+                }
+                else if (i.content.type === "image") {
+                    content = [{ type: "image_url", url: i.content.data }];
+                }
+                if (!content)
                     throw new Error(`Unsupported content type ${i.content.type}`);
                 if (i.role === "user")
-                    return template_1.UserMessageTemplate.from(i.content.text);
+                    return template_js_1.UserMessageTemplate.from(content);
                 if (i.role === "assistant")
-                    return template_1.AgentMessageTemplate.from(i.content.text);
+                    return template_js_1.AgentMessageTemplate.from(content);
                 throw new Error(`Unsupported role ${i.role}`);
             })),
         });
@@ -66,10 +68,6 @@ class PromptBuilder {
         this.instructions = options?.instructions;
     }
     instructions;
-    histories = [];
-    addHistory(...messages) {
-        this.histories.push(...messages);
-    }
     async build(options) {
         return {
             messages: this.buildMessages(options),
@@ -80,37 +78,28 @@ class PromptBuilder {
     buildMessages(options) {
         const { input } = options;
         const messages = (typeof this.instructions === "string"
-            ? template_1.ChatMessagesTemplate.from([template_1.SystemMessageTemplate.from(this.instructions)])
+            ? template_js_1.ChatMessagesTemplate.from([template_js_1.SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(options.input) ?? [];
-        if (options.enableHistory) {
-            messages.push(...(options.maxHistoryMessages
-                ? this.histories.slice(-options.maxHistoryMessages)
-                : this.histories));
-        }
-        const userMessages = [];
-        const userInputMessage = input?.[exports.USER_INPUT_MESSAGE_KEY];
-        // Parse messages from the user input with the key $user_input_message
-        if (!(0, lodash_1.isNil)(userInputMessage)) {
-            if (typeof userInputMessage === "string") {
-                userMessages.push(template_1.UserMessageTemplate.from(userInputMessage).format());
-            }
-            else {
-                const messages = (0, template_1.parseChatMessages)(userInputMessage);
-                if (messages)
-                    userMessages.push(...messages.map((i) => i.format()));
-                else
-                    userMessages.push(template_1.UserMessageTemplate.from(JSON.stringify(userInputMessage)).format());
-            }
+        const memory = options.memory ?? options.agent?.memory;
+        if (memory?.enabled) {
+            const k = memory.maxMemoriesInChat ?? exports.DEFAULT_MAX_HISTORY_MESSAGES;
+            const histories = memory.memories.slice(-k);
+            if (histories?.length)
+                messages.push(...histories.map((i) => ({
+                    role: i.role,
+                    content: convertMessageToContent(i.content),
+                    name: i.source,
+                })));
         }
-        if (userMessages.length) {
-            if (options.enableHistory)
-                this.addHistory(...userMessages);
-            messages.push(...userMessages);
+        const content = input && getMessage(input);
+        // add user input if it's not the same as the last message
+        if (content && messages.at(-1)?.content !== content) {
+            messages.push({ role: "user", content });
         }
         return messages;
     }
     buildResponseFormat(options) {
-        const outputSchema = options.agent?.outputSchema;
+        const outputSchema = options.outputSchema || options.agent?.outputSchema;
         if (!outputSchema)
             return undefined;
         const isJsonOutput = !isEmptyObjectType(outputSchema);
@@ -119,7 +108,7 @@ class PromptBuilder {
                 type: "json_schema",
                 jsonSchema: {
                     name: "output",
-                    schema: (0, zod_to_json_schema_1.default)(outputSchema),
+                    schema: (0, json_schema_js_1.outputSchemaToResponseFormatSchema)(outputSchema),
                     strict: true,
                 },
             }
@@ -135,14 +124,16 @@ class PromptBuilder {
             function: {
                 name: i.name,
                 description: i.description,
-                parameters: !isEmptyObjectType(i.inputSchema) ? (0, zod_to_json_schema_1.default)(i.inputSchema) : {},
+                parameters: !isEmptyObjectType(i.inputSchema)
+                    ? (0, json_schema_js_1.outputSchemaToResponseFormatSchema)(i.inputSchema)
+                    : {},
             },
         }));
         let toolChoice;
         // use manual choice if configured in the agent
         const manualChoice = options.agent?.toolChoice;
         if (manualChoice) {
-            if (manualChoice instanceof agent_1.Agent) {
+            if (manualChoice instanceof agent_js_1.Agent) {
                 toolChoice = {
                     type: "function",
                     function: {
@@ -179,3 +170,7 @@ function isFromPath(value) {
 function isEmptyObjectType(schema) {
     return schema instanceof zod_1.ZodObject && Object.keys(schema.shape).length === 0;
 }
+function convertMessageToContent(i) {
+    const str = i[exports.MESSAGE_KEY];
+    return !(0, lodash_es_1.isNil)(str) ? (typeof str === "string" ? str : JSON.stringify(str)) : JSON.stringify(i);
+}

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

@@ -1,4 +1,4 @@
-import type { ChatModelInputMessage, ChatModelOutputToolCall } from "../models/chat";
+import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../models/chat-model.js";
 export declare class PromptTemplate {
     template: string;
     static from(template: string): PromptTemplate;
@@ -16,22 +16,16 @@ export declare class SystemMessageTemplate extends ChatMessageTemplate {
     static from(content: string, name?: string): SystemMessageTemplate;
 }
 export declare class UserMessageTemplate extends ChatMessageTemplate {
-    static from(template: NonNullable<ChatModelInputMessage["content"]>, name?: string): UserMessageTemplate;
+    static from(template: ChatModelInputMessageContent, name?: string): UserMessageTemplate;
 }
 export declare class AgentMessageTemplate extends ChatMessageTemplate {
     toolCalls?: ChatModelOutputToolCall[] | undefined;
-    static from(template: string | ChatModelOutputToolCall[], name?: string): AgentMessageTemplate;
-    constructor(content?: string, toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
+    static from(template?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[], name?: string): AgentMessageTemplate;
+    constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCalls: ChatModelOutputToolCall[] | undefined;
-        role: import("../models/chat").Role;
-        content?: string | ({
-            type: "text";
-            text: string;
-        } | {
-            type: "image_url";
-            url: string;
-        })[];
+        role: import("../models/chat-model.js").Role;
+        content?: ChatModelInputMessageContent;
         toolCallId?: string;
         name?: string;
     };
@@ -42,20 +36,14 @@ export declare class ToolMessageTemplate extends ChatMessageTemplate {
     constructor(content: object | string, toolCallId: string, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCallId: string;
-        role: import("../models/chat").Role;
-        content?: string | ({
-            type: "text";
-            text: string;
-        } | {
-            type: "image_url";
-            url: string;
-        })[];
+        role: import("../models/chat-model.js").Role;
+        content?: ChatModelInputMessageContent;
         toolCalls?: {
             id: string;
             type: "function";
             function: {
                 name: string;
-                arguments: import("..").AgentInput;
+                arguments: import("../index.js").Message;
             };
         }[];
         name?: string;

package/lib/cjs/prompt/template.js

@@ -67,10 +67,8 @@ class UserMessageTemplate extends ChatMessageTemplate {
 exports.UserMessageTemplate = UserMessageTemplate;
 class AgentMessageTemplate extends ChatMessageTemplate {
     toolCalls;
-    static from(template, name) {
-        return typeof template === "string"
-            ? new AgentMessageTemplate(template, undefined, name)
-            : new AgentMessageTemplate(undefined, template, name);
+    static from(template, toolCalls, name) {
+        return new AgentMessageTemplate(template, toolCalls, name);
     }
     constructor(content, toolCalls, name) {
         super("agent", content, name);
@@ -164,7 +162,7 @@ function parseChatMessages(messages) {
             case "user":
                 return UserMessageTemplate.from(message.content, message.name);
             case "agent":
-                return new AgentMessageTemplate(message.content, message.toolCalls, message.name);
+                return AgentMessageTemplate.from(message.content, message.toolCalls, message.name);
             case "tool":
                 return ToolMessageTemplate.from(message.content, message.toolCallId, message.name);
         }

package/lib/cjs/utils/json-schema.d.ts

@@ -0,0 +1,4 @@
+import type { ZodType } from "zod";
+import type { Message } from "../agents/agent.js";
+export declare function outputSchemaToResponseFormatSchema(agentOutput: ZodType<Message>): Record<string, unknown>;
+export declare function parseJSON(json: string): any;

package/lib/cjs/utils/json-schema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputSchemaToResponseFormatSchema = outputSchemaToResponseFormatSchema;
+exports.parseJSON = parseJSON;
+const lodash_es_1 = require("lodash-es");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const logger_js_1 = require("./logger.js");
+function outputSchemaToResponseFormatSchema(agentOutput) {
+    return setAdditionPropertiesDeep((0, zod_to_json_schema_1.zodToJsonSchema)(agentOutput), false);
+}
+function setAdditionPropertiesDeep(schema, additionalProperties) {
+    if (Array.isArray(schema)) {
+        return schema.map((s) => setAdditionPropertiesDeep(s, additionalProperties));
+    }
+    if ((0, lodash_es_1.isObject)(schema)) {
+        return Object.entries(schema).reduce((acc, [key, value]) => {
+            acc[key] = setAdditionPropertiesDeep(value, additionalProperties);
+            if (acc.type === "object") {
+                acc.additionalProperties = additionalProperties;
+            }
+            return acc;
+        }, {});
+    }
+    return schema;
+}
+function parseJSON(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch (error) {
+        logger_js_1.logger.debug("Failed to parse JSON", { json, error });
+        throw new Error(`Failed to parse JSON ${error.message}`);
+    }
+}

package/lib/cjs/utils/mcp-utils.d.ts

@@ -1,5 +1,6 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { ListPromptsResult, ListToolsResult } from "@modelcontextprotocol/sdk/types";
-import { MCPPrompt, MCPTool } from "../agents/mcp-agent";
+import { type ListPromptsResult, type ListResourceTemplatesResult, type ListResourcesResult, type ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
+import { MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.js";
 export declare function toolFromMCPTool(client: Client, tool: ListToolsResult["tools"][number]): MCPTool;
 export declare function promptFromMCPPrompt(client: Client, prompt: ListPromptsResult["prompts"][number]): MCPPrompt;
+export declare function resourceFromMCPResource(client: Client, resource: ListResourcesResult["resources"][number] | ListResourceTemplatesResult["resourceTemplates"][number]): MCPResource;