@aigne/core 1.11.0 → 1.12.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

@@ -28,12 +28,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 +46,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") {
@@ -112,12 +112,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/chat-model.d.ts

@@ -1,5 +1,5 @@
 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;

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/openai-chat-model.d.ts

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
 import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
 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 ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
 export interface OpenAIChatModelCapabilities {
     supportsNativeStructuredOutputs: boolean;
@@ -83,7 +83,7 @@ export declare class OpenAIChatModel extends ChatModel {
     protected supportsTemperature: boolean;
     get client(): OpenAI;
     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 getParallelToolCalls;
     private getRunMessages;
     private getRunResponseFormat;

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

@@ -2,7 +2,7 @@ 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 { AgentMemory } from "../agents/memory.js";
-import type { Context } from "../execution-engine/context.js";
+import type { Context } from "../aigne/context.js";
 import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";

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

@@ -117,10 +117,10 @@ class PromptBuilder {
             : undefined;
     }
     buildTools(options) {
-        const toolAgents = (options.context?.tools ?? [])
-            .concat(options.agent?.tools ?? [])
+        const toolAgents = (options.context?.skills ?? [])
+            .concat(options.agent?.skills ?? [])
             // TODO: support nested tools?
-            .flatMap((i) => (i.isCallable ? i.tools.concat(i) : i.tools));
+            .flatMap((i) => (i.isInvokable ? i.skills.concat(i) : i.skills));
         const tools = toolAgents.map((i) => ({
             type: "function",
             function: {

package/lib/cjs/server/error.d.ts

@@ -0,0 +1,4 @@
+export declare class ServerError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}

package/lib/cjs/server/error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerError = void 0;
+class ServerError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.ServerError = ServerError;

package/lib/cjs/server/server.d.ts

@@ -0,0 +1,54 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { z } from "zod";
+import type { AIGNE } from "../aigne/aigne.js";
+export declare const invokePayloadSchema: z.ZodObject<{
+    agent: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    options: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        streaming: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        streaming?: boolean | null | undefined;
+    }, {
+        streaming?: boolean | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    agent: string;
+    input: Record<string, unknown>;
+    options?: {
+        streaming?: boolean | null | undefined;
+    } | null | undefined;
+}, {
+    agent: string;
+    input: Record<string, unknown>;
+    options?: {
+        streaming?: boolean | null | undefined;
+    } | null | undefined;
+}>;
+export interface AIGNEServerOptions {
+    /**
+     * Maximum body size for the request.
+     * Only used when the request is a Node.js IncomingMessage and no `body` property is present.
+     * @default "4mb"
+     */
+    maximumBodySize?: string;
+}
+export declare class AIGNEServer {
+    engine: AIGNE;
+    options?: AIGNEServerOptions | undefined;
+    constructor(engine: AIGNE, options?: AIGNEServerOptions | undefined);
+    /**
+     * Invoke the agent with the given input.
+     * @param request - The request object, which can be a parsed JSON object, a Fetch API Request object, or a Node.js IncomingMessage object.
+     * @returns The web standard response, you can return it directly in supported frameworks like hono.
+     */
+    invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
+    /**
+     * Invoke the agent with the given input, and write the SSE response to the Node.js ServerResponse.
+     * @param request - The request object, which can be a parsed JSON object, a Fetch API Request object, or a Node.js IncomingMessage object.
+     * @param response - The Node.js ServerResponse object to write the SSE response to.
+     */
+    invoke(request: Record<string, unknown> | Request | IncomingMessage, response: ServerResponse): Promise<void>;
+    _invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
+    _prepareInput(request: Record<string, unknown> | Request | IncomingMessage): Promise<Record<string, unknown>>;
+    _writeResponse(response: Response, res: ServerResponse): Promise<void>;
+}

package/lib/cjs/server/server.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIGNEServer = exports.invokePayloadSchema = void 0;
+const node_http_1 = require("node:http");
+const content_type_1 = __importDefault(require("content-type"));
+const raw_body_1 = __importDefault(require("raw-body"));
+const zod_1 = require("zod");
+const event_stream_js_1 = require("../utils/event-stream.js");
+const stream_utils_js_1 = require("../utils/stream-utils.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const error_js_1 = require("./error.js");
+const DEFAULT_MAXIMUM_BODY_SIZE = "4mb";
+exports.invokePayloadSchema = zod_1.z.object({
+    agent: zod_1.z.string(),
+    input: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+    options: zod_1.z
+        .object({
+        streaming: zod_1.z.boolean().nullish(),
+    })
+        .nullish(),
+});
+class AIGNEServer {
+    engine;
+    options;
+    constructor(engine, options) {
+        this.engine = engine;
+        this.options = options;
+    }
+    async invoke(request, response) {
+        const result = await this._invoke(request);
+        if (response instanceof node_http_1.ServerResponse) {
+            await this._writeResponse(result, response);
+            return;
+        }
+        return result;
+    }
+    async _invoke(request) {
+        const { engine } = this;
+        try {
+            const payload = await this._prepareInput(request);
+            const { agent: agentName, input, options, } = (0, type_utils_js_1.tryOrThrow)(() => (0, type_utils_js_1.checkArguments)(`Invoke agent ${payload.agent}`, exports.invokePayloadSchema, payload), (error) => new error_js_1.ServerError(400, error.message));
+            const agent = engine.agents[agentName];
+            if (!agent)
+                throw new error_js_1.ServerError(404, `Agent ${agentName} not found`);
+            if (!options?.streaming) {
+                const result = await engine.invoke(agent, input);
+                return new Response(JSON.stringify(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            const stream = await engine.invoke(agent, input, { streaming: true });
+            return new Response(new event_stream_js_1.AgentResponseStreamSSE(stream), {
+                headers: {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    "X-Accel-Buffering": "no",
+                },
+            });
+        }
+        catch (error) {
+            return new Response(JSON.stringify({ error: { message: error.message } }), {
+                status: error instanceof error_js_1.ServerError ? error.status : 500,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+    }
+    async _prepareInput(request) {
+        const contentTypeError = new error_js_1.ServerError(415, "Unsupported Media Type: Content-Type must be application/json");
+        if (request instanceof node_http_1.IncomingMessage) {
+            // Support for express with json() middleware
+            if ("body" in request && typeof request.body === "object") {
+                if (!(0, type_utils_js_1.isRecord)(request.body))
+                    throw contentTypeError;
+                return request.body;
+            }
+            // Support vanilla nodejs http server
+            const maximumBodySize = this.options?.maximumBodySize || DEFAULT_MAXIMUM_BODY_SIZE;
+            const ct = request.headers["content-type"];
+            if (!ct || !ct.includes("application/json"))
+                throw contentTypeError;
+            const parsedCt = content_type_1.default.parse(ct);
+            const raw = await (0, raw_body_1.default)(request, {
+                limit: maximumBodySize,
+                encoding: parsedCt.parameters.charset ?? "utf-8",
+            });
+            return (0, type_utils_js_1.tryOrThrow)(() => JSON.parse(raw.toString()), (error) => new error_js_1.ServerError(400, `Parse request body to json error: ${error.message}`));
+        }
+        if (request instanceof Request) {
+            if (!request.headers.get("content-type")?.includes("application/json")) {
+                throw contentTypeError;
+            }
+            return await request.json();
+        }
+        if (!(0, type_utils_js_1.isRecord)(request))
+            throw contentTypeError;
+        return request;
+    }
+    async _writeResponse(response, res) {
+        try {
+            res.writeHead(response.status, response.headers.toJSON());
+            res.flushHeaders();
+            if (!response.body)
+                throw new Error("Response body is empty");
+            for await (const chunk of (0, stream_utils_js_1.readableStreamToAsyncIterator)(response.body)) {
+                res.write(chunk);
+                // Support for express with compression middleware
+                if ("flush" in res && typeof res.flush === "function") {
+                    res.flush();
+                }
+            }
+        }
+        catch (error) {
+            if (!res.headersSent) {
+                res.writeHead(error instanceof error_js_1.ServerError ? error.status : 500, {
+                    "Content-Type": "application/json",
+                });
+            }
+            if (res.writable) {
+                res.write(JSON.stringify({ error: { message: error.message } }));
+            }
+        }
+        finally {
+            res.end();
+        }
+    }
+}
+exports.AIGNEServer = AIGNEServer;

package/lib/cjs/utils/event-stream.d.ts

@@ -0,0 +1,11 @@
+import type { AgentResponseChunk, AgentResponseStream, Message } from "../agents/agent.js";
+export declare class EventStreamParser<T> extends TransformStream<string, T | Error> {
+    constructor();
+}
+export declare class AgentResponseStreamParser<O extends Message> extends TransformStream<AgentResponseChunk<O> | Error, AgentResponseChunk<O>> {
+    private json;
+    constructor();
+}
+export declare class AgentResponseStreamSSE<O extends Message> extends ReadableStream<string> {
+    constructor(stream: AgentResponseStream<O>);
+}

package/lib/cjs/utils/event-stream.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentResponseStreamSSE = exports.AgentResponseStreamParser = exports.EventStreamParser = void 0;
+const eventsource_parser_1 = require("eventsource-parser");
+const immer_1 = require("immer");
+const type_utils_js_1 = require("./type-utils.js");
+class EventStreamParser extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = (0, eventsource_parser_1.createParser)({
+                    onEvent: (event) => {
+                        const json = (0, type_utils_js_1.tryOrThrow)(() => JSON.parse(event.data), (e) => {
+                            controller.enqueue(new Error(`Parse response chunk json error: ${e.message} ${event.data}`));
+                        });
+                        if (json) {
+                            if (event.event === "error") {
+                                controller.enqueue(new Error(json.message));
+                            }
+                            else {
+                                controller.enqueue(json);
+                            }
+                        }
+                    },
+                });
+            },
+            transform(chunk) {
+                parser?.feed(chunk);
+            },
+        });
+    }
+}
+exports.EventStreamParser = EventStreamParser;
+class AgentResponseStreamParser extends TransformStream {
+    json = {};
+    constructor() {
+        super({
+            transform: (chunk, controller) => {
+                if (chunk instanceof Error) {
+                    controller.error(chunk);
+                    controller.terminate();
+                    return;
+                }
+                this.json = (0, immer_1.produce)(this.json, (draft) => {
+                    if (chunk.delta.json)
+                        Object.assign(draft, chunk.delta.json);
+                    if (chunk.delta.text) {
+                        for (const [key, text] of Object.entries(chunk.delta.text)) {
+                            const original = draft[key];
+                            const t = (original || "") + (text || "");
+                            if (t)
+                                Object.assign(draft, { [key]: t });
+                        }
+                    }
+                });
+                controller.enqueue({
+                    ...chunk,
+                    delta: {
+                        ...chunk.delta,
+                        json: this.json,
+                    },
+                });
+            },
+        });
+    }
+}
+exports.AgentResponseStreamParser = AgentResponseStreamParser;
+class AgentResponseStreamSSE extends ReadableStream {
+    constructor(stream) {
+        let reader;
+        super({
+            async pull(controller) {
+                reader ??= stream.getReader();
+                try {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        return;
+                    }
+                    controller.enqueue(`data: ${JSON.stringify(value)}\n\n`);
+                }
+                catch (error) {
+                    controller.enqueue(`event: error\ndata: ${JSON.stringify({ message: error.message })}\n\n`);
+                    controller.close();
+                }
+            },
+        });
+    }
+}
+exports.AgentResponseStreamSSE = AgentResponseStreamSSE;

package/lib/cjs/utils/mcp-utils.js

@@ -8,12 +8,15 @@ const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.j
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const zod_1 = require("zod");
 const mcp_agent_js_1 = require("../agents/mcp-agent.js");
+const type_utils_js_1 = require("./type-utils.js");
 function toolFromMCPTool(tool, options) {
     return new mcp_agent_js_1.MCPTool({
         ...options,
         name: tool.name,
         description: tool.description,
-        inputSchema: (0, json_schema_to_zod_1.jsonSchemaToZod)(tool.inputSchema),
+        inputSchema: (0, type_utils_js_1.isEmpty)(tool.inputSchema.properties)
+            ? zod_1.z.object({})
+            : (0, json_schema_to_zod_1.jsonSchemaToZod)(tool.inputSchema),
         outputSchema: types_js_1.CallToolResultSchema,
     });
 }