@aigne/core 1.14.0 → 1.16.0

package/lib/esm/utils/logger.d.ts

@@ -1,8 +1,33 @@
-import debug from "debug";
-export declare const logger: debug.Debug & {
-    debug: debug.Debug;
-    default: debug.Debug;
-} & {
-    core: debug.Debugger;
-    mcp: debug.Debugger;
-};
+export declare enum LogLevel {
+    ERROR = "error",
+    WARN = "warn",
+    INFO = "info",
+    DEBUG = "debug"
+}
+export declare class Logger {
+    constructor(options: {
+        level: LogLevel;
+        ns: string;
+    });
+    level: LogLevel;
+    private debugLogger;
+    private infoLogger;
+    private warnLogger;
+    private errorLogger;
+    logMessage: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    logError: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    enabled(level: LogLevel): boolean;
+}
+export declare const logger: Logger;

package/lib/esm/utils/logger.js

@@ -1,6 +1,63 @@
+import { isatty } from "node:tty";
 import debug from "debug";
-const base = debug("aigne");
-export const logger = Object.assign(debug, {
-    core: base.extend("core"),
-    mcp: base.extend("mcp"),
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (LogLevel = {}));
+const levels = Object.values(LogLevel);
+export class Logger {
+    constructor(options) {
+        this.level = options.level;
+        this.debugLogger = debug(`${options.ns}:debug`);
+        this.infoLogger = debug(`${options.ns}:info`);
+        this.warnLogger = debug(`${options.ns}:warn`);
+        this.errorLogger = debug(`${options.ns}:error`);
+        for (const logger of [this.debugLogger, this.infoLogger, this.warnLogger]) {
+            // @ts-ignore
+            logger.useColors = isatty(process.stdout.fd);
+            logger.enabled = true;
+            logger.log = (...args) => this.logMessage(...args);
+        }
+        this.errorLogger.log = (...args) => this.logError(...args);
+        // @ts-ignore
+        this.errorLogger.useColors = isatty(process.stderr.fd);
+        this.errorLogger.enabled = true;
+    }
+    level;
+    debugLogger;
+    infoLogger;
+    warnLogger;
+    errorLogger;
+    logMessage = console.log;
+    logError = console.error;
+    debug(message, ...args) {
+        if (this.enabled(LogLevel.DEBUG)) {
+            this.debugLogger(message, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.enabled(LogLevel.INFO)) {
+            this.infoLogger(message, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.enabled(LogLevel.WARN)) {
+            this.warnLogger(message, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.enabled(LogLevel.ERROR)) {
+            this.errorLogger(message, ...args);
+        }
+    }
+    enabled(level) {
+        return levels.indexOf(this.level) >= levels.indexOf(level);
+    }
+}
+export const logger = new Logger({
+    ns: "aigne:core",
+    level: LogLevel.INFO,
 });

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

@@ -1,3 +1,3 @@
-import type { ChatModelOutputUsage } from "../models/chat-model.js";
+import type { ChatModelOutputUsage } from "../agents/chat-model.js";
 import type { Nullish } from "./type-utils.js";
 export declare function mergeUsage(...usages: Nullish<ChatModelOutputUsage>[]): ChatModelOutputUsage;

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

@@ -6,7 +6,7 @@ export declare function mergeAgentResponseChunk<T extends Message>(output: T, ch
 export declare function agentResponseStreamToObject<T extends Message>(stream: AgentResponseStream<T> | AgentProcessAsyncGenerator<T>): Promise<T>;
 export declare function asyncGeneratorToReadableStream<T extends Message>(generator: AgentProcessAsyncGenerator<T>): AgentResponseStream<T>;
 export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, callback: (result: T) => PromiseOrValue<Partial<T> | void>, options?: {
-    errorCallback?: (error: Error) => Error;
+    errorCallback?: (error: Error) => PromiseOrValue<Error>;
     processChunk?: (chunk: AgentResponseChunk<T>) => AgentResponseChunk<T>;
 }): ReadableStream<any>;
 export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
@@ -18,5 +18,6 @@ export declare function readableStreamToArray<T>(stream: ReadableStream<T>, opti
 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>;
+export declare function toReadableStream(stream: NodeJS.ReadStream): ReadableStream<Uint8Array<ArrayBufferLike>>;
+export declare function readAllString(stream: NodeJS.ReadStream | ReadableStream): Promise<string>;

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

@@ -26,7 +26,7 @@ export function mergeAgentResponseChunk(output, chunk) {
 export async function agentResponseStreamToObject(stream) {
     const json = {};
     if (stream instanceof ReadableStream) {
-        for await (const value of readableStreamToAsyncIterator(stream)) {
+        for await (const value of stream) {
             mergeAgentResponseChunk(json, value);
         }
     }
@@ -76,25 +76,29 @@ export function onAgentResponseStreamEnd(stream, callback, options) {
     return new ReadableStream({
         async pull(controller) {
             try {
-                const { value, done } = await reader.read();
-                if (!done) {
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        const result = await callback(json);
+                        if (result && !equal(result, json)) {
+                            let chunk = { delta: { json: result } };
+                            if (options?.processChunk)
+                                chunk = options.processChunk(chunk);
+                            controller.enqueue(chunk);
+                        }
+                        controller.close();
+                        return;
+                    }
+                    mergeAgentResponseChunk(json, value);
                     const chunk = options?.processChunk ? options.processChunk(value) : value;
-                    if (!isEmptyChunk(chunk))
+                    if (!isEmptyChunk(chunk)) {
                         controller.enqueue(chunk);
-                    mergeAgentResponseChunk(json, value);
-                    return;
-                }
-                const result = await callback(json);
-                if (result && !equal(result, json)) {
-                    let chunk = { delta: { json: result } };
-                    if (options?.processChunk)
-                        chunk = options.processChunk(chunk);
-                    controller.enqueue(chunk);
+                        break;
+                    }
                 }
-                controller.close();
             }
             catch (error) {
-                controller.error(options?.errorCallback?.(error) ?? error);
+                controller.error((await options?.errorCallback?.(error)) ?? error);
             }
         },
     });
@@ -131,7 +135,7 @@ export function arrayToReadableStream(chunks) {
 export async function readableStreamToArray(stream, options) {
     const result = [];
     try {
-        for await (const value of readableStreamToAsyncIterator(stream)) {
+        for await (const value of stream) {
             result.push(value);
         }
     }
@@ -142,17 +146,36 @@ export async function readableStreamToArray(stream, options) {
     }
     return result;
 }
-export async function* readableStreamToAsyncIterator(stream) {
-    const reader = stream.getReader();
-    while (true) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        yield value;
-    }
-}
 export function stringToAgentResponseStream(str, key = "text") {
     const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
     const segments = segmenter.segment(str);
     return arrayToReadableStream(Array.from(segments).map((segment) => ({ delta: { text: { [key]: segment.segment } } })));
 }
+export function toReadableStream(stream) {
+    return new ReadableStream({
+        start(controller) {
+            const onData = (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            };
+            const onEnd = () => {
+                cleanup();
+                controller.close();
+            };
+            const onError = (err) => {
+                cleanup();
+                controller.error(err);
+            };
+            function cleanup() {
+                stream.off("data", onData);
+                stream.off("end", onEnd);
+                stream.off("error", onError);
+            }
+            stream.on("data", onData);
+            stream.on("end", onEnd);
+            stream.on("error", onError);
+        },
+    });
+}
+export async function readAllString(stream) {
+    return (await readableStreamToArray((stream instanceof ReadableStream ? stream : toReadableStream(stream)).pipeThrough(new TextDecoderStream()))).join("");
+}

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

@@ -2,6 +2,11 @@ import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 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 type XOr<T, K extends keyof T, O extends keyof T> = (Omit<T, O> & {
+    [key in O]?: undefined;
+}) | (Omit<T, K> & {
+    [key in K]?: undefined;
+});
 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -50,9 +50,6 @@
       "loader/*": [
         "./lib/dts/loader/*"
       ],
-      "models/*": [
-        "./lib/dts/models/*"
-      ],
       "memory/*": [
         "./lib/dts/memory/*"
       ],
@@ -61,12 +58,6 @@
       ],
       "utils/*": [
         "./lib/dts/utils/*"
-      ],
-      "client/*": [
-        "./lib/dts/client/*"
-      ],
-      "server/*": [
-        "./lib/dts/server/*"
       ]
     }
   },
@@ -91,15 +82,7 @@
     "zod": "^3.24.4",
     "zod-to-json-schema": "^3.24.5"
   },
-  "peerDependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
-    "@aws-sdk/client-bedrock-runtime": "^3.796.0",
-    "@google/generative-ai": "^0.24.0",
-    "openai": "^4.87.3"
-  },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.41.0",
-    "@google/generative-ai": "^0.24.1",
     "@types/bun": "^1.2.12",
     "@types/compression": "^1.7.5",
     "@types/content-type": "^1.1.8",
@@ -109,9 +92,7 @@
     "compression": "^1.8.0",
     "detect-port": "^2.1.0",
     "express": "^5.1.0",
-    "hono": "^4.7.8",
     "npm-run-all": "^4.1.5",
-    "openai": "^4.97.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3"
   },

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

@@ -1,97 +0,0 @@
-/**
- * Client module used to interact with the AIGNE framework.
- */
-import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "../agents/agent.js";
-/**
- * Configuration options for the AIGNEClient.
- */
-export interface AIGNEClientOptions {
-    /**
-     * The URL of the AIGNE server to connect to.
-     * This should point to the base endpoint where the AIGNEServer is hosted.
-     */
-    url: string;
-}
-/**
- * Options for invoking an agent through the AIGNEClient.
- * Extends the standard AgentInvokeOptions with client-specific options.
- */
-export interface AIGNEClientInvokeOptions extends AgentInvokeOptions {
-    /**
-     * Additional fetch API options to customize the HTTP request.
-     * These options will be merged with the default options used by the client.
-     */
-    fetchOptions?: Partial<RequestInit>;
-}
-/**
- * Client for interacting with a remote AIGNE server.
- * AIGNEClient provides a client-side interface that matches the AIGNE API,
- * allowing applications to invoke agents and receive responses from a remote AIGNE instance.
- *
- * @example
- * Here's a simple example of how to use AIGNEClient:
- * {@includeCode ../../test/client/client.test.ts#example-aigne-client-simple}
- *
- * @example
- * Here's an example of how to use AIGNEClient with streaming response:
- * {@includeCode ../../test/client/client.test.ts#example-aigne-client-streaming}
- */
-export declare class AIGNEClient {
-    options: AIGNEClientOptions;
-    /**
-     * Creates a new AIGNEClient instance.
-     *
-     * @param options - Configuration options for connecting to the AIGNE server
-     */
-    constructor(options: AIGNEClientOptions);
-    /**
-     * Invokes an agent in non-streaming mode and returns the complete response.
-     *
-     * @param agent - Name of the agent to invoke
-     * @param input - Input message for the agent
-     * @param options - Options with streaming mode explicitly set to false or omitted
-     * @returns The complete agent response
-     *
-     * @example
-     * Here's a simple example of how to use AIGNEClient:
-     * {@includeCode ../../test/client/client.test.ts#example-aigne-client-simple}
-     */
-    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions & {
-        streaming?: false;
-    }): Promise<O>;
-    /**
-     * Invokes an agent with streaming mode enabled and returns a stream of response chunks.
-     *
-     * @param agent - Name of the agent to invoke
-     * @param input - Input message for the agent
-     * @param options - Options with streaming mode explicitly set to true
-     * @returns A stream of agent response chunks
-     *
-     * @example
-     * Here's an example of how to use AIGNEClient with streaming response:
-     * {@includeCode ../../test/client/client.test.ts#example-aigne-client-streaming}
-     */
-    invoke<I extends Message, O extends Message>(agent: string, input: I, options: AIGNEClientInvokeOptions & {
-        streaming: true;
-    }): Promise<AgentResponseStream<O>>;
-    /**
-     * Invokes an agent with the given input and options.
-     *
-     * @param agent - Name of the agent to invoke
-     * @param input - Input message for the agent
-     * @param options - Options for the invocation
-     * @returns Either a complete response or a response stream depending on the streaming option
-     */
-    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions): Promise<AgentResponse<O>>;
-    /**
-     * Enhanced fetch method that handles error responses from the AIGNE server.
-     * This method wraps the standard fetch API to provide better error handling and reporting.
-     *
-     * @param args - Standard fetch API arguments (url and options)
-     * @returns A Response object if the request was successful
-     * @throws Error with detailed information if the request failed
-     *
-     * @private
-     */
-    fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
-}

package/lib/cjs/client/client.js

@@ -1,87 +0,0 @@
-"use strict";
-/**
- * Client module used to interact with the AIGNE framework.
- */
-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");
-/**
- * Client for interacting with a remote AIGNE server.
- * AIGNEClient provides a client-side interface that matches the AIGNE API,
- * allowing applications to invoke agents and receive responses from a remote AIGNE instance.
- *
- * @example
- * Here's a simple example of how to use AIGNEClient:
- * {@includeCode ../../test/client/client.test.ts#example-aigne-client-simple}
- *
- * @example
- * Here's an example of how to use AIGNEClient with streaming response:
- * {@includeCode ../../test/client/client.test.ts#example-aigne-client-streaming}
- */
-class AIGNEClient {
-    options;
-    /**
-     * Creates a new AIGNEClient instance.
-     *
-     * @param options - Configuration options for connecting to the AIGNE server
-     */
-    constructor(options) {
-        this.options = options;
-    }
-    async invoke(agent, input, options) {
-        // Send the agent invocation request to the AIGNE server
-        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 }),
-        });
-        // For non-streaming responses, simply parse the JSON response and return it
-        if (!options?.streaming) {
-            return await response.json();
-        }
-        // For streaming responses, set up the streaming pipeline
-        const stream = response.body;
-        if (!stream)
-            throw new Error("Response body is not a stream");
-        // Process the stream through a series of transforms:
-        // 1. Convert bytes to text
-        // 2. Parse SSE format into structured events
-        // 3. Convert events into a standardized agent response stream
-        return stream
-            .pipeThrough(new TextDecoderStream())
-            .pipeThrough(new event_stream_js_1.EventStreamParser())
-            .pipeThrough(new event_stream_js_1.AgentResponseStreamParser());
-    }
-    /**
-     * Enhanced fetch method that handles error responses from the AIGNE server.
-     * This method wraps the standard fetch API to provide better error handling and reporting.
-     *
-     * @param args - Standard fetch API arguments (url and options)
-     * @returns A Response object if the request was successful
-     * @throws Error with detailed information if the request failed
-     *
-     * @private
-     */
-    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/client/index.d.ts

@@ -1 +0,0 @@
-export * from "./client.js";

package/lib/cjs/client/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./client.js"), exports);

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

@@ -1,79 +0,0 @@
-import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
-import { z } from "zod";
-import type { AgentResponse } from "../agents/agent.js";
-import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
-/**
- * @hidden
- */
-export declare function extractLastJsonObject(text: string): string | null;
-export interface BedrockChatModelOptions {
-    accessKeyId?: string;
-    secretAccessKey?: string;
-    region?: string;
-    model?: string;
-    modelOptions?: ChatModelOptions;
-}
-/**
- * @hidden
- */
-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);
-    /**
-     * @hidden
-     */
-    protected _client?: BedrockRuntimeClient;
-    get client(): BedrockRuntimeClient;
-    get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput): Promise<AgentResponse<ChatModelOutput>>;
-    private extractResultFromStream;
-    private requestStructuredOutput;
-}