@aigne/core 1.14.0 → 1.16.0

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

@@ -1,22 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for Ollama
- *
- * This model allows you to run open-source LLMs locally using Ollama,
- * with an OpenAI-compatible API interface.
- *
- * Default model: 'llama3.2'
- *
- * @example
- * Here's how to create and use an Ollama chat model:
- * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model-streaming}
- */
-export declare class OllamaChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-    protected apiKeyDefault: string;
-}

package/lib/dts/models/open-router-chat-model.d.ts

@@ -1,22 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for OpenRouter service
- *
- * OpenRouter provides access to a variety of large language models through a unified API.
- * This implementation uses the OpenAI-compatible interface to connect to OpenRouter's service.
- *
- * Default model: 'openai/gpt-4o'
- *
- * @example
- * Here's how to create and use an OpenRouter chat model:
- * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model-streaming}
- */
-export declare class OpenRouterChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-    protected supportsParallelToolCalls: boolean;
-}

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

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

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

@@ -1,83 +0,0 @@
-/**
- * Client module used to interact with the AIGNE framework.
- */
-import { AgentResponseStreamParser, EventStreamParser } from "../utils/event-stream.js";
-import { tryOrThrow } from "../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}
- */
-export 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 EventStreamParser())
-            .pipeThrough(new 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 = 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;
-    }
-}

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

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

package/lib/esm/client/index.js

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

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