@namzu/deepseek 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# @namzu/deepseek
+
+## 0.1.0
+
+### Minor Changes
+
+- 7050dd4: Add `@namzu/deepseek`, and stop dropping reasoning when a stream is collected.
+
+  **A new driver, and a separate package on purpose.** DeepSeek's endpoint is OpenAI's Chat Completions shape, so pointing `@namzu/openai` at it with a `baseURL` looks like it should work. It does not, and the reason is thinking mode: it is **on by default**, the chain of thought comes back in a `reasoning_content` field that wire has no concept of, and the vendor requires that field replayed on every later turn once tool calls are in play. A driver that does not know about it drops the model's reasoning on every call.
+
+  `@namzu/deepseek` maps `ThinkingConfig` one-to-one onto the vendor's own `adaptive | enabled | disabled`, streams reasoning through `delta.reasoning` — the same channel `@namzu/anthropic` uses, so a host that renders one renders the other — and replays it automatically. Callers pass the assistant message back and the field goes with it.
+
+  It **refuses** two things the vendor accepts and applies to nothing: `effort` (this wire validates `thinking.type` and ignores any effort beside it) and the sampling parameters while thinking is on. Both were measured against the live API rather than read off the documentation. `samplingInThinkingMode: 'ignore'` opts out of the second.
+
+  It carries no price rows, deliberately: the vendor charges twice as much during peak UTC hours, and a static table has no hour in it.
+
+  **`collectChatCompletion` dropped reasoning blocks** (`@namzu/sdk`). `delta.reasoning` existed, `AssistantMessage.reasoning` is documented as replayed verbatim, and the run loop assembled it correctly — but this helper, which every non-streaming caller goes through, threw it away. So the same stream produced a message with reasoning through one route and without it through the other, and a vendor that needs the blocks back was sent a message that had lost them. It now buckets them by index exactly as the run loop does. This affects `@namzu/anthropic` users too.
+
+  **The CLI ships the driver** (`@namzu/cli`), so `namzu --provider deepseek` works on a fresh install with `DEEPSEEK_API_KEY` set. That is a fifth bundled driver and a slightly larger install.
+
+  Models are `deepseek-v4-flash` and `deepseek-v4-pro`. `deepseek-chat` and `deepseek-reasoner` were discontinued on 2026-07-24 and resolve to nothing.

package/LICENSE.md

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Cogitave
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+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,89 @@
+<!-- okf
+type: Reference
+title: "@namzu/deepseek"
+description: >-
+  The DeepSeek model driver for the Namzu agent kernel. Chat Completions with
+  streaming and tool use, and thinking mode mapped onto the kernel's reasoning
+  blocks in both directions.
+tags: [readme, package, provider, deepseek]
+timestamp: 2026-08-17T00:00:00Z
+status: active
+diataxis: reference
+-->
+
+<div align="center">
+
+<h1>@namzu/deepseek</h1>
+
+**The DeepSeek model driver for [Namzu](https://github.com/cogitave/namzu).**
+
+[![npm](https://img.shields.io/npm/v/@namzu/deepseek.svg)](https://www.npmjs.com/package/@namzu/deepseek)
+[![build](https://github.com/cogitave/namzu/actions/workflows/ci.yml/badge.svg)](https://github.com/cogitave/namzu/actions/workflows/ci.yml)
+[![license](https://img.shields.io/badge/license-FSL--1.1--MIT-blue.svg)](https://github.com/cogitave/namzu/blob/main/LICENSE.md)
+
+[Install](#install) · [Usage](#usage) · [Thinking mode](#thinking-mode) · [Documentation](#documentation)
+
+</div>
+
+---
+
+Implements the kernel's `LLMProvider` over DeepSeek's Chat Completions
+endpoint, which is OpenAI-shaped — and then diverges where it counts, which is
+why this is its own package rather than a `baseURL` on `@namzu/openai`.
+Installed only if you use it; the kernel has no preferred vendor.
+
+## Install
+
+```bash
+pnpm add @namzu/sdk @namzu/deepseek
+```
+
+`@namzu/sdk` is a peer dependency. Install both. Requires Node.js 20+.
+
+## Usage
+
+```ts
+import { ProviderRegistry } from '@namzu/sdk'
+import { registerDeepSeek } from '@namzu/deepseek'
+
+registerDeepSeek() // once, at startup
+
+const { provider } = ProviderRegistry.create({
+  type: 'deepseek',
+  apiKey: process.env.DEEPSEEK_API_KEY ?? '',
+  model: 'deepseek-v4-flash',
+})
+
+for await (const chunk of provider.chatStream({
+  model: 'deepseek-v4-flash',
+  messages: [{ role: 'user', content: 'Is 91 prime?' }],
+})) {
+  if (chunk.delta.reasoning?.text) process.stderr.write(chunk.delta.reasoning.text)
+  if (chunk.delta.content) process.stdout.write(chunk.delta.content)
+}
+```
+
+Models are `deepseek-v4-flash` and `deepseek-v4-pro`. `deepseek-chat` and
+`deepseek-reasoner` were discontinued on 2026-07-24 and are not aliases.
+
+## Thinking mode
+
+**Thinking is on by default** — the vendor's default, not this driver's. The
+chain of thought arrives as `delta.reasoning` fragments, the same channel
+`@namzu/anthropic` uses, and is replayed back to the vendor automatically on
+later turns, which its tool-calling flow requires.
+
+Turn it off per call with `thinking: { type: 'disabled' }`.
+
+Two parameters are **refused** rather than sent, because the vendor accepts
+them and applies neither: `effort`, and the sampling parameters while thinking
+is on. Both refusals, and how to opt out, are in the documentation below.
+
+## Documentation
+
+- [The DeepSeek driver](https://github.com/cogitave/namzu/blob/main/docs/providers/deepseek.md) — thinking mode, reasoning replay, what this wire refuses, and why it carries no price rows
+- [Namzu docs](https://github.com/cogitave/namzu/tree/main/docs)
+
+## License
+
+FSL-1.1-MIT, converting to MIT two years after each release.

package/dist/client.d.ts

@@ -0,0 +1,68 @@
+import type { ChatCompletionParams, LLMProvider, ModelInfo, ProviderCapabilities, StreamChunk, ThinkingConfig } from '@namzu/sdk';
+import type { ChatCompletionMessageParam, ChatCompletionTool } from 'openai/resources/chat/completions';
+import type { DeepSeekConfig } from './types.js';
+/**
+ * No vision, no documents.
+ *
+ * The wire is OpenAI's Chat Completions, which has `image_url` content parts —
+ * but the models behind this endpoint are text-only, and a capability set is a
+ * claim about what a call will actually do, not about what the request format
+ * can express. Claiming vision here would route an image-bearing run to a
+ * driver that sends the image and gets prose about nothing.
+ */
+export declare const DEEPSEEK_CAPABILITIES: ProviderCapabilities;
+/**
+ * Is thinking on for this call?
+ *
+ * **Absent means ON.** That is the vendor's default, not a guess: a request
+ * with no `thinking` key comes back carrying `reasoning_content`. Every rule
+ * below that turns on "thinking is enabled" has to read it this way, or it
+ * applies to explicit callers only and misses the common case entirely.
+ */
+export declare function thinkingEnabled(thinking: ThinkingConfig | undefined): boolean;
+/**
+ * Refuse a sampling parameter that thinking mode will discard.
+ *
+ * Measured against the live API on 2026-08-17 rather than read off the
+ * documentation, which says only that these are "not supported": all four are
+ * accepted with HTTP 200 and applied to nothing. So a caller who pinned
+ * `temperature: 0` for reproducibility gets sampling, no error, and no way to
+ * find out — `refuse-do-not-degrade`, exactly.
+ *
+ * `samplingInThinkingMode: 'ignore'` opts out, for a host that keeps one
+ * parameter set across several providers and would rather this one drop them
+ * quietly than make it special.
+ */
+export declare function assertSamplingUsable(params: ChatCompletionParams, mode: 'refuse' | 'ignore'): void;
+/**
+ * Refuse a reasoning effort this wire cannot carry.
+ *
+ * `thinking.effort` is accepted here and validated against nothing — measured:
+ * `effort: 'bogus'` returns 200, and `effort: 'none'` still produces reasoning
+ * tokens. Only `thinking.type` is validated (the vendor's own error names its
+ * variants: `adaptive`, `enabled`, `disabled`). So an effort sent on this wire
+ * is a parameter accepted and discarded, which is the one thing a driver must
+ * not do quietly.
+ *
+ * The vendor's Anthropic-format endpoint does take `reasoning.effort`. A
+ * driver built on that wire could honour this; this one is built on Chat
+ * Completions and says so.
+ */
+export declare function assertEffortUnsupported(params: ChatCompletionParams): void;
+export declare function toDeepSeekMessages(messages: ChatCompletionParams['messages']): ChatCompletionMessageParam[];
+export declare function toDeepSeekTools(params: ChatCompletionParams): ChatCompletionTool[] | undefined;
+export declare class DeepSeekProvider implements LLMProvider {
+    readonly id = "deepseek";
+    readonly name = "DeepSeek";
+    readonly capabilities: ProviderCapabilities;
+    private client;
+    private defaultModel?;
+    private samplingMode;
+    constructor(config: DeepSeekConfig);
+    private resolveModel;
+    chatStream(params: ChatCompletionParams): AsyncIterable<StreamChunk>;
+    probeCredential(): Promise<void>;
+    listModels(): Promise<ModelInfo[]>;
+    healthCheck(): Promise<boolean>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,oBAAoB,EAEpB,WAAW,EACX,SAAS,EACT,oBAAoB,EAEpB,WAAW,EACX,cAAc,EAGd,MAAM,YAAY,CAAA;AAUnB,OAAO,KAAK,EACX,0BAA0B,EAC1B,kBAAkB,EAElB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,oBAMnC,CAAA;AAuFD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,CAE7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GACvB,IAAI,CAQN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAK1E;AA0BD,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,oBAAoB,CAAC,UAAU,CAAC,GACxC,0BAA0B,EAAE,CAoC9B;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,oBAAoB,GAAG,kBAAkB,EAAE,GAAG,SAAS,CAe9F;AAED,qBAAa,gBAAiB,YAAW,WAAW;IACnD,QAAQ,CAAC,EAAE,cAAa;IACxB,QAAQ,CAAC,IAAI,cAAa;IAC1B,QAAQ,CAAC,YAAY,uBAAwB;IAE7C,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,YAAY,CAAC,CAAQ;IAC7B,OAAO,CAAC,YAAY,CAAqB;gBAE7B,MAAM,EAAE,cAAc;IAgBlC,OAAO,CAAC,YAAY;IAUb,UAAU,CAAC,MAAM,EAAE,oBAAoB,GAAG,aAAa,CAAC,WAAW,CAAC;IAiJrE,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhC,UAAU,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAYlC,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;CAQrC"}

package/dist/client.js

@@ -0,0 +1,380 @@
+import { ProviderRequestError, attributionHeaders, isCallerAbortError, isProviderRequestError, providerVendorError, toolResultToText, } from '@namzu/sdk';
+import OpenAI from 'openai';
+/**
+ * No vision, no documents.
+ *
+ * The wire is OpenAI's Chat Completions, which has `image_url` content parts —
+ * but the models behind this endpoint are text-only, and a capability set is a
+ * claim about what a call will actually do, not about what the request format
+ * can express. Claiming vision here would route an image-bearing run to a
+ * driver that sends the image and gets prose about nothing.
+ */
+export const DEEPSEEK_CAPABILITIES = {
+    supportsTools: true,
+    supportsStreaming: true,
+    supportsFunctionCalling: true,
+    supportsVision: false,
+    supportsDocuments: false,
+};
+const DEFAULT_BASE_URL = 'https://api.deepseek.com';
+function mapFinishReason(reason) {
+    switch (reason) {
+        case 'length':
+            return 'length';
+        case 'tool_calls':
+            return 'tool_calls';
+        case 'content_filter':
+            return 'content_filter';
+        default:
+            return 'stop';
+    }
+}
+function parseUsage(raw) {
+    if (!raw) {
+        return {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            cachedTokens: 0,
+            cacheWriteTokens: 0,
+        };
+    }
+    const promptTokens = raw.prompt_tokens ?? 0;
+    const completionTokens = raw.completion_tokens ?? 0;
+    const reasoningTokens = raw.completion_tokens_details?.reasoning_tokens;
+    return {
+        promptTokens,
+        completionTokens,
+        totalTokens: raw.total_tokens ?? promptTokens + completionTokens,
+        cachedTokens: raw.prompt_tokens_details?.cached_tokens ?? raw.prompt_cache_hit_tokens ?? 0,
+        // The vendor has no write-side cache charge: a cache entry is created as
+        // a side effect of a miss, at the ordinary input rate. Reporting a
+        // fabricated number here would be worse than the zero.
+        cacheWriteTokens: 0,
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+    };
+}
+function formatToolChoice(tc) {
+    if (tc === undefined)
+        return undefined;
+    if (tc === 'auto' || tc === 'none' || tc === 'required')
+        return tc;
+    if (typeof tc === 'object' && tc.type === 'function') {
+        return { type: 'function', function: { name: tc.function.name } };
+    }
+    return undefined;
+}
+/** The four the vendor accepts in thinking mode and applies none of. */
+const SAMPLING_FIELDS = ['temperature', 'topP', 'frequencyPenalty', 'presencePenalty'];
+/**
+ * Is thinking on for this call?
+ *
+ * **Absent means ON.** That is the vendor's default, not a guess: a request
+ * with no `thinking` key comes back carrying `reasoning_content`. Every rule
+ * below that turns on "thinking is enabled" has to read it this way, or it
+ * applies to explicit callers only and misses the common case entirely.
+ */
+export function thinkingEnabled(thinking) {
+    return thinking?.type !== 'disabled';
+}
+/**
+ * Refuse a sampling parameter that thinking mode will discard.
+ *
+ * Measured against the live API on 2026-08-17 rather than read off the
+ * documentation, which says only that these are "not supported": all four are
+ * accepted with HTTP 200 and applied to nothing. So a caller who pinned
+ * `temperature: 0` for reproducibility gets sampling, no error, and no way to
+ * find out — `refuse-do-not-degrade`, exactly.
+ *
+ * `samplingInThinkingMode: 'ignore'` opts out, for a host that keeps one
+ * parameter set across several providers and would rather this one drop them
+ * quietly than make it special.
+ */
+export function assertSamplingUsable(params, mode) {
+    if (mode === 'ignore')
+        return;
+    if (!thinkingEnabled(params.thinking))
+        return;
+    const set = SAMPLING_FIELDS.filter((f) => params[f] !== undefined);
+    if (set.length === 0)
+        return;
+    throw new Error(`DeepSeekProvider: ${set.join(', ')} ${set.length === 1 ? 'is' : 'are'} ignored in thinking mode, which is on for this call — the vendor accepts them and applies none of them, so the call would silently sample when you asked it not to. Disable thinking for this call (\`thinking: { type: 'disabled' }\`) to have them honoured, drop them, or set \`samplingInThinkingMode: 'ignore'\` on the provider to send them anyway.`);
+}
+/**
+ * Refuse a reasoning effort this wire cannot carry.
+ *
+ * `thinking.effort` is accepted here and validated against nothing — measured:
+ * `effort: 'bogus'` returns 200, and `effort: 'none'` still produces reasoning
+ * tokens. Only `thinking.type` is validated (the vendor's own error names its
+ * variants: `adaptive`, `enabled`, `disabled`). So an effort sent on this wire
+ * is a parameter accepted and discarded, which is the one thing a driver must
+ * not do quietly.
+ *
+ * The vendor's Anthropic-format endpoint does take `reasoning.effort`. A
+ * driver built on that wire could honour this; this one is built on Chat
+ * Completions and says so.
+ */
+export function assertEffortUnsupported(params) {
+    if (params.effort === undefined)
+        return;
+    throw new Error(`DeepSeekProvider: \`effort\` is not carried by this endpoint. The vendor's Chat Completions wire validates \`thinking.type\` and ignores any effort sent beside it, so passing one through would change nothing and report success. Use \`thinking: { type: 'adaptive' | 'enabled' | 'disabled' }\` to steer this driver.`);
+}
+/**
+ * The reasoning blocks an assistant message carries, in wire form.
+ *
+ * The vendor's rule: with tool calls in play, an assistant turn's
+ * `reasoning_content` **must** be replayed in every later turn of the same
+ * flow; without tool calls it is ignored if sent. Replayed unconditionally
+ * here, which satisfies both halves and matches what `AssistantMessage.reasoning`
+ * already promises — "replayed verbatim and ahead of the text/tool blocks".
+ *
+ * Measured note, because it matters to anyone debugging this: as of
+ * 2026-08-17 omitting the replay does NOT produce the documented 400 on either
+ * `deepseek-v4-flash` or `deepseek-v4-pro`. The rule is still followed, because
+ * a contract the vendor states and does not currently enforce is a contract
+ * that can start being enforced in any release.
+ */
+function replayReasoning(reasoning) {
+    if (!reasoning || reasoning.length === 0)
+        return undefined;
+    const text = reasoning
+        .filter((b) => b.type === 'thinking' && typeof b.text === 'string')
+        .map((b) => b.text)
+        .join('');
+    return text.length > 0 ? text : undefined;
+}
+export function toDeepSeekMessages(messages) {
+    return messages.map((msg) => {
+        if (msg.role === 'system')
+            return { role: 'system', content: msg.content };
+        if (msg.role === 'user') {
+            // No attachment branch, deliberately. `DEEPSEEK_CAPABILITIES` says
+            // this driver has neither vision nor documents, and a driver that
+            // quietly encoded an image the model cannot read would answer about
+            // a picture it never saw.
+            if (msg.attachments && msg.attachments.length > 0) {
+                throw new Error('DeepSeekProvider: this driver has no vision or document support, and a message carried attachments. Route multimodal turns to a provider whose capabilities include them.');
+            }
+            return { role: 'user', content: msg.content };
+        }
+        if (msg.role === 'tool') {
+            return {
+                role: 'tool',
+                content: toolResultToText(msg.content),
+                tool_call_id: msg.toolCallId,
+            };
+        }
+        const assistant = { role: 'assistant', content: msg.content };
+        if ('toolCalls' in msg && msg.toolCalls && msg.toolCalls.length > 0) {
+            ;
+            assistant.tool_calls = msg.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.function.name, arguments: tc.function.arguments },
+            }));
+        }
+        const replayed = replayReasoning(msg.reasoning);
+        if (replayed !== undefined) {
+            ;
+            assistant.reasoning_content = replayed;
+        }
+        return assistant;
+    });
+}
+export function toDeepSeekTools(params) {
+    if (!params.tools || params.tools.length === 0)
+        return undefined;
+    // No `strict` branch: `enforceToolInputSchema` names tools whose schema
+    // should be enforced rather than suggested, and this wire has no field for
+    // it. Setting `strict: true` here would be accepted and ignored — the same
+    // defect `assertEffortUnsupported` refuses above — so the flag is left to
+    // the kernel's own post-call Zod validation, which runs either way.
+    return params.tools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.function.name,
+            description: t.function.description ?? '',
+            parameters: (t.function.parameters ?? {}),
+        },
+    }));
+}
+export class DeepSeekProvider {
+    id = 'deepseek';
+    name = 'DeepSeek';
+    capabilities = DEEPSEEK_CAPABILITIES;
+    client;
+    defaultModel;
+    samplingMode;
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('DeepSeek API key is required. Set DEEPSEEK_API_KEY env variable.');
+        }
+        const clientOptions = {
+            apiKey: config.apiKey,
+            baseURL: config.baseURL ?? DEFAULT_BASE_URL,
+        };
+        if (config.timeout !== undefined)
+            clientOptions.timeout = config.timeout;
+        clientOptions.defaultHeaders = { ...attributionHeaders(), ...(config.defaultHeaders ?? {}) };
+        this.client = new OpenAI(clientOptions);
+        this.defaultModel = config.model;
+        this.samplingMode = config.samplingInThinkingMode ?? 'refuse';
+    }
+    resolveModel(params) {
+        const model = params.model || this.defaultModel;
+        if (!model) {
+            throw new Error('DeepSeekProvider: model is required. Pass `model` in config or on the chat call.');
+        }
+        return model;
+    }
+    async *chatStream(params) {
+        const model = this.resolveModel(params);
+        assertEffortUnsupported(params);
+        assertSamplingUsable(params, this.samplingMode);
+        const sampling = thinkingEnabled(params.thinking)
+            ? {}
+            : {
+                temperature: params.temperature,
+                top_p: params.topP,
+                frequency_penalty: params.frequencyPenalty,
+                presence_penalty: params.presencePenalty,
+            };
+        // Built as its own object so `stream: true` keeps its literal type and the
+        // SDK's streaming overload is the one selected. Casting the whole
+        // argument — the obvious way to smuggle `thinking` past a type that does
+        // not know about it — widens `stream` to `boolean` and the call resolves
+        // to the non-streaming overload, whose result has no async iterator.
+        const body = {
+            model,
+            messages: toDeepSeekMessages(params.messages),
+            stream: true,
+            stream_options: { include_usage: true },
+            tools: toDeepSeekTools(params),
+            tool_choice: formatToolChoice(params.toolChoice),
+            max_tokens: params.maxTokens,
+            stop: params.stop,
+            response_format: params.responseFormat,
+            ...sampling,
+        };
+        // Sent only when the caller said something. Absent means the vendor's own
+        // default, which is thinking ON — see `thinkingEnabled`. The three
+        // variants are the vendor's, and they are the same three the SDK's
+        // `ThinkingConfig` declares, so this is a rename and not a mapping.
+        //
+        // Cast back to `typeof body` rather than to the SDK's parameter type: the
+        // extra key rides along at runtime, and the literal `stream: true`
+        // survives, which is what keeps the streaming overload selected.
+        const withThinking = (params.thinking ? { ...body, thinking: { type: params.thinking.type } } : body);
+        let stream;
+        try {
+            stream = await this.client.chat.completions.create(withThinking, {
+                signal: params.signal,
+            });
+        }
+        catch (err) {
+            if (isCallerAbortError(err, params.signal))
+                throw params.signal?.reason ?? err;
+            if (isProviderRequestError(err))
+                throw err;
+            throw providerVendorError({ providerId: 'deepseek', error: err });
+        }
+        // One reasoning block per turn on this wire: the vendor streams
+        // `reasoning_content` as a flat run of deltas with no index and no
+        // block boundaries, so index 0 is the whole of it rather than a guess.
+        let reasoningOpen = false;
+        try {
+            for await (const chunk of stream) {
+                params.signal?.throwIfAborted();
+                try {
+                    const choice = chunk.choices[0];
+                    const delta = choice?.delta;
+                    const toolCalls = delta?.tool_calls?.map((tc) => ({
+                        index: tc.index,
+                        id: tc.id,
+                        type: tc.type,
+                        function: tc.function
+                            ? { name: tc.function.name, arguments: tc.function.arguments }
+                            : undefined,
+                    }));
+                    const reasoningText = delta?.reasoning_content;
+                    const finishReason = choice?.finish_reason
+                        ? mapFinishReason(choice.finish_reason)
+                        : undefined;
+                    const usage = chunk.usage ? parseUsage(chunk.usage) : undefined;
+                    if (reasoningText) {
+                        reasoningOpen = true;
+                        yield {
+                            id: chunk.id,
+                            delta: { reasoning: { index: 0, type: 'thinking', text: reasoningText } },
+                        };
+                    }
+                    // The block closes when content or a tool call starts, which is
+                    // the only boundary this wire gives. Without it a consumer's
+                    // reasoning pane never receives `done` and stays open for the
+                    // life of the run.
+                    const contentStarting = (delta?.content !== undefined && delta.content !== null) ||
+                        (toolCalls !== undefined && toolCalls.length > 0);
+                    if (reasoningOpen && contentStarting) {
+                        reasoningOpen = false;
+                        yield { id: chunk.id, delta: { reasoning: { index: 0, done: true } } };
+                    }
+                    const hasDelta = (delta?.content !== undefined && delta.content !== null) ||
+                        (toolCalls !== undefined && toolCalls.length > 0);
+                    if (!hasDelta && !finishReason && !usage)
+                        continue;
+                    yield {
+                        id: chunk.id,
+                        delta: { content: delta?.content ?? undefined, toolCalls },
+                        finishReason,
+                        usage,
+                    };
+                }
+                catch (parseErr) {
+                    if (isProviderRequestError(parseErr))
+                        throw parseErr;
+                    throw new ProviderRequestError({
+                        kind: 'server',
+                        providerId: 'deepseek',
+                        detail: 'the provider stream returned malformed data',
+                    });
+                }
+            }
+            // A turn that was all reasoning and no content — the model thought
+            // and then stopped — still has to close its block.
+            if (reasoningOpen) {
+                yield { id: 'deepseek-reasoning-close', delta: { reasoning: { index: 0, done: true } } };
+            }
+        }
+        catch (err) {
+            if (isCallerAbortError(err, params.signal))
+                throw params.signal?.reason ?? err;
+            if (isProviderRequestError(err))
+                throw err;
+            throw providerVendorError({ providerId: 'deepseek', error: err });
+        }
+    }
+    async probeCredential() {
+        await this.client.models.list();
+    }
+    async listModels() {
+        const page = await this.client.models.list();
+        return page.data.map((m) => ({
+            id: m.id,
+            name: m.id,
+            inputPrice: 0,
+            outputPrice: 0,
+            supportsToolUse: true,
+            supportsStreaming: true,
+        }));
+    }
+    async healthCheck() {
+        try {
+            await this.client.models.list();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=client.js.map