@nemesis-oss/ollama-sdk 1.16.0 → 1.18.0

package/dist/index.cjs

@@ -1113,6 +1113,18 @@ function createRequestId() {
   requestSequence += 1;
   return `ollama-http-${requestSequence}`;
 }
+function isWebReadableStreamBody(body) {
+  return typeof body === "object" && body !== null && typeof body.getReader === "function";
+}
+function buildFetchInit(req) {
+  return {
+    method: req.method,
+    headers: req.headers,
+    ...req.body !== void 0 ? { body: req.body } : {},
+    ...req.signal !== void 0 ? { signal: req.signal } : {},
+    ...isWebReadableStreamBody(req.body) ? { duplex: "half" } : {}
+  };
+}
 function sameHeaders(actual, expected) {
   const actualEntries = Object.fromEntries(
     Object.entries(actual).map(([key, value]) => [key.toLowerCase(), value])
@@ -1162,13 +1174,7 @@ var HttpClient = class {
       timestamp: startedAt
     });
     const finalHandler = async (req) => {
-      const init = {
-        method: req.method,
-        headers: req.headers,
-        ...req.body !== void 0 ? { body: req.body } : {},
-        ...req.signal !== void 0 ? { signal: req.signal } : {}
-      };
-      const response = await this.fetchImpl(req.url, init);
+      const response = await this.fetchImpl(req.url, buildFetchInit(req));
       rawResponse = response;
       const responseHeaders = response.headers && typeof response.headers.entries === "function" ? Object.fromEntries(response.headers.entries()) : {};
       return {
@@ -1179,12 +1185,7 @@ var HttpClient = class {
     };
     try {
       if (this.middleware.length === 0) {
-        const response2 = await this.fetchImpl(request.url, {
-          method: request.method,
-          headers: request.headers,
-          ...request.body !== void 0 ? { body: request.body } : {},
-          ...request.signal !== void 0 ? { signal: request.signal } : {}
-        });
+        const response2 = await this.fetchImpl(request.url, buildFetchInit(request));
         if (response2.status >= 200 && response2.status < 300) {
           this.onLifecycleEvent?.({
             type: "success",
@@ -2775,7 +2776,7 @@ var ModelsClient = class {
       { model, singleEndpoint: true }
     );
   }
-  async createBlob(digest, data) {
+  async createBlob(digest, data, request) {
     await this.runner(
       (http, signal) => http.request({
         path: `/api/blobs/${encodeURIComponent(digest)}`,
@@ -2783,10 +2784,10 @@ var ModelsClient = class {
         rawBody: data,
         signal
       }),
-      { singleEndpoint: true }
+      { ...request, singleEndpoint: true }
     );
   }
-  async checkBlob(digest) {
+  async checkBlob(digest, request) {
     try {
       await this.runner(
         (http, signal) => http.request({
@@ -2794,7 +2795,7 @@ var ModelsClient = class {
           method: "HEAD",
           signal
         }),
-        { singleEndpoint: true }
+        { ...request, singleEndpoint: true }
       );
       return true;
     } catch (err) {
@@ -2836,9 +2837,32 @@ var ModelsClient = class {
    */
   async createBlobFromData(data, opts) {
     const digest = opts?.digest ?? await this.computeBlobDigest(data);
-    const alreadyExisted = await this.checkBlob(digest);
+    const alreadyExisted = await this.checkBlob(digest, opts);
     if (!alreadyExisted) {
-      await this.createBlob(digest, data);
+      await this.createBlob(digest, data, opts);
+    }
+    return { digest, alreadyExisted };
+  }
+  /**
+   * Streams a blob upload straight from a web `ReadableStream` — the
+   * multi-gigabyte-safe counterpart of {@link createBlobFromData}. The body
+   * is never materialized in memory: the transport hands the stream to
+   * `fetch` directly (setting `duplex: 'half'`, which Node 18+ requires for
+   * stream bodies), so peak heap usage is a transport-level chunk, not the
+   * blob size.
+   *
+   * The digest must be known up front — it *is* the upload URL
+   * (`/api/blobs/<digest>`), the same content-addressed protocol
+   * `curl -T` performs. Hash first when you don't have it: in-memory bytes
+   * via {@link computeBlobDigest}, files via {@link createBlobFromFile}
+   * (which hashes in a streaming pass). The server verifies the streamed
+   * bytes against the digest and rejects mismatches, so a corrupted or
+   * truncated stream fails the upload instead of poisoning the store.
+   */
+  async createBlobFromStream(digest, stream, request) {
+    const alreadyExisted = await this.checkBlob(digest, request);
+    if (!alreadyExisted) {
+      await this.createBlob(digest, stream, request);
     }
     return { digest, alreadyExisted };
   }
@@ -2847,16 +2871,61 @@ var ModelsClient = class {
    * `node:fs` import, so browser bundles never pull it in). The file name
    * (basename) is what `/api/create`'s `files` map expects as the key, so
    * this returns it alongside the digest.
+   *
+   * Streams both passes in fixed-size chunks — peak heap is O(chunk), not
+   * O(file), so multi-gigabyte GGUFs never enter the Node heap:
+   *
+   *  1. **Hash pass** (skipped when `opts.digest` is provided): the file is
+   *     streamed through `node:crypto`'s incremental SHA-256.
+   *  2. **Upload pass**: `node:fs` createReadStream → web ReadableStream →
+   *     `fetch` body with `duplex: 'half'` (see {@link createBlobFromStream}).
+   *
+   * A pre-existing blob (HEAD 200) skips the upload pass entirely, same as
+   * {@link createBlobFromData}.
    */
   async createBlobFromFile(path, opts) {
     const nodeFsModule = "node:fs";
-    const { promises: fs } = await import(nodeFsModule);
-    const data = await fs.readFile(path);
-    const result = await this.createBlobFromData(new Uint8Array(data), {
-      ...opts
-    });
+    const { createReadStream } = await import(nodeFsModule);
+    const nodeCryptoModule = "node:crypto";
+    const { createHash } = await import(nodeCryptoModule);
+    const nodeStreamModule = "node:stream";
+    const { Readable } = await import(nodeStreamModule);
+    const CHUNK_BYTES = 256 * 1024;
+    let digest = opts?.digest;
+    if (digest === void 0) {
+      const hash = createHash("sha256");
+      const hashStream = createReadStream(path, { highWaterMark: CHUNK_BYTES });
+      try {
+        for await (const chunk of hashStream) {
+          if (opts?.signal?.aborted) {
+            throw new OllamaAbortError("createBlobFromFile: aborted while hashing", {});
+          }
+          hash.update(chunk);
+        }
+      } finally {
+        hashStream.destroy();
+      }
+      digest = `sha256:${hash.digest("hex")}`;
+    }
+    const alreadyExisted = await this.checkBlob(digest, opts);
+    if (!alreadyExisted) {
+      const uploadStream = createReadStream(path, { highWaterMark: CHUNK_BYTES });
+      const onAbort = () => {
+        uploadStream.destroy();
+      };
+      opts?.signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        await this.createBlob(
+          digest,
+          Readable.toWeb(uploadStream),
+          opts
+        );
+      } finally {
+        opts?.signal?.removeEventListener("abort", onAbort);
+      }
+    }
     const fileName = path.split(/[\\/]/).pop() ?? path;
-    return { ...result, fileName };
+    return { digest, alreadyExisted, fileName };
   }
   /**
    * One-shot custom-model publishing from raw GGUF weights, following the
@@ -4110,7 +4179,7 @@ var SystemOneNoulQuestionSchema = zod.z.object({
 var SystemOneScoreQuestionSchema = zod.z.object({
   type: zod.z.enum(["score"]),
   instructions: SystemOneContentSchema,
-  criteria: zod.z.array(zod.z.string()).min(2).max(26)
+  criteria: zod.z.array(zod.z.string()).min(2).max(10)
 });
 
 // src/generated/models/SystemOneRequest.schema.ts
@@ -4145,7 +4214,7 @@ var SystemOneNoulAnswerSchema = zod.z.object({
 });
 var SystemOneScoreAnswerSchema = zod.z.object({
   type: zod.z.enum(["score"]),
-  score: zod.z.number().min(0).max(25),
+  score: zod.z.number().min(0).max(9),
   legend: zod.z.object({}).catchall(zod.z.string()),
   probabilities: SystemOneProbabilitiesSchema,
   confidence: SystemOneConfidenceSchema
@@ -5456,9 +5525,16 @@ var FailoverHttpClient = class {
 };
 
 // src/decision.ts
+function validateThreshold(value, name) {
+  if (value === void 0) return;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > 1) {
+    throw new RangeError(`${name} must be a number in (0, 1] \u2014 got ${String(value)}`);
+  }
+}
 function createDecision(client) {
   return {
     async choice(params) {
+      validateThreshold(params.minConfidence, "minConfidence");
       const response = await client.systemOne({
         model: params.model,
         state: params.state,
@@ -5477,10 +5553,12 @@ function createDecision(client) {
         choice: answer.choice,
         probabilities: answer.probabilities,
         confidence: answer.confidence,
+        ...params.minConfidence !== void 0 ? { isConfident: answer.confidence >= params.minConfidence } : {},
         usage: response.usage
       };
     },
     async noul(params) {
+      validateThreshold(params.minProbability, "minProbability");
       const response = await client.systemOne({
         model: params.model,
         state: params.state,
@@ -5496,11 +5574,12 @@ function createDecision(client) {
       const answer = response.answers.decision;
       return {
         noul: answer.noul,
-        bool: answer.noul >= 0.5,
+        bool: answer.noul >= (params.minProbability ?? 0.5),
         usage: response.usage
       };
     },
     async score(params) {
+      validateThreshold(params.minConfidence, "minConfidence");
       const response = await client.systemOne({
         model: params.model,
         state: params.state,
@@ -5520,10 +5599,12 @@ function createDecision(client) {
         legend: answer.legend,
         probabilities: answer.probabilities,
         confidence: answer.confidence,
+        ...params.minConfidence !== void 0 ? { isConfident: answer.confidence >= params.minConfidence } : {},
         usage: response.usage
       };
     },
     async route(params) {
+      validateThreshold(params.minConfidence, "minConfidence");
       const response = await client.systemOne({
         model: params.model,
         state: params.state,
@@ -5540,10 +5621,12 @@ function createDecision(client) {
       const answer = response.answers.decision;
       return {
         route: answer.choice,
-        confidence: answer.confidence
+        confidence: answer.confidence,
+        ...params.minConfidence !== void 0 ? { isConfident: answer.confidence >= params.minConfidence } : {}
       };
     },
     async verify(params) {
+      validateThreshold(params.minProbability, "minProbability");
       const state = {
         claim: params.claim,
         evidence: params.evidence
@@ -5562,11 +5645,12 @@ function createDecision(client) {
       });
       const answer = response.answers.decision;
       return {
-        verified: answer.noul >= 0.5,
+        verified: answer.noul >= (params.minProbability ?? 0.5),
         probability: answer.noul
       };
     },
     async rank(params) {
+      validateThreshold(params.minConfidence, "minConfidence");
       const promises = params.candidates.map(async (candidate) => {
         const response = await client.systemOne({
           model: params.model,
@@ -5585,7 +5669,8 @@ function createDecision(client) {
         return {
           candidate: candidate.id,
           score: answer.score,
-          confidence: answer.confidence
+          confidence: answer.confidence,
+          ...params.minConfidence !== void 0 ? { isConfident: answer.confidence >= params.minConfidence } : {}
         };
       });
       const results = await Promise.all(promises);
@@ -6196,8 +6281,8 @@ var OllamaClient = class _OllamaClient {
    */
   getContextLength = (request) => this.models.getContextLength(request);
   version = () => this.models.version();
-  createBlob = (digest, data) => this.models.createBlob(digest, data);
-  checkBlob = (digest) => this.models.checkBlob(digest);
+  createBlob = (digest, data, request) => this.models.createBlob(digest, data, request);
+  checkBlob = (digest, request) => this.models.checkBlob(digest, request);
   /**
    * Immediately unloads `model` from VRAM. Convenience alias for
    * {@link ModelsClient.unload} — see that method for the full
@@ -6717,6 +6802,64 @@ function toResponse(stream, init = {}) {
   return new Response(body, { ...init, headers });
 }
 
+// src/streaming/progress.ts
+function computeProgressPercent(chunk) {
+  if (typeof chunk.total !== "number" || typeof chunk.completed !== "number") return void 0;
+  if (chunk.total <= 0) return void 0;
+  const ratio = chunk.completed / chunk.total;
+  const clamped = Math.max(0, Math.min(1, ratio));
+  return Math.round(clamped * 1e4) / 100;
+}
+function toPullProgressEvent(chunk) {
+  return {
+    status: chunk.status,
+    ...chunk.digest !== void 0 ? { digest: chunk.digest } : {},
+    ...chunk.total !== void 0 ? { total: chunk.total } : {},
+    ...chunk.completed !== void 0 ? { completed: chunk.completed } : {},
+    percent: computeProgressPercent(chunk),
+    raw: chunk
+  };
+}
+function createProgressSpeedTracker() {
+  let epochDigest;
+  let epochStartMs = 0;
+  let epochStartCompleted = 0;
+  return (chunk) => {
+    if (typeof chunk.completed !== "number") return {};
+    const digestChanged = chunk.digest !== void 0 && chunk.digest !== epochDigest;
+    const regressed = chunk.completed < epochStartCompleted;
+    if (digestChanged || regressed) {
+      epochDigest = chunk.digest;
+      epochStartMs = performance.now();
+      epochStartCompleted = chunk.completed;
+      return {};
+    }
+    const elapsedSeconds = (performance.now() - epochStartMs) / 1e3;
+    if (elapsedSeconds <= 0) return {};
+    const transferred = chunk.completed - epochStartCompleted;
+    if (transferred <= 0) return {};
+    const bytesPerSecond = transferred / elapsedSeconds;
+    const etaSeconds = typeof chunk.total === "number" ? Math.max(0, (chunk.total - chunk.completed) / bytesPerSecond) : void 0;
+    return { bytesPerSecond, etaSeconds };
+  };
+}
+async function onProgress(stream, callback) {
+  void stream.finalResult.catch(() => void 0);
+  const speed = createProgressSpeedTracker();
+  for await (const event of stream) {
+    if (event.type === "message") {
+      callback({ ...toPullProgressEvent(event.data.chunk), ...speed(event.data.chunk) });
+    }
+    if (event.type === "done") {
+      return event.data.result;
+    }
+    if (event.type === "error") {
+      throw event.data.error;
+    }
+  }
+  throw new OllamaStreamError("Pull/push stream ended before reporting success");
+}
+
 // src/streaming/observe.ts
 async function* observeStream(source, callbacks = {}) {
   const { onChunk, onError, onDone, onAbandon, onListenerError } = callbacks;
@@ -8220,11 +8363,13 @@ exports.checkGenerateContext = checkGenerateContext;
 exports.compactConversationHistory = compactConversationHistory;
 exports.compareDraftPerformance = compareDraftPerformance;
 exports.composeMiddleware = composeMiddleware;
+exports.computeProgressPercent = computeProgressPercent;
 exports.contextWarningMessage = contextWarningMessage;
 exports.createConsoleLogger = createConsoleLogger;
 exports.createDecision = createDecision;
 exports.createModelAffinityScheduler = createModelAffinityScheduler;
 exports.createOllamaCloudFreeTierQuota = createOllamaCloudFreeTierQuota;
+exports.createProgressSpeedTracker = createProgressSpeedTracker;
 exports.createTimeoutSignal = createTimeoutSignal;
 exports.createWebFetchTool = createWebFetchTool;
 exports.createWebSearchTool = createWebSearchTool;
@@ -8266,6 +8411,7 @@ exports.normalizeGenerateStream = normalizeGenerateStream;
 exports.normalizeKeepAlive = normalizeKeepAlive;
 exports.normalizeProgressStream = normalizeProgressStream;
 exports.observeStream = observeStream;
+exports.onProgress = onProgress;
 exports.parseFrontmatter = parseFrontmatter;
 exports.parseNdjsonStream = parseNdjsonStream;
 exports.parseSseStream = parseSseStream;
@@ -8278,6 +8424,7 @@ exports.resolveImageInput = resolveImageInput;
 exports.sanitizeHistoryForNextTurn = sanitizeHistoryForNextTurn;
 exports.setSpanError = setSpanError;
 exports.toDataStream = toDataStream;
+exports.toPullProgressEvent = toPullProgressEvent;
 exports.toResponse = toResponse;
 exports.toTextStream = toTextStream;
 exports.withRetry = withRetry;