@aigne/core 1.11.0 → 1.13.0

package/lib/cjs/{execution-engine → aigne}/usage.d.ts

@@ -6,6 +6,6 @@ export interface ContextUsage {
 export declare function newEmptyContextUsage(): ContextUsage;
 export interface ContextLimits {
     maxTokens?: number;
-    maxAgentCalls?: number;
+    maxAgentInvokes?: number;
     timeout?: number;
 }

package/lib/cjs/client/client.d.ts

@@ -0,0 +1,19 @@
+import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "../agents/agent.js";
+export interface AIGNEClientOptions {
+    url: string;
+}
+export interface AIGNEClientInvokeOptions extends AgentInvokeOptions {
+    fetchOptions?: Partial<RequestInit>;
+}
+export declare class AIGNEClient {
+    options: AIGNEClientOptions;
+    constructor(options: AIGNEClientOptions);
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options: AIGNEClientInvokeOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions & {
+        streaming?: false;
+    }): Promise<O>;
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions): Promise<AgentResponse<O>>;
+    fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
+}

package/lib/cjs/client/client.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIGNEClient = void 0;
+const event_stream_js_1 = require("../utils/event-stream.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+class AIGNEClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async invoke(agent, input, options) {
+        const response = await this.fetch(this.options.url, {
+            ...options?.fetchOptions,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.fetchOptions?.headers,
+            },
+            body: JSON.stringify({ agent, input, options }),
+        });
+        if (!options?.streaming) {
+            return await response.json();
+        }
+        const stream = response.body;
+        if (!stream)
+            throw new Error("Response body is not a stream");
+        return stream
+            .pipeThrough(new TextDecoderStream())
+            .pipeThrough(new event_stream_js_1.EventStreamParser())
+            .pipeThrough(new event_stream_js_1.AgentResponseStreamParser());
+    }
+    async fetch(...args) {
+        const result = await globalThis.fetch(...args);
+        if (!result.ok) {
+            let message;
+            try {
+                const text = await result.text();
+                const json = (0, type_utils_js_1.tryOrThrow)(() => JSON.parse(text));
+                message = json?.error?.message || text;
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(`Failed to fetch url ${args[0]} with status ${result.status}: ${message}`);
+        }
+        return result;
+    }
+}
+exports.AIGNEClient = AIGNEClient;

package/lib/cjs/index.d.ts

@@ -2,9 +2,10 @@ export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/memory.js";
+export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
-export * from "./execution-engine/index.js";
+export * from "./aigne/index.js";
 export * from "./models/chat-model.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

package/lib/cjs/index.js

@@ -18,9 +18,10 @@ __exportStar(require("./agents/agent.js"), exports);
 __exportStar(require("./agents/ai-agent.js"), exports);
 __exportStar(require("./agents/mcp-agent.js"), exports);
 __exportStar(require("./agents/memory.js"), exports);
+__exportStar(require("./agents/team-agent.js"), exports);
 __exportStar(require("./agents/types.js"), exports);
 __exportStar(require("./agents/user-agent.js"), exports);
-__exportStar(require("./execution-engine/index.js"), exports);
+__exportStar(require("./aigne/index.js"), exports);
 __exportStar(require("./models/chat-model.js"), exports);
 __exportStar(require("./prompt/prompt-builder.js"), exports);
 __exportStar(require("./prompt/template.js"), exports);

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

@@ -2,12 +2,12 @@ import { type ZodObject, type ZodType, z } from "zod";
 export declare function loadAgentFromYamlFile(path: string): Promise<{
     type: "ai";
     name: string;
-    tools?: string[] | undefined;
     description?: string | undefined;
-    instructions?: string | undefined;
     memory?: true | {
-        subscribeTopic: string[];
+        subscribeTopic?: string[] | undefined;
     } | undefined;
+    skills?: string[] | undefined;
+    instructions?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {

package/lib/cjs/loader/agent-yaml.js

@@ -30,7 +30,7 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
             .string()
             .nullish()
             .transform((v) => v ?? undefined),
-        tools: zod_1.z
+        skills: zod_1.z
             .array(zod_1.z.string())
             .nullish()
             .transform((v) => v ?? undefined),
@@ -42,7 +42,10 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
             .union([
             zod_1.z.boolean(),
             zod_1.z.object({
-                subscribe_topic: zod_1.z.array(zod_1.z.string()),
+                subscribe_topic: zod_1.z
+                    .array(zod_1.z.string())
+                    .nullish()
+                    .transform((v) => v ?? undefined),
             }),
         ])
             .nullish()
@@ -67,7 +70,11 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
 async function loadAgentFromYamlFile(path) {
     const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
-    const agent = (0, type_utils_js_1.tryOrThrow)(() => (0, camelize_js_1.customCamelize)(agentFileSchema.parse({ ...json, type: json.type ?? "ai" }), {
+    const agent = (0, type_utils_js_1.tryOrThrow)(() => (0, camelize_js_1.customCamelize)(agentFileSchema.parse({
+        ...json,
+        type: json.type ?? "ai",
+        skills: json.skills ?? json.tools,
+    }), {
         shallowKeys: ["input_schema", "output_schema"],
     }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
     return agent;

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

@@ -7,9 +7,9 @@ export interface LoadOptions {
 export declare function load(options: LoadOptions): Promise<{
     model: ChatModel | undefined;
     agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
-    tools: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
-    name?: string | null | undefined;
+    skills: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
     description?: string | null | undefined;
+    name?: string | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -61,11 +61,11 @@ declare const aigneFileSchema: z.ZodObject<{
         presence_penalty?: number | null | undefined;
     } | null | undefined>;
     agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    skills: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
-    tools?: string[] | null | undefined;
-    name?: string | null | undefined;
     description?: string | null | undefined;
+    name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -76,9 +76,9 @@ declare const aigneFileSchema: z.ZodObject<{
     } | null | undefined;
     agents?: string[] | null | undefined;
 }, {
-    tools?: string[] | null | undefined;
-    name?: string | null | undefined;
     description?: string | null | undefined;
+    name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: string | {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -90,9 +90,9 @@ declare const aigneFileSchema: z.ZodObject<{
     agents?: string[] | null | undefined;
 }>;
 export declare function loadAIGNEFile(path: string): Promise<{
-    tools?: string[] | null | undefined;
-    name?: string | null | undefined;
     description?: string | null | undefined;
+    name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;

package/lib/cjs/loader/index.js

@@ -11,6 +11,7 @@ const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const ai_agent_js_1 = require("../agents/ai-agent.js");
 const mcp_agent_js_1 = require("../agents/mcp-agent.js");
+const bedrock_chat_model_js_1 = require("../models/bedrock-chat-model.js");
 const claude_chat_model_js_1 = require("../models/claude-chat-model.js");
 const deepseek_chat_model_js_1 = require("../models/deepseek-chat-model.js");
 const gemini_chat_model_js_1 = require("../models/gemini-chat-model.js");
@@ -28,12 +29,12 @@ async function load(options) {
     const rootDir = (0, node_path_1.dirname)(aigneFilePath);
     const aigne = await loadAIGNEFile(aigneFilePath);
     const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
-    const tools = await Promise.all((aigne.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
+    const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
     return {
         ...aigne,
         model: await loadModel(aigne.chat_model),
         agents,
-        tools,
+        skills,
     };
 }
 async function loadAgent(path) {
@@ -46,8 +47,8 @@ async function loadAgent(path) {
         if (agent.type === "ai") {
             return ai_agent_js_1.AIAgent.from({
                 ...agent,
-                tools: agent.tools &&
-                    (await Promise.all(agent.tools.map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename))))),
+                skills: agent.skills &&
+                    (await Promise.all(agent.skills.map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename))))),
             });
         }
         if (agent.type === "mcp") {
@@ -86,6 +87,7 @@ async function loadModel(model, modelOptions) {
         deepseek_chat_model_js_1.DeepSeekChatModel,
         open_router_chat_model_js_1.OpenRouterChatModel,
         ollama_chat_model_js_1.OllamaChatModel,
+        bedrock_chat_model_js_1.BedrockChatModel,
     ];
     const M = availableModels.find((m) => m.name
         .toLowerCase()
@@ -112,12 +114,12 @@ const aigneFileSchema = zod_1.z.object({
         .nullish()
         .transform((v) => (typeof v === "string" ? { name: v } : v)),
     agents: zod_1.z.array(zod_1.z.string()).nullish(),
-    tools: zod_1.z.array(zod_1.z.string()).nullish(),
+    skills: zod_1.z.array(zod_1.z.string()).nullish(),
 });
 async function loadAIGNEFile(path) {
     const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
     const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
-    const agent = (0, type_utils_js_1.tryOrThrow)(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
+    const agent = (0, type_utils_js_1.tryOrThrow)(() => aigneFileSchema.parse({ ...json, skills: json.skills ?? json.tools }), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
     return agent;
 }
 async function getAIGNEFilePath(path) {

package/lib/cjs/models/bedrock-chat-model.d.ts

@@ -0,0 +1,70 @@
+import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
+import { z } from "zod";
+import type { AgentInvokeOptions, AgentResponse } from "../agents/agent.js";
+import type { Context } from "../aigne/context.js";
+import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
+export declare function extractLastJsonObject(text: string): string | null;
+export interface BedrockChatModelOptions {
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    region?: string;
+    model?: string;
+    modelOptions?: ChatModelOptions;
+}
+export declare const bedrockChatModelOptionsSchema: z.ZodObject<{
+    region: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    modelOptions: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+        presencePenalty: z.ZodOptional<z.ZodNumber>;
+        parallelToolCalls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        parallelToolCalls: boolean;
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    }, {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        parallelToolCalls?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    modelOptions?: {
+        parallelToolCalls: boolean;
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    } | undefined;
+    model?: string | undefined;
+    region?: string | undefined;
+}, {
+    modelOptions?: {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        parallelToolCalls?: boolean | undefined;
+    } | undefined;
+    model?: string | undefined;
+    region?: string | undefined;
+}>;
+export declare class BedrockChatModel extends ChatModel {
+    options?: BedrockChatModelOptions | undefined;
+    constructor(options?: BedrockChatModelOptions | undefined);
+    protected _client?: BedrockRuntimeClient;
+    get client(): BedrockRuntimeClient;
+    get modelOptions(): ChatModelOptions | undefined;
+    process(input: ChatModelInput, _context: Context, options?: AgentInvokeOptions): Promise<AgentResponse<ChatModelOutput>>;
+    private extractResultFromStream;
+}

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

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockChatModel = exports.bedrockChatModelOptionsSchema = void 0;
+exports.extractLastJsonObject = extractLastJsonObject;
+const client_bedrock_runtime_1 = require("@aws-sdk/client-bedrock-runtime");
+const nanoid_1 = require("nanoid");
+const zod_1 = require("zod");
+const json_schema_js_1 = require("../utils/json-schema.js");
+const prompts_js_1 = require("../utils/prompts.js");
+const stream_utils_js_1 = require("../utils/stream-utils.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const chat_model_js_1 = require("./chat-model.js");
+function extractLastJsonObject(text) {
+    return text.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
+}
+const BEDROCK_DEFAULT_CHAT_MODEL = "us.amazon.nova-lite-v1:0";
+exports.bedrockChatModelOptionsSchema = zod_1.z.object({
+    region: zod_1.z.string().optional(),
+    model: zod_1.z.string().optional(),
+    modelOptions: zod_1.z
+        .object({
+        model: zod_1.z.string().optional(),
+        temperature: zod_1.z.number().optional(),
+        topP: zod_1.z.number().optional(),
+        frequencyPenalty: zod_1.z.number().optional(),
+        presencePenalty: zod_1.z.number().optional(),
+        parallelToolCalls: zod_1.z.boolean().optional().default(true),
+    })
+        .optional(),
+});
+class BedrockChatModel extends chat_model_js_1.ChatModel {
+    options;
+    constructor(options) {
+        if (options)
+            (0, type_utils_js_1.checkArguments)("BedrockChatModel", exports.bedrockChatModelOptionsSchema, options);
+        super();
+        this.options = options;
+    }
+    _client;
+    get client() {
+        const credentials = this.options?.accessKeyId && this.options?.secretAccessKey
+            ? {
+                accessKeyId: this.options.accessKeyId,
+                secretAccessKey: this.options.secretAccessKey,
+            }
+            : undefined;
+        this._client ??= new client_bedrock_runtime_1.BedrockRuntimeClient({
+            region: this.options?.region,
+            credentials,
+        });
+        return this._client;
+    }
+    get modelOptions() {
+        return this.options?.modelOptions;
+    }
+    async process(input, _context, options) {
+        const modelId = input.modelOptions?.model ?? this.modelOptions?.model ?? BEDROCK_DEFAULT_CHAT_MODEL;
+        const { messages, system } = getRunMessages(input);
+        const toolConfig = convertTools(input);
+        const body = {
+            modelId,
+            messages,
+            system,
+            toolConfig,
+            inferenceConfig: {
+                temperature: input.modelOptions?.temperature ?? this.modelOptions?.temperature,
+                topP: input.modelOptions?.topP ?? this.modelOptions?.topP,
+            },
+        };
+        const command = new client_bedrock_runtime_1.ConverseStreamCommand(body);
+        const response = await this.client.send(command);
+        const jsonMode = input.responseFormat?.type === "json_schema";
+        if (options?.streaming && !jsonMode) {
+            return this.extractResultFromStream(response.stream, modelId, false, true);
+        }
+        const result = await this.extractResultFromStream(response.stream, modelId, jsonMode, false);
+        return result;
+    }
+    async extractResultFromStream(stream, modelId, jsonMode, streaming) {
+        if (!stream)
+            throw new Error("Unable to get AI model response.");
+        const result = new ReadableStream({
+            start: async (controller) => {
+                try {
+                    controller.enqueue({ delta: { json: { model: modelId } } });
+                    const toolCalls = [];
+                    let text = "";
+                    let usage;
+                    for await (const chunk of stream) {
+                        if (chunk.contentBlockStart?.start?.toolUse) {
+                            const toolUse = chunk.contentBlockStart.start.toolUse;
+                            if (!toolUse.name)
+                                throw new Error("Tool use is invalid");
+                            if (chunk.contentBlockStart.contentBlockIndex === undefined)
+                                throw new Error("Tool use content block index is required");
+                            toolCalls[chunk.contentBlockStart.contentBlockIndex] = {
+                                type: "function",
+                                id: toolUse.toolUseId || (0, nanoid_1.nanoid)(),
+                                function: {
+                                    name: toolUse.name,
+                                    arguments: {},
+                                },
+                                args: "",
+                            };
+                        }
+                        if (chunk.contentBlockDelta) {
+                            const block = chunk.contentBlockDelta;
+                            const delta = block.delta;
+                            if (delta?.text) {
+                                text += delta.text;
+                                if (!jsonMode) {
+                                    controller.enqueue({ delta: { text: { text: delta.text } } });
+                                }
+                            }
+                            if (delta?.toolUse) {
+                                if (block.contentBlockIndex === undefined)
+                                    throw new Error("Content block index is required");
+                                const call = toolCalls[block.contentBlockIndex];
+                                if (!call)
+                                    throw new Error("Tool call not found");
+                                call.args += delta.toolUse.input;
+                            }
+                        }
+                        if (chunk.metadata) {
+                            usage = chunk.metadata.usage;
+                        }
+                    }
+                    if (jsonMode && text) {
+                        const match = extractLastJsonObject(text);
+                        if (!match)
+                            throw new Error("Failed to extract JSON object from model output");
+                        controller.enqueue({
+                            delta: { json: { json: (0, json_schema_js_1.parseJSON)(match) } },
+                        });
+                    }
+                    if (toolCalls.length) {
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    toolCalls: toolCalls
+                                        .map(({ args, ...c }) => ({
+                                        ...c,
+                                        function: { ...c.function, arguments: (0, json_schema_js_1.parseJSON)(args) },
+                                    }))
+                                        .filter(type_utils_js_1.isNonNullable),
+                                },
+                            },
+                        });
+                    }
+                    controller.enqueue({ delta: { json: { usage } } });
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+        return streaming ? result : await (0, stream_utils_js_1.agentResponseStreamToObject)(result);
+    }
+}
+exports.BedrockChatModel = BedrockChatModel;
+const getRunMessages = ({ messages: msgs, responseFormat, }) => {
+    const system = [];
+    const messages = [];
+    for (const msg of msgs) {
+        if (msg.role === "system") {
+            if (typeof msg.content !== "string")
+                throw new Error("System message must have content");
+            system.push({ text: 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");
+            if (messages.at(-1)?.role === "user") {
+                messages.at(-1)?.content?.push({
+                    toolResult: { toolUseId: msg.toolCallId, content: [{ json: (0, json_schema_js_1.parseJSON)(msg.content) }] },
+                });
+            }
+            else {
+                messages.push({
+                    role: "user",
+                    content: [
+                        {
+                            toolResult: {
+                                toolUseId: msg.toolCallId,
+                                content: [{ json: (0, json_schema_js_1.parseJSON)(msg.content) }],
+                            },
+                        },
+                    ],
+                });
+            }
+        }
+        else if (msg.role === "user") {
+            if (!msg.content)
+                throw new Error("User message must have content");
+            messages.push({ role: "user", content: convertContent(msg.content) });
+        }
+        else if (msg.role === "agent") {
+            if (msg.toolCalls?.length) {
+                messages.push({
+                    role: "assistant",
+                    content: msg.toolCalls.map((i) => ({
+                        toolUse: {
+                            toolUseId: i.id,
+                            name: i.function.name,
+                            input: i.function.arguments,
+                        },
+                    })),
+                });
+            }
+            else if (msg.content) {
+                messages.push({ role: "assistant", content: convertContent(msg.content) });
+            }
+            else {
+                throw new Error("Agent message must have content or toolCalls");
+            }
+        }
+    }
+    if (messages.at(0)?.role !== "user") {
+        messages.unshift({ role: "user", content: [{ text: "." }] });
+    }
+    if (responseFormat?.type === "json_schema") {
+        system.push({
+            text: (0, prompts_js_1.getJsonOutputPrompt)(responseFormat.jsonSchema.schema),
+        });
+    }
+    return { messages, system };
+};
+function convertContent(content) {
+    if (typeof content === "string")
+        return [{ text: content }];
+    if (Array.isArray(content)) {
+        const blocks = [];
+        for (const item of content) {
+            if (item.type === "text")
+                blocks.push({ text: item.text });
+        }
+        return blocks;
+    }
+    throw new Error("Invalid chat message content");
+}
+function convertTools({ tools, toolChoice }) {
+    if (!tools?.length || toolChoice === "none")
+        return undefined;
+    let choice;
+    if (typeof toolChoice === "object" && "type" in toolChoice && toolChoice.type === "function") {
+        choice = { tool: { name: toolChoice.function.name } };
+    }
+    else if (toolChoice === "required") {
+        choice = { any: {} };
+    }
+    else if (toolChoice === "auto") {
+        choice = { auto: {} };
+    }
+    return {
+        tools: tools.map((i) => {
+            const parameters = i.function.parameters;
+            if (Object.keys(parameters).length === 0) {
+                parameters.type = "object";
+            }
+            return {
+                toolSpec: {
+                    name: i.function.name,
+                    description: i.function.description,
+                    inputSchema: { json: parameters },
+                },
+            };
+        }),
+        toolChoice: choice,
+    };
+}

package/lib/cjs/models/chat-model.d.ts

@@ -1,11 +1,12 @@
 import { Agent, type Message } from "../agents/agent.js";
-import type { Context } from "../execution-engine/context.js";
+import type { Context } from "../aigne/context.js";
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
     constructor();
     protected supportsParallelToolCalls: boolean;
     getModelCapabilities(): {
         supportsParallelToolCalls: boolean;
     };
+    private validateToolNames;
     protected preprocess(input: ChatModelInput, context: Context): void;
     protected postprocess(input: ChatModelInput, output: ChatModelOutput, context: Context): void;
 }

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

@@ -16,6 +16,13 @@ class ChatModel extends agent_js_1.Agent {
             supportsParallelToolCalls: this.supportsParallelToolCalls,
         };
     }
+    validateToolNames(tools) {
+        for (const tool of tools ?? []) {
+            if (!/^[a-zA-Z0-9_]+$/.test(tool.function.name)) {
+                throw new Error(`Tool name "${tool.function.name}" can only contain letters, numbers, and underscores`);
+            }
+        }
+    }
     preprocess(input, context) {
         super.preprocess(input, context);
         const { limits, usage } = context;
@@ -23,6 +30,7 @@ class ChatModel extends agent_js_1.Agent {
         if (limits?.maxTokens && usedTokens >= limits.maxTokens) {
             throw new Error(`Exceeded max tokens ${usedTokens}/${limits.maxTokens}`);
         }
+        this.validateToolNames(input.tools);
     }
     postprocess(input, output, context) {
         super.postprocess(input, output, context);

package/lib/cjs/models/claude-chat-model.d.ts

@@ -1,7 +1,7 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { z } from "zod";
-import type { AgentCallOptions, AgentResponse } from "../agents/agent.js";
-import type { Context } from "../execution-engine/context.js";
+import type { AgentInvokeOptions, AgentResponse } from "../agents/agent.js";
+import type { Context } from "../aigne/context.js";
 import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
 export interface ClaudeChatModelOptions {
     apiKey?: string;
@@ -62,7 +62,7 @@ export declare class ClaudeChatModel extends ChatModel {
     protected _client?: Anthropic;
     get client(): Anthropic;
     get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput, _context: Context, options?: AgentCallOptions): Promise<AgentResponse<ChatModelOutput>>;
+    process(input: ChatModelInput, _context: Context, options?: AgentInvokeOptions): Promise<AgentResponse<ChatModelOutput>>;
     private extractResultFromClaudeStream;
     private requestStructuredOutput;
 }

package/lib/cjs/models/gemini-chat-model.d.ts

@@ -5,4 +5,5 @@ export declare class GeminiChatModel extends OpenAIChatModel {
     protected supportsEndWithSystemMessage: boolean;
     protected supportsToolsUseWithJsonSchema: boolean;
     protected supportsParallelToolCalls: boolean;
+    protected supportsToolStreaming: boolean;
 }