@aigne/core 1.11.0 → 1.12.0

package/lib/esm/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/esm/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/esm/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/esm/prompt/prompt-builder.js

@@ -112,10 +112,10 @@ export 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/esm/server/error.d.ts

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

package/lib/esm/server/error.js

@@ -0,0 +1,7 @@
+export class ServerError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}

package/lib/esm/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/esm/server/server.js

@@ -0,0 +1,123 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import contentType from "content-type";
+import getRawBody from "raw-body";
+import { z } from "zod";
+import { AgentResponseStreamSSE } from "../utils/event-stream.js";
+import { readableStreamToAsyncIterator } from "../utils/stream-utils.js";
+import { checkArguments, isRecord, tryOrThrow } from "../utils/type-utils.js";
+import { ServerError } from "./error.js";
+const DEFAULT_MAXIMUM_BODY_SIZE = "4mb";
+export const invokePayloadSchema = z.object({
+    agent: z.string(),
+    input: z.record(z.string(), z.unknown()),
+    options: z
+        .object({
+        streaming: z.boolean().nullish(),
+    })
+        .nullish(),
+});
+export 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 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, } = tryOrThrow(() => checkArguments(`Invoke agent ${payload.agent}`, invokePayloadSchema, payload), (error) => new ServerError(400, error.message));
+            const agent = engine.agents[agentName];
+            if (!agent)
+                throw new 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 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 ServerError ? error.status : 500,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+    }
+    async _prepareInput(request) {
+        const contentTypeError = new ServerError(415, "Unsupported Media Type: Content-Type must be application/json");
+        if (request instanceof IncomingMessage) {
+            // Support for express with json() middleware
+            if ("body" in request && typeof request.body === "object") {
+                if (!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 = contentType.parse(ct);
+            const raw = await getRawBody(request, {
+                limit: maximumBodySize,
+                encoding: parsedCt.parameters.charset ?? "utf-8",
+            });
+            return tryOrThrow(() => JSON.parse(raw.toString()), (error) => new 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 (!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 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 ServerError ? error.status : 500, {
+                    "Content-Type": "application/json",
+                });
+            }
+            if (res.writable) {
+                res.write(JSON.stringify({ error: { message: error.message } }));
+            }
+        }
+        finally {
+            res.end();
+        }
+    }
+}

package/lib/esm/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/esm/utils/event-stream.js

@@ -0,0 +1,85 @@
+import { createParser } from "eventsource-parser";
+import { produce } from "immer";
+import { tryOrThrow } from "./type-utils.js";
+export class EventStreamParser extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = createParser({
+                    onEvent: (event) => {
+                        const json = 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);
+            },
+        });
+    }
+}
+export class AgentResponseStreamParser extends TransformStream {
+    json = {};
+    constructor() {
+        super({
+            transform: (chunk, controller) => {
+                if (chunk instanceof Error) {
+                    controller.error(chunk);
+                    controller.terminate();
+                    return;
+                }
+                this.json = 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,
+                    },
+                });
+            },
+        });
+    }
+}
+export 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();
+                }
+            },
+        });
+    }
+}

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

@@ -3,12 +3,15 @@ import { UriTemplate } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
 import { CallToolResultSchema, GetPromptResultSchema, ReadResourceResultSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.js";
+import { isEmpty } from "./type-utils.js";
 export function toolFromMCPTool(tool, options) {
     return new MCPTool({
         ...options,
         name: tool.name,
         description: tool.description,
-        inputSchema: jsonSchemaToZod(tool.inputSchema),
+        inputSchema: isEmpty(tool.inputSchema.properties)
+            ? z.object({})
+            : jsonSchemaToZod(tool.inputSchema),
         outputSchema: CallToolResultSchema,
     });
 }

package/lib/esm/utils/stream-utils.d.ts

@@ -11,7 +11,12 @@ export declare function onAgentResponseStreamEnd<T extends Message>(stream: Agen
 }): ReadableStream<any>;
 export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
 export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chunks: (AgentResponseChunk<T> | Error)[], result?: Partial<T>): AgentProcessAsyncGenerator<T>;
-export declare function arrayToAgentResponseStream<T>(chunks: (AgentResponseChunk<T> | Error)[]): AgentResponseStream<T>;
-export declare function readableStreamToArray<T>(stream: ReadableStream<T>): Promise<T[]>;
+export declare function arrayToReadableStream<T>(chunks: (T | Error)[]): ReadableStream<T>;
+export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options: {
+    catchError: true;
+}): Promise<(T | Error)[]>;
+export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options?: {
+    catchError?: false;
+}): Promise<T[]>;
 export declare function readableStreamToAsyncIterator<T>(stream: ReadableStream<T>): AsyncIterable<T>;
 export declare function stringToAgentResponseStream(str: string, key?: "text" | typeof MESSAGE_KEY | string): AgentResponseStream<Message>;

package/lib/esm/utils/stream-utils.js

@@ -3,7 +3,7 @@ import { isEmptyChunk, } from "../agents/agent.js";
 import { omitBy } from "./type-utils.js";
 export function objectToAgentResponseStream(json) {
     return new ReadableStream({
-        start(controller) {
+        pull(controller) {
             controller.enqueue({ delta: { json } });
             controller.close();
         },
@@ -49,22 +49,20 @@ export async function agentResponseStreamToObject(stream) {
 }
 export function asyncGeneratorToReadableStream(generator) {
     return new ReadableStream({
-        async start(controller) {
+        async pull(controller) {
             try {
-                for (;;) {
-                    const chunk = await generator.next();
-                    if (chunk.value) {
-                        if (chunk.done) {
-                            controller.enqueue({ delta: { json: chunk.value } });
-                        }
-                        else {
-                            controller.enqueue(chunk.value);
-                        }
+                const chunk = await generator.next();
+                if (chunk.value) {
+                    if (chunk.done) {
+                        controller.enqueue({ delta: { json: chunk.value } });
+                    }
+                    else {
+                        controller.enqueue(chunk.value);
                     }
-                    if (chunk.done)
-                        break;
                 }
-                controller.close();
+                if (chunk.done) {
+                    controller.close();
+                }
             }
             catch (error) {
                 controller.error(error);
@@ -73,15 +71,18 @@ export function asyncGeneratorToReadableStream(generator) {
     });
 }
 export function onAgentResponseStreamEnd(stream, callback, options) {
+    const json = {};
+    const reader = stream.getReader();
     return new ReadableStream({
-        async start(controller) {
+        async pull(controller) {
             try {
-                const json = {};
-                for await (const value of readableStreamToAsyncIterator(stream)) {
+                const { value, done } = await reader.read();
+                if (!done) {
                     const chunk = options?.processChunk ? options.processChunk(value) : value;
                     if (!isEmptyChunk(chunk))
                         controller.enqueue(chunk);
                     mergeAgentResponseChunk(json, value);
+                    return;
                 }
                 const result = await callback(json);
                 if (result && !equal(result, json)) {
@@ -90,13 +91,11 @@ export function onAgentResponseStreamEnd(stream, callback, options) {
                         chunk = options.processChunk(chunk);
                     controller.enqueue(chunk);
                 }
+                controller.close();
             }
             catch (error) {
                 controller.error(options?.errorCallback?.(error) ?? error);
             }
-            finally {
-                controller.close();
-            }
         },
     });
 }
@@ -112,24 +111,34 @@ export async function* arrayToAgentProcessAsyncGenerator(chunks, result) {
     if (result !== undefined)
         return result;
 }
-export function arrayToAgentResponseStream(chunks) {
+export function arrayToReadableStream(chunks) {
+    const list = [...chunks];
     return new ReadableStream({
-        start(controller) {
-            for (const chunk of chunks) {
-                if (chunk instanceof Error) {
-                    controller.error(chunk);
-                    return;
-                }
-                controller.enqueue(chunk);
+        pull(controller) {
+            const item = list.shift();
+            if (!item) {
+                controller.close();
+                return;
             }
-            controller.close();
+            if (item instanceof Error) {
+                controller.error(item);
+                return;
+            }
+            controller.enqueue(item);
         },
     });
 }
-export async function readableStreamToArray(stream) {
+export async function readableStreamToArray(stream, options) {
     const result = [];
-    for await (const value of readableStreamToAsyncIterator(stream)) {
-        result.push(value);
+    try {
+        for await (const value of readableStreamToAsyncIterator(stream)) {
+            result.push(value);
+        }
+    }
+    catch (error) {
+        if (!options?.catchError)
+            throw error;
+        result.push(error);
     }
     return result;
 }
@@ -145,5 +154,5 @@ export async function* readableStreamToAsyncIterator(stream) {
 export function stringToAgentResponseStream(str, key = "text") {
     const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
     const segments = segmenter.segment(str);
-    return arrayToAgentResponseStream(Array.from(segments).map((segment) => ({ delta: { text: { [key]: segment.segment } } })));
+    return arrayToReadableStream(Array.from(segments).map((segment) => ({ delta: { text: { [key]: segment.segment } } })));
 }

package/lib/esm/utils/type-utils.d.ts

@@ -1,8 +1,9 @@
 import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
-export type Nullish<T> = T | null | undefined;
+export type Nullish<T> = T | null | undefined | void;
 export type OmitPropertiesFromArrayFirstElement<T extends unknown[], K extends string | number | symbol> = T extends [infer U, ...infer Rest] ? [Omit<U, K>, ...Rest] : never;
 export declare function isNil(value: unknown): value is null | undefined;
+export declare function isRecord<T>(value: unknown): value is Record<string, T>;
 export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
@@ -12,5 +13,6 @@ export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): T;
+export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T | unknown): T;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;
+export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error?: Nullish<string | Error | ((error: Error) => Nullish<Error>)>): P | undefined;

package/lib/esm/utils/type-utils.js

@@ -2,6 +2,9 @@ import { z } from "zod";
 export function isNil(value) {
     return value === null || value === undefined;
 }
+export function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
 export function isEmpty(obj) {
     if (isNil(obj))
         return true;
@@ -101,12 +104,16 @@ export function tryOrThrow(fn, error) {
         const result = fn();
         if (result instanceof Promise) {
             return result.catch((e) => {
-                throw createError(e);
+                const error = createError(e);
+                if (error)
+                    throw error;
             });
         }
         return result;
     }
     catch (e) {
-        throw createError(e);
+        const error = createError(e);
+        if (error)
+            throw error;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -44,8 +44,8 @@
       "agents/*": [
         "./lib/dts/agents/*"
       ],
-      "execution-engine/*": [
-        "./lib/dts/execution-engine/*"
+      "aigne/*": [
+        "./lib/dts/aigne/*"
       ],
       "loader/*": [
         "./lib/dts/loader/*"
@@ -63,15 +63,20 @@
   },
   "dependencies": {
     "@aigne/json-schema-to-zod": "^1.3.3",
-    "@modelcontextprotocol/sdk": "^1.9.0",
+    "@modelcontextprotocol/sdk": "^1.10.2",
     "@types/debug": "^4.1.12",
     "camelize-ts": "^3.0.0",
+    "content-type": "^1.0.5",
     "debug": "^4.4.0",
+    "eventsource-parser": "^3.0.1",
     "fast-deep-equal": "^3.1.3",
+    "immer": "^10.1.1",
     "inquirer": "^12.5.2",
     "mustache": "^4.2.0",
     "nanoid": "^5.1.5",
     "p-retry": "^6.2.1",
+    "raw-body": "^3.0.0",
+    "ufo": "^1.6.1",
     "uuid": "^11.1.0",
     "yaml": "^2.7.1",
     "zod": "^3.24.2",
@@ -86,11 +91,15 @@
     "@anthropic-ai/sdk": "^0.39.0",
     "@google/generative-ai": "^0.24.0",
     "@types/bun": "^1.2.9",
+    "@types/compression": "^1.7.5",
+    "@types/content-type": "^1.1.8",
     "@types/express": "^5.0.1",
     "@types/mustache": "^4.2.5",
     "@types/node": "^22.14.1",
+    "compression": "^1.8.0",
     "detect-port": "^2.1.0",
     "express": "^5.1.0",
+    "hono": "^4.7.7",
     "npm-run-all": "^4.1.5",
     "openai": "^4.94.0",
     "rimraf": "^6.0.1",

package/lib/cjs/execution-engine/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./context.js";
-export * from "./execution-engine.js";
-export * from "./message-queue.js";
-export * from "./utils.js";

package/lib/cjs/execution-engine/utils.d.ts

@@ -1,4 +0,0 @@
-import { type FunctionAgentFn } from "../agents/agent.js";
-import type { Runnable } from "./context.js";
-export declare function sequential(...agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
-export declare function parallel(...agents: [Runnable, ...Runnable[]]): FunctionAgentFn;