@warlock.js/ai-ollama 4.1.1

package/cjs/index.cjs

@@ -0,0 +1,705 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let ollama = require("ollama");
+let _warlock_js_ai = require("@warlock.js/ai");
+let _warlock_js_logger = require("@warlock.js/logger");
+
+//#region ../../@warlock.js/ai-ollama/src/utils/map-done-reason.ts
+const doneReasonMap = {
+	stop: "stop",
+	length: "length"
+};
+/**
+* Map Ollama's `done_reason` to the normalized `FinishReason` union.
+*
+* `stop` is the natural terminal; `length` means the `num_predict`
+* cap was hit. Anything else — `load` (model load only, no
+* generation), an empty string, or any future value — falls through
+* to `"error"`.
+*
+* Note: Ollama has no tool-use done reason — it sets `done_reason:
+* "stop"` and populates `message.tool_calls`. `OllamaModel` derives
+* `"tool_calls"` from tool-call presence; this map stays purely about
+* the raw signal.
+*
+* @example
+* mapDoneReason("stop");    // "stop"
+* mapDoneReason("length");  // "length"
+* mapDoneReason("load");    // "error"
+* mapDoneReason(undefined); // "error"
+*/
+function mapDoneReason(raw) {
+	return doneReasonMap[raw ?? ""] ?? "error";
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-ollama/src/utils/to-ollama-messages.ts
+/**
+* Convert vendor-neutral `Message[]` into the Ollama chat message
+* shape.
+*
+* Unlike Anthropic / Gemini / Bedrock, Ollama keeps a first-class
+* `system` role inside `messages`, so there is no system-prompt
+* hoisting — roles pass straight through. The Ollama specifics this
+* absorbs:
+*
+* 1. **Tool calls.** An assistant message with `toolCalls` becomes an
+*    `assistant` message whose `tool_calls` is the Ollama
+*    `{ function: { name, arguments } }` shape (Ollama has no tool-call
+*    id — see `OllamaModel`/decisions for the synthesized-id note).
+* 2. **Tool results.** A neutral `tool` message becomes a `tool`
+*    message with `tool_name` set from `toolCallId` (Ollama matches a
+*    result to its call by tool name).
+* 3. **Images.** Multipart user content collapses to a single
+*    `content` string plus an `images` array of base64 strings.
+*
+* @example
+* const messages = toOllamaMessages([
+*   { role: "system", content: "Be concise." },
+*   { role: "user", content: "Hi" },
+* ]);
+*/
+function toOllamaMessages(messages) {
+	return messages.map((message) => {
+		if (message.role === "tool") return {
+			role: "tool",
+			content: stringifyContent(message.content),
+			tool_name: message.toolCallId ?? ""
+		};
+		if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) return {
+			role: "assistant",
+			content: stringifyContent(message.content),
+			tool_calls: message.toolCalls.map((toolCall) => ({ function: {
+				name: toolCall.name,
+				arguments: toolCall.input ?? {}
+			} }))
+		};
+		if (message.role === "user" && Array.isArray(message.content)) return toMultipartMessage(message.content);
+		return {
+			role: message.role,
+			content: stringifyContent(message.content)
+		};
+	});
+}
+/**
+* Collapse a `ContentPart[]` user message into Ollama's
+* single-string-content + base64-`images` shape. Ollama cannot fetch
+* remote URLs, so a `{ url }` image surfaces a typed
+* `InvalidRequestError` upfront (consistent with the Bedrock/Gemini
+* adapters). The agent has already resolved attachments — nothing is
+* fetched here.
+*/
+function toMultipartMessage(parts) {
+	const textChunks = [];
+	const images = [];
+	for (const part of parts) {
+		if (part.type === "text") {
+			textChunks.push(part.text);
+			continue;
+		}
+		if ("url" in part.source) throw new _warlock_js_ai.InvalidRequestError("Ollama does not fetch remote-URL images; supply base64 image bytes instead.");
+		images.push(part.source.base64);
+	}
+	return {
+		role: "user",
+		content: textChunks.join(""),
+		...images.length > 0 ? { images } : {}
+	};
+}
+/**
+* Multipart content on a non-user role collapses to concatenated text;
+* plain strings pass through unchanged.
+*/
+function stringifyContent(content) {
+	if (typeof content === "string") return content;
+	return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-ollama/src/utils/to-ollama-tools.ts
+/**
+* Convert vendor-neutral `ToolConfig[]` into Ollama's `tools` array.
+* Each tool becomes a `{ type: "function", function: { name,
+* description, parameters } }` entry. Non-object extractions degrade
+* to a parameterless object so registration never fails.
+*
+* Returns `undefined` when there are no tools so the caller can omit
+* `tools` from the request.
+*
+* @example
+* const tools = toOllamaTools([weatherTool]);
+* await ollama.chat({ model, messages, tools });
+*/
+function toOllamaTools(tools) {
+	if (!tools || tools.length === 0) return;
+	return tools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: toParameters(tool.input)
+		}
+	}));
+}
+/**
+* Resolve a tool's input schema to a JSON-Schema object. Ollama wants
+* an object root for function parameters; anything else (or a failed
+* extraction) degrades to a parameterless object.
+*/
+function toParameters(input) {
+	const schema = (0, _warlock_js_ai.extractJsonSchema)(input);
+	if (schema && schema.type === "object") return schema;
+	return { type: "object" };
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-ollama/src/utils/wrap-ollama-error.ts
+/**
+* Wrap any thrown value caught inside the Ollama adapter into the
+* appropriate `@warlock.js/ai` `AIError` subclass.
+*
+* **Dispatch strategy.** HTTP faults carry `status_code`; the local
+* daemon being down surfaces as a connection error (`ECONNREFUSED` /
+* "fetch failed") — mapped to `ProviderError` since it's an
+* operational "is Ollama running?" condition, not a request defect.
+* `400` with context-length phrasing maps to
+* `ContextLengthExceededError`.
+*
+* `AIError` instances pass through unchanged so `catch/throw wrap(e)`
+* pipelines never double-wrap.
+*
+* @example
+* try {
+*   return await this.client.chat({ ... });
+* } catch (thrown) {
+*   throw wrapOllamaError(thrown);
+* }
+*/
+function wrapOllamaError(thrown) {
+	if (thrown instanceof _warlock_js_ai.AIError) return thrown;
+	const shape = toShape(thrown);
+	const context = buildContext(shape);
+	const message = shape.message ?? (thrown instanceof Error ? thrown.message : String(thrown));
+	if (isTimeout(shape)) return new _warlock_js_ai.ProviderTimeoutError(message, {
+		cause: thrown,
+		context
+	});
+	if (isConnectionRefused(shape, message)) return new _warlock_js_ai.ProviderError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.statusCode === 401 || shape.statusCode === 403) return new _warlock_js_ai.ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.statusCode === 429) return new _warlock_js_ai.ProviderRateLimitError(message, {
+		cause: thrown,
+		context
+	});
+	if (isClientStatus(shape.statusCode)) {
+		if (/context length|too long|exceeds|maximum context/i.test(message)) return new _warlock_js_ai.ContextLengthExceededError(message, {
+			cause: thrown,
+			context
+		});
+		return new _warlock_js_ai.InvalidRequestError(message, {
+			cause: thrown,
+			context
+		});
+	}
+	return new _warlock_js_ai.ProviderError(message, {
+		cause: thrown,
+		context
+	});
+}
+/**
+* Read the raw error shape. `ResponseError` exposes `status_code`;
+* fetch-layer errors carry a `cause` whose `code` is the OS-level
+* socket error.
+*/
+function toShape(thrown) {
+	if (typeof thrown !== "object" || thrown === null) return {};
+	const raw = thrown;
+	const cause = raw.cause;
+	return {
+		name: typeof raw.name === "string" ? raw.name : void 0,
+		message: typeof raw.message === "string" ? raw.message : void 0,
+		statusCode: typeof raw.status_code === "number" ? raw.status_code : void 0,
+		code: typeof raw.code === "string" ? raw.code : cause && typeof cause.code === "string" ? cause.code : void 0
+	};
+}
+/** Transport-level timeout signals. */
+function isTimeout(shape) {
+	if (shape.name === "AbortError" || shape.name === "TimeoutError") return true;
+	return shape.code === "ETIMEDOUT" || shape.code === "ECONNABORTED";
+}
+/**
+* The Ollama daemon not being reachable (most common local failure):
+* connection refused at the socket layer, or the `fetch failed`
+* TypeError the client surfaces when the host is down.
+*/
+function isConnectionRefused(shape, message) {
+	return shape.code === "ECONNREFUSED" || /fetch failed|econnrefused/i.test(message);
+}
+/** True for HTTP 4xx — a client-side request problem, not a server fault. */
+function isClientStatus(status) {
+	return typeof status === "number" && status >= 400 && status < 500;
+}
+/** Attach the diagnostic fields to `error.context`. */
+function buildContext(shape) {
+	const context = {};
+	if (shape.statusCode !== void 0) context.status = shape.statusCode;
+	if (shape.code) context.code = shape.code;
+	return context;
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-ollama/src/embedder.ts
+const LOG_MODULE$1 = "ai.ollama";
+/**
+* Ollama-backed implementation of `EmbedderContract`
+* (`nomic-embed-text`, `mxbai-embed-large`, …) via `client.embed`.
+*
+* **Role.** Converts text into floating-point vectors. Standalone
+* primitive — unrelated to chat / tools / the agent loop.
+*
+* **Batch is native.** Ollama's `embed` accepts a string array and
+* returns `embeddings` in input order, so `embedMany` is a single
+* request (like the Gemini adapter, unlike Bedrock/Titan).
+*
+* **Usage.** Ollama returns only `prompt_eval_count` (no separate
+* total); it is reported as both `promptTokens` and `totalTokens`.
+*
+* **Dimensions.** When no `dimensions` override is given,
+* `this.dimensions` starts at `0` and is populated from the first
+* response's vector length, then cached. Passing `dimensions`
+* forwards Ollama's truncation field and sets the initial value.
+*
+* @example
+* const embedder = new OllamaEmbedder(client, { name: "nomic-embed-text" });
+* const { vector } = await embedder.embed("Hello world");
+* const { vectors } = await embedder.embedMany(["doc 1", "doc 2"]);
+*/
+var OllamaEmbedder = class {
+	constructor(client, config, provider = "ollama") {
+		this.logger = _warlock_js_logger.log;
+		this.client = client;
+		this.name = config.name;
+		this.provider = provider;
+		this.configuredDimensions = config.dimensions;
+		this.dimensions = config.dimensions ?? 0;
+	}
+	async embed(input) {
+		const { embeddings, usage } = await this.request([input]);
+		return {
+			vector: embeddings[0] ?? [],
+			dimensions: this.dimensions,
+			usage
+		};
+	}
+	async embedMany(inputs) {
+		const { embeddings, usage } = await this.request(inputs);
+		return {
+			vectors: embeddings,
+			dimensions: this.dimensions,
+			usage
+		};
+	}
+	/**
+	* Shared transport: one `embed` call for the whole batch, wrap
+	* provider errors, cache `dimensions` from the first vector, and
+	* return vectors in input order plus a neutral usage object.
+	*/
+	async request(inputs) {
+		this.logger.debug(LOG_MODULE$1, "embedder.request", "embed", {
+			model: this.name,
+			count: inputs.length
+		});
+		let response;
+		try {
+			response = await this.client.embed({
+				model: this.name,
+				input: inputs,
+				...this.configuredDimensions !== void 0 ? { dimensions: this.configuredDimensions } : {}
+			});
+		} catch (thrown) {
+			const wrapped = wrapOllamaError(thrown);
+			this.logger.error(LOG_MODULE$1, "embedder.error", wrapped.message, {
+				code: wrapped.code,
+				context: wrapped.context
+			});
+			throw wrapped;
+		}
+		const embeddings = response.embeddings ?? [];
+		if (this.dimensions === 0 && embeddings[0]) this.dimensions = embeddings[0].length;
+		const tokens = response.prompt_eval_count ?? 0;
+		const usage = {
+			promptTokens: tokens,
+			totalTokens: tokens
+		};
+		this.logger.debug(LOG_MODULE$1, "embedder.response", "embed returned", {
+			count: embeddings.length,
+			dimensions: this.dimensions
+		});
+		return {
+			embeddings,
+			usage
+		};
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/ai-ollama/src/known-vision-models.ts
+/**
+* Substrings identifying Ollama model tags whose family accepts image
+* input (vision).
+*
+* Ollama tags are family-named with optional size/quant suffixes
+* (`llama3.2-vision:11b`, `llava:13b-v1.6`, `qwen2.5-vl:7b`). A
+* substring match tolerates those suffixes. Covers the common
+* multimodal families on the Ollama registry; text-only models
+* (`llama3.1`, `mistral`, `phi3`, `nomic-embed-text`) are excluded.
+* Override per-model via `ollama.model({ name, vision: true | false })`.
+*/
+const VISION_CAPABLE_SUBSTRINGS = [
+	"llava",
+	"vision",
+	"bakllava",
+	"moondream",
+	"minicpm-v",
+	"qwen2-vl",
+	"qwen2.5-vl",
+	"llama4",
+	"gemma3"
+];
+/**
+* Infer whether an Ollama model tag supports vision based on the known
+* multimodal-family substrings. Unknown tags default to `false` so
+* passing an image to a text-only local model surfaces a clear,
+* agent-side capability error instead of the image being silently
+* ignored by the model.
+*
+* @example
+* inferVisionCapability("llama3.2-vision:11b"); // → true
+* inferVisionCapability("llava:13b");           // → true
+* inferVisionCapability("llama3.1");            // → false
+* inferVisionCapability("nomic-embed-text");    // → false
+*/
+function inferVisionCapability(modelName) {
+	const normalized = modelName.toLowerCase();
+	return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-ollama/src/model.ts
+const LOG_MODULE = "ai.ollama";
+/**
+* Ollama-backed implementation of `ModelContract`.
+*
+* **Role.** The provider-facing bridge between the vendor-neutral
+* `@warlock.js/ai` agent runtime and a local (or self-hosted) Ollama
+* server via the official `ollama` client.
+*
+* **Responsibility.**
+* - Owns: a long-lived `Ollama` client + frozen `ModelConfig` (model
+*   tag, temperature, maxTokens) used as per-call defaults.
+* - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into
+*   Ollama's chat shapes (system stays a real role, `tool_calls` /
+*   `tool_name`, base64 `images`) and Ollama's response (content, tool
+*   calls, done reason, eval-count usage) back into neutral shapes.
+* - Does NOT own: tool dispatch, looping, history, retries — agent
+*   concerns. The model is a per-call protocol adapter.
+*
+* **Tool-call ids.** Ollama has no tool-call id concept — a `tool_call`
+* is `{ function: { name, arguments } }`. The adapter synthesizes the
+* neutral `id` from the tool name so the agent's tool-result round-trip
+* (which keys on `toolCallId`) maps back to Ollama's name-based
+* matching. Parallel calls to the *same* tool in one turn therefore
+* share an id — a documented v1 limitation inherent to Ollama's wire
+* format, not this adapter.
+*
+* Modeled as a class (see §4.2 of code-style.md — "long-lived state
+* across calls").
+*
+* @example
+* import { Ollama } from "ollama";
+* const client = new Ollama({ host: "http://127.0.0.1:11434" });
+* const model = new OllamaModel(client, { name: "llama3.1" });
+*
+* const myAgent = agent({ model, tools: [searchTool] });
+* const result = await myAgent.execute("Summarize today's news.");
+*/
+var OllamaModel = class {
+	constructor(client, config, provider = "ollama") {
+		this.logger = _warlock_js_logger.log;
+		this.client = client;
+		this.config = config;
+		this.name = config.name;
+		this.provider = provider;
+		this.pricing = config.pricing;
+		this.capabilities = {
+			structuredOutput: config.structuredOutput ?? true,
+			vision: config.vision ?? inferVisionCapability(config.name)
+		};
+	}
+	/**
+	* Single-shot completion. Sends the full message list to
+	* `client.chat`, waits for the terminal response, and reshapes it
+	* into a vendor-neutral `ModelResponse`. Per-call `options` override
+	* the instance defaults for this call only.
+	*/
+	async complete(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting chat call", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: false,
+			toolCount: options?.tools?.length ?? 0
+		});
+		let response;
+		try {
+			response = await this.client.chat({
+				...this.buildRequest(messages, options),
+				stream: false
+			});
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		const toolCalls = this.extractToolCalls(response.message);
+		const finishReason = toolCalls ? "tool_calls" : mapDoneReason(response.done_reason);
+		const usage = this.extractUsage(response);
+		this.logger.debug(LOG_MODULE, "response", "chat call succeeded", {
+			finishReason,
+			usage
+		});
+		return {
+			content: response.message?.content ?? "",
+			finishReason,
+			usage,
+			toolCalls
+		};
+	}
+	/**
+	* Incremental streaming completion. Yields neutral
+	* `ModelStreamChunk`s — `delta` for content, `tool-call` per
+	* function call (Ollama streams a fully-formed call, not partial
+	* JSON), and a terminal `done` with the final finish reason + usage.
+	* Honors `options.signal` by aborting the underlying stream.
+	*/
+	async *stream(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting streaming chat call", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: true,
+			toolCount: options?.tools?.length ?? 0
+		});
+		let stream;
+		try {
+			stream = await this.client.chat({
+				...this.buildRequest(messages, options),
+				stream: true
+			});
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		if (options?.signal) if (options.signal.aborted) stream.abort();
+		else options.signal.addEventListener("abort", () => stream.abort(), { once: true });
+		let rawDoneReason;
+		let sawToolCall = false;
+		const usage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		try {
+			for await (const chunk of stream) {
+				const content = chunk.message?.content;
+				if (content) yield {
+					type: "delta",
+					content
+				};
+				for (const call of chunk.message?.tool_calls ?? []) {
+					sawToolCall = true;
+					yield {
+						type: "tool-call",
+						id: call.function.name,
+						name: call.function.name,
+						input: call.function.arguments ?? {}
+					};
+				}
+				if (chunk.done_reason) rawDoneReason = chunk.done_reason;
+				if (chunk.done) {
+					usage.input = chunk.prompt_eval_count ?? usage.input;
+					usage.output = chunk.eval_count ?? usage.output;
+					usage.total = usage.input + usage.output;
+				}
+			}
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		const finishReason = sawToolCall ? "tool_calls" : mapDoneReason(rawDoneReason);
+		this.logger.debug(LOG_MODULE, "response", "streaming chat call succeeded", {
+			finishReason,
+			usage
+		});
+		yield {
+			type: "done",
+			finishReason,
+			usage
+		};
+	}
+	/**
+	* Assemble the Ollama chat request shared by `complete()` and
+	* `stream()` (each adds its own `stream` literal so the client's
+	* overload resolves). Maps inference params into Ollama `options`
+	* and conditionally attaches tools + native structured output.
+	*/
+	buildRequest(messages, options) {
+		const temperature = options?.temperature ?? this.config.temperature;
+		const maxTokens = options?.maxTokens ?? this.config.maxTokens;
+		const ollamaOptions = {
+			...temperature !== void 0 ? { temperature } : {},
+			...maxTokens !== void 0 ? { num_predict: maxTokens } : {}
+		};
+		return {
+			model: this.name,
+			messages: toOllamaMessages(messages),
+			...Object.keys(ollamaOptions).length > 0 ? { options: ollamaOptions } : {},
+			...this.buildTools(options?.tools),
+			...this.buildFormat(options?.responseSchema)
+		};
+	}
+	/**
+	* Spread-friendly tools fragment. Empty object when no tools were
+	* supplied so the caller can unconditionally spread it.
+	*/
+	buildTools(tools) {
+		const mapped = toOllamaTools(tools);
+		return mapped ? { tools: mapped } : {};
+	}
+	/**
+	* Translate the neutral `responseSchema` into Ollama's native
+	* structured output (`format` accepts a JSON Schema object).
+	* Emitted only when the model is `structuredOutput`-capable and the
+	* schema is an object root — otherwise the agent's soft prompt hint
+	* + client-side `validate()` carry shape.
+	*/
+	buildFormat(responseSchema) {
+		if (!responseSchema || !this.capabilities.structuredOutput) return {};
+		if (responseSchema.type !== "object" || typeof responseSchema.properties !== "object") return {};
+		return { format: responseSchema };
+	}
+	/**
+	* Reshape Ollama's `message.tool_calls` into the neutral
+	* `ModelToolCallRequest[]`. Ollama has no tool-call id, so the
+	* neutral `id` is synthesized from the tool name (see the class
+	* doc). Returns `undefined` when no tools were requested.
+	*/
+	extractToolCalls(message) {
+		const calls = message?.tool_calls;
+		if (!calls || calls.length === 0) return;
+		return calls.map((call) => ({
+			id: call.function.name,
+			name: call.function.name,
+			input: call.function.arguments ?? {}
+		}));
+	}
+	/**
+	* Normalize Ollama's eval counts into the neutral `Usage` shape.
+	* Ollama runs locally with no prompt cache, so there is no
+	* `cachedTokens`; `total` is computed from input + output.
+	*/
+	extractUsage(response) {
+		const input = response.prompt_eval_count ?? 0;
+		const output = response.eval_count ?? 0;
+		return {
+			input,
+			output,
+			total: input + output
+		};
+	}
+	/**
+	* Wrap a thrown provider error into the typed `AIError` hierarchy
+	* and emit the standard error log line before it propagates.
+	*/
+	logAndWrap(thrown) {
+		const wrapped = wrapOllamaError(thrown);
+		this.logger.error(LOG_MODULE, "error", wrapped.message, {
+			code: wrapped.code,
+			context: wrapped.context
+		});
+		return wrapped;
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/ai-ollama/src/sdk.ts
+/**
+* Ollama-backed implementation of `SDKAdapterContract`.
+*
+* **Role.** The package entry point for local / self-hosted models
+* served by an Ollama daemon via the official `ollama` client. One
+* `OllamaSDK` holds one live `Ollama` client, shared by every
+* `ModelContract` / `EmbedderContract` it produces.
+*
+* **Responsibility.**
+* - Owns: a long-lived `Ollama` client (host, headers) and its
+*   lifetime. Factory for `OllamaModel` / `OllamaEmbedder` instances
+*   sharing that client.
+* - Does NOT own: anything per-call — those live in `OllamaModel` /
+*   `OllamaEmbedder` and the agent runtime.
+*
+* Modeled as a class (see §4.2 of code-style.md — "long-lived state
+* across many calls"), fronted by FP usage like the other adapters.
+*
+* @example
+* const ollama = new OllamaSDK({});                  // local default host
+* const model = ollama.model({ name: "llama3.1", temperature: 0.7 });
+* const embedder = ollama.embedder({ name: "nomic-embed-text" });
+*/
+var OllamaSDK = class {
+	constructor(config = {}) {
+		const { provider, pricing, ...clientConfig } = config;
+		this.client = new ollama.Ollama(clientConfig);
+		this.provider = provider ?? "ollama";
+		this.pricing = pricing;
+	}
+	/**
+	* Build an `OllamaModel` bound to this SDK's client. Each call
+	* returns a fresh instance; all instances share the underlying
+	* `Ollama` client. The SDK's `provider` label is forwarded.
+	*
+	* Pricing resolution: per-model `config.pricing` wins; otherwise the
+	* SDK-level registry entry keyed by `config.name`; otherwise
+	* `undefined` (local Ollama is free, so usually undefined).
+	*/
+	model(config) {
+		const resolvedPricing = config.pricing ?? this.pricing?.[config.name];
+		const resolvedConfig = resolvedPricing === config.pricing ? config : {
+			...config,
+			pricing: resolvedPricing
+		};
+		return new OllamaModel(this.client, resolvedConfig, this.provider);
+	}
+	/**
+	* Rough token-count estimate. Uses the character-heuristic
+	* (`approximateTokenCount`) from the core package — good enough for
+	* budgeting / context guards, not billing (and Ollama is free
+	* anyway). The optional model id is reserved for future per-model
+	* tokenizer dispatch; currently ignored.
+	*/
+	async count(text, _model) {
+		return (0, _warlock_js_ai.approximateTokenCount)(text);
+	}
+	/**
+	* Build an `OllamaEmbedder` bound to this SDK's client.
+	*
+	* @example
+	* const embedder = ollama.embedder({ name: "nomic-embed-text" });
+	* const { vector } = await embedder.embed("Hello world");
+	*/
+	embedder(config) {
+		return new OllamaEmbedder(this.client, config, this.provider);
+	}
+};
+
+//#endregion
+exports.OllamaSDK = OllamaSDK;
+//# sourceMappingURL=index.cjs.map