@jsonstudio/llms 0.6.631 → 0.6.743

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -1,4 +1,5 @@
 import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pipeline.js';
+import { normalizeApplyPatchToolCallsOnResponse } from '../../../../../shared/tool-governor.js';
 import { ToolGovernanceEngine } from '../../../../tool-governance/index.js';
 import { recordStage } from '../../../stages/utils.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
@@ -8,11 +9,12 @@ export async function runRespProcessStage1ToolGovernance(options) {
         requestId: options.requestId,
         profile: 'openai-chat'
     });
-    const { payload: governed, summary } = toolGovernanceEngine.governResponse(filtered, options.clientProtocol);
+    const patched = normalizeApplyPatchToolCallsOnResponse(filtered);
+    const { payload: governed, summary } = toolGovernanceEngine.governResponse(patched, options.clientProtocol);
     recordStage(options.stageRecorder, 'resp_process_stage1_tool_governance', {
         summary,
         applied: summary?.applied,
-        filteredPayload: filtered,
+        filteredPayload: patched,
         governedPayload: governed
     });
     return { governedPayload: governed };

package/dist/conversion/hub/process/chat-process.js

@@ -1,6 +1,7 @@
 import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
 import { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
+import { normalizeApplyPatchToolCallsOnRequest } from '../../shared/tool-governor.js';
 import { isJsonObject } from '../types/json.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
@@ -79,6 +80,7 @@ async function applyRequestToolGovernance(request, context) {
         ...merged,
         messages: stripHistoricalImageAttachments(merged.messages)
     };
+    merged = normalizeApplyPatchToolCallsOnRequest(merged);
     if (containsImageAttachment(merged.messages)) {
         if (!merged.metadata) {
             merged.metadata = {

package/dist/conversion/hub/response/provider-response.js

@@ -85,7 +85,12 @@ function resolveChatReasoningMode(_entryEndpoint) {
 export async function convertProviderResponse(options) {
     const clientProtocol = resolveClientProtocol(options.entryEndpoint);
     const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline);
-    const skipServerTools = isServerToolFollowup(options.context) || !hasServerToolSupport;
+    // 是否跳过 ServerTool 编排：
+    // - 仅在当前 Provider 完全不支持 ServerTool（没有 invoker/reenterPipeline）时跳过；
+    // - 对于 serverToolFollowup=true 的二/三跳请求，也允许再次进入 ServerTool 流程，
+    //   由具体 handler（例如 gemini_empty_reply_continue / iflow_model_error_retry 等）
+    //   自行通过 serverToolFollowup 标记决定是否生效。
+    const skipServerTools = !hasServerToolSupport;
     // 对于由 server-side 工具触发的内部跳转（二跳/三跳），统一禁用 SSE 聚合输出，
     // 始终返回完整的 ChatCompletion JSON，便于在 llms 内部直接解析，而不是拿到
     // __sse_responses 可读流。

package/dist/conversion/hub/snapshot-recorder.js

@@ -5,9 +5,16 @@ export class SnapshotStageRecorder {
     writer;
     constructor(options) {
         this.options = options;
+        const contextAny = options.context;
         this.writer = createSnapshotWriter({
             requestId: options.context.requestId,
-            endpoint: options.endpoint
+            endpoint: options.endpoint,
+            providerKey: typeof options.context.providerId === 'string' ? options.context.providerId : undefined,
+            groupRequestId: typeof contextAny.clientRequestId === 'string'
+                ? contextAny.clientRequestId
+                : typeof contextAny.groupRequestId === 'string'
+                    ? contextAny.groupRequestId
+                    : undefined
         });
     }
     record(stage, payload) {

package/dist/conversion/pipeline/codecs/v2/shared/openai-chat-helpers.js

@@ -43,13 +43,6 @@ export async function canonicalizeOpenAIChatResponse(payload, context, options)
     };
     const engine = new FilterEngine();
     engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
-    try {
-        const { ResponseToolArgumentsToonDecodeFilter } = await import('../../../../../filters/index.js');
-        engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter());
-    }
-    catch {
-        // optional decode filter
-    }
     engine.registerFilter(new ResponseToolArgumentsStringifyFilter());
     engine.registerFilter(new ResponseFinishInvariantsFilter());
     const stage1 = await engine.run('response_pre', dto.data, filterContext);

package/dist/conversion/responses/responses-openai-bridge.js

@@ -154,6 +154,46 @@ function normalizeBridgeHistory(seed) {
         originalSystemMessages: systemMessages
     };
 }
+function stripRoutingTagsFromText(text) {
+    if (typeof text !== 'string') {
+        return typeof text === 'string' ? text : String(text ?? '');
+    }
+    // 移除形如 <** ... **> 的路由指令标记（例如 stopMessage/!provider 等），
+    // 避免泄露到上游 provider 或持久化的 Responses 历史中。
+    return text.replace(/<\*\*[^*]+\*\*>/g, '').trim();
+}
+function sanitizeBridgeHistory(history) {
+    if (!history || typeof history !== 'object') {
+        return history;
+    }
+    if (Array.isArray(history.input)) {
+        for (const entry of history.input) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const blocks = entry.content;
+            if (!Array.isArray(blocks))
+                continue;
+            for (const block of blocks) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const record = block;
+                if (typeof record.text === 'string') {
+                    record.text = stripRoutingTagsFromText(record.text);
+                }
+            }
+        }
+    }
+    if (typeof history.combinedSystemInstruction === 'string') {
+        history.combinedSystemInstruction = stripRoutingTagsFromText(history.combinedSystemInstruction);
+    }
+    if (typeof history.latestUserInstruction === 'string') {
+        history.latestUserInstruction = stripRoutingTagsFromText(history.latestUserInstruction);
+    }
+    if (Array.isArray(history.originalSystemMessages)) {
+        history.originalSystemMessages = history.originalSystemMessages.map((msg) => stripRoutingTagsFromText(msg));
+    }
+    return history;
+}
 function mergeResponsesTools(originalTools, fromChat) {
     const result = [];
     const byKey = new Map();
@@ -296,16 +336,16 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
             combinedSystemInstruction: ctx.systemInstruction
         }
         : undefined;
-    const historySeed = normalizeBridgeHistory(extras?.bridgeHistory) ??
-        normalizeBridgeHistory(fallbackHistory) ??
-        normalizeBridgeHistory(bridgeMetadata?.bridgeHistory) ??
-        normalizeBridgeHistory(envelopeMetadata?.bridgeHistory) ??
-        fallbackHistory;
+    const historySeed = sanitizeBridgeHistory(normalizeBridgeHistory(extras?.bridgeHistory)) ??
+        sanitizeBridgeHistory(normalizeBridgeHistory(fallbackHistory)) ??
+        sanitizeBridgeHistory(normalizeBridgeHistory(bridgeMetadata?.bridgeHistory)) ??
+        sanitizeBridgeHistory(normalizeBridgeHistory(envelopeMetadata?.bridgeHistory)) ??
+        sanitizeBridgeHistory(fallbackHistory);
     const history = historySeed ??
-        convertMessagesToBridgeInput({
+        sanitizeBridgeHistory(convertMessagesToBridgeInput({
             messages,
             tools: Array.isArray(out.tools) ? out.tools : undefined
-        });
+        }));
     const callIdTransformer = createToolCallIdTransformer(toolCallIdStyle);
     if (callIdTransformer) {
         enforceToolCallIdStyle(history.input, callIdTransformer);

package/dist/conversion/shared/compaction-detect.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from '../hub/types/json.js';
+export declare function isCompactionRequest(payload: JsonObject): boolean;

package/dist/conversion/shared/compaction-detect.js

@@ -0,0 +1,53 @@
+function hasCompactionMarker(value) {
+    const lower = value.toLowerCase();
+    return (lower.includes('context checkpoint compaction') ||
+        lower.includes('checkpoint compaction') ||
+        lower.includes('handoff summary for another llm'));
+}
+function containsMarker(value) {
+    if (typeof value === 'string') {
+        return hasCompactionMarker(value);
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry) => containsMarker(entry));
+    }
+    const record = value;
+    if (typeof record.text === 'string' && hasCompactionMarker(record.text)) {
+        return true;
+    }
+    if (typeof record.content === 'string' && hasCompactionMarker(record.content)) {
+        return true;
+    }
+    if (Array.isArray(record.content) && record.content.some((entry) => containsMarker(entry))) {
+        return true;
+    }
+    if (Array.isArray(record.parts) && record.parts.some((entry) => containsMarker(entry))) {
+        return true;
+    }
+    return false;
+}
+export function isCompactionRequest(payload) {
+    if (containsMarker(payload)) {
+        return true;
+    }
+    const messages = payload.messages;
+    if (Array.isArray(messages) && messages.some((msg) => containsMarker(msg))) {
+        return true;
+    }
+    const input = payload.input;
+    if (containsMarker(input)) {
+        return true;
+    }
+    const system = payload.system;
+    if (containsMarker(system)) {
+        return true;
+    }
+    const instructions = payload.instructions;
+    if (containsMarker(instructions)) {
+        return true;
+    }
+    return false;
+}

package/dist/conversion/shared/errors.d.ts

@@ -1,4 +1,4 @@
-export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST';
+export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST' | 'SERVERTOOL_FOLLOWUP_FAILED';
 export type ProviderErrorCategory = 'EXTERNAL_ERROR' | 'TOOL_ERROR' | 'INTERNAL_ERROR';
 export interface ProviderProtocolErrorOptions {
     code: ProviderProtocolErrorCode;

package/dist/conversion/shared/reasoning-tool-normalizer.js

@@ -96,6 +96,13 @@ export function normalizeMessageReasoningTools(message, options) {
     const { cleanedText, toolCalls } = extractToolCallsFromReasoningText(sanitized, { idPrefix });
     const trimmed = (cleanedText || '').trim();
     writeReasoningContent(message, trimmed);
+    // Chat 统一行为：如果 message 本身没有正文内容，但存在非空 reasoning_content，
+    // 则将思考内容提升到正文，前后包裹 [思考] 标记，避免客户端只看到“空回答”。
+    const rawContent = message.content;
+    if ((typeof rawContent !== 'string' || rawContent.trim().length === 0) &&
+        trimmed.length > 0) {
+        message.content = `[思考]\n${trimmed}\n[/思考]`;
+    }
     if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
         return { toolCallsAdded: 0, cleanedReasoning: trimmed };
     }

package/dist/conversion/shared/snapshot-hooks.d.ts

@@ -5,5 +5,7 @@ export interface SnapshotHookOptions {
     data: unknown;
     verbosity?: 'minimal' | 'verbose';
     channel?: string;
+    providerKey?: string;
+    groupRequestId?: string;
 }
 export declare function writeSnapshotViaHooks(options: SnapshotHookOptions): Promise<void>;

package/dist/conversion/shared/snapshot-hooks.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 const DEFAULT_SNAPSHOT_ROOT = path.join(os.homedir(), '.routecodex', 'codex-samples');
+const PENDING_PROVIDER_DIR = '__pending__';
 function resolveSnapshotRoot() {
     const envOverride = process.env.RCC_SNAPSHOT_DIR ||
         process.env.ROUTECODEX_SNAPSHOT_DIR;
@@ -37,19 +38,194 @@ function channelSuffix(channel) {
     const token = sanitizeToken(channel, '');
     return token ? `_${token}` : '';
 }
+function readStringField(value) {
+    return typeof value === 'string' && value.trim().length ? value.trim() : undefined;
+}
+function extractNestedProviderKey(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const obj = value;
+    const direct = readStringField(obj.providerKey) ||
+        readStringField(obj.providerId) ||
+        readStringField(obj.profileId);
+    if (direct) {
+        return direct;
+    }
+    const target = obj.target;
+    if (target && typeof target === 'object') {
+        const tk = readStringField(target.providerKey);
+        if (tk) {
+            return tk;
+        }
+    }
+    const meta = obj.meta;
+    if (meta && typeof meta === 'object') {
+        const m = meta;
+        const fromMeta = readStringField(m.providerKey) ||
+            readStringField(m.providerId);
+        if (fromMeta) {
+            return fromMeta;
+        }
+        const ctx = m.context;
+        if (ctx && typeof ctx === 'object') {
+            const c = ctx;
+            const fromCtx = readStringField(c.providerKey) ||
+                readStringField(c.providerId) ||
+                readStringField(c.profileId);
+            if (fromCtx) {
+                return fromCtx;
+            }
+        }
+    }
+    return undefined;
+}
+function extractNestedGroupRequestId(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const obj = value;
+    const direct = readStringField(obj.clientRequestId) ||
+        readStringField(obj.groupRequestId);
+    if (direct) {
+        return direct;
+    }
+    const meta = obj.meta;
+    if (meta && typeof meta === 'object') {
+        const m = meta;
+        const fromMeta = readStringField(m.clientRequestId) ||
+            readStringField(m.groupRequestId);
+        if (fromMeta) {
+            return fromMeta;
+        }
+        const ctx = m.context;
+        if (ctx && typeof ctx === 'object') {
+            const c = ctx;
+            const fromCtx = readStringField(c.clientRequestId) ||
+                readStringField(c.groupRequestId);
+            if (fromCtx) {
+                return fromCtx;
+            }
+        }
+    }
+    return undefined;
+}
+function toErrorCode(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const code = error.code;
+    return typeof code === 'string' && code.trim() ? code : undefined;
+}
+async function writeUniqueFile(dir, baseName, contents) {
+    const parsed = path.parse(baseName);
+    const ext = parsed.ext || '.json';
+    const stem = parsed.name || 'snapshot';
+    for (let i = 0; i < 64; i += 1) {
+        const name = i === 0 ? `${stem}${ext}` : `${stem}_${i}${ext}`;
+        try {
+            await fs.writeFile(path.join(dir, name), contents, { encoding: 'utf-8', flag: 'wx' });
+            return;
+        }
+        catch (error) {
+            if (toErrorCode(error) === 'EEXIST') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    const fallback = `${stem}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
+    await fs.writeFile(path.join(dir, fallback), contents, 'utf-8');
+}
+const requestProviderIndex = globalThis
+    .__routecodexSnapshotProviderIndex ||
+    new Map();
+globalThis
+    .__routecodexSnapshotProviderIndex = requestProviderIndex;
+async function mergeDirs(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    let entries = [];
+    try {
+        entries = await fs.readdir(src);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const from = path.join(src, name);
+        const to = path.join(dest, name);
+        try {
+            await fs.rename(from, to);
+        }
+        catch (error) {
+            if (toErrorCode(error) === 'EEXIST') {
+                // avoid overwriting; keep both
+                const parsed = path.parse(name);
+                const ext = parsed.ext || '';
+                const stem = parsed.name || 'snapshot';
+                const suffix = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                try {
+                    await fs.rename(from, path.join(dest, `${stem}_${suffix}${ext}`));
+                }
+                catch {
+                    // ignore move failure
+                }
+                continue;
+            }
+            // ignore other move failures
+        }
+    }
+    try {
+        await fs.rmdir(src);
+    }
+    catch {
+        // ignore
+    }
+}
+async function promotePendingDir(options) {
+    if (!options.groupRequestToken || options.providerToken === PENDING_PROVIDER_DIR) {
+        return;
+    }
+    const pending = path.join(options.root, options.folder, PENDING_PROVIDER_DIR, options.groupRequestToken);
+    const dest = path.join(options.root, options.folder, options.providerToken, options.groupRequestToken);
+    try {
+        await fs.access(pending);
+    }
+    catch {
+        return;
+    }
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    try {
+        await fs.rename(pending, dest);
+    }
+    catch {
+        // if rename fails (already exists / cross-device), merge
+        await mergeDirs(pending, dest);
+    }
+}
 async function writeSnapshotFile(options) {
     const root = resolveSnapshotRoot();
     const folder = resolveSnapshotFolder(options.endpoint);
-    const dir = path.join(root, folder);
     const stageToken = sanitizeToken(options.stage, 'snapshot');
-    const requestToken = sanitizeToken(options.requestId, `req_${Date.now()}`);
-    const filePath = path.join(dir, `${requestToken}_${stageToken}${channelSuffix(options.channel)}.json`);
+    const groupRequestToken = sanitizeToken(options.groupRequestId ||
+        extractNestedGroupRequestId(options.data) ||
+        options.requestId, `req_${Date.now()}`);
+    const providerFromOptions = readStringField(options.providerKey);
+    const providerFromData = extractNestedProviderKey(options.data);
+    const knownProvider = requestProviderIndex.get(groupRequestToken);
+    const providerToken = sanitizeToken(providerFromOptions || providerFromData || knownProvider || PENDING_PROVIDER_DIR, PENDING_PROVIDER_DIR);
+    if (!knownProvider && providerToken !== PENDING_PROVIDER_DIR) {
+        requestProviderIndex.set(groupRequestToken, providerToken);
+        await promotePendingDir({ root, folder, groupRequestToken, providerToken });
+    }
+    const dir = path.join(root, folder, providerToken, groupRequestToken);
     await fs.mkdir(dir, { recursive: true });
     const spacing = options.verbosity === 'minimal' ? undefined : 2;
     const payload = spacing !== undefined
         ? JSON.stringify(options.data, null, spacing)
         : JSON.stringify(options.data);
-    await fs.writeFile(filePath, payload, 'utf-8');
+    const fileName = `${stageToken}${channelSuffix(options.channel)}.json`;
+    await writeUniqueFile(dir, fileName, payload);
 }
 export async function writeSnapshotViaHooks(options) {
     try {

package/dist/conversion/shared/snapshot-utils.d.ts

@@ -4,6 +4,8 @@ interface SnapshotPayload {
     endpoint?: string;
     data: unknown;
     folderHint?: string;
+    providerKey?: string;
+    groupRequestId?: string;
 }
 export declare function shouldRecordSnapshots(): boolean;
 export declare function recordSnapshot(options: SnapshotPayload): Promise<void>;
@@ -12,5 +14,7 @@ export declare function createSnapshotWriter(opts: {
     requestId: string;
     endpoint?: string;
     folderHint?: string;
+    providerKey?: string;
+    groupRequestId?: string;
 }): SnapshotWriter | undefined;
 export {};

package/dist/conversion/shared/snapshot-utils.js

@@ -31,6 +31,8 @@ export async function recordSnapshot(options) {
         endpoint,
         stage: options.stage,
         requestId: options.requestId,
+        providerKey: options.providerKey,
+        groupRequestId: options.groupRequestId,
         data: options.data,
         verbosity: 'verbose'
     }).catch(() => {
@@ -48,6 +50,8 @@ export function createSnapshotWriter(opts) {
             requestId: opts.requestId,
             endpoint,
             folderHint: opts.folderHint,
+            providerKey: opts.providerKey,
+            groupRequestId: opts.groupRequestId,
             data: payload
         });
     };

package/dist/conversion/shared/tool-filter-pipeline.js

@@ -234,19 +234,13 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
         registeredStages.add(filter.stage);
         engine.registerFilter(filter);
     };
-    const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } = await import('../../filters/index.js');
+    const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
     register(new ResponseToolTextCanonicalizeFilter());
     try {
-        const { ResponseToolArgumentsToonDecodeFilter, ResponseApplyPatchToonDecodeFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
-        register(new ResponseToolArgumentsToonDecodeFilter());
-        register(new ResponseApplyPatchToonDecodeFilter());
-        try {
-            register(new ResponseToolArgumentsSchemaConvergeFilter());
-        }
-        catch { /* optional */ }
-        register(new ResponseToolArgumentsBlacklistFilter());
+        register(new ResponseToolArgumentsSchemaConvergeFilter());
     }
     catch { /* optional */ }
+    register(new ResponseToolArgumentsBlacklistFilter());
     register(new ResponseToolArgumentsStringifyFilter());
     register(new ResponseFinishInvariantsFilter());
     try {

package/dist/conversion/shared/tool-governor.d.ts

@@ -9,6 +9,8 @@ export interface ToolGovernanceOptions {
     };
 }
 export declare function processChatRequestTools(request: Unknown, opts?: ToolGovernanceOptions): Unknown;
+export declare function normalizeApplyPatchToolCallsOnResponse(chat: Unknown): Unknown;
+export declare function normalizeApplyPatchToolCallsOnRequest(request: Unknown): Unknown;
 export declare function processChatResponseTools(resp: Unknown): Unknown;
 export interface GovernContext extends ToolGovernanceOptions {
     phase: 'request' | 'response';