@molecule/api-ai-deepseek 1.0.11 → 1.0.13

package/dist/provider.d.ts

@@ -3,7 +3,7 @@
  *
  * Uses the DeepSeek API (OpenAI-compatible) for streaming chat completions with
  * tool use and reasoning. DeepSeek's Chat Completions endpoint mirrors OpenAI's
- * wire format (tool_calls, reasoning_content, prompt_tokens_details.cached_tokens),
+ * wire format (tool_calls, reasoning_content, native and nested cache usage),
  * so this provider shares its shape with the xAI provider.
  *
  * @module
@@ -62,8 +62,20 @@ declare class DeepseekAIProviderImpl implements AIProvider {
      * Converts internal `ChatMessage` objects to the OpenAI-compatible message format.
      * System prompt is prepended as a system role message.
      *
+     * Thinking mode has one wire obligation that non-thinking mode does not:
+     * DeepSeek's thinking-mode guide requires the `reasoning_content` of every
+     * retained assistant turn to be sent back on a later request carrying `tools`,
+     * including turns where the model made no tool call — omitting it is a 400.
+     * So when `replayReasoning` is set (the caller passed a `thinking` block), each
+     * assistant turn carries `ChatMessage.reasoning` verbatim. That reasoning is
+     * never synthesized: a turn with no recorded reasoning sends `''`, which is
+     * the only representation of "this turn ran without thinking" the wire has.
+     * A non-thinking request keeps the historical shape (no `reasoning_content`);
+     * the guide says a non-thinking request ignores the field anyway.
+     *
      * @param messages - The chat messages to format.
      * @param system - Optional system prompt to prepend.
+     * @param replayReasoning - Whether thinking mode is on for this request.
      * @returns The formatted messages array for the DeepSeek API.
      */
     private formatMessages;
@@ -81,6 +93,15 @@ declare class DeepseekAIProviderImpl implements AIProvider {
      * @yields {ChatEvent} Chat events parsed from the response.
      */
     private parseNonStreamingResponse;
+    /**
+     * Normalize native usage once for streaming and JSON responses. Native flat
+     * counters take precedence, including zero; other compatible hosts may expose
+     * only the nested count. `inputTokens` excludes cache hits in the core contract.
+     *
+     * @param usage - The latest upstream counters.
+     * @returns Uncached input, output and cached input without double-counting.
+     */
+    private parseUsage;
     /**
      * Parses a streaming SSE response from the DeepSeek API (OpenAI-compatible
      * format), yielding `ChatEvent` objects as they arrive.

package/dist/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EACV,UAAU,EAIV,SAAS,EAET,UAAU,EAGX,MAAM,kBAAkB,CAAA;AASzB,OAAO,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAsGhD,8DAA8D;AAC9D,eAAO,MAAM,8BAA8B,QAAS,CAAA;AAgGpD;;;;GAIG;AACH,cAAM,sBAAuB,YAAW,UAAU;IAChD,QAAQ,CAAC,IAAI,cAAa;IAC1B,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,WAAW,CAAC,CAAqB;IACzC,OAAO,CAAC,aAAa,CAAC,CAAuB;IAC7C,OAAO,CAAC,mBAAmB,CAAQ;IACnC,OAAO,CAAC,sBAAsB,CAAQ;gBAE1B,MAAM,GAAE,cAAmB;IAwBvC;;;;;OAKG;IACI,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC;IAiRzD;;;;;;;;;OASG;YACW,2BAA2B;IA0EzC;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;IA2BzB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAgFtB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAWnB;;;;;OAKG;IACH,OAAO,CAAE,yBAAyB;IAuDlC;;;;;;;;;;;;OAYG;YACY,sBAAsB;IA2GrC;;;;;;;;;;OAUG;IACH,OAAO,CAAE,eAAe;CA0LzB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,+BAAyB,CAAA;AAExD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,UAAU,CAElE"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EACV,UAAU,EAIV,SAAS,EAET,UAAU,EAIX,MAAM,kBAAkB,CAAA;AASzB,OAAO,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAgHhD,8DAA8D;AAC9D,eAAO,MAAM,8BAA8B,QAAS,CAAA;AAgGpD;;;;GAIG;AACH,cAAM,sBAAuB,YAAW,UAAU;IAChD,QAAQ,CAAC,IAAI,cAAa;IAC1B,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,WAAW,CAAC,CAAqB;IACzC,OAAO,CAAC,aAAa,CAAC,CAAuB;IAC7C,OAAO,CAAC,mBAAmB,CAAQ;IACnC,OAAO,CAAC,sBAAsB,CAAQ;gBAE1B,MAAM,GAAE,cAAmB;IAwBvC;;;;;OAKG;IACI,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC;IAoRzD;;;;;;;;;OASG;YACW,2BAA2B;IA0EzC;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;IA2BzB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,cAAc;IA8FtB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAWnB;;;;;OAKG;IACH,OAAO,CAAE,yBAAyB;IA+ElC;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAUlB;;;;;;;;;;;;OAYG;YACY,sBAAsB;IA2GrC;;;;;;;;;;OAUG;IACH,OAAO,CAAE,eAAe;CAwOzB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,+BAAyB,CAAA;AAExD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,UAAU,CAElE"}

package/dist/provider.js

@@ -3,7 +3,7 @@
  *
  * Uses the DeepSeek API (OpenAI-compatible) for streaming chat completions with
  * tool use and reasoning. DeepSeek's Chat Completions endpoint mirrors OpenAI's
- * wire format (tool_calls, reasoning_content, prompt_tokens_details.cached_tokens),
+ * wire format (tool_calls, reasoning_content, native and nested cache usage),
  * so this provider shares its shape with the xAI provider.
  *
  * @module
@@ -17,9 +17,11 @@ const logger = getLogger();
 // (not through the package barrel).
 import './secrets.js';
 /**
- * Map thinking budget tokens to a DeepSeek reasoning_effort level. DeepSeek V4
- * accepts only `'high'` or `'max'` for `reasoning_effort`, so larger budgets map
- * to `'max'` and everything else to `'high'`.
+ * Map thinking budget tokens to a DeepSeek reasoning_effort level, used ONLY as
+ * a fallback when the caller supplies a budget without a resolved native level.
+ * The native API accepts `low`/`high`/`max`; a caller that resolved one of them
+ * (the catalog's `supportedEffortLevels`) sends it verbatim and never reaches
+ * this function, so the fallback stays the two coarse buckets.
  *
  * @param budgetTokens - Requested thinking budget in tokens.
  * @returns `'high'` or `'max'` for the upstream effort hint.
@@ -149,7 +151,7 @@ class DeepseekAIProviderImpl {
         const canonicalModel = params.model ?? this.defaultModel;
         const model = this.modelMap[canonicalModel] ?? canonicalModel;
         const maxTokens = params.maxTokens ?? this.maxTokens;
-        const messages = this.formatMessages(params.messages, params.system);
+        const messages = this.formatMessages(params.messages, params.system, Boolean(params.thinking));
         // Stop sequences, capped at the API's own limit. Verified honoured by the
         // native endpoint on 2026-10-17: with `stop: ['<analysis>']` a reply that
         // would have opened with that tag streamed nothing at all, and one that
@@ -188,10 +190,11 @@ class DeepseekAIProviderImpl {
             // weaker nudge still produces a turn, and the agent loop has its own
             // prose-only backstops, whereas a 400 produces nothing at all.
             //
-            // Latent rather than live at the time of writing — no DeepSeek model in
-            // the catalog sets supportsThinking — but the model-health cron adds
-            // models to that catalog unattended, and the one place forceToolUse fires
-            // is discovery mode, i.e. the FIRST turn of every new conversation.
+            // LIVE for an entry that exposes opt-in reasoning (deepseek-flash, whose
+            // effort levels include a local `off` switch): a project that uses
+            // low/high/max gets thinking mode on a discovery turn, and the forced
+            // nudge is degraded here instead of 400ing the first turn of the
+            // conversation.
             const forcedChoice = params.toolChoice === 'required' ||
                 (typeof params.toolChoice === 'object' && params.toolChoice?.type === 'tool');
             if (forcedChoice && params.thinking) {
@@ -206,15 +209,18 @@ class DeepseekAIProviderImpl {
                 body.tool_choice = { type: 'function', function: { name: params.toolChoice.name } };
             }
         }
-        // DeepSeek V4 defaults `thinking` to ENABLED. Thinking mode requires the
-        // assistant's reasoning_content to be echoed back on every subsequent turn
-        // (a 400 otherwise) and is awkward to combine with the tool-calling loop, so
-        // we run non-thinking unless a thinking budget is explicitly requested. The
-        // chat handler gates that on the model's `supportsThinking` flag.
+        // DeepSeek V4 defaults `thinking` to ENABLED. Per DeepSeek's thinking-mode
+        // guide (https://api-docs.deepseek.com/guides/thinking_mode/), a
+        // thinking-mode request that carries tools must send every retained
+        // assistant turn's `reasoning_content` back — including a turn where the
+        // model made no tool call — or the API answers 400. `formatMessages` replays
+        // `ChatMessage.reasoning` for exactly that reason. The catalog decides
+        // whether a turn carries a thinking block. No block explicitly disables
+        // reasoning below; a low/high/max block enables that native effort.
         if (params.thinking) {
             body.thinking = { type: 'enabled' };
-            // Prefer a caller-resolved native value ('high' | 'max') from the model
-            // catalog; fall back to the budget threshold.
+            // Prefer a caller-resolved native value (`low` | `high` | `max`) from the
+            // model catalog; fall back to the budget threshold.
             body.reasoning_effort = params.thinking.effort ?? budgetToEffort(params.thinking.budgetTokens);
         }
         else {
@@ -345,9 +351,8 @@ class DeepseekAIProviderImpl {
                     return;
                 }
                 const state = {
-                    inputTokens: 0,
-                    outputTokens: 0,
-                    cachedTokens: 0,
+                    finishReason: null,
+                    usage: {},
                     keepAlives: 0,
                     streamedChars: 0,
                     contentSeen: false,
@@ -518,11 +523,23 @@ class DeepseekAIProviderImpl {
      * Converts internal `ChatMessage` objects to the OpenAI-compatible message format.
      * System prompt is prepended as a system role message.
      *
+     * Thinking mode has one wire obligation that non-thinking mode does not:
+     * DeepSeek's thinking-mode guide requires the `reasoning_content` of every
+     * retained assistant turn to be sent back on a later request carrying `tools`,
+     * including turns where the model made no tool call — omitting it is a 400.
+     * So when `replayReasoning` is set (the caller passed a `thinking` block), each
+     * assistant turn carries `ChatMessage.reasoning` verbatim. That reasoning is
+     * never synthesized: a turn with no recorded reasoning sends `''`, which is
+     * the only representation of "this turn ran without thinking" the wire has.
+     * A non-thinking request keeps the historical shape (no `reasoning_content`);
+     * the guide says a non-thinking request ignores the field anyway.
+     *
      * @param messages - The chat messages to format.
      * @param system - Optional system prompt to prepend.
+     * @param replayReasoning - Whether thinking mode is on for this request.
      * @returns The formatted messages array for the DeepSeek API.
      */
-    formatMessages(messages, system) {
+    formatMessages(messages, system, replayReasoning = false) {
         const formatted = [];
         if (system) {
             formatted.push({ role: 'system', content: system });
@@ -530,8 +547,14 @@ class DeepseekAIProviderImpl {
         for (const m of messages) {
             if (m.role === 'system')
                 continue; // handled above
+            // Only assistant turns have a reasoning channel. `reasoning_content: ''`
+            // is deliberate for a retained turn with no recorded reasoning (a
+            // non-thinking turn inside a thinking-mode history): the vendor requires
+            // the field on every retained assistant turn, and an empty string is the
+            // only way to say "nothing was recorded" without inventing content.
+            const reasoningField = replayReasoning && m.role === 'assistant' ? { reasoning_content: m.reasoning ?? '' } : {};
             if (typeof m.content === 'string') {
-                formatted.push({ role: m.role, content: m.content });
+                formatted.push({ role: m.role, content: m.content, ...reasoningField });
                 continue;
             }
             // Content blocks — convert to OpenAI format
@@ -578,13 +601,14 @@ class DeepseekAIProviderImpl {
                 // screenshot tool) must not be dropped: Chat Completions accepts a user
                 // message after the tool messages, so emit them instead of losing them.
                 if (parts.length > 0)
-                    formatted.push({ role: m.role, content: parts });
+                    formatted.push({ role: m.role, content: parts, ...reasoningField });
             }
             else if (toolCalls.length > 0) {
                 // Assistant message with tool calls
                 formatted.push({
                     role: 'assistant',
                     content: parts.length > 0 ? parts : null,
+                    ...reasoningField,
                     tool_calls: toolCalls,
                 });
             }
@@ -592,6 +616,7 @@ class DeepseekAIProviderImpl {
                 formatted.push({
                     role: m.role,
                     content: parts.length === 1 && parts[0].type === 'text' ? parts[0].text : parts,
+                    ...reasoningField,
                 });
             }
         }
@@ -621,48 +646,90 @@ class DeepseekAIProviderImpl {
      */
     *parseNonStreamingResponse(data) {
         const choices = data.choices;
-        if (choices?.length) {
-            const message = choices[0].message;
-            if (message) {
-                // Reasoning/thinking content
-                if (message.reasoning_content && typeof message.reasoning_content === 'string') {
-                    yield { type: 'thinking', content: message.reasoning_content };
-                }
-                if (message.content && typeof message.content === 'string') {
-                    yield { type: 'text', content: message.content };
-                }
-                const toolCalls = message.tool_calls;
-                if (toolCalls) {
-                    for (const tc of toolCalls) {
-                        const fn = tc.function;
-                        let input = {};
-                        try {
-                            input = JSON.parse(fn.arguments);
-                        }
-                        catch (_error) {
-                            // JSON.parse failed — fall back to empty object; malformed args are non-fatal.
-                        }
-                        yield {
-                            type: 'tool_use',
-                            id: tc.id,
-                            name: fn.name,
-                            input,
-                        };
+        const choice = choices?.[0];
+        const message = choice?.message;
+        if (!message) {
+            logger.warn('DeepSeek response has no assistant message');
+            yield { type: 'error', message: t('ai.error.apiError'), errorKey: 'ai.error.apiError' };
+            return;
+        }
+        // Reasoning/thinking content
+        if (message.reasoning_content && typeof message.reasoning_content === 'string') {
+            yield { type: 'thinking', content: message.reasoning_content };
+        }
+        if (message.content && typeof message.content === 'string') {
+            yield { type: 'text', content: message.content };
+        }
+        const finishReason = choice?.finish_reason;
+        if (finishReason !== 'stop' && finishReason !== 'tool_calls') {
+            logger.warn('DeepSeek response did not complete', { finishReason });
+            yield {
+                type: 'error',
+                message: t('ai.error.apiError', undefined, {
+                    defaultValue: finishReason === 'length'
+                        ? 'AI response reached the output token limit before completion.'
+                        : 'AI response ended before completion. Please try again.',
+                }),
+                errorKey: 'ai.error.apiError',
+            };
+            return;
+        }
+        const toolCalls = message.tool_calls;
+        if (finishReason === 'tool_calls' && !toolCalls?.length) {
+            logger.warn('DeepSeek finished tool use without a tool call');
+            yield { type: 'error', message: t('ai.error.apiError'), errorKey: 'ai.error.apiError' };
+            return;
+        }
+        if (toolCalls) {
+            const completedTools = [];
+            for (const tc of toolCalls) {
+                const fn = tc.function;
+                let input;
+                try {
+                    input = JSON.parse(fn.arguments);
+                    if (typeof tc.id !== 'string' ||
+                        !tc.id ||
+                        typeof fn.name !== 'string' ||
+                        !fn.name ||
+                        !input ||
+                        typeof input !== 'object' ||
+                        Array.isArray(input)) {
+                        throw new Error('Tool call must have an identity and JSON object arguments');
                     }
                 }
+                catch (error) {
+                    logger.warn('DeepSeek completed a tool call with invalid arguments', { error });
+                    yield { type: 'error', message: t('ai.error.apiError'), errorKey: 'ai.error.apiError' };
+                    return;
+                }
+                completedTools.push({
+                    type: 'tool_use',
+                    id: tc.id,
+                    name: fn.name,
+                    input,
+                });
             }
+            yield* completedTools;
         }
-        const usage = data.usage;
-        const cached = usage?.prompt_tokens_details?.cached_tokens ?? 0;
         yield {
             type: 'done',
-            usage: {
-                // Report uncached input + cached separately (Anthropic semantics) so the
-                // consumer's context/cost math doesn't double-count the cached subset.
-                inputTokens: Math.max(0, (usage?.prompt_tokens ?? 0) - cached),
-                outputTokens: usage?.completion_tokens ?? 0,
-                cacheReadInputTokens: cached,
-            },
+            usage: this.parseUsage((data.usage ?? {})),
+        };
+    }
+    /**
+     * Normalize native usage once for streaming and JSON responses. Native flat
+     * counters take precedence, including zero; other compatible hosts may expose
+     * only the nested count. `inputTokens` excludes cache hits in the core contract.
+     *
+     * @param usage - The latest upstream counters.
+     * @returns Uncached input, output and cached input without double-counting.
+     */
+    parseUsage(usage) {
+        const cached = usage.prompt_cache_hit_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? 0;
+        return {
+            inputTokens: usage.prompt_cache_miss_tokens ?? Math.max(0, (usage.prompt_tokens ?? 0) - cached),
+            outputTokens: usage.completion_tokens ?? 0,
+            cacheReadInputTokens: cached,
         };
     }
     /**
@@ -747,19 +814,22 @@ class DeepseekAIProviderImpl {
                         return;
                 }
             }
-            // Emit any tool calls still pending after stream ends (safety net for missing finish_reason)
-            if (pendingTools.size > 0) {
-                for (const [, pending] of pendingTools) {
-                    let input = {};
-                    try {
-                        input = JSON.parse(pending.args);
-                    }
-                    catch (_error) {
-                        // JSON.parse failed — fall back to empty object; malformed args are non-fatal.
-                    }
-                    yield { type: 'tool_use', id: pending.id, name: pending.name, input };
-                }
-                pendingTools.clear();
+            // A clean socket EOF can still cut off a response or tool arguments. Never
+            // turn that into executable `{}` arguments or a successful completion.
+            if (!state.finishReason || pendingTools.size > 0) {
+                logger.warn('DeepSeek stream ended before an explicit completion', {
+                    finishReason: state.finishReason,
+                    pendingTools: pendingTools.size,
+                    requestId: call.meta.requestId,
+                });
+                yield {
+                    type: 'error',
+                    message: t('ai.error.apiError', undefined, {
+                        defaultValue: 'AI response ended before completion. Please try again.',
+                    }),
+                    errorKey: 'ai.error.apiError',
+                };
+                return;
             }
         }
         finally {
@@ -767,11 +837,7 @@ class DeepseekAIProviderImpl {
         }
         yield {
             type: 'done',
-            usage: {
-                inputTokens: Math.max(0, state.inputTokens - state.cachedTokens),
-                outputTokens: state.outputTokens,
-                cacheReadInputTokens: state.cachedTokens,
-            },
+            usage: this.parseUsage(state.usage),
             provider: call.meta,
         };
     }
@@ -871,20 +937,22 @@ class DeepseekAIProviderImpl {
                 // Usage info (may appear in the final chunk)
                 const usage = event.usage;
                 if (usage) {
-                    if (usage.prompt_tokens)
-                        state.inputTokens = usage.prompt_tokens;
-                    if (usage.completion_tokens)
-                        state.outputTokens = usage.completion_tokens;
-                    if (usage.prompt_tokens_details?.cached_tokens)
-                        state.cachedTokens = usage.prompt_tokens_details.cached_tokens;
+                    // These are snapshots, never increments. Preserve partial counters
+                    // across frames while allowing a later explicit zero to reset them.
+                    state.usage = {
+                        ...state.usage,
+                        ...usage,
+                        prompt_tokens_details: {
+                            ...state.usage.prompt_tokens_details,
+                            ...usage.prompt_tokens_details,
+                        },
+                    };
                 }
                 const choices = event.choices;
                 if (!choices?.length)
                     continue;
                 const choice = choices[0];
-                const delta = choice.delta;
-                if (!delta)
-                    continue;
+                const delta = (choice.delta ?? {});
                 // Reasoning/thinking content
                 if (delta.reasoning_content && typeof delta.reasoning_content === 'string') {
                     yield { type: 'thinking', content: delta.reasoning_content };
@@ -928,30 +996,74 @@ class DeepseekAIProviderImpl {
                         }
                     }
                 }
-                // finish_reason signals completion
+                // Only these upstream reasons denote a completed response. `length`
+                // is the output-token cap; filters/resource failures/aborts also retain
+                // partial text but must not release pending tools or emit `done`.
                 const finishReason = choice.finish_reason;
-                if (finishReason === 'tool_calls' || finishReason === 'stop') {
-                    // Emit any accumulated tool calls
+                if (finishReason !== undefined && finishReason !== null) {
+                    if (finishReason !== 'tool_calls' && finishReason !== 'stop') {
+                        logger.warn('DeepSeek response did not complete', {
+                            finishReason,
+                            requestId: call.meta.requestId,
+                        });
+                        yield {
+                            type: 'error',
+                            message: t('ai.error.apiError', undefined, {
+                                defaultValue: finishReason === 'length'
+                                    ? 'AI response reached the output token limit before completion.'
+                                    : 'AI response was interrupted before completion. Please try again.',
+                            }),
+                            errorKey: 'ai.error.apiError',
+                        };
+                        return;
+                    }
+                    // Validate ALL calls before releasing any: a malformed parallel call
+                    // must not execute alongside an apparently successful partial batch.
+                    if (finishReason === 'tool_calls' && pendingTools.size === 0) {
+                        logger.warn('DeepSeek finished tool use without a tool call');
+                        yield { type: 'error', message: t('ai.error.apiError'), errorKey: 'ai.error.apiError' };
+                        return;
+                    }
+                    const completedTools = [];
                     for (const [, pending] of pendingTools) {
-                        let input = {};
+                        let input;
                         try {
                             input = JSON.parse(pending.args);
+                            if (typeof pending.id !== 'string' ||
+                                !pending.id ||
+                                typeof pending.name !== 'string' ||
+                                !pending.name ||
+                                !input ||
+                                typeof input !== 'object' ||
+                                Array.isArray(input)) {
+                                throw new Error('Tool call must have an identity and JSON object arguments');
+                            }
                         }
-                        catch (_error) {
-                            // JSON.parse failed — fall back to empty object; malformed args are non-fatal.
+                        catch (error) {
+                            logger.warn('DeepSeek completed a tool call with invalid arguments', { error });
+                            yield {
+                                type: 'error',
+                                message: t('ai.error.apiError'),
+                                errorKey: 'ai.error.apiError',
+                            };
+                            return;
                         }
-                        yield {
+                        completedTools.push({
                             type: 'tool_use',
                             id: pending.id,
                             name: pending.name,
                             input,
-                        };
+                        });
                     }
                     pendingTools.clear();
+                    state.finishReason = finishReason;
+                    yield* completedTools;
                 }
             }
             catch (error) {
-                logger.debug('Skipping malformed SSE JSON line', { json, error });
+                logger.warn('DeepSeek returned malformed SSE JSON', { error });
+                yield { type: 'error', message: t('ai.error.apiError'), errorKey: 'ai.error.apiError' };
+                return;
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@molecule/api-ai-deepseek",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "DeepSeek AI provider for molecule.dev",
   "homepage": "https://www.molecule.dev/packages/api-ai-deepseek",
   "type": "module",
@@ -37,7 +37,7 @@
     "@molecule/api-bond": "1.0.2",
     "@types/node": "26.1.2",
     "typescript": "6.0.3",
-    "vitest": "4.1.11"
+    "vitest": "4.1.12"
   },
   "peerDependencies": {
     "@molecule/api-ai": "^1.0.1",