@nemesis-oss/ollama-sdk 1.1.0 → 1.4.0

package/dist/index.d.cts

@@ -1,307 +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-DJjVpDrk.cjs';
-export { w as AppliedSkillResult, x as ApplySkillOptions, F as FormatOption, L as ListResponse, y as ModelDetails, z as ParsedFrontmatter, R as RequestCancellationOptions, B as Role, H as Skill, I as SkillFrontmatter, J as SkillSummary, K as ToolCallFunction, N as ToolExecutionContext, O as ToolExecutionFailure, Q as ToolExecutionSuccess, U as ToolFunctionDefinition, X as ToolProperty, Y as ToolRegistryOptions, Z as WebSearchResult, _ as applySkill, $ as parseFrontmatter } from './compose-DJjVpDrk.cjs';
+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-2RIErNT5.cjs';
+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-2RIErNT5.cjs';
+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.cjs';
+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.cjs';
 import { z } from 'zod';
+import { T as ToolHandler, e as Tool, f as AnyTool, g as ToolRegistry, h as ToolExecutionResult } from './compose-BR70yb4W.cjs';
+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-BR70yb4W.cjs';
+import { a as McpClientLike, M as McpToolDescriptor } from './types-B9_axjum.cjs';
+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.cjs';
 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);
-}
-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;
-    });
-}
-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.
  */
@@ -330,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.
@@ -373,17 +48,67 @@ interface OllamaEndpoint {
     readonly apiKey?: string | undefined;
     readonly headers?: Record<string, string> | undefined;
     readonly priority?: number | undefined;
+    /**
+     * Restricts this endpoint/credential to a specific set of models — for the common case
+     * of several Ollama Cloud API keys, each entitled to a different model. When set,
+     * `EndpointRegistry.candidates(model)` only returns this endpoint for a request whose
+     * `model` is in the list, so cross-endpoint failover never retries a request against a
+     * credential that isn't authorized for the requested model. Omit (the default) to make
+     * the endpoint eligible for every model, preserving prior behavior.
+     */
+    readonly models?: readonly string[] | undefined;
 }
 interface EndpointHealth {
     readonly endpoint: OllamaEndpoint;
     readonly failureCount: number;
     readonly lastFailureTimestamp?: number | undefined;
     readonly isCoolingDown: boolean;
+    /** In-flight requests currently attempting this endpoint — see `acquire`/`release`. */
+    readonly activeRequests: number;
 }
 interface EndpointRegistryOptions {
     readonly failureThreshold?: number | undefined;
     readonly cooldownMs?: number | undefined;
     readonly now?: (() => number) | undefined;
+    /**
+     * How candidates that share the same `priority` are ordered within `candidates()`.
+     * `'priority'` (the default) keeps them in registration order, so the same candidate is
+     * always tried first while it stays healthy. `'round-robin'` rotates each same-priority
+     * group by one position per `candidates()` call — i.e. per `chat`/`generate`/etc. call —
+     * so consecutive requests spread across a pool of interchangeable endpoints/credentials
+     * instead of always preferring the first one (the common case: several Ollama Cloud keys
+     * registered with no `models` restriction, meant to be used interchangeably). Endpoints
+     * at different priorities are unaffected either way — a higher-priority one is still
+     * always tried first, and failover to the rest of the group still applies if the
+     * rotated-to-front candidate fails.
+     *
+     * `'least-connections'` instead orders each same-priority group by ascending in-flight
+     * request count (tracked via `acquire`/`release`, ties broken by registration order),
+     * so a request always prefers whichever candidate currently has the fewest requests
+     * still in progress. Unlike `'round-robin'`, this remains correct under uneven or
+     * overlapping request durations — e.g. several Ollama Cloud accounts each limited to 1
+     * concurrent request: firing several requests at once (`Promise.all`) deterministically
+     * lands each on a different account rather than risking two landing on the same
+     * still-busy one, because `candidates()` and the subsequent `acquire()` for the chosen
+     * candidate run synchronously with no `await` in between — JS's single-threaded
+     * execution means no two concurrent calls can observe the same "0 active" snapshot for
+     * the same candidate.
+     */
+    readonly strategy?: 'priority' | 'round-robin' | 'least-connections' | undefined;
+    /**
+     * Caps in-flight requests per endpoint (tracked via `acquire`/`release`). Unset (the
+     * default) means no cap — candidates are never treated as saturated. When set, a
+     * request whose every otherwise-eligible candidate is already at this cap waits
+     * (`waitForCapacity`, FIFO per candidate) for one of them to free up, instead of being
+     * sent to an already-saturated candidate. Pairs naturally with `strategy:
+     * 'least-connections'` for a pool of accounts each limited to N concurrent requests —
+     * e.g. `maxConcurrentPerEndpoint: 1` for several Ollama Cloud free-tier accounts, so
+     * `N + 1` concurrent calls against `N` such accounts run `N` immediately and queue the
+     * rest, rather than the `(N+1)`th overrunning whichever account looks "least busy" at
+     * that instant. Waiting is bounded by the request's own timeout/`AbortSignal`, same as
+     * any other in-flight request — it never blocks indefinitely on its own.
+     */
+    readonly maxConcurrentPerEndpoint?: number | undefined;
 }
 declare class EndpointRegistry {
     private readonly endpoints;
@@ -392,11 +117,66 @@ declare class EndpointRegistry {
     private readonly failureThreshold;
     private readonly cooldownMs;
     private readonly now;
+    private readonly strategy;
+    private roundRobinCounter;
+    private readonly activeCounts;
+    private readonly maxConcurrentPerEndpoint;
+    private readonly waiters;
     constructor(endpoints: readonly OllamaEndpoint[], options?: EndpointRegistryOptions);
-    candidates(): OllamaEndpoint[];
+    /**
+     * Marks one more request as in-flight against `name`. Callers (`OllamaClient`) must
+     * pair every `acquire` with a `release` once that attempt finishes, success or not —
+     * see `OllamaClient.executeWithFailover`. Only affects candidate ordering when
+     * `strategy` is `'least-connections'`; harmless (just bookkeeping) otherwise, and
+     * always reflected in `status()`'s `activeRequests`.
+     */
+    acquire(name: string): void;
+    /** Releases one in-flight request marked via `acquire`, waking one waiter for `name` if any. */
+    release(name: string): void;
+    /**
+     * `candidates` filtered down to those currently under `maxConcurrentPerEndpoint` (all
+     * of them, unchanged, if that option is unset).
+     */
+    filterWithCapacity(candidates: readonly OllamaEndpoint[]): OllamaEndpoint[];
+    /**
+     * Resolves once any endpoint named in `names` has spare capacity under
+     * `maxConcurrentPerEndpoint` (a no-op resolve if that option is unset, or if one
+     * already does). Otherwise queues (FIFO per name) until a matching `release()` frees a
+     * slot, or rejects if `signal` aborts first — mirroring whatever aborted it
+     * (`OllamaTimeoutError`/the caller's own abort reason) so callers see the same error
+     * shape as any other in-flight request that times out or is cancelled. FIFO order is
+     * best-effort (a newly-arriving request can still win a race for a slot that just
+     * freed) — the capacity cap itself, not fairness, is the guarantee this exists for.
+     */
+    waitForCapacity(names: readonly string[], signal?: AbortSignal): Promise<void>;
+    /**
+     * Rotates each same-`priority` group in `sorted` (already sorted highest-priority-first)
+     * by one position further per call, wrapping around within the group. Priority tiers
+     * themselves are never reordered — only candidates that were already tied.
+     */
+    private applyRoundRobin;
+    /**
+     * Reorders each same-`priority` group in `sorted` by ascending in-flight request count
+     * (from `acquire`/`release`); a stable sort, so candidates tied on active count keep
+     * their relative (priority-then-registration) order. Priority tiers themselves are
+     * never reordered.
+     */
+    private applyLeastConnections;
+    /**
+     * Endpoints eligible for `model`, sorted healthy-first-by-priority (falling back to
+     * soonest-to-recover if every eligible endpoint is cooling down); same-priority
+     * candidates are further reordered per `options.strategy` (see
+     * `EndpointRegistryOptions.strategy`). When `model` is given, endpoints whose `models`
+     * allow-list doesn't include it are excluded entirely — see `OllamaEndpoint.models`.
+     * Omit `model` to consider every configured endpoint, regardless of any `models`
+     * restriction (used for non-model-scoped operations).
+     */
+    candidates(model?: string): OllamaEndpoint[];
     reportSuccess(name: string): void;
     reportFailure(name: string): void;
     list(): readonly OllamaEndpoint[];
+    /** True if any configured endpoint restricts itself to a `models` allow-list. */
+    hasModelScopedEndpoints(): boolean;
     status(): EndpointHealth[];
 }
 
@@ -406,6 +186,35 @@ declare class EndpointRegistry {
 
 declare const DEFAULT_BASE_URL = "http://localhost:11434";
 declare const DEFAULT_TIMEOUT_MS = 30000;
+/**
+ * Fixed host for Ollama's hosted web tools (`/api/web_search`, `/api/web_fetch`) — see
+ * `OllamaClient.webSearch`/`webFetch`. These are an Ollama Cloud service reachable only
+ * at this host, independent of any locally-configured `baseUrl`/`endpoints`.
+ */
+declare const OLLAMA_CLOUD_BASE_URL = "https://ollama.com";
+/** One named credential for the `credentials`/`modelBindings` config shape. */
+interface OllamaCredentialConfig {
+    readonly apiKey: string;
+    /** Overrides `OllamaClientConfig.baseUrl` for requests made with this credential. */
+    readonly baseUrl?: string | undefined;
+    readonly headers?: Record<string, string> | undefined;
+}
+/**
+ * Builds synthetic `OllamaEndpoint`s (named `credential:<id>`) from `config.credentials` +
+ * `config.modelBindings` — an ergonomic, map-based alternative to writing out `endpoints`
+ * with per-entry `models` allow-lists directly. Both shapes feed the same
+ * `EndpointRegistry`/`executeWithFailover` routing engine; this is pure config sugar, not
+ * a separate routing mechanism. Returns `[]` if `config.credentials` is unset.
+ *
+ * A model bound to one credential (`modelBindings: { "minimax-m3": "coder" }`) scopes that
+ * credential to only that model, same as `OllamaEndpoint.models`. A model bound to several
+ * credentials (`modelBindings: { "gpt-oss:120b": ["key1", "key2"] }`) makes ordinary
+ * endpoint failover apply between them. `config.defaultCredential`, if set, is given a
+ * lower priority than explicitly-bound credentials and no `models` restriction, so it acts
+ * as a catch-all for any model without an explicit binding without ever pre-empting one
+ * that has.
+ */
+declare function resolveCredentialEndpoints(config: Pick<OllamaClientConfig, 'credentials' | 'modelBindings' | 'defaultCredential' | 'baseUrl'>): readonly OllamaEndpoint[];
 declare const DEFAULT_FAILOVER_CODES: readonly string[];
 interface OllamaClientConfig {
     /**
@@ -422,9 +231,49 @@ interface OllamaClientConfig {
     readonly apiKey?: string;
     /** Static headers merged into every request. */
     readonly headers?: Record<string, string>;
-    /** Multiple named endpoints for rotation and automatic failover. */
+    /**
+     * Multiple named endpoints for rotation and automatic failover. Each endpoint may
+     * carry its own `apiKey` and, via `models`, be scoped to only the models that
+     * credential is entitled to — see `OllamaEndpoint.models` for routing several
+     * per-model Ollama Cloud API keys through a single client.
+     */
     readonly endpoints?: readonly OllamaEndpoint[];
-    /** Tuning options for endpoint circuit breaker. */
+    /**
+     * Named credentials, keyed by an id you choose — an ergonomic alternative to writing
+     * out `endpoints` by hand for the common "several Ollama Cloud API keys, each entitled
+     * to different models" shape. Combine with `modelBindings` to scope each credential to
+     * the models it's authorized for; a credential with no binding (or set as
+     * `defaultCredential`) is eligible for every model, same as an `OllamaEndpoint` with no
+     * `models`. Merges additively with `endpoints` if both are given.
+     */
+    readonly credentials?: Readonly<Record<string, OllamaCredentialConfig>>;
+    /**
+     * Maps a model name to the `credentials` id (or ids, for several keys authorized for
+     * the same model — ordinary failover applies between them) that may serve it. Has no
+     * effect without `credentials`. Referencing an id not present in `credentials` throws
+     * at construction time.
+     */
+    readonly modelBindings?: Readonly<Record<string, string | readonly string[]>>;
+    /**
+     * The `credentials` id to fall back to for a model with no entry in `modelBindings`.
+     * Unset means such a model has no synthesized-from-`credentials` route — it still
+     * routes normally through any plain `endpoints` entry without a `models` restriction.
+     */
+    readonly defaultCredential?: string | undefined;
+    /**
+     * Tuning options for the endpoint circuit breaker, and candidate selection ordering —
+     * pass `{ strategy: 'round-robin' }` to spread requests across a pool of same-priority
+     * endpoints/credentials (e.g. several unbound `credentials`) instead of always
+     * preferring the first one, or `{ strategy: 'least-connections' }` to route each
+     * request to whichever candidate currently has the fewest requests in flight (e.g.
+     * several free-tier Ollama Cloud accounts, each capped at 1 concurrent request — this
+     * deterministically spreads concurrent `Promise.all`-style calls one-per-account rather
+     * than risking two landing on the same still-busy one), and `maxConcurrentPerEndpoint`
+     * to cap that at an exact number and queue (rather than overrun a saturated candidate)
+     * once every eligible one is at capacity — e.g. `{ strategy: 'least-connections',
+     * maxConcurrentPerEndpoint: 1 }` for accounts that only allow one request at a time.
+     * See `EndpointRegistryOptions`.
+     */
     readonly endpointHealth?: EndpointRegistryOptions;
     /** Error codes that trigger failover to the next candidate endpoint. */
     readonly failoverOn?: readonly string[];
@@ -456,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.
@@ -471,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}
@@ -485,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[]>;
 
 /**
@@ -504,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>, {
@@ -516,14 +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;
+    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
@@ -592,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;
 }
@@ -613,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[];
@@ -623,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
@@ -646,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';
@@ -683,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.
  *
@@ -706,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;
@@ -801,8 +1342,43 @@ 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
+     * is inherently a single global credential, not tied to any one inference endpoint.
+     * Resolved the same way as a single-endpoint `apiKey` (`config.apiKey` falling back to
+     * `OLLAMA_API_KEY`), independent of whether `config.endpoints` was used instead.
+     */
+    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
@@ -823,6 +1399,25 @@ declare class OllamaClient {
          * ADR 0008. Defaults to `false`, preserving normal failover for inference calls.
          */
         singleEndpoint?: boolean | undefined;
+        /**
+         * The model this request targets, used to filter candidates by
+         * `OllamaEndpoint.models` (credential-scoped routing — see that field's docs).
+         * Requests without a `model` (e.g. `listModels`) consider every configured
+         * endpoint, same as before this option existed.
+         */
+        model?: string | undefined;
+        /**
+         * For an operation whose real completion outlasts its own returned promise — a
+         * streaming response, specifically — defers releasing the endpoint's concurrency
+         * slot (see `EndpointRegistryOptions.maxConcurrentPerEndpoint`/`'least-connections'`)
+         * until the promise this returns settles, instead of releasing as soon as
+         * `operation` resolves. Pass `(stream) => stream.finalResult` for `chatStream`/
+         * `generateStream` so the slot stays held for as long as the underlying HTTP
+         * connection realistically does — until the stream is fully consumed, errors, or is
+         * aborted. Omit for anything whose returned promise already represents the whole
+         * request/response (the default, and correct for every non-streaming call).
+         */
+        holdUntil?: ((result: T) => Promise<unknown>) | undefined;
     }): Promise<T>;
     chat(req: ChatRequestOptions & {
         stream: true;
@@ -863,9 +1458,28 @@ declare class OllamaClient {
     readonly version: () => Promise<VersionResponse>;
     readonly createBlob: (digest: string, data: BinaryBody) => Promise<void>;
     readonly checkBlob: (digest: string) => Promise<boolean>;
+    /**
+     * Ollama's hosted web search tool (`POST https://ollama.com/api/web_search`) — a fixed
+     * Ollama Cloud service, unrelated to `config.endpoints`/`baseUrl` and not proxied
+     * through a local server. Requires an Ollama account API key: pass `apiKey` to the
+     * client constructor or set `OLLAMA_API_KEY`. Applies the same default `timeoutMs` and
+     * retry policy as inference calls, but never cross-endpoint-fails-over — there is only
+     * ever the one cloud endpoint to call.
+     */
     webSearch(req: WebSearchRequestOptions): Promise<WebSearchResponse>;
+    /**
+     * Ollama's hosted web fetch tool (`POST https://ollama.com/api/web_fetch`) — see
+     * {@link OllamaClient.webSearch} for the cloud-endpoint/auth/timeout/retry behavior,
+     * which applies identically here.
+     */
     webFetch(req: WebFetchRequestOptions): Promise<WebFetchResponse>;
-    capabilities(model: string): Promise<ModelCapabilities>;
+    /**
+     * Runs `operation` against the fixed Ollama Cloud host with this client's default
+     * timeout and retry policy — the same primitives `executeWithFailover` uses, minus the
+     * multi-candidate loop, since `webSearch`/`webFetch` only ever have the one endpoint.
+     */
+    private executeCloudRequest;
+    capabilities(model: string, signal?: AbortSignal): Promise<ModelCapabilities>;
     runtimeMode(): RuntimeMode;
     healthCheck(): Promise<EndpointHealthCheckResult[]>;
     endpointStatus(): EndpointHealth[];
@@ -889,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.
@@ -919,6 +1533,89 @@ declare function toDataStream<TChunk, TFinal>(stream: OllamaStream<TChunk, TFina
  */
 declare function toResponse<TChunk, TFinal>(stream: OllamaStream<TChunk, TFinal>, init?: ResponseInit): Response;
 
+/**
+ * Client-side usage budgeting.
+ *
+ * Ollama Cloud does not expose account-level quota or remaining-budget through the API —
+ * chat/generate responses carry only per-request token counts, and there is no header or
+ * endpoint that reports how much of your plan's session or weekly limit is left (the only
+ * way to see that today is the https://ollama.com dashboard or the 90%-usage email). See
+ * https://github.com/ollama/ollama/issues/15663.
+ *
+ * `QuotaManager` does not — and cannot — read Ollama's real limits. It tracks usage you
+ * record against budgets *you* configure over one or more rolling windows, and refuses to
+ * proceed once a window's budget is spent. Pair it with `OllamaRateLimitError` (thrown by
+ * `OllamaClient` on the server's actual 429) as the authoritative signal; treat
+ * `QuotaManager` as a local safety net that fails fast before the request is even sent.
+ */
+
+interface QuotaWindowConfig {
+    /** Identifies this window in status reports and thrown errors (e.g. "session", "weekly"). */
+    readonly id: string;
+    /** Length of the rolling window in milliseconds, after which usage resets to zero. */
+    readonly windowMs: number;
+    /** Token budget for the window. Omit to only track requests. */
+    readonly maxTokens?: number;
+    /** Request-count budget for the window. Omit to only track tokens. */
+    readonly maxRequests?: number;
+}
+interface QuotaWindowStatus extends QuotaWindowConfig {
+    readonly tokensUsed: number;
+    readonly requestsMade: number;
+    readonly windowStartedAt: number;
+    readonly windowResetAt: number;
+    readonly remainingTokens?: number;
+    readonly remainingRequests?: number;
+}
+interface QuotaManagerOptions {
+    readonly windows: readonly QuotaWindowConfig[];
+    /** Clock override for testing. Defaults to `Date.now`. */
+    readonly now?: () => number;
+}
+declare class QuotaManager {
+    private readonly now;
+    private readonly windows;
+    constructor(options: QuotaManagerOptions);
+    private rollover;
+    /** Current usage, budgets, and reset time for every configured window. */
+    status(): readonly QuotaWindowStatus[];
+    /**
+     * True if one more request — optionally estimated at `estimatedTokens` — would stay
+     * within every configured window's budget. Read-only; does not record usage.
+     */
+    canProceed(estimatedTokens?: number): boolean;
+    /**
+     * Throws `OllamaQuotaExceededError` for the first window that `canProceed(estimatedTokens)`
+     * would fail on; otherwise a no-op. Call before issuing a request.
+     */
+    assertCanProceed(estimatedTokens?: number): void;
+    /** Records one request's actual usage — a raw API response or a pre-normalized `TokenUsage` — against every window. */
+    recordUsage(usage: RawUsageSource | TokenUsage): void;
+    /** Resets one window (by `id`) or, if omitted, all windows — zeroing usage and restarting their clocks. */
+    reset(windowId?: string): void;
+}
+interface OllamaCloudFreeTierQuotaBudgets {
+    /** Budget for the free tier's ~5-hour session window. Omit to skip tracking it. */
+    readonly session?: {
+        readonly maxTokens?: number;
+        readonly maxRequests?: number;
+    };
+    /** Budget for the free tier's 7-day weekly window. Omit to skip tracking it. */
+    readonly weekly?: {
+        readonly maxTokens?: number;
+        readonly maxRequests?: number;
+    };
+    readonly now?: () => number;
+}
+/**
+ * Convenience factory mirroring Ollama Cloud free-tier's documented reset cadence — a
+ * session window that resets every 5 hours and a weekly window that resets every 7 days
+ * (see https://ollama.com/pricing). Ollama does not publish the actual token/request
+ * ceilings for either window, so you must supply the budgets yourself (e.g. from your own
+ * observed usage) — this only wires up the window durations.
+ */
+declare function createOllamaCloudFreeTierQuota(budgets: OllamaCloudFreeTierQuotaBudgets): QuotaManager;
+
 /**
  * Zod schema conversion to JSON Schema for Ollama structured outputs.
  */
@@ -956,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.
@@ -1021,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;
 }
 
@@ -1036,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<{
@@ -1052,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.
@@ -1063,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;
@@ -1138,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, OllamaAbortError, OllamaAgentMaxIterationsError, OllamaAuthError, OllamaClient, type OllamaClientConfig, OllamaClientError, type OllamaClientErrorOptions, type OllamaEndpoint, type OllamaErrorRequestContext, type OllamaErrorResponseContext, OllamaGenericClientError, OllamaMcpError, OllamaNetworkError, OllamaNotFoundError, 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, 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, createTimeoutSignal, defineTool, detectModelCapabilities, encodeImage, extractUsage, inferRuntimeMode, listAvailableModels, loadMcpTools, mapError, normalizeChatStream, normalizeGenerateStream, normalizeProgressStream, parseNdjsonStream, parseStructuredOutput, registerMcpTools, 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 };