@nemesis-oss/ollama-sdk 1.6.0 → 1.8.0

package/dist/index.cjs

@@ -184,6 +184,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 OllamaToolTimeoutError = class extends OllamaClientError {
   toolName;
   timeoutMs;
@@ -239,10 +268,12 @@ var OllamaAgentMaxIterationsError = class extends OllamaClientError {
 var OllamaMcpError = class extends OllamaClientError {
   mcpMethod;
   toolName;
+  issues;
   constructor(message, options) {
     super(message, { ...options, code: "mcp_error", retryable: options.retryable ?? false });
     this.mcpMethod = options.mcpMethod;
     this.toolName = options.toolName;
+    this.issues = options.issues;
   }
 };
 var OllamaSkillNotFoundError = class extends OllamaClientError {
@@ -1885,8 +1916,9 @@ var ModelsClient = class {
         { singleEndpoint: true }
       );
       return true;
-    } catch {
-      return false;
+    } catch (err) {
+      if (err instanceof OllamaNotFoundError) return false;
+      throw err;
     }
   }
 };
@@ -2796,28 +2828,45 @@ var ChatRequestSchema = zod.z.object({
   logprobs: zod.z.boolean().optional(),
   top_logprobs: zod.z.number().optional()
 });
-var GenerateRequestSchema = zod.z.object({
-  model: zod.z.string(),
-  prompt: zod.z.string().optional(),
-  suffix: zod.z.string().optional(),
-  images: zod.z.array(zod.z.string()).optional(),
-  format: zod.z.union([zod.z.string(), zod.z.object({})]).optional(),
-  system: zod.z.string().optional(),
-  stream: zod.z.boolean().optional(),
-  think: ThinkValueSchema.optional(),
-  raw: zod.z.boolean().optional(),
-  keep_alive: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
-  options: ModelOptionsSchema.optional(),
-  logprobs: zod.z.boolean().optional(),
-  top_logprobs: zod.z.number().optional()
+var TokenLogprobSchema = zod.z.object({
+  token: zod.z.string().optional(),
+  logprob: zod.z.number().optional(),
+  bytes: zod.z.array(zod.z.number()).optional()
 });
-var EmbedRequestSchema = zod.z.object({
-  model: zod.z.string(),
-  input: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
-  truncate: zod.z.boolean().optional(),
-  dimensions: zod.z.number().optional(),
-  keep_alive: zod.z.string().optional(),
-  options: ModelOptionsSchema.optional()
+
+// src/generated/models/Logprob.schema.ts
+var LogprobSchema = zod.z.object({
+  token: zod.z.string().optional(),
+  logprob: zod.z.number().optional(),
+  bytes: zod.z.array(zod.z.number()).optional(),
+  top_logprobs: zod.z.array(TokenLogprobSchema).optional()
+});
+
+// src/generated/models/ChatResponse.schema.ts
+var ChatResponseSchema = zod.z.object({
+  model: zod.z.string().optional(),
+  created_at: zod.z.string().optional(),
+  message: zod.z.object({
+    role: zod.z.enum(["assistant"]).optional(),
+    content: zod.z.string().optional(),
+    thinking: zod.z.string().optional(),
+    tool_calls: zod.z.array(ToolCallSchema).optional(),
+    images: zod.z.array(zod.z.string()).optional()
+  }).optional(),
+  done: zod.z.boolean().optional(),
+  done_reason: zod.z.string().optional(),
+  total_duration: zod.z.number().optional(),
+  load_duration: zod.z.number().optional(),
+  prompt_eval_count: zod.z.number().optional(),
+  prompt_eval_cached_count: zod.z.number().optional(),
+  prompt_eval_duration: zod.z.number().optional(),
+  eval_count: zod.z.number().optional(),
+  eval_duration: zod.z.number().optional(),
+  logprobs: zod.z.array(LogprobSchema).optional()
+});
+var CopyRequestSchema = zod.z.object({
+  source: zod.z.string(),
+  destination: zod.z.string()
 });
 var CreateRequestSchema = zod.z.object({
   model: zod.z.string(),
@@ -2836,13 +2885,91 @@ var CreateRequestSchema = zod.z.object({
   requires: zod.z.string().optional(),
   stream: zod.z.boolean().optional()
 });
-var CopyRequestSchema = zod.z.object({
-  source: zod.z.string(),
-  destination: zod.z.string()
-});
 var DeleteRequestSchema = zod.z.object({
   model: zod.z.string()
 });
+var EmbedRequestSchema = zod.z.object({
+  model: zod.z.string(),
+  input: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
+  truncate: zod.z.boolean().optional(),
+  dimensions: zod.z.number().optional(),
+  keep_alive: zod.z.string().optional(),
+  options: ModelOptionsSchema.optional()
+});
+var EmbedResponseSchema = zod.z.object({
+  model: zod.z.string().optional(),
+  embeddings: zod.z.array(zod.z.array(zod.z.number())).optional(),
+  total_duration: zod.z.number().optional(),
+  load_duration: zod.z.number().optional(),
+  prompt_eval_count: zod.z.number().optional()
+});
+var GenerateRequestSchema = zod.z.object({
+  model: zod.z.string(),
+  prompt: zod.z.string().optional(),
+  suffix: zod.z.string().optional(),
+  images: zod.z.array(zod.z.string()).optional(),
+  format: zod.z.union([zod.z.string(), zod.z.object({})]).optional(),
+  system: zod.z.string().optional(),
+  stream: zod.z.boolean().optional(),
+  think: ThinkValueSchema.optional(),
+  raw: zod.z.boolean().optional(),
+  keep_alive: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  options: ModelOptionsSchema.optional(),
+  logprobs: zod.z.boolean().optional(),
+  top_logprobs: zod.z.number().optional()
+});
+var GenerateResponseSchema = zod.z.object({
+  model: zod.z.string().optional(),
+  created_at: zod.z.string().optional(),
+  response: zod.z.string().optional(),
+  thinking: zod.z.string().optional(),
+  done: zod.z.boolean().optional(),
+  done_reason: zod.z.string().optional(),
+  total_duration: zod.z.number().optional(),
+  load_duration: zod.z.number().optional(),
+  prompt_eval_count: zod.z.number().optional(),
+  prompt_eval_cached_count: zod.z.number().optional(),
+  prompt_eval_duration: zod.z.number().optional(),
+  eval_count: zod.z.number().optional(),
+  eval_duration: zod.z.number().optional(),
+  logprobs: zod.z.array(LogprobSchema).optional()
+});
+var ModelSummarySchema = zod.z.object({
+  name: zod.z.string().optional(),
+  model: zod.z.string().optional(),
+  remote_model: zod.z.string().optional(),
+  remote_host: zod.z.string().optional(),
+  modified_at: zod.z.string().optional(),
+  size: zod.z.number().optional(),
+  digest: zod.z.string().optional(),
+  details: zod.z.object({
+    format: zod.z.string().optional(),
+    family: zod.z.string().optional(),
+    families: zod.z.array(zod.z.string()).optional(),
+    parameter_size: zod.z.string().optional(),
+    quantization_level: zod.z.string().optional()
+  }).optional()
+});
+
+// src/generated/models/ListResponse.schema.ts
+var ListResponseSchema = zod.z.object({
+  models: zod.z.array(ModelSummarySchema).optional()
+});
+var PsSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  model: zod.z.string().optional(),
+  size: zod.z.number().optional(),
+  digest: zod.z.string().optional(),
+  details: zod.z.object({}).optional(),
+  expires_at: zod.z.string().optional(),
+  size_vram: zod.z.number().optional(),
+  context_length: zod.z.number().optional()
+});
+
+// src/generated/models/PsResponse.schema.ts
+var PsResponseSchema = zod.z.object({
+  models: zod.z.array(PsSchema).optional()
+});
 var PullRequestSchema = zod.z.object({
   model: zod.z.string(),
   insecure: zod.z.boolean().optional(),
@@ -2857,27 +2984,164 @@ var ShowRequestSchema = zod.z.object({
   model: zod.z.string(),
   verbose: zod.z.boolean().optional()
 });
+var ThinkingSchema = zod.z.object({
+  values: zod.z.array(zod.z.union([zod.z.boolean(), zod.z.string()])),
+  default: zod.z.union([zod.z.boolean(), zod.z.string()])
+});
+
+// src/generated/models/ShowResponse.schema.ts
+var ShowResponseSchema = zod.z.object({
+  thinking: ThinkingSchema.optional(),
+  parameters: zod.z.string().optional(),
+  license: zod.z.string().optional(),
+  modified_at: zod.z.string().optional(),
+  details: zod.z.object({}).optional(),
+  template: zod.z.string().optional(),
+  capabilities: zod.z.array(zod.z.string()).optional(),
+  model_info: zod.z.object({}).optional()
+});
+var StatusResponseSchema = zod.z.object({
+  status: zod.z.string().optional()
+});
+var SystemOneContentSchema = zod.z.union([
+  zod.z.string().regex(new RegExp("\\S")),
+  zod.z.object({}).catchall(zod.z.unknown()),
+  zod.z.array(zod.z.unknown())
+]);
+
+// src/generated/models/SystemOneChoiceQuestion.schema.ts
+var SystemOneChoiceQuestionSchema = zod.z.object({
+  type: zod.z.enum(["choice"]),
+  instructions: SystemOneContentSchema,
+  criteria: zod.z.object({}).catchall(zod.z.union([zod.z.string(), zod.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 = zod.z.object({
+  type: zod.z.enum(["noul"]),
+  instructions: SystemOneContentSchema,
+  criteria: zod.z.object({
+    false: zod.z.string().optional(),
+    true: zod.z.string().optional()
+  }).optional()
+});
+var SystemOneScoreQuestionSchema = zod.z.object({
+  type: zod.z.enum(["score"]),
+  instructions: SystemOneContentSchema,
+  criteria: zod.z.array(zod.z.string()).min(2).max(26)
+});
+
+// src/generated/models/SystemOneRequest.schema.ts
+var SystemOneRequestSchema = zod.z.object({
+  model: zod.z.string().regex(new RegExp("\\S")),
+  state: SystemOneContentSchema,
+  images: zod.z.array(zod.z.string()).optional(),
+  questions: zod.z.object({}).catchall(
+    zod.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: zod.z.union([zod.z.string(), zod.z.number()]).optional()
+});
+var SystemOneConfidenceSchema = zod.z.number().min(0).max(1);
+var SystemOneProbabilitiesSchema = zod.z.object({}).catchall(zod.z.number().min(0).max(1));
+
+// src/generated/models/SystemOneChoiceAnswer.schema.ts
+var SystemOneChoiceAnswerSchema = zod.z.object({
+  type: zod.z.enum(["choice"]),
+  choice: zod.z.string(),
+  probabilities: SystemOneProbabilitiesSchema,
+  confidence: SystemOneConfidenceSchema
+});
+var SystemOneNoulAnswerSchema = zod.z.object({
+  type: zod.z.enum(["noul"]),
+  noul: zod.z.number().min(0).max(1)
+});
+var SystemOneScoreAnswerSchema = zod.z.object({
+  type: zod.z.enum(["score"]),
+  score: zod.z.number().min(0).max(25),
+  legend: zod.z.object({}).catchall(zod.z.string()),
+  probabilities: SystemOneProbabilitiesSchema,
+  confidence: SystemOneConfidenceSchema
+});
+
+// src/generated/models/SystemOneResponse.schema.ts
+var SystemOneResponseSchema = zod.z.object({
+  model: zod.z.string(),
+  answers: zod.z.object({}).catchall(
+    zod.z.union([SystemOneChoiceAnswerSchema, SystemOneNoulAnswerSchema, SystemOneScoreAnswerSchema])
+  ),
+  usage: zod.z.object({
+    input_tokens: zod.z.number().min(0),
+    output_tokens: zod.z.number().min(0)
+  })
+});
+var VersionResponseSchema = zod.z.object({
+  version: zod.z.string().optional()
+});
+var WebFetchRequestSchema = zod.z.object({
+  url: zod.z.string()
+});
+var WebFetchResponseSchema = zod.z.object({
+  title: zod.z.string().optional(),
+  content: zod.z.string().optional(),
+  links: zod.z.array(zod.z.string()).optional()
+});
+var WebSearchRequestSchema = zod.z.object({
+  query: zod.z.string(),
+  max_results: zod.z.number().min(1).max(10).optional()
+});
+var WebSearchResultSchema = zod.z.object({
+  title: zod.z.string().optional(),
+  url: zod.z.string().optional(),
+  content: zod.z.string().optional()
+});
+
+// src/generated/models/WebSearchResponse.schema.ts
+var WebSearchResponseSchema = zod.z.object({
+  results: zod.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) {
@@ -2890,18 +3154,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) {
@@ -2924,6 +3183,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.
    *
@@ -2932,7 +3220,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);
@@ -2951,32 +3239,668 @@ 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;
+}
+
+// src/generated/api/operations.ts
+var blobsOp = {
+  operationId: "blobs",
+  method: "HEAD",
+  path: "/api/blobs/{digest}",
+  environment: { local: true, cloud: false },
+  parameters: [{ name: "digest", in: "path", required: true, schema: { type: "string" } }],
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native",
+  notes: [
+    "HEAD-only endpoint for blob existence checks; declared in OpenAPI but not in the legacy parity manifest."
+  ]
+};
+var chatOp = {
+  operationId: "chat",
+  method: "POST",
+  path: "/api/chat",
+  request: { $ref: "#/schemas/ChatRequest" },
+  response: { $ref: "#/schemas/ChatResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: {
+    thinking: "model-dependent",
+    tools: "model-dependent",
+    vision: "model-dependent",
+    structuredOutput: "supported",
+    logprobs: "supported"
+  },
+  status: { documented: true },
+  domain: "native",
+  notes: [
+    "Use /api/show to discover model-specific thinking values and defaults.",
+    "Structured output (format field) is rejected by Ollama Cloud."
+  ]
+};
+var copyOp = {
+  operationId: "copy",
+  method: "POST",
+  path: "/api/copy",
+  request: { $ref: "#/schemas/CopyRequest" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var createOp = {
+  operationId: "create",
+  method: "POST",
+  path: "/api/create",
+  request: { $ref: "#/schemas/CreateRequest" },
+  response: { $ref: "#/schemas/StatusResponse" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: { thinking: "unsupported", tools: "unsupported" },
+  status: { documented: true },
+  domain: "native",
+  notes: ["Model creation is local-only; Ollama Cloud does not support it."]
+};
+var deleteOp = {
+  operationId: "delete",
+  method: "DELETE",
+  path: "/api/delete",
+  request: { $ref: "#/schemas/DeleteRequest" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var embedOp = {
+  operationId: "embed",
+  method: "POST",
+  path: "/api/embed",
+  request: { $ref: "#/schemas/EmbedRequest" },
+  response: { $ref: "#/schemas/EmbedResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: { embeddings: "supported" },
+  status: { documented: true },
+  domain: "native"
+};
+var generateOp = {
+  operationId: "generate",
+  method: "POST",
+  path: "/api/generate",
+  request: { $ref: "#/schemas/GenerateRequest" },
+  response: { $ref: "#/schemas/GenerateResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: {
+    thinking: "model-dependent",
+    vision: "supported",
+    structuredOutput: "supported",
+    logprobs: "supported"
+  },
+  status: { documented: true },
+  domain: "native"
+};
+var psOp = {
+  operationId: "ps",
+  method: "GET",
+  path: "/api/ps",
+  response: { $ref: "#/schemas/PsResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var pullOp = {
+  operationId: "pull",
+  method: "POST",
+  path: "/api/pull",
+  request: { $ref: "#/schemas/PullRequest" },
+  response: { $ref: "#/schemas/StatusResponse" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var pushOp = {
+  operationId: "push",
+  method: "POST",
+  path: "/api/push",
+  request: { $ref: "#/schemas/PushRequest" },
+  response: { $ref: "#/schemas/StatusResponse" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var showOp = {
+  operationId: "show",
+  method: "POST",
+  path: "/api/show",
+  request: { $ref: "#/schemas/ShowRequest" },
+  response: { $ref: "#/schemas/ShowResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native",
+  notes: [
+    "Capabilities source: /api/show is the runtime source of truth for model-dependent capability values (tools, vision, thinking, embeddings)."
+  ]
+};
+var systemOneOp = {
+  operationId: "systemOne",
+  method: "POST",
+  path: "/v1/systemone",
+  request: { $ref: "#/schemas/SystemOneRequest" },
+  response: { $ref: "#/schemas/SystemOneResponse" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "json", streaming: false },
+  capabilities: {
+    thinking: "unsupported",
+    tools: "unsupported",
+    vision: "model-dependent",
+    structuredOutput: "unsupported",
+    logprobs: "unsupported",
+    embeddings: "unsupported"
+  },
+  constraints: {
+    minOllamaVersion: "0.35.0",
+    maxRequestBytes: 65536,
+    maxRequestBytesWithImages: 33554432
+  },
+  status: { documented: true, experimental: true },
+  domain: "native",
+  notes: [
+    "Local-only; Ollama Cloud rejects /v1/systemone.",
+    "64 KiB request limit without images, 32 MiB with images (includes JSON/base64 overhead).",
+    "No tools, no generation controls (temperature, top_p, etc.).",
+    "Vision is model-dependent: images are accepted by vision-weighted models (Clef/Clef Flash) but not by text-only models.",
+    "Experimental: behavioral surface may change between Ollama releases."
+  ]
+};
+var tagsOp = {
+  operationId: "tags",
+  method: "GET",
+  path: "/api/tags",
+  response: { $ref: "#/schemas/ListResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var versionOp = {
+  operationId: "version",
+  method: "GET",
+  path: "/api/version",
+  response: { $ref: "#/schemas/VersionResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+
+// src/generated/api/native-api.ts
+var NativeApi = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  runtime;
+  blobs(digest, options) {
+    return this.runtime.invoke({
+      operation: blobsOp,
+      body: void 0,
+      pathParams: { digest },
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+  chat(request) {
+    return this.runtime.invoke({
+      operation: chatOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  copy(request) {
+    return this.runtime.invoke({
+      operation: copyOp,
+      body: request
+    });
+  }
+  create(request) {
+    return this.runtime.invoke({
+      operation: createOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  delete(request) {
+    return this.runtime.invoke({
+      operation: deleteOp,
+      body: request
+    });
+  }
+  embed(request) {
+    return this.runtime.invoke({
+      operation: embedOp,
+      body: request
+    });
+  }
+  generate(request) {
+    return this.runtime.invoke({
+      operation: generateOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  ps(options) {
+    return this.runtime.invoke({
+      operation: psOp,
+      body: void 0,
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+  pull(request) {
+    return this.runtime.invoke({
+      operation: pullOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  push(request) {
+    return this.runtime.invoke({
+      operation: pushOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  show(request) {
+    return this.runtime.invoke({
+      operation: showOp,
+      body: request
+    });
+  }
+  systemOne(request) {
+    return this.runtime.invoke({
+      operation: systemOneOp,
+      body: request
+    });
+  }
+  tags(options) {
+    return this.runtime.invoke({
+      operation: tagsOp,
+      body: void 0,
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+  version(options) {
+    return this.runtime.invoke({
+      operation: versionOp,
+      body: void 0,
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
   }
 };
 
+// src/failover-http-client.ts
+var FailoverHttpClient = class {
+  constructor(client, baseUrl) {
+    this.client = client;
+    this.baseUrl = baseUrl;
+  }
+  client;
+  /**
+   * The first candidate endpoint's base URL. Used for inferRuntimeMode()
+   * checks (local vs cloud). The actual request routing picks the best
+   * healthy endpoint per call.
+   */
+  baseUrl;
+  /**
+   * Route a request through OllamaClient's failover machinery.
+   *
+   * Each call to request() goes through executeWithFailover, which:
+   *   - Picks the best healthy endpoint from the registry
+   *   - Applies retry/backoff within that endpoint
+   *   - Fails over to the next candidate on retryable errors
+   *   - Reports success/failure to the endpoint health tracker
+   *
+   * Wave 15 (P1): the model is extracted from the request body by the
+   * runtime and passed via the `model` field on the options. This lets
+   * the failover layer filter endpoints by `OllamaEndpoint.models`
+   * (credential-scoped routing). If no model is provided, all endpoints
+   * are considered.
+   *
+   * The `raw` option (for streaming responses) is passed through
+   * unchanged — executeWithFailover returns whatever the operation
+   * callback returns, including raw Response objects.
+   */
+  async request(options) {
+    const { model, ...httpOptions } = options;
+    return this.client.executeWithFailover(
+      async (http, signal) => {
+        const mergedOptions = {
+          ...httpOptions,
+          ...httpOptions.signal !== void 0 ? { signal } : { signal }
+        };
+        return http.request(mergedOptions);
+      },
+      {
+        singleEndpoint: false,
+        ...model !== void 0 ? { model } : {}
+      }
+    );
+  }
+};
+
+// src/decision.ts
+function createDecision(client) {
+  return {
+    async choice(params) {
+      const response = await client.systemOne({
+        model: params.model,
+        state: params.state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "choice",
+            instructions: params.instructions,
+            criteria: params.criteria
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        choice: answer.choice,
+        probabilities: answer.probabilities,
+        confidence: answer.confidence,
+        usage: response.usage
+      };
+    },
+    async noul(params) {
+      const response = await client.systemOne({
+        model: params.model,
+        state: params.state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "noul",
+            instructions: params.instructions
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        noul: answer.noul,
+        bool: answer.noul >= 0.5,
+        usage: response.usage
+      };
+    },
+    async score(params) {
+      const response = await client.systemOne({
+        model: params.model,
+        state: params.state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "score",
+            instructions: params.instructions,
+            criteria: params.criteria
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        score: answer.score,
+        legend: answer.legend,
+        probabilities: answer.probabilities,
+        confidence: answer.confidence,
+        usage: response.usage
+      };
+    },
+    async route(params) {
+      const response = await client.systemOne({
+        model: params.model,
+        state: params.state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "choice",
+            instructions: params.instructions,
+            criteria: params.criteria
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        route: answer.choice,
+        confidence: answer.confidence
+      };
+    },
+    async verify(params) {
+      const state = {
+        claim: params.claim,
+        evidence: params.evidence
+      };
+      const response = await client.systemOne({
+        model: params.model,
+        state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "noul",
+            instructions: params.instructions ?? "Is the claim supported by the evidence?"
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        verified: answer.noul >= 0.5,
+        probability: answer.noul
+      };
+    },
+    async rank(params) {
+      const promises = params.candidates.map(async (candidate) => {
+        const response = await client.systemOne({
+          model: params.model,
+          state: candidate.state,
+          ...params.images ? { images: params.images } : {},
+          questions: {
+            decision: {
+              type: "score",
+              instructions: params.instructions,
+              criteria: params.criteria
+            }
+          },
+          ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+        });
+        const answer = response.answers.decision;
+        return {
+          candidate: candidate.id,
+          score: answer.score,
+          confidence: answer.confidence
+        };
+      });
+      const results = await Promise.all(promises);
+      return results.sort((a, b) => b.score - a.score);
+    }
+  };
+}
+
 // src/client.ts
 var logicalRequestSequence = 0;
 function createLogicalRequestId() {
@@ -3037,42 +3961,82 @@ var OllamaClient = class {
    * API with the generated `NativeApi` / `OpenAIApi` / `AnthropicApi`
    * surface without configuring two separate HttpClient instances.
    *
-   * The returned runtime is bound to the registry's first candidate
-   * endpoint (or the resolved single-endpoint config if no `endpoints`
-   * array was provided). For multi-endpoint configs that need per-call
-   * routing, prefer constructing `OllamaRuntime` directly with a
-   * specific HttpClient:
-   *
-   * ```ts
-   * const http = new HttpClient({ baseUrl: 'http://host-a:11434' });
-   * const runtime = new OllamaRuntime({ http });
-   * const api = new NativeApi(runtime);
-   * ```
+   * Wave 14: the runtime now participates in multi-endpoint failover.
+   * Each request is routed through this client's `executeWithFailover`
+   * machinery via a {@link FailoverHttpClient} wrapper. If the first
+   * candidate endpoint is down, requests automatically fail over to
+   * the next healthy candidate — matching the behavior of the
+   * hand-written OllamaClient methods (chat, generate, etc.).
    *
    * The runtime is cached on first call — subsequent calls return the
-   * same instance.
+   * same instance. The `FailoverHttpClient` holds a reference to this
+   * client, so it always sees the current endpoint registry state.
    */
   get runtime() {
     if (this._runtime === void 0) {
       const candidates = this.registry.candidates();
       const endpoint = candidates[0];
       const baseUrl = endpoint?.baseUrl ?? "http://localhost:11434";
-      const http = new HttpClient({
-        baseUrl,
-        ...endpoint?.apiKey !== void 0 ? { apiKey: endpoint.apiKey } : {},
-        ...endpoint?.headers !== void 0 ? { headers: endpoint.headers } : {},
+      const http = new FailoverHttpClient(this, baseUrl);
+      const cloudHttp = new HttpClient({
+        baseUrl: OLLAMA_CLOUD_BASE_URL,
+        ...this.cloudApiKey !== void 0 ? { apiKey: this.cloudApiKey } : {},
         fetch: this.fetchImpl,
         ...this.middleware !== void 0 ? { middleware: this.middleware } : {},
         ...this.onLifecycleEvent !== void 0 ? { onLifecycleEvent: this.onLifecycleEvent } : {}
       });
       this._runtime = new OllamaRuntime({
         http,
+        cloudHttp,
         localMode: inferRuntimeMode(baseUrl) === "local"
       });
     }
     return this._runtime;
   }
   _runtime;
+  /**
+   * Lazily-constructed `NativeApi` bound to this client's runtime. Exposes
+   * the full generated native API surface (chat, generate, embed, systemOne,
+   * etc.) with contract-driven types and runtime enforcement.
+   *
+   * Wave 13: `systemOne()` delegates to this accessor.
+   */
+  get native() {
+    if (this._nativeApi === void 0) {
+      this._nativeApi = new NativeApi(this.runtime);
+    }
+    return this._nativeApi;
+  }
+  _nativeApi;
+  /**
+   * Higher-level System One decision helpers (Wave 14B).
+   *
+   * Ergonomic wrappers around `systemOne()` for the six most common
+   * decision patterns: `choice()`, `noul()`, `score()`, `route()`,
+   * `verify()`, `rank()`. Each constructs a single-question request
+   * and extracts the typed answer.
+   *
+   * ```ts
+   * const result = await client.decision.choice({
+   *   model: 'tev1:4b',
+   *   state: 'Customer was charged twice',
+   *   instructions: 'What is the primary intent?',
+   *   criteria: {
+   *     refund: 'Customer wants a refund',
+   *     duplicate_charge: 'Customer reports multiple charges',
+   *   },
+   * });
+   * console.log(result.choice); // 'duplicate_charge'
+   * console.log(result.confidence); // 0.89
+   * ```
+   */
+  get decision() {
+    if (this._decision === void 0) {
+      this._decision = createDecision(this);
+    }
+    return this._decision;
+  }
+  _decision;
   /**
    * 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
@@ -3345,6 +4309,43 @@ var OllamaClient = class {
   version = () => this.models.version();
   createBlob = (digest, data) => this.models.createBlob(digest, data);
   checkBlob = (digest) => this.models.checkBlob(digest);
+  // --- System One (Wave 13) ---
+  /**
+   * Ollama's System One decision layer (`POST /v1/systemone`) — evaluates
+   * 1–64 typed questions (choice, noul, or score) against a provided state
+   * and returns typed answers with probabilities and confidence.
+   *
+   * Local-only; requires Ollama >= 0.35.0. The runtime enforces the
+   * version constraint automatically (lazily fetching `/api/version` when
+   * `enforceVersion` is `'auto'` or `'strict'`) and rejects cloud-mode
+   * calls. Request size is checked client-side: 64 KiB without images,
+   * 32 MiB with images.
+   *
+   * The generic `Q` parameter captures the caller's question map at
+   * compile time, giving key-safe answer access:
+   *
+   * ```ts
+   * const result = await ollama.systemOne({
+   *   model: 'tev1:4b',
+   *   state: { ticket: 'Customer was charged twice' },
+   *   questions: {
+   *     intent: { type: 'choice', instructions: '...', criteria: { ... } },
+   *     urgent: { type: 'noul', instructions: '...' },
+   *   },
+   * });
+   * result.answers.intent  // ✓ SystemOneAnswer (choice)
+   * result.answers.urgent  // ✓ SystemOneAnswer (noul)
+   * result.answers.typo    // ✗ TypeScript error
+   * ```
+   *
+   * For the low-level generated API (without the generic wrapper), use
+   * `client.native.systemOne(request)` directly.
+   */
+  async systemOne(request) {
+    return this.native.systemOne(
+      request
+    );
+  }
   // --- Web Endpoints ---
   /**
    * Ollama's hosted web search tool (`POST https://ollama.com/api/web_search`) — a fixed
@@ -4006,6 +5007,22 @@ async function listAllMcpTools(mcpClient, options = {}, signal) {
     const params = cursor !== void 0 ? { cursor } : void 0;
     const requestOptions = signal !== void 0 ? { signal } : void 0;
     const page = await mcpClient.listTools(params, requestOptions);
+    const pageNames = /* @__PURE__ */ new Set();
+    for (const tool of page.tools) {
+      if (pageNames.has(tool.name)) {
+        throw new OllamaMcpError(
+          `MCP tools/list returned duplicate tool name "${tool.name}"`,
+          { mcpMethod: "listTools", toolName: tool.name }
+        );
+      }
+      pageNames.add(tool.name);
+      if (tools.some((existing) => existing.name === tool.name)) {
+        throw new OllamaMcpError(
+          `MCP tools/list returned duplicate tool name "${tool.name}" across pages`,
+          { mcpMethod: "listTools", toolName: tool.name }
+        );
+      }
+    }
     tools.push(...page.tools);
     if (page.nextCursor === void 0) {
       return tools;
@@ -4019,6 +5036,9 @@ async function listAllMcpTools(mcpClient, options = {}, signal) {
   throw new Error("MCP tools/list exceeded maxPages (" + maxPages + ")");
 }
 function formatMcpToolResult(result) {
+  if ("resultType" in result || "task" in result) {
+    return JSON.stringify(result) ?? String(result);
+  }
   const parts = result.content.map((block) => {
     if (block.type === "text" && typeof block.text === "string") {
       return block.text;
@@ -4040,6 +5060,20 @@ function formatMcpToolResult(result) {
   }
   return parts.join("\n");
 }
+function supportsTaskCalls(mcpClient) {
+  return mcpClient.getServerCapabilities?.()?.tasks?.requests?.tools?.call !== void 0;
+}
+function shouldCallAsTask(descriptor, options, serverSupportsTasks) {
+  const support = descriptor.execution?.taskSupport;
+  if (support === "required" && !serverSupportsTasks) {
+    throw new OllamaMcpError(
+      `MCP tool "${descriptor.name}" requires task execution, but the server does not advertise tasks.requests.tools.call`,
+      { mcpMethod: "callTool", toolName: descriptor.name }
+    );
+  }
+  if (!serverSupportsTasks || support === void 0 || support === "forbidden") return false;
+  return support === "required" || options.taskMode === "all-supported";
+}
 function createInputValidator(inputSchema) {
   return zod.z.custom().superRefine((value, ctx) => {
     const issues = validateJsonSchema(value, inputSchema);
@@ -4052,7 +5086,7 @@ function createInputValidator(inputSchema) {
     }
   });
 }
-function convertMcpDescriptorToTool(descriptor, mcpClient, namePrefix = "", resultMode = "text") {
+function convertMcpDescriptorToTool(descriptor, mcpClient, namePrefix = "", resultMode = "text", validateOutputSchema = true, executeAsTask = false, taskTtlMs) {
   const toolName = `${namePrefix}${descriptor.name}`;
   const inputSchema = descriptor.inputSchema ?? { type: "object", properties: {} };
   const properties = inputSchema["properties"] ?? {};
@@ -4072,10 +5106,27 @@ function convertMcpDescriptorToTool(descriptor, mcpClient, namePrefix = "", resu
         const result = await mcpClient.callTool(
           {
             name: descriptor.name,
-            arguments: args
+            arguments: args,
+            ...executeAsTask ? { task: taskTtlMs !== void 0 ? { ttl: taskTtlMs } : {} } : {}
           },
-          context.signal !== void 0 ? { signal: context.signal } : void 0
+          {
+            ...context.signal !== void 0 ? { signal: context.signal } : {},
+            allowInputRequired: true
+          }
         );
+        if (!("resultType" in result) && !("task" in result) && validateOutputSchema && descriptor.outputSchema !== void 0 && result.structuredContent !== void 0) {
+          const issues = validateJsonSchema(result.structuredContent, descriptor.outputSchema);
+          if (issues.length > 0) {
+            throw new OllamaMcpError(
+              `MCP tool "${descriptor.name}" returned structuredContent that violates outputSchema`,
+              {
+                mcpMethod: "tools/call",
+                toolName: descriptor.name,
+                issues
+              }
+            );
+          }
+        }
         return resultMode === "structured" ? result : formatMcpToolResult(result);
       } catch (err) {
         if (err instanceof OllamaMcpError) throw err;
@@ -4098,9 +5149,29 @@ function convertMcpDescriptorToTool(descriptor, mcpClient, namePrefix = "", resu
 }
 async function loadMcpTools(mcpClient, options = {}, signal) {
   try {
+    if (options.taskTtlMs !== void 0 && (!Number.isFinite(options.taskTtlMs) || options.taskTtlMs <= 0)) {
+      throw new RangeError("MCP taskTtlMs must be a positive finite number");
+    }
     const tools = await listAllMcpTools(mcpClient, options, signal);
-    return tools.map((t) => convertMcpDescriptorToTool(t, mcpClient, options.namePrefix, options.resultMode));
+    const serverSupportsTasks = supportsTaskCalls(mcpClient);
+    return tools.map((tool) => {
+      const taskCall = shouldCallAsTask(
+        tool,
+        options,
+        serverSupportsTasks
+      );
+      return convertMcpDescriptorToTool(
+        tool,
+        mcpClient,
+        options.namePrefix,
+        options.resultMode,
+        options.validateOutputSchema ?? true,
+        taskCall,
+        options.taskTtlMs
+      );
+    });
   } catch (err) {
+    if (err instanceof OllamaMcpError) throw err;
     throw new OllamaMcpError("Failed listing MCP tools from client", {
       mcpMethod: "listTools",
       cause: err
@@ -4111,8 +5182,18 @@ async function registerMcpTools(registry, mcpClient, options = {}, signal) {
   const tools = await loadMcpTools(mcpClient, options, signal);
   registry.registerMany(tools);
 }
-
-// src/mcp/bridge.ts
+var taskSchema = zod.z.object({
+  taskId: zod.z.string(),
+  status: zod.z.enum(["working", "input_required", "completed", "failed", "cancelled"]),
+  statusMessage: zod.z.string().optional(),
+  createdAt: zod.z.string(),
+  lastUpdatedAt: zod.z.string(),
+  ttl: zod.z.number().optional(),
+  pollInterval: zod.z.number().optional()
+}).passthrough();
+var callToolResultSchema = zod.z.custom(
+  (value) => typeof value === "object" && value !== null && "content" in value && Array.isArray(value.content)
+);
 var McpBridge = class _McpBridge {
   constructor(client, options = {}) {
     this.client = client;
@@ -4147,6 +5228,50 @@ var McpBridge = class _McpBridge {
   async register(registry, signal) {
     await registry.registerMany(await this.loadTools(signal));
   }
+  /** Refreshes the current MCP tool catalog into an existing registry without clearing local tools. */
+  async refresh(registry, signal) {
+    await registry.registerMany(await this.loadTools(signal));
+  }
+  /** Fetches one legacy MCP task's current status without starting a polling loop. */
+  async getTaskStatus(taskId, signal) {
+    return this.requestTask(
+      "tasks/get",
+      taskId,
+      taskSchema,
+      signal
+    );
+  }
+  /** Retrieves a completed legacy MCP task's result. */
+  async getTaskResult(taskId, signal) {
+    return this.requestTask(
+      "tasks/result",
+      taskId,
+      callToolResultSchema,
+      signal
+    );
+  }
+  /** Cancels one legacy MCP task. */
+  async cancelTask(taskId, signal) {
+    return this.requestTask(
+      "tasks/cancel",
+      taskId,
+      taskSchema,
+      signal
+    );
+  }
+  requestTask(method, taskId, resultSchema, signal) {
+    if (this.client.request === void 0) {
+      throw new OllamaMcpError(
+        `MCP client does not support ${method} requests`,
+        { mcpMethod: method }
+      );
+    }
+    return this.client.request(
+      { method, params: { taskId } },
+      resultSchema,
+      signal !== void 0 ? { signal } : void 0
+    );
+  }
 };
 
 // src/skills/frontmatter.ts
@@ -4420,8 +5545,11 @@ exports.OllamaNetworkError = OllamaNetworkError;
 exports.OllamaNotFoundError = OllamaNotFoundError;
 exports.OllamaQuotaExceededError = OllamaQuotaExceededError;
 exports.OllamaRateLimitError = OllamaRateLimitError;
+exports.OllamaRequestTooLargeError = OllamaRequestTooLargeError;
 exports.OllamaRequestValidationError = OllamaRequestValidationError;
+exports.OllamaResponseValidationError = OllamaResponseValidationError;
 exports.OllamaServerError = OllamaServerError;
+exports.OllamaServerVersionUnknownError = OllamaServerVersionUnknownError;
 exports.OllamaSkillInvalidError = OllamaSkillInvalidError;
 exports.OllamaSkillNotFoundError = OllamaSkillNotFoundError;
 exports.OllamaStream = OllamaStream;
@@ -4442,6 +5570,7 @@ exports.calculateBackoff = calculateBackoff;
 exports.checkEndpointHealth = checkEndpointHealth;
 exports.composeMiddleware = composeMiddleware;
 exports.createConsoleLogger = createConsoleLogger;
+exports.createDecision = createDecision;
 exports.createOllamaCloudFreeTierQuota = createOllamaCloudFreeTierQuota;
 exports.createTimeoutSignal = createTimeoutSignal;
 exports.defineTool = defineTool;