@warlock.js/ai-deepseek 5.29.0 → 5.31.0

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to `@warlock.js/ai-deepseek` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.31.0 - 2026-10-18
+
+### Added
+
+- An adapter contract test verifies that aborting `signal` rejects `complete()` and `stream()` on the model and cancels the HTTP request.
+
+### Changed
+
+- Chat calls inherit `providerOptions.openai.body` from the OpenAI adapter, including its protected fields and one-level plain-object merge. Use only this provider's accepted fields when sharing fallback options. Native `countTokens` remains absent; `sdk.count(text)` is an offline estimate.
+
+### Fixed
+
+- `DEEPSEEK_DEFAULT_PRICING` (now exported) matches DeepSeek's price list (2026-10-17) for `deepseek-flash`, `deepseek-v4-flash` and `deepseek-v4-pro`. DeepSeek bills by time of day; the defaults are the peak rates, an upper bound, and `DEEPSEEK_OFF_PEAK_PRICING` holds the off-peak rates.
+
+### Upgrading
+
+- **BREAKING** `deepseek-chat` and `deepseek-reasoner` (discontinued by DeepSeek) no longer have built-in prices, so a USD budget on them rejects the run as unpriced. Reported costs for the remaining models rise to the peak rates; pass `pricing: DEEPSEEK_OFF_PEAK_PRICING` when you run off-peak.
+
+## 5.30.0 - 2026-10-16
+
+### Changed
+
+- Lockstep release; package APIs are unchanged.
+
 ## 5.29.0 - 2026-10-01
 
 ### Changed
@@ -75,6 +99,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### Changed
 
 - Lockstep release maintenance and dependency refresh.
+
 ## 5.20.0 - 2026-09-24
 
 ### Changed

package/README.md

@@ -51,12 +51,12 @@ DeepSeekModelConfig {
 
 ## Models
 
-| Model               | Notes                                                                 |
-| ------------------- | --------------------------------------------------------------------- |
-| `deepseek-chat`     | Non-thinking surface (V3 lineage). Fast, cheap. Reasoning **off**.    |
+| Model               | Notes                                                                       |
+| ------------------- | --------------------------------------------------------------------------- |
+| `deepseek-chat`     | Non-thinking surface (V3 lineage). Fast, cheap. Reasoning **off**.          |
 | `deepseek-reasoner` | Thinking surface (R1 lineage). Emits a reasoning channel. Reasoning **on**. |
-| `deepseek-v4-flash` | Newer flash tier. Reasoning **off** by default.                       |
-| `deepseek-v4-pro`   | Newer quality tier. Reasoning **on** by default.                      |
+| `deepseek-v4-flash` | Newer flash tier. Reasoning **off** by default.                             |
+| `deepseek-v4-pro`   | Newer quality tier. Reasoning **on** by default.                            |
 
 DeepSeek announced the legacy `deepseek-chat` / `deepseek-reasoner` names retire 2026/07/24 in favor of the `deepseek-v4-*` family; both name sets are understood by the capability inference. `deepseek.model({ name })` accepts any id the upstream serves. `DEEPSEEK_CHAT_MODELS` exports the informational list.
 
@@ -64,23 +64,23 @@ DeepSeek announced the legacy `deepseek-chat` / `deepseek-reasoner` names retire
 
 Capabilities are inferred from the DeepSeek model **name** (via `inferReasoningCapability` / `inferVisionCapability`) and injected as explicit flags before delegating — an explicit value always wins.
 
-| Capability         | Default                                                                                 |
-| ------------------ | --------------------------------------------------------------------------------------- |
-| `reasoning`        | `true` for `deepseek-reasoner` and the `*-pro` tier; `false` for `deepseek-chat` / `*-flash`. |
-| `vision`           | `false` for every DeepSeek model — no chat model documents image input (mid-2026).      |
+| Capability         | Default                                                                                        |
+| ------------------ | ---------------------------------------------------------------------------------------------- |
+| `reasoning`        | `true` for `deepseek-reasoner` and the `*-pro` tier; `false` for `deepseek-chat` / `*-flash`.  |
+| `vision`           | `false` for every DeepSeek model — no chat model documents image input (mid-2026).             |
 | `structuredOutput` | `true` (inherited from the wrapped OpenAI model), unless `responseFormat` forces a loose mode. |
-| `promptCaching`    | `true` (inherited). DeepSeek reports cache hits via `usage.cachedTokens`.                |
+| `promptCaching`    | `true` (inherited). DeepSeek reports cache hits via `usage.cachedTokens`.                      |
 
 ```ts
-deepseek.model({ name: "deepseek-chat", reasoning: true });     // force the thinking flag
+deepseek.model({ name: "deepseek-chat", reasoning: true }); // force the thinking flag
 deepseek.model({ name: "deepseek-reasoner", reasoning: false }); // suppress it
 ```
 
 ## Reasoning effort
 
 ```ts
-const model = deepseek.model({ name: "deepseek-reasoner" });        // reasoning auto-true
-await model.complete(messages, { reasoning: { effort: "high" } });  // → reasoning_effort: "high"
+const model = deepseek.model({ name: "deepseek-reasoner" }); // reasoning auto-true
+await model.complete(messages, { reasoning: { effort: "high" } }); // → reasoning_effort: "high"
 ```
 
 `reasoning.effort` maps to the OpenAI-compatible `reasoning_effort` param and is dropped for a non-reasoning model.

package/cjs/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 let _warlock_js_ai_openai = require("@warlock.js/ai-openai");
 
-//#region ../ai-deepseek/src/known-models.ts
+//#region ../../packages/ai-deepseek/src/known-models.ts
 /**
 * Capability inference for DeepSeek chat model ids.
 *
@@ -100,7 +100,7 @@ function inferVisionCapability(modelId) {
 }
 
 //#endregion
-//#region ../ai-deepseek/src/sdk.ts
+//#region ../../packages/ai-deepseek/src/sdk.ts
 /**
 * DeepSeek's OpenAI-compatible Chat Completions endpoint. Verified against
 * the official API docs (api-docs.deepseek.com, mid-2026).
@@ -110,31 +110,62 @@ const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
 const DEEPSEEK_PROVIDER = "deepseek";
 /**
 * Built-in DeepSeek pricing defaults, in USD per 1,000,000 tokens, keyed
-* by model name. Sourced from DeepSeek's official pricing table
-* (mid-2026); `cachedInput` is the cache-hit input rate. A caller-supplied
-* SDK `pricing` registry, or a per-model `pricing`, overrides any entry
-* here. Update when DeepSeek revises its published rates.
+* by model name; `cachedInput` is the cache-hit input rate.
+*
+* Source: https://api-docs.deepseek.com/quick_start/pricing, fetched
+* 2026-10-17. DeepSeek bills by time of day: peak hours (01:00–04:00 and
+* 06:00–10:00 UTC, Monday to Friday) cost twice the off-peak rate. A flat
+* `ModelPricing` cannot follow the clock, so these are the **peak** rates —
+* an upper bound that keeps USD budgets safe; off-peak calls really cost
+* half. Pass {@link DEEPSEEK_OFF_PEAK_PRICING} (or your own) as `pricing`
+* when you know you run off-peak.
+*
+* `deepseek-v4-flash` is the legacy name of `deepseek-flash` and bills at
+* the same rate. `deepseek-chat` / `deepseek-reasoner` are gone from the
+* price list (discontinued 2026-07-24) and stay unpriced.
+*
+* A caller-supplied SDK `pricing` registry, or a per-model `pricing`,
+* overrides any entry here.
 */
 const DEEPSEEK_DEFAULT_PRICING = {
-	"deepseek-chat": {
-		input: .14,
-		output: .28,
-		cachedInput: .0028
+	"deepseek-flash": {
+		input: .3,
+		output: 1.2,
+		cachedInput: .006
 	},
-	"deepseek-reasoner": {
-		input: .14,
-		output: .28,
-		cachedInput: .0028
+	"deepseek-v4-flash": {
+		input: .3,
+		output: 1.2,
+		cachedInput: .006
+	},
+	"deepseek-v4-pro": {
+		input: 1.32,
+		output: 3.96,
+		cachedInput: .044
+	}
+};
+/**
+* DeepSeek's off-peak rates (half the peak {@link DEEPSEEK_DEFAULT_PRICING}),
+* same source and date. Opt in per SDK:
+*
+* @example
+* new DeepSeekSDK({ apiKey, pricing: DEEPSEEK_OFF_PEAK_PRICING });
+*/
+const DEEPSEEK_OFF_PEAK_PRICING = {
+	"deepseek-flash": {
+		input: .15,
+		output: .6,
+		cachedInput: .003
 	},
 	"deepseek-v4-flash": {
-		input: .14,
-		output: .28,
-		cachedInput: .0028
+		input: .15,
+		output: .6,
+		cachedInput: .003
 	},
 	"deepseek-v4-pro": {
-		input: .435,
-		output: .87,
-		cachedInput: .003625
+		input: .66,
+		output: 1.98,
+		cachedInput: .022
 	}
 };
 /**
@@ -249,6 +280,8 @@ var DeepSeekSDK = class {
 
 //#endregion
 exports.DEEPSEEK_CHAT_MODELS = DEEPSEEK_CHAT_MODELS;
+exports.DEEPSEEK_DEFAULT_PRICING = DEEPSEEK_DEFAULT_PRICING;
+exports.DEEPSEEK_OFF_PEAK_PRICING = DEEPSEEK_OFF_PEAK_PRICING;
 exports.DeepSeekSDK = DeepSeekSDK;
 exports.inferReasoningCapability = inferReasoningCapability;
 exports.inferVisionCapability = inferVisionCapability;

package/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["OpenAISDK"],"sources":["../../../../../../ai-deepseek/src/known-models.ts","../../../../../../ai-deepseek/src/sdk.ts"],"sourcesContent":["/**\n * Capability inference for DeepSeek chat model ids.\n *\n * DeepSeek's API is OpenAI-compatible on the wire (`@warlock.js/ai-deepseek`\n * wraps {@link OpenAISDK}), but its model **names** are not OpenAI names —\n * so OpenAI's own prefix lists (`gpt-4o`, `o3`, …) never match them. This\n * module supplies DeepSeek's OWN name-based inference, which the\n * {@link DeepSeekSDK} injects as explicit capability booleans into the\n * wrapped `openai.model(...)` call (explicit config wins over OpenAI's\n * inference inside `OpenAIModel`).\n *\n * Verified against the official DeepSeek API docs (api-docs.deepseek.com,\n * mid-2026): base URL `https://api.deepseek.com`, OpenAI-compatible Chat\n * Completions. Two reasoning-capable surfaces exist — the legacy\n * `deepseek-reasoner` (thinking mode) and the `*-pro` tier — while\n * `deepseek-chat` is the non-thinking surface. No DeepSeek chat model\n * documents image (vision) input, so vision inference is conservatively\n * `false` for every id.\n */\n\n/**\n * Default DeepSeek chat model ids, surfaced for discovery and docs.\n *\n * - `deepseek-chat` — the non-thinking surface (V3 lineage). Fast, cheap,\n *   broad production coverage. Not reasoning-capable.\n * - `deepseek-reasoner` — the thinking surface (R1 lineage). Emits a\n *   reasoning channel and accepts the reasoning-effort knob.\n *\n * Both legacy names are scheduled for retirement (2026/07/24 per DeepSeek's\n * deprecation notice) in favor of the `deepseek-v4-*` family\n * (`deepseek-v4-flash`, `deepseek-v4-pro`), which this inference also\n * understands. The list is informational only — `deepseek.model({ name })`\n * accepts any id the upstream serves.\n */\nexport const DEEPSEEK_CHAT_MODELS = [\n  \"deepseek-chat\",\n  \"deepseek-reasoner\",\n  \"deepseek-v4-flash\",\n  \"deepseek-v4-pro\",\n] as const;\n\n/**\n * Substrings identifying DeepSeek model ids that expose a reasoning /\n * thinking channel and accept the reasoning-effort knob.\n *\n * - `deepseek-reasoner` — the dedicated thinking surface (R1 lineage).\n * - `-pro` — the V4 quality tier (`deepseek-v4-pro`), which thinks by\n *   default per DeepSeek's docs.\n *\n * `deepseek-chat` (the V3 non-thinking surface) and `deepseek-v4-flash`\n * stay `false`. A substring match tolerates date/preview suffixes the\n * provider may append. Override per-model via\n * `deepseek.model({ name, reasoning: true | false })`.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\"deepseek-reasoner\", \"-pro\"];\n\n/**\n * Infer whether a DeepSeek model id is reasoning-capable based on the\n * known substrings. Unknown ids default to `false` so the adapter never\n * forwards an unsupported reasoning param to a non-thinking model.\n *\n * @example\n * inferReasoningCapability(\"deepseek-reasoner\");  // → true\n * inferReasoningCapability(\"deepseek-v4-pro\");     // → true\n * inferReasoningCapability(\"deepseek-chat\");        // → false\n * inferReasoningCapability(\"deepseek-v4-flash\");    // → false\n */\nexport function inferReasoningCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Substrings identifying DeepSeek model ids that accept image (vision)\n * input.\n *\n * Currently **empty**: as of mid-2026, no DeepSeek chat model documents\n * vision input on the OpenAI-compatible Chat Completions endpoint, so\n * inference returns `false` for every id and passing an image attachment\n * surfaces a clear, agent-side capability error instead of an opaque 400.\n * Append a fragment here (and a paired spec case) the day DeepSeek ships a\n * multimodal chat model. Devs can always opt in per-model via\n * `deepseek.model({ name, vision: true })`.\n */\nconst VISION_CAPABLE_SUBSTRINGS: readonly string[] = [];\n\n/**\n * Infer whether a DeepSeek model id supports vision based on the known\n * substrings. Today this is always `false` (see\n * {@link VISION_CAPABLE_SUBSTRINGS}); kept as a function so the\n * {@link DeepSeekSDK} call site and the override semantics stay identical\n * to the other adapters, ready for a future multimodal id.\n *\n * @example\n * inferVisionCapability(\"deepseek-chat\");      // → false\n * inferVisionCapability(\"deepseek-reasoner\");  // → false\n */\nexport function inferVisionCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n","import type {\n  EmbedderContract,\n  ImageModelContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type {\n  DeepSeekEmbedderConfig,\n  DeepSeekImageConfig,\n  DeepSeekModelConfig,\n  DeepSeekSDKConfig,\n} from \"./config.type\";\nimport { inferReasoningCapability, inferVisionCapability } from \"./known-models\";\n\n/**\n * DeepSeek's OpenAI-compatible Chat Completions endpoint. Verified against\n * the official API docs (api-docs.deepseek.com, mid-2026).\n */\nconst DEEPSEEK_BASE_URL = \"https://api.deepseek.com\";\n\n/** Default upstream label for models produced by this SDK. */\nconst DEEPSEEK_PROVIDER = \"deepseek\";\n\n/**\n * Built-in DeepSeek pricing defaults, in USD per 1,000,000 tokens, keyed\n * by model name. Sourced from DeepSeek's official pricing table\n * (mid-2026); `cachedInput` is the cache-hit input rate. A caller-supplied\n * SDK `pricing` registry, or a per-model `pricing`, overrides any entry\n * here. Update when DeepSeek revises its published rates.\n */\nconst DEEPSEEK_DEFAULT_PRICING: Record<string, ModelPricing> = {\n  \"deepseek-chat\": { input: 0.14, output: 0.28, cachedInput: 0.0028 },\n  \"deepseek-reasoner\": { input: 0.14, output: 0.28, cachedInput: 0.0028 },\n  \"deepseek-v4-flash\": { input: 0.14, output: 0.28, cachedInput: 0.0028 },\n  \"deepseek-v4-pro\": { input: 0.435, output: 0.87, cachedInput: 0.003625 },\n};\n\n/**\n * DeepSeek-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for DeepSeek models. DeepSeek's API is\n * OpenAI-compatible on the wire, so rather than reimplementing the\n * battle-tested Chat Completions translation, this is a **thin wrapper**\n * over {@link OpenAISDK} from `@warlock.js/ai-openai`: it constructs one\n * internal `OpenAISDK` pinned to DeepSeek's `baseURL` and the `\"deepseek\"`\n * provider label, and delegates `model()` / `embedder()` / `image()` /\n * `count()` straight to it. Construct one `DeepSeekSDK` per account and\n * reuse it everywhere.\n *\n * **What the wrapper adds over a bare `OpenAISDK`.** DeepSeek's model\n * **names** are not OpenAI names, so OpenAI's own vision/reasoning prefix\n * lists never match them. This wrapper injects DeepSeek's OWN capability\n * inference (see `known-models.ts`) and built-in DeepSeek pricing defaults\n * as explicit values on every `model()` call — so `deepseek-reasoner` is\n * correctly flagged reasoning-capable and `deepseek-chat` is not, even\n * though neither matches an OpenAI prefix. An explicit `vision` /\n * `reasoning` / `pricing` you pass per model always wins over these\n * injected defaults.\n *\n * **Responsibility.**\n * - Owns: one long-lived internal `OpenAISDK` (auth, DeepSeek base URL)\n *   and DeepSeek's capability + pricing defaults.\n * - Does NOT own: the wire protocol, streaming loop, message/tool\n *   translation, or error wrapping — all inherited unchanged from\n *   `OpenAISDK` / `OpenAIModel`.\n *\n * @example\n * const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY! });\n * const chat = deepseek.model({ name: \"deepseek-chat\" });        // reasoning=false\n * const reasoner = deepseek.model({ name: \"deepseek-reasoner\" }); // reasoning=true\n *\n * @example\n * // Compose into an `ai.deepseek` namespace for ergonomic agent wiring\n * const ai = { agent, tool, deepseek: new DeepSeekSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.deepseek.model({ name: \"deepseek-reasoner\" }) });\n */\nexport class DeepSeekSDK implements SDKAdapterContract {\n  /** The wrapped OpenAI-compatible client, pinned to DeepSeek. */\n  private readonly openai: OpenAISDK;\n  private readonly provider: string;\n  private readonly pricing: Record<string, ModelPricing>;\n\n  public constructor(config: DeepSeekSDKConfig) {\n    const { provider, pricing, baseURL, ...clientOptions } = config;\n\n    this.provider = provider ?? DEEPSEEK_PROVIDER;\n    // Caller pricing overrides the built-in DeepSeek defaults entry-by-entry.\n    this.pricing = { ...DEEPSEEK_DEFAULT_PRICING, ...pricing };\n\n    // The internal OpenAISDK carries the DeepSeek base URL + provider label;\n    // pricing stays on THIS wrapper so it can be merged with the built-in\n    // defaults before each per-model resolution below.\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? DEEPSEEK_BASE_URL,\n      provider: this.provider,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` for a DeepSeek model. Delegates to the wrapped\n   * `OpenAISDK.model()`, but first injects this provider's defaults:\n   * - `vision` / `reasoning` inferred from DeepSeek's model-name lists\n   *   (`known-models.ts`) — so the right capabilities are set even though\n   *   the names aren't OpenAI names.\n   * - `pricing` resolved from the built-in DeepSeek table merged with any\n   *   caller-supplied SDK registry.\n   *\n   * An explicit `vision` / `reasoning` / `pricing` on `config` always wins\n   * over the injected default. Everything else (sampling, structured\n   * output, streaming, error wrapping) is inherited unchanged from\n   * `OpenAIModel`.\n   */\n  public model(config: DeepSeekModelConfig): ModelContract {\n    const resolved: DeepSeekModelConfig = {\n      ...config,\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      pricing: config.pricing ?? this.pricing[config.name],\n    };\n\n    return this.openai.model(resolved);\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegated to the wrapped\n   * `OpenAISDK.count()` (the core character-heuristic) — good for\n   * budgeting/quota guards, not billing.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an `EmbedderContract`. Delegated verbatim to\n   * `OpenAISDK.embedder()`.\n   *\n   * NOTE: DeepSeek does not officially document an OpenAI-compatible\n   * embeddings endpoint (mid-2026); this delegate works against a\n   * compatible gateway you point `baseURL` at, but may fail against the\n   * stock DeepSeek endpoint. Prefer a dedicated embeddings provider for\n   * RAG.\n   */\n  public embedder(config: DeepSeekEmbedderConfig): EmbedderContract {\n    return this.openai.embedder(config);\n  }\n\n  /**\n   * Build an `ImageModelContract`. Delegated verbatim to\n   * `OpenAISDK.image()`.\n   *\n   * NOTE: DeepSeek does not document an image-generation endpoint\n   * (mid-2026); provided for adapter parity. A non-image model id is\n   * rejected at construction by the wrapped OpenAI image model.\n   */\n  public image(config: DeepSeekImageConfig): ImageModelContract {\n    return this.openai.image(config);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,uBAAuB;CAClC;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,MAAM,+BAA+B,CAAC,qBAAqB,MAAM;;;;;;;;;;;;AAajE,SAAgB,yBAAyB,SAA0B;CACjE,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;;;;AAcA,MAAM,4BAA+C,CAAC;;;;;;;;;;;;AAatD,SAAgB,sBAAsB,SAA0B;CAC9D,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF;;;;;;;;AClFA,MAAM,oBAAoB;;AAG1B,MAAM,oBAAoB;;;;;;;;AAS1B,MAAM,2BAAyD;CAC7D,iBAAiB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAO;CAClE,qBAAqB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAO;CACtE,qBAAqB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAO;CACtE,mBAAmB;EAAE,OAAO;EAAO,QAAQ;EAAM,aAAa;CAAS;AACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,cAAb,MAAuD;CAMrD,AAAO,YAAY,QAA2B;EAC5C,MAAM,EAAE,UAAU,SAAS,SAAS,GAAG,kBAAkB;EAEzD,KAAK,WAAW,YAAY;EAE5B,KAAK,UAAU;GAAE,GAAG;GAA0B,GAAG;EAAQ;EAKzD,KAAK,SAAS,IAAIA,gCAAU;GAC1B,GAAG;GACH,SAAS,WAAW;GACpB,UAAU,KAAK;EACjB,CAAC;CACH;;;;;;;;;;;;;;;CAgBA,AAAO,MAAM,QAA4C;EACvD,MAAM,WAAgC;GACpC,GAAG;GACH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;GACnE,SAAS,OAAO,WAAW,KAAK,QAAQ,OAAO;EACjD;EAEA,OAAO,KAAK,OAAO,MAAM,QAAQ;CACnC;;;;;;CAOA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAAkD;EAChE,OAAO,KAAK,OAAO,SAAS,MAAM;CACpC;;;;;;;;;CAUA,AAAO,MAAM,QAAiD;EAC5D,OAAO,KAAK,OAAO,MAAM,MAAM;CACjC;AACF"}
+{"version":3,"file":"index.cjs","names":["OpenAISDK"],"sources":["../../../../../../../packages/ai-deepseek/src/known-models.ts","../../../../../../../packages/ai-deepseek/src/sdk.ts"],"sourcesContent":["/**\n * Capability inference for DeepSeek chat model ids.\n *\n * DeepSeek's API is OpenAI-compatible on the wire (`@warlock.js/ai-deepseek`\n * wraps {@link OpenAISDK}), but its model **names** are not OpenAI names —\n * so OpenAI's own prefix lists (`gpt-4o`, `o3`, …) never match them. This\n * module supplies DeepSeek's OWN name-based inference, which the\n * {@link DeepSeekSDK} injects as explicit capability booleans into the\n * wrapped `openai.model(...)` call (explicit config wins over OpenAI's\n * inference inside `OpenAIModel`).\n *\n * Verified against the official DeepSeek API docs (api-docs.deepseek.com,\n * mid-2026): base URL `https://api.deepseek.com`, OpenAI-compatible Chat\n * Completions. Two reasoning-capable surfaces exist — the legacy\n * `deepseek-reasoner` (thinking mode) and the `*-pro` tier — while\n * `deepseek-chat` is the non-thinking surface. No DeepSeek chat model\n * documents image (vision) input, so vision inference is conservatively\n * `false` for every id.\n */\n\n/**\n * Default DeepSeek chat model ids, surfaced for discovery and docs.\n *\n * - `deepseek-chat` — the non-thinking surface (V3 lineage). Fast, cheap,\n *   broad production coverage. Not reasoning-capable.\n * - `deepseek-reasoner` — the thinking surface (R1 lineage). Emits a\n *   reasoning channel and accepts the reasoning-effort knob.\n *\n * Both legacy names are scheduled for retirement (2026/07/24 per DeepSeek's\n * deprecation notice) in favor of the `deepseek-v4-*` family\n * (`deepseek-v4-flash`, `deepseek-v4-pro`), which this inference also\n * understands. The list is informational only — `deepseek.model({ name })`\n * accepts any id the upstream serves.\n */\nexport const DEEPSEEK_CHAT_MODELS = [\n  \"deepseek-chat\",\n  \"deepseek-reasoner\",\n  \"deepseek-v4-flash\",\n  \"deepseek-v4-pro\",\n] as const;\n\n/**\n * Substrings identifying DeepSeek model ids that expose a reasoning /\n * thinking channel and accept the reasoning-effort knob.\n *\n * - `deepseek-reasoner` — the dedicated thinking surface (R1 lineage).\n * - `-pro` — the V4 quality tier (`deepseek-v4-pro`), which thinks by\n *   default per DeepSeek's docs.\n *\n * `deepseek-chat` (the V3 non-thinking surface) and `deepseek-v4-flash`\n * stay `false`. A substring match tolerates date/preview suffixes the\n * provider may append. Override per-model via\n * `deepseek.model({ name, reasoning: true | false })`.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\"deepseek-reasoner\", \"-pro\"];\n\n/**\n * Infer whether a DeepSeek model id is reasoning-capable based on the\n * known substrings. Unknown ids default to `false` so the adapter never\n * forwards an unsupported reasoning param to a non-thinking model.\n *\n * @example\n * inferReasoningCapability(\"deepseek-reasoner\");  // → true\n * inferReasoningCapability(\"deepseek-v4-pro\");     // → true\n * inferReasoningCapability(\"deepseek-chat\");        // → false\n * inferReasoningCapability(\"deepseek-v4-flash\");    // → false\n */\nexport function inferReasoningCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Substrings identifying DeepSeek model ids that accept image (vision)\n * input.\n *\n * Currently **empty**: as of mid-2026, no DeepSeek chat model documents\n * vision input on the OpenAI-compatible Chat Completions endpoint, so\n * inference returns `false` for every id and passing an image attachment\n * surfaces a clear, agent-side capability error instead of an opaque 400.\n * Append a fragment here (and a paired spec case) the day DeepSeek ships a\n * multimodal chat model. Devs can always opt in per-model via\n * `deepseek.model({ name, vision: true })`.\n */\nconst VISION_CAPABLE_SUBSTRINGS: readonly string[] = [];\n\n/**\n * Infer whether a DeepSeek model id supports vision based on the known\n * substrings. Today this is always `false` (see\n * {@link VISION_CAPABLE_SUBSTRINGS}); kept as a function so the\n * {@link DeepSeekSDK} call site and the override semantics stay identical\n * to the other adapters, ready for a future multimodal id.\n *\n * @example\n * inferVisionCapability(\"deepseek-chat\");      // → false\n * inferVisionCapability(\"deepseek-reasoner\");  // → false\n */\nexport function inferVisionCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n","import type {\n  EmbedderContract,\n  ImageModelContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type {\n  DeepSeekEmbedderConfig,\n  DeepSeekImageConfig,\n  DeepSeekModelConfig,\n  DeepSeekSDKConfig,\n} from \"./config.type\";\nimport { inferReasoningCapability, inferVisionCapability } from \"./known-models\";\n\n/**\n * DeepSeek's OpenAI-compatible Chat Completions endpoint. Verified against\n * the official API docs (api-docs.deepseek.com, mid-2026).\n */\nconst DEEPSEEK_BASE_URL = \"https://api.deepseek.com\";\n\n/** Default upstream label for models produced by this SDK. */\nconst DEEPSEEK_PROVIDER = \"deepseek\";\n\n/**\n * Built-in DeepSeek pricing defaults, in USD per 1,000,000 tokens, keyed\n * by model name; `cachedInput` is the cache-hit input rate.\n *\n * Source: https://api-docs.deepseek.com/quick_start/pricing, fetched\n * 2026-10-17. DeepSeek bills by time of day: peak hours (01:00–04:00 and\n * 06:00–10:00 UTC, Monday to Friday) cost twice the off-peak rate. A flat\n * `ModelPricing` cannot follow the clock, so these are the **peak** rates —\n * an upper bound that keeps USD budgets safe; off-peak calls really cost\n * half. Pass {@link DEEPSEEK_OFF_PEAK_PRICING} (or your own) as `pricing`\n * when you know you run off-peak.\n *\n * `deepseek-v4-flash` is the legacy name of `deepseek-flash` and bills at\n * the same rate. `deepseek-chat` / `deepseek-reasoner` are gone from the\n * price list (discontinued 2026-07-24) and stay unpriced.\n *\n * A caller-supplied SDK `pricing` registry, or a per-model `pricing`,\n * overrides any entry here.\n */\nexport const DEEPSEEK_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"deepseek-flash\": { input: 0.3, output: 1.2, cachedInput: 0.006 },\n  \"deepseek-v4-flash\": { input: 0.3, output: 1.2, cachedInput: 0.006 },\n  \"deepseek-v4-pro\": { input: 1.32, output: 3.96, cachedInput: 0.044 },\n};\n\n/**\n * DeepSeek's off-peak rates (half the peak {@link DEEPSEEK_DEFAULT_PRICING}),\n * same source and date. Opt in per SDK:\n *\n * @example\n * new DeepSeekSDK({ apiKey, pricing: DEEPSEEK_OFF_PEAK_PRICING });\n */\nexport const DEEPSEEK_OFF_PEAK_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"deepseek-flash\": { input: 0.15, output: 0.6, cachedInput: 0.003 },\n  \"deepseek-v4-flash\": { input: 0.15, output: 0.6, cachedInput: 0.003 },\n  \"deepseek-v4-pro\": { input: 0.66, output: 1.98, cachedInput: 0.022 },\n};\n\n/**\n * DeepSeek-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for DeepSeek models. DeepSeek's API is\n * OpenAI-compatible on the wire, so rather than reimplementing the\n * battle-tested Chat Completions translation, this is a **thin wrapper**\n * over {@link OpenAISDK} from `@warlock.js/ai-openai`: it constructs one\n * internal `OpenAISDK` pinned to DeepSeek's `baseURL` and the `\"deepseek\"`\n * provider label, and delegates `model()` / `embedder()` / `image()` /\n * `count()` straight to it. Construct one `DeepSeekSDK` per account and\n * reuse it everywhere.\n *\n * **What the wrapper adds over a bare `OpenAISDK`.** DeepSeek's model\n * **names** are not OpenAI names, so OpenAI's own vision/reasoning prefix\n * lists never match them. This wrapper injects DeepSeek's OWN capability\n * inference (see `known-models.ts`) and built-in DeepSeek pricing defaults\n * as explicit values on every `model()` call — so `deepseek-reasoner` is\n * correctly flagged reasoning-capable and `deepseek-chat` is not, even\n * though neither matches an OpenAI prefix. An explicit `vision` /\n * `reasoning` / `pricing` you pass per model always wins over these\n * injected defaults.\n *\n * **Responsibility.**\n * - Owns: one long-lived internal `OpenAISDK` (auth, DeepSeek base URL)\n *   and DeepSeek's capability + pricing defaults.\n * - Does NOT own: the wire protocol, streaming loop, message/tool\n *   translation, or error wrapping — all inherited unchanged from\n *   `OpenAISDK` / `OpenAIModel`.\n *\n * @example\n * const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY! });\n * const chat = deepseek.model({ name: \"deepseek-chat\" });        // reasoning=false\n * const reasoner = deepseek.model({ name: \"deepseek-reasoner\" }); // reasoning=true\n *\n * @example\n * // Compose into an `ai.deepseek` namespace for ergonomic agent wiring\n * const ai = { agent, tool, deepseek: new DeepSeekSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.deepseek.model({ name: \"deepseek-reasoner\" }) });\n */\nexport class DeepSeekSDK implements SDKAdapterContract {\n  /** The wrapped OpenAI-compatible client, pinned to DeepSeek. */\n  private readonly openai: OpenAISDK;\n  private readonly provider: string;\n  private readonly pricing: Record<string, ModelPricing>;\n\n  public constructor(config: DeepSeekSDKConfig) {\n    const { provider, pricing, baseURL, ...clientOptions } = config;\n\n    this.provider = provider ?? DEEPSEEK_PROVIDER;\n    // Caller pricing overrides the built-in DeepSeek defaults entry-by-entry.\n    this.pricing = { ...DEEPSEEK_DEFAULT_PRICING, ...pricing };\n\n    // The internal OpenAISDK carries the DeepSeek base URL + provider label;\n    // pricing stays on THIS wrapper so it can be merged with the built-in\n    // defaults before each per-model resolution below.\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? DEEPSEEK_BASE_URL,\n      provider: this.provider,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` for a DeepSeek model. Delegates to the wrapped\n   * `OpenAISDK.model()`, but first injects this provider's defaults:\n   * - `vision` / `reasoning` inferred from DeepSeek's model-name lists\n   *   (`known-models.ts`) — so the right capabilities are set even though\n   *   the names aren't OpenAI names.\n   * - `pricing` resolved from the built-in DeepSeek table merged with any\n   *   caller-supplied SDK registry.\n   *\n   * An explicit `vision` / `reasoning` / `pricing` on `config` always wins\n   * over the injected default. Everything else (sampling, structured\n   * output, streaming, error wrapping) is inherited unchanged from\n   * `OpenAIModel`.\n   */\n  public model(config: DeepSeekModelConfig): ModelContract {\n    const resolved: DeepSeekModelConfig = {\n      ...config,\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      pricing: config.pricing ?? this.pricing[config.name],\n    };\n\n    return this.openai.model(resolved);\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegated to the wrapped\n   * `OpenAISDK.count()` (the core character-heuristic) — good for\n   * budgeting/quota guards, not billing.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an `EmbedderContract`. Delegated verbatim to\n   * `OpenAISDK.embedder()`.\n   *\n   * NOTE: DeepSeek does not officially document an OpenAI-compatible\n   * embeddings endpoint (mid-2026); this delegate works against a\n   * compatible gateway you point `baseURL` at, but may fail against the\n   * stock DeepSeek endpoint. Prefer a dedicated embeddings provider for\n   * RAG.\n   */\n  public embedder(config: DeepSeekEmbedderConfig): EmbedderContract {\n    return this.openai.embedder(config);\n  }\n\n  /**\n   * Build an `ImageModelContract`. Delegated verbatim to\n   * `OpenAISDK.image()`.\n   *\n   * NOTE: DeepSeek does not document an image-generation endpoint\n   * (mid-2026); provided for adapter parity. A non-image model id is\n   * rejected at construction by the wrapped OpenAI image model.\n   */\n  public image(config: DeepSeekImageConfig): ImageModelContract {\n    return this.openai.image(config);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,uBAAuB;CAClC;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,MAAM,+BAA+B,CAAC,qBAAqB,MAAM;;;;;;;;;;;;AAajE,SAAgB,yBAAyB,SAA0B;CACjE,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;;;;AAcA,MAAM,4BAA+C,CAAC;;;;;;;;;;;;AAatD,SAAgB,sBAAsB,SAA0B;CAC9D,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF;;;;;;;;AClFA,MAAM,oBAAoB;;AAG1B,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;AAqB1B,MAAa,2BAAmE;CAC9E,kBAAkB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAM;CAChE,qBAAqB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAM;CACnE,mBAAmB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAM;AACrE;;;;;;;;AASA,MAAa,4BAAoE;CAC/E,kBAAkB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACjE,qBAAqB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACpE,mBAAmB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAM;AACrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,cAAb,MAAuD;CAMrD,AAAO,YAAY,QAA2B;EAC5C,MAAM,EAAE,UAAU,SAAS,SAAS,GAAG,kBAAkB;EAEzD,KAAK,WAAW,YAAY;EAE5B,KAAK,UAAU;GAAE,GAAG;GAA0B,GAAG;EAAQ;EAKzD,KAAK,SAAS,IAAIA,gCAAU;GAC1B,GAAG;GACH,SAAS,WAAW;GACpB,UAAU,KAAK;EACjB,CAAC;CACH;;;;;;;;;;;;;;;CAgBA,AAAO,MAAM,QAA4C;EACvD,MAAM,WAAgC;GACpC,GAAG;GACH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;GACnE,SAAS,OAAO,WAAW,KAAK,QAAQ,OAAO;EACjD;EAEA,OAAO,KAAK,OAAO,MAAM,QAAQ;CACnC;;;;;;CAOA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAAkD;EAChE,OAAO,KAAK,OAAO,SAAS,MAAM;CACpC;;;;;;;;;CAUA,AAAO,MAAM,QAAiD;EAC5D,OAAO,KAAK,OAAO,MAAM,MAAM;CACjC;AACF"}

package/esm/config.type.d.mts

@@ -1,7 +1,7 @@
 import { OpenAISDKConfig } from "@warlock.js/ai-openai";
 import { EmbedderConfig, ImageModelConfig, ModelConfig } from "@warlock.js/ai";
 
-//#region ../ai-deepseek/src/config.type.d.ts
+//#region ../../packages/ai-deepseek/src/config.type.d.ts
 /**
  * Per-model `response_format` override forwarded to the wrapped OpenAI
  * model. Mirrors the OpenAI adapter's union (DeepSeek speaks the same

package/esm/config.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../ai-deepseek/src/config.type.ts"],"mappings":";;;;;;AAaA;;;;AAAkC;AAsClC;;;KAtCY,sBAAA;;;;;;AAiDF;AAoBV;;;;;;;;;;;;;AAsCO;AAcP;;;;AAAmD;AAWnD;;;;AAAkD;;;;;;;KA9FtC,iBAAA,GAAoB,IAAI,CAAC,eAAA;;;;;;EAMnC,OAAA;;;;;EAKA,QAAA;AAAA;;;;;;;;;;;;;;;;;;KAoBU,mBAAA,GAAsB,WAAA;;;;;;;EAOhC,MAAA;;;;;;;;EAQA,SAAA;;;;;;EAMA,gBAAA;;;;;;;EAOA,cAAA,GAAiB,sBAAsB;;;;;EAKvC,GAAA;;;;;EAKA,KAAA;AAAA;;;;;;;;;;;;KAcU,sBAAA,GAAyB,cAAc;;;;;;;;;;KAWvC,mBAAA,GAAsB,gBAAgB"}
+{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-deepseek/src/config.type.ts"],"mappings":";;;;;;AAaA;;;;AAAkC;AAsClC;;;KAtCY,sBAAA;;;;;;AAiDF;AAoBV;;;;;;;;;;;;;AAsCO;AAcP;;;;AAAmD;AAWnD;;;;AAAkD;;;;;;;KA9FtC,iBAAA,GAAoB,IAAI,CAAC,eAAA;;;;;;EAMnC,OAAA;;;;;EAKA,QAAA;AAAA;;;;;;;;;;;;;;;;;;KAoBU,mBAAA,GAAsB,WAAA;;;;;;;EAOhC,MAAA;;;;;;;;EAQA,SAAA;;;;;;EAMA,gBAAA;;;;;;;EAOA,cAAA,GAAiB,sBAAsB;;;;;EAKvC,GAAA;;;;;EAKA,KAAA;AAAA;;;;;;;;;;;;KAcU,sBAAA,GAAyB,cAAc;;;;;;;;;;KAWvC,mBAAA,GAAsB,gBAAgB"}

package/esm/index.d.mts

@@ -1,4 +1,4 @@
 import { DeepSeekEmbedderConfig, DeepSeekImageConfig, DeepSeekModelConfig, DeepSeekSDKConfig } from "./config.type.mjs";
-import { DeepSeekSDK } from "./sdk.mjs";
+import { DEEPSEEK_DEFAULT_PRICING, DEEPSEEK_OFF_PEAK_PRICING, DeepSeekSDK } from "./sdk.mjs";
 import { DEEPSEEK_CHAT_MODELS, inferReasoningCapability, inferVisionCapability } from "./known-models.mjs";
-export { DEEPSEEK_CHAT_MODELS, type DeepSeekEmbedderConfig, type DeepSeekImageConfig, type DeepSeekModelConfig, DeepSeekSDK, type DeepSeekSDKConfig, inferReasoningCapability, inferVisionCapability };
+export { DEEPSEEK_CHAT_MODELS, DEEPSEEK_DEFAULT_PRICING, DEEPSEEK_OFF_PEAK_PRICING, type DeepSeekEmbedderConfig, type DeepSeekImageConfig, type DeepSeekModelConfig, DeepSeekSDK, type DeepSeekSDKConfig, inferReasoningCapability, inferVisionCapability };

package/esm/index.mjs

@@ -1,4 +1,4 @@
 import { DEEPSEEK_CHAT_MODELS, inferReasoningCapability, inferVisionCapability } from "./known-models.mjs";
-import { DeepSeekSDK } from "./sdk.mjs";
+import { DEEPSEEK_DEFAULT_PRICING, DEEPSEEK_OFF_PEAK_PRICING, DeepSeekSDK } from "./sdk.mjs";
 
-export { DEEPSEEK_CHAT_MODELS, DeepSeekSDK, inferReasoningCapability, inferVisionCapability };
+export { DEEPSEEK_CHAT_MODELS, DEEPSEEK_DEFAULT_PRICING, DEEPSEEK_OFF_PEAK_PRICING, DeepSeekSDK, inferReasoningCapability, inferVisionCapability };

package/esm/known-models.d.mts

@@ -1,4 +1,4 @@
-//#region ../ai-deepseek/src/known-models.d.ts
+//#region ../../packages/ai-deepseek/src/known-models.d.ts
 /**
  * Capability inference for DeepSeek chat model ids.
  *

package/esm/known-models.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"known-models.d.mts","names":[],"sources":["../../../../../../ai-deepseek/src/known-models.ts"],"mappings":";;AAkCA;;;;AAKU;AA4BV;;;;AAAwD;AA+BxD;;;;AAAqD;;;;;;;;;;;;;;;;;;cAhExC,oBAAA;;;;;;;;;;;;iBAiCG,wBAAA,CAAyB,OAAe;;;;;;;;;;;;iBA+BxC,qBAAA,CAAsB,OAAe"}
+{"version":3,"file":"known-models.d.mts","names":[],"sources":["../../../../../../../packages/ai-deepseek/src/known-models.ts"],"mappings":";;AAkCA;;;;AAKU;AA4BV;;;;AAAwD;AA+BxD;;;;AAAqD;;;;;;;;;;;;;;;;;;cAhExC,oBAAA;;;;;;;;;;;;iBAiCG,wBAAA,CAAyB,OAAe;;;;;;;;;;;;iBA+BxC,qBAAA,CAAsB,OAAe"}

package/esm/known-models.mjs

@@ -1,4 +1,4 @@
-//#region ../ai-deepseek/src/known-models.ts
+//#region ../../packages/ai-deepseek/src/known-models.ts
 /**
 * Capability inference for DeepSeek chat model ids.
 *

package/esm/known-models.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"known-models.mjs","names":[],"sources":["../../../../../../ai-deepseek/src/known-models.ts"],"sourcesContent":["/**\n * Capability inference for DeepSeek chat model ids.\n *\n * DeepSeek's API is OpenAI-compatible on the wire (`@warlock.js/ai-deepseek`\n * wraps {@link OpenAISDK}), but its model **names** are not OpenAI names —\n * so OpenAI's own prefix lists (`gpt-4o`, `o3`, …) never match them. This\n * module supplies DeepSeek's OWN name-based inference, which the\n * {@link DeepSeekSDK} injects as explicit capability booleans into the\n * wrapped `openai.model(...)` call (explicit config wins over OpenAI's\n * inference inside `OpenAIModel`).\n *\n * Verified against the official DeepSeek API docs (api-docs.deepseek.com,\n * mid-2026): base URL `https://api.deepseek.com`, OpenAI-compatible Chat\n * Completions. Two reasoning-capable surfaces exist — the legacy\n * `deepseek-reasoner` (thinking mode) and the `*-pro` tier — while\n * `deepseek-chat` is the non-thinking surface. No DeepSeek chat model\n * documents image (vision) input, so vision inference is conservatively\n * `false` for every id.\n */\n\n/**\n * Default DeepSeek chat model ids, surfaced for discovery and docs.\n *\n * - `deepseek-chat` — the non-thinking surface (V3 lineage). Fast, cheap,\n *   broad production coverage. Not reasoning-capable.\n * - `deepseek-reasoner` — the thinking surface (R1 lineage). Emits a\n *   reasoning channel and accepts the reasoning-effort knob.\n *\n * Both legacy names are scheduled for retirement (2026/07/24 per DeepSeek's\n * deprecation notice) in favor of the `deepseek-v4-*` family\n * (`deepseek-v4-flash`, `deepseek-v4-pro`), which this inference also\n * understands. The list is informational only — `deepseek.model({ name })`\n * accepts any id the upstream serves.\n */\nexport const DEEPSEEK_CHAT_MODELS = [\n  \"deepseek-chat\",\n  \"deepseek-reasoner\",\n  \"deepseek-v4-flash\",\n  \"deepseek-v4-pro\",\n] as const;\n\n/**\n * Substrings identifying DeepSeek model ids that expose a reasoning /\n * thinking channel and accept the reasoning-effort knob.\n *\n * - `deepseek-reasoner` — the dedicated thinking surface (R1 lineage).\n * - `-pro` — the V4 quality tier (`deepseek-v4-pro`), which thinks by\n *   default per DeepSeek's docs.\n *\n * `deepseek-chat` (the V3 non-thinking surface) and `deepseek-v4-flash`\n * stay `false`. A substring match tolerates date/preview suffixes the\n * provider may append. Override per-model via\n * `deepseek.model({ name, reasoning: true | false })`.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\"deepseek-reasoner\", \"-pro\"];\n\n/**\n * Infer whether a DeepSeek model id is reasoning-capable based on the\n * known substrings. Unknown ids default to `false` so the adapter never\n * forwards an unsupported reasoning param to a non-thinking model.\n *\n * @example\n * inferReasoningCapability(\"deepseek-reasoner\");  // → true\n * inferReasoningCapability(\"deepseek-v4-pro\");     // → true\n * inferReasoningCapability(\"deepseek-chat\");        // → false\n * inferReasoningCapability(\"deepseek-v4-flash\");    // → false\n */\nexport function inferReasoningCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Substrings identifying DeepSeek model ids that accept image (vision)\n * input.\n *\n * Currently **empty**: as of mid-2026, no DeepSeek chat model documents\n * vision input on the OpenAI-compatible Chat Completions endpoint, so\n * inference returns `false` for every id and passing an image attachment\n * surfaces a clear, agent-side capability error instead of an opaque 400.\n * Append a fragment here (and a paired spec case) the day DeepSeek ships a\n * multimodal chat model. Devs can always opt in per-model via\n * `deepseek.model({ name, vision: true })`.\n */\nconst VISION_CAPABLE_SUBSTRINGS: readonly string[] = [];\n\n/**\n * Infer whether a DeepSeek model id supports vision based on the known\n * substrings. Today this is always `false` (see\n * {@link VISION_CAPABLE_SUBSTRINGS}); kept as a function so the\n * {@link DeepSeekSDK} call site and the override semantics stay identical\n * to the other adapters, ready for a future multimodal id.\n *\n * @example\n * inferVisionCapability(\"deepseek-chat\");      // → false\n * inferVisionCapability(\"deepseek-reasoner\");  // → false\n */\nexport function inferVisionCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,uBAAuB;CAClC;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,MAAM,+BAA+B,CAAC,qBAAqB,MAAM;;;;;;;;;;;;AAajE,SAAgB,yBAAyB,SAA0B;CACjE,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;;;;AAcA,MAAM,4BAA+C,CAAC;;;;;;;;;;;;AAatD,SAAgB,sBAAsB,SAA0B;CAC9D,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF"}
+{"version":3,"file":"known-models.mjs","names":[],"sources":["../../../../../../../packages/ai-deepseek/src/known-models.ts"],"sourcesContent":["/**\n * Capability inference for DeepSeek chat model ids.\n *\n * DeepSeek's API is OpenAI-compatible on the wire (`@warlock.js/ai-deepseek`\n * wraps {@link OpenAISDK}), but its model **names** are not OpenAI names —\n * so OpenAI's own prefix lists (`gpt-4o`, `o3`, …) never match them. This\n * module supplies DeepSeek's OWN name-based inference, which the\n * {@link DeepSeekSDK} injects as explicit capability booleans into the\n * wrapped `openai.model(...)` call (explicit config wins over OpenAI's\n * inference inside `OpenAIModel`).\n *\n * Verified against the official DeepSeek API docs (api-docs.deepseek.com,\n * mid-2026): base URL `https://api.deepseek.com`, OpenAI-compatible Chat\n * Completions. Two reasoning-capable surfaces exist — the legacy\n * `deepseek-reasoner` (thinking mode) and the `*-pro` tier — while\n * `deepseek-chat` is the non-thinking surface. No DeepSeek chat model\n * documents image (vision) input, so vision inference is conservatively\n * `false` for every id.\n */\n\n/**\n * Default DeepSeek chat model ids, surfaced for discovery and docs.\n *\n * - `deepseek-chat` — the non-thinking surface (V3 lineage). Fast, cheap,\n *   broad production coverage. Not reasoning-capable.\n * - `deepseek-reasoner` — the thinking surface (R1 lineage). Emits a\n *   reasoning channel and accepts the reasoning-effort knob.\n *\n * Both legacy names are scheduled for retirement (2026/07/24 per DeepSeek's\n * deprecation notice) in favor of the `deepseek-v4-*` family\n * (`deepseek-v4-flash`, `deepseek-v4-pro`), which this inference also\n * understands. The list is informational only — `deepseek.model({ name })`\n * accepts any id the upstream serves.\n */\nexport const DEEPSEEK_CHAT_MODELS = [\n  \"deepseek-chat\",\n  \"deepseek-reasoner\",\n  \"deepseek-v4-flash\",\n  \"deepseek-v4-pro\",\n] as const;\n\n/**\n * Substrings identifying DeepSeek model ids that expose a reasoning /\n * thinking channel and accept the reasoning-effort knob.\n *\n * - `deepseek-reasoner` — the dedicated thinking surface (R1 lineage).\n * - `-pro` — the V4 quality tier (`deepseek-v4-pro`), which thinks by\n *   default per DeepSeek's docs.\n *\n * `deepseek-chat` (the V3 non-thinking surface) and `deepseek-v4-flash`\n * stay `false`. A substring match tolerates date/preview suffixes the\n * provider may append. Override per-model via\n * `deepseek.model({ name, reasoning: true | false })`.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\"deepseek-reasoner\", \"-pro\"];\n\n/**\n * Infer whether a DeepSeek model id is reasoning-capable based on the\n * known substrings. Unknown ids default to `false` so the adapter never\n * forwards an unsupported reasoning param to a non-thinking model.\n *\n * @example\n * inferReasoningCapability(\"deepseek-reasoner\");  // → true\n * inferReasoningCapability(\"deepseek-v4-pro\");     // → true\n * inferReasoningCapability(\"deepseek-chat\");        // → false\n * inferReasoningCapability(\"deepseek-v4-flash\");    // → false\n */\nexport function inferReasoningCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Substrings identifying DeepSeek model ids that accept image (vision)\n * input.\n *\n * Currently **empty**: as of mid-2026, no DeepSeek chat model documents\n * vision input on the OpenAI-compatible Chat Completions endpoint, so\n * inference returns `false` for every id and passing an image attachment\n * surfaces a clear, agent-side capability error instead of an opaque 400.\n * Append a fragment here (and a paired spec case) the day DeepSeek ships a\n * multimodal chat model. Devs can always opt in per-model via\n * `deepseek.model({ name, vision: true })`.\n */\nconst VISION_CAPABLE_SUBSTRINGS: readonly string[] = [];\n\n/**\n * Infer whether a DeepSeek model id supports vision based on the known\n * substrings. Today this is always `false` (see\n * {@link VISION_CAPABLE_SUBSTRINGS}); kept as a function so the\n * {@link DeepSeekSDK} call site and the override semantics stay identical\n * to the other adapters, ready for a future multimodal id.\n *\n * @example\n * inferVisionCapability(\"deepseek-chat\");      // → false\n * inferVisionCapability(\"deepseek-reasoner\");  // → false\n */\nexport function inferVisionCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,uBAAuB;CAClC;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,MAAM,+BAA+B,CAAC,qBAAqB,MAAM;;;;;;;;;;;;AAajE,SAAgB,yBAAyB,SAA0B;CACjE,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,6BAA6B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACtF;;;;;;;;;;;;;AAcA,MAAM,4BAA+C,CAAC;;;;;;;;;;;;AAatD,SAAgB,sBAAsB,SAA0B;CAC9D,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF"}

package/esm/sdk.d.mts

@@ -1,7 +1,35 @@
 import { DeepSeekEmbedderConfig, DeepSeekImageConfig, DeepSeekModelConfig, DeepSeekSDKConfig } from "./config.type.mjs";
-import { EmbedderContract, ImageModelContract, ModelContract, SDKAdapterContract } from "@warlock.js/ai";
+import { EmbedderContract, ImageModelContract, ModelContract, ModelPricing, SDKAdapterContract } from "@warlock.js/ai";
 
-//#region ../ai-deepseek/src/sdk.d.ts
+//#region ../../packages/ai-deepseek/src/sdk.d.ts
+/**
+ * Built-in DeepSeek pricing defaults, in USD per 1,000,000 tokens, keyed
+ * by model name; `cachedInput` is the cache-hit input rate.
+ *
+ * Source: https://api-docs.deepseek.com/quick_start/pricing, fetched
+ * 2026-10-17. DeepSeek bills by time of day: peak hours (01:00–04:00 and
+ * 06:00–10:00 UTC, Monday to Friday) cost twice the off-peak rate. A flat
+ * `ModelPricing` cannot follow the clock, so these are the **peak** rates —
+ * an upper bound that keeps USD budgets safe; off-peak calls really cost
+ * half. Pass {@link DEEPSEEK_OFF_PEAK_PRICING} (or your own) as `pricing`
+ * when you know you run off-peak.
+ *
+ * `deepseek-v4-flash` is the legacy name of `deepseek-flash` and bills at
+ * the same rate. `deepseek-chat` / `deepseek-reasoner` are gone from the
+ * price list (discontinued 2026-07-24) and stay unpriced.
+ *
+ * A caller-supplied SDK `pricing` registry, or a per-model `pricing`,
+ * overrides any entry here.
+ */
+declare const DEEPSEEK_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>>;
+/**
+ * DeepSeek's off-peak rates (half the peak {@link DEEPSEEK_DEFAULT_PRICING}),
+ * same source and date. Opt in per SDK:
+ *
+ * @example
+ * new DeepSeekSDK({ apiKey, pricing: DEEPSEEK_OFF_PEAK_PRICING });
+ */
+declare const DEEPSEEK_OFF_PEAK_PRICING: Readonly<Record<string, ModelPricing>>;
 /**
  * DeepSeek-backed implementation of `SDKAdapterContract`.
  *
@@ -90,5 +118,5 @@ declare class DeepSeekSDK implements SDKAdapterContract {
   image(config: DeepSeekImageConfig): ImageModelContract;
 }
 //#endregion
-export { DeepSeekSDK };
+export { DEEPSEEK_DEFAULT_PRICING, DEEPSEEK_OFF_PEAK_PRICING, DeepSeekSDK };
 //# sourceMappingURL=sdk.d.mts.map

package/esm/sdk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../ai-deepseek/src/sdk.ts"],"mappings":";;;;;;AA8EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,WAAA,YAAuB,kBAAA;EA+E2B;EAAA,iBA7E5C,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,OAAA;cAEE,MAAA,EAAQ,iBAAA;;;;;;;;;;;;;;;EA+BpB,KAAA,CAAM,MAAA,EAAQ,mBAAA,GAAsB,aAAA;;;;;;EAgB9B,KAAA,CAAM,IAAA,UAAc,KAAA,YAAiB,OAAA;;;;;;;;;;;EAc3C,QAAA,CAAS,MAAA,EAAQ,sBAAA,GAAyB,gBAAA;;;;;;;;;EAY1C,KAAA,CAAM,MAAA,EAAQ,mBAAA,GAAsB,kBAAA;AAAA"}
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../../packages/ai-deepseek/src/sdk.ts"],"mappings":";;;;;;AA4CA;;;;;;;;;;;;AAA2E;AAa3E;;;;cAba,wBAAA,EAA0B,QAAA,CAAS,MAAA,SAAe,YAAA;;;;;;;;cAalD,yBAAA,EAA2B,QAAA,CAAS,MAAA,SAAe,YAAA;AA6ChE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+E+D;AA/E/D,cAAa,WAAA,YAAuB,kBAAA;;mBAEjB,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,OAAA;cAEE,MAAA,EAAQ,iBAAA;;;;;;;;;;;;;;;EA+BpB,KAAA,CAAM,MAAA,EAAQ,mBAAA,GAAsB,aAAA;;;;;;EAgB9B,KAAA,CAAM,IAAA,UAAc,KAAA,YAAiB,OAAA;;;;;;;;;;;EAc3C,QAAA,CAAS,MAAA,EAAQ,sBAAA,GAAyB,gBAAA;;;;;;;;;EAY1C,KAAA,CAAM,MAAA,EAAQ,mBAAA,GAAsB,kBAAA;AAAA"}

package/esm/sdk.mjs

@@ -1,7 +1,7 @@
 import { inferReasoningCapability, inferVisionCapability } from "./known-models.mjs";
 import { OpenAISDK } from "@warlock.js/ai-openai";
 
-//#region ../ai-deepseek/src/sdk.ts
+//#region ../../packages/ai-deepseek/src/sdk.ts
 /**
 * DeepSeek's OpenAI-compatible Chat Completions endpoint. Verified against
 * the official API docs (api-docs.deepseek.com, mid-2026).
@@ -11,31 +11,62 @@ const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
 const DEEPSEEK_PROVIDER = "deepseek";
 /**
 * Built-in DeepSeek pricing defaults, in USD per 1,000,000 tokens, keyed
-* by model name. Sourced from DeepSeek's official pricing table
-* (mid-2026); `cachedInput` is the cache-hit input rate. A caller-supplied
-* SDK `pricing` registry, or a per-model `pricing`, overrides any entry
-* here. Update when DeepSeek revises its published rates.
+* by model name; `cachedInput` is the cache-hit input rate.
+*
+* Source: https://api-docs.deepseek.com/quick_start/pricing, fetched
+* 2026-10-17. DeepSeek bills by time of day: peak hours (01:00–04:00 and
+* 06:00–10:00 UTC, Monday to Friday) cost twice the off-peak rate. A flat
+* `ModelPricing` cannot follow the clock, so these are the **peak** rates —
+* an upper bound that keeps USD budgets safe; off-peak calls really cost
+* half. Pass {@link DEEPSEEK_OFF_PEAK_PRICING} (or your own) as `pricing`
+* when you know you run off-peak.
+*
+* `deepseek-v4-flash` is the legacy name of `deepseek-flash` and bills at
+* the same rate. `deepseek-chat` / `deepseek-reasoner` are gone from the
+* price list (discontinued 2026-07-24) and stay unpriced.
+*
+* A caller-supplied SDK `pricing` registry, or a per-model `pricing`,
+* overrides any entry here.
 */
 const DEEPSEEK_DEFAULT_PRICING = {
-	"deepseek-chat": {
-		input: .14,
-		output: .28,
-		cachedInput: .0028
+	"deepseek-flash": {
+		input: .3,
+		output: 1.2,
+		cachedInput: .006
 	},
-	"deepseek-reasoner": {
-		input: .14,
-		output: .28,
-		cachedInput: .0028
+	"deepseek-v4-flash": {
+		input: .3,
+		output: 1.2,
+		cachedInput: .006
+	},
+	"deepseek-v4-pro": {
+		input: 1.32,
+		output: 3.96,
+		cachedInput: .044
+	}
+};
+/**
+* DeepSeek's off-peak rates (half the peak {@link DEEPSEEK_DEFAULT_PRICING}),
+* same source and date. Opt in per SDK:
+*
+* @example
+* new DeepSeekSDK({ apiKey, pricing: DEEPSEEK_OFF_PEAK_PRICING });
+*/
+const DEEPSEEK_OFF_PEAK_PRICING = {
+	"deepseek-flash": {
+		input: .15,
+		output: .6,
+		cachedInput: .003
 	},
 	"deepseek-v4-flash": {
-		input: .14,
-		output: .28,
-		cachedInput: .0028
+		input: .15,
+		output: .6,
+		cachedInput: .003
 	},
 	"deepseek-v4-pro": {
-		input: .435,
-		output: .87,
-		cachedInput: .003625
+		input: .66,
+		output: 1.98,
+		cachedInput: .022
 	}
 };
 /**
@@ -149,5 +180,5 @@ var DeepSeekSDK = class {
 };
 
 //#endregion
-export { DeepSeekSDK };
+export { DEEPSEEK_DEFAULT_PRICING, DEEPSEEK_OFF_PEAK_PRICING, DeepSeekSDK };
 //# sourceMappingURL=sdk.mjs.map

package/esm/sdk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../../ai-deepseek/src/sdk.ts"],"sourcesContent":["import type {\n  EmbedderContract,\n  ImageModelContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type {\n  DeepSeekEmbedderConfig,\n  DeepSeekImageConfig,\n  DeepSeekModelConfig,\n  DeepSeekSDKConfig,\n} from \"./config.type\";\nimport { inferReasoningCapability, inferVisionCapability } from \"./known-models\";\n\n/**\n * DeepSeek's OpenAI-compatible Chat Completions endpoint. Verified against\n * the official API docs (api-docs.deepseek.com, mid-2026).\n */\nconst DEEPSEEK_BASE_URL = \"https://api.deepseek.com\";\n\n/** Default upstream label for models produced by this SDK. */\nconst DEEPSEEK_PROVIDER = \"deepseek\";\n\n/**\n * Built-in DeepSeek pricing defaults, in USD per 1,000,000 tokens, keyed\n * by model name. Sourced from DeepSeek's official pricing table\n * (mid-2026); `cachedInput` is the cache-hit input rate. A caller-supplied\n * SDK `pricing` registry, or a per-model `pricing`, overrides any entry\n * here. Update when DeepSeek revises its published rates.\n */\nconst DEEPSEEK_DEFAULT_PRICING: Record<string, ModelPricing> = {\n  \"deepseek-chat\": { input: 0.14, output: 0.28, cachedInput: 0.0028 },\n  \"deepseek-reasoner\": { input: 0.14, output: 0.28, cachedInput: 0.0028 },\n  \"deepseek-v4-flash\": { input: 0.14, output: 0.28, cachedInput: 0.0028 },\n  \"deepseek-v4-pro\": { input: 0.435, output: 0.87, cachedInput: 0.003625 },\n};\n\n/**\n * DeepSeek-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for DeepSeek models. DeepSeek's API is\n * OpenAI-compatible on the wire, so rather than reimplementing the\n * battle-tested Chat Completions translation, this is a **thin wrapper**\n * over {@link OpenAISDK} from `@warlock.js/ai-openai`: it constructs one\n * internal `OpenAISDK` pinned to DeepSeek's `baseURL` and the `\"deepseek\"`\n * provider label, and delegates `model()` / `embedder()` / `image()` /\n * `count()` straight to it. Construct one `DeepSeekSDK` per account and\n * reuse it everywhere.\n *\n * **What the wrapper adds over a bare `OpenAISDK`.** DeepSeek's model\n * **names** are not OpenAI names, so OpenAI's own vision/reasoning prefix\n * lists never match them. This wrapper injects DeepSeek's OWN capability\n * inference (see `known-models.ts`) and built-in DeepSeek pricing defaults\n * as explicit values on every `model()` call — so `deepseek-reasoner` is\n * correctly flagged reasoning-capable and `deepseek-chat` is not, even\n * though neither matches an OpenAI prefix. An explicit `vision` /\n * `reasoning` / `pricing` you pass per model always wins over these\n * injected defaults.\n *\n * **Responsibility.**\n * - Owns: one long-lived internal `OpenAISDK` (auth, DeepSeek base URL)\n *   and DeepSeek's capability + pricing defaults.\n * - Does NOT own: the wire protocol, streaming loop, message/tool\n *   translation, or error wrapping — all inherited unchanged from\n *   `OpenAISDK` / `OpenAIModel`.\n *\n * @example\n * const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY! });\n * const chat = deepseek.model({ name: \"deepseek-chat\" });        // reasoning=false\n * const reasoner = deepseek.model({ name: \"deepseek-reasoner\" }); // reasoning=true\n *\n * @example\n * // Compose into an `ai.deepseek` namespace for ergonomic agent wiring\n * const ai = { agent, tool, deepseek: new DeepSeekSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.deepseek.model({ name: \"deepseek-reasoner\" }) });\n */\nexport class DeepSeekSDK implements SDKAdapterContract {\n  /** The wrapped OpenAI-compatible client, pinned to DeepSeek. */\n  private readonly openai: OpenAISDK;\n  private readonly provider: string;\n  private readonly pricing: Record<string, ModelPricing>;\n\n  public constructor(config: DeepSeekSDKConfig) {\n    const { provider, pricing, baseURL, ...clientOptions } = config;\n\n    this.provider = provider ?? DEEPSEEK_PROVIDER;\n    // Caller pricing overrides the built-in DeepSeek defaults entry-by-entry.\n    this.pricing = { ...DEEPSEEK_DEFAULT_PRICING, ...pricing };\n\n    // The internal OpenAISDK carries the DeepSeek base URL + provider label;\n    // pricing stays on THIS wrapper so it can be merged with the built-in\n    // defaults before each per-model resolution below.\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? DEEPSEEK_BASE_URL,\n      provider: this.provider,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` for a DeepSeek model. Delegates to the wrapped\n   * `OpenAISDK.model()`, but first injects this provider's defaults:\n   * - `vision` / `reasoning` inferred from DeepSeek's model-name lists\n   *   (`known-models.ts`) — so the right capabilities are set even though\n   *   the names aren't OpenAI names.\n   * - `pricing` resolved from the built-in DeepSeek table merged with any\n   *   caller-supplied SDK registry.\n   *\n   * An explicit `vision` / `reasoning` / `pricing` on `config` always wins\n   * over the injected default. Everything else (sampling, structured\n   * output, streaming, error wrapping) is inherited unchanged from\n   * `OpenAIModel`.\n   */\n  public model(config: DeepSeekModelConfig): ModelContract {\n    const resolved: DeepSeekModelConfig = {\n      ...config,\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      pricing: config.pricing ?? this.pricing[config.name],\n    };\n\n    return this.openai.model(resolved);\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegated to the wrapped\n   * `OpenAISDK.count()` (the core character-heuristic) — good for\n   * budgeting/quota guards, not billing.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an `EmbedderContract`. Delegated verbatim to\n   * `OpenAISDK.embedder()`.\n   *\n   * NOTE: DeepSeek does not officially document an OpenAI-compatible\n   * embeddings endpoint (mid-2026); this delegate works against a\n   * compatible gateway you point `baseURL` at, but may fail against the\n   * stock DeepSeek endpoint. Prefer a dedicated embeddings provider for\n   * RAG.\n   */\n  public embedder(config: DeepSeekEmbedderConfig): EmbedderContract {\n    return this.openai.embedder(config);\n  }\n\n  /**\n   * Build an `ImageModelContract`. Delegated verbatim to\n   * `OpenAISDK.image()`.\n   *\n   * NOTE: DeepSeek does not document an image-generation endpoint\n   * (mid-2026); provided for adapter parity. A non-image model id is\n   * rejected at construction by the wrapped OpenAI image model.\n   */\n  public image(config: DeepSeekImageConfig): ImageModelContract {\n    return this.openai.image(config);\n  }\n}\n"],"mappings":";;;;;;;;AAoBA,MAAM,oBAAoB;;AAG1B,MAAM,oBAAoB;;;;;;;;AAS1B,MAAM,2BAAyD;CAC7D,iBAAiB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAO;CAClE,qBAAqB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAO;CACtE,qBAAqB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAO;CACtE,mBAAmB;EAAE,OAAO;EAAO,QAAQ;EAAM,aAAa;CAAS;AACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,cAAb,MAAuD;CAMrD,AAAO,YAAY,QAA2B;EAC5C,MAAM,EAAE,UAAU,SAAS,SAAS,GAAG,kBAAkB;EAEzD,KAAK,WAAW,YAAY;EAE5B,KAAK,UAAU;GAAE,GAAG;GAA0B,GAAG;EAAQ;EAKzD,KAAK,SAAS,IAAI,UAAU;GAC1B,GAAG;GACH,SAAS,WAAW;GACpB,UAAU,KAAK;EACjB,CAAC;CACH;;;;;;;;;;;;;;;CAgBA,AAAO,MAAM,QAA4C;EACvD,MAAM,WAAgC;GACpC,GAAG;GACH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;GACnE,SAAS,OAAO,WAAW,KAAK,QAAQ,OAAO;EACjD;EAEA,OAAO,KAAK,OAAO,MAAM,QAAQ;CACnC;;;;;;CAOA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAAkD;EAChE,OAAO,KAAK,OAAO,SAAS,MAAM;CACpC;;;;;;;;;CAUA,AAAO,MAAM,QAAiD;EAC5D,OAAO,KAAK,OAAO,MAAM,MAAM;CACjC;AACF"}
+{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../../../packages/ai-deepseek/src/sdk.ts"],"sourcesContent":["import type {\n  EmbedderContract,\n  ImageModelContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n} from \"@warlock.js/ai\";\nimport { OpenAISDK } from \"@warlock.js/ai-openai\";\nimport type {\n  DeepSeekEmbedderConfig,\n  DeepSeekImageConfig,\n  DeepSeekModelConfig,\n  DeepSeekSDKConfig,\n} from \"./config.type\";\nimport { inferReasoningCapability, inferVisionCapability } from \"./known-models\";\n\n/**\n * DeepSeek's OpenAI-compatible Chat Completions endpoint. Verified against\n * the official API docs (api-docs.deepseek.com, mid-2026).\n */\nconst DEEPSEEK_BASE_URL = \"https://api.deepseek.com\";\n\n/** Default upstream label for models produced by this SDK. */\nconst DEEPSEEK_PROVIDER = \"deepseek\";\n\n/**\n * Built-in DeepSeek pricing defaults, in USD per 1,000,000 tokens, keyed\n * by model name; `cachedInput` is the cache-hit input rate.\n *\n * Source: https://api-docs.deepseek.com/quick_start/pricing, fetched\n * 2026-10-17. DeepSeek bills by time of day: peak hours (01:00–04:00 and\n * 06:00–10:00 UTC, Monday to Friday) cost twice the off-peak rate. A flat\n * `ModelPricing` cannot follow the clock, so these are the **peak** rates —\n * an upper bound that keeps USD budgets safe; off-peak calls really cost\n * half. Pass {@link DEEPSEEK_OFF_PEAK_PRICING} (or your own) as `pricing`\n * when you know you run off-peak.\n *\n * `deepseek-v4-flash` is the legacy name of `deepseek-flash` and bills at\n * the same rate. `deepseek-chat` / `deepseek-reasoner` are gone from the\n * price list (discontinued 2026-07-24) and stay unpriced.\n *\n * A caller-supplied SDK `pricing` registry, or a per-model `pricing`,\n * overrides any entry here.\n */\nexport const DEEPSEEK_DEFAULT_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"deepseek-flash\": { input: 0.3, output: 1.2, cachedInput: 0.006 },\n  \"deepseek-v4-flash\": { input: 0.3, output: 1.2, cachedInput: 0.006 },\n  \"deepseek-v4-pro\": { input: 1.32, output: 3.96, cachedInput: 0.044 },\n};\n\n/**\n * DeepSeek's off-peak rates (half the peak {@link DEEPSEEK_DEFAULT_PRICING}),\n * same source and date. Opt in per SDK:\n *\n * @example\n * new DeepSeekSDK({ apiKey, pricing: DEEPSEEK_OFF_PEAK_PRICING });\n */\nexport const DEEPSEEK_OFF_PEAK_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"deepseek-flash\": { input: 0.15, output: 0.6, cachedInput: 0.003 },\n  \"deepseek-v4-flash\": { input: 0.15, output: 0.6, cachedInput: 0.003 },\n  \"deepseek-v4-pro\": { input: 0.66, output: 1.98, cachedInput: 0.022 },\n};\n\n/**\n * DeepSeek-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for DeepSeek models. DeepSeek's API is\n * OpenAI-compatible on the wire, so rather than reimplementing the\n * battle-tested Chat Completions translation, this is a **thin wrapper**\n * over {@link OpenAISDK} from `@warlock.js/ai-openai`: it constructs one\n * internal `OpenAISDK` pinned to DeepSeek's `baseURL` and the `\"deepseek\"`\n * provider label, and delegates `model()` / `embedder()` / `image()` /\n * `count()` straight to it. Construct one `DeepSeekSDK` per account and\n * reuse it everywhere.\n *\n * **What the wrapper adds over a bare `OpenAISDK`.** DeepSeek's model\n * **names** are not OpenAI names, so OpenAI's own vision/reasoning prefix\n * lists never match them. This wrapper injects DeepSeek's OWN capability\n * inference (see `known-models.ts`) and built-in DeepSeek pricing defaults\n * as explicit values on every `model()` call — so `deepseek-reasoner` is\n * correctly flagged reasoning-capable and `deepseek-chat` is not, even\n * though neither matches an OpenAI prefix. An explicit `vision` /\n * `reasoning` / `pricing` you pass per model always wins over these\n * injected defaults.\n *\n * **Responsibility.**\n * - Owns: one long-lived internal `OpenAISDK` (auth, DeepSeek base URL)\n *   and DeepSeek's capability + pricing defaults.\n * - Does NOT own: the wire protocol, streaming loop, message/tool\n *   translation, or error wrapping — all inherited unchanged from\n *   `OpenAISDK` / `OpenAIModel`.\n *\n * @example\n * const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY! });\n * const chat = deepseek.model({ name: \"deepseek-chat\" });        // reasoning=false\n * const reasoner = deepseek.model({ name: \"deepseek-reasoner\" }); // reasoning=true\n *\n * @example\n * // Compose into an `ai.deepseek` namespace for ergonomic agent wiring\n * const ai = { agent, tool, deepseek: new DeepSeekSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.deepseek.model({ name: \"deepseek-reasoner\" }) });\n */\nexport class DeepSeekSDK implements SDKAdapterContract {\n  /** The wrapped OpenAI-compatible client, pinned to DeepSeek. */\n  private readonly openai: OpenAISDK;\n  private readonly provider: string;\n  private readonly pricing: Record<string, ModelPricing>;\n\n  public constructor(config: DeepSeekSDKConfig) {\n    const { provider, pricing, baseURL, ...clientOptions } = config;\n\n    this.provider = provider ?? DEEPSEEK_PROVIDER;\n    // Caller pricing overrides the built-in DeepSeek defaults entry-by-entry.\n    this.pricing = { ...DEEPSEEK_DEFAULT_PRICING, ...pricing };\n\n    // The internal OpenAISDK carries the DeepSeek base URL + provider label;\n    // pricing stays on THIS wrapper so it can be merged with the built-in\n    // defaults before each per-model resolution below.\n    this.openai = new OpenAISDK({\n      ...clientOptions,\n      baseURL: baseURL ?? DEEPSEEK_BASE_URL,\n      provider: this.provider,\n    });\n  }\n\n  /**\n   * Build a `ModelContract` for a DeepSeek model. Delegates to the wrapped\n   * `OpenAISDK.model()`, but first injects this provider's defaults:\n   * - `vision` / `reasoning` inferred from DeepSeek's model-name lists\n   *   (`known-models.ts`) — so the right capabilities are set even though\n   *   the names aren't OpenAI names.\n   * - `pricing` resolved from the built-in DeepSeek table merged with any\n   *   caller-supplied SDK registry.\n   *\n   * An explicit `vision` / `reasoning` / `pricing` on `config` always wins\n   * over the injected default. Everything else (sampling, structured\n   * output, streaming, error wrapping) is inherited unchanged from\n   * `OpenAIModel`.\n   */\n  public model(config: DeepSeekModelConfig): ModelContract {\n    const resolved: DeepSeekModelConfig = {\n      ...config,\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      pricing: config.pricing ?? this.pricing[config.name],\n    };\n\n    return this.openai.model(resolved);\n  }\n\n  /**\n   * Rough offline token-count estimate. Delegated to the wrapped\n   * `OpenAISDK.count()` (the core character-heuristic) — good for\n   * budgeting/quota guards, not billing.\n   */\n  public async count(text: string, model?: string): Promise<number> {\n    return this.openai.count(text, model);\n  }\n\n  /**\n   * Build an `EmbedderContract`. Delegated verbatim to\n   * `OpenAISDK.embedder()`.\n   *\n   * NOTE: DeepSeek does not officially document an OpenAI-compatible\n   * embeddings endpoint (mid-2026); this delegate works against a\n   * compatible gateway you point `baseURL` at, but may fail against the\n   * stock DeepSeek endpoint. Prefer a dedicated embeddings provider for\n   * RAG.\n   */\n  public embedder(config: DeepSeekEmbedderConfig): EmbedderContract {\n    return this.openai.embedder(config);\n  }\n\n  /**\n   * Build an `ImageModelContract`. Delegated verbatim to\n   * `OpenAISDK.image()`.\n   *\n   * NOTE: DeepSeek does not document an image-generation endpoint\n   * (mid-2026); provided for adapter parity. A non-image model id is\n   * rejected at construction by the wrapped OpenAI image model.\n   */\n  public image(config: DeepSeekImageConfig): ImageModelContract {\n    return this.openai.image(config);\n  }\n}\n"],"mappings":";;;;;;;;AAoBA,MAAM,oBAAoB;;AAG1B,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;AAqB1B,MAAa,2BAAmE;CAC9E,kBAAkB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAM;CAChE,qBAAqB;EAAE,OAAO;EAAK,QAAQ;EAAK,aAAa;CAAM;CACnE,mBAAmB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAM;AACrE;;;;;;;;AASA,MAAa,4BAAoE;CAC/E,kBAAkB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACjE,qBAAqB;EAAE,OAAO;EAAM,QAAQ;EAAK,aAAa;CAAM;CACpE,mBAAmB;EAAE,OAAO;EAAM,QAAQ;EAAM,aAAa;CAAM;AACrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,cAAb,MAAuD;CAMrD,AAAO,YAAY,QAA2B;EAC5C,MAAM,EAAE,UAAU,SAAS,SAAS,GAAG,kBAAkB;EAEzD,KAAK,WAAW,YAAY;EAE5B,KAAK,UAAU;GAAE,GAAG;GAA0B,GAAG;EAAQ;EAKzD,KAAK,SAAS,IAAI,UAAU;GAC1B,GAAG;GACH,SAAS,WAAW;GACpB,UAAU,KAAK;EACjB,CAAC;CACH;;;;;;;;;;;;;;;CAgBA,AAAO,MAAM,QAA4C;EACvD,MAAM,WAAgC;GACpC,GAAG;GACH,QAAQ,OAAO,UAAU,sBAAsB,OAAO,IAAI;GAC1D,WAAW,OAAO,aAAa,yBAAyB,OAAO,IAAI;GACnE,SAAS,OAAO,WAAW,KAAK,QAAQ,OAAO;EACjD;EAEA,OAAO,KAAK,OAAO,MAAM,QAAQ;CACnC;;;;;;CAOA,MAAa,MAAM,MAAc,OAAiC;EAChE,OAAO,KAAK,OAAO,MAAM,MAAM,KAAK;CACtC;;;;;;;;;;;CAYA,AAAO,SAAS,QAAkD;EAChE,OAAO,KAAK,OAAO,SAAS,MAAM;CACpC;;;;;;;;;CAUA,AAAO,MAAM,QAAiD;EAC5D,OAAO,KAAK,OAAO,MAAM,MAAM;CACjC;AACF"}

package/llms-full.txt

@@ -8,7 +8,7 @@
 
 ---
 name: setup-deepseek
-description: 'Wire @warlock.js/ai-deepseek — new DeepSeekSDK({apiKey, baseURL?, provider?, pricing?}) for DeepSeek''s OpenAI-compatible API, .model({name, reasoning?, vision?, structuredOutput?, responseFormat?}) for ModelContract. Thin wrapper over @warlock.js/ai-openai''s OpenAISDK pinned to https://api.deepseek.com with provider "deepseek"; injects DeepSeek-specific reasoning/vision inference + built-in pricing. Models: deepseek-chat (non-thinking), deepseek-reasoner (thinking/reasoning), deepseek-v4-flash, deepseek-v4-pro. Triggers: `DeepSeekSDK`, `deepseek-chat`, `deepseek-reasoner`, `deepseek-v4`, `api.deepseek.com`, `DEEPSEEK_API_KEY`, reasoning effort on deepseek; "wire deepseek into a warlock agent", "use deepseek-reasoner", "configure deepseek-chat", "route a warlock agent through deepseek". Skip: OpenAI/Azure/OpenRouter — `@warlock.js/ai-openai`; agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; raw deepseek HTTP / the `openai` SDK directly. Typical import `import { DeepSeekSDK } from "@warlock.js/ai-deepseek"`.'
+description: 'Wire @warlock.js/ai-deepseek — new DeepSeekSDK({apiKey, baseURL?, provider?, pricing?}) for DeepSeek''s OpenAI-compatible API, .model({name, reasoning?, vision?, structuredOutput?, responseFormat?}) for ModelContract. Thin wrapper over @warlock.js/ai-openai''s OpenAISDK pinned to https://api.deepseek.com with provider "deepseek"; injects DeepSeek-specific reasoning/vision inference + built-in pricing. Models: deepseek-flash / deepseek-v4-flash, deepseek-v4-pro, legacy deepseek-chat / deepseek-reasoner. Built-in peak-rate pricing (DEEPSEEK_DEFAULT_PRICING) and an opt-in off-peak table (DEEPSEEK_OFF_PEAK_PRICING). Triggers: `DeepSeekSDK`, `DEEPSEEK_DEFAULT_PRICING`, `DEEPSEEK_OFF_PEAK_PRICING`, `deepseek-chat`, `deepseek-reasoner`, `deepseek-v4`, `api.deepseek.com`, `DEEPSEEK_API_KEY`, reasoning effort on deepseek; "wire deepseek into a warlock agent", "use deepseek-reasoner", "configure deepseek-chat", "route a warlock agent through deepseek". Skip: OpenAI/Azure/OpenRouter — `@warlock.js/ai-openai`; agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; raw deepseek HTTP / the `openai` SDK directly. Typical import `import { DeepSeekSDK } from "@warlock.js/ai-deepseek"`.'
 ---
 
 # `@warlock.js/ai-deepseek`
@@ -34,38 +34,38 @@ new DeepSeekSDK({ apiKey, baseURL: "https://my-gateway/deepseek", provider: "dee
 ## Producing a model
 
 ```ts
-deepseek.model({ name: "deepseek-chat" })            // V3 lineage, non-thinking
-deepseek.model({ name: "deepseek-reasoner" })        // R1 lineage, reasoning-capable
-deepseek.model({ name: "deepseek-chat", temperature: 0.2 })
+deepseek.model({ name: "deepseek-chat" }); // V3 lineage, non-thinking
+deepseek.model({ name: "deepseek-reasoner" }); // R1 lineage, reasoning-capable
+deepseek.model({ name: "deepseek-chat", temperature: 0.2 });
 ```
 
 Returns a `ModelContract` you pass straight into `ai.agent({ model })`.
 
 ## Models
 
-| Model | Notes |
-| --- | --- |
-| `deepseek-chat` | Non-thinking surface (V3 lineage). Fast, cheap, broad coverage. Reasoning **off**. |
-| `deepseek-reasoner` | Thinking surface (R1 lineage). Emits a reasoning channel. Reasoning **on**. |
-| `deepseek-v4-flash` | Newer flash tier. Reasoning **off** by default. |
-| `deepseek-v4-pro` | Newer quality tier. Reasoning **on** by default. |
+| Model               | Notes                                                                              |
+| ------------------- | ---------------------------------------------------------------------------------- |
+| `deepseek-chat`     | Non-thinking surface (V3 lineage). Fast, cheap, broad coverage. Reasoning **off**. |
+| `deepseek-reasoner` | Thinking surface (R1 lineage). Emits a reasoning channel. Reasoning **on**.        |
+| `deepseek-v4-flash` | Newer flash tier. Reasoning **off** by default.                                    |
+| `deepseek-v4-pro`   | Newer quality tier. Reasoning **on** by default.                                   |
 
 DeepSeek announced the legacy `deepseek-chat` / `deepseek-reasoner` names retire 2026/07/24 in favor of the `deepseek-v4-*` family; both name sets are understood by the capability inference. `deepseek.model({ name })` accepts any id the upstream serves.
 
 ## Capabilities — what's auto-set
 
-| Flag | Default |
-| --- | --- |
-| `reasoning` | Inferred from the DeepSeek model name. `true` for `deepseek-reasoner` and the `*-pro` tier; `false` for `deepseek-chat` / `*-flash`. Drives whether the reasoning-effort knob is forwarded. |
-| `vision` | `false` for every DeepSeek model — no DeepSeek chat model documents image input (mid-2026). |
-| `structuredOutput` | `true` (inherited from the wrapped OpenAI model), unless `responseFormat` is set to a loose mode. |
-| `promptCaching` | `true` (inherited). DeepSeek reports cache hits via `usage.cachedTokens`, the same shape as OpenAI. |
+| Flag               | Default                                                                                                                                                                                     |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `reasoning`        | Inferred from the DeepSeek model name. `true` for `deepseek-reasoner` and the `*-pro` tier; `false` for `deepseek-chat` / `*-flash`. Drives whether the reasoning-effort knob is forwarded. |
+| `vision`           | `false` for every DeepSeek model — no DeepSeek chat model documents image input (mid-2026).                                                                                                 |
+| `structuredOutput` | `true` (inherited from the wrapped OpenAI model), unless `responseFormat` is set to a loose mode.                                                                                           |
+| `promptCaching`    | `true` (inherited). DeepSeek reports cache hits via `usage.cachedTokens`, the same shape as OpenAI.                                                                                         |
 
 **Override any flag explicitly** via `.model({ name, reasoning?, vision?, structuredOutput? })` — an explicit value always wins over the injected inference.
 
 ```ts
-deepseek.model({ name: "deepseek-chat", reasoning: true })   // force thinking flag
-deepseek.model({ name: "deepseek-reasoner", reasoning: false }) // suppress it
+deepseek.model({ name: "deepseek-chat", reasoning: true }); // force thinking flag
+deepseek.model({ name: "deepseek-reasoner", reasoning: false }); // suppress it
 ```
 
 ## Uses the OpenAI-compatible endpoint
@@ -75,8 +75,8 @@ Everything on the wire — Chat Completions request/response shape, streaming lo
 Structured output, reasoning effort, and streaming therefore behave exactly as documented for the OpenAI adapter:
 
 ```ts
-const model = deepseek.model({ name: "deepseek-reasoner" });        // reasoning auto-true
-await model.complete(messages, { reasoning: { effort: "high" } });  // → reasoning_effort: "high"
+const model = deepseek.model({ name: "deepseek-reasoner" }); // reasoning auto-true
+await model.complete(messages, { reasoning: { effort: "high" } }); // → reasoning_effort: "high"
 ```
 
 ## Embeddings & images
@@ -85,21 +85,41 @@ await model.complete(messages, { reasoning: { effort: "high" } });  // → reaso
 
 ## Pricing
 
-The adapter ships **built-in DeepSeek pricing defaults** (USD per 1M tokens, from DeepSeek's published table), so `usage.cost` is computed out of the box:
+The adapter ships **built-in DeepSeek pricing defaults** (`DEEPSEEK_DEFAULT_PRICING`, USD per 1M tokens; `cachedInput` is the cache-hit rate), so `usage.cost` is computed out of the box — on agent reports and on each `model.complete()` / streaming `done` usage.
+
+DeepSeek bills by time of day: peak hours (01:00–04:00 and 06:00–10:00 UTC, Monday to Friday) cost twice the off-peak rate. A flat `ModelPricing` cannot follow the clock, so the defaults are the **peak** rates — an upper bound that keeps USD budgets safe; off-peak calls really cost half. Opt into `DEEPSEEK_OFF_PEAK_PRICING` when you know you run off-peak.
 
 ```ts
-const deepseek = new DeepSeekSDK({ apiKey }); // deepseek-chat → { input: 0.14, output: 0.28, cachedInput: 0.0028 }
+import { totalCost } from "@warlock.js/ai";
+import {
+  DEEPSEEK_DEFAULT_PRICING,
+  DEEPSEEK_OFF_PEAK_PRICING,
+  DeepSeekSDK,
+} from "@warlock.js/ai-deepseek";
+
+const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY ?? "" });
+DEEPSEEK_DEFAULT_PRICING["deepseek-flash"]; // { input: 0.3, output: 1.2, cachedInput: 0.006 } — peak
+
+const offPeak = new DeepSeekSDK({
+  apiKey: process.env.DEEPSEEK_API_KEY ?? "",
+  pricing: DEEPSEEK_OFF_PEAK_PRICING, // { input: 0.15, output: 0.6, cachedInput: 0.003 } for flash
+});
+
+const { usage } = await offPeak
+  .model({ name: "deepseek-v4-pro" })
+  .complete([{ role: "user", content: "hi" }]);
+console.log(usage.cachedTokens, totalCost(usage.cost));
 ```
 
-Override per model or per SDK exactly like the OpenAI adapter. Resolution at `model()` time: per-model `pricing` > SDK `pricing` registry > built-in DeepSeek default > `undefined`.
+Resolution at `model()` time: per-model `pricing` > SDK `pricing` registry > built-in DeepSeek default > `undefined`.
 
-```ts
-new DeepSeekSDK({ apiKey, pricing: { "deepseek-reasoner": { input: 0.55, output: 2.19 } } });
-```
+- **Source.** https://api-docs.deepseek.com/quick_start/pricing, fetched 2026-10-17. Covered: `deepseek-flash`, `deepseek-v4-flash` (its legacy name, same rate) and `deepseek-v4-pro`.
+- **Unpriced:** `deepseek-chat` / `deepseek-reasoner` are gone from the price list (announced for discontinuation on 2026-07-24) — pass `pricing` if a gateway still serves them.
+- **Usage semantics.** DeepSeek's `prompt_tokens` equals cache hits + misses and `prompt_tokens_details.cached_tokens` mirrors `prompt_cache_hit_tokens`, so the usage is `inputIncludesCache: true` and hits bill at `cachedInput`. DeepSeek caches automatically on disk and takes no request hint, so `promptCacheKey` is never sent.
 
 ## Errors
 
-Raw errors surface through the wrapped OpenAI adapter's wrapper into the typed `@warlock.js/ai` `AIError` hierarchy — see the `handle-ai-errors` topic of the `warlock-js-ai` skill.
+Raw errors surface through the wrapped OpenAI adapter's wrapper into the typed `@warlock.js/ai` `AIError` hierarchy — see the `handle-ai-errors` topic of the `warlock-js-ai` skill. DeepSeek documents 503 as "Server Overloaded" (https://api-docs.deepseek.com/quick_start/error_codes); it maps to `ProviderOverloadedError` (`code: "PROVIDER_OVERLOADED"`, `retryable: true`). Every wrapped error carries `status`, `retryable` and `billed` (`false` for 401 / 402 / 403, otherwise `"unknown"`).
 
 ## When NOT to use this skill
 
@@ -113,4 +133,18 @@ Raw errors surface through the wrapped OpenAI adapter's wrapper into the typed `
 - The `run-ai-agent` topic of the `warlock-js-ai` skill — passing the model into `ai.agent({...})`.
 - The `pick-ai-provider` topic of the `warlock-js-ai` skill — adapter comparison.
 
+## Provider body options and token estimates
+
+This adapter delegates Chat Completions to the OpenAI adapter, so
+`providerOptions.openai.body` adds native Chat request fields. Other provider
+keys are ignored. Plain-object fields merge one level deep with neutral options;
+caller-provided keys win, while arrays, scalars and `null` replace the field.
+The OpenAI adapter's protected conversation, tool and transport fields remain
+protected here too. Send only fields supported by this provider; do not reuse
+OpenAI-only bodies across a mixed-provider fallback chain.
+
+Models from this adapter have no native `countTokens` method. Check
+`model.countTokens` before using an optional native counting capability;
+`sdk.count(text)` is a separate offline estimate.
+
 

package/llms.txt

@@ -6,4 +6,4 @@
 
 ## Skills
 
-- [setup-deepseek](@warlock.js/ai-deepseek/setup-deepseek/SKILL.md): Wire @warlock.js/ai-deepseek — new DeepSeekSDK({apiKey, baseURL?, provider?, pricing?}) for DeepSeek's OpenAI-compatible API, .model({name, reasoning?, vision?, structuredOutput?, responseFormat?}) for ModelContract. Thin wrapper over @warlock.js/ai-openai's OpenAISDK pinned to https://api.deepseek.com with provider "deepseek"; injects DeepSeek-specific reasoning/vision inference + built-in pricing. Models: deepseek-chat (non-thinking), deepseek-reasoner (thinking/reasoning), deepseek-v4-flash, deepseek-v4-pro. Triggers: `DeepSeekSDK`, `deepseek-chat`, `deepseek-reasoner`, `deepseek-v4`, `api.deepseek.com`, `DEEPSEEK_API_KEY`, reasoning effort on deepseek; "wire deepseek into a warlock agent", "use deepseek-reasoner", "configure deepseek-chat", "route a warlock agent through deepseek". Skip: OpenAI/Azure/OpenRouter — `@warlock.js/ai-openai`; agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; raw deepseek HTTP / the `openai` SDK directly. Typical import `import { DeepSeekSDK } from "@warlock.js/ai-deepseek"`.
+- [setup-deepseek](@warlock.js/ai-deepseek/setup-deepseek/SKILL.md): Wire @warlock.js/ai-deepseek — new DeepSeekSDK({apiKey, baseURL?, provider?, pricing?}) for DeepSeek's OpenAI-compatible API, .model({name, reasoning?, vision?, structuredOutput?, responseFormat?}) for ModelContract. Thin wrapper over @warlock.js/ai-openai's OpenAISDK pinned to https://api.deepseek.com with provider "deepseek"; injects DeepSeek-specific reasoning/vision inference + built-in pricing. Models: deepseek-flash / deepseek-v4-flash, deepseek-v4-pro, legacy deepseek-chat / deepseek-reasoner. Built-in peak-rate pricing (DEEPSEEK_DEFAULT_PRICING) and an opt-in off-peak table (DEEPSEEK_OFF_PEAK_PRICING). Triggers: `DeepSeekSDK`, `DEEPSEEK_DEFAULT_PRICING`, `DEEPSEEK_OFF_PEAK_PRICING`, `deepseek-chat`, `deepseek-reasoner`, `deepseek-v4`, `api.deepseek.com`, `DEEPSEEK_API_KEY`, reasoning effort on deepseek; "wire deepseek into a warlock agent", "use deepseek-reasoner", "configure deepseek-chat", "route a warlock agent through deepseek". Skip: OpenAI/Azure/OpenRouter — `@warlock.js/ai-openai`; agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; raw deepseek HTTP / the `openai` SDK directly. Typical import `import { DeepSeekSDK } from "@warlock.js/ai-deepseek"`.

package/package.json

@@ -10,16 +10,17 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/warlockjs/ai-deepseek"
+    "url": "git+https://github.com/warlockjs/framework.git",
+    "directory": "packages/ai-deepseek"
   },
   "dependencies": {
-    "@warlock.js/ai-openai": "5.29.0",
-    "@warlock.js/logger": "5.29.0"
+    "@warlock.js/ai-openai": "5.31.0",
+    "@warlock.js/logger": "5.31.0"
   },
   "peerDependencies": {
-    "@warlock.js/ai": "5.29.0"
+    "@warlock.js/ai": "5.31.0"
   },
-  "version": "5.29.0",
+  "version": "5.31.0",
   "main": "./cjs/index.cjs",
   "module": "./esm/index.mjs",
   "types": "./esm/index.d.mts",

package/skills/setup-deepseek/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-deepseek
-description: 'Wire @warlock.js/ai-deepseek — new DeepSeekSDK({apiKey, baseURL?, provider?, pricing?}) for DeepSeek''s OpenAI-compatible API, .model({name, reasoning?, vision?, structuredOutput?, responseFormat?}) for ModelContract. Thin wrapper over @warlock.js/ai-openai''s OpenAISDK pinned to https://api.deepseek.com with provider "deepseek"; injects DeepSeek-specific reasoning/vision inference + built-in pricing. Models: deepseek-chat (non-thinking), deepseek-reasoner (thinking/reasoning), deepseek-v4-flash, deepseek-v4-pro. Triggers: `DeepSeekSDK`, `deepseek-chat`, `deepseek-reasoner`, `deepseek-v4`, `api.deepseek.com`, `DEEPSEEK_API_KEY`, reasoning effort on deepseek; "wire deepseek into a warlock agent", "use deepseek-reasoner", "configure deepseek-chat", "route a warlock agent through deepseek". Skip: OpenAI/Azure/OpenRouter — `@warlock.js/ai-openai`; agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; raw deepseek HTTP / the `openai` SDK directly. Typical import `import { DeepSeekSDK } from "@warlock.js/ai-deepseek"`.'
+description: 'Wire @warlock.js/ai-deepseek — new DeepSeekSDK({apiKey, baseURL?, provider?, pricing?}) for DeepSeek''s OpenAI-compatible API, .model({name, reasoning?, vision?, structuredOutput?, responseFormat?}) for ModelContract. Thin wrapper over @warlock.js/ai-openai''s OpenAISDK pinned to https://api.deepseek.com with provider "deepseek"; injects DeepSeek-specific reasoning/vision inference + built-in pricing. Models: deepseek-flash / deepseek-v4-flash, deepseek-v4-pro, legacy deepseek-chat / deepseek-reasoner. Built-in peak-rate pricing (DEEPSEEK_DEFAULT_PRICING) and an opt-in off-peak table (DEEPSEEK_OFF_PEAK_PRICING). Triggers: `DeepSeekSDK`, `DEEPSEEK_DEFAULT_PRICING`, `DEEPSEEK_OFF_PEAK_PRICING`, `deepseek-chat`, `deepseek-reasoner`, `deepseek-v4`, `api.deepseek.com`, `DEEPSEEK_API_KEY`, reasoning effort on deepseek; "wire deepseek into a warlock agent", "use deepseek-reasoner", "configure deepseek-chat", "route a warlock agent through deepseek". Skip: OpenAI/Azure/OpenRouter — `@warlock.js/ai-openai`; agent wiring — the `run-ai-agent` topic of the `warlock-js-ai` skill; adapter comparison — the `pick-ai-provider` topic of the `warlock-js-ai` skill; raw deepseek HTTP / the `openai` SDK directly. Typical import `import { DeepSeekSDK } from "@warlock.js/ai-deepseek"`.'
 ---
 
 # `@warlock.js/ai-deepseek`
@@ -26,38 +26,38 @@ new DeepSeekSDK({ apiKey, baseURL: "https://my-gateway/deepseek", provider: "dee
 ## Producing a model
 
 ```ts
-deepseek.model({ name: "deepseek-chat" })            // V3 lineage, non-thinking
-deepseek.model({ name: "deepseek-reasoner" })        // R1 lineage, reasoning-capable
-deepseek.model({ name: "deepseek-chat", temperature: 0.2 })
+deepseek.model({ name: "deepseek-chat" }); // V3 lineage, non-thinking
+deepseek.model({ name: "deepseek-reasoner" }); // R1 lineage, reasoning-capable
+deepseek.model({ name: "deepseek-chat", temperature: 0.2 });
 ```
 
 Returns a `ModelContract` you pass straight into `ai.agent({ model })`.
 
 ## Models
 
-| Model | Notes |
-| --- | --- |
-| `deepseek-chat` | Non-thinking surface (V3 lineage). Fast, cheap, broad coverage. Reasoning **off**. |
-| `deepseek-reasoner` | Thinking surface (R1 lineage). Emits a reasoning channel. Reasoning **on**. |
-| `deepseek-v4-flash` | Newer flash tier. Reasoning **off** by default. |
-| `deepseek-v4-pro` | Newer quality tier. Reasoning **on** by default. |
+| Model               | Notes                                                                              |
+| ------------------- | ---------------------------------------------------------------------------------- |
+| `deepseek-chat`     | Non-thinking surface (V3 lineage). Fast, cheap, broad coverage. Reasoning **off**. |
+| `deepseek-reasoner` | Thinking surface (R1 lineage). Emits a reasoning channel. Reasoning **on**.        |
+| `deepseek-v4-flash` | Newer flash tier. Reasoning **off** by default.                                    |
+| `deepseek-v4-pro`   | Newer quality tier. Reasoning **on** by default.                                   |
 
 DeepSeek announced the legacy `deepseek-chat` / `deepseek-reasoner` names retire 2026/07/24 in favor of the `deepseek-v4-*` family; both name sets are understood by the capability inference. `deepseek.model({ name })` accepts any id the upstream serves.
 
 ## Capabilities — what's auto-set
 
-| Flag | Default |
-| --- | --- |
-| `reasoning` | Inferred from the DeepSeek model name. `true` for `deepseek-reasoner` and the `*-pro` tier; `false` for `deepseek-chat` / `*-flash`. Drives whether the reasoning-effort knob is forwarded. |
-| `vision` | `false` for every DeepSeek model — no DeepSeek chat model documents image input (mid-2026). |
-| `structuredOutput` | `true` (inherited from the wrapped OpenAI model), unless `responseFormat` is set to a loose mode. |
-| `promptCaching` | `true` (inherited). DeepSeek reports cache hits via `usage.cachedTokens`, the same shape as OpenAI. |
+| Flag               | Default                                                                                                                                                                                     |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `reasoning`        | Inferred from the DeepSeek model name. `true` for `deepseek-reasoner` and the `*-pro` tier; `false` for `deepseek-chat` / `*-flash`. Drives whether the reasoning-effort knob is forwarded. |
+| `vision`           | `false` for every DeepSeek model — no DeepSeek chat model documents image input (mid-2026).                                                                                                 |
+| `structuredOutput` | `true` (inherited from the wrapped OpenAI model), unless `responseFormat` is set to a loose mode.                                                                                           |
+| `promptCaching`    | `true` (inherited). DeepSeek reports cache hits via `usage.cachedTokens`, the same shape as OpenAI.                                                                                         |
 
 **Override any flag explicitly** via `.model({ name, reasoning?, vision?, structuredOutput? })` — an explicit value always wins over the injected inference.
 
 ```ts
-deepseek.model({ name: "deepseek-chat", reasoning: true })   // force thinking flag
-deepseek.model({ name: "deepseek-reasoner", reasoning: false }) // suppress it
+deepseek.model({ name: "deepseek-chat", reasoning: true }); // force thinking flag
+deepseek.model({ name: "deepseek-reasoner", reasoning: false }); // suppress it
 ```
 
 ## Uses the OpenAI-compatible endpoint
@@ -67,8 +67,8 @@ Everything on the wire — Chat Completions request/response shape, streaming lo
 Structured output, reasoning effort, and streaming therefore behave exactly as documented for the OpenAI adapter:
 
 ```ts
-const model = deepseek.model({ name: "deepseek-reasoner" });        // reasoning auto-true
-await model.complete(messages, { reasoning: { effort: "high" } });  // → reasoning_effort: "high"
+const model = deepseek.model({ name: "deepseek-reasoner" }); // reasoning auto-true
+await model.complete(messages, { reasoning: { effort: "high" } }); // → reasoning_effort: "high"
 ```
 
 ## Embeddings & images
@@ -77,21 +77,41 @@ await model.complete(messages, { reasoning: { effort: "high" } });  // → reaso
 
 ## Pricing
 
-The adapter ships **built-in DeepSeek pricing defaults** (USD per 1M tokens, from DeepSeek's published table), so `usage.cost` is computed out of the box:
+The adapter ships **built-in DeepSeek pricing defaults** (`DEEPSEEK_DEFAULT_PRICING`, USD per 1M tokens; `cachedInput` is the cache-hit rate), so `usage.cost` is computed out of the box — on agent reports and on each `model.complete()` / streaming `done` usage.
+
+DeepSeek bills by time of day: peak hours (01:00–04:00 and 06:00–10:00 UTC, Monday to Friday) cost twice the off-peak rate. A flat `ModelPricing` cannot follow the clock, so the defaults are the **peak** rates — an upper bound that keeps USD budgets safe; off-peak calls really cost half. Opt into `DEEPSEEK_OFF_PEAK_PRICING` when you know you run off-peak.
 
 ```ts
-const deepseek = new DeepSeekSDK({ apiKey }); // deepseek-chat → { input: 0.14, output: 0.28, cachedInput: 0.0028 }
+import { totalCost } from "@warlock.js/ai";
+import {
+  DEEPSEEK_DEFAULT_PRICING,
+  DEEPSEEK_OFF_PEAK_PRICING,
+  DeepSeekSDK,
+} from "@warlock.js/ai-deepseek";
+
+const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY ?? "" });
+DEEPSEEK_DEFAULT_PRICING["deepseek-flash"]; // { input: 0.3, output: 1.2, cachedInput: 0.006 } — peak
+
+const offPeak = new DeepSeekSDK({
+  apiKey: process.env.DEEPSEEK_API_KEY ?? "",
+  pricing: DEEPSEEK_OFF_PEAK_PRICING, // { input: 0.15, output: 0.6, cachedInput: 0.003 } for flash
+});
+
+const { usage } = await offPeak
+  .model({ name: "deepseek-v4-pro" })
+  .complete([{ role: "user", content: "hi" }]);
+console.log(usage.cachedTokens, totalCost(usage.cost));
 ```
 
-Override per model or per SDK exactly like the OpenAI adapter. Resolution at `model()` time: per-model `pricing` > SDK `pricing` registry > built-in DeepSeek default > `undefined`.
+Resolution at `model()` time: per-model `pricing` > SDK `pricing` registry > built-in DeepSeek default > `undefined`.
 
-```ts
-new DeepSeekSDK({ apiKey, pricing: { "deepseek-reasoner": { input: 0.55, output: 2.19 } } });
-```
+- **Source.** https://api-docs.deepseek.com/quick_start/pricing, fetched 2026-10-17. Covered: `deepseek-flash`, `deepseek-v4-flash` (its legacy name, same rate) and `deepseek-v4-pro`.
+- **Unpriced:** `deepseek-chat` / `deepseek-reasoner` are gone from the price list (announced for discontinuation on 2026-07-24) — pass `pricing` if a gateway still serves them.
+- **Usage semantics.** DeepSeek's `prompt_tokens` equals cache hits + misses and `prompt_tokens_details.cached_tokens` mirrors `prompt_cache_hit_tokens`, so the usage is `inputIncludesCache: true` and hits bill at `cachedInput`. DeepSeek caches automatically on disk and takes no request hint, so `promptCacheKey` is never sent.
 
 ## Errors
 
-Raw errors surface through the wrapped OpenAI adapter's wrapper into the typed `@warlock.js/ai` `AIError` hierarchy — see the `handle-ai-errors` topic of the `warlock-js-ai` skill.
+Raw errors surface through the wrapped OpenAI adapter's wrapper into the typed `@warlock.js/ai` `AIError` hierarchy — see the `handle-ai-errors` topic of the `warlock-js-ai` skill. DeepSeek documents 503 as "Server Overloaded" (https://api-docs.deepseek.com/quick_start/error_codes); it maps to `ProviderOverloadedError` (`code: "PROVIDER_OVERLOADED"`, `retryable: true`). Every wrapped error carries `status`, `retryable` and `billed` (`false` for 401 / 402 / 403, otherwise `"unknown"`).
 
 ## When NOT to use this skill
 
@@ -104,3 +124,17 @@ Raw errors surface through the wrapped OpenAI adapter's wrapper into the typed `
 - The `setup-openai` topic of the `warlock-js-ai-openai` skill — the wrapped adapter; all wire-level behavior.
 - The `run-ai-agent` topic of the `warlock-js-ai` skill — passing the model into `ai.agent({...})`.
 - The `pick-ai-provider` topic of the `warlock-js-ai` skill — adapter comparison.
+
+## Provider body options and token estimates
+
+This adapter delegates Chat Completions to the OpenAI adapter, so
+`providerOptions.openai.body` adds native Chat request fields. Other provider
+keys are ignored. Plain-object fields merge one level deep with neutral options;
+caller-provided keys win, while arrays, scalars and `null` replace the field.
+The OpenAI adapter's protected conversation, tool and transport fields remain
+protected here too. Send only fields supported by this provider; do not reuse
+OpenAI-only bodies across a mixed-provider fallback chain.
+
+Models from this adapter have no native `countTokens` method. Check
+`model.countTokens` before using an optional native counting capability;
+`sdk.count(text)` is a separate offline estimate.