@deepstrike/sdk 0.1.14 → 0.1.16

package/dist/providers/qwen.js

@@ -5,16 +5,19 @@ import { OpenAIChatAdapter } from "./openai-chat.js";
 import { endpointProfiles } from "./profiles.js";
 const QWEN_BASE = endpointProfiles["qwen.dashscope"].baseURL;
 const QWEN_POLICIES = {
-    "qwen-max": { maxTurns: 25 },
-    "qwen-plus": { maxTurns: 20 },
-    "qwen-turbo": { maxTurns: 15 },
-    "qwq-plus": { maxTurns: 40 },
-    "qwq-32b": { maxTurns: 35 },
-    "qwen3-235b-a22b": { maxTurns: 35 },
-    "qwen3-72b": { maxTurns: 25 },
-    "qwen3-32b": { maxTurns: 20 },
-    "qwen3-14b": { maxTurns: 15 },
-    "qwen3-8b": { maxTurns: 15 },
+    "qwen3.7-max-preview": { maxTurns: 45 },
+    "qwen3.7-plus-preview": { maxTurns: 40 },
+    "qwen3.6-max-preview": { maxTurns: 40 },
+    "qwen3.6-plus": { maxTurns: 35 },
+    "qwen3.6-flash": { maxTurns: 20 },
+    "qwen3.6-35b-a3b": { maxTurns: 25 },
+    "qwen3.6-27b": { maxTurns: 25 },
+    "qwen3.5-plus": { maxTurns: 35 },
+    "qwen3.5-flash": { maxTurns: 20 },
+    "qwen3.5-397b-a17b": { maxTurns: 35 },
+    "qwen3.5-122b-a10b": { maxTurns: 25 },
+    "qwen3.5-35b-a3b": { maxTurns: 20 },
+    "qwen3.5-27b": { maxTurns: 20 },
 };
 export class QwenProvider {
     model;
@@ -23,7 +26,7 @@ export class QwenProvider {
     maxRetries;
     baseDelay;
     chat = new OpenAIChatAdapter();
-    constructor(apiKey, model = "qwen-max", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = QWEN_BASE) {
+    constructor(apiKey, model = "qwen3.6-plus", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = QWEN_BASE) {
         this.model = model;
         this.client = withServerRuntimeGuard(() => new OpenAI({ apiKey, baseURL }));
         this.circuit = new CircuitBreaker();
@@ -33,6 +36,17 @@ export class QwenProvider {
     runtimePolicy() {
         return QWEN_POLICIES[this.model] ?? {};
     }
+    peekProviderReplay(message) {
+        const fields = this.chat.peekReplayFields(message);
+        if (!fields || !("reasoning_content" in fields))
+            return undefined;
+        return { reasoning_content: String(fields.reasoning_content ?? "") };
+    }
+    seedProviderReplay(message, replay) {
+        if (replay.reasoning_content !== undefined) {
+            this.chat.rememberReplayFields(message, { reasoning_content: replay.reasoning_content });
+        }
+    }
     async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
@@ -66,6 +80,8 @@ export class QwenProvider {
         const msgs = this.chat.buildMessages(context);
         const toolCallBufs = {};
         const emittedToolCallIndexes = new Set();
+        let reasoningContent = "";
+        let finalText = "";
         const extraBody = this.thinkingExtraBody(extensions);
         const stream = await this.client.chat.completions.create({
             ...this.requestExtensions(extensions),
@@ -86,10 +102,14 @@ export class QwenProvider {
             if (!choice)
                 continue;
             const delta = choice.delta;
-            if (delta.reasoning_content)
+            if (delta.reasoning_content) {
+                reasoningContent += String(delta.reasoning_content);
                 yield { type: "thinking_delta", delta: delta.reasoning_content };
-            if (delta.content)
+            }
+            if (delta.content) {
+                finalText += String(delta.content);
                 yield { type: "text_delta", delta: delta.content };
+            }
             for (const tc of delta.tool_calls ?? []) {
                 const idx = tc.index;
                 if (!toolCallBufs[idx])
@@ -99,6 +119,10 @@ export class QwenProvider {
                 toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
             }
             if (choice.finish_reason === "tool_calls") {
+                const toolCalls = Object.values(toolCallBufs).map(tb => ({
+                    id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
+                }));
+                this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
                 for (const [index, tb] of Object.entries(toolCallBufs)) {
                     const idx = Number(index);
                     if (emittedToolCallIndexes.has(idx))
@@ -115,6 +139,12 @@ export class QwenProvider {
                 }
             }
         }
+        const toolCalls = Object.values(toolCallBufs).map(tb => ({
+            id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
+        }));
+        if (toolCalls.length || reasoningContent) {
+            this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
+        }
         for (const [index, tb] of Object.entries(toolCallBufs)) {
             const idx = Number(index);
             if (emittedToolCallIndexes.has(idx))

package/dist/runtime/provider-replay.d.ts

@@ -0,0 +1,7 @@
+import type { LLMProvider, Message, ProviderReplay, ToolCall } from "../types.js";
+import type { SessionEvent } from "./session-log.js";
+export declare function assistantReplayKey(message: Pick<Message, "content" | "toolCalls">): string;
+export declare function seedProviderReplayFromEvents(provider: LLMProvider, events: Array<{
+    event: SessionEvent;
+}>): void;
+export declare function peekProviderReplay(provider: LLMProvider, content: string, toolCalls: ToolCall[]): ProviderReplay | undefined;

package/dist/runtime/provider-replay.js

@@ -0,0 +1,47 @@
+function sortObjectKeys(val) {
+    if (val === null || typeof val !== "object") {
+        return val;
+    }
+    if (Array.isArray(val)) {
+        return val.map(sortObjectKeys);
+    }
+    const sortedKeys = Object.keys(val).sort();
+    const result = {};
+    for (const key of sortedKeys) {
+        result[key] = sortObjectKeys(val[key]);
+    }
+    return result;
+}
+export function assistantReplayKey(message) {
+    const toolCalls = (message.toolCalls ?? []).map(tc => {
+        let normalizedArgs = tc.arguments;
+        try {
+            const parsed = typeof tc.arguments === "string" ? JSON.parse(tc.arguments) : tc.arguments;
+            normalizedArgs = JSON.stringify(sortObjectKeys(parsed));
+        }
+        catch {
+            // fallback
+        }
+        return {
+            id: tc.id,
+            name: tc.name,
+            arguments: normalizedArgs,
+        };
+    });
+    return JSON.stringify({
+        content: message.content,
+        toolCalls,
+    });
+}
+export function seedProviderReplayFromEvents(provider, events) {
+    if (!provider.seedProviderReplay)
+        return;
+    for (const { event } of events) {
+        if (event.kind !== "llm_completed" || !event.provider_replay)
+            continue;
+        provider.seedProviderReplay({ content: event.content, toolCalls: event.tool_calls ?? [] }, event.provider_replay);
+    }
+}
+export function peekProviderReplay(provider, content, toolCalls) {
+    return provider.peekProviderReplay?.({ content, toolCalls });
+}

package/dist/runtime/runner.js

@@ -1,4 +1,5 @@
 import { getKernel } from "../kernel.js";
+import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
 export class RuntimeRunner {
     opts;
     interrupted = false;
@@ -128,6 +129,7 @@ export class RuntimeRunner {
         if (this.opts.knowledgeSource)
             sm.setKnowledgeEnabled(true);
         if (priorEvents && priorEvents.length > 0) {
+            seedProviderReplayFromEvents(this.opts.provider, priorEvents);
             sm.preloadHistory(replayMessages(priorEvents));
         }
         const sessionStart = Date.now();
@@ -202,12 +204,14 @@ export class RuntimeRunner {
                     toolCalls: finalToolCalls,
                     tokenCount: turnTokens || undefined,
                 });
+                const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
                 await this.opts.sessionLog.append(sessionId, {
                     kind: "llm_completed",
                     turn: sm.turn,
                     content: finalText,
                     token_count: turnTokens || undefined,
                     tool_calls: finalToolCalls,
+                    ...(providerReplay ? { provider_replay: providerReplay } : {}),
                 });
             }
             else if (action.kind === "execute_tools") {

package/dist/runtime/session-log.d.ts

@@ -1,4 +1,4 @@
-import type { ToolCall } from "../types.js";
+import type { ProviderReplay, ToolCall } from "../types.js";
 export type SessionEvent = {
     kind: "run_started";
     run_id: string;
@@ -12,6 +12,7 @@ export type SessionEvent = {
     content: string;
     token_count?: number;
     tool_calls: ToolCall[];
+    provider_replay?: ProviderReplay;
 } | {
     kind: "tool_requested";
     turn: number;

package/dist/types.d.ts

@@ -152,6 +152,13 @@ export interface RetryConfig {
  * Responses `previous_response_id` without leaking those semantics into the kernel.
  */
 export type ProviderRunState = Record<string, unknown>;
+/** Provider-native fields required to replay a turn across requests (thinking blocks, reasoning_content, etc.). */
+export interface ProviderReplay {
+    /** Anthropic-style assistant content blocks (thinking, text, tool_use). */
+    native_blocks?: Array<Record<string, unknown>>;
+    /** OpenAI-compatible reasoning field (DeepSeek, etc.). */
+    reasoning_content?: string;
+}
 /** Structured render output produced by the kernel for each LLM call. */
 export interface RenderedContext {
     /** Combined system text: system partition + dashboard (when non-empty).
@@ -180,6 +187,10 @@ export interface LLMProvider {
      * maxTurns / timeoutMs in RuntimeOptions.
      */
     runtimePolicy?(): RuntimePolicy;
+    /** Read provider-native replay fields captured after the most recent assistant turn. */
+    peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
+    /** Restore provider-native replay fields when rebuilding history from SessionLog. */
+    seedProviderReplay?(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.1.14",
+    "@deepstrike/core": "0.1.16",
     "@google/generative-ai": "^0.24.1",
     "openai": "^4.77.0"
   },