@nemesis-oss/ollama-sdk 1.4.0 → 1.5.0

package/dist/index.js

@@ -1,5 +1,51 @@
 import { z } from 'zod';
 
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
 // src/config.ts
 var DEFAULT_BASE_URL = "http://localhost:11434";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -127,6 +173,15 @@ var OllamaToolValidationError = class extends OllamaClientError {
     this.issues = options.issues;
   }
 };
+var OllamaRequestValidationError = class extends OllamaClientError {
+  operationId;
+  issues;
+  constructor(message, options) {
+    super(message, { ...options, code: "request_validation_error", retryable: false });
+    this.operationId = options.operationId;
+    this.issues = options.issues;
+  }
+};
 var OllamaToolTimeoutError = class extends OllamaClientError {
   toolName;
   timeoutMs;
@@ -492,12 +547,65 @@ function composeMiddleware(middlewares, finalHandler) {
   };
 }
 
+// src/utils.ts
+async function encodeImage(image) {
+  if (typeof image === "string") return image;
+  const bufferCtor = globalThis.Buffer;
+  if (bufferCtor !== void 0) return bufferCtor.from(image).toString("base64");
+  const CHUNK_SIZE = 32768;
+  let binary = "";
+  for (let i = 0; i < image.length; i += CHUNK_SIZE) {
+    binary += String.fromCharCode(...image.subarray(i, i + CHUNK_SIZE));
+  }
+  return btoa(binary);
+}
+async function encodeImages(images) {
+  if (images === void 0) return void 0;
+  return Promise.all(images.map((image) => encodeImage(image)));
+}
+async function withEncodedImages(req) {
+  if (!req.images?.some((image) => image instanceof Uint8Array)) return req;
+  return { ...req, images: await encodeImages(req.images) };
+}
+async function withEncodedMessageImages(messages) {
+  if (!messages.some((message) => message.images?.some((image) => image instanceof Uint8Array)))
+    return messages;
+  return Promise.all(messages.map((message) => withEncodedImages(message)));
+}
+function disposableTimer(timer) {
+  return {
+    [Symbol.dispose]() {
+      clearTimeout(timer);
+    }
+  };
+}
+function disposableReader(reader) {
+  return {
+    async [Symbol.asyncDispose]() {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      reader.releaseLock();
+    }
+  };
+}
+function disposableSpan(span) {
+  return {
+    [Symbol.dispose]() {
+      span.end();
+    }
+  };
+}
+
 // src/streaming/ndjson.ts
 async function* parseNdjsonStream(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
+  var _stack = [];
   try {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const _reader = __using(_stack, disposableReader(reader), true);
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
@@ -519,12 +627,11 @@ async function* parseNdjsonStream(stream) {
     if (buffer.trim()) {
       yield JSON.parse(buffer.trim());
     }
+  } catch (_) {
+    var _error = _, _hasError = true;
   } finally {
-    try {
-      await reader.cancel();
-    } catch {
-    }
-    reader.releaseLock();
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
   }
 }
 
@@ -540,47 +647,51 @@ function dispatch(event, data, id, retry) {
   };
 }
 async function* parseSseStream(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let eventType;
-  let data = [];
-  let lastEventId;
-  let retry;
-  const processLine = (line) => {
-    if (line.length === 0) {
-      const event = dispatch(eventType, data, lastEventId, retry);
-      eventType = void 0;
-      data = [];
-      retry = void 0;
-      return event;
-    }
-    if (line.startsWith(":")) return void 0;
-    const separator = line.indexOf(":");
-    const field = separator === -1 ? line : line.slice(0, separator);
-    let value = separator === -1 ? "" : line.slice(separator + 1);
-    if (value.startsWith(" ")) value = value.slice(1);
-    switch (field) {
-      case "event":
-        eventType = value;
-        break;
-      case "data":
-        data.push(value);
-        break;
-      case "id":
-        if (!value.includes("\0")) lastEventId = value;
-        break;
-      case "retry": {
-        if (/^\d+$/.test(value)) {
-          const parsed = Number(value);
-          if (Number.isSafeInteger(parsed)) retry = parsed;
+  var _stack = [];
+  try {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let eventType;
+    let data = [];
+    let lastEventId;
+    let retry;
+    const processLine = (line) => {
+      if (line.length === 0) {
+        const event = dispatch(eventType, data, lastEventId, retry);
+        eventType = void 0;
+        data = [];
+        retry = void 0;
+        return event;
+      }
+      if (line.startsWith(":")) return void 0;
+      const separator = line.indexOf(":");
+      const field = separator === -1 ? line : line.slice(0, separator);
+      let value = separator === -1 ? "" : line.slice(separator + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+      switch (field) {
+        case "event":
+          eventType = value;
+          break;
+        case "data":
+          data.push(value);
+          break;
+        case "id":
+          if (!value.includes("\0")) lastEventId = value;
+          break;
+        case "retry": {
+          if (/^\d+$/.test(value)) {
+            const parsed = Number(value);
+            if (Number.isSafeInteger(parsed)) retry = parsed;
+          }
+          break;
         }
-        break;
+        default:
+          break;
       }
-    }
-    return void 0;
-  };
-  try {
+      return void 0;
+    };
+    const _reader = __using(_stack, disposableReader(reader), true);
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
@@ -608,12 +719,11 @@ async function* parseSseStream(stream) {
     }
     const terminal = dispatch(eventType, data, lastEventId, retry);
     if (terminal) yield terminal;
+  } catch (_) {
+    var _error = _, _hasError = true;
   } finally {
-    try {
-      await reader.cancel();
-    } catch {
-    }
-    reader.releaseLock();
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
   }
 }
 
@@ -641,16 +751,22 @@ async function withSpan(name, attributes, fn) {
   }
   const tracer = api.trace.getTracer(INSTRUMENTATION_NAME, INSTRUMENTATION_VERSION);
   return tracer.startActiveSpan(name, async (span) => {
-    span.setAttributes(cleanAttributes(attributes));
+    var _stack = [];
     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;
+      span.setAttributes(cleanAttributes(attributes));
+      const _span = __using(_stack, disposableSpan(span));
+      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;
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
     } finally {
-      span.end();
+      __callDispose(_stack, _error, _hasError);
     }
   });
 }
@@ -1060,42 +1176,48 @@ var HttpClient = class {
 
 // src/providers/health-check.ts
 async function checkEndpointHealth(endpoint, fetchImpl, timeoutMs = 5e3, middleware, onLifecycleEvent) {
-  const client = new HttpClient({
-    baseUrl: endpoint.baseUrl,
-    apiKey: endpoint.apiKey,
-    headers: endpoint.headers,
-    fetch: fetchImpl,
-    middleware,
-    onLifecycleEvent
-  });
-  const startTime = Date.now();
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  var _stack = [];
   try {
-    const res = await client.request({
-      path: "/api/version",
-      method: "GET",
-      signal: controller.signal
-    });
-    const latencyMs = Date.now() - startTime;
-    return {
-      name: endpoint.name,
+    const client = new HttpClient({
       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)
-    };
+      apiKey: endpoint.apiKey,
+      headers: endpoint.headers,
+      fetch: fetchImpl,
+      middleware,
+      onLifecycleEvent
+    });
+    const startTime = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const _timer = __using(_stack, disposableTimer(timer));
+    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)
+      };
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
   } finally {
-    clearTimeout(timer);
+    __callDispose(_stack, _error, _hasError);
   }
 }
 
@@ -2624,6 +2746,136 @@ var AnthropicCompatClient = class {
     return this.createMessage(request, signal);
   }
 };
+var ToolCallSchema = z.object({
+  function: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    arguments: z.object({}).optional()
+  }).optional()
+});
+
+// src/generated/models/ChatMessage.schema.ts
+var ChatMessageSchema = z.object({
+  role: z.enum(["system", "user", "assistant", "tool"]),
+  content: z.string(),
+  images: z.array(z.string()).optional(),
+  tool_calls: z.array(ToolCallSchema).optional()
+});
+var ModelOptionsSchema = z.object({
+  seed: z.number().optional(),
+  temperature: z.number().optional(),
+  top_k: z.number().optional(),
+  top_p: z.number().optional(),
+  min_p: z.number().optional(),
+  stop: z.union([z.string(), z.array(z.string())]).optional(),
+  num_ctx: z.number().optional(),
+  num_predict: z.number().optional()
+}).catchall(z.unknown());
+var ThinkValueSchema = z.union([z.boolean(), z.string(), z.null()]);
+var ToolDefinitionSchema = z.object({
+  type: z.enum(["function"]),
+  function: z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    parameters: z.object({})
+  })
+});
+
+// src/generated/models/ChatRequest.schema.ts
+var ChatRequestSchema = z.object({
+  model: z.string(),
+  messages: z.array(ChatMessageSchema),
+  tools: z.array(ToolDefinitionSchema).optional(),
+  format: z.union([z.enum(["json"]), z.object({})]).optional(),
+  options: ModelOptionsSchema.optional(),
+  stream: z.boolean().optional(),
+  think: ThinkValueSchema.optional(),
+  keep_alive: z.union([z.string(), z.number()]).optional(),
+  logprobs: z.boolean().optional(),
+  top_logprobs: z.number().optional()
+});
+var GenerateRequestSchema = z.object({
+  model: z.string(),
+  prompt: z.string().optional(),
+  suffix: z.string().optional(),
+  images: z.array(z.string()).optional(),
+  format: z.union([z.string(), z.object({})]).optional(),
+  system: z.string().optional(),
+  stream: z.boolean().optional(),
+  think: ThinkValueSchema.optional(),
+  raw: z.boolean().optional(),
+  keep_alive: z.union([z.string(), z.number()]).optional(),
+  options: ModelOptionsSchema.optional(),
+  logprobs: z.boolean().optional(),
+  top_logprobs: z.number().optional()
+});
+var EmbedRequestSchema = z.object({
+  model: z.string(),
+  input: z.union([z.string(), z.array(z.string())]),
+  truncate: z.boolean().optional(),
+  dimensions: z.number().optional(),
+  keep_alive: z.string().optional(),
+  options: ModelOptionsSchema.optional()
+});
+var CreateRequestSchema = z.object({
+  model: z.string(),
+  from: z.string().optional(),
+  template: z.string().optional(),
+  renderer: z.string().optional(),
+  parser: z.string().optional(),
+  files: z.object({}).catchall(z.string()).optional(),
+  draft_files: z.object({}).catchall(z.string()).optional(),
+  license: z.union([z.string(), z.array(z.string())]).optional(),
+  system: z.string().optional(),
+  parameters: z.object({}).optional(),
+  messages: z.array(ChatMessageSchema).optional(),
+  quantize: z.string().optional(),
+  draft_quantize: z.string().optional(),
+  requires: z.string().optional(),
+  stream: z.boolean().optional()
+});
+var CopyRequestSchema = z.object({
+  source: z.string(),
+  destination: z.string()
+});
+var DeleteRequestSchema = z.object({
+  model: z.string()
+});
+var PullRequestSchema = z.object({
+  model: z.string(),
+  insecure: z.boolean().optional(),
+  stream: z.boolean().optional()
+});
+var PushRequestSchema = z.object({
+  model: z.string(),
+  insecure: z.boolean().optional(),
+  stream: z.boolean().optional()
+});
+var ShowRequestSchema = z.object({
+  model: z.string(),
+  verbose: z.boolean().optional()
+});
+
+// src/generated/runtime/schema-registry.ts
+var requestSchemas = {
+  chat: ChatRequestSchema,
+  generate: GenerateRequestSchema,
+  embed: EmbedRequestSchema,
+  create: CreateRequestSchema,
+  copy: CopyRequestSchema,
+  delete: DeleteRequestSchema,
+  pull: PullRequestSchema,
+  push: PushRequestSchema,
+  show: ShowRequestSchema
+  // Operations without a registered request schema (blobs, ps, tags,
+  // version, systemOne, openai*, anthropic*) skip validation. This is
+  // deliberate — the OpenAPI spec doesn't define request bodies for
+  // GET/HEAD operations, and the compat-surface request schemas (OpenAI,
+  // Anthropic) are richer than what the IR currently models.
+};
+function getRequestSchema(operationId) {
+  return requestSchemas[operationId];
+}
 
 // src/generated/runtime/runtime.ts
 function compareVersions(a, b) {
@@ -2679,7 +2931,24 @@ var OllamaRuntime = class {
    */
   async invoke(req) {
     assertOperationAllowed(req.operation, this.options);
-    const body = buildBody(req);
+    let body = buildBody(req);
+    if (this.options.validateRequests === true && body !== void 0) {
+      const schema = getRequestSchema(req.operation.operationId);
+      if (schema) {
+        const result = schema.safeParse(body);
+        if (!result.success) {
+          throw new OllamaRequestValidationError(
+            `Request validation failed for operation "${req.operation.operationId}" (${req.operation.method} ${req.operation.path}): ` + result.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; "),
+            {
+              operationId: req.operation.operationId,
+              issues: result.error.issues,
+              request: { method: req.operation.method, url: req.operation.path }
+            }
+          );
+        }
+        body = result.data;
+      }
+    }
     const streaming = shouldStream(req);
     const httpReq = {
       path: req.operation.path,
@@ -2706,32 +2975,6 @@ var OllamaRuntime = class {
   }
 };
 
-// src/utils.ts
-async function encodeImage(image) {
-  if (typeof image === "string") return image;
-  const bufferCtor = globalThis.Buffer;
-  if (bufferCtor !== void 0) return bufferCtor.from(image).toString("base64");
-  const CHUNK_SIZE = 32768;
-  let binary = "";
-  for (let i = 0; i < image.length; i += CHUNK_SIZE) {
-    binary += String.fromCharCode(...image.subarray(i, i + CHUNK_SIZE));
-  }
-  return btoa(binary);
-}
-async function encodeImages(images) {
-  if (images === void 0) return void 0;
-  return Promise.all(images.map((image) => encodeImage(image)));
-}
-async function withEncodedImages(req) {
-  if (!req.images?.some((image) => image instanceof Uint8Array)) return req;
-  return { ...req, images: await encodeImages(req.images) };
-}
-async function withEncodedMessageImages(messages) {
-  if (!messages.some((message) => message.images?.some((image) => image instanceof Uint8Array)))
-    return messages;
-  return Promise.all(messages.map((message) => withEncodedImages(message)));
-}
-
 // src/client.ts
 var logicalRequestSequence = 0;
 function createLogicalRequestId() {
@@ -3138,9 +3381,15 @@ var OllamaClient = class {
    * multi-candidate loop, since `webSearch`/`webFetch` only ever have the one endpoint.
    */
   async executeCloudRequest(operation, options) {
-    const timeout = createTimeoutSignal(options.timeoutMs ?? this.timeoutMs, options.signal);
-    const requestId = createLogicalRequestId();
+    var _stack = [];
     try {
+      const timeout = createTimeoutSignal(options.timeoutMs ?? this.timeoutMs, options.signal);
+      const _timeout = __using(_stack, {
+        [Symbol.dispose]() {
+          timeout.cancel();
+        }
+      });
+      const requestId = createLogicalRequestId();
       const http = new HttpClient({
         baseUrl: OLLAMA_CLOUD_BASE_URL,
         apiKey: this.cloudApiKey,
@@ -3167,8 +3416,10 @@ var OllamaClient = class {
         },
         timeout.signal
       );
+    } catch (_) {
+      var _error = _, _hasError = true;
     } finally {
-      timeout.cancel();
+      __callDispose(_stack, _error, _hasError);
     }
   }
   // --- Capabilities & Health ---
@@ -3529,25 +3780,32 @@ var ToolRegistry = class {
     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);
+    var _stack = [];
     try {
+      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);
+      const _timer = __using(_stack, disposableTimer(timer));
+      const _listener = __using(_stack, {
+        [Symbol.dispose]() {
+          ctx.signal?.removeEventListener("abort", onParentAbort);
+        }
+      });
       const executePromise = Promise.resolve(
         tool.execute(params, { ...ctx, signal: controller.signal })
       );
@@ -3564,11 +3822,10 @@ var ToolRegistry = class {
           });
         })
       ]);
+    } catch (_) {
+      var _error = _, _hasError = true;
     } finally {
-      clearTimeout(timer);
-      if (ctx.signal) {
-        ctx.signal.removeEventListener("abort", onParentAbort);
-      }
+      __callDispose(_stack, _error, _hasError);
     }
   }
   truncateOutput(output) {
@@ -4113,6 +4370,6 @@ var Agent = class {
   }
 };
 
-export { ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_REQUEST_MODEL, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_USAGE_INPUT_TOKENS, ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_OLLAMA_AGENT_ITERATION, ATTR_OLLAMA_AGENT_MAX_ITERATIONS, ATTR_OLLAMA_ENDPOINT_ATTEMPT, ATTR_OLLAMA_ENDPOINT_NAME, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_URL_FULL, Agent, AnthropicCompatClient, AnthropicMessagesStream, DEFAULT_BACKOFF, DEFAULT_BASE_URL, DEFAULT_FAILOVER_CODES, DEFAULT_RETRY_CONFIG, DEFAULT_TIMEOUT_MS, EndpointRegistry, GEN_AI_SYSTEM_OLLAMA, HttpClient, McpBridge, ModelsClient, NANOS_PER_MS, NANOS_PER_SECOND, NOOP_LOGGER, OLLAMA_CLOUD_BASE_URL, OllamaAbortError, OllamaAgentMaxIterationsError, OllamaAgentMaxToolCallsError, OllamaAuthError, OllamaClient, OllamaClientError, OllamaGenericClientError, OllamaIncompatibleModelError, OllamaMcpError, OllamaModelRoutingError, OllamaNetworkError, OllamaNotFoundError, OllamaQuotaExceededError, OllamaRateLimitError, OllamaServerError, OllamaSkillInvalidError, OllamaSkillNotFoundError, OllamaStream, OllamaTimeoutError, OllamaToolTimeoutError, OllamaToolValidationError, OllamaUnsupportedCapabilityError, OpenAIChatCompletionStream, OpenAICompatClient, OpenAICompletionStream, OpenAIResponsesStream, OpenAIResponsesStreamError, QuotaManager, ToolRegistry, addSpanEvent, applySkill, calculateBackoff, checkEndpointHealth, composeMiddleware, createConsoleLogger, createOllamaCloudFreeTierQuota, createTimeoutSignal, defineTool, detectModelCapabilities, encodeImage, extractUsage, inferRuntimeMode, listAllMcpTools, listAvailableModels, loadMcpTools, mapError, normalizeChatStream, normalizeGenerateStream, normalizeProgressStream, parseFrontmatter, parseNdjsonStream, parseSseStream, parseStructuredOutput, registerMcpTools, resolveCredentialEndpoints, setSpanError, toDataStream, toResponse, toTextStream, withRetry, withSpan, zodToJsonSchema };
+export { ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_REQUEST_MODEL, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_USAGE_INPUT_TOKENS, ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_OLLAMA_AGENT_ITERATION, ATTR_OLLAMA_AGENT_MAX_ITERATIONS, ATTR_OLLAMA_ENDPOINT_ATTEMPT, ATTR_OLLAMA_ENDPOINT_NAME, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_URL_FULL, Agent, AnthropicCompatClient, AnthropicMessagesStream, DEFAULT_BACKOFF, DEFAULT_BASE_URL, DEFAULT_FAILOVER_CODES, DEFAULT_RETRY_CONFIG, DEFAULT_TIMEOUT_MS, EndpointRegistry, GEN_AI_SYSTEM_OLLAMA, HttpClient, McpBridge, ModelsClient, NANOS_PER_MS, NANOS_PER_SECOND, NOOP_LOGGER, OLLAMA_CLOUD_BASE_URL, OllamaAbortError, OllamaAgentMaxIterationsError, OllamaAgentMaxToolCallsError, OllamaAuthError, OllamaClient, OllamaClientError, OllamaGenericClientError, OllamaIncompatibleModelError, OllamaMcpError, OllamaModelRoutingError, OllamaNetworkError, OllamaNotFoundError, OllamaQuotaExceededError, OllamaRateLimitError, OllamaRequestValidationError, OllamaServerError, OllamaSkillInvalidError, OllamaSkillNotFoundError, OllamaStream, OllamaTimeoutError, OllamaToolTimeoutError, OllamaToolValidationError, OllamaUnsupportedCapabilityError, OpenAIChatCompletionStream, OpenAICompatClient, OpenAICompletionStream, OpenAIResponsesStream, OpenAIResponsesStreamError, QuotaManager, ToolRegistry, addSpanEvent, applySkill, calculateBackoff, checkEndpointHealth, composeMiddleware, createConsoleLogger, createOllamaCloudFreeTierQuota, createTimeoutSignal, defineTool, detectModelCapabilities, encodeImage, extractUsage, inferRuntimeMode, listAllMcpTools, listAvailableModels, loadMcpTools, mapError, normalizeChatStream, normalizeGenerateStream, normalizeProgressStream, parseFrontmatter, parseNdjsonStream, parseSseStream, parseStructuredOutput, registerMcpTools, resolveCredentialEndpoints, setSpanError, toDataStream, toResponse, toTextStream, withRetry, withSpan, zodToJsonSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map