@warlock.js/ai-ollama 4.1.1

package/esm/sdk.d.mts

@@ -0,0 +1,62 @@
+import { OllamaEmbedderConfig, OllamaModelConfig, OllamaSDKConfig } from "./config.type.mjs";
+import { EmbedderContract, ModelContract, SDKAdapterContract } from "@warlock.js/ai";
+
+//#region ../../@warlock.js/ai-ollama/src/sdk.d.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" });
+ */
+declare class OllamaSDK implements SDKAdapterContract {
+  private readonly client;
+  private readonly provider;
+  private readonly pricing?;
+  constructor(config?: OllamaSDKConfig);
+  /**
+   * 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: OllamaModelConfig): ModelContract;
+  /**
+   * 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.
+   */
+  count(text: string, _model?: string): Promise<number>;
+  /**
+   * 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: OllamaEmbedderConfig): EmbedderContract;
+}
+//#endregion
+export { OllamaSDK };
+//# sourceMappingURL=sdk.d.mts.map

package/esm/sdk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../@warlock.js/ai-ollama/src/sdk.ts"],"mappings":";;;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;cAAa,SAAA,YAAqB,kBAAA;EAAA,iBACf,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,OAAA;cAEE,MAAA,GAAQ,eAAA;EAgCwB;;;;;;AAWY;;;EA1BxD,KAAA,CAAM,MAAA,EAAQ,iBAAA,GAAoB,aAAA;;;;;;;;EAe5B,KAAA,CAAM,IAAA,UAAc,MAAA,YAAkB,OAAA;;;;;;;;EAW5C,QAAA,CAAS,MAAA,EAAQ,oBAAA,GAAuB,gBAAA;AAAA"}

package/esm/sdk.mjs

@@ -0,0 +1,78 @@
+import { OllamaEmbedder } from "./embedder.mjs";
+import { OllamaModel } from "./model.mjs";
+import { Ollama } from "ollama";
+import { approximateTokenCount } from "@warlock.js/ai";
+
+//#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(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 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
+export { OllamaSDK };
+//# sourceMappingURL=sdk.mjs.map

package/esm/sdk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../@warlock.js/ai-ollama/src/sdk.ts"],"sourcesContent":["import { Ollama } from \"ollama\";\nimport type {\n  EmbedderContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { approximateTokenCount } from \"@warlock.js/ai\";\nimport type {\n  OllamaEmbedderConfig,\n  OllamaModelConfig,\n  OllamaSDKConfig,\n} from \"./config.type\";\nimport { OllamaEmbedder } from \"./embedder\";\nimport { OllamaModel } from \"./model\";\n\n/**\n * Ollama-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for local / self-hosted models\n * served by an Ollama daemon via the official `ollama` client. One\n * `OllamaSDK` holds one live `Ollama` client, shared by every\n * `ModelContract` / `EmbedderContract` it produces.\n *\n * **Responsibility.**\n * - Owns: a long-lived `Ollama` client (host, headers) and its\n *   lifetime. Factory for `OllamaModel` / `OllamaEmbedder` instances\n *   sharing that client.\n * - Does NOT own: anything per-call — those live in `OllamaModel` /\n *   `OllamaEmbedder` and the agent runtime.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"), fronted by FP usage like the other adapters.\n *\n * @example\n * const ollama = new OllamaSDK({});                  // local default host\n * const model = ollama.model({ name: \"llama3.1\", temperature: 0.7 });\n * const embedder = ollama.embedder({ name: \"nomic-embed-text\" });\n */\nexport class OllamaSDK implements SDKAdapterContract {\n  private readonly client: Ollama;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: OllamaSDKConfig = {}) {\n    const { provider, pricing, ...clientConfig } = config;\n\n    this.client = new Ollama(clientConfig);\n    this.provider = provider ?? \"ollama\";\n    this.pricing = pricing;\n  }\n\n  /**\n   * Build an `OllamaModel` bound to this SDK's client. Each call\n   * returns a fresh instance; all instances share the underlying\n   * `Ollama` client. The SDK's `provider` label is forwarded.\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise the\n   * SDK-level registry entry keyed by `config.name`; otherwise\n   * `undefined` (local Ollama is free, so usually undefined).\n   */\n  public model(config: OllamaModelConfig): ModelContract {\n    const resolvedPricing = config.pricing ?? this.pricing?.[config.name];\n    const resolvedConfig: OllamaModelConfig =\n      resolvedPricing === config.pricing ? config : { ...config, pricing: resolvedPricing };\n\n    return new OllamaModel(this.client, resolvedConfig, this.provider);\n  }\n\n  /**\n   * Rough token-count estimate. Uses the character-heuristic\n   * (`approximateTokenCount`) from the core package — good enough for\n   * budgeting / context guards, not billing (and Ollama is free\n   * anyway). The optional model id is reserved for future per-model\n   * tokenizer dispatch; currently ignored.\n   */\n  public async count(text: string, _model?: string): Promise<number> {\n    return approximateTokenCount(text);\n  }\n\n  /**\n   * Build an `OllamaEmbedder` bound to this SDK's client.\n   *\n   * @example\n   * const embedder = ollama.embedder({ name: \"nomic-embed-text\" });\n   * const { vector } = await embedder.embed(\"Hello world\");\n   */\n  public embedder(config: OllamaEmbedderConfig): EmbedderContract {\n    return new OllamaEmbedder(this.client, config, this.provider);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,YAAb,MAAqD;CAKnD,AAAO,YAAY,SAA0B,CAAC,GAAG;EAC/C,MAAM,EAAE,UAAU,SAAS,GAAG,iBAAiB;EAE/C,KAAK,SAAS,IAAI,OAAO,YAAY;EACrC,KAAK,WAAW,YAAY;EAC5B,KAAK,UAAU;CACjB;;;;;;;;;;CAWA,AAAO,MAAM,QAA0C;EACrD,MAAM,kBAAkB,OAAO,WAAW,KAAK,UAAU,OAAO;EAChE,MAAM,iBACJ,oBAAoB,OAAO,UAAU,SAAS;GAAE,GAAG;GAAQ,SAAS;EAAgB;EAEtF,OAAO,IAAI,YAAY,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;CACnE;;;;;;;;CASA,MAAa,MAAM,MAAc,QAAkC;EACjE,OAAO,sBAAsB,IAAI;CACnC;;;;;;;;CASA,AAAO,SAAS,QAAgD;EAC9D,OAAO,IAAI,eAAe,KAAK,QAAQ,QAAQ,KAAK,QAAQ;CAC9D;AACF"}

package/esm/utils/index.mjs

@@ -0,0 +1,6 @@
+import { mapDoneReason } from "./map-done-reason.mjs";
+import { toOllamaMessages } from "./to-ollama-messages.mjs";
+import { toOllamaTools } from "./to-ollama-tools.mjs";
+import { wrapOllamaError } from "./wrap-ollama-error.mjs";
+
+export {  };

package/esm/utils/map-done-reason.mjs

@@ -0,0 +1,31 @@
+//#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
+export { mapDoneReason };
+//# sourceMappingURL=map-done-reason.mjs.map

package/esm/utils/map-done-reason.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-done-reason.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-ollama/src/utils/map-done-reason.ts"],"sourcesContent":["import type { FinishReason } from \"@warlock.js/ai\";\n\nconst doneReasonMap: Record<string, FinishReason> = {\n  stop: \"stop\",\n  length: \"length\",\n};\n\n/**\n * Map Ollama's `done_reason` to the normalized `FinishReason` union.\n *\n * `stop` is the natural terminal; `length` means the `num_predict`\n * cap was hit. Anything else — `load` (model load only, no\n * generation), an empty string, or any future value — falls through\n * to `\"error\"`.\n *\n * Note: Ollama has no tool-use done reason — it sets `done_reason:\n * \"stop\"` and populates `message.tool_calls`. `OllamaModel` derives\n * `\"tool_calls\"` from tool-call presence; this map stays purely about\n * the raw signal.\n *\n * @example\n * mapDoneReason(\"stop\");    // \"stop\"\n * mapDoneReason(\"length\");  // \"length\"\n * mapDoneReason(\"load\");    // \"error\"\n * mapDoneReason(undefined); // \"error\"\n */\nexport function mapDoneReason(raw: string | null | undefined): FinishReason {\n  return doneReasonMap[raw ?? \"\"] ?? \"error\";\n}\n"],"mappings":";AAEA,MAAM,gBAA8C;CAClD,MAAM;CACN,QAAQ;AACV;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,cAAc,KAA8C;CAC1E,OAAO,cAAc,OAAO,OAAO;AACrC"}

package/esm/utils/to-ollama-messages.mjs

@@ -0,0 +1,87 @@
+import { InvalidRequestError } from "@warlock.js/ai";
+
+//#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 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
+export { toOllamaMessages };
+//# sourceMappingURL=to-ollama-messages.mjs.map

package/esm/utils/to-ollama-messages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-ollama-messages.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-ollama/src/utils/to-ollama-messages.ts"],"sourcesContent":["import { InvalidRequestError, type ContentPart, type Message } from \"@warlock.js/ai\";\nimport type { Message as OllamaMessage } from \"ollama\";\n\n/**\n * Convert vendor-neutral `Message[]` into the Ollama chat message\n * shape.\n *\n * Unlike Anthropic / Gemini / Bedrock, Ollama keeps a first-class\n * `system` role inside `messages`, so there is no system-prompt\n * hoisting — roles pass straight through. The Ollama specifics this\n * absorbs:\n *\n * 1. **Tool calls.** An assistant message with `toolCalls` becomes an\n *    `assistant` message whose `tool_calls` is the Ollama\n *    `{ function: { name, arguments } }` shape (Ollama has no tool-call\n *    id — see `OllamaModel`/decisions for the synthesized-id note).\n * 2. **Tool results.** A neutral `tool` message becomes a `tool`\n *    message with `tool_name` set from `toolCallId` (Ollama matches a\n *    result to its call by tool name).\n * 3. **Images.** Multipart user content collapses to a single\n *    `content` string plus an `images` array of base64 strings.\n *\n * @example\n * const messages = toOllamaMessages([\n *   { role: \"system\", content: \"Be concise.\" },\n *   { role: \"user\", content: \"Hi\" },\n * ]);\n */\nexport function toOllamaMessages(messages: Message[]): OllamaMessage[] {\n  return messages.map((message): OllamaMessage => {\n    if (message.role === \"tool\") {\n      return {\n        role: \"tool\",\n        content: stringifyContent(message.content),\n        tool_name: message.toolCallId ?? \"\",\n      };\n    }\n\n    if (message.role === \"assistant\" && message.toolCalls && message.toolCalls.length > 0) {\n      return {\n        role: \"assistant\",\n        content: stringifyContent(message.content),\n        tool_calls: message.toolCalls.map((toolCall) => ({\n          function: {\n            name: toolCall.name,\n            arguments: (toolCall.input ?? {}) as Record<string, unknown>,\n          },\n        })),\n      };\n    }\n\n    if (message.role === \"user\" && Array.isArray(message.content)) {\n      return toMultipartMessage(message.content);\n    }\n\n    return { role: message.role, content: stringifyContent(message.content) };\n  });\n}\n\n/**\n * Collapse a `ContentPart[]` user message into Ollama's\n * single-string-content + base64-`images` shape. Ollama cannot fetch\n * remote URLs, so a `{ url }` image surfaces a typed\n * `InvalidRequestError` upfront (consistent with the Bedrock/Gemini\n * adapters). The agent has already resolved attachments — nothing is\n * fetched here.\n */\nfunction toMultipartMessage(parts: ContentPart[]): OllamaMessage {\n  const textChunks: string[] = [];\n  const images: string[] = [];\n\n  for (const part of parts) {\n    if (part.type === \"text\") {\n      textChunks.push(part.text);\n\n      continue;\n    }\n\n    if (\"url\" in part.source) {\n      throw new InvalidRequestError(\n        \"Ollama does not fetch remote-URL images; supply base64 image bytes instead.\",\n      );\n    }\n\n    images.push(part.source.base64);\n  }\n\n  return {\n    role: \"user\",\n    content: textChunks.join(\"\"),\n    ...(images.length > 0 ? { images } : {}),\n  };\n}\n\n/**\n * Multipart content on a non-user role collapses to concatenated text;\n * plain strings pass through unchanged.\n */\nfunction stringifyContent(content: string | ContentPart[]): string {\n  if (typeof content === \"string\") {\n    return content;\n  }\n\n  return content\n    .filter((part): part is { type: \"text\"; text: string } => part.type === \"text\")\n    .map((part) => part.text)\n    .join(\"\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,iBAAiB,UAAsC;CACrE,OAAO,SAAS,KAAK,YAA2B;EAC9C,IAAI,QAAQ,SAAS,QACnB,OAAO;GACL,MAAM;GACN,SAAS,iBAAiB,QAAQ,OAAO;GACzC,WAAW,QAAQ,cAAc;EACnC;EAGF,IAAI,QAAQ,SAAS,eAAe,QAAQ,aAAa,QAAQ,UAAU,SAAS,GAClF,OAAO;GACL,MAAM;GACN,SAAS,iBAAiB,QAAQ,OAAO;GACzC,YAAY,QAAQ,UAAU,KAAK,cAAc,EAC/C,UAAU;IACR,MAAM,SAAS;IACf,WAAY,SAAS,SAAS,CAAC;GACjC,EACF,EAAE;EACJ;EAGF,IAAI,QAAQ,SAAS,UAAU,MAAM,QAAQ,QAAQ,OAAO,GAC1D,OAAO,mBAAmB,QAAQ,OAAO;EAG3C,OAAO;GAAE,MAAM,QAAQ;GAAM,SAAS,iBAAiB,QAAQ,OAAO;EAAE;CAC1E,CAAC;AACH;;;;;;;;;AAUA,SAAS,mBAAmB,OAAqC;CAC/D,MAAM,aAAuB,CAAC;CAC9B,MAAM,SAAmB,CAAC;CAE1B,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,KAAK,SAAS,QAAQ;GACxB,WAAW,KAAK,KAAK,IAAI;GAEzB;EACF;EAEA,IAAI,SAAS,KAAK,QAChB,MAAM,IAAI,oBACR,6EACF;EAGF,OAAO,KAAK,KAAK,OAAO,MAAM;CAChC;CAEA,OAAO;EACL,MAAM;EACN,SAAS,WAAW,KAAK,EAAE;EAC3B,GAAI,OAAO,SAAS,IAAI,EAAE,OAAO,IAAI,CAAC;CACxC;AACF;;;;;AAMA,SAAS,iBAAiB,SAAyC;CACjE,IAAI,OAAO,YAAY,UACrB,OAAO;CAGT,OAAO,QACJ,QAAQ,SAAiD,KAAK,SAAS,MAAM,EAC7E,KAAK,SAAS,KAAK,IAAI,EACvB,KAAK,EAAE;AACZ"}

package/esm/utils/to-ollama-tools.mjs

@@ -0,0 +1,41 @@
+import { extractJsonSchema } from "@warlock.js/ai";
+
+//#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 = extractJsonSchema(input);
+	if (schema && schema.type === "object") return schema;
+	return { type: "object" };
+}
+
+//#endregion
+export { toOllamaTools };
+//# sourceMappingURL=to-ollama-tools.mjs.map

package/esm/utils/to-ollama-tools.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-ollama-tools.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-ollama/src/utils/to-ollama-tools.ts"],"sourcesContent":["import { extractJsonSchema, type ToolConfig } from \"@warlock.js/ai\";\nimport type { Tool } from \"ollama\";\n\n/**\n * Convert vendor-neutral `ToolConfig[]` into Ollama's `tools` array.\n * Each tool becomes a `{ type: \"function\", function: { name,\n * description, parameters } }` entry. Non-object extractions degrade\n * to a parameterless object so registration never fails.\n *\n * Returns `undefined` when there are no tools so the caller can omit\n * `tools` from the request.\n *\n * @example\n * const tools = toOllamaTools([weatherTool]);\n * await ollama.chat({ model, messages, tools });\n */\nexport function toOllamaTools(\n  tools: ToolConfig<unknown, unknown>[] | undefined,\n): Tool[] | undefined {\n  if (!tools || tools.length === 0) {\n    return undefined;\n  }\n\n  return tools.map((tool) => ({\n    type: \"function\",\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: toParameters(tool.input),\n    },\n  }));\n}\n\n/**\n * Resolve a tool's input schema to a JSON-Schema object. Ollama wants\n * an object root for function parameters; anything else (or a failed\n * extraction) degrades to a parameterless object.\n */\nfunction toParameters(input: ToolConfig<unknown, unknown>[\"input\"]): Tool[\"function\"][\"parameters\"] {\n  const schema = extractJsonSchema(input);\n\n  if (schema && schema.type === \"object\") {\n    return schema as Tool[\"function\"][\"parameters\"];\n  }\n\n  return { type: \"object\" } as Tool[\"function\"][\"parameters\"];\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAgB,cACd,OACoB;CACpB,IAAI,CAAC,SAAS,MAAM,WAAW,GAC7B;CAGF,OAAO,MAAM,KAAK,UAAU;EAC1B,MAAM;EACN,UAAU;GACR,MAAM,KAAK;GACX,aAAa,KAAK;GAClB,YAAY,aAAa,KAAK,KAAK;EACrC;CACF,EAAE;AACJ;;;;;;AAOA,SAAS,aAAa,OAA8E;CAClG,MAAM,SAAS,kBAAkB,KAAK;CAEtC,IAAI,UAAU,OAAO,SAAS,UAC5B,OAAO;CAGT,OAAO,EAAE,MAAM,SAAS;AAC1B"}

package/esm/utils/wrap-ollama-error.mjs

@@ -0,0 +1,104 @@
+import { AIError, ContextLengthExceededError, InvalidRequestError, ProviderAuthError, ProviderError, ProviderRateLimitError, ProviderTimeoutError } from "@warlock.js/ai";
+
+//#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 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 ProviderTimeoutError(message, {
+		cause: thrown,
+		context
+	});
+	if (isConnectionRefused(shape, message)) return new ProviderError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.statusCode === 401 || shape.statusCode === 403) return new ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.statusCode === 429) return new ProviderRateLimitError(message, {
+		cause: thrown,
+		context
+	});
+	if (isClientStatus(shape.statusCode)) {
+		if (/context length|too long|exceeds|maximum context/i.test(message)) return new ContextLengthExceededError(message, {
+			cause: thrown,
+			context
+		});
+		return new InvalidRequestError(message, {
+			cause: thrown,
+			context
+		});
+	}
+	return new 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
+export { wrapOllamaError };
+//# sourceMappingURL=wrap-ollama-error.mjs.map

package/esm/utils/wrap-ollama-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-ollama-error.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-ollama/src/utils/wrap-ollama-error.ts"],"sourcesContent":["import {\n  AIError,\n  ContextLengthExceededError,\n  InvalidRequestError,\n  ProviderAuthError,\n  ProviderError,\n  ProviderRateLimitError,\n  ProviderTimeoutError,\n} from \"@warlock.js/ai\";\n\n/**\n * Raw-error fields the wrapper reads off an Ollama client error. The\n * `ollama` client throws a `ResponseError` (`name: \"ResponseError\"`,\n * numeric `status_code`, message = the server's `error` text) for HTTP\n * faults; transport failures surface as a `fetch`-layer `TypeError`\n * with an `ECONNREFUSED` / `ETIMEDOUT` cause. We duck-type both —\n * `ResponseError` is internal to the package and not exported.\n */\ntype OllamaErrorShape = {\n  name?: string;\n  message?: string;\n  statusCode?: number;\n  code?: string;\n};\n\n/**\n * Wrap any thrown value caught inside the Ollama adapter into the\n * appropriate `@warlock.js/ai` `AIError` subclass.\n *\n * **Dispatch strategy.** HTTP faults carry `status_code`; the local\n * daemon being down surfaces as a connection error (`ECONNREFUSED` /\n * \"fetch failed\") — mapped to `ProviderError` since it's an\n * operational \"is Ollama running?\" condition, not a request defect.\n * `400` with context-length phrasing maps to\n * `ContextLengthExceededError`.\n *\n * `AIError` instances pass through unchanged so `catch/throw wrap(e)`\n * pipelines never double-wrap.\n *\n * @example\n * try {\n *   return await this.client.chat({ ... });\n * } catch (thrown) {\n *   throw wrapOllamaError(thrown);\n * }\n */\nexport function wrapOllamaError(thrown: unknown): AIError {\n  if (thrown instanceof AIError) {\n    return thrown;\n  }\n\n  const shape = toShape(thrown);\n  const context = buildContext(shape);\n  const message = shape.message ?? (thrown instanceof Error ? thrown.message : String(thrown));\n\n  if (isTimeout(shape)) {\n    return new ProviderTimeoutError(message, { cause: thrown, context });\n  }\n\n  if (isConnectionRefused(shape, message)) {\n    return new ProviderError(message, { cause: thrown, context });\n  }\n\n  if (shape.statusCode === 401 || shape.statusCode === 403) {\n    return new ProviderAuthError(message, { cause: thrown, context });\n  }\n\n  if (shape.statusCode === 429) {\n    return new ProviderRateLimitError(message, { cause: thrown, context });\n  }\n\n  if (isClientStatus(shape.statusCode)) {\n    if (/context length|too long|exceeds|maximum context/i.test(message)) {\n      return new ContextLengthExceededError(message, { cause: thrown, context });\n    }\n\n    return new InvalidRequestError(message, { cause: thrown, context });\n  }\n\n  return new ProviderError(message, { cause: thrown, context });\n}\n\n/**\n * Read the raw error shape. `ResponseError` exposes `status_code`;\n * fetch-layer errors carry a `cause` whose `code` is the OS-level\n * socket error.\n */\nfunction toShape(thrown: unknown): OllamaErrorShape {\n  if (typeof thrown !== \"object\" || thrown === null) {\n    return {};\n  }\n\n  const raw = thrown as Record<string, unknown>;\n  const cause = raw.cause as Record<string, unknown> | undefined;\n\n  return {\n    name: typeof raw.name === \"string\" ? raw.name : undefined,\n    message: typeof raw.message === \"string\" ? raw.message : undefined,\n    statusCode: typeof raw.status_code === \"number\" ? raw.status_code : undefined,\n    code:\n      typeof raw.code === \"string\"\n        ? raw.code\n        : cause && typeof cause.code === \"string\"\n          ? cause.code\n          : undefined,\n  };\n}\n\n/** Transport-level timeout signals. */\nfunction isTimeout(shape: OllamaErrorShape): boolean {\n  if (shape.name === \"AbortError\" || shape.name === \"TimeoutError\") {\n    return true;\n  }\n\n  return shape.code === \"ETIMEDOUT\" || shape.code === \"ECONNABORTED\";\n}\n\n/**\n * The Ollama daemon not being reachable (most common local failure):\n * connection refused at the socket layer, or the `fetch failed`\n * TypeError the client surfaces when the host is down.\n */\nfunction isConnectionRefused(shape: OllamaErrorShape, message: string): boolean {\n  return shape.code === \"ECONNREFUSED\" || /fetch failed|econnrefused/i.test(message);\n}\n\n/** True for HTTP 4xx — a client-side request problem, not a server fault. */\nfunction isClientStatus(status: number | undefined): boolean {\n  return typeof status === \"number\" && status >= 400 && status < 500;\n}\n\n/** Attach the diagnostic fields to `error.context`. */\nfunction buildContext(shape: OllamaErrorShape): Record<string, unknown> {\n  const context: Record<string, unknown> = {};\n\n  if (shape.statusCode !== undefined) {\n    context.status = shape.statusCode;\n  }\n\n  if (shape.code) {\n    context.code = shape.code;\n  }\n\n  return context;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,gBAAgB,QAA0B;CACxD,IAAI,kBAAkB,SACpB,OAAO;CAGT,MAAM,QAAQ,QAAQ,MAAM;CAC5B,MAAM,UAAU,aAAa,KAAK;CAClC,MAAM,UAAU,MAAM,YAAY,kBAAkB,QAAQ,OAAO,UAAU,OAAO,MAAM;CAE1F,IAAI,UAAU,KAAK,GACjB,OAAO,IAAI,qBAAqB,SAAS;EAAE,OAAO;EAAQ;CAAQ,CAAC;CAGrE,IAAI,oBAAoB,OAAO,OAAO,GACpC,OAAO,IAAI,cAAc,SAAS;EAAE,OAAO;EAAQ;CAAQ,CAAC;CAG9D,IAAI,MAAM,eAAe,OAAO,MAAM,eAAe,KACnD,OAAO,IAAI,kBAAkB,SAAS;EAAE,OAAO;EAAQ;CAAQ,CAAC;CAGlE,IAAI,MAAM,eAAe,KACvB,OAAO,IAAI,uBAAuB,SAAS;EAAE,OAAO;EAAQ;CAAQ,CAAC;CAGvE,IAAI,eAAe,MAAM,UAAU,GAAG;EACpC,IAAI,mDAAmD,KAAK,OAAO,GACjE,OAAO,IAAI,2BAA2B,SAAS;GAAE,OAAO;GAAQ;EAAQ,CAAC;EAG3E,OAAO,IAAI,oBAAoB,SAAS;GAAE,OAAO;GAAQ;EAAQ,CAAC;CACpE;CAEA,OAAO,IAAI,cAAc,SAAS;EAAE,OAAO;EAAQ;CAAQ,CAAC;AAC9D;;;;;;AAOA,SAAS,QAAQ,QAAmC;CAClD,IAAI,OAAO,WAAW,YAAY,WAAW,MAC3C,OAAO,CAAC;CAGV,MAAM,MAAM;CACZ,MAAM,QAAQ,IAAI;CAElB,OAAO;EACL,MAAM,OAAO,IAAI,SAAS,WAAW,IAAI,OAAO;EAChD,SAAS,OAAO,IAAI,YAAY,WAAW,IAAI,UAAU;EACzD,YAAY,OAAO,IAAI,gBAAgB,WAAW,IAAI,cAAc;EACpE,MACE,OAAO,IAAI,SAAS,WAChB,IAAI,OACJ,SAAS,OAAO,MAAM,SAAS,WAC7B,MAAM,OACN;CACV;AACF;;AAGA,SAAS,UAAU,OAAkC;CACnD,IAAI,MAAM,SAAS,gBAAgB,MAAM,SAAS,gBAChD,OAAO;CAGT,OAAO,MAAM,SAAS,eAAe,MAAM,SAAS;AACtD;;;;;;AAOA,SAAS,oBAAoB,OAAyB,SAA0B;CAC9E,OAAO,MAAM,SAAS,kBAAkB,6BAA6B,KAAK,OAAO;AACnF;;AAGA,SAAS,eAAe,QAAqC;CAC3D,OAAO,OAAO,WAAW,YAAY,UAAU,OAAO,SAAS;AACjE;;AAGA,SAAS,aAAa,OAAkD;CACtE,MAAM,UAAmC,CAAC;CAE1C,IAAI,MAAM,eAAe,QACvB,QAAQ,SAAS,MAAM;CAGzB,IAAI,MAAM,MACR,QAAQ,OAAO,MAAM;CAGvB,OAAO;AACT"}

package/llms-full.txt

@@ -0,0 +1,122 @@
+# Warlock AI Ollama — full skills
+
+> Package: `@warlock.js/ai-ollama`
+
+> Generated artifact. Concatenates every SKILL.md and reference file under `@warlock.js/ai-ollama/skills/`. Re-run `node scripts/generate-llms.mjs` after any change.
+
+## setup-ollama  `@warlock.js/ai-ollama/setup-ollama/SKILL.md`
+
+---
+name: setup-ollama
+description: 'Wire @warlock.js/ai-ollama — new OllamaSDK({host?, headers?}) for local / self-hosted Ollama via the official ollama client (not OpenAI-compat). chat + embed, daemon-down error handling. Triggers: `OllamaSDK`, `ollama.model`, `ollama.embedder`, `embedder.embedMany`, `ollama.count`, `host`, `headers`; "use ollama with warlock", "run llama3 locally", "self-hosted llama"; typical import `import { OllamaSDK } from "@warlock.js/ai-ollama"`. Skip: agent loop — `@warlock.js/ai/run-ai-agent/SKILL.md`; provider choice — `@warlock.js/ai/pick-ai-provider/SKILL.md`; embeddings core — `@warlock.js/ai/embed-text/SKILL.md`; siblings `@warlock.js/ai-openai`, `@warlock.js/ai-anthropic`, `@warlock.js/ai-google`; raw `ollama` npm, Vercel `@ai-sdk/ollama`; OpenAI-compat gateway via `@warlock.js/ai-openai` `baseURL`.'
+---
+
+# `@warlock.js/ai-ollama`
+
+Provider adapter that turns a local (or self-hosted) Ollama server into a vendor-neutral `ModelContract`, plus an Ollama embedder. Uses the **official `ollama` npm package** (not OpenAI-compat). Mirrors the openai / anthropic / bedrock / google adapters.
+
+## Construction
+
+```ts
+import { OllamaSDK } from "@warlock.js/ai-ollama";
+
+const ollama = new OllamaSDK();                                  // local default host
+const remote = new OllamaSDK({ host: "http://gpu-box.internal:11434" });
+const gated  = new OllamaSDK({
+  host: "https://ollama.internal",
+  headers: { Authorization: `Bearer ${process.env.OLLAMA_TOKEN}` },
+});
+```
+
+`OllamaSDK` is a class with a long-lived `Ollama` client. Config is `Partial<Config>` (host defaults to `http://127.0.0.1:11434`) + `provider` (default `"ollama"`) + optional `pricing` (local is free; kept for parity/chargeback).
+
+## Producing a model
+
+```ts
+ollama.model({ name: "llama3.1" })
+ollama.model({ name: "qwen2.5:14b", temperature: 0.2 })
+ollama.model({ name: "llama3.2-vision", maxTokens: 1024 })
+```
+
+## Capabilities — what's auto-set
+
+| Flag | Default |
+| --- | --- |
+| `structuredOutput` | `true` (via Ollama's native `format` JSON-schema field) |
+| `vision` | Inferred from model tag substring. `true` for `llava`, `bakllava`, `*-vision`, `moondream`, `minicpm-v`, `qwen2-vl`, `qwen2.5-vl`, `llama4`, `gemma3`; `false` otherwise. |
+
+Explicit config always wins.
+
+## System prompt & roles
+
+Unlike Anthropic/Gemini/Bedrock, **Ollama keeps a first-class `system` role inside `messages`** — no hoisting. Neutral roles (`system`/`user`/`assistant`/`tool`) pass straight through.
+
+## Tool calls
+
+- Outgoing: neutral tools → `{ type: "function", function: { name, description, parameters } }`.
+- Assistant tool calls → `tool_calls: [{ function: { name, arguments } }]` (Ollama has **no tool-call id**).
+- Tool results (`role: "tool"`) → a `tool` message with `tool_name` set from `toolCallId` (Ollama matches a result to its call by name).
+
+**Synthesized ids.** Because Ollama tool calls carry no id, the adapter sets neutral `id` = tool name. **Parallel calls to the same tool in one turn share an id** — a documented v1 limitation. Ollama reports `done_reason: "stop"` even when it called a tool; the adapter derives `finishReason: "tool_calls"` from tool-call presence.
+
+## Structured output
+
+Object-root `responseSchema` + `structuredOutput`-capable → `chat({ format: <schema> })` (Ollama's `format` accepts a JSON Schema object).
+
+## Multipart messages (vision)
+
+A multipart user message collapses to a single `content` string + an `images` array of **base64 strings**. `{ type: "image", source: { url } }` → **throws `InvalidRequestError`** (Ollama cannot fetch remote URLs). Resolve images to base64 first.
+
+## Streaming
+
+`model.stream()` drains `chat({ stream: true })` (an `AbortableAsyncIterator`). Each chunk's `message.content` → `{ type: "delta" }`; `message.tool_calls` are emitted as `{ type: "tool-call" }` **fully formed**. Terminal `{ type: "done", finishReason, usage }` — usage from the final (`done: true`) chunk's `prompt_eval_count` / `eval_count`.
+
+**`options.signal` is honored** by calling the iterator's `abort()` (stream path; non-stream `complete()` ignores it — the agent still honors the signal at trip boundaries).
+
+## Finish-reason mapping
+
+`stop` → `stop` · `length` → `length` · `load` / unknown / null → `error`. `tool_calls` derived from tool-call presence.
+
+## Embeddings
+
+```ts
+const embedder = ollama.embedder({ name: "nomic-embed-text" });
+const { vector } = await embedder.embed("Hello world");
+const { vectors } = await embedder.embedMany(["a", "b"]);   // single batched call
+const truncated = ollama.embedder({ name: "mxbai-embed-large", dimensions: 512 });
+```
+
+`client.embed` accepts a string array natively, so `embedMany` is **one request** (like the Gemini adapter). Usage comes from `prompt_eval_count` (reported as both `promptTokens` and `totalTokens`). Local Ollama runs without a prompt cache, so model usage has no `cachedTokens`.
+
+`dimensions` is optional. When set it's forwarded as Ollama's `dimensions` truncation field (newer embedding models) and seeds `embedder.dimensions`; when omitted, `embedder.dimensions` starts at `0` and is resolved lazily from the first response's vector length, then cached.
+
+## Errors
+
+Wrapped into the typed `@warlock.js/ai` `AIError` hierarchy. The `ollama` client throws an internal `ResponseError` (`status_code` + message); transport failures surface as `fetch` `TypeError` with `ECONNREFUSED` cause:
+
+- **Daemon-down (`ECONNREFUSED` / "fetch failed") → `ProviderError`** (operational "is Ollama running?", not a request defect)
+- Timeouts → `ProviderTimeoutError`
+- 401/403 → `ProviderAuthError`
+- 429 → `ProviderRateLimitError`
+- 4xx with context phrasing → `ContextLengthExceededError`, else `InvalidRequestError`
+- 5xx → `ProviderError`
+
+## Token counting
+
+```ts
+await ollama.count("some text")  // approximate heuristic, offline
+```
+
+## When NOT to use this skill
+
+- Direct `ollama` client calls without going through `@warlock.js/ai` agents.
+- OpenAI / Anthropic / Bedrock / Google models — those have their own adapter packages.
+- An OpenAI-compatible Ollama gateway you specifically want to drive through the OpenAI protocol — use `@warlock.js/ai-openai` with `baseURL` instead.
+
+## See also
+
+- [`@warlock.js/ai/run-ai-agent/SKILL.md`](@warlock.js/ai/run-ai-agent/SKILL.md)
+- [`@warlock.js/ai/pick-ai-provider/SKILL.md`](@warlock.js/ai/pick-ai-provider/SKILL.md)
+- [`@warlock.js/ai/embed-text/SKILL.md`](@warlock.js/ai/embed-text/SKILL.md)
+
+

package/llms.txt

@@ -0,0 +1,9 @@
+# Warlock AI Ollama
+
+> Package: `@warlock.js/ai-ollama`
+
+> Ollama adapter for @warlock.js/ai
+
+## Skills
+
+- [setup-ollama](@warlock.js/ai-ollama/setup-ollama/SKILL.md): Wire @warlock.js/ai-ollama — new OllamaSDK({host?, headers?}) for local / self-hosted Ollama via the official ollama client (not OpenAI-compat). chat + embed, daemon-down error handling. Triggers: `OllamaSDK`, `ollama.model`, `ollama.embedder`, `embedder.embedMany`, `ollama.count`, `host`, `headers`; "use ollama with warlock", "run llama3 locally", "self-hosted llama"; typical import `import { OllamaSDK } from "@warlock.js/ai-ollama"`. Skip: agent loop — `@warlock.js/ai/run-ai-agent/SKILL.md`; provider choice — `@warlock.js/ai/pick-ai-provider/SKILL.md`; embeddings core — `@warlock.js/ai/embed-text/SKILL.md`; siblings `@warlock.js/ai-openai`, `@warlock.js/ai-anthropic`, `@warlock.js/ai-google`; raw `ollama` npm, Vercel `@ai-sdk/ollama`; OpenAI-compat gateway via `@warlock.js/ai-openai` `baseURL`.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@warlock.js/ai-ollama",
+  "description": "Ollama adapter for @warlock.js/ai",
+  "keywords": [
+    "warlock",
+    "ai",
+    "ollama"
+  ],
+  "author": "Hasan Zohdy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/warlockjs/ai-ollama"
+  },
+  "dependencies": {
+    "ollama": "^0.6.3",
+    "@warlock.js/logger": "*"
+  },
+  "peerDependencies": {
+    "@warlock.js/ai": "*"
+  },
+  "version": "4.1.1",
+  "main": "./cjs/index.cjs",
+  "module": "./esm/index.mjs",
+  "types": "./esm/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./esm/index.d.mts",
+        "default": "./esm/index.mjs"
+      },
+      "require": {
+        "types": "./esm/index.d.mts",
+        "default": "./cjs/index.cjs"
+      }
+    }
+  }
+}

package/skills/README.md

@@ -0,0 +1,9 @@
+# `@warlock.js/ai-ollama` — skills index
+
+Per-task skills. All cross-references use the form `@warlock.js/<pkg>/<skill>/SKILL.md`.
+
+## Skills
+
+### [`setup-ollama/`](./setup-ollama/SKILL.md)
+
+Wire @warlock.js/ai-ollama — new OllamaSDK({host?, headers?}) for local / self-hosted Ollama via the official ollama client (not OpenAI-compat). chat + embed, daemon-down error handling. Load when wiring a local or self-hosted Ollama model into a @warlock.js agent.