@molecule/api-ai-deepseek 1.0.12 → 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
@@ -93,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;AAwGhD,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;IAsRzD;;;;;;;;;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;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
@@ -191,7 +191,7 @@ class DeepseekAIProviderImpl {
             // prose-only backstops, whereas a 400 produces nothing at all.
             //
             // LIVE for an entry that exposes opt-in reasoning (deepseek-flash, whose
-            // effort levels include the local `off` default): a project that picks
+            // 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.
@@ -215,9 +215,8 @@ class DeepseekAIProviderImpl {
         // 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: deepseek-flash defaults to the
-        // local `off` level (no block → reasoning explicitly disabled below), and
-        // only a project that opts into low/high/max sends one.
+        // 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 (`low` | `high` | `max`) from the
@@ -352,9 +351,8 @@ class DeepseekAIProviderImpl {
                     return;
                 }
                 const state = {
-                    inputTokens: 0,
-                    outputTokens: 0,
-                    cachedTokens: 0,
+                    finishReason: null,
+                    usage: {},
                     keepAlives: 0,
                     streamedChars: 0,
                     contentSeen: false,
@@ -648,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,
         };
     }
     /**
@@ -774,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 {
@@ -794,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,
         };
     }
@@ -898,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 };
@@ -955,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.12",
+  "version": "1.0.13",
   "description": "DeepSeek AI provider for molecule.dev",
   "homepage": "https://www.molecule.dev/packages/api-ai-deepseek",
   "type": "module",