@aigne/core 1.14.0 → 1.16.0

package/lib/cjs/server/index.js

@@ -1,18 +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("./error.js"), exports);
-__exportStar(require("./server.js"), exports);

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

@@ -1,135 +0,0 @@
-import { IncomingMessage, ServerResponse } from "node:http";
-import { z } from "zod";
-import type { AIGNE } from "../aigne/aigne.js";
-/**
- * Schema for validating agent invocation payloads.
- * Defines the expected structure for requests to invoke an agent.
- *
- * @hidden
- */
-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;
-}>;
-/**
- * Configuration options for the AIGNEServer.
- * These options control various aspects of server behavior including
- * request parsing, payload limits, and response handling.
- */
-export interface AIGNEServerOptions {
-    /**
-     * Maximum body size for incoming HTTP requests.
-     * This controls the upper limit of request payload size when parsing raw HTTP requests.
-     * Only used when working with Node.js IncomingMessage objects that don't already have
-     * a pre-parsed body property (e.g., when not using Express middleware).
-     *
-     * @default "4mb"
-     */
-    maximumBodySize?: string;
-}
-/**
- * AIGNEServer provides HTTP API access to AIGNE capabilities.
- * It handles requests to invoke agents, manages response streaming,
- * and supports multiple HTTP server frameworks including Node.js http,
- * Express, and Fetch API compatible environments.
- *
- * @example
- * Here's a simple example of how to use AIGNEServer with express:
- * {@includeCode ../../test/server/server.test.ts#example-aigne-server-express}
- *
- * @example
- * Here's an example of how to use AIGNEServer with Hono:
- * {@includeCode ../../test/server/server.test.ts#example-aigne-server-hono}
- */
-export declare class AIGNEServer {
-    engine: AIGNE;
-    options?: AIGNEServerOptions | undefined;
-    /**
-     * Creates a new AIGNEServer instance.
-     *
-     * @param engine - The AIGNE engine instance that will process agent invocations
-     * @param options - Configuration options for the server
-     */
-    constructor(engine: AIGNE, options?: AIGNEServerOptions | undefined);
-    /**
-     * Invokes an agent with the provided input and returns a standard web Response.
-     * This method serves as the primary API endpoint for agent invocation.
-     *
-     * The request can be provided in various formats to support different integration scenarios:
-     * - As a pre-parsed JavaScript object
-     * - As a Fetch API Request instance (for modern web frameworks)
-     * - As a Node.js IncomingMessage (for Express, Fastify, etc.)
-     *
-     * @param request - The agent invocation request in any supported format
-     * @returns A web standard Response object that can be returned directly in frameworks
-     *          like Hono, Next.js, or any Fetch API compatible environment
-     *
-     * @example
-     * Here's a simple example of how to use AIGNEServer with Hono:
-     * {@includeCode ../../test/server/server.test.ts#example-aigne-server-hono}
-     */
-    invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
-    /**
-     * Invokes an agent with the provided input and streams the response to a Node.js ServerResponse.
-     * This overload is specifically designed for Node.js HTTP server environments.
-     *
-     * The method handles both regular JSON responses and streaming Server-Sent Events (SSE)
-     * responses based on the options specified in the request.
-     *
-     * @param request - The agent invocation request in any supported format
-     * @param response - The Node.js ServerResponse object to write the response to
-     *
-     * @example
-     * Here's a simple example of how to use AIGNEServer with express:
-     * {@includeCode ../../test/server/server.test.ts#example-aigne-server-express}
-     */
-    invoke(request: Record<string, unknown> | Request | IncomingMessage, response: ServerResponse): Promise<void>;
-    /**
-     * Internal method that handles the core logic of processing an agent invocation request.
-     * Validates the request payload, finds the requested agent, and processes the invocation
-     * with either streaming or non-streaming response handling.
-     *
-     * @param request - The parsed or raw request to process
-     * @returns A standard Response object with the invocation result
-     * @private
-     */
-    _invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
-    /**
-     * Prepares and normalizes the input from various request types.
-     * Handles different request formats (Node.js IncomingMessage, Fetch API Request,
-     * or already parsed object) and extracts the JSON payload.
-     *
-     * @param request - The request object in any supported format
-     * @returns The normalized payload as a JavaScript object
-     * @private
-     */
-    _prepareInput(request: Record<string, unknown> | Request | IncomingMessage): Promise<Record<string, unknown>>;
-    /**
-     * Writes a web standard Response object to a Node.js ServerResponse.
-     * Handles streaming responses and error conditions appropriately.
-     *
-     * @param response - The web standard Response object to write
-     * @param res - The Node.js ServerResponse to write to
-     * @private
-     */
-    _writeResponse(response: Response, res: ServerResponse): Promise<void>;
-}

package/lib/cjs/server/server.js

@@ -1,188 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIGNEServer = exports.invokePayloadSchema = void 0;
-const node_http_1 = require("node:http");
-const content_type_1 = __importDefault(require("content-type"));
-const raw_body_1 = __importDefault(require("raw-body"));
-const zod_1 = require("zod");
-const event_stream_js_1 = require("../utils/event-stream.js");
-const stream_utils_js_1 = require("../utils/stream-utils.js");
-const type_utils_js_1 = require("../utils/type-utils.js");
-const error_js_1 = require("./error.js");
-/**
- * Default maximum allowed size for request bodies when parsing raw HTTP requests.
- * This limits the amount of data that can be uploaded to protect against denial of service attacks.
- * Can be overridden via AIGNEServerOptions.
- * @internal
- */
-const DEFAULT_MAXIMUM_BODY_SIZE = "4mb";
-/**
- * Schema for validating agent invocation payloads.
- * Defines the expected structure for requests to invoke an agent.
- *
- * @hidden
- */
-exports.invokePayloadSchema = zod_1.z.object({
-    agent: zod_1.z.string(),
-    input: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
-    options: zod_1.z
-        .object({
-        streaming: zod_1.z.boolean().nullish(),
-    })
-        .nullish(),
-});
-/**
- * AIGNEServer provides HTTP API access to AIGNE capabilities.
- * It handles requests to invoke agents, manages response streaming,
- * and supports multiple HTTP server frameworks including Node.js http,
- * Express, and Fetch API compatible environments.
- *
- * @example
- * Here's a simple example of how to use AIGNEServer with express:
- * {@includeCode ../../test/server/server.test.ts#example-aigne-server-express}
- *
- * @example
- * Here's an example of how to use AIGNEServer with Hono:
- * {@includeCode ../../test/server/server.test.ts#example-aigne-server-hono}
- */
-class AIGNEServer {
-    engine;
-    options;
-    /**
-     * Creates a new AIGNEServer instance.
-     *
-     * @param engine - The AIGNE engine instance that will process agent invocations
-     * @param options - Configuration options for the server
-     */
-    constructor(engine, options) {
-        this.engine = engine;
-        this.options = options;
-    }
-    async invoke(request, response) {
-        const result = await this._invoke(request);
-        if (response instanceof node_http_1.ServerResponse) {
-            await this._writeResponse(result, response);
-            return;
-        }
-        return result;
-    }
-    /**
-     * Internal method that handles the core logic of processing an agent invocation request.
-     * Validates the request payload, finds the requested agent, and processes the invocation
-     * with either streaming or non-streaming response handling.
-     *
-     * @param request - The parsed or raw request to process
-     * @returns A standard Response object with the invocation result
-     * @private
-     */
-    async _invoke(request) {
-        const { engine } = this;
-        try {
-            const payload = await this._prepareInput(request);
-            const { agent: agentName, input, options, } = (0, type_utils_js_1.tryOrThrow)(() => (0, type_utils_js_1.checkArguments)(`Invoke agent ${payload.agent}`, exports.invokePayloadSchema, payload), (error) => new error_js_1.ServerError(400, error.message));
-            const agent = engine.agents[agentName];
-            if (!agent)
-                throw new error_js_1.ServerError(404, `Agent ${agentName} not found`);
-            if (!options?.streaming) {
-                const result = await engine.invoke(agent, input);
-                return new Response(JSON.stringify(result), {
-                    headers: { "Content-Type": "application/json" },
-                });
-            }
-            const stream = await engine.invoke(agent, input, { streaming: true });
-            return new Response(new event_stream_js_1.AgentResponseStreamSSE(stream), {
-                headers: {
-                    "Content-Type": "text/event-stream",
-                    "Cache-Control": "no-cache",
-                    "X-Accel-Buffering": "no",
-                },
-            });
-        }
-        catch (error) {
-            return new Response(JSON.stringify({ error: { message: error.message } }), {
-                status: error instanceof error_js_1.ServerError ? error.status : 500,
-                headers: { "Content-Type": "application/json" },
-            });
-        }
-    }
-    /**
-     * Prepares and normalizes the input from various request types.
-     * Handles different request formats (Node.js IncomingMessage, Fetch API Request,
-     * or already parsed object) and extracts the JSON payload.
-     *
-     * @param request - The request object in any supported format
-     * @returns The normalized payload as a JavaScript object
-     * @private
-     */
-    async _prepareInput(request) {
-        const contentTypeError = new error_js_1.ServerError(415, "Unsupported Media Type: Content-Type must be application/json");
-        if (request instanceof node_http_1.IncomingMessage) {
-            // Support for express with json() middleware
-            if ("body" in request && typeof request.body === "object") {
-                if (!(0, type_utils_js_1.isRecord)(request.body))
-                    throw contentTypeError;
-                return request.body;
-            }
-            // Support vanilla nodejs http server
-            const maximumBodySize = this.options?.maximumBodySize || DEFAULT_MAXIMUM_BODY_SIZE;
-            const ct = request.headers["content-type"];
-            if (!ct || !ct.includes("application/json"))
-                throw contentTypeError;
-            const parsedCt = content_type_1.default.parse(ct);
-            const raw = await (0, raw_body_1.default)(request, {
-                limit: maximumBodySize,
-                encoding: parsedCt.parameters.charset ?? "utf-8",
-            });
-            return (0, type_utils_js_1.tryOrThrow)(() => JSON.parse(raw.toString()), (error) => new error_js_1.ServerError(400, `Parse request body to json error: ${error.message}`));
-        }
-        if (request instanceof Request) {
-            if (!request.headers.get("content-type")?.includes("application/json")) {
-                throw contentTypeError;
-            }
-            return await request.json();
-        }
-        if (!(0, type_utils_js_1.isRecord)(request))
-            throw contentTypeError;
-        return request;
-    }
-    /**
-     * Writes a web standard Response object to a Node.js ServerResponse.
-     * Handles streaming responses and error conditions appropriately.
-     *
-     * @param response - The web standard Response object to write
-     * @param res - The Node.js ServerResponse to write to
-     * @private
-     */
-    async _writeResponse(response, res) {
-        try {
-            res.writeHead(response.status, response.headers.toJSON());
-            res.flushHeaders();
-            if (!response.body)
-                throw new Error("Response body is empty");
-            for await (const chunk of (0, stream_utils_js_1.readableStreamToAsyncIterator)(response.body)) {
-                res.write(chunk);
-                // Support for express with compression middleware
-                if ("flush" in res && typeof res.flush === "function") {
-                    res.flush();
-                }
-            }
-        }
-        catch (error) {
-            if (!res.headersSent) {
-                res.writeHead(error instanceof error_js_1.ServerError ? error.status : 500, {
-                    "Content-Type": "application/json",
-                });
-            }
-            if (res.writable) {
-                res.write(JSON.stringify({ error: { message: error.message } }));
-            }
-        }
-        finally {
-            res.end();
-        }
-    }
-}
-exports.AIGNEServer = AIGNEServer;

package/lib/dts/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/dts/client/index.d.ts

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

package/lib/dts/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;
-}

package/lib/dts/models/claude-chat-model.d.ts

@@ -1,114 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { z } from "zod";
-import type { AgentProcessResult } from "../agents/agent.js";
-import { type PromiseOrValue } from "../utils/type-utils.js";
-import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
-/**
- * Configuration options for Claude Chat Model
- */
-export interface ClaudeChatModelOptions {
-    /**
-     * API key for Anthropic's Claude API
-     *
-     * If not provided, will look for ANTHROPIC_API_KEY or CLAUDE_API_KEY in environment variables
-     */
-    apiKey?: string;
-    /**
-     * Claude model to use
-     *
-     * Defaults to 'claude-3-7-sonnet-latest'
-     */
-    model?: string;
-    /**
-     * Additional model options to control behavior
-     */
-    modelOptions?: ChatModelOptions;
-}
-/**
- * @hidden
- */
-export declare const claudeChatModelOptionsSchema: z.ZodObject<{
-    apiKey: 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;
-}, {
-    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;
-}>;
-/**
- * Implementation of the ChatModel interface for Anthropic's Claude API
- *
- * This model provides access to Claude's capabilities including:
- * - Text generation
- * - Tool use
- * - JSON structured output
- *
- * Default model: 'claude-3-7-sonnet-latest'
- *
- * @example
- * Here's how to create and use a Claude chat model:
- * {@includeCode ../../test/models/claude-chat-model.test.ts#example-claude-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/claude-chat-model.test.ts#example-claude-chat-model-streaming-async-generator}
- */
-export declare class ClaudeChatModel extends ChatModel {
-    options?: ClaudeChatModelOptions | undefined;
-    constructor(options?: ClaudeChatModelOptions | undefined);
-    /**
-     * @hidden
-     */
-    protected _client?: Anthropic;
-    get client(): Anthropic;
-    get modelOptions(): ChatModelOptions | undefined;
-    /**
-     * Process the input using Claude's chat model
-     * @param input - The input to process
-     * @returns The processed output from the model
-     */
-    process(input: ChatModelInput): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
-    private _process;
-    private extractResultFromClaudeStream;
-    private requestStructuredOutput;
-}

package/lib/dts/models/deepseek-chat-model.d.ts

@@ -1,23 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for DeepSeek's API
- *
- * This model uses OpenAI-compatible API format to interact with DeepSeek's models,
- * but with specific configuration and capabilities for DeepSeek.
- *
- * Default model: 'deepseek-chat'
- *
- * @example
- * Here's how to create and use a DeepSeek chat model:
- * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model-streaming}
- */
-export declare class DeepSeekChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-    protected supportsNativeStructuredOutputs: boolean;
-    protected supportsToolsEmptyParameters: boolean;
-}

package/lib/dts/models/gemini-chat-model.d.ts

@@ -1,23 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for Google's Gemini API
- *
- * This model uses OpenAI-compatible API format to interact with Google's Gemini models,
- * providing access to models like Gemini 1.5 and Gemini 2.0.
- *
- * @example
- * Here's how to create and use a Gemini chat model:
- * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model-streaming}
- */
-export declare class GeminiChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-    protected supportsEndWithSystemMessage: boolean;
-    protected supportsToolsUseWithJsonSchema: boolean;
-    protected supportsParallelToolCalls: boolean;
-    protected supportsToolStreaming: boolean;
-}