@aigne/core 1.14.0 → 1.16.0

package/lib/esm/{models → agents}/chat-model.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Agent } from "../agents/agent.js";
+import { Agent } from "./agent.js";
 /**
  * ChatModel is an abstract base class for interacting with Large Language Models (LLMs).
  *
@@ -9,19 +9,19 @@ import { Agent } from "../agents/agent.js";
  *
  * @example
  * Here's how to implement a custom ChatModel:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model}
  *
  * @example
  * Here's an example showing streaming response with readable stream:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-streaming}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-streaming}
  *
  * @example
  * Here's an example showing streaming response with async generator:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-streaming-async-generator}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-streaming-async-generator}
  *
  * @example
  * Here's an example with tool calls:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-tools}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export class ChatModel extends Agent {
     constructor() {
@@ -56,6 +56,19 @@ export class ChatModel extends Agent {
             }
         }
     }
+    /**
+     * Normalizes tool names to ensure compatibility with language models
+     *
+     * This method converts tool names to a format that complies with model requirements
+     * by replacing hyphens and whitespace characters with underscores. The normalized
+     * names are used for tool calls while preserving the original names for reference.
+     *
+     * @param name - The original tool name to normalize
+     * @returns A promise that resolves to the normalized tool name
+     */
+    async normalizeToolName(name) {
+        return name.replaceAll(/[-\s]/g, "_");
+    }
     /**
      * Performs preprocessing operations before handling input
      *
@@ -65,14 +78,29 @@ export class ChatModel extends Agent {
      * @param context Execution context
      * @throws Error if token usage exceeds maximum limit
      */
-    preprocess(input, context) {
+    async preprocess(input, context) {
         super.preprocess(input, context);
         const { limits, usage } = context;
         const usedTokens = usage.outputTokens + usage.inputTokens;
         if (limits?.maxTokens && usedTokens >= limits.maxTokens) {
             throw new Error(`Exceeded max tokens ${usedTokens}/${limits.maxTokens}`);
         }
-        this.validateToolNames(input.tools);
+        // Automatically convert tool names to a valid format
+        if (input.tools?.length) {
+            const toolsMap = {};
+            const tools = [];
+            for (const originalTool of input.tools) {
+                const name = await this.normalizeToolName(originalTool.function.name);
+                const tool = {
+                    ...originalTool,
+                    function: { ...originalTool.function, name },
+                };
+                tools.push(tool);
+                toolsMap[name] = originalTool;
+            }
+            this.validateToolNames(tools);
+            Object.assign(input, { _toolsMap: toolsMap, tools });
+        }
     }
     /**
      * Performs postprocessing operations after handling output
@@ -84,6 +112,19 @@ export class ChatModel extends Agent {
      * @param context Execution context
      */
     postprocess(input, output, context) {
+        // Restore original tool names in the output
+        if (output.toolCalls?.length) {
+            const toolsMap = input._toolsMap;
+            if (toolsMap) {
+                for (const toolCall of output.toolCalls) {
+                    const originalTool = toolsMap[toolCall.function.name];
+                    if (!originalTool) {
+                        throw new Error(`Tool "${toolCall.function.name}" not found in tools map`);
+                    }
+                    toolCall.function.name = originalTool.function.name;
+                }
+            }
+        }
         super.postprocess(input, output, context);
         const { usage } = output;
         if (usage) {

package/lib/esm/agents/guide-rail-agent.d.ts

@@ -0,0 +1,62 @@
+import type { Agent, AgentOptions, Message } from "./agent.js";
+/**
+ * Input interface for GuideRail agents
+ *
+ * GuideRail agents receive both input and expected output, allowing them to
+ * validate, transform, or control the flow of messages between other agents.
+ */
+export interface GuideRailAgentInput extends Message {
+    /**
+     * The input data to be processed
+     *
+     * This is the original message that would be sent to the target agent
+     */
+    input?: unknown;
+    /**
+     * The expected output data
+     *
+     * This is what the target agent is expected to produce, allowing
+     * the GuideRail agent to validate or transform the data flow
+     */
+    output?: unknown;
+}
+/**
+ * Output interface for GuideRail agents
+ *
+ * GuideRail agents can either allow the process to continue or abort it with a reason.
+ * This provides a mechanism for enforcing rules, validating data, and controlling
+ * the execution flow of the agent system.
+ */
+export interface GuideRailAgentOutput extends Message {
+    /**
+     * Whether to abort the current process
+     *
+     * When true, the agent system should stop the current execution flow
+     * and prevent further processing based on this input/output pair
+     *
+     * @default false
+     */
+    abort?: boolean;
+    /**
+     * Reason for aborting the process
+     *
+     * When abort is true, this provides a human-readable explanation
+     * for why the process was stopped
+     */
+    reason?: string;
+}
+/**
+ * GuideRail agent type definition
+ *
+ * GuideRail agents act as validators, transformers, or controllers for the message
+ * flow between agents. They can enforce rules, perform safety checks, ensure data
+ * quality, or implement business logic validations.
+ *
+ * Use GuideRail agents when you need to:
+ * - Validate inputs or outputs against specific criteria
+ * - Enforce security or safety policies
+ * - Implement business rules that control agent interactions
+ * - Monitor and audit agent behavior
+ */
+export type GuideRailAgent = Agent<GuideRailAgentInput, GuideRailAgentOutput>;
+export declare const guideRailAgentOptions: AgentOptions<GuideRailAgentInput, GuideRailAgentOutput>;

package/lib/esm/agents/guide-rail-agent.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export const guideRailAgentOptions = {
+    inputSchema: z.object({
+        input: z.unknown(),
+        output: z.unknown(),
+    }),
+    outputSchema: z.object({
+        abort: z.boolean().optional().describe("Whether to abort the current process"),
+        reason: z.string().optional().describe("Reason for aborting the process"),
+    }),
+};

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

@@ -78,25 +78,25 @@ export class MCPAgent extends Agent {
             version: MCP_AGENT_CLIENT_VERSION,
         }, undefined, isSSEServerParameters(options) ? { transportCreator, ...options } : undefined);
         const transport = transportCreator();
-        logger.mcp(`Connecting to MCP server: ${getMCPServerString(options)}`);
+        logger.debug(`Connecting to MCP server: ${getMCPServerString(options)}`);
         await client.connect(transport);
         const mcpServer = getMCPServerName(client);
         const { tools: isToolsAvailable, prompts: isPromptsAvailable, resources: isResourcesAvailable, } = client.getServerCapabilities() ?? {};
-        logger.mcp(`Listing tools from ${mcpServer}`);
+        logger.debug(`Listing tools from ${mcpServer}`);
         const skills = isToolsAvailable
             ? await client.listTools().then(({ tools }) => {
-                logger.mcp(`Listing tools from ${mcpServer} completed %O`, tools?.map((i) => i.name));
+                logger.debug(`Listing tools from ${mcpServer} completed %O`, tools?.map((i) => i.name));
                 return tools.map((tool) => toolFromMCPTool(tool, { client }));
             })
             : undefined;
-        logger.mcp(`Listing prompts from ${mcpServer}`);
+        logger.debug(`Listing prompts from ${mcpServer}`);
         const prompts = isPromptsAvailable
             ? await client.listPrompts().then(({ prompts }) => {
-                logger.mcp(`Listing prompts from ${mcpServer} completed %O`, prompts?.map((i) => i.name));
+                logger.debug(`Listing prompts from ${mcpServer} completed %O`, prompts?.map((i) => i.name));
                 return prompts.map((prompt) => promptFromMCPPrompt(prompt, { client }));
             })
             : undefined;
-        logger.mcp(`Listing resources from ${mcpServer}`);
+        logger.debug(`Listing resources from ${mcpServer}`);
         // TODO: should conditionally call listResourceTemplates based on the server capabilities
         // but the capability is not correct in the current SDK version
         const resources = isResourcesAvailable
@@ -105,7 +105,7 @@ export class MCPAgent extends Agent {
                 client.listResourceTemplates().catch(() => ({ resourceTemplates: [] })),
             ]).then(([{ resources }, { resourceTemplates }]) => {
                 const result = [...resources, ...resourceTemplates].map((resource) => resourceFromMCPResource(resource, { client }));
-                logger.mcp(`Listing resources from ${mcpServer} completed %O`, result.map((i) => i.name));
+                logger.debug(`Listing resources from ${mcpServer} completed %O`, result.map((i) => i.name));
                 return result;
             })
             : undefined;
@@ -228,7 +228,7 @@ class ClientWithReconnect extends Client {
         }, {
             retries: this.reconnectOptions?.maxReconnects ?? DEFAULT_MAX_RECONNECTS,
             shouldRetry: this.shouldReconnect,
-            onFailedAttempt: (error) => logger.mcp("Reconnect attempt failed: %O", error),
+            onFailedAttempt: (error) => logger.error("Reconnect attempt failed: %O", error),
         });
     }
     async request(request, resultSchema, options) {
@@ -241,7 +241,7 @@ class ClientWithReconnect extends Client {
         }
         catch (error) {
             if (this.shouldReconnect(error)) {
-                logger.mcp("Error occurred, reconnecting to MCP server: %O", error);
+                logger.error("Error occurred, reconnecting to MCP server: %O", error);
                 await this.reconnect();
                 return await super.request(request, resultSchema, mergedOptions);
             }

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

@@ -1,4 +1,4 @@
-import { mergeAgentResponseChunk, readableStreamToAsyncIterator } from "../utils/stream-utils.js";
+import { mergeAgentResponseChunk } from "../utils/stream-utils.js";
 import { isEmpty } from "../utils/type-utils.js";
 import { Agent, } from "./agent.js";
 /**
@@ -116,7 +116,7 @@ export class TeamAgent extends Agent {
         const newAgents = [];
         for (const agent of agents) {
             const [o, transferToAgent] = await context.invoke(agent, { ...input, ...output }, { returnActiveAgent: true, streaming: true });
-            for await (const chunk of readableStreamToAsyncIterator(o)) {
+            for await (const chunk of o) {
                 yield chunk;
                 mergeAgentResponseChunk(output, chunk);
             }

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

@@ -1,6 +1,7 @@
 import { Agent, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
+import { ChatModel } from "../agents/chat-model.js";
 import type { UserAgent } from "../agents/user-agent.js";
-import { ChatModel } from "../models/chat-model.js";
+import { type LoadOptions } from "../loader/index.js";
 import { AIGNEContext, type InvokeOptions } from "./context.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 import type { ContextLimits } from "./usage.js";
@@ -54,7 +55,7 @@ export declare class AIGNE {
      * @param options - Options to override the loaded configuration.
      * @returns A fully initialized AIGNE instance with configured agents and skills.
      */
-    static load(path: string, options?: AIGNEOptions): Promise<AIGNE>;
+    static load(path: string, options: AIGNEOptions & Pick<LoadOptions, "models">): Promise<AIGNE>;
     /**
      * Creates a new AIGNE instance with the specified options.
      *

package/lib/esm/aigne/aigne.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { Agent, } from "../agents/agent.js";
+import { ChatModel } from "../agents/chat-model.js";
 import { load } from "../loader/index.js";
-import { ChatModel } from "../models/chat-model.js";
 import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
 import { AIGNEContext } from "./context.js";
 import { MessageQueue, } from "./message-queue.js";
@@ -27,7 +27,7 @@ export class AIGNE {
      * @returns A fully initialized AIGNE instance with configured agents and skills.
      */
     static async load(path, options) {
-        const { model, agents, skills, ...aigne } = await load({ path });
+        const { model, agents, skills, ...aigne } = await load({ models: options.models, path });
         return new AIGNE({
             ...options,
             model: options?.model || model,

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

@@ -1,7 +1,7 @@
 import EventEmitter from "node:events";
 import { Agent, type AgentInvokeOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { ChatModel } from "../agents/chat-model.js";
 import { UserAgent } from "../agents/user-agent.js";
-import type { ChatModel } from "../models/chat-model.js";
 import { type OmitPropertiesFromArrayFirstElement } from "../utils/type-utils.js";
 import type { Args, Listener, TypedEventEmitter } from "../utils/typed-event-emtter.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
@@ -41,6 +41,7 @@ export type ContextEmitEventMap = {
 export interface InvokeOptions extends AgentInvokeOptions {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
+    sourceAgent?: Agent;
 }
 /**
  * @hidden

package/lib/esm/aigne/context.js

@@ -5,7 +5,7 @@ import { Agent, } from "../agents/agent.js";
 import { isTransferAgentOutput, transferAgentOutputKey } from "../agents/types.js";
 import { UserAgent } from "../agents/user-agent.js";
 import { createMessage } from "../prompt/prompt-builder.js";
-import { agentResponseStreamToObject, asyncGeneratorToReadableStream, onAgentResponseStreamEnd, readableStreamToAsyncIterator, } from "../utils/stream-utils.js";
+import { agentResponseStreamToObject, asyncGeneratorToReadableStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
 import { checkArguments, isNil, omitBy, } from "../utils/type-utils.js";
 import { MessageQueue, toMessagePayload, } from "./message-queue.js";
 import { newEmptyContextUsage } from "./usage.js";
@@ -167,8 +167,15 @@ class AIGNEContextInternal {
         let output;
         for (;;) {
             const result = {};
+            if (options?.sourceAgent && activeAgent !== options.sourceAgent) {
+                options.sourceAgent.hooks.onHandoff?.({
+                    source: options.sourceAgent,
+                    target: activeAgent,
+                    input,
+                });
+            }
             const stream = await activeAgent.invoke(input, context, { streaming: true });
-            for await (const value of readableStreamToAsyncIterator(stream)) {
+            for await (const value of stream) {
                 if (value.delta.text) {
                     yield { delta: { text: value.delta.text } };
                 }

package/lib/esm/index.d.ts

@@ -5,6 +5,6 @@ export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
 export * from "./aigne/index.js";
-export * from "./models/chat-model.js";
+export * from "./agents/chat-model.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

package/lib/esm/index.js

@@ -5,6 +5,6 @@ export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
 export * from "./aigne/index.js";
-export * from "./models/chat-model.js";
+export * from "./agents/chat-model.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

package/lib/esm/loader/agent-yaml.d.ts

@@ -14,13 +14,13 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     }, {
         [x: string]: any;
     }> | undefined;
-    toolChoice?: AIAgentToolChoice | undefined;
     outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
     outputKey?: string | undefined;
+    toolChoice?: AIAgentToolChoice | undefined;
 } | {
     type: "mcp";
     url?: string | undefined;

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

@@ -1,7 +1,14 @@
+import type { Camelize } from "camelize-ts";
 import { z } from "zod";
 import { type Agent } from "../agents/agent.js";
-import type { ChatModel, ChatModelOptions } from "../models/chat-model.js";
+import type { ChatModel, ChatModelOptions } from "../agents/chat-model.js";
 export interface LoadOptions {
+    models: {
+        new (parameters: {
+            model?: string;
+            modelOptions?: ChatModelOptions;
+        }): ChatModel;
+    }[];
     path: string;
 }
 export declare function load(options: LoadOptions): Promise<{
@@ -15,12 +22,12 @@ export declare function load(options: LoadOptions): Promise<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
 }>;
 export declare function loadAgent(path: string): Promise<Agent>;
-export declare function loadModel(model?: z.infer<typeof aigneFileSchema>["chat_model"], modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
+export declare function loadModel(models: LoadOptions["models"], model?: Camelize<z.infer<typeof aigneFileSchema>["chat_model"]>, modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
 declare const aigneFileSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -29,35 +36,35 @@ declare const aigneFileSchema: z.ZodObject<{
         name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         top_p: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        frequent_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        frequency_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         presence_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     }, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     }>]>>>, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined, string | {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined>;
     agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
@@ -71,7 +78,7 @@ declare const aigneFileSchema: z.ZodObject<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;
@@ -84,7 +91,7 @@ declare const aigneFileSchema: z.ZodObject<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;
@@ -98,7 +105,7 @@ export declare function loadAIGNEFile(path: string): Promise<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;

package/lib/esm/loader/index.js

@@ -5,14 +5,6 @@ import { z } from "zod";
 import { FunctionAgent } from "../agents/agent.js";
 import { AIAgent } from "../agents/ai-agent.js";
 import { MCPAgent } from "../agents/mcp-agent.js";
-import { BedrockChatModel } from "../models/bedrock-chat-model.js";
-import { ClaudeChatModel } from "../models/claude-chat-model.js";
-import { DeepSeekChatModel } from "../models/deepseek-chat-model.js";
-import { GeminiChatModel } from "../models/gemini-chat-model.js";
-import { OllamaChatModel } from "../models/ollama-chat-model.js";
-import { OpenRouterChatModel } from "../models/open-router-chat-model.js";
-import { OpenAIChatModel } from "../models/openai-chat-model.js";
-import { XAIChatModel } from "../models/xai-chat-model.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
 import { loadAgentFromYamlFile } from "./agent-yaml.js";
@@ -26,7 +18,7 @@ export async function load(options) {
     const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent(join(rootDir, filename))));
     return {
         ...aigne,
-        model: await loadModel(aigne.chat_model),
+        model: await loadModel(options.models, aigne.chat_model),
         agents,
         skills,
     };
@@ -64,26 +56,15 @@ export async function loadAgent(path) {
 }
 const { MODEL_PROVIDER, MODEL_NAME } = process.env;
 const DEFAULT_MODEL_PROVIDER = "openai";
-const DEFAULT_MODEL_NAME = "gpt-4o-mini";
-export async function loadModel(model, modelOptions) {
+export async function loadModel(models, model, modelOptions) {
     const params = {
-        model: MODEL_NAME ?? model?.name ?? DEFAULT_MODEL_NAME,
+        model: MODEL_NAME ?? model?.name ?? undefined,
         temperature: model?.temperature ?? undefined,
-        topP: model?.top_p ?? undefined,
-        frequencyPenalty: model?.frequent_penalty ?? undefined,
-        presencePenalty: model?.presence_penalty ?? undefined,
+        topP: model?.topP ?? undefined,
+        frequencyPenalty: model?.frequencyPenalty ?? undefined,
+        presencePenalty: model?.presencePenalty ?? undefined,
     };
-    const availableModels = [
-        OpenAIChatModel,
-        ClaudeChatModel,
-        XAIChatModel,
-        GeminiChatModel,
-        DeepSeekChatModel,
-        OpenRouterChatModel,
-        OllamaChatModel,
-        BedrockChatModel,
-    ];
-    const M = availableModels.find((m) => m.name
+    const M = models.find((m) => m.name
         .toLowerCase()
         .includes((MODEL_PROVIDER ?? model?.provider ?? DEFAULT_MODEL_PROVIDER).toLowerCase()));
     if (!M)
@@ -101,7 +82,7 @@ const aigneFileSchema = z.object({
             name: z.string().nullish(),
             temperature: z.number().min(0).max(2).nullish(),
             top_p: z.number().min(0).nullish(),
-            frequent_penalty: z.number().min(-2).max(2).nullish(),
+            frequency_penalty: z.number().min(-2).max(2).nullish(),
             presence_penalty: z.number().min(-2).max(2).nullish(),
         }),
     ])

package/lib/esm/memory/retriever.d.ts

@@ -39,11 +39,11 @@ export declare const memoryRetrieverInputSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     search: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    limit?: number | undefined;
     search?: string | undefined;
-}, {
     limit?: number | undefined;
+}, {
     search?: string | undefined;
+    limit?: number | undefined;
 }>;
 /**
  * @hidden

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

@@ -1,9 +1,9 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
 import { Agent, 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 { Context } from "../aigne/context.js";
 import type { MemoryAgent } from "../memory/memory.js";
-import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
 export declare function createMessage<I extends Message>(message: string | I): I;
@@ -11,7 +11,7 @@ export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
-export interface PromptBuilderBuildOptions {
+export interface PromptBuildOptions {
     memory?: MemoryAgent | MemoryAgent[];
     context: Context;
     agent?: AIAgent;
@@ -32,7 +32,7 @@ export declare class PromptBuilder {
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
     instructions?: string | ChatMessagesTemplate;
-    build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
+    build(options: PromptBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;
     private buildMessages;

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

@@ -1,4 +1,4 @@
-import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../models/chat-model.js";
+import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../agents/chat-model.js";
 export declare class PromptTemplate {
     template: string;
     static from(template: string): PromptTemplate;
@@ -24,7 +24,7 @@ export declare class AgentMessageTemplate extends ChatMessageTemplate {
     constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCalls: ChatModelOutputToolCall[] | undefined;
-        role: import("../models/chat-model.js").Role;
+        role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCallId?: string;
         name?: string;
@@ -36,7 +36,7 @@ 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-model.js").Role;
+        role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCalls?: {
             id: string;

package/lib/esm/prompt/template.js

@@ -80,7 +80,7 @@ export class ToolMessageTemplate extends ChatMessageTemplate {
     constructor(content, toolCallId, name) {
         super("tool", typeof content === "string"
             ? content
-            : tryOrThrow(() => JSON.stringify(content), `Failed to stringify tool content. toolCallId: ${toolCallId}, content: ${inspect(content)}`), name);
+            : tryOrThrow(() => JSON.stringify(content, (_, value) => typeof value === "bigint" ? value.toString() : value), `Failed to stringify tool content. toolCallId: ${toolCallId}, content: ${inspect(content)}`), name);
         this.toolCallId = toolCallId;
     }
     format(variables) {

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

@@ -23,7 +23,7 @@ export function parseJSON(json) {
         return JSON.parse(json);
     }
     catch (error) {
-        logger.core("Failed to parse JSON", { json, error });
+        logger.error("Failed to parse JSON", { json, error });
         throw error;
     }
 }