@warlock.js/ai-deepseek 4.6.0

package/esm/known-models.d.mts

@@ -0,0 +1,62 @@
+//#region ../@warlock.js/ai-deepseek/src/known-models.d.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.
+ */
+declare const DEEPSEEK_CHAT_MODELS: readonly ["deepseek-chat", "deepseek-reasoner", "deepseek-v4-flash", "deepseek-v4-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
+ */
+declare function inferReasoningCapability(modelId: string): boolean;
+/**
+ * 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
+ */
+declare function inferVisionCapability(modelId: string): boolean;
+//#endregion
+export { DEEPSEEK_CHAT_MODELS, inferReasoningCapability, inferVisionCapability };
+//# sourceMappingURL=known-models.d.mts.map

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

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

@@ -0,0 +1,101 @@
+//#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
+export { DEEPSEEK_CHAT_MODELS, inferReasoningCapability, inferVisionCapability };
+//# sourceMappingURL=known-models.mjs.map

package/esm/known-models.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-models.mjs","names":[],"sources":["../../../../../../@warlock.js/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

@@ -0,0 +1,94 @@
+import { DeepSeekEmbedderConfig, DeepSeekImageConfig, DeepSeekModelConfig, DeepSeekSDKConfig } from "./config.type.mjs";
+import { EmbedderContract, ImageModelContract, ModelContract, SDKAdapterContract } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-deepseek/src/sdk.d.ts
+/**
+ * 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" }) });
+ */
+declare class DeepSeekSDK implements SDKAdapterContract {
+  /** The wrapped OpenAI-compatible client, pinned to DeepSeek. */
+  private readonly openai;
+  private readonly provider;
+  private readonly pricing;
+  constructor(config: DeepSeekSDKConfig);
+  /**
+   * 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: DeepSeekModelConfig): ModelContract;
+  /**
+   * Rough offline token-count estimate. Delegated to the wrapped
+   * `OpenAISDK.count()` (the core character-heuristic) — good for
+   * budgeting/quota guards, not billing.
+   */
+  count(text: string, model?: string): Promise<number>;
+  /**
+   * 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: DeepSeekEmbedderConfig): EmbedderContract;
+  /**
+   * 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: DeepSeekImageConfig): ImageModelContract;
+}
+//#endregion
+export { DeepSeekSDK };
+//# sourceMappingURL=sdk.d.mts.map

package/esm/sdk.d.mts.map

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

package/esm/sdk.mjs

@@ -0,0 +1,153 @@
+import { inferReasoningCapability, inferVisionCapability } from "./known-models.mjs";
+import { OpenAISDK } from "@warlock.js/ai-openai";
+
+//#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 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
+export { DeepSeekSDK };
+//# sourceMappingURL=sdk.mjs.map

package/esm/sdk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../../@warlock.js/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"}

package/llms-full.txt

@@ -0,0 +1,116 @@
+# Warlock AI Deepseek — full skills
+
+> Package: `@warlock.js/ai-deepseek`
+
+> Generated artifact. Concatenates every SKILL.md and reference file under `@warlock.js/ai-deepseek/skills/`. Re-run `node scripts/generate-llms.mjs` after any change.
+
+## setup-deepseek  `@warlock.js/ai-deepseek/setup-deepseek/SKILL.md`
+
+---
+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 — `@warlock.js/ai/run-ai-agent/SKILL.md`; adapter comparison — `@warlock.js/ai/pick-ai-provider/SKILL.md`; raw deepseek HTTP / the `openai` SDK directly. Typical import `import { DeepSeekSDK } from "@warlock.js/ai-deepseek"`.'
+---
+
+# `@warlock.js/ai-deepseek`
+
+Provider adapter for DeepSeek. DeepSeek's API is **OpenAI-compatible**, so this package is a **thin wrapper** over [`@warlock.js/ai-openai`](@warlock.js/ai-openai/skills/setup-openai/SKILL.md)'s `OpenAISDK`: it constructs an 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 pricing so the right flags are set even though the model names aren't OpenAI names. Pair with `@warlock.js/ai` for the agent / tool / system-prompt surface.
+
+## Construction
+
+```ts
+import { DeepSeekSDK } from "@warlock.js/ai-deepseek";
+
+const deepseek = new DeepSeekSDK({ apiKey: process.env.DEEPSEEK_API_KEY! });
+```
+
+`apiKey` is the only required field — `baseURL` defaults to `https://api.deepseek.com` (DeepSeek's OpenAI-compatible endpoint) and `provider` defaults to `"deepseek"`. Override `baseURL` only for a proxy/gateway, or `provider` to relabel the upstream:
+
+```ts
+new DeepSeekSDK({ apiKey, baseURL: "https://my-gateway/deepseek", provider: "deepseek-proxy" });
+```
+
+`DeepSeekSDK` is a class (like `OpenAISDK`) holding one long-lived wrapped client — construct once per account and reuse.
+
+## 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 })
+```
+
+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. |
+
+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. |
+
+**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
+```
+
+## Uses the OpenAI-compatible endpoint
+
+Everything on the wire — Chat Completions request/response shape, streaming loop, tool-call accumulation, structured-output `response_format`, multipart message mapping, and error wrapping — is inherited **unchanged** from `OpenAIModel`. See [`setup-openai`](@warlock.js/ai-openai/skills/setup-openai/SKILL.md) for the wire-level detail; it all applies here against `https://api.deepseek.com`.
+
+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"
+```
+
+## 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.
+
+## 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:
+
+```ts
+const deepseek = new DeepSeekSDK({ apiKey }); // deepseek-chat → { input: 0.14, output: 0.28, cachedInput: 0.0028 }
+```
+
+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`.
+
+```ts
+new DeepSeekSDK({ apiKey, pricing: { "deepseek-reasoner": { input: 0.55, output: 2.19 } } });
+```
+
+## Errors
+
+Raw errors surface through the wrapped OpenAI adapter's wrapper into the typed `@warlock.js/ai` `AIError` hierarchy — see [`@warlock.js/ai/handle-ai-errors/SKILL.md`](@warlock.js/ai/handle-ai-errors/SKILL.md).
+
+## When NOT to use this skill
+
+- OpenAI / Azure OpenAI / OpenRouter / local OpenAI-compatible gateways — use `@warlock.js/ai-openai`.
+- Anthropic — `@warlock.js/ai-anthropic`. Gemini — `@warlock.js/ai-google`. Ollama — `@warlock.js/ai-ollama`.
+- Calling the DeepSeek HTTP API or the raw `openai` SDK directly without going through `@warlock.js/ai` agents.
+
+## See also
+
+- [`@warlock.js/ai-openai/skills/setup-openai/SKILL.md`](@warlock.js/ai-openai/skills/setup-openai/SKILL.md) — the wrapped adapter; all wire-level behavior.
+- [`@warlock.js/ai/run-ai-agent/SKILL.md`](@warlock.js/ai/run-ai-agent/SKILL.md) — passing the model into `ai.agent({...})`.
+- [`@warlock.js/ai/pick-ai-provider/SKILL.md`](@warlock.js/ai/pick-ai-provider/SKILL.md) — adapter comparison.
+
+

package/llms.txt

@@ -0,0 +1,9 @@
+# Warlock AI Deepseek
+
+> Package: `@warlock.js/ai-deepseek`
+
+> DeepSeek adapter for @warlock.js/ai
+
+## 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 — `@warlock.js/ai/run-ai-agent/SKILL.md`; adapter comparison — `@warlock.js/ai/pick-ai-provider/SKILL.md`; raw deepseek HTTP / the `openai` SDK directly. Typical import `import { DeepSeekSDK } from "@warlock.js/ai-deepseek"`.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@warlock.js/ai-deepseek",
+  "description": "DeepSeek adapter for @warlock.js/ai",
+  "keywords": [
+    "warlock",
+    "ai",
+    "deepseek"
+  ],
+  "author": "Hasan Zohdy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/warlockjs/ai-deepseek"
+  },
+  "dependencies": {
+    "@warlock.js/ai-openai": "4.6.0",
+    "@warlock.js/logger": "4.6.0"
+  },
+  "peerDependencies": {
+    "@warlock.js/ai": "4.6.0"
+  },
+  "version": "4.6.0",
+  "main": "./cjs/index.cjs",
+  "module": "./esm/index.mjs",
+  "types": "./esm/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./esm/index.d.mts",
+        "default": "./esm/index.mjs"
+      },
+      "require": {
+        "types": "./esm/index.d.mts",
+        "default": "./cjs/index.cjs"
+      }
+    }
+  }
+}