@nemesis-oss/ollama-sdk 1.1.0 → 1.4.0

package/dist/index-2RIErNT5.d.cts

@@ -0,0 +1,583 @@
+import { M as Message, k as ChatResponse, l as GenerateResponse, a as ToolCall, e as ProgressResponse } from './types-BQhgW-du.cjs';
+
+/**
+ * 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>;
+
+/**
+ * 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;
+
+/**
+ * Server-Sent Events (SSE) parser for OpenAI/Anthropic-compatible streaming endpoints.
+ *
+ * Implements standard event-stream field rules without coupling the parser to
+ * any provider-specific event schema.
+ */
+interface SseEvent {
+    /** Event type; omitted when the server emitted no explicit event field. */
+    readonly event?: string | undefined;
+    /** Event data with consecutive data fields joined by a newline. */
+    readonly data: string;
+    /** Last event id associated with this dispatch, when present. */
+    readonly id?: string | undefined;
+    /** Reconnection delay requested by the server, in milliseconds, when valid. */
+    readonly retry?: number | undefined;
+}
+/**
+ * Parses an SSE byte stream into discrete events.
+ *
+ * Supports CRLF, CR, and LF line endings; comments; repeated data fields;
+ * event/id/retry fields; UTF-8 chunks split across arbitrary byte boundaries;
+ * and a terminal event without a trailing blank line.
+ */
+declare function parseSseStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<SseEvent, void, undefined>;
+
+/**
+ * Structured, typed error hierarchy for OllamaClient.
+ */
+interface OllamaErrorRequestContext {
+    readonly method?: string | undefined;
+    readonly url?: string | undefined;
+    readonly model?: string | undefined;
+}
+interface OllamaErrorResponseContext {
+    readonly status?: number | undefined;
+    readonly headers?: Record<string, string> | undefined;
+    readonly body?: unknown;
+}
+interface OllamaClientErrorOptions extends ErrorOptions {
+    readonly code: string;
+    readonly status?: number | undefined;
+    readonly retryable?: boolean | undefined;
+    readonly request?: OllamaErrorRequestContext | undefined;
+    readonly response?: OllamaErrorResponseContext | undefined;
+}
+declare class OllamaClientError extends Error {
+    readonly code: string;
+    readonly status?: number | undefined;
+    readonly retryable: boolean;
+    readonly request?: OllamaErrorRequestContext | undefined;
+    readonly response?: OllamaErrorResponseContext | undefined;
+    constructor(message: string, options: OllamaClientErrorOptions);
+}
+declare class OllamaNetworkError extends OllamaClientError {
+    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
+}
+declare class OllamaTimeoutError extends OllamaClientError {
+    readonly timeoutMs?: number | undefined;
+    constructor(message: string, options?: (Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
+        timeoutMs?: number | undefined;
+    }) | undefined);
+}
+declare class OllamaAuthError extends OllamaClientError {
+    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
+}
+declare class OllamaNotFoundError extends OllamaClientError {
+    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
+}
+declare class OllamaRateLimitError extends OllamaClientError {
+    readonly retryAfterMs?: number | undefined;
+    constructor(message: string, options?: (Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
+        retryAfterMs?: number | undefined;
+    }) | undefined);
+}
+/**
+ * Thrown client-side, before a network request is made, by `QuotaManager.assertCanProceed`
+ * (see `src/quota.ts`) when issuing the request would exceed a configured usage budget for
+ * one of its rolling windows. This is distinct from `OllamaRateLimitError`, which reflects
+ * the server's own 429 response — Ollama Cloud does not expose account-level quota via the
+ * API, so `QuotaManager` tracks usage against budgets the caller configures locally and
+ * fails fast rather than waiting for the server to reject the request.
+ */
+declare class OllamaQuotaExceededError extends OllamaClientError {
+    readonly windowId: string;
+    readonly resetAt: number;
+    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
+        windowId: string;
+        resetAt: number;
+    });
+}
+declare class OllamaServerError extends OllamaClientError {
+    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
+}
+declare class OllamaAbortError extends OllamaClientError {
+    constructor(message: string, options?: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> | undefined);
+}
+declare class OllamaToolValidationError extends OllamaClientError {
+    readonly toolName: string;
+    readonly issues?: unknown;
+    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code'> & {
+        toolName: string;
+        issues?: unknown;
+    });
+}
+declare class OllamaToolTimeoutError extends OllamaClientError {
+    readonly toolName: string;
+    readonly timeoutMs: number;
+    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
+        toolName: string;
+        timeoutMs: number;
+    });
+}
+/**
+ * Thrown client-side, before a network request is made, when a request asks for a
+ * capability an endpoint is known not to support (e.g. structured output `format` against
+ * an Ollama Cloud endpoint — see `ModelCapabilities.supportsStructuredOutputRequest` in
+ * `src/capabilities/capabilities.ts`). Its `code` is included in `DEFAULT_FAILOVER_CODES`
+ * by default, so in a multi-endpoint setup it causes failover to the next candidate rather
+ * than failing outright — it only surfaces to the caller if every candidate is rejected.
+ */
+declare class OllamaUnsupportedCapabilityError extends OllamaClientError {
+    readonly capability: string;
+    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
+        capability: string;
+    });
+}
+/**
+ * Thrown client-side, before any network call, when `config.endpoints` uses
+ * `OllamaEndpoint.models` to scope endpoints/credentials to specific models and the
+ * requested `model` isn't in any configured endpoint's allow-list. This is a routing
+ * misconfiguration, not a connectivity problem — the SDK deliberately does not "probe"
+ * unauthorized endpoints to find one that happens to work (that would burn quota on keys
+ * that were never entitled to the model and produce non-deterministic startup behavior).
+ */
+declare class OllamaModelRoutingError extends OllamaClientError {
+    readonly model: string;
+    readonly availableModels: readonly string[];
+    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
+        model: string;
+        availableModels: readonly string[];
+    });
+}
+/**
+ * Thrown before an agent tool loop starts when the selected model's /api/show metadata
+ * does not advertise a capability required by the loop.
+ */
+declare class OllamaIncompatibleModelError extends OllamaClientError {
+    readonly model: string;
+    readonly capability: string;
+    readonly reportedCapabilities: readonly string[];
+    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code' | 'retryable'> & {
+        model: string;
+        capability: string;
+        reportedCapabilities: readonly string[];
+    });
+}
+declare class OllamaAgentMaxToolCallsError extends OllamaClientError {
+    readonly maxToolCalls: number;
+    readonly toolCallsExecuted: number;
+    constructor(message: string, options: Omit<OllamaClientErrorOptions, 'code'> & {
+        maxToolCalls: number;
+        toolCallsExecuted: number;
+    });
+}
+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;
+    /** Prompt tokens read from Ollama's KV cache. */
+    readonly cachedPromptTokens?: number | undefined;
+    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 prompt_eval_cached_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 thinking?: string | undefined;
+    readonly image?: string | undefined;
+    readonly completed?: number | undefined;
+    readonly total?: number | 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;
+}
+
+/**
+ * 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;
+    readonly middleware?: readonly Middleware[] | undefined;
+    readonly onLifecycleEvent?: RequestLifecycleHook | undefined;
+    /** Reuse a logical request id across endpoint failover/retry attempts. */
+    readonly requestId?: string | 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;
+    /**
+     * When `true`, return the raw {@link Response} object instead of parsing
+     * the body as JSON. Used by callers that need direct access to the
+     * streaming body (e.g. {@link src/generated/runtime/runtime.ts} for
+     * NDJSON streaming through the runtime seam).
+     *
+     * The returned `Response` is the same one middleware/retry/telemetry
+     * have already processed, so this option does NOT bypass any of the
+     * transport-layer concerns.
+     */
+    readonly raw?: boolean | undefined;
+}
+declare class HttpClient {
+    readonly baseUrl: string;
+    private readonly apiKey?;
+    private readonly defaultHeaders;
+    private readonly fetchImpl;
+    private readonly middleware;
+    private readonly onLifecycleEvent;
+    private readonly requestId?;
+    constructor(options: HttpClientOptions);
+    private buildHeaders;
+    private fetchWithMiddleware;
+    request<T>(options: HttpRequestOptions): Promise<T>;
+    /**
+     * Opens an event-stream response and exposes parsed SSE events.
+     *
+     * This is intentionally schema-agnostic so OpenAI and Anthropic compatibility layers
+     * can decode their provider-specific event payloads without duplicating transport logic.
+     */
+    requestSseStream(options: HttpRequestOptions): Promise<AbortableAsyncIterable<SseEvent>>;
+    requestStream<T>(options: HttpRequestOptions): Promise<AbortableAsyncIterable<T>>;
+}
+
+/**
+ * OperationDefinition — the runtime-facing contract shape.
+ *
+ * Every generated operation in `src/generated/api/operations.ts` is typed
+ * `as const satisfies OperationDefinition`. This file is the ONLY hand-written
+ * file in `src/generated/` — it defines the contract the generated code
+ * expects the runtime to honor.
+ *
+ * The shape mirrors {@link OperationContract} from the canonical IR, with
+ * one simplification: schema refs are typed as `$ref: string` rather than
+ * the full `SchemaRef` interface, because the runtime never resolves them
+ * (it just passes the request body to the HTTP client).
+ *
+ * The types below are intentionally inlined (not imported from
+ * `generator/types.ts`) so that `src/generated/` is self-contained and
+ * the shipped package does not depend on the build-time `generator/`
+ * directory at runtime. The contract IR is regenerated by `npm run
+ * contract:generate`; the canonical type definitions live in
+ * `generator/types.ts`, and this file mirrors just the subset the runtime
+ * needs.
+ */
+/** Wire-format used to transport request/response bodies. */
+type TransportMode = 'json' | 'ndjson' | 'sse';
+/** HTTP method an operation uses. */
+type HttpMethod = 'GET' | 'POST' | 'DELETE' | 'PUT' | 'PATCH' | 'HEAD';
+/** Capability support level — first-class concept in Ollama's docs. */
+type CapabilitySupport = 'supported' | 'unsupported' | 'model-dependent' | 'version-dependent';
+/** Schema reference, same shape as the IR's SchemaRef. */
+interface SchemaRef {
+    readonly $ref: string;
+}
+/** Behavioral contract a generated operation carries into the runtime. */
+interface OperationDefinition {
+    readonly operationId: string;
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly request?: SchemaRef;
+    readonly response?: SchemaRef;
+    readonly environment: {
+        readonly local: boolean;
+        readonly cloud: boolean;
+    };
+    readonly transport: {
+        readonly mode: TransportMode;
+        readonly streaming: boolean;
+        readonly streamingDefault?: boolean;
+    };
+    readonly capabilities: {
+        readonly thinking?: CapabilitySupport;
+        readonly tools?: CapabilitySupport;
+        readonly vision?: CapabilitySupport;
+        readonly structuredOutput?: CapabilitySupport;
+        readonly logprobs?: CapabilitySupport;
+        readonly embeddings?: CapabilitySupport;
+    };
+    readonly constraints?: {
+        readonly minOllamaVersion?: string;
+        readonly maxRequestBytes?: number;
+    };
+    readonly status: {
+        readonly documented: boolean;
+        readonly deprecated?: boolean;
+        readonly experimental?: boolean;
+    };
+    readonly domain: 'native' | 'openai' | 'anthropic';
+    readonly notes?: readonly string[];
+}
+/** Request descriptor passed by generated API classes to {@link OllamaRuntime.invoke}. */
+interface InvokeRequest {
+    /** The operation definition this call corresponds to. */
+    readonly operation: OperationDefinition;
+    /** Request body, or `undefined` for GET/HEAD calls. */
+    readonly body: unknown;
+    /** Optional per-call abort signal. */
+    readonly signal?: AbortSignal;
+    /**
+     * Whether the docs say this operation streams by default. The runtime
+     * uses this to decide whether to enable streaming when the request body
+     * doesn't explicitly set `stream`.
+     */
+    readonly streamingDefault?: boolean;
+}
+
+/**
+ * OllamaRuntime — the runtime seam generated API classes delegate to.
+ *
+ * This is the only hand-written file in `src/generated/runtime/`. Every
+ * generated method in `src/generated/api/*-api.ts` ends with:
+ *
+ * ```ts
+ * return this.runtime.invoke({ operation: chatOp, body: request });
+ * ```
+ *
+ * The runtime is responsible for:
+ *   - Method/path resolution (from {@link OperationDefinition})
+ *   - Streaming default application (when the request doesn't set `stream`)
+ *   - Environment guard (rejecting cloud calls for local-only operations)
+ *   - Version constraint guard (failing fast when the server is too old)
+ *   - Delegating to the existing {@link HttpClient} for transport, retry,
+ *     telemetry, NDJSON/SSE parsing
+ *
+ * It is intentionally a thin adapter — the existing transport, streaming,
+ * middleware, and error-mapping layers are preserved verbatim. This file
+ * only adds the contract-aware glue between generated API classes and the
+ * existing HttpClient.
+ */
+
+/** Constructor options for {@link OllamaRuntime}. */
+interface OllamaRuntimeOptions {
+    readonly http: HttpClient;
+    /**
+     * Whether this runtime is targeting a local Ollama instance. Defaults to
+     * `true`. When `false`, operations marked `environment.cloud === false`
+     * (i.e. local-only like `/v1/systemone`) are rejected at request time.
+     */
+    readonly localMode?: boolean;
+    /**
+     * Server version, if known (typically from a prior `/api/version` call).
+     * When set, operations with `constraints.minOllamaVersion` are checked
+     * against this value at request time.
+     */
+    readonly serverVersion?: string;
+}
+/** The runtime seam. */
+declare class OllamaRuntime {
+    private readonly options;
+    constructor(options: OllamaRuntimeOptions);
+    /**
+     * Invoke an operation. Called by every generated API method.
+     *
+     * Returns a `Promise<T>` for non-streaming operations, or an
+     * `AsyncGenerator<T>` for streaming operations. The generated API
+     * class's overloads pick the right return type at compile time.
+     */
+    invoke<T = unknown>(req: InvokeRequest): Promise<T>;
+}
+
+export { OllamaToolValidationError as $, type AbortableAsyncIterable as A, type BinaryBody as B, type ChatStreamResult as C, type DoneEvent as D, type ErrorEvent as E, type FetchLike as F, type GenerateStreamResult as G, HttpClient as H, OllamaMcpError as I, OllamaModelRoutingError as J, OllamaNetworkError as K, type Logger as L, type Middleware as M, NANOS_PER_MS as N, OllamaRuntime as O, type ProgressStreamResult as P, OllamaNotFoundError as Q, type RequestLifecycleHook as R, type SseEvent as S, type TokenUsage as T, OllamaQuotaExceededError as U, OllamaRateLimitError as V, OllamaServerError as W, OllamaSkillInvalidError as X, OllamaSkillNotFoundError as Y, OllamaTimeoutError as Z, OllamaToolTimeoutError as _, type OllamaStreamEvent as a, OllamaUnsupportedCapabilityError as a0, type RequestContext as a1, type RequestLifecycleEvent as a2, type ResponseContext as a3, type ThinkingEvent as a4, type TokenEvent as a5, type ToolCallEvent as a6, composeMiddleware as a7, createConsoleLogger as a8, extractUsage as a9, mapError as aa, parseSseStream as ab, type OperationDefinition as ac, type InvokeRequest as ad, type OllamaRuntimeOptions as ae, type SchemaRef as af, type OllamaStreamEventType as b, OllamaClientError as c, type RawUsageSource as d, type HttpBody as e, type HttpClientOptions as f, type HttpRequestOptions as g, type LifecycleErrorEvent as h, type LifecycleRetryEvent as i, type LifecycleStartEvent as j, type LifecycleSuccessEvent as k, type LogFn as l, type MessageEvent as m, type MiddlewareContext as n, NANOS_PER_SECOND as o, NOOP_LOGGER as p, type NextFunction as q, OllamaAbortError as r, OllamaAgentMaxIterationsError as s, OllamaAgentMaxToolCallsError as t, OllamaAuthError as u, type OllamaClientErrorOptions as v, type OllamaErrorRequestContext as w, type OllamaErrorResponseContext as x, OllamaGenericClientError as y, OllamaIncompatibleModelError as z };