@nemesis-oss/ollama-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2049 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/config.ts
+var DEFAULT_BASE_URL = "http://localhost:11434";
+var DEFAULT_TIMEOUT_MS = 3e4;
+function readEnv(name) {
+  return typeof process !== "undefined" && process.env ? process.env[name] : void 0;
+}
+function resolveBaseUrl(configBaseUrl) {
+  return configBaseUrl ?? readEnv("OLLAMA_HOST") ?? DEFAULT_BASE_URL;
+}
+function resolveApiKey(configApiKey) {
+  return configApiKey ?? readEnv("OLLAMA_API_KEY");
+}
+var DEFAULT_FAILOVER_CODES = [
+  "network_error",
+  "timeout",
+  "server_error",
+  "rate_limited",
+  "auth_error",
+  // A candidate endpoint rejected the request pre-flight for a known-unsupported
+  // capability (e.g. structured output against Ollama Cloud) — try the next candidate
+  // rather than failing outright; see OllamaUnsupportedCapabilityError.
+  "unsupported_capability"
+];
+
+// src/errors.ts
+var OllamaClientError = class extends Error {
+  code;
+  status;
+  retryable;
+  request;
+  response;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = this.constructor.name;
+    this.code = options.code;
+    this.status = options.status;
+    this.retryable = options.retryable ?? false;
+    this.request = options.request;
+    this.response = options.response;
+  }
+};
+var OllamaNetworkError = class extends OllamaClientError {
+  constructor(message, options) {
+    super(message, { ...options, code: "network_error", retryable: true });
+  }
+};
+var OllamaTimeoutError = class extends OllamaClientError {
+  timeoutMs;
+  constructor(message, options) {
+    super(message, { ...options, code: "timeout", retryable: true });
+    this.timeoutMs = options?.timeoutMs;
+  }
+};
+var OllamaAuthError = class extends OllamaClientError {
+  constructor(message, options) {
+    super(message, { ...options, code: "auth_error", retryable: false });
+  }
+};
+var OllamaNotFoundError = class extends OllamaClientError {
+  constructor(message, options) {
+    super(message, { ...options, code: "not_found", retryable: false });
+  }
+};
+var OllamaRateLimitError = class extends OllamaClientError {
+  retryAfterMs;
+  constructor(message, options) {
+    super(message, { ...options, code: "rate_limited", retryable: true });
+    this.retryAfterMs = options?.retryAfterMs;
+  }
+};
+var OllamaServerError = class extends OllamaClientError {
+  constructor(message, options) {
+    super(message, { ...options, code: "server_error", retryable: true });
+  }
+};
+var OllamaAbortError = class extends OllamaClientError {
+  constructor(message, options) {
+    super(message, { ...options, code: "aborted", retryable: false });
+  }
+};
+var OllamaToolValidationError = class extends OllamaClientError {
+  toolName;
+  issues;
+  constructor(message, options) {
+    super(message, { ...options, code: "tool_validation_error", retryable: false });
+    this.toolName = options.toolName;
+    this.issues = options.issues;
+  }
+};
+var OllamaToolTimeoutError = class extends OllamaClientError {
+  toolName;
+  timeoutMs;
+  constructor(message, options) {
+    super(message, { ...options, code: "tool_timeout", retryable: false });
+    this.toolName = options.toolName;
+    this.timeoutMs = options.timeoutMs;
+  }
+};
+var OllamaUnsupportedCapabilityError = class extends OllamaClientError {
+  capability;
+  constructor(message, options) {
+    super(message, { ...options, code: "unsupported_capability", retryable: false });
+    this.capability = options.capability;
+  }
+};
+var OllamaAgentMaxIterationsError = class extends OllamaClientError {
+  maxIterations;
+  constructor(message, options) {
+    super(message, { ...options, code: "agent_max_iterations_exceeded", retryable: false });
+    this.maxIterations = options.maxIterations;
+  }
+};
+var OllamaMcpError = class extends OllamaClientError {
+  mcpMethod;
+  toolName;
+  constructor(message, options) {
+    super(message, { ...options, code: "mcp_error", retryable: options.retryable ?? false });
+    this.mcpMethod = options.mcpMethod;
+    this.toolName = options.toolName;
+  }
+};
+var OllamaSkillNotFoundError = class extends OllamaClientError {
+  skillName;
+  constructor(message, options) {
+    super(message, { ...options, code: "skill_not_found", retryable: false });
+    this.skillName = options.skillName;
+  }
+};
+var OllamaSkillInvalidError = class extends OllamaClientError {
+  skillName;
+  path;
+  constructor(message, options) {
+    super(message, { ...options, code: "skill_invalid", retryable: false });
+    this.skillName = options.skillName;
+    this.path = options.path;
+  }
+};
+var OllamaGenericClientError = class extends OllamaClientError {
+  constructor(message, options) {
+    super(message, { ...options, code: "client_error" });
+  }
+};
+function isDomAbortError(error) {
+  return typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError";
+}
+function statusToError(status, message, options) {
+  if (status === 401 || status === 403) {
+    return new OllamaAuthError(message, { ...options, status });
+  }
+  if (status === 404) {
+    return new OllamaNotFoundError(message, { ...options, status });
+  }
+  if (status === 429) {
+    return new OllamaRateLimitError(message, { ...options, status });
+  }
+  if (status >= 500) {
+    return new OllamaServerError(message, { ...options, status });
+  }
+  return new OllamaGenericClientError(message, { ...options, status });
+}
+function mapError(error, context = {}) {
+  if (error instanceof OllamaClientError) {
+    return error;
+  }
+  if (isDomAbortError(error)) {
+    return new OllamaAbortError(error.message || "Request was aborted", {
+      cause: error,
+      request: context.request
+    });
+  }
+  if (error instanceof TypeError) {
+    return new OllamaNetworkError(error.message || "Network request failed", {
+      cause: error,
+      request: context.request
+    });
+  }
+  if (context.response?.status !== void 0) {
+    const message2 = error instanceof Error ? error.message : String(error);
+    return statusToError(context.response.status, message2, {
+      cause: error,
+      request: context.request,
+      response: context.response
+    });
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new OllamaGenericClientError(message, {
+    cause: error,
+    request: context.request,
+    response: context.response
+  });
+}
+
+// src/logger.ts
+var NOOP_LOGGER = {
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+function createConsoleLogger(prefix = "[@nemesis-oss/ollama-sdk]") {
+  return {
+    debug: (msg, ctx) => console.debug(`${prefix} ${msg}`, ctx ?? ""),
+    info: (msg, ctx) => console.info(`${prefix} ${msg}`, ctx ?? ""),
+    warn: (msg, ctx) => console.warn(`${prefix} ${msg}`, ctx ?? ""),
+    error: (msg, ctx) => console.error(`${prefix} ${msg}`, ctx ?? "")
+  };
+}
+
+// src/providers/endpoint-registry.ts
+var EndpointRegistry = class {
+  endpoints;
+  failureCounts = /* @__PURE__ */ new Map();
+  lastFailures = /* @__PURE__ */ new Map();
+  failureThreshold;
+  cooldownMs;
+  now;
+  constructor(endpoints, options = {}) {
+    this.endpoints = endpoints.length > 0 ? endpoints : [{ name: "default", baseUrl: "http://localhost:11434" }];
+    this.failureThreshold = options.failureThreshold ?? 3;
+    this.cooldownMs = options.cooldownMs ?? 3e4;
+    this.now = options.now ?? Date.now;
+  }
+  candidates() {
+    const currentTime = this.now();
+    const healthy = [];
+    const coolingDown = [];
+    for (const ep of this.endpoints) {
+      const failures = this.failureCounts.get(ep.name) ?? 0;
+      const lastFail = this.lastFailures.get(ep.name) ?? 0;
+      const isCooling = failures >= this.failureThreshold && currentTime - lastFail < this.cooldownMs;
+      if (!isCooling) {
+        healthy.push(ep);
+      } else {
+        coolingDown.push({ endpoint: ep, recoveredAt: lastFail + this.cooldownMs });
+      }
+    }
+    if (healthy.length > 0) {
+      return healthy.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+    return coolingDown.sort((a, b) => a.recoveredAt - b.recoveredAt).map((c) => c.endpoint);
+  }
+  reportSuccess(name) {
+    this.failureCounts.delete(name);
+    this.lastFailures.delete(name);
+  }
+  reportFailure(name) {
+    const current = (this.failureCounts.get(name) ?? 0) + 1;
+    this.failureCounts.set(name, current);
+    this.lastFailures.set(name, this.now());
+  }
+  list() {
+    return this.endpoints;
+  }
+  status() {
+    const currentTime = this.now();
+    return this.endpoints.map((ep) => {
+      const failures = this.failureCounts.get(ep.name) ?? 0;
+      const lastFail = this.lastFailures.get(ep.name);
+      const isCoolingDown = failures >= this.failureThreshold && lastFail !== void 0 && currentTime - lastFail < this.cooldownMs;
+      return {
+        endpoint: ep,
+        failureCount: failures,
+        ...lastFail !== void 0 ? { lastFailureTimestamp: lastFail } : {},
+        isCoolingDown
+      };
+    });
+  }
+};
+
+// src/streaming/ndjson.ts
+async function* parseNdjsonStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          yield JSON.parse(trimmed);
+        } catch (err) {
+          throw new OllamaGenericClientError(`Failed to parse stream JSON chunk: ${trimmed}`, {
+            cause: err
+          });
+        }
+      }
+    }
+    if (buffer.trim()) {
+      yield JSON.parse(buffer.trim());
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/telemetry/tracer.ts
+var INSTRUMENTATION_NAME = "@nemesis-oss/ollama-sdk";
+var INSTRUMENTATION_VERSION = "1.0.0";
+var apiPromise;
+function loadApi() {
+  apiPromise ??= import('@opentelemetry/api').catch(() => void 0);
+  return apiPromise;
+}
+function cleanAttributes(attributes) {
+  const clean = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (value !== void 0) {
+      clean[key] = value;
+    }
+  }
+  return clean;
+}
+async function withSpan(name, attributes, fn) {
+  const api = await loadApi();
+  if (!api) {
+    return fn(void 0);
+  }
+  const tracer = api.trace.getTracer(INSTRUMENTATION_NAME, INSTRUMENTATION_VERSION);
+  return tracer.startActiveSpan(name, async (span) => {
+    span.setAttributes(cleanAttributes(attributes));
+    try {
+      return await fn(span);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      span.recordException(error);
+      span.setStatus({ code: api.SpanStatusCode.ERROR, message: error.message });
+      throw error;
+    } finally {
+      span.end();
+    }
+  });
+}
+function addSpanEvent(span, name, attributes) {
+  span?.addEvent(name, attributes ? cleanAttributes(attributes) : void 0);
+}
+async function setSpanError(span, error) {
+  if (!span) {
+    return;
+  }
+  const api = await loadApi();
+  span.recordException(error);
+  span.setStatus({ code: api?.SpanStatusCode.ERROR ?? 2, message: error.message });
+}
+var ATTR_HTTP_REQUEST_METHOD = "http.request.method";
+var ATTR_URL_FULL = "url.full";
+var ATTR_SERVER_ADDRESS = "server.address";
+var ATTR_SERVER_PORT = "server.port";
+var ATTR_HTTP_RESPONSE_STATUS_CODE = "http.response.status_code";
+var ATTR_GEN_AI_SYSTEM = "gen_ai.system";
+var ATTR_GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+var ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+var ATTR_GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+var ATTR_GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+var ATTR_GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+var ATTR_GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+var ATTR_GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+var ATTR_OLLAMA_ENDPOINT_NAME = "ollama.endpoint.name";
+var ATTR_OLLAMA_ENDPOINT_ATTEMPT = "ollama.endpoint.attempt";
+var ATTR_OLLAMA_AGENT_MAX_ITERATIONS = "ollama.agent.max_iterations";
+var ATTR_OLLAMA_AGENT_ITERATION = "ollama.agent.iteration";
+var GEN_AI_SYSTEM_OLLAMA = "ollama";
+
+// src/transport/http.ts
+function routeTemplate(path) {
+  return path.replace(/^\/api\/blobs\/.+$/, "/api/blobs/{digest}");
+}
+function httpSpanAttributes(method, url) {
+  const target = new URL(url);
+  return {
+    [ATTR_HTTP_REQUEST_METHOD]: method,
+    [ATTR_URL_FULL]: url,
+    [ATTR_SERVER_ADDRESS]: target.hostname,
+    [ATTR_SERVER_PORT]: target.port ? Number(target.port) : void 0
+  };
+}
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  defaultHeaders;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.defaultHeaders = options.headers ?? {};
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+  }
+  buildHeaders(customHeaders) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.defaultHeaders,
+      ...customHeaders
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  async request(options) {
+    const url = `${this.baseUrl}${options.path}`;
+    const method = options.method ?? (options.body !== void 0 || options.rawBody !== void 0 ? "POST" : "GET");
+    const headers = this.buildHeaders(options.headers);
+    if (options.rawBody !== void 0 && !options.headers?.["Content-Type"]) {
+      delete headers["Content-Type"];
+    }
+    return withSpan(
+      `${method} ${routeTemplate(options.path)}`,
+      httpSpanAttributes(method, url),
+      async (span) => {
+        try {
+          const bodyInit = options.rawBody !== void 0 ? options.rawBody : options.body !== void 0 ? JSON.stringify(options.body) : void 0;
+          const init = {
+            method,
+            headers,
+            ...bodyInit !== void 0 ? { body: bodyInit } : {},
+            ...options.signal !== void 0 ? { signal: options.signal } : {}
+          };
+          const response = await this.fetchImpl(url, init);
+          span?.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
+          if (!response.ok) {
+            let errorBody;
+            try {
+              errorBody = await response.json();
+            } catch {
+              errorBody = await response.text();
+            }
+            const message = typeof errorBody === "object" && errorBody !== null && "error" in errorBody ? String(errorBody.error) : `HTTP ${response.status} ${response.statusText}`;
+            throw mapError(new Error(message), {
+              request: { method, url },
+              response: { status: response.status, body: errorBody }
+            });
+          }
+          if (options.method === "HEAD" || response.status === 204) {
+            return void 0;
+          }
+          if (typeof response.text === "function") {
+            const text = await response.text();
+            return text ? JSON.parse(text) : void 0;
+          }
+          if (typeof response.json === "function") {
+            return await response.json();
+          }
+          return void 0;
+        } catch (err) {
+          throw mapError(err, { request: { method, url } });
+        }
+      }
+    );
+  }
+  async requestStream(options) {
+    const url = `${this.baseUrl}${options.path}`;
+    const method = options.method ?? "POST";
+    const headers = this.buildHeaders(options.headers);
+    return withSpan(
+      `${method} ${routeTemplate(options.path)}`,
+      httpSpanAttributes(method, url),
+      async (span) => {
+        try {
+          const init = {
+            method,
+            headers,
+            ...options.body !== void 0 ? { body: JSON.stringify(options.body) } : {},
+            ...options.signal !== void 0 ? { signal: options.signal } : {}
+          };
+          const response = await this.fetchImpl(url, init);
+          span?.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw mapError(new Error(errorText || `HTTP ${response.status}`), {
+              request: { method, url },
+              response: { status: response.status, body: errorText }
+            });
+          }
+          if (!response.body) {
+            throw mapError(new Error("Response body is null, cannot stream"), {
+              request: { method, url }
+            });
+          }
+          const stream = parseNdjsonStream(response.body);
+          const abortable = {
+            [Symbol.asyncIterator]() {
+              return stream[Symbol.asyncIterator]();
+            }
+          };
+          return abortable;
+        } catch (err) {
+          throw mapError(err, { request: { method, url } });
+        }
+      }
+    );
+  }
+};
+
+// src/providers/health-check.ts
+async function checkEndpointHealth(endpoint, fetchImpl, timeoutMs = 5e3) {
+  const client = new HttpClient({
+    baseUrl: endpoint.baseUrl,
+    apiKey: endpoint.apiKey,
+    headers: endpoint.headers,
+    fetch: fetchImpl
+  });
+  const startTime = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await client.request({
+      path: "/api/version",
+      method: "GET",
+      signal: controller.signal
+    });
+    const latencyMs = Date.now() - startTime;
+    return {
+      name: endpoint.name,
+      baseUrl: endpoint.baseUrl,
+      reachable: true,
+      latencyMs,
+      version: res.version
+    };
+  } catch (err) {
+    const latencyMs = Date.now() - startTime;
+    return {
+      name: endpoint.name,
+      baseUrl: endpoint.baseUrl,
+      reachable: false,
+      latencyMs,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/capabilities/capabilities.ts
+function inferRuntimeMode(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    const host = url.hostname.toLowerCase();
+    if (host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".local") || host.startsWith("192.168.") || host.startsWith("10.")) {
+      return "local";
+    }
+    return "cloud";
+  } catch {
+    return "unknown";
+  }
+}
+async function detectModelCapabilities(http, model) {
+  const showRes = await http.request({
+    path: "/api/show",
+    body: { model }
+  });
+  const reported = showRes.capabilities ?? [];
+  const reportedSet = new Set(reported.map((c) => c.toLowerCase()));
+  return {
+    model,
+    reported,
+    supportsTools: reportedSet.has("tools"),
+    supportsVision: reportedSet.has("vision"),
+    supportsEmbedding: reportedSet.has("embedding"),
+    supportsCompletion: reportedSet.has("completion") || !reportedSet.has("embedding"),
+    supportsThinking: reportedSet.has("thinking"),
+    supportsStreaming: true,
+    supportsStructuredOutputRequest: inferRuntimeMode(http.baseUrl) !== "cloud"
+  };
+}
+async function listAvailableModels(http) {
+  const res = await http.request({
+    path: "/api/tags",
+    method: "GET"
+  });
+  return [...res.models];
+}
+function extractJsonSubstring(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return trimmed;
+  }
+  const match = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  if (match && match[1]) {
+    return match[1].trim();
+  }
+  const firstBrace = trimmed.indexOf("{");
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    return trimmed.slice(firstBrace, lastBrace + 1);
+  }
+  return trimmed;
+}
+function zodV3ToJsonSchema(schema) {
+  const def = schema._def;
+  if (!def) {
+    return { type: "object" };
+  }
+  switch (def["typeName"]) {
+    case "ZodObject": {
+      const shape = def["shape"]();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodV3ToJsonSchema(value);
+        if (!isZodV3Optional(value)) {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodDate":
+      return { type: "string", format: "date-time" };
+    case "ZodArray":
+      return { type: "array", items: zodV3ToJsonSchema(def["type"]) };
+    case "ZodEnum":
+      return { type: "string", enum: def["values"] };
+    case "ZodNativeEnum":
+      return { enum: Object.values(def["values"]) };
+    case "ZodLiteral":
+      return { const: def["value"] };
+    case "ZodOptional":
+    case "ZodNullable":
+    case "ZodDefault":
+      return zodV3ToJsonSchema(def["innerType"]);
+    case "ZodEffects":
+      return zodV3ToJsonSchema(def["schema"]);
+    case "ZodUnion":
+      return { anyOf: def["options"].map((option) => zodV3ToJsonSchema(option)) };
+    case "ZodRecord":
+      return { type: "object", additionalProperties: zodV3ToJsonSchema(def["valueType"]) };
+    default:
+      return { type: "object" };
+  }
+}
+function isZodV3Optional(schema) {
+  const typeName = schema._def?.typeName;
+  return typeName === "ZodOptional" || typeName === "ZodDefault";
+}
+function zodToJsonSchema(schema) {
+  if (typeof zod.z.toJSONSchema === "function") {
+    return zod.z.toJSONSchema(schema);
+  }
+  return zodV3ToJsonSchema(schema);
+}
+function parseStructuredOutput(rawJson, schema, toolName = "structured_output") {
+  let parsed;
+  const jsonStr = extractJsonSubstring(rawJson);
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch (err) {
+    throw new OllamaToolValidationError(`Failed to parse structured output as JSON: ${rawJson}`, {
+      toolName,
+      cause: err
+    });
+  }
+  const result = schema.safeParse(parsed);
+  if (!result.success) {
+    throw new OllamaToolValidationError(`Structured output failed schema validation`, {
+      toolName,
+      issues: result.error.issues,
+      cause: result.error
+    });
+  }
+  return result.data;
+}
+
+// src/usage.ts
+var NANOS_PER_MS = 1e6;
+var NANOS_PER_SECOND = 1e9;
+function extractUsage(raw) {
+  const promptTokens = raw.prompt_eval_count ?? 0;
+  const completionTokens = raw.eval_count ?? 0;
+  const totalTokens = promptTokens + completionTokens;
+  let tokensPerSecond;
+  if (raw.eval_count && raw.eval_duration && raw.eval_duration > 0) {
+    tokensPerSecond = Number((raw.eval_count / raw.eval_duration * NANOS_PER_SECOND).toFixed(2));
+  }
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    ...tokensPerSecond !== void 0 ? { tokensPerSecond } : {},
+    ...raw.load_duration !== void 0 ? { loadDurationMs: raw.load_duration / NANOS_PER_MS } : {},
+    ...raw.prompt_eval_duration !== void 0 ? { promptEvalDurationMs: raw.prompt_eval_duration / NANOS_PER_MS } : {},
+    ...raw.eval_duration !== void 0 ? { evalDurationMs: raw.eval_duration / NANOS_PER_MS } : {},
+    ...raw.total_duration !== void 0 ? { totalDurationMs: raw.total_duration / NANOS_PER_MS } : {}
+  };
+}
+
+// src/tools/tool-call-id.ts
+function generateToolCallId() {
+  return `call_${crypto.randomUUID()}`;
+}
+function ensureToolCallIds(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) {
+    return toolCalls;
+  }
+  return toolCalls.map((tc) => tc.id !== void 0 ? tc : { ...tc, id: generateToolCallId() });
+}
+
+// src/streaming/stream.ts
+var OllamaStream = class {
+  constructor(source, mapChunk, aggregate, initial) {
+    this.source = source;
+    this.mapChunk = mapChunk;
+    this.aggregate = aggregate;
+    this.initial = initial;
+    this.finalResultPromise = new Promise((resolve, reject) => {
+      this.resolveFinal = resolve;
+      this.rejectFinal = reject;
+    });
+  }
+  source;
+  mapChunk;
+  aggregate;
+  initial;
+  mode = "unconsumed";
+  listeners = /* @__PURE__ */ new Map();
+  finalResultPromise;
+  resolveFinal;
+  rejectFinal;
+  get finalResult() {
+    return this.finalResultPromise;
+  }
+  abort() {
+    this.source.abort?.();
+  }
+  on(type, listener) {
+    if (this.mode === "iterator") {
+      throw new Error(
+        "Cannot register event listeners: this stream is already being consumed via async iteration."
+      );
+    }
+    const genericListener = listener;
+    let set = this.listeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(type, set);
+    }
+    set.add(genericListener);
+    if (this.mode !== "events") {
+      this.mode = "events";
+      void this.pump();
+    }
+    return () => {
+      set?.delete(genericListener);
+    };
+  }
+  emit(event) {
+    for (const listener of this.listeners.get(event.type) ?? []) {
+      listener(event);
+    }
+  }
+  async pump() {
+    let accumulated = this.initial;
+    try {
+      for await (const chunk of this.source) {
+        accumulated = this.aggregate(accumulated, chunk);
+        for (const event of this.mapChunk(chunk, accumulated)) {
+          this.emit(event);
+          if (event.type === "done") {
+            this.resolveFinal(event.data.result);
+          }
+        }
+      }
+    } catch (error) {
+      const mapped = mapError(error);
+      this.emit({ type: "error", data: { error: mapped } });
+      this.rejectFinal(mapped);
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.mode === "events") {
+      throw new Error(
+        "Cannot use async iteration: this stream already has event listeners registered via .on()."
+      );
+    }
+    this.mode = "iterator";
+    let accumulated = this.initial;
+    try {
+      for await (const chunk of this.source) {
+        accumulated = this.aggregate(accumulated, chunk);
+        const events = this.mapChunk(chunk, accumulated);
+        for (const event of events) {
+          if (event.type === "done") {
+            this.resolveFinal(event.data.result);
+          }
+          yield event;
+        }
+      }
+    } catch (error) {
+      const mapped = mapError(error);
+      this.rejectFinal(mapped);
+      yield { type: "error", data: { error: mapped } };
+    }
+  }
+};
+
+// src/streaming/normalize.ts
+function aggregateChat(accumulated, chunk) {
+  const message = chunk.message ?? { role: "assistant", content: "" };
+  return {
+    message: {
+      role: message.role || accumulated.message.role,
+      content: accumulated.message.content + (message.content ?? ""),
+      thinking: message.thinking !== void 0 ? (accumulated.message.thinking ?? "") + message.thinking : accumulated.message.thinking,
+      tool_calls: message.tool_calls?.length ? [...accumulated.message.tool_calls ?? [], ...message.tool_calls] : accumulated.message.tool_calls
+    },
+    model: chunk.model,
+    done: chunk.done,
+    totalDurationMs: chunk.done && chunk.total_duration !== void 0 ? chunk.total_duration / NANOS_PER_MS : accumulated.totalDurationMs,
+    usage: chunk.done ? extractUsage(chunk) : accumulated.usage,
+    raw: chunk
+  };
+}
+function mapChatChunk(chunk, aggregated) {
+  const events = [];
+  const message = chunk.message;
+  if (message?.thinking) {
+    events.push({ type: "thinking", data: { delta: message.thinking } });
+  }
+  for (const toolCall of message?.tool_calls ?? []) {
+    events.push({ type: "tool_call", data: { toolCall } });
+  }
+  if (message?.content) {
+    events.push({ type: "token", data: { delta: message.content, role: message.role } });
+  }
+  events.push({ type: "message", data: { chunk } });
+  if (chunk.done) {
+    events.push({ type: "done", data: { result: aggregated } });
+  }
+  return events;
+}
+function withStableToolCallIds(source) {
+  async function* generator() {
+    for await (const chunk of source) {
+      const toolCalls = chunk.message?.tool_calls;
+      if (!toolCalls?.length) {
+        yield chunk;
+        continue;
+      }
+      yield { ...chunk, message: { ...chunk.message, tool_calls: ensureToolCallIds(toolCalls) } };
+    }
+  }
+  return Object.assign(generator(), { abort: source.abort });
+}
+function normalizeChatStream(source) {
+  const initial = {
+    message: { role: "assistant", content: "" },
+    model: "",
+    done: false
+  };
+  return new OllamaStream(withStableToolCallIds(source), mapChatChunk, aggregateChat, initial);
+}
+function aggregateGenerate(accumulated, chunk) {
+  return {
+    response: accumulated.response + (chunk.response ?? ""),
+    model: chunk.model,
+    done: chunk.done,
+    totalDurationMs: chunk.done && chunk.total_duration !== void 0 ? chunk.total_duration / NANOS_PER_MS : accumulated.totalDurationMs,
+    usage: chunk.done ? extractUsage(chunk) : accumulated.usage,
+    raw: chunk
+  };
+}
+function mapGenerateChunk(chunk, aggregated) {
+  const events = [];
+  if (chunk.thinking) {
+    events.push({ type: "thinking", data: { delta: chunk.thinking } });
+  }
+  if (chunk.response) {
+    events.push({ type: "token", data: { delta: chunk.response, role: "assistant" } });
+  }
+  events.push({ type: "message", data: { chunk } });
+  if (chunk.done) {
+    events.push({ type: "done", data: { result: aggregated } });
+  }
+  return events;
+}
+function normalizeGenerateStream(source) {
+  const initial = { response: "", model: "", done: false };
+  return new OllamaStream(source, mapGenerateChunk, aggregateGenerate, initial);
+}
+function aggregateProgress(_accumulated, chunk) {
+  return {
+    status: chunk.status,
+    completed: chunk.completed,
+    total: chunk.total,
+    done: chunk.status === "success",
+    raw: chunk
+  };
+}
+function mapProgressChunk(chunk, aggregated) {
+  const events = [
+    { type: "message", data: { chunk } }
+  ];
+  if (chunk.status === "success") {
+    events.push({ type: "done", data: { result: aggregated } });
+  }
+  return events;
+}
+function normalizeProgressStream(source) {
+  const initial = { status: "", done: false };
+  return new OllamaStream(source, mapProgressChunk, aggregateProgress, initial);
+}
+
+// src/transport/backoff.ts
+var DEFAULT_BACKOFF = {
+  initialDelayMs: 500,
+  maxDelayMs: 3e4,
+  backoffFactor: 2
+};
+function calculateBackoff(attempt, options = DEFAULT_BACKOFF) {
+  const exponential = options.initialDelayMs * Math.pow(options.backoffFactor, attempt);
+  const ceiling = Math.min(exponential, options.maxDelayMs);
+  return Math.floor(Math.random() * (ceiling + 1));
+}
+
+// src/transport/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  backoff: DEFAULT_BACKOFF
+};
+function isRetryableDefault(error) {
+  if (error instanceof OllamaClientError) {
+    return error.retryable;
+  }
+  return false;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function withRetry(operation, config = DEFAULT_RETRY_CONFIG) {
+  let attempt = 0;
+  while (true) {
+    try {
+      return await operation(attempt);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const shouldRetry = config.shouldRetry ?? isRetryableDefault;
+      if (attempt >= config.maxRetries || !shouldRetry(error, attempt)) {
+        throw error;
+      }
+      const delayMs = calculateBackoff(attempt, config.backoff);
+      config.onRetry?.(error, attempt, delayMs);
+      await sleep(delayMs);
+      attempt += 1;
+    }
+  }
+}
+
+// src/transport/timeout.ts
+function createTimeoutSignal(timeoutMs, userSignal) {
+  if (!timeoutMs && !userSignal) {
+    const controller2 = new AbortController();
+    return { signal: controller2.signal, cancel: () => void 0 };
+  }
+  const controller = new AbortController();
+  let timerId;
+  if (timeoutMs && timeoutMs > 0) {
+    timerId = setTimeout(() => {
+      controller.abort(
+        new OllamaTimeoutError(`Request timed out after ${timeoutMs}ms`, { timeoutMs })
+      );
+    }, timeoutMs);
+  }
+  const onUserAbort = () => {
+    if (timerId) clearTimeout(timerId);
+    controller.abort(userSignal?.reason);
+  };
+  if (userSignal) {
+    if (userSignal.aborted) {
+      if (timerId) clearTimeout(timerId);
+      controller.abort(userSignal.reason);
+    } else {
+      userSignal.addEventListener("abort", onUserAbort, { once: true });
+    }
+  }
+  const cancel = () => {
+    if (timerId) clearTimeout(timerId);
+    if (userSignal) {
+      userSignal.removeEventListener("abort", onUserAbort);
+    }
+  };
+  return { signal: controller.signal, cancel };
+}
+
+// src/models-client.ts
+var ModelsClient = class {
+  constructor(runner) {
+    this.runner = runner;
+  }
+  runner;
+  list() {
+    return this.runner((http) => listAvailableModels(http), { singleEndpoint: true });
+  }
+  show(request) {
+    return this.runner(
+      (http, signal) => http.request({ path: "/api/show", body: request, signal }),
+      { ...request, singleEndpoint: true }
+    );
+  }
+  async pull(request) {
+    if (request.stream) {
+      return this.runner(
+        async (http, signal) => {
+          const stream = await http.requestStream({
+            path: "/api/pull",
+            body: { ...request, stream: true },
+            signal
+          });
+          return normalizeProgressStream(stream);
+        },
+        { ...request, singleEndpoint: true }
+      );
+    }
+    return this.runner(
+      (http, signal) => http.request({
+        path: "/api/pull",
+        body: { ...request, stream: false },
+        signal
+      }),
+      { ...request, singleEndpoint: true }
+    );
+  }
+  async push(request) {
+    if (request.stream) {
+      return this.runner(
+        async (http, signal) => {
+          const stream = await http.requestStream({
+            path: "/api/push",
+            body: { ...request, stream: true },
+            signal
+          });
+          return normalizeProgressStream(stream);
+        },
+        { ...request, singleEndpoint: true }
+      );
+    }
+    return this.runner(
+      (http, signal) => http.request({
+        path: "/api/push",
+        body: { ...request, stream: false },
+        signal
+      }),
+      { ...request, singleEndpoint: true }
+    );
+  }
+  async create(request) {
+    if (request.stream) {
+      return this.runner(
+        async (http, signal) => {
+          const stream = await http.requestStream({
+            path: "/api/create",
+            body: { ...request, stream: true },
+            signal
+          });
+          return normalizeProgressStream(stream);
+        },
+        { ...request, singleEndpoint: true }
+      );
+    }
+    return this.runner(
+      (http, signal) => http.request({
+        path: "/api/create",
+        body: { ...request, stream: false },
+        signal
+      }),
+      { ...request, singleEndpoint: true }
+    );
+  }
+  delete(request) {
+    return this.runner(
+      (http, signal) => http.request({
+        path: "/api/delete",
+        method: "DELETE",
+        body: request,
+        signal
+      }),
+      { ...request, singleEndpoint: true }
+    );
+  }
+  copy(request) {
+    return this.runner(
+      (http, signal) => http.request({ path: "/api/copy", body: request, signal }),
+      { ...request, singleEndpoint: true }
+    );
+  }
+  ps() {
+    return this.runner((http) => http.request({ path: "/api/ps", method: "GET" }), {
+      singleEndpoint: true
+    });
+  }
+  version() {
+    return this.runner(
+      (http) => http.request({ path: "/api/version", method: "GET" }),
+      { singleEndpoint: true }
+    );
+  }
+  async createBlob(digest, data) {
+    await this.runner(
+      (http, signal) => http.request({
+        path: `/api/blobs/${encodeURIComponent(digest)}`,
+        method: "POST",
+        rawBody: data,
+        signal
+      }),
+      { singleEndpoint: true }
+    );
+  }
+  async checkBlob(digest) {
+    try {
+      await this.runner(
+        (http, signal) => http.request({
+          path: `/api/blobs/${encodeURIComponent(digest)}`,
+          method: "HEAD",
+          signal
+        }),
+        { singleEndpoint: true }
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/integrations/openai.ts
+var OpenAICompatClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async createChatCompletion(request, signal) {
+    return this.http.request({
+      path: "/v1/chat/completions",
+      body: request,
+      signal
+    });
+  }
+  async chatCompletions(request, signal) {
+    return this.createChatCompletion(request, signal);
+  }
+  async listModels(signal) {
+    return this.http.request({
+      path: "/v1/models",
+      method: "GET",
+      signal
+    });
+  }
+};
+
+// src/integrations/anthropic.ts
+var AnthropicCompatClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async createMessage(request, signal) {
+    return this.http.request({
+      path: "/v1/messages",
+      body: request,
+      signal
+    });
+  }
+  async messages(request, signal) {
+    return this.createMessage(request, signal);
+  }
+};
+
+// src/client.ts
+var OllamaClient = class {
+  registry;
+  models;
+  retryConfig;
+  timeoutMs;
+  failoverCodes;
+  fetchImpl;
+  logger;
+  constructor(config = {}) {
+    const resolvedApiKey = resolveApiKey(config.apiKey);
+    const endpoints = config.endpoints ?? [
+      {
+        name: "default",
+        baseUrl: resolveBaseUrl(config.baseUrl),
+        ...resolvedApiKey !== void 0 ? { apiKey: resolvedApiKey } : {},
+        ...config.headers !== void 0 ? { headers: config.headers } : {}
+      }
+    ];
+    this.registry = new EndpointRegistry(endpoints, config.endpointHealth);
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.failoverCodes = new Set(config.failoverOn ?? DEFAULT_FAILOVER_CODES);
+    this.fetchImpl = config.fetch ?? globalThis.fetch;
+    this.logger = config.logger ?? (config.debug ? createConsoleLogger() : NOOP_LOGGER);
+    this.retryConfig = typeof config.retries === "number" ? { ...DEFAULT_RETRY_CONFIG, maxRetries: config.retries } : { ...DEFAULT_RETRY_CONFIG, ...config.retries };
+    this.models = new ModelsClient((op, opts) => this.executeWithFailover(op, opts));
+  }
+  get modelsClient() {
+    return this.models;
+  }
+  /**
+   * Fail-fast guard for `format` (structured output) requests: throws before any network
+   * call if the candidate endpoint is inferred as Ollama Cloud, which does not currently
+   * support structured outputs (see `ModelCapabilities.supportsStructuredOutputRequest`).
+   * `unsupported_capability` is in `DEFAULT_FAILOVER_CODES`, so in a multi-endpoint setup
+   * this causes failover to the next candidate rather than failing the whole request.
+   */
+  assertStructuredOutputSupported(baseUrl, model) {
+    if (inferRuntimeMode(baseUrl) === "cloud") {
+      throw new OllamaUnsupportedCapabilityError(
+        `Structured output ("format") requests are not supported against Ollama Cloud endpoints (model "${model}" via ${baseUrl}). This is a known Ollama Cloud limitation, not a bug in this SDK.`,
+        { capability: "structuredOutputRequest" }
+      );
+    }
+  }
+  async executeWithFailover(operation, options) {
+    const timeout = createTimeoutSignal(options?.timeoutMs ?? this.timeoutMs, options?.signal);
+    try {
+      const allCandidates = this.registry.candidates();
+      const candidates = options?.singleEndpoint ? allCandidates.slice(0, 1) : allCandidates;
+      let lastError;
+      for (const [attemptIndex, endpoint] of candidates.entries()) {
+        this.logger.debug(`Executing on endpoint "${endpoint.name}" (${endpoint.baseUrl})`);
+        const http = new HttpClient({
+          baseUrl: endpoint.baseUrl,
+          ...endpoint.apiKey !== void 0 ? { apiKey: endpoint.apiKey } : {},
+          ...endpoint.headers !== void 0 ? { headers: endpoint.headers } : {},
+          fetch: this.fetchImpl
+        });
+        try {
+          const result = await withSpan(
+            "ollama.endpoint.attempt",
+            {
+              [ATTR_OLLAMA_ENDPOINT_NAME]: endpoint.name,
+              [ATTR_OLLAMA_ENDPOINT_ATTEMPT]: attemptIndex
+            },
+            () => withRetry(() => operation(http, timeout.signal), this.retryConfig)
+          );
+          this.registry.reportSuccess(endpoint.name);
+          return result;
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          lastError = error;
+          this.registry.reportFailure(endpoint.name);
+          this.logger.warn(`Failed on "${endpoint.name}": ${error.message}`);
+          if (!(error instanceof OllamaClientError && this.failoverCodes.has(error.code)))
+            throw error;
+        }
+      }
+      throw lastError ?? new Error("No healthy Ollama endpoints available");
+    } finally {
+      timeout.cancel();
+    }
+  }
+  async chat(req) {
+    if (req.stream) {
+      return this.executeWithFailover(async (http, signal) => {
+        if (req.format !== void 0) this.assertStructuredOutputSupported(http.baseUrl, req.model);
+        const stream = await http.requestStream({
+          path: "/api/chat",
+          body: { ...req, stream: true },
+          signal
+        });
+        return normalizeChatStream(stream);
+      }, req);
+    }
+    return withSpan(
+      `chat ${req.model}`,
+      {
+        [ATTR_GEN_AI_SYSTEM]: GEN_AI_SYSTEM_OLLAMA,
+        [ATTR_GEN_AI_OPERATION_NAME]: "chat",
+        [ATTR_GEN_AI_REQUEST_MODEL]: req.model
+      },
+      async (span) => {
+        const rawRes = await this.executeWithFailover((http, signal) => {
+          if (req.format !== void 0)
+            this.assertStructuredOutputSupported(http.baseUrl, req.model);
+          return http.request({
+            path: "/api/chat",
+            body: { ...req, stream: false },
+            signal
+          });
+        }, req);
+        const toolCalls = ensureToolCallIds(rawRes.message.tool_calls);
+        const res = toolCalls === rawRes.message.tool_calls ? rawRes : { ...rawRes, message: { ...rawRes.message, tool_calls: toolCalls } };
+        span?.setAttributes({
+          [ATTR_GEN_AI_RESPONSE_MODEL]: res.model,
+          ...res.prompt_eval_count !== void 0 ? { [ATTR_GEN_AI_USAGE_INPUT_TOKENS]: res.prompt_eval_count } : {},
+          ...res.eval_count !== void 0 ? { [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: res.eval_count } : {}
+        });
+        return res;
+      }
+    );
+  }
+  chatStream(req) {
+    return this.chat({ ...req, stream: true });
+  }
+  async chatText(req) {
+    const res = await this.chat({ ...req, stream: false });
+    return res.message.content;
+  }
+  async chatWithSchema(req, schema) {
+    const res = await this.chat({ ...req, format: zodToJsonSchema(schema), stream: false });
+    return parseStructuredOutput(res.message.content, schema);
+  }
+  async generate(req) {
+    if (req.stream) {
+      return this.executeWithFailover(async (http, signal) => {
+        if (req.format !== void 0) this.assertStructuredOutputSupported(http.baseUrl, req.model);
+        const stream = await http.requestStream({
+          path: "/api/generate",
+          body: { ...req, stream: true },
+          signal
+        });
+        return normalizeGenerateStream(stream);
+      }, req);
+    }
+    return withSpan(
+      `text_completion ${req.model}`,
+      {
+        [ATTR_GEN_AI_SYSTEM]: GEN_AI_SYSTEM_OLLAMA,
+        [ATTR_GEN_AI_OPERATION_NAME]: "text_completion",
+        [ATTR_GEN_AI_REQUEST_MODEL]: req.model
+      },
+      async (span) => {
+        const res = await this.executeWithFailover((http, signal) => {
+          if (req.format !== void 0)
+            this.assertStructuredOutputSupported(http.baseUrl, req.model);
+          return http.request({
+            path: "/api/generate",
+            body: { ...req, stream: false },
+            signal
+          });
+        }, req);
+        span?.setAttributes({
+          [ATTR_GEN_AI_RESPONSE_MODEL]: res.model,
+          ...res.prompt_eval_count !== void 0 ? { [ATTR_GEN_AI_USAGE_INPUT_TOKENS]: res.prompt_eval_count } : {},
+          ...res.eval_count !== void 0 ? { [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: res.eval_count } : {}
+        });
+        return res;
+      }
+    );
+  }
+  generateStream(req) {
+    return this.generate({ ...req, stream: true });
+  }
+  async generateText(req) {
+    const res = await this.generate({ ...req, stream: false });
+    return res.response;
+  }
+  async generateWithSchema(req, schema) {
+    const res = await this.generate({ ...req, format: zodToJsonSchema(schema), stream: false });
+    return parseStructuredOutput(res.response, schema);
+  }
+  // --- Embeddings ---
+  embed(req) {
+    return this.executeWithFailover(
+      (http, signal) => http.request({ path: "/api/embed", body: req, signal }),
+      req
+    );
+  }
+  async embedText(model, input) {
+    const res = await this.embed({ model, input });
+    return res.embeddings;
+  }
+  /**
+   * @deprecated Ollama's `/api/embeddings` endpoint has been superseded by `/api/embed`
+   * (exposed here as {@link OllamaClient.embed}), which additionally supports batch
+   * input. Kept for compatibility with existing callers; new code should use `embed`.
+   */
+  embeddings(req) {
+    return this.executeWithFailover(
+      (http, signal) => http.request({ path: "/api/embeddings", body: req, signal }),
+      req
+    );
+  }
+  // --- Model Operations (Delegated to ModelsClient) ---
+  listModels = () => this.models.list();
+  showModel = (req) => this.models.show(req);
+  pullModel = (r) => this.models.pull(r);
+  pushModel = (r) => this.models.push(r);
+  createModel = (r) => this.models.create(r);
+  deleteModel = (req) => this.models.delete(req);
+  copyModel = (req) => this.models.copy(req);
+  ps = () => this.models.ps();
+  version = () => this.models.version();
+  createBlob = (digest, data) => this.models.createBlob(digest, data);
+  checkBlob = (digest) => this.models.checkBlob(digest);
+  // --- Web Endpoints ---
+  webSearch(req) {
+    return this.executeWithFailover(
+      (http, signal) => http.request({ path: "/api/websearch", body: req, signal }),
+      req
+    );
+  }
+  webFetch(req) {
+    return this.executeWithFailover(
+      (http, signal) => http.request({ path: "/api/webfetch", body: req, signal }),
+      req
+    );
+  }
+  // --- Capabilities & Health ---
+  capabilities(model) {
+    return this.executeWithFailover((http) => detectModelCapabilities(http, model), {
+      singleEndpoint: true
+    });
+  }
+  runtimeMode() {
+    const ep = this.registry.candidates()[0];
+    return inferRuntimeMode(ep?.baseUrl ?? DEFAULT_BASE_URL);
+  }
+  healthCheck() {
+    return Promise.all(this.registry.list().map((ep) => checkEndpointHealth(ep, this.fetchImpl)));
+  }
+  endpointStatus() {
+    return this.registry.status();
+  }
+  // --- Compatibility Adapters ---
+  get openai() {
+    const ep = this.registry.candidates()[0];
+    return new OpenAICompatClient(
+      new HttpClient({
+        baseUrl: ep?.baseUrl ?? DEFAULT_BASE_URL,
+        apiKey: ep?.apiKey,
+        headers: ep?.headers,
+        fetch: this.fetchImpl
+      })
+    );
+  }
+  get anthropic() {
+    const ep = this.registry.candidates()[0];
+    return new AnthropicCompatClient(
+      new HttpClient({
+        baseUrl: ep?.baseUrl ?? DEFAULT_BASE_URL,
+        apiKey: ep?.apiKey,
+        headers: ep?.headers,
+        fetch: this.fetchImpl
+      })
+    );
+  }
+};
+
+// src/middleware.ts
+function composeMiddleware(middlewares, finalHandler) {
+  return function runPipeline(initialRequest) {
+    let index = -1;
+    function dispatch(i, currentRequest) {
+      if (i <= index) {
+        return Promise.reject(new Error("next() called multiple times in middleware"));
+      }
+      index = i;
+      const fn = middlewares[i];
+      if (i === middlewares.length || !fn) {
+        return finalHandler(currentRequest);
+      }
+      return fn({
+        request: currentRequest,
+        next: () => dispatch(i + 1, currentRequest)
+      });
+    }
+    return dispatch(0, initialRequest);
+  };
+}
+
+// src/streaming/adapters.ts
+function toTextStream(stream) {
+  const iterator = stream[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        while (true) {
+          const { done, value } = await iterator.next();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (value.type === "token" && value.data.delta) {
+            controller.enqueue(value.data.delta);
+            return;
+          }
+        }
+      } catch (err) {
+        controller.error(err);
+      }
+    },
+    cancel() {
+      stream.abort();
+    }
+  });
+}
+function toDataStream(stream) {
+  const textStream = toTextStream(stream);
+  const reader = textStream.getReader();
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(value));
+      } catch (err) {
+        controller.error(err);
+      }
+    },
+    cancel() {
+      reader.cancel();
+      stream.abort();
+    }
+  });
+}
+function toResponse(stream, init = {}) {
+  const body = toDataStream(stream);
+  const headers = new Headers(init.headers);
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "text/plain; charset=utf-8");
+  }
+  return new Response(body, { ...init, headers });
+}
+
+// src/tools/define-tool.ts
+function defineTool(options) {
+  const jsonSchema = zodToJsonSchema(options.schema);
+  const properties = jsonSchema["properties"] ?? {};
+  const required = jsonSchema["required"] ?? [];
+  return {
+    name: options.name,
+    description: options.description,
+    schema: options.schema,
+    execute: options.execute,
+    timeoutMs: options.timeoutMs,
+    definition: {
+      type: "function",
+      function: {
+        name: options.name,
+        description: options.description,
+        parameters: {
+          type: "object",
+          properties,
+          ...required.length > 0 ? { required } : {}
+        }
+      }
+    }
+  };
+}
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  onError;
+  defaultTimeoutMs;
+  maxConcurrency;
+  maxOutputChars;
+  constructor(toolsOrOptions) {
+    if (Array.isArray(toolsOrOptions)) {
+      this.registerMany(toolsOrOptions);
+    } else if (toolsOrOptions !== void 0) {
+      const opts = toolsOrOptions;
+      this.onError = opts.onError;
+      this.defaultTimeoutMs = opts.timeoutMs;
+      this.maxConcurrency = opts.maxConcurrency;
+      this.maxOutputChars = opts.maxOutputChars;
+      if (opts.tools) {
+        this.registerMany(opts.tools);
+      }
+    }
+  }
+  register(tool) {
+    this.tools.set(tool.name, tool);
+    return this;
+  }
+  registerMany(tools) {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+    return this;
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  definitions() {
+    return Array.from(this.tools.values()).map((t) => t.definition);
+  }
+  async executeToolCall(toolCall, ctx = {}) {
+    const { name } = toolCall.function;
+    return withSpan(
+      `execute_tool ${name}`,
+      { [ATTR_GEN_AI_TOOL_NAME]: name, [ATTR_GEN_AI_TOOL_CALL_ID]: toolCall.id },
+      async (span) => {
+        const result = await this.executeToolCallUninstrumented(toolCall, ctx);
+        if (!result.success) {
+          await setSpanError(span, result.error);
+        }
+        return result;
+      }
+    );
+  }
+  async executeToolCallUninstrumented(toolCall, ctx) {
+    const { name, arguments: args } = toolCall.function;
+    const tool = this.tools.get(name);
+    if (!tool) {
+      const err = new OllamaNotFoundError(`Tool "${name}" is not registered in this registry`);
+      return this.handleExecutionError(err, toolCall);
+    }
+    const parseResult = tool.schema.safeParse(args);
+    if (!parseResult.success) {
+      const err = new OllamaToolValidationError(`Tool "${name}" arguments validation failed`, {
+        toolName: name,
+        issues: parseResult.error.issues,
+        cause: parseResult.error
+      });
+      return this.handleExecutionError(err, toolCall);
+    }
+    try {
+      const result = await this.runWithTimeout(tool, parseResult.data, ctx, name);
+      const outputString = this.truncateOutput(
+        typeof result === "string" ? result : JSON.stringify(result)
+      );
+      return {
+        toolName: name,
+        toolCallId: toolCall.id,
+        success: true,
+        result,
+        outputString
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return this.handleExecutionError(error, toolCall);
+    }
+  }
+  /**
+   * Executes every call in `toolCalls` and returns results in the same order, so results
+   * are always correlatable by array position regardless of `id`. Each result also echoes
+   * its call's `toolCallId` for callers who'd rather match by ID — see the {@link ToolCall}
+   * docs for how that id is produced. Runs fully in parallel (`Promise.all`) unless
+   * `maxConcurrency` was configured, in which case a bounded worker pool is used instead.
+   */
+  async executeToolCalls(toolCalls, ctx = {}) {
+    const limit = this.maxConcurrency;
+    if (!limit || limit >= toolCalls.length) {
+      return Promise.all(toolCalls.map((tc) => this.executeToolCall(tc, ctx)));
+    }
+    const results = new Array(toolCalls.length);
+    let nextIndex = 0;
+    const worker = async () => {
+      for (let i = nextIndex++; i < toolCalls.length; i = nextIndex++) {
+        results[i] = await this.executeToolCall(toolCalls[i], ctx);
+      }
+    };
+    await Promise.all(Array.from({ length: limit }, () => worker()));
+    return results;
+  }
+  async runWithTimeout(tool, params, ctx, toolName) {
+    const timeoutMs = tool.timeoutMs ?? this.defaultTimeoutMs;
+    if (!timeoutMs || timeoutMs <= 0) {
+      return tool.execute(params, ctx);
+    }
+    const controller = new AbortController();
+    const onParentAbort = () => controller.abort(ctx.signal?.reason);
+    if (ctx.signal) {
+      if (ctx.signal.aborted) {
+        controller.abort(ctx.signal.reason);
+      } else {
+        ctx.signal.addEventListener("abort", onParentAbort, { once: true });
+      }
+    }
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    try {
+      const executePromise = Promise.resolve(
+        tool.execute(params, { ...ctx, signal: controller.signal })
+      );
+      executePromise.catch(() => void 0);
+      const abortRejection = () => timedOut ? new OllamaToolTimeoutError(`Tool "${toolName}" timed out after ${timeoutMs}ms`, {
+        toolName,
+        timeoutMs
+      }) : ctx.signal?.reason ?? new Error("Tool execution aborted");
+      return await Promise.race([
+        executePromise,
+        controller.signal.aborted ? Promise.reject(abortRejection()) : new Promise((_resolve, reject) => {
+          controller.signal.addEventListener("abort", () => reject(abortRejection()), {
+            once: true
+          });
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      if (ctx.signal) {
+        ctx.signal.removeEventListener("abort", onParentAbort);
+      }
+    }
+  }
+  truncateOutput(output) {
+    const limit = this.maxOutputChars;
+    if (!limit || output.length <= limit) {
+      return output;
+    }
+    return `${output.slice(0, limit)}
+\u2026 [truncated ${output.length - limit} of ${output.length} chars]`;
+  }
+  handleExecutionError(error, toolCall) {
+    const fallbackMessage = this.onError ? this.onError(error, toolCall) : error.message;
+    return {
+      toolName: toolCall.function.name,
+      toolCallId: toolCall.id,
+      success: false,
+      error,
+      outputString: this.truncateOutput(fallbackMessage)
+    };
+  }
+};
+function convertMcpDescriptorToTool(descriptor, mcpClient, namePrefix = "") {
+  const toolName = `${namePrefix}${descriptor.name}`;
+  const inputSchema = descriptor.inputSchema ?? { properties: {} };
+  const properties = inputSchema["properties"] ?? {};
+  const required = inputSchema["required"] ?? [];
+  return {
+    name: toolName,
+    description: descriptor.description ?? "",
+    schema: zod.z.record(zod.z.string(), zod.z.unknown()),
+    execute: async (args) => {
+      try {
+        const result = await mcpClient.callTool({
+          name: descriptor.name,
+          arguments: args
+        });
+        if (result.isError) {
+          throw new OllamaMcpError(`MCP tool "${descriptor.name}" returned error`, {
+            mcpMethod: "callTool",
+            toolName: descriptor.name
+          });
+        }
+        return result.content.map((b) => b.type === "text" && b.text ? b.text : `[${b.type}]`).join("\n");
+      } catch (err) {
+        if (err instanceof OllamaMcpError) throw err;
+        throw new OllamaMcpError(`Failed calling MCP tool "${descriptor.name}"`, {
+          mcpMethod: "callTool",
+          toolName: descriptor.name,
+          cause: err
+        });
+      }
+    },
+    definition: {
+      type: "function",
+      function: {
+        name: toolName,
+        description: descriptor.description ?? "",
+        parameters: {
+          type: "object",
+          properties,
+          ...required.length > 0 ? { required } : {}
+        }
+      }
+    }
+  };
+}
+async function loadMcpTools(mcpClient, options = {}) {
+  try {
+    const { tools } = await mcpClient.listTools();
+    return tools.map((t) => convertMcpDescriptorToTool(t, mcpClient, options.namePrefix));
+  } catch (err) {
+    throw new OllamaMcpError("Failed listing MCP tools from client", {
+      mcpMethod: "listTools",
+      cause: err
+    });
+  }
+}
+async function registerMcpTools(registry, mcpClient, options = {}) {
+  const tools = await loadMcpTools(mcpClient, options);
+  registry.registerMany(tools);
+}
+
+// src/skills/frontmatter.ts
+function parseYamlValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (!Number.isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseYamlBlock(yamlText) {
+  const result = {};
+  const lines = yamlText.split("\n");
+  let currentKey;
+  let currentList;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("- ") && currentKey) {
+      if (!currentList) {
+        currentList = [];
+        result[currentKey] = currentList;
+      }
+      currentList.push(parseYamlValue(trimmed.slice(2)));
+      continue;
+    }
+    currentList = void 0;
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const valStr = line.slice(colonIndex + 1).trim();
+      currentKey = key;
+      if (valStr.length > 0) {
+        result[key] = parseYamlValue(valStr);
+      }
+    }
+  }
+  return result;
+}
+function parseFrontmatter(source, path = "") {
+  const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    throw new OllamaSkillInvalidError("Missing YAML frontmatter delimiters (---)", {
+      skillName: path || "unknown",
+      path
+    });
+  }
+  const rawYaml = match[1] ?? "";
+  const body = match[2]?.trim() ?? "";
+  const parsed = parseYamlBlock(rawYaml);
+  if (!parsed["name"] || typeof parsed["name"] !== "string") {
+    throw new OllamaSkillInvalidError('Frontmatter missing required string "name"', {
+      skillName: String(parsed["name"] ?? "unknown"),
+      path
+    });
+  }
+  if (!parsed["description"] || typeof parsed["description"] !== "string") {
+    throw new OllamaSkillInvalidError('Frontmatter missing required string "description"', {
+      skillName: parsed["name"],
+      path
+    });
+  }
+  return {
+    frontmatter: parsed,
+    body
+  };
+}
+
+// src/skills/compose.ts
+function applySkill(skill, options) {
+  const systemPrompt = `[Skill: ${skill.name}]
+${skill.description}
+
+${skill.body}`;
+  const messages = [...options.messages];
+  const systemIndex = messages.findIndex((m) => m.role === "system");
+  if (systemIndex >= 0) {
+    const existing = messages[systemIndex];
+    if (existing) {
+      messages[systemIndex] = {
+        role: "system",
+        content: `${existing.content}
+
+${systemPrompt}`
+      };
+    }
+  } else {
+    messages.unshift({ role: "system", content: systemPrompt });
+  }
+  return {
+    messages,
+    ...options.tools !== void 0 ? { tools: options.tools } : {}
+  };
+}
+
+// src/agent/agent.ts
+var Agent = class {
+  client;
+  tools;
+  maxIterations;
+  hooks;
+  constructor(client, config = {}) {
+    this.client = client;
+    this.tools = config.tools;
+    this.maxIterations = config.maxIterations ?? 10;
+    this.hooks = config.hooks;
+  }
+  run(input) {
+    return withSpan(
+      `invoke_agent ${input.model}`,
+      {
+        [ATTR_GEN_AI_SYSTEM]: GEN_AI_SYSTEM_OLLAMA,
+        [ATTR_GEN_AI_OPERATION_NAME]: "invoke_agent",
+        [ATTR_GEN_AI_REQUEST_MODEL]: input.model,
+        [ATTR_OLLAMA_AGENT_MAX_ITERATIONS]: this.maxIterations
+      },
+      () => this.runLoop(input)
+    );
+  }
+  async runLoop(input) {
+    const history = [...input.messages];
+    const turns = [];
+    const toolDefs = this.tools?.definitions();
+    for (let iteration = 1; iteration <= this.maxIterations; iteration++) {
+      const outcome = await withSpan(
+        "ollama.agent.turn",
+        { [ATTR_OLLAMA_AGENT_ITERATION]: iteration },
+        async () => {
+          this.hooks?.onTurnStart?.(iteration);
+          const response = await this.client.chat({
+            model: input.model,
+            messages: history,
+            ...toolDefs !== void 0 ? { tools: toolDefs } : {},
+            ...input.options !== void 0 ? { options: input.options } : {},
+            ...input.think !== void 0 ? { think: input.think } : {},
+            stream: false,
+            ...input.signal !== void 0 ? { signal: input.signal } : {}
+          });
+          const rawToolCalls = response.message.tool_calls;
+          const toolCalls = ensureToolCallIds(rawToolCalls);
+          const assistantMessage = toolCalls === rawToolCalls ? response.message : { ...response.message, tool_calls: toolCalls };
+          history.push(assistantMessage);
+          if (!toolCalls || toolCalls.length === 0 || !this.tools) {
+            const finalTurn = { iteration, message: assistantMessage };
+            turns.push(finalTurn);
+            this.hooks?.onTurnEnd?.(finalTurn);
+            return { done: true, finalMessage: assistantMessage };
+          }
+          for (const tc of toolCalls) {
+            this.hooks?.onToolCallStart?.(tc);
+          }
+          const toolResults = await this.tools.executeToolCalls(toolCalls, {
+            signal: input.signal
+          });
+          for (const res of toolResults) {
+            this.hooks?.onToolCallEnd?.(res);
+            history.push({
+              role: "tool",
+              ...res.toolCallId !== void 0 ? { tool_call_id: res.toolCallId } : {},
+              content: res.outputString
+            });
+          }
+          const turn = { iteration, message: assistantMessage, toolCalls, toolResults };
+          turns.push(turn);
+          this.hooks?.onTurnEnd?.(turn);
+          return { done: false };
+        }
+      );
+      if (outcome.done) {
+        return { finalMessage: outcome.finalMessage, turns, totalIterations: iteration };
+      }
+    }
+    throw new OllamaAgentMaxIterationsError(
+      `Agent exceeded max iterations (${this.maxIterations}) without converging`,
+      { maxIterations: this.maxIterations }
+    );
+  }
+};
+
+exports.ATTR_GEN_AI_OPERATION_NAME = ATTR_GEN_AI_OPERATION_NAME;
+exports.ATTR_GEN_AI_REQUEST_MODEL = ATTR_GEN_AI_REQUEST_MODEL;
+exports.ATTR_GEN_AI_RESPONSE_MODEL = ATTR_GEN_AI_RESPONSE_MODEL;
+exports.ATTR_GEN_AI_SYSTEM = ATTR_GEN_AI_SYSTEM;
+exports.ATTR_GEN_AI_TOOL_CALL_ID = ATTR_GEN_AI_TOOL_CALL_ID;
+exports.ATTR_GEN_AI_TOOL_NAME = ATTR_GEN_AI_TOOL_NAME;
+exports.ATTR_GEN_AI_USAGE_INPUT_TOKENS = ATTR_GEN_AI_USAGE_INPUT_TOKENS;
+exports.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS = ATTR_GEN_AI_USAGE_OUTPUT_TOKENS;
+exports.ATTR_HTTP_REQUEST_METHOD = ATTR_HTTP_REQUEST_METHOD;
+exports.ATTR_HTTP_RESPONSE_STATUS_CODE = ATTR_HTTP_RESPONSE_STATUS_CODE;
+exports.ATTR_OLLAMA_AGENT_ITERATION = ATTR_OLLAMA_AGENT_ITERATION;
+exports.ATTR_OLLAMA_AGENT_MAX_ITERATIONS = ATTR_OLLAMA_AGENT_MAX_ITERATIONS;
+exports.ATTR_OLLAMA_ENDPOINT_ATTEMPT = ATTR_OLLAMA_ENDPOINT_ATTEMPT;
+exports.ATTR_OLLAMA_ENDPOINT_NAME = ATTR_OLLAMA_ENDPOINT_NAME;
+exports.ATTR_SERVER_ADDRESS = ATTR_SERVER_ADDRESS;
+exports.ATTR_SERVER_PORT = ATTR_SERVER_PORT;
+exports.ATTR_URL_FULL = ATTR_URL_FULL;
+exports.Agent = Agent;
+exports.AnthropicCompatClient = AnthropicCompatClient;
+exports.DEFAULT_BACKOFF = DEFAULT_BACKOFF;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_FAILOVER_CODES = DEFAULT_FAILOVER_CODES;
+exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG;
+exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
+exports.EndpointRegistry = EndpointRegistry;
+exports.GEN_AI_SYSTEM_OLLAMA = GEN_AI_SYSTEM_OLLAMA;
+exports.HttpClient = HttpClient;
+exports.ModelsClient = ModelsClient;
+exports.NANOS_PER_MS = NANOS_PER_MS;
+exports.NANOS_PER_SECOND = NANOS_PER_SECOND;
+exports.NOOP_LOGGER = NOOP_LOGGER;
+exports.OllamaAbortError = OllamaAbortError;
+exports.OllamaAgentMaxIterationsError = OllamaAgentMaxIterationsError;
+exports.OllamaAuthError = OllamaAuthError;
+exports.OllamaClient = OllamaClient;
+exports.OllamaClientError = OllamaClientError;
+exports.OllamaGenericClientError = OllamaGenericClientError;
+exports.OllamaMcpError = OllamaMcpError;
+exports.OllamaNetworkError = OllamaNetworkError;
+exports.OllamaNotFoundError = OllamaNotFoundError;
+exports.OllamaRateLimitError = OllamaRateLimitError;
+exports.OllamaServerError = OllamaServerError;
+exports.OllamaSkillInvalidError = OllamaSkillInvalidError;
+exports.OllamaSkillNotFoundError = OllamaSkillNotFoundError;
+exports.OllamaStream = OllamaStream;
+exports.OllamaTimeoutError = OllamaTimeoutError;
+exports.OllamaToolTimeoutError = OllamaToolTimeoutError;
+exports.OllamaToolValidationError = OllamaToolValidationError;
+exports.OllamaUnsupportedCapabilityError = OllamaUnsupportedCapabilityError;
+exports.OpenAICompatClient = OpenAICompatClient;
+exports.ToolRegistry = ToolRegistry;
+exports.addSpanEvent = addSpanEvent;
+exports.applySkill = applySkill;
+exports.calculateBackoff = calculateBackoff;
+exports.checkEndpointHealth = checkEndpointHealth;
+exports.composeMiddleware = composeMiddleware;
+exports.createConsoleLogger = createConsoleLogger;
+exports.createTimeoutSignal = createTimeoutSignal;
+exports.defineTool = defineTool;
+exports.detectModelCapabilities = detectModelCapabilities;
+exports.extractUsage = extractUsage;
+exports.inferRuntimeMode = inferRuntimeMode;
+exports.listAvailableModels = listAvailableModels;
+exports.loadMcpTools = loadMcpTools;
+exports.mapError = mapError;
+exports.normalizeChatStream = normalizeChatStream;
+exports.normalizeGenerateStream = normalizeGenerateStream;
+exports.normalizeProgressStream = normalizeProgressStream;
+exports.parseFrontmatter = parseFrontmatter;
+exports.parseNdjsonStream = parseNdjsonStream;
+exports.parseStructuredOutput = parseStructuredOutput;
+exports.registerMcpTools = registerMcpTools;
+exports.setSpanError = setSpanError;
+exports.toDataStream = toDataStream;
+exports.toResponse = toResponse;
+exports.toTextStream = toTextStream;
+exports.withRetry = withRetry;
+exports.withSpan = withSpan;
+exports.zodToJsonSchema = zodToJsonSchema;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map