@aigne/core 1.10.0 → 1.12.0

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

@@ -7,7 +7,7 @@ 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>[];
+    skills: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
     description?: string | null | undefined;
     name?: string | null | undefined;
     chat_model?: {
@@ -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, {
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -77,8 +77,8 @@ declare const aigneFileSchema: z.ZodObject<{
     agents?: string[] | null | undefined;
 }, {
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: string | {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -91,8 +91,8 @@ declare const aigneFileSchema: z.ZodObject<{
 }>;
 export declare function loadAIGNEFile(path: string): Promise<{
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;

package/lib/esm/loader/index.js

@@ -22,37 +22,26 @@ export async function load(options) {
     const rootDir = dirname(aigneFilePath);
     const aigne = await loadAIGNEFile(aigneFilePath);
     const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent(join(rootDir, filename))));
-    const tools = await Promise.all((aigne.tools ?? []).map((filename) => loadAgent(join(rootDir, filename))));
+    const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent(join(rootDir, filename))));
     return {
         ...aigne,
         model: await loadModel(aigne.chat_model),
         agents,
-        tools,
+        skills,
     };
 }
 export async function loadAgent(path) {
     if (extname(path) === ".js") {
         const agent = await loadAgentFromJsFile(path);
-        return FunctionAgent.from({
-            name: agent.name,
-            description: agent.description,
-            inputSchema: agent.input_schema,
-            outputSchema: agent.output_schema,
-            fn: agent.fn,
-        });
+        return FunctionAgent.from(agent);
     }
     if (extname(path) === ".yaml" || extname(path) === ".yml") {
         const agent = await loadAgentFromYamlFile(path);
         if (agent.type === "ai") {
             return AIAgent.from({
-                name: agent.name,
-                description: agent.description,
-                instructions: agent.instructions,
-                inputSchema: agent.input_schema,
-                outputSchema: agent.output_schema,
-                outputKey: agent.output_key,
-                tools: await Promise.all((agent.tools ?? []).map((filename) => loadAgent(join(dirname(path), filename)))),
-                toolChoice: agent.tool_choice,
+                ...agent,
+                skills: agent.skills &&
+                    (await Promise.all(agent.skills.map((filename) => loadAgent(join(dirname(path), filename))))),
             });
         }
         if (agent.type === "mcp") {
@@ -117,12 +106,12 @@ const aigneFileSchema = z.object({
         .nullish()
         .transform((v) => (typeof v === "string" ? { name: v } : v)),
     agents: z.array(z.string()).nullish(),
-    tools: z.array(z.string()).nullish(),
+    skills: z.array(z.string()).nullish(),
 });
 export async function loadAIGNEFile(path) {
     const raw = await tryOrThrow(() => readFile(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
     const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
-    const agent = tryOrThrow(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
+    const agent = 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/esm/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/esm/models/claude-chat-model.d.ts

@@ -1,5 +1,7 @@
 import Anthropic from "@anthropic-ai/sdk";
 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 interface ClaudeChatModelOptions {
     apiKey?: string;
@@ -60,7 +62,7 @@ export declare class ClaudeChatModel extends ChatModel {
     protected _client?: Anthropic;
     get client(): Anthropic;
     get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput): Promise<ChatModelOutput>;
+    process(input: ChatModelInput, _context: Context, options?: AgentInvokeOptions): Promise<AgentResponse<ChatModelOutput>>;
     private extractResultFromClaudeStream;
     private requestStructuredOutput;
 }

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

@@ -1,8 +1,8 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { z } from "zod";
 import { parseJSON } from "../utils/json-schema.js";
-import { logger } from "../utils/logger.js";
 import { mergeUsage } from "../utils/model-utils.js";
+import { agentResponseStreamToObject } from "../utils/stream-utils.js";
 import { checkArguments, isEmpty, isNonNullable } from "../utils/type-utils.js";
 import { ChatModel, } from "./chat-model.js";
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
@@ -39,7 +39,7 @@ export class ClaudeChatModel extends ChatModel {
     get modelOptions() {
         return this.options?.modelOptions;
     }
-    async process(input) {
+    async process(input, _context, options) {
         const model = this.options?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL;
         const disableParallelToolUse = input.modelOptions?.parallelToolCalls === false ||
             this.modelOptions?.parallelToolCalls === false;
@@ -56,6 +56,9 @@ export class ClaudeChatModel extends ChatModel {
             ...body,
             stream: true,
         });
+        if (options?.streaming && input.responseFormat?.type !== "json_schema") {
+            return this.extractResultFromClaudeStream(stream, true);
+        }
         const result = await this.extractResultFromClaudeStream(stream);
         // Claude doesn't support json_schema response and tool calls in the same request,
         // so we need to make a separate request for json_schema response when the tool calls is empty
@@ -69,67 +72,79 @@ export class ClaudeChatModel extends ChatModel {
         }
         return result;
     }
-    async extractResultFromClaudeStream(stream) {
+    async extractResultFromClaudeStream(stream, streaming) {
         const logs = [];
-        try {
-            let text = "";
-            const toolCalls = [];
-            let usage;
-            let model;
-            for await (const chunk of stream) {
-                if (chunk.type === "message_start") {
-                    model ??= chunk.message.model;
-                    const { input_tokens, output_tokens } = chunk.message.usage;
-                    usage = {
-                        inputTokens: input_tokens,
-                        outputTokens: output_tokens,
-                    };
-                }
-                if (chunk.type === "message_delta" && usage) {
-                    usage.outputTokens = chunk.usage.output_tokens;
-                }
-                logs.push(JSON.stringify(chunk));
-                // handle streaming text
-                if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-                    text += chunk.delta.text;
+        const result = new ReadableStream({
+            async start(controller) {
+                try {
+                    const toolCalls = [];
+                    let usage;
+                    let model;
+                    for await (const chunk of stream) {
+                        if (chunk.type === "message_start") {
+                            if (!model) {
+                                model = chunk.message.model;
+                                controller.enqueue({ delta: { json: { model } } });
+                            }
+                            const { input_tokens, output_tokens } = chunk.message.usage;
+                            usage = {
+                                inputTokens: input_tokens,
+                                outputTokens: output_tokens,
+                            };
+                        }
+                        if (chunk.type === "message_delta" && usage) {
+                            usage.outputTokens = chunk.usage.output_tokens;
+                        }
+                        logs.push(JSON.stringify(chunk));
+                        // handle streaming text
+                        if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                            controller.enqueue({ delta: { text: { text: chunk.delta.text } } });
+                        }
+                        if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+                            toolCalls[chunk.index] = {
+                                type: "function",
+                                id: chunk.content_block.id,
+                                function: {
+                                    name: chunk.content_block.name,
+                                    arguments: {},
+                                },
+                                args: "",
+                            };
+                        }
+                        if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+                            const call = toolCalls[chunk.index];
+                            if (!call)
+                                throw new Error("Tool call not found");
+                            call.args += chunk.delta.partial_json;
+                        }
+                    }
+                    controller.enqueue({ delta: { json: { usage } } });
+                    if (toolCalls.length) {
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    toolCalls: toolCalls
+                                        .map(({ args, ...c }) => ({
+                                        ...c,
+                                        function: {
+                                            ...c.function,
+                                            // NOTE: claude may return a blank string for empty object (the tool's input schema is a empty object)
+                                            arguments: args.trim() ? parseJSON(args) : {},
+                                        },
+                                    }))
+                                        .filter(isNonNullable),
+                                },
+                            },
+                        });
+                    }
+                    controller.close();
                 }
-                if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
-                    toolCalls[chunk.index] = {
-                        type: "function",
-                        id: chunk.content_block.id,
-                        function: {
-                            name: chunk.content_block.name,
-                            arguments: {},
-                        },
-                        args: "",
-                    };
+                catch (error) {
+                    controller.error(error);
                 }
-                if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
-                    const call = toolCalls[chunk.index];
-                    if (!call)
-                        throw new Error("Tool call not found");
-                    call.args += chunk.delta.partial_json;
-                }
-            }
-            const result = { usage, model, text };
-            if (toolCalls.length) {
-                result.toolCalls = toolCalls
-                    .map(({ args, ...c }) => ({
-                    ...c,
-                    function: {
-                        ...c.function,
-                        // NOTE: claude may return a blank string for empty object (the tool's input schema is a empty object)
-                        arguments: args.trim() ? parseJSON(args) : {},
-                    },
-                }))
-                    .filter(isNonNullable);
-            }
-            return result;
-        }
-        catch (error) {
-            logger.core("Failed to process Claude stream", { error, logs });
-            throw error;
-        }
+            },
+        });
+        return streaming ? result : await agentResponseStreamToObject(result);
     }
     async requestStructuredOutput(body, responseFormat) {
         if (responseFormat?.type !== "json_schema") {

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/models/openai-chat-model.js

@@ -323,13 +323,11 @@ async function extractResultFromStream(stream, jsonMode, streaming) {
                         },
                     });
                 }
+                controller.close();
             }
             catch (error) {
                 controller.error(error);
             }
-            finally {
-                controller.close();
-            }
         },
     });
     return streaming ? result : await agentResponseStreamToObject(result);

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/camelize.d.ts

@@ -0,0 +1,13 @@
+export declare function customCamelize<T extends Record<string, unknown>, K extends KeyofUnion<T> = never>(obj: T, { shallowKeys }?: {
+    shallowKeys?: K[];
+}): CustomCamelize<T, K>;
+type KeyofUnion<U> = U extends Record<string, unknown> ? keyof U : never;
+type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${P1}${Uppercase<P2>}${CamelCase<P3>}` : S;
+declare const _unique: unique symbol;
+type _never = typeof _unique;
+type ExtractTypeFromUnion<T, U> = Extract<T, U> extends never ? _never : Extract<T, U> extends Array<infer E> ? Array<E> : U;
+type ExtractTypeWithConstFromUnion<T, U> = Exclude<T, Exclude<T, U>>;
+export type CustomCamelize<T, ShallowKeys extends KeyofUnion<T> | undefined = undefined> = ExtractTypeFromUnion<T, never> extends never ? never : ExtractTypeFromUnion<T, Date> extends Date ? ExtractTypeWithConstFromUnion<T, Date> | CustomCamelize<Exclude<T, Date>> : ExtractTypeFromUnion<T, RegExp> extends RegExp ? ExtractTypeWithConstFromUnion<T, RegExp> | CustomCamelize<Exclude<T, RegExp>> : ExtractTypeFromUnion<T, Array<unknown>> extends Array<infer U> ? Array<CustomCamelize<U>> | CustomCamelize<Exclude<T, Array<U>>> : ExtractTypeFromUnion<T, Function> extends Function ? ExtractTypeWithConstFromUnion<T, Function> | CustomCamelize<Exclude<T, Function>> : ExtractTypeFromUnion<T, object> extends object ? {
+    [K in keyof T as Uncapitalize<CamelCase<string & K>>]: K extends Exclude<ShallowKeys, undefined> ? T[K] : CustomCamelize<T[K]>;
+} : T;
+export {};

package/lib/esm/utils/camelize.js

@@ -0,0 +1,10 @@
+import camelize from "camelize-ts";
+export function customCamelize(obj, { shallowKeys = [] } = {}) {
+    const shallow = Object.fromEntries(shallowKeys?.filter((key) => key in obj).map((key) => [key, obj[key]]) ?? []);
+    const deep = Object.fromEntries(Object.entries(obj).filter(([key]) => !shallowKeys?.includes(key)));
+    return {
+        ...camelize(shallow, true),
+        ...camelize(deep),
+    };
+}
+const _unique = Symbol();

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>);
+}