@aigne/core 1.15.0 → 1.16.0

package/lib/esm/loader/index.js

@@ -5,14 +5,6 @@ import { z } from "zod";
 import { FunctionAgent } from "../agents/agent.js";
 import { AIAgent } from "../agents/ai-agent.js";
 import { MCPAgent } from "../agents/mcp-agent.js";
-import { BedrockChatModel } from "../models/bedrock-chat-model.js";
-import { ClaudeChatModel } from "../models/claude-chat-model.js";
-import { DeepSeekChatModel } from "../models/deepseek-chat-model.js";
-import { GeminiChatModel } from "../models/gemini-chat-model.js";
-import { OllamaChatModel } from "../models/ollama-chat-model.js";
-import { OpenRouterChatModel } from "../models/open-router-chat-model.js";
-import { OpenAIChatModel } from "../models/openai-chat-model.js";
-import { XAIChatModel } from "../models/xai-chat-model.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
 import { loadAgentFromYamlFile } from "./agent-yaml.js";
@@ -26,7 +18,7 @@ export async function load(options) {
     const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent(join(rootDir, filename))));
     return {
         ...aigne,
-        model: await loadModel(aigne.chat_model),
+        model: await loadModel(options.models, aigne.chat_model),
         agents,
         skills,
     };
@@ -64,26 +56,15 @@ export async function loadAgent(path) {
 }
 const { MODEL_PROVIDER, MODEL_NAME } = process.env;
 const DEFAULT_MODEL_PROVIDER = "openai";
-const DEFAULT_MODEL_NAME = "gpt-4o-mini";
-export async function loadModel(model, modelOptions) {
+export async function loadModel(models, model, modelOptions) {
     const params = {
-        model: MODEL_NAME ?? model?.name ?? DEFAULT_MODEL_NAME,
+        model: MODEL_NAME ?? model?.name ?? undefined,
         temperature: model?.temperature ?? undefined,
-        topP: model?.top_p ?? undefined,
-        frequencyPenalty: model?.frequent_penalty ?? undefined,
-        presencePenalty: model?.presence_penalty ?? undefined,
+        topP: model?.topP ?? undefined,
+        frequencyPenalty: model?.frequencyPenalty ?? undefined,
+        presencePenalty: model?.presencePenalty ?? undefined,
     };
-    const availableModels = [
-        OpenAIChatModel,
-        ClaudeChatModel,
-        XAIChatModel,
-        GeminiChatModel,
-        DeepSeekChatModel,
-        OpenRouterChatModel,
-        OllamaChatModel,
-        BedrockChatModel,
-    ];
-    const M = availableModels.find((m) => m.name
+    const M = models.find((m) => m.name
         .toLowerCase()
         .includes((MODEL_PROVIDER ?? model?.provider ?? DEFAULT_MODEL_PROVIDER).toLowerCase()));
     if (!M)
@@ -101,7 +82,7 @@ const aigneFileSchema = z.object({
             name: z.string().nullish(),
             temperature: z.number().min(0).max(2).nullish(),
             top_p: z.number().min(0).nullish(),
-            frequent_penalty: z.number().min(-2).max(2).nullish(),
+            frequency_penalty: z.number().min(-2).max(2).nullish(),
             presence_penalty: z.number().min(-2).max(2).nullish(),
         }),
     ])

package/lib/esm/memory/retriever.d.ts

@@ -39,11 +39,11 @@ export declare const memoryRetrieverInputSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     search: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    limit?: number | undefined;
     search?: string | undefined;
-}, {
     limit?: number | undefined;
+}, {
     search?: string | undefined;
+    limit?: number | undefined;
 }>;
 /**
  * @hidden

package/lib/esm/prompt/prompt-builder.d.ts

@@ -1,9 +1,9 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
 import { Agent, type Message } from "../agents/agent.js";
 import type { AIAgent } from "../agents/ai-agent.js";
+import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
 import type { Context } from "../aigne/context.js";
 import type { MemoryAgent } from "../memory/memory.js";
-import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
 export declare function createMessage<I extends Message>(message: string | I): I;
@@ -11,7 +11,7 @@ export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
-export interface PromptBuilderBuildOptions {
+export interface PromptBuildOptions {
     memory?: MemoryAgent | MemoryAgent[];
     context: Context;
     agent?: AIAgent;
@@ -32,7 +32,7 @@ export declare class PromptBuilder {
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
     instructions?: string | ChatMessagesTemplate;
-    build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
+    build(options: PromptBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;
     private buildMessages;

package/lib/esm/prompt/template.d.ts

@@ -1,4 +1,4 @@
-import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../models/chat-model.js";
+import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../agents/chat-model.js";
 export declare class PromptTemplate {
     template: string;
     static from(template: string): PromptTemplate;
@@ -24,7 +24,7 @@ export declare class AgentMessageTemplate extends ChatMessageTemplate {
     constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCalls: ChatModelOutputToolCall[] | undefined;
-        role: import("../models/chat-model.js").Role;
+        role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCallId?: string;
         name?: string;
@@ -36,7 +36,7 @@ export declare class ToolMessageTemplate extends ChatMessageTemplate {
     constructor(content: object | string, toolCallId: string, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCallId: string;
-        role: import("../models/chat-model.js").Role;
+        role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCalls?: {
             id: string;

package/lib/esm/utils/json-schema.js

@@ -23,7 +23,7 @@ export function parseJSON(json) {
         return JSON.parse(json);
     }
     catch (error) {
-        logger.core("Failed to parse JSON", { json, error });
+        logger.error("Failed to parse JSON", { json, error });
         throw error;
     }
 }

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;
@@ -19,3 +19,5 @@ export declare function readableStreamToArray<T>(stream: ReadableStream<T>, opti
     catchError?: false;
 }): Promise<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

@@ -98,7 +98,7 @@ export function onAgentResponseStreamEnd(stream, callback, options) {
                 }
             }
             catch (error) {
-                controller.error(options?.errorCallback?.(error) ?? error);
+                controller.error((await options?.errorCallback?.(error)) ?? error);
             }
         },
     });
@@ -151,3 +151,31 @@ export function stringToAgentResponseStream(str, key = "text") {
     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.15.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;
-}