@warlock.js/ai-deepseek 4.6.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog — @warlock.js/ai-deepseek
+
+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.
+
+## 4.6.0
+
+### Added
+
+- **First release.** DeepSeek adapter for `@warlock.js/ai` — a thin wrapper over `@warlock.js/ai-openai`'s `OpenAISDK` pinned to `https://api.deepseek.com` (`provider: "deepseek"`), so all wire behavior (streaming, tool calls, structured output, error wrapping) is inherited unchanged.
+- **`DeepSeekSDK`** — `.model()` / `.embedder()` / `.image()` / `.count()` delegated to the wrapped client. `baseURL` and `provider` are optional (default to DeepSeek's endpoint / label); every other `openai` `ClientOptions` value is forwarded verbatim.
+- **DeepSeek-specific capability inference** (`inferReasoningCapability` / `inferVisionCapability`) — `reasoning` is auto-`true` for `deepseek-reasoner` and the `*-pro` tier, auto-`false` for `deepseek-chat` / `*-flash`; `vision` is `false` for every id (no documented vision surface). An explicit `reasoning` / `vision` per model always wins.
+- **Built-in DeepSeek pricing defaults** (USD per 1M tokens) for `deepseek-chat`, `deepseek-reasoner`, `deepseek-v4-flash`, `deepseek-v4-pro`, so `usage.cost` is computed out of the box; overridable per model or per SDK.
+- **`DEEPSEEK_CHAT_MODELS`** — informational list of the documented chat model ids.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Hassan Zohdy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# @warlock.js/ai-deepseek
+
+DeepSeek adapter for [`@warlock.js/ai`](../ai). DeepSeek's API is **OpenAI-compatible** on the wire, so this package is a **thin wrapper** over [`@warlock.js/ai-openai`](../ai-openai)'s `OpenAISDK`: it constructs one internal `OpenAISDK` pinned to `https://api.deepseek.com` with `provider: "deepseek"` and delegates `model()` / `embedder()` / `image()` / `count()` to it — while injecting DeepSeek's own capability inference and built-in pricing so the right flags are set even though the model names aren't OpenAI names.
+
+```bash
+npm install @warlock.js/ai @warlock.js/ai-deepseek @warlock.js/seal openai
+```
+
+> `@warlock.js/seal` is the recommended Standard Schema library for tool inputs and structured output. Any Standard Schema V1 library works (Zod, Valibot, …). `openai` is required because this adapter wraps `@warlock.js/ai-openai`.
+
+## Quick start
+
+```ts
+import { DeepSeekSDK } from "@warlock.js/ai-deepseek";
+import { ai } from "@warlock.js/ai";
+
+const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY! });
+
+const myAgent = ai.agent({
+  model: deepseek.model({ name: "deepseek-chat" }),
+});
+
+const result = await myAgent.execute("Hello!");
+console.log(result.text);
+```
+
+`apiKey` is the only required field — `baseURL` defaults to `https://api.deepseek.com` (DeepSeek's OpenAI-compatible endpoint) and `provider` defaults to `"deepseek"`. `DeepSeekSDK` is a class holding one long-lived wrapped client; construct one per account and reuse it.
+
+## API surface
+
+```ts
+new DeepSeekSDK(config: DeepSeekSDKConfig)      // Omit<OpenAISDKConfig, "baseURL" | "provider"> + optional baseURL/provider
+  .model(config: DeepSeekModelConfig)           // → ModelContract
+  .embedder(config: DeepSeekEmbedderConfig)     // → EmbedderContract
+  .image(config: DeepSeekImageConfig)           // → ImageModelContract
+  .count(text, model?)                          // approximate token count
+
+DeepSeekModelConfig {
+  name: string;                                 // e.g. "deepseek-chat", "deepseek-reasoner"
+  temperature?: number;
+  maxTokens?: number;
+  vision?: boolean;                             // override auto-inference (always false today)
+  reasoning?: boolean;                          // override auto-inference
+  structuredOutput?: boolean;                   // override; defaults true
+  responseFormat?: "json_schema" | "json_object" | "text";
+  pdf?: boolean;                                // opt into PDF input
+  audio?: boolean;                              // opt into audio input
+  // ...any other ModelConfig field forwarded to the wrapped OpenAI model
+}
+```
+
+## Models
+
+| 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 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.
+
+## Capabilities
+
+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).      |
+| `structuredOutput` | `true` (inherited from the wrapped OpenAI model), unless `responseFormat` forces a loose mode. |
+| `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-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"
+```
+
+`reasoning.effort` maps to the OpenAI-compatible `reasoning_effort` param and is dropped for a non-reasoning model.
+
+## 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. 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 } },
+});
+```
+
+## Embeddings & images
+
+`deepseek.embedder({...})` and `deepseek.image({...})` delegate to the wrapped `OpenAISDK`. **DeepSeek does not officially document an OpenAI-compatible embeddings endpoint or an image-generation endpoint (mid-2026)** — these delegates exist for adapter parity and work against a compatible gateway you point `baseURL` at, but may fail against the stock DeepSeek endpoint. Use a dedicated embeddings provider (e.g. `@warlock.js/ai-openai` / `@warlock.js/ai-google`) for RAG.
+
+## OpenAI-compatible endpoints
+
+Override `baseURL` (proxy / gateway) or `provider` (relabel the upstream):
+
+```ts
+new DeepSeekSDK({
+  apiKey,
+  baseURL: "https://my-gateway.example.com/deepseek",
+  provider: "deepseek-proxy",
+});
+```
+
+## Tests
+
+```bash
+npm test
+```
+
+Covers DeepSeek capability inference and the thin-wrapper delegation to `OpenAISDK`.
+
+## License
+
+MIT

package/cjs/index.cjs

@@ -0,0 +1,255 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _warlock_js_ai_openai = require("@warlock.js/ai-openai");
+
+//#region ../@warlock.js/ai-deepseek/src/known-models.ts
+/**
+* Capability inference for DeepSeek chat model ids.
+*
+* DeepSeek's API is OpenAI-compatible on the wire (`@warlock.js/ai-deepseek`
+* wraps {@link OpenAISDK}), but its model **names** are not OpenAI names —
+* so OpenAI's own prefix lists (`gpt-4o`, `o3`, …) never match them. This
+* module supplies DeepSeek's OWN name-based inference, which the
+* {@link DeepSeekSDK} injects as explicit capability booleans into the
+* wrapped `openai.model(...)` call (explicit config wins over OpenAI's
+* inference inside `OpenAIModel`).
+*
+* Verified against the official DeepSeek API docs (api-docs.deepseek.com,
+* mid-2026): base URL `https://api.deepseek.com`, OpenAI-compatible Chat
+* Completions. Two reasoning-capable surfaces exist — the legacy
+* `deepseek-reasoner` (thinking mode) and the `*-pro` tier — while
+* `deepseek-chat` is the non-thinking surface. No DeepSeek chat model
+* documents image (vision) input, so vision inference is conservatively
+* `false` for every id.
+*/
+/**
+* Default DeepSeek chat model ids, surfaced for discovery and docs.
+*
+* - `deepseek-chat` — the non-thinking surface (V3 lineage). Fast, cheap,
+*   broad production coverage. Not reasoning-capable.
+* - `deepseek-reasoner` — the thinking surface (R1 lineage). Emits a
+*   reasoning channel and accepts the reasoning-effort knob.
+*
+* Both legacy names are scheduled for retirement (2026/07/24 per DeepSeek's
+* deprecation notice) in favor of the `deepseek-v4-*` family
+* (`deepseek-v4-flash`, `deepseek-v4-pro`), which this inference also
+* understands. The list is informational only — `deepseek.model({ name })`
+* accepts any id the upstream serves.
+*/
+const DEEPSEEK_CHAT_MODELS = [
+	"deepseek-chat",
+	"deepseek-reasoner",
+	"deepseek-v4-flash",
+	"deepseek-v4-pro"
+];
+/**
+* Substrings identifying DeepSeek model ids that expose a reasoning /
+* thinking channel and accept the reasoning-effort knob.
+*
+* - `deepseek-reasoner` — the dedicated thinking surface (R1 lineage).
+* - `-pro` — the V4 quality tier (`deepseek-v4-pro`), which thinks by
+*   default per DeepSeek's docs.
+*
+* `deepseek-chat` (the V3 non-thinking surface) and `deepseek-v4-flash`
+* stay `false`. A substring match tolerates date/preview suffixes the
+* provider may append. Override per-model via
+* `deepseek.model({ name, reasoning: true | false })`.
+*/
+const REASONING_CAPABLE_SUBSTRINGS = ["deepseek-reasoner", "-pro"];
+/**
+* Infer whether a DeepSeek model id is reasoning-capable based on the
+* known substrings. Unknown ids default to `false` so the adapter never
+* forwards an unsupported reasoning param to a non-thinking model.
+*
+* @example
+* inferReasoningCapability("deepseek-reasoner");  // → true
+* inferReasoningCapability("deepseek-v4-pro");     // → true
+* inferReasoningCapability("deepseek-chat");        // → false
+* inferReasoningCapability("deepseek-v4-flash");    // → false
+*/
+function inferReasoningCapability(modelId) {
+	const normalized = modelId.toLowerCase();
+	return REASONING_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));
+}
+/**
+* Substrings identifying DeepSeek model ids that accept image (vision)
+* input.
+*
+* Currently **empty**: as of mid-2026, no DeepSeek chat model documents
+* vision input on the OpenAI-compatible Chat Completions endpoint, so
+* inference returns `false` for every id and passing an image attachment
+* surfaces a clear, agent-side capability error instead of an opaque 400.
+* Append a fragment here (and a paired spec case) the day DeepSeek ships a
+* multimodal chat model. Devs can always opt in per-model via
+* `deepseek.model({ name, vision: true })`.
+*/
+const VISION_CAPABLE_SUBSTRINGS = [];
+/**
+* Infer whether a DeepSeek model id supports vision based on the known
+* substrings. Today this is always `false` (see
+* {@link VISION_CAPABLE_SUBSTRINGS}); kept as a function so the
+* {@link DeepSeekSDK} call site and the override semantics stay identical
+* to the other adapters, ready for a future multimodal id.
+*
+* @example
+* inferVisionCapability("deepseek-chat");      // → false
+* inferVisionCapability("deepseek-reasoner");  // → false
+*/
+function inferVisionCapability(modelId) {
+	const normalized = modelId.toLowerCase();
+	return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));
+}
+
+//#endregion
+//#region ../@warlock.js/ai-deepseek/src/sdk.ts
+/**
+* DeepSeek's OpenAI-compatible Chat Completions endpoint. Verified against
+* the official API docs (api-docs.deepseek.com, mid-2026).
+*/
+const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+/** Default upstream label for models produced by this SDK. */
+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.
+*/
+const DEEPSEEK_DEFAULT_PRICING = {
+	"deepseek-chat": {
+		input: .14,
+		output: .28,
+		cachedInput: .0028
+	},
+	"deepseek-reasoner": {
+		input: .14,
+		output: .28,
+		cachedInput: .0028
+	},
+	"deepseek-v4-flash": {
+		input: .14,
+		output: .28,
+		cachedInput: .0028
+	},
+	"deepseek-v4-pro": {
+		input: .435,
+		output: .87,
+		cachedInput: .003625
+	}
+};
+/**
+* DeepSeek-backed implementation of `SDKAdapterContract`.
+*
+* **Role.** The package entry point for DeepSeek models. DeepSeek's API is
+* OpenAI-compatible on the wire, so rather than reimplementing the
+* battle-tested Chat Completions translation, this is a **thin wrapper**
+* over {@link OpenAISDK} from `@warlock.js/ai-openai`: it constructs one
+* internal `OpenAISDK` pinned to DeepSeek's `baseURL` and the `"deepseek"`
+* provider label, and delegates `model()` / `embedder()` / `image()` /
+* `count()` straight to it. Construct one `DeepSeekSDK` per account and
+* reuse it everywhere.
+*
+* **What the wrapper adds over a bare `OpenAISDK`.** DeepSeek's model
+* **names** are not OpenAI names, so OpenAI's own vision/reasoning prefix
+* lists never match them. This wrapper injects DeepSeek's OWN capability
+* inference (see `known-models.ts`) and built-in DeepSeek pricing defaults
+* as explicit values on every `model()` call — so `deepseek-reasoner` is
+* correctly flagged reasoning-capable and `deepseek-chat` is not, even
+* though neither matches an OpenAI prefix. An explicit `vision` /
+* `reasoning` / `pricing` you pass per model always wins over these
+* injected defaults.
+*
+* **Responsibility.**
+* - Owns: one long-lived internal `OpenAISDK` (auth, DeepSeek base URL)
+*   and DeepSeek's capability + pricing defaults.
+* - Does NOT own: the wire protocol, streaming loop, message/tool
+*   translation, or error wrapping — all inherited unchanged from
+*   `OpenAISDK` / `OpenAIModel`.
+*
+* @example
+* const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY! });
+* const chat = deepseek.model({ name: "deepseek-chat" });        // reasoning=false
+* const reasoner = deepseek.model({ name: "deepseek-reasoner" }); // reasoning=true
+*
+* @example
+* // Compose into an `ai.deepseek` namespace for ergonomic agent wiring
+* const ai = { agent, tool, deepseek: new DeepSeekSDK({ apiKey }) };
+* const myAgent = ai.agent({ model: ai.deepseek.model({ name: "deepseek-reasoner" }) });
+*/
+var DeepSeekSDK = class {
+	constructor(config) {
+		const { provider, pricing, baseURL, ...clientOptions } = config;
+		this.provider = provider ?? DEEPSEEK_PROVIDER;
+		this.pricing = {
+			...DEEPSEEK_DEFAULT_PRICING,
+			...pricing
+		};
+		this.openai = new _warlock_js_ai_openai.OpenAISDK({
+			...clientOptions,
+			baseURL: baseURL ?? DEEPSEEK_BASE_URL,
+			provider: this.provider
+		});
+	}
+	/**
+	* Build a `ModelContract` for a DeepSeek model. Delegates to the wrapped
+	* `OpenAISDK.model()`, but first injects this provider's defaults:
+	* - `vision` / `reasoning` inferred from DeepSeek's model-name lists
+	*   (`known-models.ts`) — so the right capabilities are set even though
+	*   the names aren't OpenAI names.
+	* - `pricing` resolved from the built-in DeepSeek table merged with any
+	*   caller-supplied SDK registry.
+	*
+	* An explicit `vision` / `reasoning` / `pricing` on `config` always wins
+	* over the injected default. Everything else (sampling, structured
+	* output, streaming, error wrapping) is inherited unchanged from
+	* `OpenAIModel`.
+	*/
+	model(config) {
+		const resolved = {
+			...config,
+			vision: config.vision ?? inferVisionCapability(config.name),
+			reasoning: config.reasoning ?? inferReasoningCapability(config.name),
+			pricing: config.pricing ?? this.pricing[config.name]
+		};
+		return this.openai.model(resolved);
+	}
+	/**
+	* Rough offline token-count estimate. Delegated to the wrapped
+	* `OpenAISDK.count()` (the core character-heuristic) — good for
+	* budgeting/quota guards, not billing.
+	*/
+	async count(text, model) {
+		return this.openai.count(text, model);
+	}
+	/**
+	* Build an `EmbedderContract`. Delegated verbatim to
+	* `OpenAISDK.embedder()`.
+	*
+	* NOTE: DeepSeek does not officially document an OpenAI-compatible
+	* embeddings endpoint (mid-2026); this delegate works against a
+	* compatible gateway you point `baseURL` at, but may fail against the
+	* stock DeepSeek endpoint. Prefer a dedicated embeddings provider for
+	* RAG.
+	*/
+	embedder(config) {
+		return this.openai.embedder(config);
+	}
+	/**
+	* Build an `ImageModelContract`. Delegated verbatim to
+	* `OpenAISDK.image()`.
+	*
+	* NOTE: DeepSeek does not document an image-generation endpoint
+	* (mid-2026); provided for adapter parity. A non-image model id is
+	* rejected at construction by the wrapped OpenAI image model.
+	*/
+	image(config) {
+		return this.openai.image(config);
+	}
+};
+
+//#endregion
+exports.DEEPSEEK_CHAT_MODELS = DEEPSEEK_CHAT_MODELS;
+exports.DeepSeekSDK = DeepSeekSDK;
+exports.inferReasoningCapability = inferReasoningCapability;
+exports.inferVisionCapability = inferVisionCapability;
+//# sourceMappingURL=index.cjs.map

package/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["OpenAISDK"],"sources":["../../../../../../@warlock.js/ai-deepseek/src/known-models.ts","../../../../../../@warlock.js/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"}

package/esm/config.type.d.mts

@@ -0,0 +1,146 @@
+import { OpenAISDKConfig } from "@warlock.js/ai-openai";
+import { EmbedderConfig, ImageModelConfig, ModelConfig } from "@warlock.js/ai";
+
+//#region ../@warlock.js/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
+ * OpenAI-compatible Chat Completions protocol):
+ *
+ * - `"json_schema"` — strict token-level shape enforcement.
+ * - `"json_object"` — guarantees valid JSON, NOT shape; the agent
+ *   re-injects the schema as a soft prompt hint.
+ * - `"text"` — no `response_format` on the wire; relies on the prompt hint.
+ */
+type DeepSeekResponseFormat = "json_schema" | "json_object" | "text";
+/**
+ * Configuration for the DeepSeek SDK adapter.
+ *
+ * DeepSeek's API is OpenAI-compatible on the wire, so this config is the
+ * {@link OpenAISDKConfig} shape with one ergonomic change: `baseURL` and
+ * `provider` are **optional** because the adapter defaults them to
+ * DeepSeek's endpoint (`https://api.deepseek.com`) and the `"deepseek"`
+ * label. Pass only your `apiKey` for the common path; every other upstream
+ * `openai` `ClientOptions` value (`timeout`, `maxRetries`,
+ * `defaultHeaders`, `fetch`, …) is forwarded verbatim to the wrapped
+ * `OpenAISDK`.
+ *
+ * `provider` flows through to `ModelContract.provider`, `AgentReport.model`,
+ * logs, and any provider-aware middleware. Defaults to `"deepseek"`.
+ *
+ * `pricing` is an optional SDK-level registry keyed by model name —
+ * resolution at `model()` time is per-model `pricing` > this SDK registry >
+ * the adapter's built-in DeepSeek defaults > `undefined`.
+ *
+ * @example
+ * new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY! });
+ *
+ * @example
+ * // Override the default endpoint (e.g. a proxy) or the provider label:
+ * new DeepSeekSDK({
+ *   apiKey,
+ *   baseURL: "https://my-gateway.example.com/deepseek",
+ *   provider: "deepseek-proxy",
+ * });
+ *
+ * @example
+ * new DeepSeekSDK({
+ *   apiKey,
+ *   pricing: { "deepseek-chat": { input: 0.14, output: 0.28, cachedInput: 0.0028 } },
+ * });
+ */
+type DeepSeekSDKConfig = Omit<OpenAISDKConfig, "baseURL" | "provider"> & {
+  /**
+   * Override the DeepSeek base URL. Defaults to
+   * `https://api.deepseek.com` (the OpenAI-compatible endpoint). Set this
+   * only to route through a proxy or a self-hosted gateway.
+   */
+  baseURL?: string;
+  /**
+   * Override the upstream label. Defaults to `"deepseek"`. Flows through
+   * to `ModelContract.provider`, `AgentReport.model`, and logs.
+   */
+  provider?: string;
+};
+/**
+ * Per-model configuration for `DeepSeekSDK.model()`. `name` is a DeepSeek
+ * chat model id (e.g. `"deepseek-chat"`, `"deepseek-reasoner"`).
+ *
+ * Mirrors the OpenAI adapter's per-model overrides field-for-field —
+ * DeepSeek runs on the same OpenAI-compatible wire. The difference from
+ * using `OpenAISDK` directly is the **default** capability inference:
+ * `DeepSeekSDK` derives `vision` and `reasoning` from DeepSeek's own
+ * model-name lists (see `known-models.ts`) rather than OpenAI's prefix
+ * lists, then injects them as explicit booleans. An explicit value you
+ * pass here always wins over that inference.
+ *
+ * @example
+ * deepseek.model({ name: "deepseek-chat" });                  // reasoning auto-false
+ * deepseek.model({ name: "deepseek-reasoner" });              // reasoning auto-true
+ * deepseek.model({ name: "deepseek-chat", reasoning: true }); // explicit override
+ */
+type DeepSeekModelConfig = ModelConfig & {
+  /**
+   * Override the auto-inferred vision capability. When omitted, the
+   * adapter infers from the DeepSeek model name (always `false` today —
+   * no DeepSeek chat model documents image input). Explicit `true`/`false`
+   * always wins.
+   */
+  vision?: boolean;
+  /**
+   * Override the auto-inferred reasoning capability. When omitted, the
+   * adapter infers 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.
+   * Explicit `true`/`false` always wins.
+   */
+  reasoning?: boolean;
+  /**
+   * Override the inferred `structuredOutput` capability. Forwarded to the
+   * wrapped OpenAI model, where it defaults to `true` unless
+   * `responseFormat` forces a loose mode.
+   */
+  structuredOutput?: boolean;
+  /**
+   * Override the wire-level `response_format` the adapter emits for a
+   * response schema. Use a loose mode (`"json_object"` / `"text"`) for a
+   * route that rejects strict `json_schema`. Forwarded to the wrapped
+   * OpenAI model unchanged.
+   */
+  responseFormat?: DeepSeekResponseFormat;
+  /**
+   * Opt into PDF / document **input**. Forwarded to the wrapped OpenAI
+   * model; off by default.
+   */
+  pdf?: boolean;
+  /**
+   * Opt into audio **input**. Forwarded to the wrapped OpenAI model; off
+   * by default.
+   */
+  audio?: boolean;
+};
+/**
+ * Per-embedder configuration for `DeepSeekSDK.embedder()`. Mirrors the
+ * neutral {@link EmbedderConfig}.
+ *
+ * NOTE: DeepSeek does not officially document an OpenAI-compatible
+ * embeddings endpoint (mid-2026). `embedder()` is delegated to the wrapped
+ * `OpenAISDK` for completeness, so it works against any compatible gateway
+ * you point `baseURL` at — but calling `.embed()` against the stock
+ * `https://api.deepseek.com` endpoint may fail upstream. Prefer a
+ * dedicated embeddings provider for RAG.
+ */
+type DeepSeekEmbedderConfig = EmbedderConfig;
+/**
+ * Per-model configuration for `DeepSeekSDK.image()`. Mirrors the neutral
+ * {@link ImageModelConfig}.
+ *
+ * NOTE: DeepSeek does not document an image-generation endpoint
+ * (mid-2026). `image()` is delegated to the wrapped `OpenAISDK` for
+ * parity; a non-image model id is rejected by the wrapped OpenAI image
+ * model at construction exactly as it would be there.
+ */
+type DeepSeekImageConfig = ImageModelConfig;
+//#endregion
+export { DeepSeekEmbedderConfig, DeepSeekImageConfig, DeepSeekModelConfig, DeepSeekSDKConfig };
+//# sourceMappingURL=config.type.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../@warlock.js/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

@@ -0,0 +1,4 @@
+import { DeepSeekEmbedderConfig, DeepSeekImageConfig, DeepSeekModelConfig, DeepSeekSDKConfig } from "./config.type.mjs";
+import { 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 };

package/esm/index.mjs

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