@jsonstudio/llms 0.6.3539 → 0.6.3541

package/dist/conversion/compat/actions/deepseek-web-response.js

@@ -1,6 +1,7 @@
 import { buildNativeReqOutboundCompatAdapterContext } from '../../hub/pipeline/compat/native-adapter-context.js';
 import { loadNativeRouterHotpathBindingForInternalUse } from '../../../router/virtual-router/engine-selection/native-router-hotpath.js';
 import { isNativeDisabledByEnv, makeNativeRequiredError } from '../../../router/virtual-router/engine-selection/native-router-hotpath-policy.js';
+import { providerErrorCenter } from '../../../router/virtual-router/error-center.js';
 const CAPABILITY = 'runRespInboundStage3CompatJson';
 const PROFILE = 'chat:deepseek-web';
 const DEFAULT_PROVIDER_PROTOCOL = 'openai-chat';
@@ -28,6 +29,44 @@ const readToolProtocol = (value) => {
     const normalized = value.trim().toLowerCase();
     return normalized === 'native' || normalized === 'text' ? normalized : undefined;
 };
+function buildRuntimeMetadata(adapterContext, payload, details) {
+    const contextRecord = adapterContext && typeof adapterContext === 'object'
+        ? adapterContext
+        : undefined;
+    const runtime = {};
+    const assignString = (key, value) => {
+        if (typeof value === 'string' && value.trim()) {
+            runtime[key] = value.trim();
+        }
+    };
+    assignString('requestId', contextRecord?.requestId);
+    assignString('providerProtocol', contextRecord?.providerProtocol);
+    assignString('providerId', contextRecord?.providerId);
+    assignString('providerKey', contextRecord?.providerKey);
+    assignString('runtimeKey', contextRecord?.runtimeKey);
+    assignString('routeName', contextRecord?.routeId);
+    assignString('pipelineId', PROFILE);
+    if (payload && typeof payload === 'object') {
+        assignString('target', payload.model);
+    }
+    if (details && Object.keys(details).length > 0) {
+        runtime.details = details;
+    }
+    return runtime;
+}
+function emitCompatError(error, adapterContext, payload, details) {
+    providerErrorCenter.emit({
+        code: 'DEEPSEEK_WEB_COMPAT_ERROR',
+        message: error.message,
+        stage: 'compat:deepseek-web-response',
+        runtime: buildRuntimeMetadata(adapterContext, payload, details),
+        details: {
+            compatibilityProfile: PROFILE,
+            ...(details ?? {})
+        }
+    });
+    throw error;
+}
 function resolveDeepseekNode(adapterContext, config) {
     const nativeContext = buildNativeReqOutboundCompatAdapterContext(adapterContext);
     const baseNode = isRecord(nativeContext.deepseek) ? nativeContext.deepseek : {};
@@ -72,31 +111,49 @@ function parseCompatOutput(raw) {
     }
     return parsed;
 }
-function callDeepSeekWebResponseCompat(input) {
+function callDeepSeekWebResponseCompat(input, adapterContext) {
     if (isNativeDisabledByEnv()) {
-        throw makeNativeRequiredError(CAPABILITY, 'native disabled');
+        emitCompatError(makeNativeRequiredError(CAPABILITY, 'native disabled'), adapterContext, input.payload, {
+            reason: 'native disabled'
+        });
     }
     const binding = loadNativeRouterHotpathBindingForInternalUse();
     const fn = binding?.[CAPABILITY];
     if (typeof fn !== 'function') {
-        throw makeNativeRequiredError(CAPABILITY);
+        emitCompatError(makeNativeRequiredError(CAPABILITY), adapterContext, input.payload, {
+            reason: 'missing native export'
+        });
     }
     let inputJson;
     try {
         inputJson = JSON.stringify(input);
     }
     catch {
-        throw makeNativeRequiredError(CAPABILITY, 'json stringify failed');
+        emitCompatError(makeNativeRequiredError(CAPABILITY, 'json stringify failed'), adapterContext, input.payload, {
+            reason: 'json stringify failed'
+        });
+    }
+    try {
+        const raw = fn(inputJson);
+        if (typeof raw !== 'string' || !raw) {
+            emitCompatError(makeNativeRequiredError(CAPABILITY, 'empty result'), adapterContext, input.payload, {
+                reason: 'empty result'
+            });
+        }
+        return parseCompatOutput(raw);
     }
-    const raw = fn(inputJson);
-    if (typeof raw !== 'string' || !raw) {
-        throw makeNativeRequiredError(CAPABILITY, 'empty result');
+    catch (error) {
+        const compatError = error instanceof Error ? error : new Error(String(error));
+        emitCompatError(compatError, adapterContext, input.payload, {
+            reason: 'native compat execution failed'
+        });
     }
-    return parseCompatOutput(raw);
 }
 export function applyDeepSeekWebResponseTransform(payload, adapterContext, config) {
     if (!payload || typeof payload !== 'object') {
-        return payload;
+        emitCompatError(new Error('[deepseek-web] invalid compat payload: expected object'), adapterContext, payload, {
+            reason: 'payload is not an object'
+        });
     }
-    return callDeepSeekWebResponseCompat(buildCompatInput(payload, adapterContext, config)).payload;
+    return callDeepSeekWebResponseCompat(buildCompatInput(payload, adapterContext, config), adapterContext).payload;
 }

package/dist/quota/quota-state.js

@@ -1,6 +1,7 @@
 const COOLDOWN_SCHEDULE_429_MS = [3_000, 10_000, 31_000, 61_000];
 const COOLDOWN_SCHEDULE_FATAL_MS = [3_000, 10_000, 31_000, 61_000];
 const COOLDOWN_SCHEDULE_DEFAULT_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS = [3_000, 5_000, 10_000, 31_000];
 const ERROR_CHAIN_WINDOW_MS = 10 * 60_000;
 const NETWORK_ERROR_CODES = [
     'ECONNRESET',
@@ -84,10 +85,26 @@ function computeCooldownMsBySeries(series, consecutive) {
     const idx = Math.min(consecutive - 1, schedule.length - 1);
     return schedule[idx] ?? null;
 }
+function shouldKeepProviderInPoolDuringCooldown(series, consecutive) {
+    if (consecutive <= 0) {
+        return false;
+    }
+    return (series === 'ENET' || series === 'E5XX' || series === 'EOTHER') && consecutive <= 2;
+}
+function shouldAccumulateBySeries(series) {
+    return series === 'ENET' || series === 'E5XX' || series === 'EOTHER';
+}
+function computeTransientKeepPoolCooldownMs(series, consecutive) {
+    if (!shouldKeepProviderInPoolDuringCooldown(series, consecutive)) {
+        return null;
+    }
+    const idx = Math.min(consecutive - 1, COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS.length - 1);
+    return COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS[idx] ?? null;
+}
 export function tickQuotaStateTime(state, nowMs) {
     let next = state;
     if (typeof next.cooldownUntil === 'number' && next.cooldownUntil <= nowMs) {
-        next = { ...next, cooldownUntil: null };
+        next = { ...next, cooldownUntil: null, cooldownKeepsPool: undefined };
     }
     if (typeof next.blacklistUntil === 'number' && next.blacklistUntil <= nowMs) {
         next = { ...next, blacklistUntil: null };
@@ -107,14 +124,15 @@ export function tickQuotaStateTime(state, nowMs) {
         return next;
     }
     if (inCooldown) {
-        if (next.inPool !== false || next.reason !== 'cooldown') {
-            next = { ...next, inPool: false, reason: 'cooldown' };
+        const keepInPool = next.cooldownKeepsPool === true;
+        if (next.inPool !== keepInPool || next.reason !== 'cooldown') {
+            next = { ...next, inPool: keepInPool, reason: 'cooldown' };
         }
         return next;
     }
     // TTLs expired: only auto-reset "cooldown/blacklist" back to ok.
     if (next.reason === 'cooldown' || next.reason === 'blacklist') {
-        next = { ...next, inPool: true, reason: 'ok' };
+        next = { ...next, inPool: true, reason: 'ok', cooldownKeepsPool: undefined };
     }
     return next;
 }
@@ -131,7 +149,9 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
     const withinChainWindow = typeof lastAt === 'number' &&
         nowMs - lastAt >= 0 &&
         nowMs - lastAt <= ERROR_CHAIN_WINDOW_MS;
-    const sameErrorKey = withinChainWindow && state.lastErrorCode === errorKey;
+    const sameErrorKey = withinChainWindow &&
+        (state.lastErrorCode === errorKey ||
+            (shouldAccumulateBySeries(series) && state.lastErrorSeries === series));
     const schedule = series === 'E429'
         ? COOLDOWN_SCHEDULE_429_MS
         : series === 'EFATAL'
@@ -139,7 +159,7 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
             : COOLDOWN_SCHEDULE_DEFAULT_MS;
     const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
     const nextCount = rawNextCount > schedule.length ? 1 : rawNextCount;
-    const cooldownMs = computeCooldownMsBySeries(series, nextCount);
+    const cooldownMs = computeTransientKeepPoolCooldownMs(series, nextCount) ?? computeCooldownMsBySeries(series, nextCount);
     const nextUntil = cooldownMs ? nowMs + cooldownMs : null;
     const existingUntil = typeof state.cooldownUntil === 'number' ? state.cooldownUntil : null;
     const cooldownUntil = typeof nextUntil === 'number' && Number.isFinite(nextUntil)
@@ -149,12 +169,14 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
         : existingUntil;
     const inCooldown = typeof cooldownUntil === 'number' && cooldownUntil > nowMs;
     const inBlacklist = typeof state.blacklistUntil === 'number' && state.blacklistUntil > nowMs;
-    const inPool = !inCooldown && !inBlacklist;
+    const cooldownKeepsPool = shouldKeepProviderInPoolDuringCooldown(series, nextCount);
+    const inPool = !inBlacklist && (!inCooldown || cooldownKeepsPool);
     return {
         ...state,
         inPool,
         reason: inBlacklist ? 'blacklist' : inCooldown ? 'cooldown' : 'ok',
         cooldownUntil,
+        cooldownKeepsPool: inCooldown ? cooldownKeepsPool : undefined,
         lastErrorSeries: series,
         lastErrorCode: errorKey,
         lastErrorAtMs: nowMs,

package/dist/quota/types.d.ts

@@ -26,6 +26,7 @@ export interface QuotaState {
     authIssue?: QuotaAuthIssue;
     priorityTier: number;
     cooldownUntil: number | null;
+    cooldownKeepsPool?: boolean;
     blacklistUntil: number | null;
     lastErrorSeries: ErrorSeries | null;
     lastErrorCode: string | null;

package/dist/servertool/handlers/followup-request-builder.js

@@ -1,4 +1,5 @@
 import { buildChatRequestFromResponses, captureResponsesContext } from '../../conversion/responses/responses-openai-bridge.js';
+import { stripHistoricalImageAttachments } from '../../conversion/hub/process/chat-process-media.js';
 import { cloneJson } from '../server-side-tools.js';
 import { trimOpenAiMessagesForFollowup } from './followup-message-trimmer.js';
 function extractResponsesTopLevelParameters(record) {
@@ -74,9 +75,13 @@ export function normalizeFollowupParameters(value) {
         return undefined;
     }
     const cloned = cloneJson(value);
-    // Followup requests are always non-streaming (servertool orchestration enforces this),
-    // so remove any inherited stream hints to avoid conflicting flags.
+    // Followup requests are always re-entered as a fresh hop:
+    // - non-streaming (servertool orchestration enforces this)
+    // - no inherited tool-selection hints, otherwise the resumed turn can be biased toward
+    //   immediately calling tools again instead of consuming the tool outputs that were just injected.
+    // Keep `parallel_tool_calls` inherited; provider compat can still disable it selectively.
     delete cloned.stream;
+    delete cloned.tool_choice;
     return Object.keys(cloned).length ? cloned : undefined;
 }
 export function dropToolByFunctionName(tools, dropName) {
@@ -418,6 +423,11 @@ export function buildServerToolFollowupChatPayloadFromInjection(args) {
         return null;
     }
     let messages = Array.isArray(seed.messages) ? cloneJson(seed.messages) : [];
+    // ServerTool followups must enter marker/routing/chat-process analysis with the same
+    // historical-media invariants as normal chat-process requests:
+    // only the latest live user turn may keep inline image payloads; earlier user turns
+    // are scrubbed to placeholders before any followup ops append new assistant/user items.
+    messages = stripHistoricalImageAttachments(messages);
     const ops = Array.isArray(args.injection?.ops) ? args.injection.ops : [];
     // Followup is a normal request hop: inherit tool schema from the captured request and
     // let compat/tool-governance apply standard sanitization rules.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.3539",
+  "version": "0.6.3541",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",