@nemesis-oss/ollama-sdk 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,1044 @@
+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-DC11aDJn.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-DC11aDJn.cjs';
+import { z } from 'zod';
+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;
+    readonly totalDurationMs?: number | undefined;
+    readonly usage?: TokenUsage | undefined;
+    readonly raw?: ChatResponse | undefined;
+}
+interface GenerateStreamResult {
+    readonly response: string;
+    readonly model: string;
+    readonly done: boolean;
+    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.
+ */
+interface BackoffOptions {
+    readonly initialDelayMs: number;
+    readonly maxDelayMs: number;
+    readonly backoffFactor: number;
+}
+declare const DEFAULT_BACKOFF: BackoffOptions;
+/**
+ * Calculates exponential backoff with full jitter for attempt (0-indexed).
+ */
+declare function calculateBackoff(attempt: number, options?: BackoffOptions): number;
+
+/**
+ * Retry policy and execution runner.
+ */
+
+interface RetryConfig {
+    readonly maxRetries: number;
+    readonly backoff: BackoffOptions;
+    readonly shouldRetry?: (error: Error, attempt: number) => boolean;
+    readonly onRetry?: (error: Error, attempt: number, delayMs: number) => void;
+}
+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>>;
+}
+
+/**
+ * Multi-endpoint registry with priority routing and circuit breaker failover.
+ */
+interface OllamaEndpoint {
+    readonly name: string;
+    readonly baseUrl: string;
+    readonly apiKey?: string | undefined;
+    readonly headers?: Record<string, string> | undefined;
+    readonly priority?: number | undefined;
+}
+interface EndpointHealth {
+    readonly endpoint: OllamaEndpoint;
+    readonly failureCount: number;
+    readonly lastFailureTimestamp?: number | undefined;
+    readonly isCoolingDown: boolean;
+}
+interface EndpointRegistryOptions {
+    readonly failureThreshold?: number | undefined;
+    readonly cooldownMs?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+declare class EndpointRegistry {
+    private readonly endpoints;
+    private readonly failureCounts;
+    private readonly lastFailures;
+    private readonly failureThreshold;
+    private readonly cooldownMs;
+    private readonly now;
+    constructor(endpoints: readonly OllamaEndpoint[], options?: EndpointRegistryOptions);
+    candidates(): OllamaEndpoint[];
+    reportSuccess(name: string): void;
+    reportFailure(name: string): void;
+    list(): readonly OllamaEndpoint[];
+    status(): EndpointHealth[];
+}
+
+/**
+ * Configuration options and constants for OllamaClient.
+ */
+
+declare const DEFAULT_BASE_URL = "http://localhost:11434";
+declare const DEFAULT_TIMEOUT_MS = 30000;
+declare const DEFAULT_FAILOVER_CODES: readonly string[];
+interface OllamaClientConfig {
+    /**
+     * Base URL of a single Ollama server. Ignored if `endpoints` is provided. Falls back to
+     * the `OLLAMA_HOST` environment variable (when set and running under Node), then
+     * `http://localhost:11434`.
+     */
+    readonly baseUrl?: string;
+    /**
+     * Bearer token sent as `Authorization: Bearer <apiKey>` for a single-endpoint setup.
+     * Falls back to the `OLLAMA_API_KEY` environment variable (when set and running under
+     * Node).
+     */
+    readonly apiKey?: string;
+    /** Static headers merged into every request. */
+    readonly headers?: Record<string, string>;
+    /** Multiple named endpoints for rotation and automatic failover. */
+    readonly endpoints?: readonly OllamaEndpoint[];
+    /** Tuning options for endpoint circuit breaker. */
+    readonly endpointHealth?: EndpointRegistryOptions;
+    /** Error codes that trigger failover to the next candidate endpoint. */
+    readonly failoverOn?: readonly string[];
+    /** Default per-request timeout in milliseconds (default 30_000ms). */
+    readonly timeoutMs?: number;
+    /** Retry configuration or retry count override. */
+    readonly retries?: number | Partial<RetryConfig>;
+    /** Custom fetch implementation (defaults to globalThis.fetch). */
+    readonly fetch?: FetchLike;
+    /** Request/Response middleware list. */
+    readonly middleware?: readonly Middleware[];
+    /** Structured logger. */
+    readonly logger?: Logger;
+    /** Enables console debug logger if true. */
+    readonly debug?: boolean;
+    /** Request lifecycle hook for telemetry/metrics. */
+    readonly onLifecycleEvent?: RequestLifecycleHook;
+}
+
+/**
+ * Active endpoint health pinging utility.
+ */
+
+interface EndpointHealthCheckResult {
+    readonly name: string;
+    readonly baseUrl: string;
+    readonly reachable: boolean;
+    readonly latencyMs: number;
+    readonly version?: string;
+    readonly error?: string;
+}
+declare function checkEndpointHealth(endpoint: OllamaEndpoint, fetchImpl?: FetchLike, timeoutMs?: number): Promise<EndpointHealthCheckResult>;
+
+/**
+ * Model capability detection and runtime environment inference.
+ */
+
+type RuntimeMode = 'local' | 'cloud' | 'unknown';
+interface ModelCapabilities {
+    readonly model: string;
+    readonly reported: readonly string[];
+    readonly supportsTools: boolean;
+    readonly supportsVision: boolean;
+    readonly supportsEmbedding: boolean;
+    readonly supportsCompletion: boolean;
+    readonly supportsThinking: boolean;
+    readonly supportsStreaming: true;
+    /**
+     * 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}
+     * — `false` for `cloud`, since Ollama Cloud does not currently support structured outputs;
+     * `true` for `local`/`unknown`. A locally-hosted model that genuinely can't follow a JSON
+     * schema will still report `true` here; the request itself is the only reliable way to find
+     * out. `OllamaClient.chat`/`generate` apply this same inference as a fail-fast pre-flight
+     * guard whenever `format` is set, throwing `OllamaUnsupportedCapabilityError` rather than
+     * making a network call that Ollama Cloud is known to reject.
+     */
+    readonly supportsStructuredOutputRequest: boolean;
+}
+declare function inferRuntimeMode(baseUrl: string): RuntimeMode;
+declare function detectModelCapabilities(http: HttpClient, model: string): Promise<ModelCapabilities>;
+declare function listAvailableModels(http: HttpClient): Promise<ModelResponse[]>;
+
+/**
+ * Dual-mode (AsyncIterator and EventEmitter-like) stream wrapper.
+ */
+
+type ChunkMapper<TChunk, TFinal> = (chunk: TChunk, accumulated: TFinal) => Array<OllamaStreamEvent<TChunk, TFinal>>;
+type Aggregator<TChunk, TFinal> = (accumulated: TFinal, chunk: TChunk) => TFinal;
+declare class OllamaStream<TChunk, TFinal> implements AsyncIterable<OllamaStreamEvent<TChunk, TFinal>> {
+    private readonly source;
+    private readonly mapChunk;
+    private readonly aggregate;
+    private readonly initial;
+    private mode;
+    private readonly listeners;
+    private readonly finalResultPromise;
+    private resolveFinal;
+    private rejectFinal;
+    constructor(source: AbortableAsyncIterable<TChunk>, mapChunk: ChunkMapper<TChunk, TFinal>, aggregate: Aggregator<TChunk, TFinal>, initial: TFinal);
+    get finalResult(): Promise<TFinal>;
+    abort(): void;
+    on<TType extends OllamaStreamEventType>(type: TType, listener: (event: Extract<OllamaStreamEvent<TChunk, TFinal>, {
+        type: TType;
+    }>) => void): () => void;
+    private emit;
+    private pump;
+    [Symbol.asyncIterator](): AsyncGenerator<OllamaStreamEvent<TChunk, TFinal>, void, undefined>;
+}
+
+/**
+ * Model and blob management operations.
+ */
+
+type RequestRunner = <T>(op: (http: HttpClient, signal: AbortSignal) => Promise<T>, opts?: {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+    singleEndpoint?: boolean | undefined;
+}) => Promise<T>;
+/**
+ * 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
+ * substitute; it's a different catalog/store entirely. `singleEndpoint: true` disables
+ * `OllamaClient`'s cross-endpoint failover for these calls (same-endpoint retry via
+ * `withRetry` still applies), so a multi-endpoint setup never silently lists/mutates the
+ * wrong server just because the intended one had a transient failure. See ADR 0008.
+ */
+declare class ModelsClient {
+    private readonly runner;
+    constructor(runner: RequestRunner);
+    list(): Promise<ModelResponse[]>;
+    show(request: ShowRequestOptions): Promise<ShowResponse>;
+    pull(request: PullRequestOptions & {
+        stream: true;
+    }): Promise<OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    pull(request: PullRequestOptions & {
+        stream?: false | undefined;
+    }): Promise<ProgressResponse>;
+    pull(request: PullRequestOptions): Promise<ProgressResponse | OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    push(request: PushRequestOptions & {
+        stream: true;
+    }): Promise<OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    push(request: PushRequestOptions & {
+        stream?: false | undefined;
+    }): Promise<ProgressResponse>;
+    push(request: PushRequestOptions): Promise<ProgressResponse | OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    create(request: CreateRequestOptions & {
+        stream: true;
+    }): Promise<OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    create(request: CreateRequestOptions & {
+        stream?: false | undefined;
+    }): Promise<ProgressResponse>;
+    create(request: CreateRequestOptions): Promise<ProgressResponse | OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    delete(request: DeleteRequestOptions): Promise<StatusResponse>;
+    copy(request: CopyRequestOptions): Promise<StatusResponse>;
+    ps(): Promise<PsResponse>;
+    version(): Promise<VersionResponse>;
+    createBlob(digest: string, data: BinaryBody): Promise<void>;
+    checkBlob(digest: string): Promise<boolean>;
+}
+
+/**
+ * OpenAI Compatibility interfaces and client helpers for Ollama.
+ * Ollama exposes OpenAI-compatible /v1 endpoints.
+ *
+ * @remarks
+ * This is a typed pass-through to Ollama's own OpenAI-compatible `/v1` endpoints — it
+ * implements the subset of the OpenAI Chat Completions API that Ollama documents as
+ * supported (https://docs.ollama.com/api/openai-compatibility), not the full OpenAI
+ * surface (Responses API, hosted tools like web/file search, computer use, code
+ * interpreter, or server-side conversation state). Notably, `tools` is supported by
+ * Ollama's compat layer but `tool_choice` and `parallel_tool_calls` are explicitly
+ * **not** — deliberately omitted from {@link OpenAIChatCompletionRequest} rather than
+ * typed as accepted-but-ignored.
+ */
+
+interface OpenAIToolCall {
+    readonly id: string;
+    readonly type: 'function';
+    readonly function: {
+        readonly name: string;
+        /** JSON-encoded arguments string, matching OpenAI's wire format (not a parsed object). */
+        readonly arguments: string;
+    };
+}
+interface OpenAIMessage {
+    readonly role: 'system' | 'user' | 'assistant' | 'tool';
+    readonly content: string;
+    readonly name?: string | undefined;
+    readonly tool_calls?: readonly OpenAIToolCall[] | undefined;
+    /** Set on a `role: 'tool'` message to identify which call this is a result for. */
+    readonly tool_call_id?: string | undefined;
+}
+interface OpenAIStreamOptions {
+    /** Emit a final SSE chunk carrying `usage` (prompt/completion/total tokens) before `[DONE]`. */
+    readonly include_usage?: boolean | undefined;
+}
+interface OpenAIFunctionDefinition {
+    readonly name: string;
+    readonly description?: string | undefined;
+    readonly parameters?: Record<string, unknown> | undefined;
+}
+interface OpenAITool {
+    readonly type: 'function';
+    readonly function: OpenAIFunctionDefinition;
+}
+interface OpenAIChatCompletionRequest {
+    readonly model: string;
+    readonly messages: readonly OpenAIMessage[];
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly stream?: boolean | undefined;
+    /** Only meaningful when `stream: true`; ignored otherwise. */
+    readonly stream_options?: OpenAIStreamOptions | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly user?: string | undefined;
+    readonly tools?: readonly OpenAITool[] | undefined;
+}
+interface OpenAIChatCompletionChoice {
+    readonly index: number;
+    readonly message: OpenAIMessage;
+    readonly finish_reason: string;
+}
+interface OpenAIChatCompletionResponse {
+    readonly id: string;
+    readonly object: 'chat.completion';
+    readonly created: number;
+    readonly model: string;
+    readonly choices: readonly OpenAIChatCompletionChoice[];
+    readonly usage?: {
+        readonly prompt_tokens: number;
+        readonly completion_tokens: number;
+        readonly total_tokens: number;
+    } | undefined;
+}
+interface OpenAIModelItem {
+    readonly id: string;
+    readonly object: 'model';
+    readonly created: number;
+    readonly owned_by: string;
+}
+interface OpenAIListModelsResponse {
+    readonly object: 'list';
+    readonly data: readonly OpenAIModelItem[];
+}
+declare class OpenAICompatClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    createChatCompletion(request: OpenAIChatCompletionRequest, signal?: AbortSignal): Promise<OpenAIChatCompletionResponse>;
+    chatCompletions(request: OpenAIChatCompletionRequest, signal?: AbortSignal): Promise<OpenAIChatCompletionResponse>;
+    listModels(signal?: AbortSignal): Promise<OpenAIListModelsResponse>;
+}
+
+/**
+ * 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.
+ */
+
+interface AnthropicCacheControl {
+    readonly type: 'ephemeral';
+}
+interface AnthropicContentBlock {
+    readonly type: 'text';
+    readonly text: string;
+    /** Marks this block as a prompt-caching breakpoint (Anthropic's ephemeral cache). */
+    readonly cache_control?: AnthropicCacheControl | undefined;
+}
+interface AnthropicMessage {
+    readonly role: 'user' | 'assistant';
+    readonly content: string | readonly AnthropicContentBlock[];
+}
+interface AnthropicMessagesRequest {
+    readonly model: string;
+    readonly messages: readonly AnthropicMessage[];
+    readonly system?: string | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly top_k?: number | undefined;
+    readonly stream?: boolean | undefined;
+}
+interface AnthropicMessagesResponse {
+    readonly id: string;
+    readonly type: 'message';
+    readonly role: 'assistant';
+    readonly content: readonly AnthropicContentBlock[];
+    readonly model: string;
+    readonly stop_reason: string;
+    readonly usage?: {
+        readonly input_tokens: number;
+        readonly output_tokens: number;
+    } | undefined;
+}
+declare class AnthropicCompatClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    createMessage(request: AnthropicMessagesRequest, signal?: AbortSignal): Promise<AnthropicMessagesResponse>;
+    messages(request: AnthropicMessagesRequest, signal?: AbortSignal): Promise<AnthropicMessagesResponse>;
+}
+
+declare class OllamaClient {
+    readonly registry: EndpointRegistry;
+    readonly models: ModelsClient;
+    private readonly retryConfig;
+    private readonly timeoutMs;
+    private readonly failoverCodes;
+    private readonly fetchImpl;
+    private readonly logger;
+    constructor(config?: OllamaClientConfig);
+    get modelsClient(): ModelsClient;
+    /**
+     * 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
+     * support structured outputs (see `ModelCapabilities.supportsStructuredOutputRequest`).
+     * `unsupported_capability` is in `DEFAULT_FAILOVER_CODES`, so in a multi-endpoint setup
+     * this causes failover to the next candidate rather than failing the whole request.
+     */
+    private assertStructuredOutputSupported;
+    executeWithFailover<T>(operation: (http: HttpClient, signal: AbortSignal) => Promise<T>, options?: {
+        signal?: AbortSignal | undefined;
+        timeoutMs?: number | undefined;
+        /**
+         * Disables cross-endpoint failover: only the single best candidate endpoint is
+         * tried (same-endpoint retry via `withRetry` still applies). For operations whose
+         * target IS the endpoint — model catalog/blob management — a different endpoint
+         * isn't an interchangeable substitute, so failing over to one would silently
+         * operate on the wrong server's state rather than retrying "the same" request. See
+         * ADR 0008. Defaults to `false`, preserving normal failover for inference calls.
+         */
+        singleEndpoint?: boolean | undefined;
+    }): Promise<T>;
+    chat(req: ChatRequestOptions & {
+        stream: true;
+    }): Promise<OllamaStream<ChatResponse, ChatStreamResult>>;
+    chat(req: ChatRequestOptions & {
+        stream?: false | undefined;
+    }): Promise<ChatResponse>;
+    chat(req: ChatRequestOptions): Promise<ChatResponse | OllamaStream<ChatResponse, ChatStreamResult>>;
+    chatStream(req: Omit<ChatRequestOptions, 'stream'>): Promise<OllamaStream<ChatResponse, ChatStreamResult>>;
+    chatText(req: Omit<ChatRequestOptions, 'stream'>): Promise<string>;
+    chatWithSchema<T>(req: Omit<ChatRequestOptions, 'stream' | 'format'>, schema: z.ZodType<T>): Promise<T>;
+    generate(req: GenerateRequestOptions & {
+        stream: true;
+    }): Promise<OllamaStream<GenerateResponse, GenerateStreamResult>>;
+    generate(req: GenerateRequestOptions & {
+        stream?: false | undefined;
+    }): Promise<GenerateResponse>;
+    generate(req: GenerateRequestOptions): Promise<GenerateResponse | OllamaStream<GenerateResponse, GenerateStreamResult>>;
+    generateStream(req: Omit<GenerateRequestOptions, 'stream'>): Promise<OllamaStream<GenerateResponse, GenerateStreamResult>>;
+    generateText(req: Omit<GenerateRequestOptions, 'stream'>): Promise<string>;
+    generateWithSchema<T>(req: Omit<GenerateRequestOptions, 'stream' | 'format'>, schema: z.ZodType<T>): Promise<T>;
+    embed(req: EmbedRequestOptions): Promise<EmbedResponse>;
+    embedText(model: string, input: string | readonly string[]): Promise<readonly (readonly number[])[]>;
+    /**
+     * @deprecated Ollama's `/api/embeddings` endpoint has been superseded by `/api/embed`
+     * (exposed here as {@link OllamaClient.embed}), which additionally supports batch
+     * input. Kept for compatibility with existing callers; new code should use `embed`.
+     */
+    embeddings(req: EmbeddingsRequestOptions): Promise<EmbeddingsResponse>;
+    readonly listModels: () => Promise<ModelResponse[]>;
+    readonly showModel: (req: ShowRequestOptions) => Promise<ShowResponse>;
+    readonly pullModel: (r: PullRequestOptions) => Promise<ProgressResponse | OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    readonly pushModel: (r: PushRequestOptions) => Promise<ProgressResponse | OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    readonly createModel: (r: CreateRequestOptions) => Promise<ProgressResponse | OllamaStream<ProgressResponse, ProgressStreamResult>>;
+    readonly deleteModel: (req: DeleteRequestOptions) => Promise<StatusResponse>;
+    readonly copyModel: (req: CopyRequestOptions) => Promise<StatusResponse>;
+    readonly ps: () => Promise<PsResponse>;
+    readonly version: () => Promise<VersionResponse>;
+    readonly createBlob: (digest: string, data: BinaryBody) => Promise<void>;
+    readonly checkBlob: (digest: string) => Promise<boolean>;
+    webSearch(req: WebSearchRequestOptions): Promise<WebSearchResponse>;
+    webFetch(req: WebFetchRequestOptions): Promise<WebFetchResponse>;
+    capabilities(model: string): Promise<ModelCapabilities>;
+    runtimeMode(): RuntimeMode;
+    healthCheck(): Promise<EndpointHealthCheckResult[]>;
+    endpointStatus(): EndpointHealth[];
+    get openai(): OpenAICompatClient;
+    get anthropic(): AnthropicCompatClient;
+}
+
+/**
+ * AbortSignal and timeout management for HTTP requests.
+ */
+interface TimeoutSignal {
+    readonly signal: AbortSignal;
+    readonly cancel: () => void;
+}
+/**
+ * Combines an optional timeout with an optional caller-provided AbortSignal.
+ */
+declare function createTimeoutSignal(timeoutMs?: number, userSignal?: AbortSignal): TimeoutSignal;
+
+/**
+ * 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>;
+
+/**
+ * NDJSON (newline-delimited JSON) stream reader for native fetch Response bodies.
+ */
+/**
+ * Parses a byte stream from fetch body into an async generator of typed JSON chunks.
+ */
+declare function parseNdjsonStream<T>(stream: ReadableStream<Uint8Array>): AsyncGenerator<T, void, undefined>;
+
+/**
+ * Web Standard Stream adapters for OllamaStream.
+ * Enables seamless integration with Vercel AI SDK, Next.js route handlers, and standard web fetch responses.
+ */
+
+/**
+ * Transforms an OllamaStream into a standard Web ReadableStream of token text strings.
+ */
+declare function toTextStream<TChunk, TFinal>(stream: OllamaStream<TChunk, TFinal>): ReadableStream<string>;
+/**
+ * Transforms an OllamaStream into a standard Web ReadableStream of encoded Uint8Array bytes.
+ */
+declare function toDataStream<TChunk, TFinal>(stream: OllamaStream<TChunk, TFinal>): ReadableStream<Uint8Array>;
+/**
+ * Converts an OllamaStream directly into a standard Web Response with text/plain streaming headers.
+ */
+declare function toResponse<TChunk, TFinal>(stream: OllamaStream<TChunk, TFinal>, init?: ResponseInit): Response;
+
+/**
+ * Zod schema conversion to JSON Schema for Ollama structured outputs.
+ */
+
+type SupportedSchema<T = unknown> = z.ZodType<T>;
+/**
+ * Converts a Zod schema into a JSON Schema object accepted by Ollama's `format` parameter.
+ *
+ * Uses Zod v4's native `z.toJSONSchema` when available, falling back to a structural
+ * walk of Zod v3's internal `_def` shape so both major versions work as peer dependencies.
+ */
+declare function zodToJsonSchema<T>(schema: z.ZodType<T>): Record<string, unknown>;
+/**
+ * Parses and validates a JSON output string against a Zod schema.
+ */
+declare function parseStructuredOutput<T>(rawJson: string, schema: z.ZodType<T>, toolName?: string): T;
+
+/**
+ * Type-safe tool definition helper.
+ */
+
+interface DefineToolOptions<TParams, TResult> {
+    readonly name: string;
+    readonly description: string;
+    readonly schema: z.ZodType<TParams>;
+    readonly execute: ToolHandler<TParams, TResult>;
+    /**
+     * Per-tool execution timeout in milliseconds, overriding the registry's default.
+     * Pass `0` to explicitly disable timeout enforcement for this tool.
+     */
+    readonly timeoutMs?: number | undefined;
+}
+/**
+ * Creates a strongly-typed Tool definition with automatic JSON Schema conversion.
+ */
+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.
+ */
+
+interface LoadMcpToolsOptions {
+    readonly namePrefix?: string;
+}
+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.
+ */
+
+interface AgentTurn {
+    readonly iteration: number;
+    readonly message: Message;
+    readonly toolCalls?: readonly ToolCall[] | undefined;
+    readonly toolResults?: readonly ToolExecutionResult[] | undefined;
+}
+interface AgentResult {
+    readonly finalMessage: Message;
+    readonly turns: readonly AgentTurn[];
+    readonly totalIterations: number;
+}
+interface AgentHooks {
+    readonly onTurnStart?: ((iteration: number) => void) | undefined;
+    readonly onToken?: ((delta: string) => void) | undefined;
+    readonly onThinking?: ((delta: string) => void) | undefined;
+    readonly onToolCallStart?: ((toolCall: ToolCall) => void) | undefined;
+    readonly onToolCallEnd?: ((result: ToolExecutionResult) => void) | undefined;
+    readonly onTurnEnd?: ((turn: AgentTurn) => void) | undefined;
+}
+interface AgentConfig {
+    readonly tools?: ToolRegistry | undefined;
+    readonly maxIterations?: number | undefined;
+    readonly hooks?: AgentHooks | undefined;
+}
+interface AgentRunInput {
+    readonly model: string;
+    readonly messages: readonly Message[];
+    readonly options?: ModelOptions | undefined;
+    readonly think?: boolean | 'low' | 'medium' | 'high' | 'max' | undefined;
+    readonly signal?: AbortSignal | undefined;
+}
+
+/**
+ * Multi-turn tool execution loop agent.
+ */
+
+interface AgentChatClient {
+    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 stream?: false | undefined;
+        readonly signal?: AbortSignal | undefined;
+    }): Promise<{
+        readonly message: Message;
+    }>;
+}
+/**
+ * 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).
+ * `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.
+ */
+declare class Agent {
+    private readonly client;
+    private readonly tools?;
+    private readonly maxIterations;
+    private readonly hooks?;
+    constructor(client: AgentChatClient, config?: AgentConfig);
+    run(input: AgentRunInput): Promise<AgentResult>;
+    private runLoop;
+}
+
+/**
+ * Optional OpenTelemetry tracing.
+ *
+ * `@opentelemetry/api` is an optional peer dependency. When it isn't installed, or when
+ * the host process hasn't registered a global TracerProvider, `withSpan` degrades to
+ * invoking its callback directly — no spans, no exporters, nothing beyond one cached
+ * dynamic `import()` attempt. Once a consumer wires up an OpenTelemetry SDK, spans for
+ * HTTP requests, endpoint failover attempts, agent turns, and tool calls appear
+ * automatically without any configuration on this SDK's side.
+ */
+
+type SpanAttributeValue = string | number | boolean;
+type SpanAttributes = Record<string, SpanAttributeValue | undefined>;
+/**
+ * Runs `fn` inside an active OpenTelemetry span named `name`, when OpenTelemetry is
+ * available. `fn` receives the live span (to add events/attributes as work proceeds) or
+ * `undefined` when tracing is a no-op. Exceptions from `fn` are recorded on the span,
+ * marked as an error status, and re-thrown unchanged; the span always ends.
+ *
+ * On success the span status is left `Unset` rather than forced to `Ok` — per the
+ * OpenTelemetry spec, `Ok` is final and silently suppresses any later `Error` status.
+ * Some call sites (e.g. tool execution, which reports failure via a return value rather
+ * than a throw) need to mark a successfully-*returned* span as an error after the fact,
+ * via `setSpanError`; leaving success as `Unset` keeps that possible. Backends treat
+ * `Unset` the same as `Ok` for filtering purposes.
+ */
+declare function withSpan<T>(name: string, attributes: SpanAttributes, fn: (span: Otel.Span | undefined) => Promise<T>): Promise<T>;
+/** Adds an attribute/event to `span` if tracing is active; a cheap no-op otherwise. */
+declare function addSpanEvent(span: Otel.Span | undefined, name: string, attributes?: SpanAttributes): void;
+/**
+ * Marks a span as failed without throwing — for operations (like tool execution) that
+ * report failure through a return value rather than an exception. No-ops when tracing
+ * is inactive.
+ */
+declare function setSpanError(span: Otel.Span | undefined, error: Error): Promise<void>;
+declare const ATTR_HTTP_REQUEST_METHOD = "http.request.method";
+declare const ATTR_URL_FULL = "url.full";
+declare const ATTR_SERVER_ADDRESS = "server.address";
+declare const ATTR_SERVER_PORT = "server.port";
+declare const ATTR_HTTP_RESPONSE_STATUS_CODE = "http.response.status_code";
+declare const ATTR_GEN_AI_SYSTEM = "gen_ai.system";
+declare const ATTR_GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+declare const ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+declare const ATTR_GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+declare const ATTR_GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+declare const ATTR_GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+declare const ATTR_GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+declare const ATTR_GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+declare const ATTR_OLLAMA_ENDPOINT_NAME = "ollama.endpoint.name";
+declare const ATTR_OLLAMA_ENDPOINT_ATTEMPT = "ollama.endpoint.attempt";
+declare const ATTR_OLLAMA_AGENT_MAX_ITERATIONS = "ollama.agent.max_iterations";
+declare const ATTR_OLLAMA_AGENT_ITERATION = "ollama.agent.iteration";
+declare const GEN_AI_SYSTEM_OLLAMA = "ollama";
+
+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 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, extractUsage, inferRuntimeMode, listAvailableModels, loadMcpTools, mapError, normalizeChatStream, normalizeGenerateStream, normalizeProgressStream, parseNdjsonStream, parseStructuredOutput, registerMcpTools, setSpanError, toDataStream, toResponse, toTextStream, withRetry, withSpan, zodToJsonSchema };