@nemesis-oss/ollama-sdk 1.13.0 → 1.14.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [1.14.0] — Speculative-decoding model assembly & the public testing subpath: `draftGguf`, `draft_num_predict` docs, `@nemesis-oss/ollama-sdk/testing`
+
+The October 12 digest ("Speculative Decoding & Draft Model Creation") reviewed the official model-creation surfaces — `draft_files` + `draft_quantize` on `POST /api/create`, the `draft_num_predict` Modelfile parameter and runtime option — and asked for an exportable zero-network mock server. Audited against the codebase first (see [ADR 0029](./docs/adr/0029-public-testing-subpath-speculative-draft-conveniences.md)): the digest's headline typing claims were stale — `draft_files`/`draft_quantize` already shipped on both the generated `CreateRequest` and the hand-written `CreateRequestOptions` (official OpenAPI, 2026-10-07 pin), and `draft_num_predict` was already typed + documented on the runtime `ModelOptions`; the "DRAFT `<model>`" Modelfile instruction the digest describes is not in the current official docs (only the parameter is). The real gaps — a path-based draft upload convenience, wire tests, discoverable documentation, and the not-exported mock server — are closed here. All additive, no breaking changes. 932 pre-existing tests stay green, 28 new tests added.
+
+### Speculative model assembly (`createModelFromGguf` → `draftGguf`)
+
+- **`CreateModelFromGgufOptions.draftGguf`**: pass the draft network's GGUF path(s) alongside the primary shards — each is uploaded as a blob and assembled into `draft_files` under its basename, the same protocol as primary shards. Split draft GGUFs, explicit `draft_files` digest maps (merged; path uploads win on basename collision), and `draft_quantize` passthrough all work; no draft → no `draft_files` key on the wire at all.
+- **Discoverable speculative-decoding docs**: `CreateRequestOptions.parameters` now documents `draft_num_predict` (separate draft models default to 4; `0` disables drafting; embedded MTP tensors require setting it explicitly — official Modelfile reference), and `draft_files`/`draft_quantize` carry the speculative-decoding context with the verification-semantics note that makes aggressive draft compression safe.
+- Wire tests pin the whole contract: `createModel` round-trips `draft_files` + `draft_quantize` + `parameters.draft_num_predict`; `createModelFromGguf` uploads draft blobs separately (HEAD + POST per shard) and never leaks `draftGguf` or empty maps into the request body.
+
+### Public testing subpath (`@nemesis-oss/ollama-sdk/testing`)
+
+- The SDK's internal mock engine is **promoted, not forked** (ADR 0029, same discipline as ADRs 0027/0028): `test/mocks/ollama-mock-server.ts` is now a re-export shim, so the SDK's own suite exercises exactly the code consumers import.
+- **`createMockOllamaServer(options?)`** — the recommended factory. Built-in **default routes** answer the official liveness probe (`HEAD /` → 200, `GET /` → the plain-text body "Ollama is running" byte-for-byte) and `GET /api/version` (configurable version, default `0.14.0`), so `client.ping()` works against a fresh mock with zero setup. `defaultRoutes: false` restores bare 404s; `register()` always wins over the defaults.
+- **Request recording** — `server.requests` captures every request (method, path, parsed body, timestamp), including default-route hits and 404s; `clearRequests()` for `beforeEach` hooks. Wire-level assertions without per-route callbacks.
+- **In-band mid-stream error injection** — `injectErrorFrame: { message, after? }` emits an `{"error": "..."}` NDJSON frame while HTTP stays 200, exactly how a real daemon reports GPU OOM/driver crashes mid-generation. The default injection point is `chunks.length - 1`: every content chunk, then the error frame, with the final `done` frame never emitted — an error frame after `done` would be unread (the stream has already completed cleanly). `after: 0` errors before any content; explicit larger values move the position. The SDK's stream readers raise `OllamaStreamError` with the partial content.
+- **`rawBody`** route option for exact non-NDJSON bodies (the liveness body uses it — no trailing newline).
+- **Chunk builders** producing correctly-shaped `/api/chat` frames: `mockChatChunk` (one frame, counter defaults on the done frame for telemetry paths), `mockTextChunks` (chunked text + done frame), and `mockToolCallChunks` — parallel tool calls in one frame, the documented native shape, followed by the done frame.
+- **Packaging**: dedicated `./testing` entry in the exports map (paired `.d.ts`/`.d.cts`), a new tsup entry, and the consumer-type verification now compiles a real CJS (node16) **and** ESM (nodenext) consumer importing the subpath. Node.js-only by design (`node:http`) — never imported from the Edge-safe main entry, so `verify:edge-runtime` stays clean.
+
+### Lab
+
+- `lab/15-speculative-draft/measure-draft-speedup.ts`: live harness comparing `draft_num_predict` 0/4/8/16 — warm-up per setting, 5 samples each, median `tokensPerSecond` via `formatTelemetry`, and a speedup table against drafting-disabled. Makes "the server has no draft network, the option is being ignored" obvious at a glance.
+
 ## [1.13.0] — docs.ollama.com re-audit: parity verifier reads checkbox state, strict compat types, web-search agent tools
 
 A full re-read of docs.ollama.com (API reference, capability guides, integrations, OpenAPI spec) against the SDK. The native API was already at parity except for two upstream changes; the real defect was in the compatibility-parity tooling, which had been reporting fields Ollama documents as unsupported as "supported".

package/README.md

@@ -33,7 +33,8 @@ Nexum’s model harness (2026-10-09) exercised this SDK via `gemma4:cloud` and `
 - 🌉 **OpenAI & Anthropic Compatibility Bridges**: Built-in clients for `/v1/chat/completions`, `/v1/responses`, `/v1/models`, and `/v1/messages`, including `reasoning_effort`/`reasoning.effort` for thinking models — plus an ergonomic dual-mode `client.responses.create()` bridge that prefers native `/v1/responses` and transparently re-issues via `/api/chat` on older servers (pre-v0.13.3).
 - 💬 **KV-Cache-Aware Conversation Sessions**: `client.session(model, systemPrompt)` keeps an append-only, prefix-stable history that maximizes Ollama's KV-cache reuse across turns, surfaces per-turn + cumulative cache hit rates (`prompt_eval_cached_count`) so cache degradation is visible instead of silent, and offers a one-call `compact()` sliding-window escape hatch when a session outgrows its window.
 - 🛑 **Context-Window Safety**: Heuristic client-side token estimation warns (or throws, `onContextOverflow: 'throw'`) before a request is sent when the prompt approaches the effective `num_ctx` window — Ollama's default behavior is to _silently truncate_ oversized prompts — and `defaultContextLength` makes the window explicit on every request.
-- 📦 **Blob & Custom Model Publishing**: Content-addressed blob management per Ollama's documented protocol — `computeBlobDigest()` (SHA-256 → `sha256:<hex>`), `createBlobFromData()`/`createBlobFromFile()` (HEAD-check + upload, skipping existing blobs), and one-shot `createModelFromGguf()` (upload GGUF shard blobs, then `/api/create` with `files: {name: digest}`).
+- 📦 **Blob & Custom Model Publishing**: Content-addressed blob management per Ollama's documented protocol — `computeBlobDigest()` (SHA-256 → `sha256:<hex>`), `createBlobFromData()`/`createBlobFromFile()` (HEAD-check + upload, skipping existing blobs), and one-shot `createModelFromGguf()` (upload GGUF shard blobs, then `/api/create` with `files: {name: digest}`) — with **speculative-decoding assembly**: `draftGguf` uploads the draft network's shards into `draft_files`, `draft_quantize` compresses them independently, and `parameters.draft_num_predict` tunes the per-step draft length.
+- 🧪 **In-Memory Mock Server (`@nemesis-oss/ollama-sdk/testing`)**: The SDK's own deterministic test double, promoted public — `createMockOllamaServer()` with scriptable NDJSON routes, built-in liveness/version defaults (so `ping()` works out of the box), request recording for wire-level assertions, mid-stream **in-band error injection** (`{"error": "..."}` frames at HTTP 200, exactly how a real daemon reports GPU OOM), connection drops, and correctly-shaped chunk builders for streaming text and **parallel tool calls** — zero network, zero daemon, CI-deterministic.
 - 🧵 **Batched Embeddings with Backpressure**: `client.embedBatch()` splits corpora of any size into bounded `/api/embed` batches (default 32 inputs × 3 in flight) — order-preserving, fail-fast, progress-reporting — so RAG/vector ingestion can't OOM a local daemon or saturate `OLLAMA_MAX_QUEUE` the way `Promise.all` floods do, with per-string context-window pre-flight against silent truncation.
 - 🧹 **Client Teardown (`destroy()`)**: One call aborts every in-flight request, active stream, and queued capacity waiter with `OllamaAbortError` — the clean-exit path for `worker_threads`, CLI runners, and short-lived scripts where dangling fetch bodies keep the event loop alive.
 - 🧠 **Dynamic Context-Window Discovery**: `client.models.getContextLength({ model })` resolves the real window from the server — the allocated window of the running instance (`/api/ps`), the Modelfile `num_ctx` default, and the native GGUF maximum (`model_info`), in precedence order — so applications stop hardcoding 2048/4096 guesses.
@@ -497,6 +498,45 @@ await client.models.createModelFromGguf('my-model', [
 ]);
 ```
 
+### Speculative Decoding (Draft Models)
+
+Ollama packages speculative decoding as a small **draft network** whose token
+guesses are batch-verified against the primary weights in a single forward
+pass — the draft runs ahead, the primary model confirms. On the wire this is
+`draft_files` (draft GGUF digests) + `draft_quantize` on `/api/create`, the
+`draft_num_predict` Modelfile parameter, and the `draft_num_predict` runtime
+option at generation time. The SDK covers the full flow:
+
+```typescript
+// 1. Assemble: primary + draft shards, draft weights quantized independently
+//    (draft tokens are verified, never returned — aggressive compression is
+//    usually safe). Separate draft models default draft_num_predict to 4;
+//    0 disables drafting; models with embedded MTP tensors require setting
+//    it explicitly.
+await client.models.createModelFromGguf('my-model', '/models/model.gguf', {
+  draftGguf: '/models/draft.gguf',
+  draftQuantize: 'q8_0',
+  parameters: { draft_num_predict: 8 },
+});
+
+// 2. Generate with drafting (also available ad hoc via options at runtime)
+const response = await client.chat({
+  model: 'my-model',
+  messages: [{ role: 'user', content: 'Describe a lighthouse in a storm.' }],
+  options: { draft_num_predict: 8 },
+});
+
+// 3. Measure the speedup with the standardized telemetry
+const t = formatTelemetry(response);
+console.log(`${t.tokensPerSecond} tok/s (load ${t.modelLoadMs}ms)`);
+```
+
+Already have the draft blobs uploaded? Pass the digest map directly —
+`createModel({ draft_files: { 'draft.gguf': digest } })` — or merge both
+(path uploads win on basename collision). A live measurement harness
+comparing `draft_num_predict` settings lives at
+`lab/15-speculative-draft/measure-draft-speedup.ts`.
+
 ### Token Log Probabilities (`logprobs`)
 
 Set `logprobs: true` (optionally with `top_logprobs`) on `chat()`/`generate()` to get per-token log probabilities back — useful for confidence scoring, speculative decoding, or agent routing decisions.
@@ -955,9 +995,19 @@ rejects `x-api-key`-only auth; the SDK always sends the bearer header plus
 `anthropic-version: 2023-06-01`):
 
 ```typescript
-const cloud = new OllamaClient({ baseUrl: 'https://ollama.com', apiKey: process.env.OLLAMA_API_KEY });
-await cloud.openai.chatCompletions({ model: 'gemma4:31b', messages: [{ role: 'user', content: 'Hi' }] });
-await cloud.anthropic.messages({ model: 'gemma4:31b', max_tokens: 1024, messages: [{ role: 'user', content: 'Hi' }] });
+const cloud = new OllamaClient({
+  baseUrl: 'https://ollama.com',
+  apiKey: process.env.OLLAMA_API_KEY,
+});
+await cloud.openai.chatCompletions({
+  model: 'gemma4:31b',
+  messages: [{ role: 'user', content: 'Hi' }],
+});
+await cloud.anthropic.messages({
+  model: 'gemma4:31b',
+  max_tokens: 1024,
+  messages: [{ role: 'user', content: 'Hi' }],
+});
 ```
 
 The cloud API does not support stateful Responses, built-in web search through
@@ -1454,6 +1504,62 @@ windows: [...] })` directly with your own `windowMs`/`maxTokens`/`maxRequests` p
 
 ---
 
+### Testing with the In-Memory Mock Server (`/testing`)
+
+The SDK ships its own deterministic test double as a dedicated subpath —
+`@nemesis-oss/ollama-sdk/testing` — the same engine the SDK's own test suite
+runs against (ADR 0029: promote, don't fork). No daemon, no network, no GPU:
+scriptable NDJSON routes on a real `node:http` server, built-in defaults for
+the official liveness probe and `/api/version`, wire-level request recording,
+and failure injection that covers what static cassettes can't.
+
+```typescript
+import {
+  createMockOllamaServer,
+  mockTextChunks,
+  mockToolCallChunks,
+} from '@nemesis-oss/ollama-sdk/testing';
+import { OllamaClient } from '@nemesis-oss/ollama-sdk';
+
+const server = createMockOllamaServer(); // ephemeral port, defaults on
+await server.start();
+const client = new OllamaClient({ baseUrl: server.baseUrl });
+
+// Defaults answer out of the box: HEAD / (ping) and GET /api/version.
+// Register everything else — register() always wins over the defaults.
+server.register('/api/chat', {
+  chunks: mockToolCallChunks([
+    // Parallel tool calls: one frame, complete calls — the native shape.
+    { name: 'get_weather', arguments: { city: 'Tokyo' } },
+    { name: 'get_time', arguments: { tz: 'Asia/Tokyo' } },
+  ]),
+  chunkDelayMs: 10, // inter-chunk backpressure testing
+});
+
+// Mid-stream failure, GPU-OOM style: HTTP stays 200, the done frame is
+// replaced by an {"error": "..."} frame — the SDK raises OllamaStreamError.
+server.register('/api/generate', {
+  chunks: mockTextChunks('partial answer', { chunkSize: 8 }),
+  injectErrorFrame: { message: 'CUDA out of memory' }, // after: N to move it
+});
+
+// ... run your code against the client ...
+
+// Wire-level assertions: every request was recorded.
+expect(server.requests[0]?.body).toMatchObject({ model: 'llama3.2' });
+server.clearRequests(); // and server.clear() between tests
+
+await server.stop(); // idempotent — safe in afterEach
+```
+
+Per-route controls: `status` (503/502/429 bodies), `chunkDelayMs`,
+`dropConnectionMidStream` (connection reset mid-response), `onRequest`
+(per-route body capture), and `injectErrorFrame.after` (error position).
+Chunk builders: `mockChatChunk` (one frame with counter defaults),
+`mockTextChunks` (chunked text + done frame), `mockToolCallChunks` (parallel
+tool calls + done frame). Node.js only — the subpath builds on `node:http`
+and is never imported from the Edge-safe main entry.
+
 ### Edge Runtime Compatibility
 
 The core client (`OllamaClient`, `Agent`, `ToolRegistry`, and everything exported from

package/dist/{anthropic-B9AFyzXI.d.ts → anthropic-DrDUfbfQ.d.ts}

@@ -1,4 +1,4 @@
-import { O as OllamaRuntime, H as HttpClient, A as AbortableAsyncIterable, af as SseEvent, y as OllamaClientError } from './runtime-CIQYCRL3.js';
+import { O as OllamaRuntime, H as HttpClient, A as AbortableAsyncIterable, af as SseEvent, y as OllamaClientError } from './runtime-BIjr5ME4.js';
 
 /**
  * AUTO-GENERATED by `npm run contract:generate`. DO NOT EDIT.

package/dist/{anthropic-CYy_ECam.d.cts → anthropic-UeaVjLeP.d.cts}

@@ -1,4 +1,4 @@
-import { O as OllamaRuntime, H as HttpClient, A as AbortableAsyncIterable, af as SseEvent, y as OllamaClientError } from './runtime-DmI1cOEq.cjs';
+import { O as OllamaRuntime, H as HttpClient, A as AbortableAsyncIterable, af as SseEvent, y as OllamaClientError } from './runtime-C4RRHqOs.cjs';
 
 /**
  * AUTO-GENERATED by `npm run contract:generate`. DO NOT EDIT.

package/dist/{compose-6UOPEknN.d.ts → compose-CeFbHJeO.d.ts}

@@ -1,4 +1,4 @@
-import { l as ToolDefinition, i as ToolCall, n as Message } from './types-B57ZZfp3.js';
+import { l as ToolDefinition, i as ToolCall, n as Message } from './types-DbPnfVh-.js';
 import { z } from 'zod';
 
 /**

package/dist/{compose-DhvoUrWa.d.cts → compose-DFkmtUOP.d.cts}

@@ -1,4 +1,4 @@
-import { l as ToolDefinition, i as ToolCall, n as Message } from './types-B57ZZfp3.cjs';
+import { l as ToolDefinition, i as ToolCall, n as Message } from './types-DbPnfVh-.cjs';
 import { z } from 'zod';
 
 /**

package/dist/generated-api.d.cts

@@ -1,8 +1,8 @@
-import { O as OpenAIChatCompletionRequest, a as OpenAIChatCompletionResponse, b as OpenAIChatCompletionChunk, c as OpenAICompletionRequest, d as OpenAICompletionResponse, e as OpenAICompletionChunk, f as OpenAIEmbeddingRequest, g as OpenAIEmbeddingResponse, h as OpenAIListModelsResponse, i as OpenAIModelItem, j as OpenAIResponsesRequest, k as OpenAIResponsesResponse, l as OpenAIResponsesStreamEvent, A as AnthropicMessagesRequest, m as AnthropicMessagesResponse, n as AnthropicMessageStreamEvent } from './anthropic-CYy_ECam.cjs';
-export { N as NativeApi } from './anthropic-CYy_ECam.cjs';
-import { O as OllamaRuntime } from './runtime-DmI1cOEq.cjs';
-export { a as OperationDefinition } from './runtime-DmI1cOEq.cjs';
-import './types-B57ZZfp3.cjs';
+import { O as OpenAIChatCompletionRequest, a as OpenAIChatCompletionResponse, b as OpenAIChatCompletionChunk, c as OpenAICompletionRequest, d as OpenAICompletionResponse, e as OpenAICompletionChunk, f as OpenAIEmbeddingRequest, g as OpenAIEmbeddingResponse, h as OpenAIListModelsResponse, i as OpenAIModelItem, j as OpenAIResponsesRequest, k as OpenAIResponsesResponse, l as OpenAIResponsesStreamEvent, A as AnthropicMessagesRequest, m as AnthropicMessagesResponse, n as AnthropicMessageStreamEvent } from './anthropic-UeaVjLeP.cjs';
+export { N as NativeApi } from './anthropic-UeaVjLeP.cjs';
+import { O as OllamaRuntime } from './runtime-C4RRHqOs.cjs';
+export { a as OperationDefinition } from './runtime-C4RRHqOs.cjs';
+import './types-DbPnfVh-.cjs';
 import 'zod';
 
 /**

package/dist/generated-api.d.ts

@@ -1,8 +1,8 @@
-import { O as OpenAIChatCompletionRequest, a as OpenAIChatCompletionResponse, b as OpenAIChatCompletionChunk, c as OpenAICompletionRequest, d as OpenAICompletionResponse, e as OpenAICompletionChunk, f as OpenAIEmbeddingRequest, g as OpenAIEmbeddingResponse, h as OpenAIListModelsResponse, i as OpenAIModelItem, j as OpenAIResponsesRequest, k as OpenAIResponsesResponse, l as OpenAIResponsesStreamEvent, A as AnthropicMessagesRequest, m as AnthropicMessagesResponse, n as AnthropicMessageStreamEvent } from './anthropic-B9AFyzXI.js';
-export { N as NativeApi } from './anthropic-B9AFyzXI.js';
-import { O as OllamaRuntime } from './runtime-CIQYCRL3.js';
-export { a as OperationDefinition } from './runtime-CIQYCRL3.js';
-import './types-B57ZZfp3.js';
+import { O as OpenAIChatCompletionRequest, a as OpenAIChatCompletionResponse, b as OpenAIChatCompletionChunk, c as OpenAICompletionRequest, d as OpenAICompletionResponse, e as OpenAICompletionChunk, f as OpenAIEmbeddingRequest, g as OpenAIEmbeddingResponse, h as OpenAIListModelsResponse, i as OpenAIModelItem, j as OpenAIResponsesRequest, k as OpenAIResponsesResponse, l as OpenAIResponsesStreamEvent, A as AnthropicMessagesRequest, m as AnthropicMessagesResponse, n as AnthropicMessageStreamEvent } from './anthropic-DrDUfbfQ.js';
+export { N as NativeApi } from './anthropic-DrDUfbfQ.js';
+import { O as OllamaRuntime } from './runtime-BIjr5ME4.js';
+export { a as OperationDefinition } from './runtime-BIjr5ME4.js';
+import './types-DbPnfVh-.js';
 import 'zod';
 
 /**

package/dist/generated-runtime.d.cts

@@ -1,6 +1,6 @@
-export { I as InvokeRequest, O as OllamaRuntime, b as OllamaRuntimeOptions, a as OperationDefinition, S as SchemaRef } from './runtime-DmI1cOEq.cjs';
+export { I as InvokeRequest, O as OllamaRuntime, b as OllamaRuntimeOptions, a as OperationDefinition, S as SchemaRef } from './runtime-C4RRHqOs.cjs';
 import { z } from 'zod';
-import './types-B57ZZfp3.cjs';
+import './types-DbPnfVh-.cjs';
 
 /**
  * AUTO-GENERATED by `npm run contract:generate`. DO NOT EDIT.

package/dist/generated-runtime.d.ts

@@ -1,6 +1,6 @@
-export { I as InvokeRequest, O as OllamaRuntime, b as OllamaRuntimeOptions, a as OperationDefinition, S as SchemaRef } from './runtime-CIQYCRL3.js';
+export { I as InvokeRequest, O as OllamaRuntime, b as OllamaRuntimeOptions, a as OperationDefinition, S as SchemaRef } from './runtime-BIjr5ME4.js';
 import { z } from 'zod';
-import './types-B57ZZfp3.js';
+import './types-DbPnfVh-.js';
 
 /**
  * AUTO-GENERATED by `npm run contract:generate`. DO NOT EDIT.

package/dist/index.cjs

@@ -2817,12 +2817,29 @@ var ModelsClient = class {
    * await client.models.createModelFromGguf('my-model', '/path/to/model.gguf', {
    *   template: '{{ .Prompt }}',
    * });
+   *
+   * // Speculative decoding: primary + draft shards + tuning:
+   * await client.models.createModelFromGguf('my-model', '/path/to/model.gguf', {
+   *   draftGguf: '/path/to/draft.gguf',
+   *   draftQuantize: 'q8_0',
+   *   parameters: { draft_num_predict: 8 },
+   * });
    * ```
    *
+   * Speculative-decoding models assemble the same way: pass the draft
+   * network's GGUF(s) as `draftGguf` (uploaded into `draft_files`), optionally
+   * set `draft_quantize` to compress the draft weights independently of the
+   * primary model, and set `parameters.draft_num_predict` to tune how many
+   * tokens the draft network predicts per step (Ollama defaults separate
+   * draft models to 4; `0` disables drafting; models with embedded MTP
+   * tensors require setting it explicitly).
+   *
    * @param model Name for the new model (e.g. `'my-model:latest'`).
    * @param gguf Path(s) to GGUF file(s) on the local filesystem.
    * @param opts Everything else `/api/create` accepts (`template`, `system`,
-   *   `parameters`, `license`, `quantize`, …) except `files` and `from`.
+   *   `parameters`, `license`, `quantize`, `draftGguf`, …) except `files`,
+   *   `draft_files` (use `draftGguf` for path-based drafts; an explicit digest
+   *   map is still accepted and merged), `from`, and `stream`.
    */
   async createModelFromGguf(model, gguf, opts) {
     const paths = typeof gguf === "string" ? [gguf] : gguf;
@@ -2836,14 +2853,29 @@ var ModelsClient = class {
       const uploaded = await this.createBlobFromFile(path, { signal: opts?.signal });
       files[uploaded.fileName] = uploaded.digest;
     }
+    const draftOpt = opts?.draftGguf;
+    const draftPaths = typeof draftOpt === "string" ? [draftOpt] : draftOpt ?? [];
     const {
       model: _model,
       files: _files,
       from: _from,
       stream: _stream,
+      draftGguf: _draftGguf,
+      draft_files: _draftFiles,
       ...rest
     } = opts ?? {};
-    return this.create({ ...rest, model, files, stream: false });
+    const draftFiles = { ..._draftFiles ?? {} };
+    for (const path of draftPaths) {
+      const uploaded = await this.createBlobFromFile(path, { signal: opts?.signal });
+      draftFiles[uploaded.fileName] = uploaded.digest;
+    }
+    return this.create({
+      ...rest,
+      model,
+      files,
+      ...Object.keys(draftFiles).length > 0 ? { draft_files: draftFiles } : {},
+      stream: false
+    });
   }
 };