@aigne/core 1.14.0 → 1.16.0

package/lib/esm/models/openai-chat-model.d.ts

@@ -1,166 +0,0 @@
-import OpenAI from "openai";
-import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
-import { z } from "zod";
-import type { AgentProcessResult } from "../agents/agent.js";
-import { type PromiseOrValue } from "../utils/type-utils.js";
-import { ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
-export interface OpenAIChatModelCapabilities {
-    supportsNativeStructuredOutputs: boolean;
-    supportsEndWithSystemMessage: boolean;
-    supportsToolsUseWithJsonSchema: boolean;
-    supportsParallelToolCalls: boolean;
-    supportsToolsEmptyParameters: boolean;
-    supportsToolStreaming: boolean;
-    supportsTemperature: boolean;
-}
-/**
- * Configuration options for OpenAI Chat Model
- */
-export interface OpenAIChatModelOptions {
-    /**
-     * API key for OpenAI API
-     *
-     * If not provided, will look for OPENAI_API_KEY in environment variables
-     */
-    apiKey?: string;
-    /**
-     * Base URL for OpenAI API
-     *
-     * Useful for proxies or alternate endpoints
-     */
-    baseURL?: string;
-    /**
-     * OpenAI model to use
-     *
-     * Defaults to 'gpt-4o-mini'
-     */
-    model?: string;
-    /**
-     * Additional model options to control behavior
-     */
-    modelOptions?: ChatModelOptions;
-}
-/**
- * @hidden
- */
-export declare const openAIChatModelOptionsSchema: z.ZodObject<{
-    apiKey: z.ZodOptional<z.ZodString>;
-    baseURL: 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;
-    apiKey?: string | undefined;
-    baseURL?: 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;
-    apiKey?: string | undefined;
-    baseURL?: string | undefined;
-}>;
-/**
- * Implementation of the ChatModel interface for OpenAI's API
- *
- * This model provides access to OpenAI's capabilities including:
- * - Text generation
- * - Tool use with parallel tool calls
- * - JSON structured output
- * - Image understanding
- *
- * Default model: 'gpt-4o-mini'
- *
- * @example
- * Here's how to create and use an OpenAI chat model:
- * {@includeCode ../../test/models/openai-chat-model.test.ts#example-openai-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/openai-chat-model.test.ts#example-openai-chat-model-streaming}
- */
-export declare class OpenAIChatModel extends ChatModel {
-    options?: OpenAIChatModelOptions | undefined;
-    constructor(options?: OpenAIChatModelOptions | undefined);
-    /**
-     * @hidden
-     */
-    protected _client?: OpenAI;
-    protected apiKeyEnvName: string;
-    protected apiKeyDefault: string | undefined;
-    protected supportsNativeStructuredOutputs: boolean;
-    protected supportsEndWithSystemMessage: boolean;
-    protected supportsToolsUseWithJsonSchema: boolean;
-    protected supportsParallelToolCalls: boolean;
-    protected supportsToolsEmptyParameters: boolean;
-    protected supportsToolStreaming: boolean;
-    protected supportsTemperature: boolean;
-    get client(): OpenAI;
-    get modelOptions(): ChatModelOptions | undefined;
-    /**
-     * Process the input and generate a response
-     * @param input The input to process
-     * @returns The generated response
-     */
-    process(input: ChatModelInput): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
-    private _process;
-    private getParallelToolCalls;
-    private getRunMessages;
-    private getRunResponseFormat;
-    private requestStructuredOutput;
-    private extractResultFromStream;
-}
-/**
- * @hidden
- */
-export declare const ROLE_MAP: {
-    [key in Role]: ChatCompletionMessageParam["role"];
-};
-/**
- * @hidden
- */
-export declare function contentsFromInputMessages(messages: ChatModelInputMessage[]): Promise<ChatCompletionMessageParam[]>;
-/**
- * @hidden
- */
-export declare function toolsFromInputTools(tools?: ChatModelInputTool[], options?: {
-    addTypeToEmptyParameters?: boolean;
-}): ChatCompletionTool[] | undefined;
-/**
- * @hidden
- */
-export declare function jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;

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

@@ -1,405 +0,0 @@
-import { nanoid } from "nanoid";
-import OpenAI from "openai";
-import { z } from "zod";
-import { parseJSON } from "../utils/json-schema.js";
-import { mergeUsage } from "../utils/model-utils.js";
-import { getJsonOutputPrompt } from "../utils/prompts.js";
-import { agentResponseStreamToObject } from "../utils/stream-utils.js";
-import { checkArguments, isNonNullable } from "../utils/type-utils.js";
-import { ChatModel, } from "./chat-model.js";
-const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
-const OPENAI_CHAT_MODEL_CAPABILITIES = {
-    "o4-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
-    "o3-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
-};
-/**
- * @hidden
- */
-export const openAIChatModelOptionsSchema = z.object({
-    apiKey: z.string().optional(),
-    baseURL: z.string().optional(),
-    model: z.string().optional(),
-    modelOptions: z
-        .object({
-        model: z.string().optional(),
-        temperature: z.number().optional(),
-        topP: z.number().optional(),
-        frequencyPenalty: z.number().optional(),
-        presencePenalty: z.number().optional(),
-        parallelToolCalls: z.boolean().optional().default(true),
-    })
-        .optional(),
-});
-/**
- * Implementation of the ChatModel interface for OpenAI's API
- *
- * This model provides access to OpenAI's capabilities including:
- * - Text generation
- * - Tool use with parallel tool calls
- * - JSON structured output
- * - Image understanding
- *
- * Default model: 'gpt-4o-mini'
- *
- * @example
- * Here's how to create and use an OpenAI chat model:
- * {@includeCode ../../test/models/openai-chat-model.test.ts#example-openai-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/openai-chat-model.test.ts#example-openai-chat-model-streaming}
- */
-export class OpenAIChatModel extends ChatModel {
-    options;
-    constructor(options) {
-        super();
-        this.options = options;
-        if (options)
-            checkArguments(this.name, openAIChatModelOptionsSchema, options);
-        const preset = options?.model ? OPENAI_CHAT_MODEL_CAPABILITIES[options.model] : undefined;
-        Object.assign(this, preset);
-    }
-    /**
-     * @hidden
-     */
-    _client;
-    apiKeyEnvName = "OPENAI_API_KEY";
-    apiKeyDefault;
-    supportsNativeStructuredOutputs = true;
-    supportsEndWithSystemMessage = true;
-    supportsToolsUseWithJsonSchema = true;
-    supportsParallelToolCalls = true;
-    supportsToolsEmptyParameters = true;
-    supportsToolStreaming = true;
-    supportsTemperature = true;
-    get client() {
-        const apiKey = this.options?.apiKey || process.env[this.apiKeyEnvName] || this.apiKeyDefault;
-        if (!apiKey)
-            throw new Error(`Api Key is required for ${this.name}`);
-        this._client ??= new OpenAI({
-            baseURL: this.options?.baseURL,
-            apiKey,
-        });
-        return this._client;
-    }
-    get modelOptions() {
-        return this.options?.modelOptions;
-    }
-    /**
-     * Process the input and generate a response
-     * @param input The input to process
-     * @returns The generated response
-     */
-    process(input) {
-        return this._process(input);
-    }
-    async _process(input) {
-        const messages = await this.getRunMessages(input);
-        const body = {
-            model: this.options?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
-            temperature: this.supportsTemperature
-                ? (input.modelOptions?.temperature ?? this.modelOptions?.temperature)
-                : undefined,
-            top_p: input.modelOptions?.topP ?? this.modelOptions?.topP,
-            frequency_penalty: input.modelOptions?.frequencyPenalty ?? this.modelOptions?.frequencyPenalty,
-            presence_penalty: input.modelOptions?.presencePenalty ?? this.modelOptions?.presencePenalty,
-            messages,
-            stream_options: {
-                include_usage: true,
-            },
-            stream: true,
-        };
-        const { jsonMode, responseFormat } = await this.getRunResponseFormat(input);
-        const stream = await this.client.chat.completions.create({
-            ...body,
-            tools: toolsFromInputTools(input.tools, {
-                addTypeToEmptyParameters: !this.supportsToolsEmptyParameters,
-            }),
-            tool_choice: input.toolChoice,
-            parallel_tool_calls: this.getParallelToolCalls(input),
-            response_format: responseFormat,
-        });
-        if (input.responseFormat?.type !== "json_schema") {
-            return await this.extractResultFromStream(stream, false, true);
-        }
-        const result = await this.extractResultFromStream(stream, jsonMode);
-        if (!this.supportsToolsUseWithJsonSchema &&
-            !result.toolCalls?.length &&
-            input.responseFormat?.type === "json_schema" &&
-            result.text) {
-            const output = await this.requestStructuredOutput(body, input.responseFormat);
-            return { ...output, usage: mergeUsage(result.usage, output.usage) };
-        }
-        return result;
-    }
-    getParallelToolCalls(input) {
-        if (!this.supportsParallelToolCalls)
-            return undefined;
-        if (!input.tools?.length)
-            return undefined;
-        return input.modelOptions?.parallelToolCalls ?? this.modelOptions?.parallelToolCalls;
-    }
-    async getRunMessages(input) {
-        const messages = await contentsFromInputMessages(input.messages);
-        if (!this.supportsEndWithSystemMessage && messages.at(-1)?.role !== "user") {
-            messages.push({ role: "user", content: "" });
-        }
-        if (!this.supportsToolsUseWithJsonSchema && input.tools?.length)
-            return messages;
-        if (this.supportsNativeStructuredOutputs)
-            return messages;
-        if (input.responseFormat?.type === "json_schema") {
-            messages.unshift({
-                role: "system",
-                content: getJsonOutputPrompt(input.responseFormat.jsonSchema.schema),
-            });
-        }
-        return messages;
-    }
-    async getRunResponseFormat(input) {
-        if (!this.supportsToolsUseWithJsonSchema && input.tools?.length)
-            return { jsonMode: false, responseFormat: undefined };
-        if (!this.supportsNativeStructuredOutputs) {
-            const jsonMode = input.responseFormat?.type === "json_schema";
-            return { jsonMode, responseFormat: jsonMode ? { type: "json_object" } : undefined };
-        }
-        if (input.responseFormat?.type === "json_schema") {
-            return {
-                jsonMode: true,
-                responseFormat: {
-                    type: "json_schema",
-                    json_schema: {
-                        ...input.responseFormat.jsonSchema,
-                        schema: jsonSchemaToOpenAIJsonSchema(input.responseFormat.jsonSchema.schema),
-                    },
-                },
-            };
-        }
-        return { jsonMode: false, responseFormat: undefined };
-    }
-    async requestStructuredOutput(body, responseFormat) {
-        if (responseFormat?.type !== "json_schema") {
-            throw new Error("Expected json_schema response format");
-        }
-        const { jsonMode, responseFormat: resolvedResponseFormat } = await this.getRunResponseFormat({
-            responseFormat,
-        });
-        const res = await this.client.chat.completions.create({
-            ...body,
-            response_format: resolvedResponseFormat,
-        });
-        return this.extractResultFromStream(res, jsonMode);
-    }
-    async extractResultFromStream(stream, jsonMode, streaming) {
-        const result = new ReadableStream({
-            start: async (controller) => {
-                try {
-                    let text = "";
-                    let refusal = "";
-                    const toolCalls = [];
-                    let model;
-                    for await (const chunk of stream) {
-                        const choice = chunk.choices?.[0];
-                        if (!model) {
-                            model = chunk.model;
-                            controller.enqueue({
-                                delta: {
-                                    json: {
-                                        model,
-                                    },
-                                },
-                            });
-                        }
-                        if (choice?.delta.tool_calls?.length) {
-                            for (const call of choice.delta.tool_calls) {
-                                if (this.supportsToolStreaming && call.index !== undefined) {
-                                    handleToolCallDelta(toolCalls, call);
-                                }
-                                else {
-                                    handleCompleteToolCall(toolCalls, call);
-                                }
-                            }
-                        }
-                        if (choice?.delta.content) {
-                            text += choice.delta.content;
-                            if (!jsonMode) {
-                                controller.enqueue({
-                                    delta: {
-                                        text: {
-                                            text: choice.delta.content,
-                                        },
-                                    },
-                                });
-                            }
-                        }
-                        if (choice?.delta.refusal) {
-                            refusal += choice.delta.refusal;
-                            if (!jsonMode) {
-                                controller.enqueue({
-                                    delta: {
-                                        text: { text: choice.delta.refusal },
-                                    },
-                                });
-                            }
-                        }
-                        if (chunk.usage) {
-                            controller.enqueue({
-                                delta: {
-                                    json: {
-                                        usage: {
-                                            inputTokens: chunk.usage.prompt_tokens,
-                                            outputTokens: chunk.usage.completion_tokens,
-                                        },
-                                    },
-                                },
-                            });
-                        }
-                    }
-                    text = text || refusal;
-                    if (jsonMode && text) {
-                        controller.enqueue({
-                            delta: {
-                                json: {
-                                    json: parseJSON(text),
-                                },
-                            },
-                        });
-                    }
-                    if (toolCalls.length) {
-                        controller.enqueue({
-                            delta: {
-                                json: {
-                                    toolCalls: toolCalls.map(({ args, ...c }) => ({
-                                        ...c,
-                                        function: { ...c.function, arguments: parseJSON(args) },
-                                    })),
-                                },
-                            },
-                        });
-                    }
-                    controller.close();
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-            },
-        });
-        return streaming ? result : await agentResponseStreamToObject(result);
-    }
-}
-/**
- * @hidden
- */
-export const ROLE_MAP = {
-    system: "system",
-    user: "user",
-    agent: "assistant",
-    tool: "tool",
-};
-/**
- * @hidden
- */
-export async function contentsFromInputMessages(messages) {
-    return messages.map((i) => ({
-        role: ROLE_MAP[i.role],
-        content: typeof i.content === "string"
-            ? i.content
-            : i.content
-                ?.map((c) => {
-                if (c.type === "text") {
-                    return { type: "text", text: c.text };
-                }
-                if (c.type === "image_url") {
-                    return {
-                        type: "image_url",
-                        image_url: { url: c.url },
-                    };
-                }
-            })
-                .filter(isNonNullable),
-        tool_calls: i.toolCalls?.map((i) => ({
-            ...i,
-            function: {
-                ...i.function,
-                arguments: JSON.stringify(i.function.arguments),
-            },
-        })),
-        tool_call_id: i.toolCallId,
-        name: i.name,
-    }));
-}
-/**
- * @hidden
- */
-export function toolsFromInputTools(tools, options) {
-    return tools?.length
-        ? tools.map((i) => {
-            const parameters = i.function.parameters;
-            if (options?.addTypeToEmptyParameters && Object.keys(parameters).length === 0) {
-                parameters.type = "object";
-            }
-            return {
-                type: "function",
-                function: {
-                    name: i.function.name,
-                    description: i.function.description,
-                    parameters,
-                },
-            };
-        })
-        : undefined;
-}
-/**
- * @hidden
- */
-export function jsonSchemaToOpenAIJsonSchema(schema) {
-    if (schema?.type === "object") {
-        const { required, properties } = schema;
-        return {
-            ...schema,
-            properties: Object.fromEntries(Object.entries(properties).map(([key, value]) => {
-                const valueSchema = jsonSchemaToOpenAIJsonSchema(value);
-                // NOTE: All fields must be required https://platform.openai.com/docs/guides/structured-outputs/all-fields-must-be-required
-                return [
-                    key,
-                    required?.includes(key) ? valueSchema : { anyOf: [valueSchema, { type: ["null"] }] },
-                ];
-            })),
-            required: Object.keys(properties),
-        };
-    }
-    if (schema?.type === "array") {
-        const { items } = schema;
-        return {
-            ...schema,
-            items: jsonSchemaToOpenAIJsonSchema(items),
-        };
-    }
-    return schema;
-}
-function handleToolCallDelta(toolCalls, call) {
-    toolCalls[call.index] ??= {
-        id: call.id || nanoid(),
-        type: "function",
-        function: { name: "", arguments: {} },
-        args: "",
-    };
-    const c = toolCalls[call.index];
-    if (!c)
-        throw new Error("Tool call not found");
-    if (call.type)
-        c.type = call.type;
-    c.function.name = c.function.name + (call.function?.name || "");
-    c.args = c.args.concat(call.function?.arguments || "");
-}
-function handleCompleteToolCall(toolCalls, call) {
-    toolCalls.push({
-        id: call.id || nanoid(),
-        type: "function",
-        function: {
-            name: call.function?.name || "",
-            arguments: parseJSON(call.function?.arguments || "{}"),
-        },
-        args: call.function?.arguments || "",
-    });
-}

package/lib/esm/models/xai-chat-model.d.ts

@@ -1,21 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for X.AI's API (Grok)
- *
- * This model uses OpenAI-compatible API format to interact with X.AI models,
- * providing access to models like Grok.
- *
- * Default model: 'grok-2-latest'
- *
- * @example
- * Here's how to create and use an X.AI chat model:
- * {@includeCode ../../test/models/xai-chat-model.test.ts#example-xai-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/xai-chat-model.test.ts#example-xai-chat-model-streaming}
- */
-export declare class XAIChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-}

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

@@ -1,29 +0,0 @@
-import { OpenAIChatModel } from "./openai-chat-model.js";
-const XAI_DEFAULT_CHAT_MODEL = "grok-2-latest";
-const XAI_BASE_URL = "https://api.x.ai/v1";
-/**
- * Implementation of the ChatModel interface for X.AI's API (Grok)
- *
- * This model uses OpenAI-compatible API format to interact with X.AI models,
- * providing access to models like Grok.
- *
- * Default model: 'grok-2-latest'
- *
- * @example
- * Here's how to create and use an X.AI chat model:
- * {@includeCode ../../test/models/xai-chat-model.test.ts#example-xai-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/xai-chat-model.test.ts#example-xai-chat-model-streaming}
- */
-export class XAIChatModel extends OpenAIChatModel {
-    constructor(options) {
-        super({
-            ...options,
-            model: options?.model || XAI_DEFAULT_CHAT_MODEL,
-            baseURL: options?.baseURL || XAI_BASE_URL,
-        });
-    }
-    apiKeyEnvName = "XAI_API_KEY";
-}

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

@@ -1,15 +0,0 @@
-/**
- * Custom error class for AIGNEServer HTTP-related errors.
- * Extends the standard Error class with an HTTP status code property.
- * This allows error responses to include appropriate HTTP status codes.
- */
-export declare class ServerError extends Error {
-    status: number;
-    /**
-     * Creates a new ServerError instance.
-     *
-     * @param status - The HTTP status code for this error (e.g., 400, 404, 500)
-     * @param message - The error message describing what went wrong
-     */
-    constructor(status: number, message: string);
-}

package/lib/esm/server/error.js

@@ -1,18 +0,0 @@
-/**
- * Custom error class for AIGNEServer HTTP-related errors.
- * Extends the standard Error class with an HTTP status code property.
- * This allows error responses to include appropriate HTTP status codes.
- */
-export class ServerError extends Error {
-    status;
-    /**
-     * Creates a new ServerError instance.
-     *
-     * @param status - The HTTP status code for this error (e.g., 400, 404, 500)
-     * @param message - The error message describing what went wrong
-     */
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-    }
-}

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

@@ -1,2 +0,0 @@
-export * from "./error.js";
-export * from "./server.js";

package/lib/esm/server/index.js

@@ -1,2 +0,0 @@
-export * from "./error.js";
-export * from "./server.js";