@nemesis-oss/ollama-sdk 1.3.0 → 1.4.0

package/dist/index.d.ts

@@ -1,339 +1,14 @@
-import { M as Message, C as ChatResponse, G as GenerateResponse, T as ToolCall, P as ProgressResponse, a as ModelResponse, S as ShowRequestOptions, b as ShowResponse, c as PullRequestOptions, d as PushRequestOptions, e as CreateRequestOptions, D as DeleteRequestOptions, f as StatusResponse, g as CopyRequestOptions, h as PsResponse, V as VersionResponse, i as ChatRequestOptions, j as GenerateRequestOptions, E as EmbedRequestOptions, k as EmbedResponse, l as EmbeddingsRequestOptions, m as EmbeddingsResponse, W as WebSearchRequestOptions, n as WebSearchResponse, o as WebFetchRequestOptions, p as WebFetchResponse, q as ToolHandler, r as Tool, A as AnyTool, s as ToolRegistry, t as ToolExecutionResult, u as ModelOptions, v as ToolDefinition } from './compose-CDWq8oxJ.js';
-export { w as AppliedSkillResult, x as ApplySkillOptions, F as FormatOption, L as ListResponse, y as Logprob, z as LogprobToken, B as ModelDetails, H as ParsedFrontmatter, R as RequestCancellationOptions, I as Role, J as Skill, K as SkillFrontmatter, N as SkillSummary, O as ToolCallFunction, Q as ToolExecutionContext, U as ToolExecutionFailure, X as ToolExecutionSuccess, Y as ToolFunctionDefinition, Z as ToolProperty, _ as ToolRegistryOptions, $ as WebSearchResult, a0 as applySkill, a1 as parseFrontmatter } from './compose-CDWq8oxJ.js';
+import { F as FetchLike, M as Middleware, L as Logger, R as RequestLifecycleHook, H as HttpClient, a as OllamaStreamEvent, A as AbortableAsyncIterable, b as OllamaStreamEventType, P as ProgressStreamResult, B as BinaryBody, S as SseEvent, c as OllamaClientError, O as OllamaRuntime, C as ChatStreamResult, G as GenerateStreamResult, d as RawUsageSource, T as TokenUsage } from './index-DIQ8NUbU.js';
+export { D as DoneEvent, E as ErrorEvent, e as HttpBody, f as HttpClientOptions, g as HttpRequestOptions, h as LifecycleErrorEvent, i as LifecycleRetryEvent, j as LifecycleStartEvent, k as LifecycleSuccessEvent, l as LogFn, m as MessageEvent, n as MiddlewareContext, N as NANOS_PER_MS, o as NANOS_PER_SECOND, p as NOOP_LOGGER, q as NextFunction, r as OllamaAbortError, s as OllamaAgentMaxIterationsError, t as OllamaAgentMaxToolCallsError, u as OllamaAuthError, v as OllamaClientErrorOptions, w as OllamaErrorRequestContext, x as OllamaErrorResponseContext, y as OllamaGenericClientError, z as OllamaIncompatibleModelError, I as OllamaMcpError, J as OllamaModelRoutingError, K as OllamaNetworkError, Q as OllamaNotFoundError, U as OllamaQuotaExceededError, V as OllamaRateLimitError, W as OllamaServerError, X as OllamaSkillInvalidError, Y as OllamaSkillNotFoundError, Z as OllamaTimeoutError, _ as OllamaToolTimeoutError, $ as OllamaToolValidationError, a0 as OllamaUnsupportedCapabilityError, a1 as RequestContext, a2 as RequestLifecycleEvent, a3 as ResponseContext, a4 as ThinkingEvent, a5 as TokenEvent, a6 as ToolCallEvent, a7 as composeMiddleware, a8 as createConsoleLogger, a9 as extractUsage, aa as mapError, ab as parseSseStream } from './index-DIQ8NUbU.js';
+import { b as ThinkingMetadata, c as ModelResponse, S as ShowRequestOptions, d as ShowResponse, P as PullRequestOptions, e as ProgressResponse, f as PushRequestOptions, C as CreateRequestOptions, D as DeleteRequestOptions, g as StatusResponse, h as CopyRequestOptions, i as PsResponse, V as VersionResponse, j as ChatRequestOptions, k as ChatResponse, G as GenerateRequestOptions, l as GenerateResponse, E as EmbedRequestOptions, m as EmbedResponse, n as EmbeddingsRequestOptions, o as EmbeddingsResponse, W as WebSearchRequestOptions, p as WebSearchResponse, q as WebFetchRequestOptions, r as WebFetchResponse, T as ToolDefinition, a as ToolCall, M as Message, s as ModelOptions, t as ThinkValue } from './types-BQhgW-du.js';
+export { F as FormatOption, L as ListResponse, u as Logprob, v as LogprobToken, w as ModelDetails, R as RequestCancellationOptions, x as Role, y as ToolCallFunction, z as ToolFunctionDefinition, A as ToolParameters, B as ToolProperty, H as WebSearchResult } from './types-BQhgW-du.js';
 import { z } from 'zod';
+import { T as ToolHandler, e as Tool, f as AnyTool, g as ToolRegistry, h as ToolExecutionResult } from './compose-DfAqKAFj.js';
+export { A as AppliedSkillResult, b as ApplySkillOptions, P as ParsedFrontmatter, a as Skill, c as SkillFrontmatter, S as SkillSummary, i as ToolExecutionContext, j as ToolExecutionFailure, k as ToolExecutionSuccess, l as ToolRegistryOptions, d as applySkill, p as parseFrontmatter } from './compose-DfAqKAFj.js';
+import { a as McpClientLike, M as McpToolDescriptor } from './types-B9_axjum.js';
+export { b as McpCallToolResult, c as McpContentBlock, d as McpIcon, e as McpListToolsParams, f as McpListToolsResult, g as McpRequestOptions, h as McpToolAnnotations, i as McpToolExecution } from './types-B9_axjum.js';
 import * as Otel from '@opentelemetry/api';
 
-/**
- * Structured, typed error hierarchy for OllamaClient.
- */
-interface OllamaErrorRequestContext {
-    readonly method?: string | undefined;
-    readonly url?: string | undefined;
-    readonly model?: string | undefined;
-}
-interface OllamaErrorResponseContext {
-    readonly status?: number | undefined;
-    readonly headers?: Record<string, string> | undefined;
-    readonly body?: unknown;
-}
-interface OllamaClientErrorOptions extends ErrorOptions {
-    readonly code: string;
-    readonly status?: number | undefined;
-    readonly retryable?: boolean | undefined;
-    readonly request?: OllamaErrorRequestContext | undefined;
-    readonly response?: OllamaErrorResponseContext | undefined;
-}
-declare class OllamaClientError extends Error {
-    readonly code: string;
-    readonly status?: number | undefined;
-    readonly retryable: boolean;
-    readonly request?: OllamaErrorRequestContext | undefined;
-    readonly response?: OllamaErrorResponseContext | undefined;
-    constructor(message: string, options: OllamaClientErrorOptions);
-}
-declare class OllamaNetworkError extends OllamaClientError {
-    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
-}
-declare class OllamaTimeoutError extends OllamaClientError {
-    readonly timeoutMs?: number | undefined;
-    constructor(message: string, options?: (Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
-        timeoutMs?: number | undefined;
-    }) | undefined);
-}
-declare class OllamaAuthError extends OllamaClientError {
-    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
-}
-declare class OllamaNotFoundError extends OllamaClientError {
-    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
-}
-declare class OllamaRateLimitError extends OllamaClientError {
-    readonly retryAfterMs?: number | undefined;
-    constructor(message: string, options?: (Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
-        retryAfterMs?: number | undefined;
-    }) | undefined);
-}
-/**
- * Thrown client-side, before a network request is made, by `QuotaManager.assertCanProceed`
- * (see `src/quota.ts`) when issuing the request would exceed a configured usage budget for
- * one of its rolling windows. This is distinct from `OllamaRateLimitError`, which reflects
- * the server's own 429 response — Ollama Cloud does not expose account-level quota via the
- * API, so `QuotaManager` tracks usage against budgets the caller configures locally and
- * fails fast rather than waiting for the server to reject the request.
- */
-declare class OllamaQuotaExceededError extends OllamaClientError {
-    readonly windowId: string;
-    readonly resetAt: number;
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
-        windowId: string;
-        resetAt: number;
-    });
-}
-declare class OllamaServerError extends OllamaClientError {
-    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
-}
-declare class OllamaAbortError extends OllamaClientError {
-    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
-}
-declare class OllamaToolValidationError extends OllamaClientError {
-    readonly toolName: string;
-    readonly issues?: unknown;
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code'> & {
-        toolName: string;
-        issues?: unknown;
-    });
-}
-declare class OllamaToolTimeoutError extends OllamaClientError {
-    readonly toolName: string;
-    readonly timeoutMs: number;
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
-        toolName: string;
-        timeoutMs: number;
-    });
-}
-/**
- * Thrown client-side, before a network request is made, when a request asks for a
- * capability an endpoint is known not to support (e.g. structured output `format` against
- * an Ollama Cloud endpoint — see `ModelCapabilities.supportsStructuredOutputRequest` in
- * `src/capabilities/capabilities.ts`). Its `code` is included in `DEFAULT_FAILOVER_CODES`
- * by default, so in a multi-endpoint setup it causes failover to the next candidate rather
- * than failing outright — it only surfaces to the caller if every candidate is rejected.
- */
-declare class OllamaUnsupportedCapabilityError extends OllamaClientError {
-    readonly capability: string;
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
-        capability: string;
-    });
-}
-/**
- * Thrown client-side, before any network call, when `config.endpoints` uses
- * `OllamaEndpoint.models` to scope endpoints/credentials to specific models and the
- * requested `model` isn't in any configured endpoint's allow-list. This is a routing
- * misconfiguration, not a connectivity problem — the SDK deliberately does not "probe"
- * unauthorized endpoints to find one that happens to work (that would burn quota on keys
- * that were never entitled to the model and produce non-deterministic startup behavior).
- */
-declare class OllamaModelRoutingError extends OllamaClientError {
-    readonly model: string;
-    readonly availableModels: readonly string[];
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
-        model: string;
-        availableModels: readonly string[];
-    });
-}
-declare class OllamaAgentMaxIterationsError extends OllamaClientError {
-    readonly maxIterations: number;
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code'> & {
-        maxIterations: number;
-    });
-}
-declare class OllamaMcpError extends OllamaClientError {
-    readonly mcpMethod: 'listTools' | 'callTool';
-    readonly toolName?: string | undefined;
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code'> & {
-        mcpMethod: 'listTools' | 'callTool';
-        toolName?: string | undefined;
-    });
-}
-declare class OllamaSkillNotFoundError extends OllamaClientError {
-    readonly skillName: string;
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code'> & {
-        skillName: string;
-    });
-}
-declare class OllamaSkillInvalidError extends OllamaClientError {
-    readonly skillName: string;
-    readonly path?: string | undefined;
-    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code'> & {
-        skillName: string;
-        path?: string | undefined;
-    });
-}
-declare class OllamaGenericClientError extends OllamaClientError {
-    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code'> | undefined);
-}
-/**
- * Maps arbitrary thrown exceptions into structured OllamaClientError instances.
- */
-declare function mapError(error: unknown, context?: {
-    request?: OllamaErrorRequestContext | undefined;
-    response?: OllamaErrorResponseContext | undefined;
-}): OllamaClientError;
-
-/**
- * Token usage and duration calculation utilities.
- */
-declare const NANOS_PER_MS = 1000000;
-declare const NANOS_PER_SECOND = 1000000000;
-interface TokenUsage {
-    readonly promptTokens: number;
-    readonly completionTokens: number;
-    readonly totalTokens: number;
-    readonly tokensPerSecond?: number | undefined;
-    readonly loadDurationMs?: number | undefined;
-    readonly promptEvalDurationMs?: number | undefined;
-    readonly evalDurationMs?: number | undefined;
-    readonly totalDurationMs?: number | undefined;
-}
-interface RawUsageSource {
-    readonly prompt_eval_count?: number | undefined;
-    readonly eval_count?: number | undefined;
-    readonly total_duration?: number | undefined;
-    readonly load_duration?: number | undefined;
-    readonly prompt_eval_duration?: number | undefined;
-    readonly eval_duration?: number | undefined;
-}
-/**
- * Extracts and normalizes token usage metrics from an Ollama response.
- */
-declare function extractUsage(raw: RawUsageSource): TokenUsage;
-
-/**
- * Streaming event types, listener contracts, and aggregated result shapes.
- */
-
-interface TokenEvent {
-    readonly type: 'token';
-    readonly data: {
-        readonly delta: string;
-        readonly role?: string | undefined;
-    };
-}
-interface ThinkingEvent {
-    readonly type: 'thinking';
-    readonly data: {
-        readonly delta: string;
-    };
-}
-interface ToolCallEvent {
-    readonly type: 'tool_call';
-    readonly data: {
-        readonly toolCall: ToolCall;
-    };
-}
-interface MessageEvent<TChunk> {
-    readonly type: 'message';
-    readonly data: {
-        readonly chunk: TChunk;
-    };
-}
-interface DoneEvent<TFinal> {
-    readonly type: 'done';
-    readonly data: {
-        readonly result: TFinal;
-    };
-}
-interface ErrorEvent {
-    readonly type: 'error';
-    readonly data: {
-        readonly error: OllamaClientError;
-    };
-}
-type OllamaStreamEvent<TChunk, TFinal> = TokenEvent | ThinkingEvent | ToolCallEvent | MessageEvent<TChunk> | DoneEvent<TFinal> | ErrorEvent;
-type OllamaStreamEventType = OllamaStreamEvent<unknown, unknown>['type'];
-interface ChatStreamResult {
-    readonly message: Message;
-    readonly model: string;
-    readonly done: boolean;
-    /** Mirrors the final chunk's `done_reason` (e.g. `"stop"`, `"load"`, `"unload"`). */
-    readonly doneReason?: string | undefined;
-    readonly totalDurationMs?: number | undefined;
-    readonly usage?: TokenUsage | undefined;
-    readonly raw?: ChatResponse | undefined;
-}
-interface GenerateStreamResult {
-    readonly response: string;
-    readonly model: string;
-    readonly done: boolean;
-    /** Mirrors the final chunk's `done_reason` (e.g. `"stop"`, `"load"`, `"unload"`). */
-    readonly doneReason?: string | undefined;
-    readonly totalDurationMs?: number | undefined;
-    readonly usage?: TokenUsage | undefined;
-    readonly raw?: GenerateResponse | undefined;
-}
-interface ProgressStreamResult {
-    readonly status: string;
-    readonly completed?: number | undefined;
-    readonly total?: number | undefined;
-    readonly done: boolean;
-    readonly raw?: ProgressResponse | undefined;
-}
-interface AbortableAsyncIterable<T> extends AsyncIterable<T> {
-    abort?: (() => void) | undefined;
-}
-
-/**
- * Structured logger and request lifecycle interfaces.
- */
-interface LogFn {
-    (message: string, context?: Record<string, unknown>): void;
-}
-interface Logger {
-    readonly debug: LogFn;
-    readonly info: LogFn;
-    readonly warn: LogFn;
-    readonly error: LogFn;
-}
-interface LifecycleStartEvent {
-    readonly type: 'start';
-    readonly requestId: string;
-    readonly method: string;
-    readonly url: string;
-    readonly timestamp: number;
-}
-interface LifecycleSuccessEvent {
-    readonly type: 'success';
-    readonly requestId: string;
-    readonly durationMs: number;
-    readonly status: number;
-    readonly timestamp: number;
-}
-interface LifecycleRetryEvent {
-    readonly type: 'retry';
-    readonly requestId: string;
-    readonly attempt: number;
-    readonly error: Error;
-    readonly delayMs: number;
-    readonly timestamp: number;
-}
-interface LifecycleErrorEvent {
-    readonly type: 'error';
-    readonly requestId: string;
-    readonly durationMs: number;
-    readonly error: Error;
-    readonly timestamp: number;
-}
-type RequestLifecycleEvent = LifecycleStartEvent | LifecycleSuccessEvent | LifecycleRetryEvent | LifecycleErrorEvent;
-interface RequestLifecycleHook {
-    (event: RequestLifecycleEvent): void;
-}
-declare const NOOP_LOGGER: Logger;
-declare function createConsoleLogger(prefix?: string): Logger;
-
-/**
- * Request/response middleware pipeline.
- */
-interface RequestContext {
-    readonly url: string;
-    readonly method: string;
-    readonly headers: Record<string, string>;
-    readonly body?: unknown;
-    readonly signal?: AbortSignal;
-}
-interface ResponseContext {
-    readonly status: number;
-    readonly headers: Record<string, string>;
-    readonly body: unknown;
-}
-type NextFunction = () => Promise<ResponseContext>;
-interface MiddlewareContext {
-    readonly request: RequestContext;
-    readonly next: NextFunction;
-}
-interface Middleware {
-    (ctx: MiddlewareContext): Promise<ResponseContext>;
-}
-declare function composeMiddleware(middlewares: readonly Middleware[], finalHandler: (req: RequestContext) => Promise<ResponseContext>): (req: RequestContext) => Promise<ResponseContext>;
-
 /**
  * Exponential backoff with full jitter calculation.
  */
@@ -362,39 +37,7 @@ declare const DEFAULT_RETRY_CONFIG: RetryConfig;
 /**
  * Executes an async operation with retries according to config.
  */
-declare function withRetry<T>(operation: (attempt: number) => Promise<T>, config?: RetryConfig): Promise<T>;
-
-/**
- * Native fetch HTTP transport client for Ollama API.
- */
-
-type FetchLike = typeof globalThis.fetch;
-type BinaryBody = Uint8Array | ArrayBuffer | string | Blob | ReadableStream<Uint8Array>;
-type HttpBody = unknown;
-interface HttpClientOptions {
-    readonly baseUrl: string;
-    readonly apiKey?: string | undefined;
-    readonly headers?: Record<string, string> | undefined;
-    readonly fetch?: FetchLike | undefined;
-}
-interface HttpRequestOptions {
-    readonly path: string;
-    readonly method?: 'GET' | 'POST' | 'DELETE' | 'HEAD' | undefined;
-    readonly body?: HttpBody;
-    readonly rawBody?: BinaryBody | undefined;
-    readonly headers?: Record<string, string> | undefined;
-    readonly signal?: AbortSignal | undefined;
-}
-declare class HttpClient {
-    readonly baseUrl: string;
-    private readonly apiKey?;
-    private readonly defaultHeaders;
-    private readonly fetchImpl;
-    constructor(options: HttpClientOptions);
-    private buildHeaders;
-    request<T>(options: HttpRequestOptions): Promise<T>;
-    requestStream<T>(options: HttpRequestOptions): Promise<AbortableAsyncIterable<T>>;
-}
+declare function withRetry<T>(operation: (attempt: number) => Promise<T>, config?: RetryConfig, signal?: AbortSignal): Promise<T>;
 
 /**
  * Multi-endpoint registry with priority routing and circuit breaker failover.
@@ -662,7 +305,7 @@ interface EndpointHealthCheckResult {
     readonly version?: string;
     readonly error?: string;
 }
-declare function checkEndpointHealth(endpoint: OllamaEndpoint, fetchImpl?: FetchLike, timeoutMs?: number): Promise<EndpointHealthCheckResult>;
+declare function checkEndpointHealth(endpoint: OllamaEndpoint, fetchImpl?: FetchLike, timeoutMs?: number, middleware?: readonly Middleware[] | undefined, onLifecycleEvent?: RequestLifecycleHook | undefined): Promise<EndpointHealthCheckResult>;
 
 /**
  * Model capability detection and runtime environment inference.
@@ -677,7 +320,11 @@ interface ModelCapabilities {
     readonly supportsEmbedding: boolean;
     readonly supportsCompletion: boolean;
     readonly supportsThinking: boolean;
+    /** Model-defined thinking values and default, when /api/show reports them. */
+    readonly thinking?: ThinkingMetadata | undefined;
     readonly supportsStreaming: true;
+    /** Maximum model context length reported by /api/show model_info, when available. */
+    readonly contextLength?: number | undefined;
     /**
      * Best-effort inference, not a guarantee: Ollama's `/api/show` does not report structured
      * output support as a queryable capability, so this is inferred from {@link inferRuntimeMode}
@@ -691,7 +338,7 @@ interface ModelCapabilities {
     readonly supportsStructuredOutputRequest: boolean;
 }
 declare function inferRuntimeMode(baseUrl: string): RuntimeMode;
-declare function detectModelCapabilities(http: HttpClient, model: string): Promise<ModelCapabilities>;
+declare function detectModelCapabilities(http: HttpClient, model: string, signal?: AbortSignal): Promise<ModelCapabilities>;
 declare function listAvailableModels(http: HttpClient): Promise<ModelResponse[]>;
 
 /**
@@ -710,7 +357,8 @@ declare class OllamaStream<TChunk, TFinal> implements AsyncIterable<OllamaStream
     private readonly finalResultPromise;
     private resolveFinal;
     private rejectFinal;
-    constructor(source: AbortableAsyncIterable<TChunk>, mapChunk: ChunkMapper<TChunk, TFinal>, aggregate: Aggregator<TChunk, TFinal>, initial: TFinal);
+    private removeAbortListener;
+    constructor(source: AbortableAsyncIterable<TChunk>, mapChunk: ChunkMapper<TChunk, TFinal>, aggregate: Aggregator<TChunk, TFinal>, initial: TFinal, signal?: AbortSignal);
     get finalResult(): Promise<TFinal>;
     abort(): void;
     on<TType extends OllamaStreamEventType>(type: TType, listener: (event: Extract<OllamaStreamEvent<TChunk, TFinal>, {
@@ -722,17 +370,22 @@ declare class OllamaStream<TChunk, TFinal> implements AsyncIterable<OllamaStream
 }
 
 /**
- * Model and blob management operations.
+ * Shared request-runner contract used by native and compatibility clients.
  */
 
 type RequestRunner = <T>(op: (http: HttpClient, signal: AbortSignal) => Promise<T>, opts?: {
-    signal?: AbortSignal | undefined;
-    timeoutMs?: number | undefined;
-    singleEndpoint?: boolean | undefined;
-    model?: string | undefined;
-    /** See `OllamaClient.executeWithFailover`'s `holdUntil` doc. */
-    holdUntil?: ((result: T) => Promise<unknown>) | undefined;
+    readonly signal?: AbortSignal | undefined;
+    readonly timeoutMs?: number | undefined;
+    readonly singleEndpoint?: boolean | undefined;
+    readonly model?: string | undefined;
+    /** Defers endpoint capacity release until the returned promise settles. */
+    readonly holdUntil?: ((result: T) => Promise<unknown>) | undefined;
 }) => Promise<T>;
+
+/**
+ * Model and blob management operations.
+ */
+
 /**
  * Every operation here targets one specific Ollama server's local model catalog or blob
  * store — unlike `chat`/`generate`/`embed`, a different endpoint isn't an interchangeable
@@ -801,11 +454,26 @@ interface OpenAIToolCall {
         readonly arguments: string;
     };
 }
+interface OpenAITextContentPart {
+    readonly type: 'text';
+    readonly text: string;
+}
+interface OpenAIImageUrlContentPart {
+    readonly type: 'image_url';
+    /** Ollama accepts a data/image URL string or the standard OpenAI URL object. */
+    readonly image_url: string | {
+        readonly url: string;
+        readonly detail?: 'auto' | 'low' | 'high' | 'original' | undefined;
+    };
+}
+type OpenAIContentPart = OpenAITextContentPart | OpenAIImageUrlContentPart;
 interface OpenAIMessage {
     readonly role: 'system' | 'user' | 'assistant' | 'tool';
-    readonly content: string;
+    readonly content: string | readonly OpenAIContentPart[];
     readonly name?: string | undefined;
     readonly tool_calls?: readonly OpenAIToolCall[] | undefined;
+    /** Ollama may emit model reasoning alongside assistant content. */
+    readonly reasoning?: string | undefined;
     /** Set on a `role: 'tool'` message to identify which call this is a result for. */
     readonly tool_call_id?: string | undefined;
 }
@@ -822,6 +490,15 @@ interface OpenAITool {
     readonly type: 'function';
     readonly function: OpenAIFunctionDefinition;
 }
+type OpenAIReasoningEffort = 'high' | 'medium' | 'low' | 'max' | 'none' | 'minimal' | 'xhigh' | 'ultra' | (string & {});
+type OpenAIResponseFormat = {
+    readonly type: 'text';
+} | {
+    readonly type: 'json_object';
+} | {
+    readonly type: 'json_schema';
+    readonly json_schema: Record<string, unknown>;
+};
 interface OpenAIChatCompletionRequest {
     readonly model: string;
     readonly messages: readonly OpenAIMessage[];
@@ -832,9 +509,16 @@ interface OpenAIChatCompletionRequest {
     readonly stream_options?: OpenAIStreamOptions | undefined;
     readonly max_tokens?: number | undefined;
     readonly stop?: readonly string[] | undefined;
+    readonly response_format?: OpenAIResponseFormat | undefined;
+    readonly seed?: number | undefined;
     readonly presence_penalty?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly user?: string | undefined;
+    readonly logit_bias?: Record<string, number> | undefined;
+    readonly n?: number | undefined;
+    /** Ollama exposes log probabilities for supported reasoning/chat models. */
+    readonly logprobs?: boolean | undefined;
+    readonly top_logprobs?: number | undefined;
     readonly tools?: readonly OpenAITool[] | undefined;
     /**
      * @remarks Accepted for OpenAI compatibility but ignored by Ollama — every tool the
@@ -855,33 +539,92 @@ interface OpenAIChatCompletionRequest {
      * Effort level for thinking models (e.g. `deepseek-r1`, `qwen3`). Equivalent to
      * `reasoning.effort`; only effective for models that support reasoning/thinking.
      */
-    readonly reasoning_effort?: 'high' | 'medium' | 'low' | 'max' | 'none' | undefined;
+    readonly reasoning_effort?: OpenAIReasoningEffort | undefined;
     /**
      * Effort level for thinking models (e.g. `deepseek-r1`, `qwen3`), nested OpenAI-style.
      * Equivalent to `reasoning_effort`; only effective for models that support
      * reasoning/thinking.
      */
     readonly reasoning?: {
-        readonly effort?: 'high' | 'medium' | 'low' | 'max' | 'none' | undefined;
+        readonly effort?: OpenAIReasoningEffort | undefined;
     } | undefined;
 }
+/** Ollama Chat Completions supports text plus base64 image content via a string image URL. */
+type OllamaOpenAIChatContentPart = OpenAITextContentPart | {
+    readonly type: 'image_url';
+    /** Ollama's current compatibility docs accept an image URL string, including data URLs. */
+    readonly image_url: string;
+};
+type OllamaOpenAIReasoningEffort = 'high' | 'medium' | 'low' | 'max' | 'none';
+type OllamaOpenAIChatMessage = Omit<OpenAIMessage, 'content'> & {
+    readonly content: string | readonly OllamaOpenAIChatContentPart[];
+};
+/** Strict Ollama-documented Chat Completions request; excludes only the SDK-only parallel tool flag. */
+type OllamaOpenAIChatCompletionRequest = Omit<OpenAIChatCompletionRequest, 'messages' | 'parallel_tool_calls' | 'reasoning_effort' | 'reasoning'> & {
+    readonly messages: readonly OllamaOpenAIChatMessage[];
+    readonly reasoning_effort?: OllamaOpenAIReasoningEffort | undefined;
+    readonly reasoning?: {
+        readonly effort?: OllamaOpenAIReasoningEffort | undefined;
+    } | undefined;
+};
 interface OpenAIChatCompletionChoice {
     readonly index: number;
     readonly message: OpenAIMessage;
     readonly finish_reason: string;
+    readonly logprobs?: Record<string, unknown> | null | undefined;
 }
-interface OpenAIChatCompletionResponse {
+interface OpenAIToolCallDelta {
+    readonly index: number;
+    readonly id?: string | undefined;
+    readonly type?: 'function' | undefined;
+    readonly function?: {
+        readonly name?: string | undefined;
+        readonly arguments?: string | undefined;
+    } | undefined;
+}
+interface OpenAIChatCompletionDelta {
+    readonly role?: OpenAIMessage['role'] | undefined;
+    readonly content?: string | null | undefined;
+    readonly reasoning?: string | null | undefined;
+    readonly refusal?: string | null | undefined;
+    readonly tool_calls?: readonly OpenAIToolCallDelta[] | undefined;
+}
+interface OpenAIChatCompletionChunkChoice {
+    readonly index: number;
+    readonly delta: OpenAIChatCompletionDelta;
+    readonly finish_reason?: string | null | undefined;
+    readonly logprobs?: Record<string, unknown> | null | undefined;
+}
+interface OpenAIChatCompletionChunk {
     readonly id: string;
-    readonly object: 'chat.completion';
+    readonly object: 'chat.completion.chunk';
     readonly created: number;
     readonly model: string;
-    readonly choices: readonly OpenAIChatCompletionChoice[];
+    readonly system_fingerprint?: string | undefined;
+    readonly choices: readonly OpenAIChatCompletionChunkChoice[];
     readonly usage?: {
         readonly prompt_tokens: number;
         readonly completion_tokens: number;
         readonly total_tokens: number;
+    } | null | undefined;
+}
+interface OpenAIUsage {
+    readonly prompt_tokens: number;
+    readonly completion_tokens: number;
+    readonly total_tokens: number;
+    readonly prompt_tokens_details?: {
+        readonly cached_tokens?: number | undefined;
     } | undefined;
 }
+interface OpenAIChatCompletionResponse {
+    readonly id: string;
+    readonly object: 'chat.completion';
+    readonly created: number;
+    readonly model: string;
+    readonly system_fingerprint?: string | undefined;
+    readonly choices: readonly OpenAIChatCompletionChoice[];
+    readonly usage?: OpenAIUsage | undefined;
+}
 interface OpenAIModelItem {
     readonly id: string;
     readonly object: 'model';
@@ -892,6 +635,87 @@ interface OpenAIListModelsResponse {
     readonly object: 'list';
     readonly data: readonly OpenAIModelItem[];
 }
+interface OpenAICompletionRequest {
+    readonly model: string;
+    /** Ollama currently accepts a string prompt for /v1/completions. */
+    readonly prompt: string;
+    /** Number of log probability alternatives requested for completion tokens. */
+    readonly logprobs?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly stream?: boolean | undefined;
+    readonly stream_options?: OpenAIStreamOptions | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly suffix?: string | undefined;
+    readonly best_of?: number | undefined;
+    readonly echo?: boolean | undefined;
+    readonly logit_bias?: Record<string, number> | undefined;
+    readonly user?: string | undefined;
+    readonly n?: number | undefined;
+}
+/** Strict Ollama-documented Completions request. */
+type OllamaOpenAICompletionRequest = OpenAICompletionRequest;
+interface OpenAICompletionChoice {
+    readonly text: string;
+    readonly index: number;
+    readonly logprobs?: Record<string, unknown> | null | undefined;
+    readonly finish_reason: string | null;
+}
+interface OpenAICompletionChunk {
+    readonly id: string;
+    readonly object: 'text_completion';
+    readonly created: number;
+    readonly model: string;
+    readonly system_fingerprint?: string | undefined;
+    readonly choices: readonly {
+        readonly text: string;
+        readonly index: number;
+        readonly logprobs?: Record<string, unknown> | null | undefined;
+        readonly finish_reason?: string | null | undefined;
+    }[];
+    readonly usage?: {
+        readonly prompt_tokens: number;
+        readonly completion_tokens: number;
+        readonly total_tokens: number;
+    } | null | undefined;
+}
+interface OpenAICompletionResponse {
+    readonly id: string;
+    readonly object: 'text_completion';
+    readonly created: number;
+    readonly model: string;
+    readonly system_fingerprint?: string | undefined;
+    readonly choices: readonly OpenAICompletionChoice[];
+    readonly usage?: OpenAIUsage | undefined;
+}
+type OpenAIEmbeddingInput = string | readonly string[] | readonly number[] | readonly (readonly number[])[];
+interface OpenAIEmbeddingRequest {
+    readonly model: string;
+    readonly input: OpenAIEmbeddingInput;
+    readonly encoding_format?: 'float' | 'base64' | undefined;
+    readonly dimensions?: number | undefined;
+    readonly user?: string | undefined;
+}
+/** Strict Ollama-documented Embeddings request. */
+type OllamaOpenAIEmbeddingRequest = OpenAIEmbeddingRequest;
+interface OpenAIEmbeddingItem {
+    readonly object: 'embedding';
+    readonly embedding: readonly number[] | string;
+    readonly index: number;
+}
+interface OpenAIEmbeddingResponse {
+    readonly object: 'list';
+    readonly data: readonly OpenAIEmbeddingItem[];
+    readonly model: string;
+    readonly usage?: {
+        readonly prompt_tokens: number;
+        readonly total_tokens: number;
+    } | undefined;
+}
 /**
  * Request body for OpenAI's Responses API (`/v1/responses`), added in Ollama v0.13.3.
  *
@@ -915,93 +739,601 @@ interface OpenAIResponsesRequest {
     /** @remarks Not supported by Ollama, which is stateless across calls — accepted but ignored. */
     readonly conversation?: string | undefined;
     readonly truncation?: string | undefined;
+    readonly reasoning?: {
+        readonly effort?: OpenAIReasoningEffort | undefined;
+    } | undefined;
+    /** Ollama extension: boolean, model-defined string, or null for model default. */
+    readonly think?: boolean | string | null | undefined;
+}
+/** Strict Ollama-documented Responses request; excludes stateful and SDK-only request fields. */
+/** Strict Ollama-documented Responses request; excludes only unsupported stateful fields. */
+type OllamaOpenAIResponsesRequest = Omit<OpenAIResponsesRequest, 'previous_response_id' | 'conversation'>;
+type OpenAIResponsesStatus = 'completed' | 'failed' | 'in_progress' | 'cancelled' | 'queued' | 'incomplete';
+interface OpenAIResponsesError {
+    readonly code?: string | undefined;
+    readonly message?: string | undefined;
+    readonly [key: string]: unknown;
+}
+interface OpenAIResponsesIncompleteDetails {
+    readonly reason?: string | undefined;
+    readonly [key: string]: unknown;
 }
 interface OpenAIResponsesOutputTextContent {
     readonly type: 'output_text';
     readonly text: string;
+    readonly annotations?: readonly Record<string, unknown>[] | undefined;
+    readonly logprobs?: readonly Record<string, unknown>[] | undefined;
 }
+interface OpenAIResponsesOutputRefusal {
+    readonly type: 'refusal';
+    readonly refusal: string;
+}
+type OpenAIResponsesOutputContent = OpenAIResponsesOutputTextContent | OpenAIResponsesOutputRefusal;
 interface OpenAIResponsesOutputMessage {
     readonly type: 'message';
+    readonly id?: string | undefined;
+    readonly status?: OpenAIResponsesStatus | undefined;
     readonly role?: string | undefined;
-    readonly content: readonly OpenAIResponsesOutputTextContent[];
+    readonly phase?: string | undefined;
+    readonly content: readonly OpenAIResponsesOutputContent[];
 }
-/** Non-stateful response shape for `/v1/responses`; see {@link OpenAIResponsesRequest}. */
+interface OpenAIResponsesOutputFunctionCall {
+    readonly type: 'function_call';
+    readonly id?: string | undefined;
+    readonly call_id?: string | undefined;
+    readonly name: string;
+    readonly arguments: string;
+    readonly status?: OpenAIResponsesStatus | undefined;
+}
+interface OpenAIResponsesOutputReasoning {
+    readonly type: 'reasoning';
+    readonly id?: string | undefined;
+    readonly status?: OpenAIResponsesStatus | undefined;
+    readonly summary?: readonly {
+        readonly type: 'summary_text';
+        readonly text: string;
+    }[] | undefined;
+    readonly text?: string | undefined;
+    readonly encrypted_content?: string | undefined;
+}
+type OpenAIResponsesOutputItem = OpenAIResponsesOutputMessage | OpenAIResponsesOutputFunctionCall | OpenAIResponsesOutputReasoning;
+interface OpenAIResponsesUsage {
+    readonly input_tokens: number;
+    readonly output_tokens: number;
+    readonly total_tokens: number;
+    readonly input_tokens_details?: Record<string, unknown> | undefined;
+    readonly output_tokens_details?: Record<string, unknown> | undefined;
+}
+/** Non-stateful response shape for the Ollama Responses compatibility endpoint. */
 interface OpenAIResponsesResponse {
     readonly id: string;
     readonly object: 'response';
     readonly created: number;
+    readonly created_at?: number | undefined;
+    readonly status?: OpenAIResponsesStatus | undefined;
+    readonly completed_at?: number | null | undefined;
+    readonly error?: OpenAIResponsesError | null | undefined;
+    readonly incomplete_details?: OpenAIResponsesIncompleteDetails | null | undefined;
     readonly model: string;
-    readonly output: readonly OpenAIResponsesOutputMessage[];
-    readonly usage?: {
-        readonly input_tokens: number;
-        readonly output_tokens: number;
-        readonly total_tokens: number;
-    } | undefined;
+    readonly output: readonly OpenAIResponsesOutputItem[];
+    readonly output_text?: string | undefined;
+    readonly previous_response_id?: string | null | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
+    readonly usage?: OpenAIResponsesUsage | undefined;
+}
+declare class OpenAIResponsesStreamError extends OllamaClientError {
+    readonly responsePayload: OpenAIResponsesResponse;
+    constructor(message: string, responsePayload: OpenAIResponsesResponse);
+}
+declare class OpenAIChatCompletionStream implements AsyncIterable<OpenAIChatCompletionChunk> {
+    private readonly source;
+    private readonly finalResultPromise;
+    private resolveFinal;
+    private rejectFinal;
+    private removeAbortListener;
+    constructor(source: AbortableAsyncIterable<SseEvent>, signal?: AbortSignal);
+    get finalResult(): Promise<OpenAIChatCompletionResponse>;
+    abort(): void;
+    [Symbol.asyncIterator](): AsyncGenerator<OpenAIChatCompletionChunk, void, undefined>;
+}
+declare class OpenAICompletionStream implements AsyncIterable<OpenAICompletionChunk> {
+    private readonly source;
+    private readonly finalResultPromise;
+    private resolveFinal;
+    private rejectFinal;
+    private removeAbortListener;
+    constructor(source: AbortableAsyncIterable<SseEvent>, signal?: AbortSignal);
+    get finalResult(): Promise<OpenAICompletionResponse>;
+    abort(): void;
+    [Symbol.asyncIterator](): AsyncGenerator<OpenAICompletionChunk, void, undefined>;
+}
+interface OpenAIResponsesEventBase {
+    readonly response_id?: string | undefined;
+    readonly sequence_number?: number | undefined;
+}
+interface OpenAIResponsesOutputTextDeltaEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.output_text.delta';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly content_index: number;
+    readonly delta: string;
+}
+interface OpenAIResponsesOutputTextDoneEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.output_text.done';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly content_index: number;
+    readonly text: string;
+}
+interface OpenAIResponsesFunctionCallArgumentsDeltaEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.function_call_arguments.delta';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly delta: string;
+}
+interface OpenAIResponsesFunctionCallArgumentsDoneEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.function_call_arguments.done';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly arguments: string;
+    readonly name?: string | undefined;
+}
+interface OpenAIResponsesReasoningTextDeltaEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.reasoning_text.delta';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly content_index: number;
+    readonly delta: string;
+}
+interface OpenAIResponsesReasoningTextDoneEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.reasoning_text.done';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly content_index: number;
+    readonly text: string;
+}
+interface OpenAIResponsesReasoningSummaryPartAddedEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.reasoning_summary_part.added';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly summary_index: number;
+    readonly part: {
+        readonly type: 'summary_text';
+        readonly text: string;
+    };
+}
+interface OpenAIResponsesReasoningSummaryPartDoneEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.reasoning_summary_part.done';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly summary_index: number;
+    readonly part: {
+        readonly type: 'summary_text';
+        readonly text: string;
+    };
+    readonly status?: 'incomplete' | undefined;
+}
+interface OpenAIResponsesReasoningSummaryTextDeltaEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.reasoning_summary_text.delta';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly summary_index: number;
+    readonly delta: string;
+}
+interface OpenAIResponsesReasoningSummaryTextDoneEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.reasoning_summary_text.done';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly summary_index: number;
+    readonly text: string;
+}
+interface OpenAIResponsesOutputItemAddedEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.output_item.added';
+    readonly item: OpenAIResponsesOutputItem;
+    readonly output_index: number;
+}
+interface OpenAIResponsesOutputItemDoneEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.output_item.done';
+    readonly item: OpenAIResponsesOutputItem;
+    readonly output_index: number;
+}
+interface OpenAIResponsesContentPartAddedEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.content_part.added';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly content_index: number;
+    readonly part: OpenAIResponsesOutputContent | {
+        readonly type: string;
+        readonly [key: string]: unknown;
+    };
+}
+interface OpenAIResponsesContentPartDoneEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.content_part.done';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly content_index: number;
+    readonly part: OpenAIResponsesOutputContent | {
+        readonly type: string;
+        readonly [key: string]: unknown;
+    };
+}
+interface OpenAIResponsesRefusalDeltaEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.refusal.delta';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly content_index: number;
+    readonly delta: string;
+}
+interface OpenAIResponsesRefusalDoneEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.refusal.done';
+    readonly item_id: string;
+    readonly output_index: number;
+    readonly content_index: number;
+    readonly refusal: string;
+}
+interface OpenAIResponsesCreatedEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.created';
+    readonly response: OpenAIResponsesResponse;
+}
+interface OpenAIResponsesInProgressEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.in_progress';
+    readonly response: OpenAIResponsesResponse;
+}
+interface OpenAIResponsesQueuedEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.queued';
+    readonly response: OpenAIResponsesResponse;
+}
+interface OpenAIResponsesCompletedEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.completed' | 'response.done';
+    readonly response: OpenAIResponsesResponse;
+}
+interface OpenAIResponsesFailedEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.failed';
+    readonly response: OpenAIResponsesResponse;
+}
+interface OpenAIResponsesIncompleteEvent extends OpenAIResponsesEventBase {
+    readonly type: 'response.incomplete';
+    readonly response: OpenAIResponsesResponse;
+}
+type OpenAIResponsesStreamEvent = OpenAIResponsesOutputTextDeltaEvent | OpenAIResponsesOutputTextDoneEvent | OpenAIResponsesFunctionCallArgumentsDeltaEvent | OpenAIResponsesFunctionCallArgumentsDoneEvent | OpenAIResponsesReasoningTextDeltaEvent | OpenAIResponsesReasoningTextDoneEvent | OpenAIResponsesReasoningSummaryPartAddedEvent | OpenAIResponsesReasoningSummaryPartDoneEvent | OpenAIResponsesReasoningSummaryTextDeltaEvent | OpenAIResponsesReasoningSummaryTextDoneEvent | OpenAIResponsesOutputItemAddedEvent | OpenAIResponsesOutputItemDoneEvent | OpenAIResponsesContentPartAddedEvent | OpenAIResponsesContentPartDoneEvent | OpenAIResponsesRefusalDeltaEvent | OpenAIResponsesRefusalDoneEvent | OpenAIResponsesCreatedEvent | OpenAIResponsesInProgressEvent | OpenAIResponsesQueuedEvent | OpenAIResponsesCompletedEvent | OpenAIResponsesFailedEvent | OpenAIResponsesIncompleteEvent | {
+    readonly type: string;
+    readonly [key: string]: unknown;
+};
+declare class OpenAIResponsesStream implements AsyncIterable<OpenAIResponsesStreamEvent> {
+    private readonly source;
+    private readonly finalResultPromise;
+    private resolveFinal;
+    private rejectFinal;
+    private removeAbortListener;
+    constructor(source: AbortableAsyncIterable<SseEvent>, signal?: AbortSignal);
+    get finalResult(): Promise<OpenAIResponsesResponse>;
+    abort(): void;
+    [Symbol.asyncIterator](): AsyncGenerator<OpenAIResponsesStreamEvent, void, undefined>;
 }
 declare class OpenAICompatClient {
     private readonly http;
-    constructor(http: HttpClient);
-    createChatCompletion(request: OpenAIChatCompletionRequest, signal?: AbortSignal): Promise<OpenAIChatCompletionResponse>;
-    chatCompletions(request: OpenAIChatCompletionRequest, signal?: AbortSignal): Promise<OpenAIChatCompletionResponse>;
+    private readonly runner?;
+    constructor(http: HttpClient, runner?: RequestRunner | undefined);
+    private request;
+    createChatCompletion(request: OpenAIChatCompletionRequest & {
+        stream: true;
+    }, signal?: AbortSignal): Promise<OpenAIChatCompletionStream>;
+    createChatCompletion(request: OpenAIChatCompletionRequest & {
+        stream?: false | undefined;
+    }, signal?: AbortSignal): Promise<OpenAIChatCompletionResponse>;
+    chatCompletions(request: OpenAIChatCompletionRequest & {
+        stream: true;
+    }, signal?: AbortSignal): Promise<OpenAIChatCompletionStream>;
+    chatCompletions(request: OpenAIChatCompletionRequest & {
+        stream?: false | undefined;
+    }, signal?: AbortSignal): Promise<OpenAIChatCompletionResponse>;
     listModels(signal?: AbortSignal): Promise<OpenAIListModelsResponse>;
-    createResponses(request: OpenAIResponsesRequest, signal?: AbortSignal): Promise<OpenAIResponsesResponse>;
-    responses(request: OpenAIResponsesRequest, signal?: AbortSignal): Promise<OpenAIResponsesResponse>;
+    retrieveModel(model: string, signal?: AbortSignal): Promise<OpenAIModelItem>;
+    getModel(model: string, signal?: AbortSignal): Promise<OpenAIModelItem>;
+    createCompletion(request: OpenAICompletionRequest & {
+        stream: true;
+    }, signal?: AbortSignal): Promise<OpenAICompletionStream>;
+    createCompletion(request: OpenAICompletionRequest & {
+        stream?: false | undefined;
+    }, signal?: AbortSignal): Promise<OpenAICompletionResponse>;
+    completions(request: OpenAICompletionRequest & {
+        stream: true;
+    }, signal?: AbortSignal): Promise<OpenAICompletionStream>;
+    completions(request: OpenAICompletionRequest & {
+        stream?: false | undefined;
+    }, signal?: AbortSignal): Promise<OpenAICompletionResponse>;
+    createEmbedding(request: OpenAIEmbeddingRequest, signal?: AbortSignal): Promise<OpenAIEmbeddingResponse>;
+    embeddings(request: OpenAIEmbeddingRequest, signal?: AbortSignal): Promise<OpenAIEmbeddingResponse>;
+    createResponses(request: OpenAIResponsesRequest & {
+        stream: true;
+    }, signal?: AbortSignal): Promise<OpenAIResponsesStream>;
+    createResponses(request: OpenAIResponsesRequest & {
+        stream?: false | undefined;
+    }, signal?: AbortSignal): Promise<OpenAIResponsesResponse>;
+    responses(request: OpenAIResponsesRequest & {
+        stream: true;
+    }, signal?: AbortSignal): Promise<OpenAIResponsesStream>;
+    responses(request: OpenAIResponsesRequest & {
+        stream?: false | undefined;
+    }, signal?: AbortSignal): Promise<OpenAIResponsesResponse>;
 }
 
 /**
  * Anthropic Compatibility interfaces and client helpers for Ollama.
- * Ollama supports Anthropic Messages API format.
- *
- * @remarks
- * This is a typed pass-through to Ollama's Anthropic-compatible `/v1/messages` endpoint
- * — a subset of Anthropic's Messages API (text content, system prompt, sampling
- * parameters, ephemeral prompt-caching hints via `cache_control`), not the full Anthropic
- * surface. Tool use (`tool_use`/`tool_result` content blocks), extended thinking,
- * citations, files, token counting, and the Batches API are not modeled here.
+ * Ollama supports the Anthropic Messages API format.
  */
 
 interface AnthropicCacheControl {
     readonly type: 'ephemeral';
+    readonly ttl?: '5m' | '1h' | undefined;
 }
-interface AnthropicContentBlock {
+interface AnthropicTextContentBlock {
     readonly type: 'text';
     readonly text: string;
-    /** Marks this block as a prompt-caching breakpoint (Anthropic's ephemeral cache). */
     readonly cache_control?: AnthropicCacheControl | undefined;
 }
+interface AnthropicImageContentBlock {
+    readonly type: 'image';
+    readonly source: {
+        readonly type: 'base64';
+        readonly media_type: string;
+        readonly data: string;
+    };
+}
+interface AnthropicToolUseContentBlock {
+    readonly type: 'tool_use';
+    readonly id: string;
+    readonly name: string;
+    readonly input: Record<string, unknown>;
+}
+interface AnthropicToolResultContentBlock {
+    readonly type: 'tool_result';
+    readonly tool_use_id: string;
+    readonly content?: string | readonly AnthropicTextContentBlock[] | undefined;
+    readonly is_error?: boolean | undefined;
+}
+interface AnthropicThinkingContentBlock {
+    readonly type: 'thinking';
+    readonly thinking: string;
+    readonly signature?: string | undefined;
+}
+interface AnthropicRedactedThinkingContentBlock {
+    readonly type: 'redacted_thinking';
+    readonly data: string;
+}
+type AnthropicContentBlock = AnthropicTextContentBlock | AnthropicImageContentBlock | AnthropicToolUseContentBlock | AnthropicToolResultContentBlock | AnthropicThinkingContentBlock | AnthropicRedactedThinkingContentBlock;
 interface AnthropicMessage {
     readonly role: 'user' | 'assistant';
     readonly content: string | readonly AnthropicContentBlock[];
 }
+interface AnthropicSystemTextBlock {
+    readonly type: 'text';
+    readonly text: string;
+    readonly cache_control?: AnthropicCacheControl | undefined;
+}
+type AnthropicSystem = string | readonly AnthropicSystemTextBlock[];
+interface AnthropicTool {
+    readonly name: string;
+    readonly description?: string | undefined;
+    readonly input_schema: Record<string, unknown>;
+    readonly eager_input_streaming?: boolean | undefined;
+}
+type AnthropicToolChoice = {
+    readonly type: 'auto';
+    readonly disable_parallel_tool_use?: boolean | undefined;
+} | {
+    readonly type: 'any';
+    readonly disable_parallel_tool_use?: boolean | undefined;
+} | {
+    readonly type: 'tool';
+    readonly name: string;
+    readonly disable_parallel_tool_use?: boolean | undefined;
+} | {
+    readonly type: 'none';
+};
+interface AnthropicThinkingConfig {
+    readonly type: 'enabled' | 'disabled' | 'adaptive';
+    readonly display?: 'omitted' | 'summarized' | 'updates' | undefined;
+    /** Accepted by Ollama for compatibility but currently not enforced by the server. */
+    readonly budget_tokens?: number | undefined;
+}
+interface AnthropicOutputConfig {
+    readonly effort?: string | undefined;
+}
+interface AnthropicMetadata {
+    readonly user_id?: string | undefined;
+}
 interface AnthropicMessagesRequest {
     readonly model: string;
     readonly messages: readonly AnthropicMessage[];
-    readonly system?: string | undefined;
+    readonly system?: AnthropicSystem | undefined;
     readonly max_tokens?: number | undefined;
     readonly temperature?: number | undefined;
     readonly top_p?: number | undefined;
     readonly top_k?: number | undefined;
+    readonly stop_sequences?: readonly string[] | undefined;
     readonly stream?: boolean | undefined;
-}
+    readonly tools?: readonly AnthropicTool[] | undefined;
+    readonly thinking?: AnthropicThinkingConfig | undefined;
+    readonly output_config?: AnthropicOutputConfig | undefined;
+    /**
+     * Accepted for Anthropic compatibility but currently ignored by Ollama.
+     * Tool selection cannot be forced through the Ollama compatibility endpoint.
+     */
+    readonly tool_choice?: AnthropicToolChoice | undefined;
+    /** Accepted for compatibility but currently ignored by Ollama. */
+    readonly metadata?: AnthropicMetadata | undefined;
+}
+/** Strict Ollama-documented Messages request; excludes fields Ollama marks unsupported. */
+type OllamaAnthropicTextContentBlock = Omit<AnthropicTextContentBlock, 'cache_control'>;
+type OllamaAnthropicTool = Omit<AnthropicTool, 'eager_input_streaming'>;
+type OllamaAnthropicThinkingConfig = {
+    readonly type: 'enabled' | 'disabled';
+    /** Accepted by Ollama for compatibility but currently not enforced by the server. */
+    readonly budget_tokens?: number | undefined;
+};
+type OllamaAnthropicToolResultContentBlock = Omit<AnthropicToolResultContentBlock, 'content'> & {
+    readonly content?: string | readonly OllamaAnthropicTextContentBlock[] | undefined;
+};
+type OllamaAnthropicContentBlock = OllamaAnthropicTextContentBlock | AnthropicImageContentBlock | AnthropicToolUseContentBlock | OllamaAnthropicToolResultContentBlock | AnthropicThinkingContentBlock;
+type OllamaAnthropicMessage = Omit<AnthropicMessage, 'content'> & {
+    readonly content: string | readonly OllamaAnthropicContentBlock[];
+};
+type OllamaAnthropicSystemTextBlock = Omit<AnthropicSystemTextBlock, 'cache_control'>;
+type OllamaAnthropicSystem = string | readonly OllamaAnthropicSystemTextBlock[];
+/** Strict Ollama-documented Messages request; excludes unsupported caching/tool-choice metadata. */
+type OllamaAnthropicMessagesRequest = Omit<AnthropicMessagesRequest, 'messages' | 'system' | 'tools' | 'thinking' | 'tool_choice' | 'metadata'> & {
+    readonly messages: readonly OllamaAnthropicMessage[];
+    readonly system?: OllamaAnthropicSystem | undefined;
+    readonly tools?: readonly OllamaAnthropicTool[] | undefined;
+    readonly thinking?: OllamaAnthropicThinkingConfig | undefined;
+};
 interface AnthropicMessagesResponse {
     readonly id: string;
     readonly type: 'message';
     readonly role: 'assistant';
     readonly content: readonly AnthropicContentBlock[];
     readonly model: string;
-    readonly stop_reason: string;
+    readonly stop_reason: string | null;
+    readonly stop_sequence?: string | null | undefined;
     readonly usage?: {
         readonly input_tokens: number;
         readonly output_tokens: number;
+        readonly cache_creation_input_tokens?: number | undefined;
+        readonly cache_read_input_tokens?: number | undefined;
+        readonly cache_creation?: Record<string, unknown> | undefined;
     } | undefined;
 }
+interface AnthropicMessageStartEvent {
+    readonly type: 'message_start';
+    readonly message: AnthropicMessagesResponse;
+}
+interface AnthropicContentBlockStartEvent {
+    readonly type: 'content_block_start';
+    readonly index: number;
+    readonly content_block: AnthropicContentBlock;
+}
+type AnthropicContentBlockDelta = {
+    readonly type: 'text_delta';
+    readonly text: string;
+} | {
+    readonly type: 'input_json_delta';
+    readonly partial_json: string;
+} | {
+    readonly type: 'thinking_delta';
+    readonly thinking: string;
+} | {
+    readonly type: 'signature_delta';
+    readonly signature: string;
+};
+interface AnthropicContentBlockDeltaEvent {
+    readonly type: 'content_block_delta';
+    readonly index: number;
+    readonly delta: AnthropicContentBlockDelta;
+}
+interface AnthropicContentBlockStopEvent {
+    readonly type: 'content_block_stop';
+    readonly index: number;
+}
+interface AnthropicMessageDeltaEvent {
+    readonly type: 'message_delta';
+    readonly delta: {
+        readonly stop_reason?: string | null | undefined;
+        readonly stop_sequence?: string | null | undefined;
+    };
+    readonly usage?: {
+        readonly input_tokens?: number | undefined;
+        readonly output_tokens: number;
+        readonly cache_creation_input_tokens?: number | undefined;
+        readonly cache_read_input_tokens?: number | undefined;
+        readonly cache_creation?: Record<string, unknown> | undefined;
+    } | undefined;
+}
+interface AnthropicMessageStopEvent {
+    readonly type: 'message_stop';
+}
+interface AnthropicPingEvent {
+    readonly type: 'ping';
+}
+interface AnthropicErrorEvent {
+    readonly type: 'error';
+    readonly error: {
+        readonly type: string;
+        readonly message: string;
+    };
+}
+interface AnthropicUnknownStreamEvent {
+    /** Forward-compatible event type not yet modeled by this SDK. */
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+type AnthropicMessageStreamEvent = AnthropicMessageStartEvent | AnthropicContentBlockStartEvent | AnthropicContentBlockDeltaEvent | AnthropicContentBlockStopEvent | AnthropicMessageDeltaEvent | AnthropicMessageStopEvent | AnthropicPingEvent | AnthropicErrorEvent | AnthropicUnknownStreamEvent;
+declare class AnthropicMessagesStream implements AsyncIterable<AnthropicMessageStreamEvent> {
+    private readonly source;
+    private readonly finalResultPromise;
+    private resolveFinal;
+    private rejectFinal;
+    private removeAbortListener;
+    constructor(source: AbortableAsyncIterable<SseEvent>, signal?: AbortSignal);
+    get finalResult(): Promise<AnthropicMessagesResponse>;
+    abort(): void;
+    [Symbol.asyncIterator](): AsyncGenerator<AnthropicMessageStreamEvent, void, undefined>;
+}
 declare class AnthropicCompatClient {
     private readonly http;
-    constructor(http: HttpClient);
-    createMessage(request: AnthropicMessagesRequest, signal?: AbortSignal): Promise<AnthropicMessagesResponse>;
-    messages(request: AnthropicMessagesRequest, signal?: AbortSignal): Promise<AnthropicMessagesResponse>;
+    private readonly runner?;
+    constructor(http: HttpClient, runner?: RequestRunner | undefined);
+    private request;
+    createMessage(request: AnthropicMessagesRequest & {
+        stream: true;
+    }, signal?: AbortSignal): Promise<AnthropicMessagesStream>;
+    createMessage(request: AnthropicMessagesRequest & {
+        stream?: false | undefined;
+    }, signal?: AbortSignal): Promise<AnthropicMessagesResponse>;
+    createMessage(request: AnthropicMessagesRequest, signal?: AbortSignal): Promise<AnthropicMessagesResponse | AnthropicMessagesStream>;
+    messages(request: AnthropicMessagesRequest & {
+        stream: true;
+    }, signal?: AbortSignal): Promise<AnthropicMessagesStream>;
+    messages(request: AnthropicMessagesRequest & {
+        stream?: false | undefined;
+    }, signal?: AbortSignal): Promise<AnthropicMessagesResponse>;
+    messages(request: AnthropicMessagesRequest, signal?: AbortSignal): Promise<AnthropicMessagesResponse | AnthropicMessagesStream>;
 }
 
+/**
+ * High-level Ollama client — the original, hand-written API surface.
+ *
+ * **Wave 8 (ADR 0018) deprecation notice:**
+ *
+ * For new code, prefer the generated `NativeApi` from
+ * {@link ./generated/runtime/runtime.js} + {@link ./generated/api/native-api.js}
+ * instead. The generated surface:
+ *
+ *   - Inherits every contract-layer guarantee (environment guards, version
+ *     guards, streaming defaults) automatically from the canonical IR.
+ *   - Stays in sync with the OpenAPI spec by construction — no hand-written
+ *     surface to drift.
+ *   - Uses the same `HttpClient` (and therefore the same middleware,
+ *     retry, telemetry, and streaming pipeline) as this client.
+ *
+ * The migration path is non-breaking:
+ *
+ * ```ts
+ * // Before (still works, no breaking changes):
+ * const client = new OllamaClient({ baseUrl: 'http://localhost:11434' });
+ * const res = await client.chat({ model, messages });
+ *
+ * // After (recommended for new code):
+ * const http = new HttpClient({ baseUrl: 'http://localhost:11434' });
+ * const runtime = new OllamaRuntime({ http });
+ * const api = new NativeApi(runtime);
+ * const res = await api.chat({ model, messages, stream: false });
+ * ```
+ *
+ * `OllamaClient` is preserved verbatim — existing callers do not need to
+ * change anything. New methods and operations will land on the generated
+ * surface first; `OllamaClient` will receive them only as a follow-up.
+ */
 declare class OllamaClient {
     readonly registry: EndpointRegistry;
     readonly models: ModelsClient;
@@ -1010,6 +1342,8 @@ declare class OllamaClient {
     private readonly failoverCodes;
     private readonly fetchImpl;
     private readonly logger;
+    private readonly middleware;
+    private readonly onLifecycleEvent;
     /**
      * API key for Ollama's hosted web tools (`webSearch`/`webFetch`), which always target
      * `OLLAMA_CLOUD_BASE_URL` regardless of `config.endpoints` — an Ollama account API key
@@ -1020,6 +1354,31 @@ declare class OllamaClient {
     private readonly cloudApiKey;
     constructor(config?: OllamaClientConfig);
     get modelsClient(): ModelsClient;
+    /**
+     * Return a generated {@link OllamaRuntime} that shares this client's
+     * transport (HttpClient + middleware + retry + telemetry).
+     *
+     * Wave 8 (ADR 0018) bridge: lets callers mix the existing `OllamaClient`
+     * API with the generated `NativeApi` / `OpenAIApi` / `AnthropicApi`
+     * surface without configuring two separate HttpClient instances.
+     *
+     * The returned runtime is bound to the registry's first candidate
+     * endpoint (or the resolved single-endpoint config if no `endpoints`
+     * array was provided). For multi-endpoint configs that need per-call
+     * routing, prefer constructing `OllamaRuntime` directly with a
+     * specific HttpClient:
+     *
+     * ```ts
+     * const http = new HttpClient({ baseUrl: 'http://host-a:11434' });
+     * const runtime = new OllamaRuntime({ http });
+     * const api = new NativeApi(runtime);
+     * ```
+     *
+     * The runtime is cached on first call — subsequent calls return the
+     * same instance.
+     */
+    get runtime(): OllamaRuntime;
+    private _runtime;
     /**
      * Fail-fast guard for `format` (structured output) requests: throws before any network
      * call if the candidate endpoint is inferred as Ollama Cloud, which does not currently
@@ -1120,7 +1479,7 @@ declare class OllamaClient {
      * multi-candidate loop, since `webSearch`/`webFetch` only ever have the one endpoint.
      */
     private executeCloudRequest;
-    capabilities(model: string): Promise<ModelCapabilities>;
+    capabilities(model: string, signal?: AbortSignal): Promise<ModelCapabilities>;
     runtimeMode(): RuntimeMode;
     healthCheck(): Promise<EndpointHealthCheckResult[]>;
     endpointStatus(): EndpointHealth[];
@@ -1144,9 +1503,9 @@ declare function createTimeoutSignal(timeoutMs?: number, userSignal?: AbortSigna
  * Normalization mappers and aggregators for Ollama streaming responses.
  */
 
-declare function normalizeChatStream(source: AbortableAsyncIterable<ChatResponse>): OllamaStream<ChatResponse, ChatStreamResult>;
-declare function normalizeGenerateStream(source: AbortableAsyncIterable<GenerateResponse>): OllamaStream<GenerateResponse, GenerateStreamResult>;
-declare function normalizeProgressStream(source: AbortableAsyncIterable<ProgressResponse>): OllamaStream<ProgressResponse, ProgressStreamResult>;
+declare function normalizeChatStream(source: AbortableAsyncIterable<ChatResponse>, signal?: AbortSignal): OllamaStream<ChatResponse, ChatStreamResult>;
+declare function normalizeGenerateStream(source: AbortableAsyncIterable<GenerateResponse>, signal?: AbortSignal): OllamaStream<GenerateResponse, GenerateStreamResult>;
+declare function normalizeProgressStream(source: AbortableAsyncIterable<ProgressResponse>, signal?: AbortSignal): OllamaStream<ProgressResponse, ProgressStreamResult>;
 
 /**
  * NDJSON (newline-delimited JSON) stream reader for native fetch Response bodies.
@@ -1294,44 +1653,36 @@ interface DefineToolOptions<TParams, TResult> {
  */
 declare function defineTool<TParams, TResult>(options: DefineToolOptions<TParams, TResult>): Tool<TParams, TResult>;
 
-/**
- * Duck-typed MCP (Model Context Protocol) client interfaces.
- * Decoupled from any specific MCP SDK.
- */
-interface McpToolDescriptor {
-    readonly name: string;
-    readonly description?: string;
-    readonly inputSchema?: Record<string, unknown>;
-}
-interface McpListToolsResult {
-    readonly tools: readonly McpToolDescriptor[];
-}
-interface McpContentBlock {
-    readonly type: string;
-    readonly text?: string;
-    readonly [key: string]: unknown;
-}
-interface McpCallToolResult {
-    readonly content: readonly McpContentBlock[];
-    readonly isError?: boolean;
-}
-interface McpClientLike {
-    listTools: () => Promise<McpListToolsResult>;
-    callTool: (params: {
-        readonly name: string;
-        readonly arguments?: Record<string, unknown>;
-    }) => Promise<McpCallToolResult>;
-}
-
 /**
  * Converts MCP tools into Ollama-compatible tools.
  */
 
+type McpToolResultMode = 'text' | 'structured';
 interface LoadMcpToolsOptions {
-    readonly namePrefix?: string;
+    readonly namePrefix?: string | undefined;
+    /** Maximum number of paginated tools/list responses to traverse. */
+    readonly maxPages?: number | undefined;
+    /**
+     * Return MCP's raw CallToolResult to programmatic callers instead of the legacy
+     * model-oriented text representation. The default preserves existing behavior.
+     */
+    readonly resultMode?: McpToolResultMode | undefined;
+}
+declare function listAllMcpTools(mcpClient: McpClientLike, options?: LoadMcpToolsOptions, signal?: AbortSignal): Promise<McpToolDescriptor[]>;
+declare function loadMcpTools(mcpClient: McpClientLike, options?: LoadMcpToolsOptions, signal?: AbortSignal): Promise<AnyTool[]>;
+declare function registerMcpTools(registry: ToolRegistry, mcpClient: McpClientLike, options?: LoadMcpToolsOptions, signal?: AbortSignal): Promise<void>;
+
+type McpBridgeOptions = LoadMcpToolsOptions;
+declare class McpBridge {
+    private readonly client;
+    private readonly options;
+    constructor(client: McpClientLike, options?: McpBridgeOptions);
+    static toOllamaTools(tools: readonly McpToolDescriptor[], options?: McpBridgeOptions): ToolDefinition[];
+    listTools(signal?: AbortSignal): Promise<readonly McpToolDescriptor[]>;
+    definitions(signal?: AbortSignal): Promise<ToolDefinition[]>;
+    loadTools(signal?: AbortSignal): Promise<AnyTool[]>;
+    register(registry: ToolRegistry, signal?: AbortSignal): Promise<void>;
 }
-declare function loadMcpTools(mcpClient: McpClientLike, options?: LoadMcpToolsOptions): Promise<AnyTool[]>;
-declare function registerMcpTools(registry: ToolRegistry, mcpClient: McpClientLike, options?: LoadMcpToolsOptions): Promise<void>;
 
 /**
  * Agent loop options, turn state, and execution hooks.
@@ -1359,13 +1710,22 @@ interface AgentHooks {
 interface AgentConfig {
     readonly tools?: ToolRegistry | undefined;
     readonly maxIterations?: number | undefined;
+    /** Maximum total tool calls allowed during one agent run. */
+    readonly maxToolCalls?: number | undefined;
     readonly hooks?: AgentHooks | undefined;
+    /** Validate tool support from /api/show before starting a tool-enabled run. Default: true. */
+    readonly validateToolCapability?: boolean | undefined;
+    /**
+     * Automatic context size for tool-enabled runs when options.num_ctx is not supplied.
+     * Defaults to 32768 and is clamped to the model-reported maximum when available.
+     */
+    readonly toolContextSize?: number | undefined;
 }
 interface AgentRunInput {
     readonly model: string;
     readonly messages: readonly Message[];
     readonly options?: ModelOptions | undefined;
-    readonly think?: boolean | 'low' | 'medium' | 'high' | 'max' | undefined;
+    readonly think?: ThinkValue | undefined;
     readonly signal?: AbortSignal | undefined;
 }
 
@@ -1374,12 +1734,13 @@ interface AgentRunInput {
  */
 
 interface AgentChatClient {
+    capabilities?: ((model: string, signal?: AbortSignal) => Promise<ModelCapabilities>) | undefined;
     chat(request: {
         readonly model: string;
         readonly messages: readonly Message[];
         readonly tools?: readonly ToolDefinition[] | undefined;
         readonly options?: ModelOptions | undefined;
-        readonly think?: boolean | 'low' | 'medium' | 'high' | 'max' | undefined;
+        readonly think?: ThinkValue | undefined;
         readonly stream?: false | undefined;
         readonly signal?: AbortSignal | undefined;
     }): Promise<{
@@ -1390,9 +1751,9 @@ interface AgentChatClient {
  * Runs a multi-turn `chat` + tool-execution loop until the model responds without
  * requesting further tool calls, or `maxIterations` is exceeded. Tool calls within a
  * single turn are handed to `ToolRegistry.executeToolCalls` and their results are
- * appended to history in the same order the model requested them, each tagged with the
- * originating call's `tool_call_id` — see the {@link ToolCall} type docs for how that id
- * is produced (Ollama's native tool-calling protocol has none; this SDK synthesizes one).
+ * appended to history in the same order the model requested them. Native Ollama tool-result
+ * messages use `tool_name` on the wire; the SDK-generated `toolCallId` remains execution
+ * metadata and is not sent to Ollama.
  * `Agent` assigns ids defensively even when `AgentChatClient` isn't `OllamaClient` (e.g. a
  * custom/test implementation), so this guarantee holds regardless of which chat client is
  * supplied.
@@ -1401,7 +1762,10 @@ declare class Agent {
     private readonly client;
     private readonly tools?;
     private readonly maxIterations;
+    private readonly maxToolCalls?;
     private readonly hooks?;
+    private readonly validateToolCapability;
+    private readonly toolContextSize;
     constructor(client: AgentChatClient, config?: AgentConfig);
     run(input: AgentRunInput): Promise<AgentResult>;
     private runLoop;
@@ -1476,4 +1840,4 @@ declare const GEN_AI_SYSTEM_OLLAMA = "ollama";
  */
 declare function encodeImage(image: Uint8Array | string): Promise<string>;
 
-export { ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_REQUEST_MODEL, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_USAGE_INPUT_TOKENS, ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_OLLAMA_AGENT_ITERATION, ATTR_OLLAMA_AGENT_MAX_ITERATIONS, ATTR_OLLAMA_ENDPOINT_ATTEMPT, ATTR_OLLAMA_ENDPOINT_NAME, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_URL_FULL, type AbortableAsyncIterable, Agent, type AgentChatClient, type AgentConfig, type AgentHooks, type AgentResult, type AgentRunInput, type AgentTurn, type AnthropicCacheControl, AnthropicCompatClient, type AnthropicContentBlock, type AnthropicMessage, type AnthropicMessagesRequest, type AnthropicMessagesResponse, AnyTool, type BackoffOptions, ChatRequestOptions, ChatResponse, type ChatStreamResult, CopyRequestOptions, CreateRequestOptions, DEFAULT_BACKOFF, DEFAULT_BASE_URL, DEFAULT_FAILOVER_CODES, DEFAULT_RETRY_CONFIG, DEFAULT_TIMEOUT_MS, type DefineToolOptions, DeleteRequestOptions, type DoneEvent, EmbedRequestOptions, EmbedResponse, EmbeddingsRequestOptions, EmbeddingsResponse, type EndpointHealth, type EndpointHealthCheckResult, EndpointRegistry, type EndpointRegistryOptions, type ErrorEvent, type FetchLike, GEN_AI_SYSTEM_OLLAMA, GenerateRequestOptions, GenerateResponse, type GenerateStreamResult, type HttpBody, HttpClient, type HttpClientOptions, type HttpRequestOptions, type LifecycleErrorEvent, type LifecycleRetryEvent, type LifecycleStartEvent, type LifecycleSuccessEvent, type LoadMcpToolsOptions, type LogFn, type Logger, type McpCallToolResult, type McpClientLike, type McpContentBlock, type McpListToolsResult, type McpToolDescriptor, Message, type MessageEvent, type Middleware, type MiddlewareContext, type ModelCapabilities, ModelOptions, ModelResponse, ModelsClient, NANOS_PER_MS, NANOS_PER_SECOND, NOOP_LOGGER, type NextFunction, OLLAMA_CLOUD_BASE_URL, OllamaAbortError, OllamaAgentMaxIterationsError, OllamaAuthError, OllamaClient, type OllamaClientConfig, OllamaClientError, type OllamaClientErrorOptions, type OllamaCloudFreeTierQuotaBudgets, type OllamaCredentialConfig, type OllamaEndpoint, type OllamaErrorRequestContext, type OllamaErrorResponseContext, OllamaGenericClientError, OllamaMcpError, OllamaModelRoutingError, OllamaNetworkError, OllamaNotFoundError, OllamaQuotaExceededError, OllamaRateLimitError, OllamaServerError, OllamaSkillInvalidError, OllamaSkillNotFoundError, OllamaStream, type OllamaStreamEvent, type OllamaStreamEventType, OllamaTimeoutError, OllamaToolTimeoutError, OllamaToolValidationError, OllamaUnsupportedCapabilityError, type OpenAIChatCompletionChoice, type OpenAIChatCompletionRequest, type OpenAIChatCompletionResponse, OpenAICompatClient, type OpenAIFunctionDefinition, type OpenAIListModelsResponse, type OpenAIMessage, type OpenAIModelItem, type OpenAIResponsesOutputMessage, type OpenAIResponsesOutputTextContent, type OpenAIResponsesRequest, type OpenAIResponsesResponse, type OpenAIStreamOptions, type OpenAITool, type OpenAIToolCall, ProgressResponse, type ProgressStreamResult, PsResponse, PullRequestOptions, PushRequestOptions, QuotaManager, type QuotaManagerOptions, type QuotaWindowConfig, type QuotaWindowStatus, type RawUsageSource, type RequestContext, type RequestLifecycleEvent, type RequestLifecycleHook, type RequestRunner, type ResponseContext, type RetryConfig, type RuntimeMode, ShowRequestOptions, ShowResponse, type SpanAttributeValue, type SpanAttributes, StatusResponse, type SupportedSchema, type ThinkingEvent, type TimeoutSignal, type TokenEvent, type TokenUsage, Tool, ToolCall, type ToolCallEvent, ToolDefinition, ToolExecutionResult, ToolHandler, ToolRegistry, VersionResponse, WebFetchRequestOptions, WebFetchResponse, WebSearchRequestOptions, WebSearchResponse, addSpanEvent, calculateBackoff, checkEndpointHealth, composeMiddleware, createConsoleLogger, createOllamaCloudFreeTierQuota, createTimeoutSignal, defineTool, detectModelCapabilities, encodeImage, extractUsage, inferRuntimeMode, listAvailableModels, loadMcpTools, mapError, normalizeChatStream, normalizeGenerateStream, normalizeProgressStream, parseNdjsonStream, parseStructuredOutput, registerMcpTools, resolveCredentialEndpoints, setSpanError, toDataStream, toResponse, toTextStream, withRetry, withSpan, zodToJsonSchema };
+export { ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_REQUEST_MODEL, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_USAGE_INPUT_TOKENS, ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_OLLAMA_AGENT_ITERATION, ATTR_OLLAMA_AGENT_MAX_ITERATIONS, ATTR_OLLAMA_ENDPOINT_ATTEMPT, ATTR_OLLAMA_ENDPOINT_NAME, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_URL_FULL, AbortableAsyncIterable, Agent, type AgentChatClient, type AgentConfig, type AgentHooks, type AgentResult, type AgentRunInput, type AgentTurn, type AnthropicCacheControl, AnthropicCompatClient, type AnthropicContentBlock, type AnthropicImageContentBlock, type AnthropicMessage, type AnthropicMessageStreamEvent, type AnthropicMessagesRequest, type AnthropicMessagesResponse, AnthropicMessagesStream, type AnthropicMetadata, type AnthropicOutputConfig, type AnthropicRedactedThinkingContentBlock, type AnthropicSystem, type AnthropicSystemTextBlock, type AnthropicTextContentBlock, type AnthropicThinkingConfig, type AnthropicThinkingContentBlock, type AnthropicTool, type AnthropicToolChoice, type AnthropicToolResultContentBlock, type AnthropicToolUseContentBlock, type AnthropicUnknownStreamEvent, AnyTool, type BackoffOptions, ChatRequestOptions, ChatResponse, ChatStreamResult, CopyRequestOptions, CreateRequestOptions, DEFAULT_BACKOFF, DEFAULT_BASE_URL, DEFAULT_FAILOVER_CODES, DEFAULT_RETRY_CONFIG, DEFAULT_TIMEOUT_MS, type DefineToolOptions, DeleteRequestOptions, EmbedRequestOptions, EmbedResponse, EmbeddingsRequestOptions, EmbeddingsResponse, type EndpointHealth, type EndpointHealthCheckResult, EndpointRegistry, type EndpointRegistryOptions, FetchLike, GEN_AI_SYSTEM_OLLAMA, GenerateRequestOptions, GenerateResponse, GenerateStreamResult, HttpClient, type LoadMcpToolsOptions, Logger, McpBridge, type McpBridgeOptions, McpClientLike, McpToolDescriptor, Message, Middleware, type ModelCapabilities, ModelOptions, ModelResponse, ModelsClient, OLLAMA_CLOUD_BASE_URL, type OllamaAnthropicContentBlock, type OllamaAnthropicMessage, type OllamaAnthropicMessagesRequest, type OllamaAnthropicSystem, type OllamaAnthropicSystemTextBlock, type OllamaAnthropicTextContentBlock, type OllamaAnthropicThinkingConfig, type OllamaAnthropicTool, type OllamaAnthropicToolResultContentBlock, OllamaClient, type OllamaClientConfig, OllamaClientError, type OllamaCloudFreeTierQuotaBudgets, type OllamaCredentialConfig, type OllamaEndpoint, type OllamaOpenAIChatCompletionRequest, type OllamaOpenAICompletionRequest, type OllamaOpenAIEmbeddingRequest, type OllamaOpenAIReasoningEffort, type OllamaOpenAIResponsesRequest, OllamaStream, OllamaStreamEvent, OllamaStreamEventType, type OpenAIChatCompletionChoice, type OpenAIChatCompletionChunk, type OpenAIChatCompletionChunkChoice, type OpenAIChatCompletionDelta, type OpenAIChatCompletionRequest, type OpenAIChatCompletionResponse, OpenAIChatCompletionStream, OpenAICompatClient, type OpenAICompletionChoice, type OpenAICompletionChunk, type OpenAICompletionRequest, type OpenAICompletionResponse, OpenAICompletionStream, type OpenAIContentPart, type OpenAIEmbeddingInput, type OpenAIEmbeddingItem, type OpenAIEmbeddingRequest, type OpenAIEmbeddingResponse, type OpenAIFunctionDefinition, type OpenAIImageUrlContentPart, type OpenAIListModelsResponse, type OpenAIMessage, type OpenAIModelItem, type OpenAIReasoningEffort, type OpenAIResponseFormat, type OpenAIResponsesCompletedEvent, type OpenAIResponsesContentPartAddedEvent, type OpenAIResponsesContentPartDoneEvent, type OpenAIResponsesCreatedEvent, type OpenAIResponsesError, type OpenAIResponsesEventBase, type OpenAIResponsesFailedEvent, type OpenAIResponsesFunctionCallArgumentsDeltaEvent, type OpenAIResponsesFunctionCallArgumentsDoneEvent, type OpenAIResponsesInProgressEvent, type OpenAIResponsesIncompleteDetails, type OpenAIResponsesIncompleteEvent, type OpenAIResponsesOutputContent, type OpenAIResponsesOutputFunctionCall, type OpenAIResponsesOutputItem, type OpenAIResponsesOutputItemAddedEvent, type OpenAIResponsesOutputItemDoneEvent, type OpenAIResponsesOutputMessage, type OpenAIResponsesOutputReasoning, type OpenAIResponsesOutputRefusal, type OpenAIResponsesOutputTextContent, type OpenAIResponsesOutputTextDeltaEvent, type OpenAIResponsesOutputTextDoneEvent, type OpenAIResponsesQueuedEvent, type OpenAIResponsesReasoningSummaryPartAddedEvent, type OpenAIResponsesReasoningSummaryPartDoneEvent, type OpenAIResponsesReasoningSummaryTextDeltaEvent, type OpenAIResponsesReasoningSummaryTextDoneEvent, type OpenAIResponsesReasoningTextDeltaEvent, type OpenAIResponsesReasoningTextDoneEvent, type OpenAIResponsesRefusalDeltaEvent, type OpenAIResponsesRefusalDoneEvent, type OpenAIResponsesRequest, type OpenAIResponsesResponse, type OpenAIResponsesStatus, OpenAIResponsesStream, OpenAIResponsesStreamError, type OpenAIResponsesStreamEvent, type OpenAIResponsesUsage, type OpenAIStreamOptions, type OpenAITextContentPart, type OpenAITool, type OpenAIToolCall, type OpenAIToolCallDelta, type OpenAIUsage, ProgressResponse, ProgressStreamResult, PsResponse, PullRequestOptions, PushRequestOptions, QuotaManager, type QuotaManagerOptions, type QuotaWindowConfig, type QuotaWindowStatus, RawUsageSource, RequestLifecycleHook, type RequestRunner, type RetryConfig, type RuntimeMode, ShowRequestOptions, ShowResponse, type SpanAttributeValue, type SpanAttributes, SseEvent, StatusResponse, type SupportedSchema, ThinkValue, ThinkingMetadata, type TimeoutSignal, TokenUsage, Tool, ToolCall, ToolDefinition, ToolExecutionResult, ToolHandler, ToolRegistry, VersionResponse, WebFetchRequestOptions, WebFetchResponse, WebSearchRequestOptions, WebSearchResponse, addSpanEvent, calculateBackoff, checkEndpointHealth, createOllamaCloudFreeTierQuota, createTimeoutSignal, defineTool, detectModelCapabilities, encodeImage, inferRuntimeMode, listAllMcpTools, listAvailableModels, loadMcpTools, normalizeChatStream, normalizeGenerateStream, normalizeProgressStream, parseNdjsonStream, parseStructuredOutput, registerMcpTools, resolveCredentialEndpoints, setSpanError, toDataStream, toResponse, toTextStream, withRetry, withSpan, zodToJsonSchema };