@nemesis-oss/ollama-sdk 1.7.0 → 1.8.0

package/dist/generated-runtime.js

@@ -72,6 +72,35 @@ var OllamaRequestValidationError = class extends OllamaClientError {
     this.issues = options.issues;
   }
 };
+var OllamaRequestTooLargeError = class extends OllamaClientError {
+  operationId;
+  actualBytes;
+  maxBytes;
+  constructor(message, options) {
+    super(message, { ...options, code: "request_too_large", retryable: false, status: 413 });
+    this.operationId = options.operationId;
+    this.actualBytes = options.actualBytes;
+    this.maxBytes = options.maxBytes;
+  }
+};
+var OllamaResponseValidationError = class extends OllamaClientError {
+  operationId;
+  issues;
+  constructor(message, options) {
+    super(message, { ...options, code: "response_validation_error", retryable: false });
+    this.operationId = options.operationId;
+    this.issues = options.issues;
+  }
+};
+var OllamaServerVersionUnknownError = class extends OllamaClientError {
+  operationId;
+  minRequiredVersion;
+  constructor(message, options) {
+    super(message, { ...options, code: "server_version_unknown", retryable: false });
+    this.operationId = options.operationId;
+    this.minRequiredVersion = options.minRequiredVersion;
+  }
+};
 var OllamaGenericClientError = class extends OllamaClientError {
   constructor(message, options) {
     super(message, { ...options, code: "client_error" });
@@ -127,6 +156,98 @@ async function* parseNdjsonStream(stream) {
     _promise && await _promise;
   }
 }
+
+// src/streaming/sse.ts
+function dispatch(event, data, id, retry) {
+  if (data.length === 0) return void 0;
+  const joined = data.join("\n");
+  return {
+    ...event !== void 0 ? { event } : {},
+    data: joined.endsWith("\n") ? joined.slice(0, -1) : joined,
+    ...id !== void 0 ? { id } : {},
+    ...retry !== void 0 ? { retry } : {}
+  };
+}
+async function* parseSseStream(stream) {
+  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;
+        }
+        default:
+          break;
+      }
+      return void 0;
+    };
+    const _reader = __using(_stack, disposableReader(reader), true);
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      while (true) {
+        const lf = buffer.indexOf("\n");
+        const cr = buffer.indexOf("\r");
+        if (lf === -1 && cr === -1) break;
+        if (cr !== -1 && lf === -1 && cr === buffer.length - 1) break;
+        const lineEnd = lf === -1 ? cr : cr === -1 ? lf : Math.min(lf, cr);
+        let separatorLength = 1;
+        if (buffer[lineEnd] === "\r" && buffer[lineEnd + 1] === "\n") {
+          separatorLength = 2;
+        }
+        const line = buffer.slice(0, lineEnd);
+        buffer = buffer.slice(lineEnd + separatorLength);
+        const event = processLine(line);
+        if (event) yield event;
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.length > 0) {
+      const event = processLine(buffer);
+      if (event) yield event;
+    }
+    const terminal = dispatch(eventType, data, lastEventId, retry);
+    if (terminal) yield terminal;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
+  }
+}
 var ToolCallSchema = z.object({
   function: z.object({
     name: z.string(),
@@ -175,28 +296,45 @@ var ChatRequestSchema = z.object({
   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 TokenLogprobSchema = z.object({
+  token: z.string().optional(),
+  logprob: z.number().optional(),
+  bytes: z.array(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()
+
+// src/generated/models/Logprob.schema.ts
+var LogprobSchema = z.object({
+  token: z.string().optional(),
+  logprob: z.number().optional(),
+  bytes: z.array(z.number()).optional(),
+  top_logprobs: z.array(TokenLogprobSchema).optional()
+});
+
+// src/generated/models/ChatResponse.schema.ts
+var ChatResponseSchema = z.object({
+  model: z.string().optional(),
+  created_at: z.string().optional(),
+  message: z.object({
+    role: z.enum(["assistant"]).optional(),
+    content: z.string().optional(),
+    thinking: z.string().optional(),
+    tool_calls: z.array(ToolCallSchema).optional(),
+    images: z.array(z.string()).optional()
+  }).optional(),
+  done: z.boolean().optional(),
+  done_reason: z.string().optional(),
+  total_duration: z.number().optional(),
+  load_duration: z.number().optional(),
+  prompt_eval_count: z.number().optional(),
+  prompt_eval_cached_count: z.number().optional(),
+  prompt_eval_duration: z.number().optional(),
+  eval_count: z.number().optional(),
+  eval_duration: z.number().optional(),
+  logprobs: z.array(LogprobSchema).optional()
+});
+var CopyRequestSchema = z.object({
+  source: z.string(),
+  destination: z.string()
 });
 var CreateRequestSchema = z.object({
   model: z.string(),
@@ -215,13 +353,91 @@ var CreateRequestSchema = z.object({
   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 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 EmbedResponseSchema = z.object({
+  model: z.string().optional(),
+  embeddings: z.array(z.array(z.number())).optional(),
+  total_duration: z.number().optional(),
+  load_duration: z.number().optional(),
+  prompt_eval_count: 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 GenerateResponseSchema = z.object({
+  model: z.string().optional(),
+  created_at: z.string().optional(),
+  response: z.string().optional(),
+  thinking: z.string().optional(),
+  done: z.boolean().optional(),
+  done_reason: z.string().optional(),
+  total_duration: z.number().optional(),
+  load_duration: z.number().optional(),
+  prompt_eval_count: z.number().optional(),
+  prompt_eval_cached_count: z.number().optional(),
+  prompt_eval_duration: z.number().optional(),
+  eval_count: z.number().optional(),
+  eval_duration: z.number().optional(),
+  logprobs: z.array(LogprobSchema).optional()
+});
+var ModelSummarySchema = z.object({
+  name: z.string().optional(),
+  model: z.string().optional(),
+  remote_model: z.string().optional(),
+  remote_host: z.string().optional(),
+  modified_at: z.string().optional(),
+  size: z.number().optional(),
+  digest: z.string().optional(),
+  details: z.object({
+    format: z.string().optional(),
+    family: z.string().optional(),
+    families: z.array(z.string()).optional(),
+    parameter_size: z.string().optional(),
+    quantization_level: z.string().optional()
+  }).optional()
+});
+
+// src/generated/models/ListResponse.schema.ts
+var ListResponseSchema = z.object({
+  models: z.array(ModelSummarySchema).optional()
+});
+var PsSchema = z.object({
+  name: z.string().optional(),
+  model: z.string().optional(),
+  size: z.number().optional(),
+  digest: z.string().optional(),
+  details: z.object({}).optional(),
+  expires_at: z.string().optional(),
+  size_vram: z.number().optional(),
+  context_length: z.number().optional()
+});
+
+// src/generated/models/PsResponse.schema.ts
+var PsResponseSchema = z.object({
+  models: z.array(PsSchema).optional()
+});
 var PullRequestSchema = z.object({
   model: z.string(),
   insecure: z.boolean().optional(),
@@ -236,27 +452,164 @@ var ShowRequestSchema = z.object({
   model: z.string(),
   verbose: z.boolean().optional()
 });
+var ThinkingSchema = z.object({
+  values: z.array(z.union([z.boolean(), z.string()])),
+  default: z.union([z.boolean(), z.string()])
+});
+
+// src/generated/models/ShowResponse.schema.ts
+var ShowResponseSchema = z.object({
+  thinking: ThinkingSchema.optional(),
+  parameters: z.string().optional(),
+  license: z.string().optional(),
+  modified_at: z.string().optional(),
+  details: z.object({}).optional(),
+  template: z.string().optional(),
+  capabilities: z.array(z.string()).optional(),
+  model_info: z.object({}).optional()
+});
+var StatusResponseSchema = z.object({
+  status: z.string().optional()
+});
+var SystemOneContentSchema = z.union([
+  z.string().regex(new RegExp("\\S")),
+  z.object({}).catchall(z.unknown()),
+  z.array(z.unknown())
+]);
+
+// src/generated/models/SystemOneChoiceQuestion.schema.ts
+var SystemOneChoiceQuestionSchema = z.object({
+  type: z.enum(["choice"]),
+  instructions: SystemOneContentSchema,
+  criteria: z.object({}).catchall(z.union([z.string(), z.null()])).refine((v) => Object.keys(v).length >= 2, { message: "must have at least 2 properties" }).refine((v) => Object.keys(v).length <= 26, { message: "must have at most 26 properties" }).refine((v) => Object.keys(v).every((k) => new RegExp("\\S").test(k)), {
+    message: 'property names must match pattern "\\S"'
+  })
+});
+var SystemOneNoulQuestionSchema = z.object({
+  type: z.enum(["noul"]),
+  instructions: SystemOneContentSchema,
+  criteria: z.object({
+    false: z.string().optional(),
+    true: z.string().optional()
+  }).optional()
+});
+var SystemOneScoreQuestionSchema = z.object({
+  type: z.enum(["score"]),
+  instructions: SystemOneContentSchema,
+  criteria: z.array(z.string()).min(2).max(26)
+});
+
+// src/generated/models/SystemOneRequest.schema.ts
+var SystemOneRequestSchema = z.object({
+  model: z.string().regex(new RegExp("\\S")),
+  state: SystemOneContentSchema,
+  images: z.array(z.string()).optional(),
+  questions: z.object({}).catchall(
+    z.union([
+      SystemOneChoiceQuestionSchema,
+      SystemOneNoulQuestionSchema,
+      SystemOneScoreQuestionSchema
+    ])
+  ).refine((v) => Object.keys(v).length >= 1, { message: "must have at least 1 properties" }).refine((v) => Object.keys(v).length <= 64, { message: "must have at most 64 properties" }).refine((v) => Object.keys(v).every((k) => new RegExp("\\S").test(k)), {
+    message: 'property names must match pattern "\\S"'
+  }),
+  keep_alive: z.union([z.string(), z.number()]).optional()
+});
+var SystemOneConfidenceSchema = z.number().min(0).max(1);
+var SystemOneProbabilitiesSchema = z.object({}).catchall(z.number().min(0).max(1));
+
+// src/generated/models/SystemOneChoiceAnswer.schema.ts
+var SystemOneChoiceAnswerSchema = z.object({
+  type: z.enum(["choice"]),
+  choice: z.string(),
+  probabilities: SystemOneProbabilitiesSchema,
+  confidence: SystemOneConfidenceSchema
+});
+var SystemOneNoulAnswerSchema = z.object({
+  type: z.enum(["noul"]),
+  noul: z.number().min(0).max(1)
+});
+var SystemOneScoreAnswerSchema = z.object({
+  type: z.enum(["score"]),
+  score: z.number().min(0).max(25),
+  legend: z.object({}).catchall(z.string()),
+  probabilities: SystemOneProbabilitiesSchema,
+  confidence: SystemOneConfidenceSchema
+});
+
+// src/generated/models/SystemOneResponse.schema.ts
+var SystemOneResponseSchema = z.object({
+  model: z.string(),
+  answers: z.object({}).catchall(
+    z.union([SystemOneChoiceAnswerSchema, SystemOneNoulAnswerSchema, SystemOneScoreAnswerSchema])
+  ),
+  usage: z.object({
+    input_tokens: z.number().min(0),
+    output_tokens: z.number().min(0)
+  })
+});
+var VersionResponseSchema = z.object({
+  version: z.string().optional()
+});
+var WebFetchRequestSchema = z.object({
+  url: z.string()
+});
+var WebFetchResponseSchema = z.object({
+  title: z.string().optional(),
+  content: z.string().optional(),
+  links: z.array(z.string()).optional()
+});
+var WebSearchRequestSchema = z.object({
+  query: z.string(),
+  max_results: z.number().min(1).max(10).optional()
+});
+var WebSearchResultSchema = z.object({
+  title: z.string().optional(),
+  url: z.string().optional(),
+  content: z.string().optional()
+});
+
+// src/generated/models/WebSearchResponse.schema.ts
+var WebSearchResponseSchema = z.object({
+  results: z.array(WebSearchResultSchema).optional()
+});
 
 // src/generated/runtime/schema-registry.ts
 var requestSchemas = {
   chat: ChatRequestSchema,
-  generate: GenerateRequestSchema,
-  embed: EmbedRequestSchema,
-  create: CreateRequestSchema,
   copy: CopyRequestSchema,
+  create: CreateRequestSchema,
   delete: DeleteRequestSchema,
+  embed: EmbedRequestSchema,
+  generate: GenerateRequestSchema,
   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.
+  show: ShowRequestSchema,
+  systemOne: SystemOneRequestSchema,
+  webFetch: WebFetchRequestSchema,
+  webSearch: WebSearchRequestSchema
+};
+var responseSchemas = {
+  chat: ChatResponseSchema,
+  create: StatusResponseSchema,
+  embed: EmbedResponseSchema,
+  generate: GenerateResponseSchema,
+  ps: PsResponseSchema,
+  pull: StatusResponseSchema,
+  push: StatusResponseSchema,
+  show: ShowResponseSchema,
+  systemOne: SystemOneResponseSchema,
+  tags: ListResponseSchema,
+  version: VersionResponseSchema,
+  webFetch: WebFetchResponseSchema,
+  webSearch: WebSearchResponseSchema
 };
 function getRequestSchema(operationId) {
   return requestSchemas[operationId];
 }
+function getResponseSchema(operationId) {
+  return responseSchemas[operationId];
+}
 
 // src/generated/runtime/runtime.ts
 function compareVersions(a, b) {
@@ -269,18 +622,13 @@ function compareVersions(a, b) {
   }
   return 0;
 }
-function assertOperationAllowed(operation, options) {
-  const localMode = options.localMode ?? true;
-  if (!localMode && !operation.environment.cloud) {
-    throw new OllamaGenericClientError(
-      `Operation ${operation.operationId} (${operation.method} ${operation.path}) is local-only and not supported in cloud mode.`
-    );
-  }
-  if (operation.constraints?.minOllamaVersion && options.serverVersion && compareVersions(options.serverVersion, operation.constraints.minOllamaVersion) < 0) {
-    throw new OllamaGenericClientError(
-      `Operation ${operation.operationId} (${operation.method} ${operation.path}) requires Ollama >= ${operation.constraints.minOllamaVersion} (server reports ${options.serverVersion}).`
-    );
-  }
+async function fetchServerVersion(http) {
+  const result = await http.request({
+    path: "/api/version",
+    method: "GET"
+  });
+  if (result && typeof result.version === "string") return result.version;
+  return void 0;
 }
 function shouldStream(req) {
   if (req.body && typeof req.body === "object" && "stream" in req.body) {
@@ -303,6 +651,35 @@ var OllamaRuntime = class {
     this.options = options;
   }
   options;
+  /**
+   * Cached promise of the Ollama server version, populated lazily the first
+   * time a version-gated operation is invoked. `undefined` until then.
+   *
+   * Wave 12 (P0 #5): see {@link OllamaRuntimeOptions.enforceVersion}.
+   */
+  serverVersionCache;
+  /**
+   * Wave 15 (P0): resolve the HTTP backend for a given operation.
+   *
+   * Operations with a declared `host` (e.g. web search/fetch at
+   * https://ollama.com) must route to a HttpClient pointed at that host,
+   * not the default one. The runtime accepts an optional `cloudHttp`
+   * backend for this purpose — if the operation declares a host and no
+   * cloud backend is configured, the runtime throws rather than silently
+   * sending the request to the wrong server.
+   */
+  resolveHttpBackend(operation) {
+    if (operation.host) {
+      const cloudHttp = this.options.cloudHttp;
+      if (!cloudHttp) {
+        throw new OllamaGenericClientError(
+          `Operation ${operation.operationId} (${operation.method} ${operation.path}) targets host "${operation.host}" but the runtime has no cloudHttp backend configured. Use OllamaClient.webSearch() / OllamaClient.webFetch() for cloud-hosted operations, or construct OllamaRuntime with a cloudHttp option.`
+        );
+      }
+      return cloudHttp;
+    }
+    return this.options.http;
+  }
   /**
    * Invoke an operation. Called by every generated API method.
    *
@@ -311,7 +688,7 @@ var OllamaRuntime = class {
    * class's overloads pick the right return type at compile time.
    */
   async invoke(req) {
-    assertOperationAllowed(req.operation, this.options);
+    await this.assertOperationAllowed(req.operation);
     let body = buildBody(req);
     if (this.options.validateRequests === true && body !== void 0) {
       const schema = getRequestSchema(req.operation.operationId);
@@ -330,32 +707,172 @@ var OllamaRuntime = class {
         body = result.data;
       }
     }
+    if (body !== void 0) {
+      const serialized = serializeForByteCount(body);
+      const hasImages = bodyHasImages(body);
+      const maxBytesWithImages = req.operation.constraints?.maxRequestBytesWithImages;
+      const maxBytesBase = req.operation.constraints?.maxRequestBytes;
+      const applicableLimit = hasImages && maxBytesWithImages !== void 0 ? maxBytesWithImages : maxBytesBase;
+      if (applicableLimit !== void 0 && serialized.byteLength > applicableLimit) {
+        throw new OllamaRequestTooLargeError(
+          `Operation ${req.operation.operationId} (${req.operation.method} ${req.operation.path}) request body is ${serialized.byteLength} bytes, exceeding the contract limit of ${applicableLimit} bytes` + (hasImages ? " (images limit)." : "."),
+          {
+            operationId: req.operation.operationId,
+            actualBytes: serialized.byteLength,
+            maxBytes: applicableLimit,
+            request: { method: req.operation.method, url: req.operation.path }
+          }
+        );
+      }
+    }
     const streaming = shouldStream(req);
+    const resolvedPath = resolvePathParams(req.operation.path, req.pathParams);
+    const model = req.model ?? extractModelFromBody(body);
     const httpReq = {
-      path: req.operation.path,
+      path: resolvedPath,
       method: req.operation.method,
       ...body !== void 0 ? { body } : {},
       ...req.signal !== void 0 ? { signal: req.signal } : {},
-      // For streaming calls, request the raw Response so we can pipe it
-      // through parseNdjsonStream directly. This inherits middleware,
-      // retry, telemetry, and error-mapping from HttpClient — the
-      // previous Wave 3 implementation bypassed them with a direct
-      // `fetch()` call.
-      ...streaming ? { raw: true } : {}
+      ...streaming ? { raw: true } : {},
+      ...model !== void 0 ? { model } : {}
     };
     if (!streaming) {
-      return await this.options.http.request(httpReq);
+      const result = await this.resolveHttpBackend(req.operation).request(httpReq);
+      if (this.options.validateResponses === true) {
+        const responseSchema = getResponseSchema(req.operation.operationId);
+        if (responseSchema) {
+          const result2 = responseSchema.safeParse(result);
+          if (!result2.success) {
+            throw new OllamaResponseValidationError(
+              `Response validation failed for operation "${req.operation.operationId}" (${req.operation.method} ${req.operation.path}): ` + result2.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; "),
+              {
+                operationId: req.operation.operationId,
+                issues: result2.error.issues,
+                request: { method: req.operation.method, url: req.operation.path }
+              }
+            );
+          }
+        }
+      }
+      return result;
     }
-    const response = await this.options.http.request(httpReq);
+    const response = await this.resolveHttpBackend(req.operation).request(httpReq);
     if (!response.body) {
       throw new OllamaGenericClientError(
         `Operation ${req.operation.operationId}: streaming response had no body.`
       );
     }
-    return parseNdjsonStream(response.body);
+    return parseStreamByMode(req.operation.transport.mode, response.body);
+  }
+  /**
+   * Apply environment + version guards before delegating to HttpClient.
+   *
+   * Throws {@link OllamaGenericClientError} when:
+   *   - The operation is local-only and the runtime is in cloud mode.
+   *   - The operation has `constraints.minOllamaVersion` and the server is older.
+   *
+   * Wave 12 (P0 #5): when `minOllamaVersion` is declared but the runtime's
+   * `serverVersion` is unknown AND `enforceVersion` is `'auto'` or
+   * `'strict'`, the runtime lazily fetches `/api/version` (cached on the
+   * runtime instance) so the constraint is actually enforced even when the
+   * caller didn't supply it. Previously the constraint was only enforced
+   * when `serverVersion` was manually supplied — meaning in practice it was
+   * almost never enforced.
+   */
+  async assertOperationAllowed(operation) {
+    const localMode = this.options.localMode ?? true;
+    if (!localMode && !operation.environment.cloud) {
+      throw new OllamaGenericClientError(
+        `Operation ${operation.operationId} (${operation.method} ${operation.path}) is local-only and not supported in cloud mode.`
+      );
+    }
+    const minVersion = operation.constraints?.minOllamaVersion;
+    if (!minVersion) return;
+    let serverVersion = this.options.serverVersion;
+    const policy = this.options.enforceVersion ?? "auto";
+    if (!serverVersion && policy !== "off") {
+      if (!this.serverVersionCache) {
+        const p = fetchServerVersion(this.options.http).catch((err) => {
+          if (policy === "strict") {
+            throw new OllamaServerVersionUnknownError(
+              `Operation ${operation.operationId} requires Ollama >= ${minVersion} but the runtime could not determine the server version (enforceVersion: 'strict').`,
+              {
+                operationId: operation.operationId,
+                minRequiredVersion: minVersion,
+                cause: err
+              }
+            );
+          }
+          return void 0;
+        });
+        this.serverVersionCache = p;
+      }
+      serverVersion = await this.serverVersionCache ?? void 0;
+    }
+    if (serverVersion && compareVersions(serverVersion, minVersion) < 0) {
+      throw new OllamaGenericClientError(
+        `Operation ${operation.operationId} (${operation.method} ${operation.path}) requires Ollama >= ${minVersion} (server reports ${serverVersion}).`
+      );
+    }
   }
 };
+function parseStreamByMode(mode, body) {
+  if (mode === "ndjson") {
+    return parseNdjsonStream(body);
+  }
+  if (mode === "sse") {
+    return parseSseStreamAsJson(body);
+  }
+  throw new OllamaGenericClientError(
+    `Transport mode "${mode}" is not a streaming mode; cannot parse a stream for it.`
+  );
+}
+async function* parseSseStreamAsJson(body) {
+  for await (const event of parseSseStream(body)) {
+    const data = event.data;
+    if (!data) continue;
+    if (data === "[DONE]") return;
+    try {
+      yield JSON.parse(data);
+    } catch (err) {
+      throw new OllamaGenericClientError(`Failed to parse SSE event data as JSON: ${data}`, {
+        cause: err
+      });
+    }
+  }
+}
+function serializeForByteCount(body) {
+  if (body instanceof Uint8Array) return body;
+  if (typeof body === "string") return new TextEncoder().encode(body);
+  const json = JSON.stringify(body);
+  return new TextEncoder().encode(json);
+}
+function bodyHasImages(body) {
+  if (typeof body !== "object" || body === null) return false;
+  const obj = body;
+  const images = obj.images;
+  return Array.isArray(images) && images.length > 0;
+}
+function resolvePathParams(pathTemplate, pathParams) {
+  if (!pathTemplate.includes("{")) return pathTemplate;
+  const params = pathParams ?? {};
+  return pathTemplate.replace(/\{([^}]+)\}/g, (_match, name) => {
+    const value = params[name];
+    if (value === void 0) {
+      throw new OllamaGenericClientError(
+        `Missing path parameter "${name}" for path template "${pathTemplate}". Provide it via the pathParams field on the invoke() request.`
+      );
+    }
+    return encodeURIComponent(value);
+  });
+}
+function extractModelFromBody(body) {
+  if (typeof body !== "object" || body === null) return void 0;
+  const obj = body;
+  const model = obj.model;
+  return typeof model === "string" ? model : void 0;
+}
 
-export { OllamaRuntime, getRequestSchema, requestSchemas };
+export { OllamaRuntime, getRequestSchema, getResponseSchema, requestSchemas, responseSchemas };
 //# sourceMappingURL=generated-runtime.js.map
 //# sourceMappingURL=generated-runtime.js.map