@jsonstudio/rcc 0.89.552 → 0.89.611

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/types.d.ts

@@ -5,6 +5,7 @@ import type { StandardizedRequest } from '../../conversion/hub/types/standardize
 export declare const DEFAULT_MODEL_CONTEXT_TOKENS = 200000;
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
+export type RoutingInstructionMode = 'force' | 'sticky' | 'none';
 export interface RoutePoolTier {
     id: string;
     targets: string[];
@@ -167,6 +168,46 @@ export interface RouterMetadataInput {
      * serverToolsDisabled when this flag is true.
      */
     serverToolRequired?: boolean;
+    /**
+     * 强制路由模式，从消息中的 <**...**> 指令解析得出
+     */
+    routingMode?: RoutingInstructionMode;
+    /**
+     * 允许的 provider 白名单
+     */
+    allowedProviders?: string[];
+    /**
+     * 强制使用的 provider model (格式: provider.model)
+     */
+    forcedProviderModel?: string;
+    /**
+     * 强制使用的 provider keyAlias
+     */
+    forcedProviderKeyAlias?: string;
+    /**
+     * 强制使用的 provider keyIndex (从 1 开始)
+     */
+    forcedProviderKeyIndex?: number;
+    /**
+     * 禁用的 provider model 列表
+     */
+    disabledProviderModels?: string[];
+    /**
+     * 禁用的 provider keyAlias 列表
+     */
+    disabledProviderKeyAliases?: string[];
+    /**
+     * 禁用的 provider keyIndex 列表 (从 1 开始)
+     */
+    disabledProviderKeyIndexes?: number[];
+    /**
+     * 本次请求内需要临时排除的 providerKey 列表。
+     * 与 disabledProviders/disabledKeys 不同，这些 key 仅对当前路由决策生效，
+     * 不会写入或持久化到 RoutingInstructionState/sticky 存储中。
+     */
+    excludedProviderKeys?: string[];
+    sessionId?: string;
+    conversationId?: string;
     responsesResume?: {
         previousRequestId?: string;
         restoredFromResponseId?: string;

package/node_modules/@jsonstudio/llms/dist/servertool/engine.js

@@ -41,12 +41,53 @@ export async function runServerToolOrchestration(options) {
     const followupBody = followup.body && typeof followup.body === 'object'
         ? followup.body
         : engineResult.finalChatResponse;
+    const decorated = decorateFinalChatWithServerToolContext(followupBody, engineResult.execution);
     return {
-        chat: followupBody,
+        chat: decorated,
         executed: true,
         flowId: engineResult.execution.flowId
     };
 }
+function decorateFinalChatWithServerToolContext(chat, execution) {
+    if (!execution || !execution.context) {
+        return chat;
+    }
+    // 目前仅对 web_search flow 附加原文摘要，避免影响其它 ServerTool。
+    if (execution.flowId !== 'web_search_flow') {
+        return chat;
+    }
+    const ctx = execution.context;
+    const web = ctx.web_search;
+    const summary = web && typeof web.summary === 'string' && web.summary.trim().length
+        ? web.summary.trim()
+        : '';
+    if (!summary) {
+        return chat;
+    }
+    const engineId = web && typeof web.engineId === 'string' && web.engineId.trim().length
+        ? web.engineId.trim()
+        : undefined;
+    const label = engineId
+        ? `【web_search 原文 | engine: ${engineId}】`
+        : '【web_search 原文】';
+    const cloned = JSON.parse(JSON.stringify(chat));
+    const choices = Array.isArray(cloned.choices) ? cloned.choices : [];
+    if (!choices.length) {
+        return cloned;
+    }
+    const first = choices[0] && typeof choices[0] === 'object' ? choices[0] : null;
+    if (!first || !first.message || typeof first.message !== 'object') {
+        return cloned;
+    }
+    const message = first.message;
+    const baseContent = typeof message.content === 'string' ? message.content : '';
+    const suffix = `${label}\n${summary}`;
+    message.content =
+        baseContent && baseContent.trim().length
+            ? `${baseContent}\n\n${suffix}`
+            : suffix;
+    return cloned;
+}
 function resolveRouteHint(adapterContext, flowId) {
     const rawRoute = adapterContext.routeId;
     const routeId = typeof rawRoute === 'string' && rawRoute.trim() ? rawRoute.trim() : '';

package/node_modules/@jsonstudio/llms/dist/servertool/handlers/web-search.js

@@ -62,7 +62,14 @@ const handler = async (ctx) => {
                 payload: followupPayload,
                 metadata: buildFollowupMetadata(ctx.adapterContext, 'web_search')
             }
-            : undefined
+            : undefined,
+        context: {
+            web_search: {
+                engineId: chosenEngine.id,
+                providerKey: chosenEngine.providerKey,
+                summary: chosenResult.summary
+            }
+        }
     };
     return {
         chatResponse: patched,
@@ -89,7 +96,9 @@ function getWebSearchConfig(ctx) {
     const enginesRaw = Array.isArray(record.engines) ? record.engines : [];
     const engines = [];
     for (const entry of enginesRaw) {
-        const obj = entry && typeof entry === 'object' && !Array.isArray(entry) ? entry : null;
+        const obj = entry && typeof entry === 'object' && !Array.isArray(entry)
+            ? entry
+            : null;
         if (!obj)
             continue;
         const id = typeof obj.id === 'string' && obj.id.trim() ? obj.id.trim() : undefined;
@@ -104,12 +113,26 @@ function getWebSearchConfig(ctx) {
             (obj.serverTools &&
                 typeof obj.serverTools === 'object' &&
                 obj.serverTools.enabled === false);
+        let searchEngineList;
+        const rawSearchList = obj.searchEngineList;
+        if (Array.isArray(rawSearchList)) {
+            const normalizedList = [];
+            for (const item of rawSearchList) {
+                if (typeof item === 'string' && item.trim().length) {
+                    normalizedList.push(item.trim());
+                }
+            }
+            if (normalizedList.length) {
+                searchEngineList = normalizedList;
+            }
+        }
         engines.push({
             id,
             providerKey,
             description: typeof obj.description === 'string' && obj.description.trim() ? obj.description.trim() : undefined,
             default: obj.default === true,
-            ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
+            ...(serverToolsDisabled ? { serverToolsDisabled: true } : {}),
+            ...(searchEngineList ? { searchEngineList } : {})
         });
     }
     if (!engines.length) {
@@ -179,6 +202,10 @@ function isGeminiWebSearchEngine(engine) {
         key.startsWith('antigravity.') ||
         key.startsWith('gemini.'));
 }
+function isIflowWebSearchEngine(engine) {
+    const key = engine.providerKey.toLowerCase();
+    return key.startsWith('iflow.');
+}
 function normalizeResultCount(value) {
     if (typeof value === 'number' && Number.isFinite(value)) {
         const normalized = Math.trunc(value);
@@ -197,7 +224,22 @@ async function executeWebSearchBackend(args) {
     try {
         logServerToolWebSearch(engine, ctx.options.requestId, query);
         const requestSuffix = `:web_search:${engine.id}`;
-        if (ctx.options.reenterPipeline) {
+        // 对于 iFlow，直接通过 providerInvoker 调用 /chat/retrieve，
+        // 即使 reenterPipeline 可用，也不走 Chat 模型 + tools。
+        if (isIflowWebSearchEngine(engine) && ctx.options.providerInvoker) {
+            const backendResult = await executeIflowWebSearchViaProvider({
+                ctx,
+                engine,
+                query,
+                recency,
+                count: args.resultCount,
+                requestSuffix
+            });
+            summary = backendResult.summary;
+            hits = backendResult.hits;
+            ok = backendResult.ok;
+        }
+        else if (ctx.options.reenterPipeline) {
             const payload = buildWebSearchReenterPayload(engine, query, recency, args.resultCount);
             const followup = await ctx.options.reenterPipeline({
                 entryEndpoint: '/v1/chat/completions',
@@ -384,6 +426,117 @@ async function executeWebSearchViaProvider(args) {
     }
     return extractTextFromChatLike(providerResponse);
 }
+async function executeIflowWebSearchViaProvider(args) {
+    const { ctx, engine, query, count, requestSuffix } = args;
+    if (!ctx.options.providerInvoker) {
+        return {
+            summary: '',
+            hits: [],
+            ok: false
+        };
+    }
+    const searchEngineList = Array.isArray(engine.searchEngineList) && engine.searchEngineList.length
+        ? engine.searchEngineList
+        : ['GOOGLE', 'BING', 'SCHOLAR', 'AIPGC', 'PDF'];
+    const searchBody = {
+        query,
+        history: {},
+        userId: 2,
+        userIp: '42.120.74.197',
+        appCode: 'SEARCH_CHATBOT',
+        chatId: Date.now(),
+        phase: 'UNIFY',
+        enableQueryRewrite: false,
+        enableRetrievalSecurity: false,
+        enableIntention: false,
+        searchEngineList
+    };
+    let providerKey = engine.providerKey;
+    try {
+        const adapter = ctx.adapterContext && typeof ctx.adapterContext === 'object'
+            ? ctx.adapterContext
+            : null;
+        const target = adapter && adapter.target && typeof adapter.target === 'object'
+            ? adapter.target
+            : null;
+        const targetProviderKey = target && typeof target.providerKey === 'string' && target.providerKey.trim()
+            ? target.providerKey.trim()
+            : undefined;
+        if (targetProviderKey) {
+            providerKey = targetProviderKey;
+        }
+    }
+    catch {
+        // best-effort: fallback to engine.providerKey
+    }
+    const payload = {
+        data: searchBody,
+        metadata: {
+            entryEndpoint: '/chat/retrieve',
+            iflowWebSearch: true,
+            routeName: 'web_search'
+        }
+    };
+    const backend = await ctx.options.providerInvoker({
+        providerKey,
+        providerType: undefined,
+        modelId: undefined,
+        providerProtocol: ctx.options.providerProtocol,
+        payload,
+        entryEndpoint: '/v1/chat/retrieve',
+        requestId: `${ctx.options.requestId}${requestSuffix}`,
+        routeHint: 'web_search'
+    });
+    const providerResponse = backend.providerResponse && typeof backend.providerResponse === 'object'
+        ? backend.providerResponse
+        : null;
+    if (!providerResponse) {
+        return {
+            summary: '',
+            hits: [],
+            ok: false
+        };
+    }
+    const container = providerResponse;
+    const rawHits = Array.isArray(container.data) ? container.data : [];
+    const hits = [];
+    for (const item of rawHits) {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            continue;
+        const record = item;
+        const link = typeof record.url === 'string' && record.url.trim() ? record.url.trim() : '';
+        if (!link)
+            continue;
+        const title = typeof record.title === 'string' && record.title.trim() ? record.title.trim() : undefined;
+        const publishDate = typeof record.time === 'string' && record.time.trim() ? record.time.trim() : undefined;
+        const content = typeof record.abstractInfo === 'string' && record.abstractInfo.trim()
+            ? record.abstractInfo.trim()
+            : undefined;
+        hits.push({
+            title,
+            link,
+            publish_date: publishDate,
+            content
+        });
+        if (hits.length >= count) {
+            break;
+        }
+    }
+    let summary = '';
+    if (typeof container.message === 'string' && container.message.trim()) {
+        summary = container.message.trim();
+    }
+    if (!summary && hits.length) {
+        summary = formatHitsSummary(hits);
+    }
+    const successField = container.success;
+    const ok = typeof successField === 'boolean' ? successField : hits.length > 0;
+    return {
+        summary,
+        hits,
+        ok
+    };
+}
 function injectWebSearchToolResult(base, toolCall, engine, query, backendResult) {
     const cloned = cloneJson(base);
     const existingOutputs = Array.isArray(cloned.tool_outputs)

package/node_modules/@jsonstudio/llms/dist/servertool/types.d.ts

@@ -57,6 +57,12 @@ export interface ServerToolFollowupPlan {
 export interface ServerToolExecution {
     flowId: string;
     followup?: ServerToolFollowupPlan;
+    /**
+     * Optional tool-specific context for the execution result.
+     * For example, web_search handler may attach { web_search: { engineId, providerKey, summary } }
+     * so that orchestration layer can decorate final Chat response without touching host code.
+     */
+    context?: JsonObject;
 }
 /**
  * ServerSideToolEngineResult：ServerTool 引擎出参。

package/node_modules/@jsonstudio/llms/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/rcc",
-  "version": "0.89.552",
+  "version": "0.89.611",
   "description": "Multi-provider OpenAI proxy server with anthropic/responses/chat support (dev)",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,7 @@
   },
   "scripts": {
     "build": "npm run llmswitch:ensure && node scripts/build-core.mjs && node scripts/vendor-core.mjs && npm run clean && node scripts/gen-build-info.mjs && tsc && node scripts/copy-compat-assets.mjs && node scripts/copy-modules-config.mjs",
-    "build:dev": "BUILD_MODE=dev npm run build && npm run verify:e2e-toolcall && npm run install:global",
+    "build:dev": "BUILD_MODE=dev npm run build && npm run verify:e2e-toolcall && npm run verify:apply-patch && npm run test:routing-instructions && npm run install:global",
     "build:min": "npm run llmswitch:ensure && node scripts/build-core.mjs && node scripts/vendor-core.mjs && npm run clean && node scripts/gen-build-info.mjs && tsc && node scripts/copy-compat-assets.mjs && node scripts/copy-modules-config.mjs",
     "prepack": "echo skip-prepack",
     "postbuild": "chmod +x dist/cli.js || true",
@@ -40,7 +40,8 @@
     "start": "npm run -s start:bg",
     "dev": "tsx watch src/index.ts",
     "jest:run": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
-    "test": "npm run jest:run",
+    "test": "npm run test:routing-instructions && npm run mock:regressions",
+    "test:routing-instructions": "npm run jest:run -- --runTestsByPath tests/servertool/routing-instructions.spec.ts tests/servertool/hub-pipeline-session-headers.spec.ts tests/providers/core/runtime/http-transport-provider.headers.test.ts",
     "test:watch": "npm run jest:run -- --watch",
     "test:coverage": "npm run jest:run -- --coverage",
     "test:integration": "npm run jest:run -- --testPathPattern=integration",
@@ -56,6 +57,7 @@
     "prebuild": "echo skip-lint",
     "prepare": "",
     "postinstall": "chmod +x dist/cli.js || true",
+    "verify:apply-patch": "node scripts/verify-apply-patch.mjs",
     "install:global": "./scripts/install-global.sh",
     "install:release": "./scripts/install-release.sh",
     "audit:tool-text": "node scripts/audit-tool-text.mjs",
@@ -121,13 +123,14 @@
     "sync:ci-goldens": "node scripts/tools/sync-ci-goldens.mjs",
     "mock:extract": "node scripts/mock-provider/extract.mjs",
     "mock:validate": "node scripts/mock-provider/validate.mjs",
+    "mock:regressions": "node scripts/mock-provider/run-regressions.mjs",
     "mock:clean": "node scripts/mock-provider/clean.mjs",
     "publish:rcc": "node scripts/publish-rcc.mjs"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.65.0",
-    "@jsonstudio/llms": "^0.6.375",
-    "@jsonstudio/rcc": "^0.89.524",
+    "@jsonstudio/llms": "^0.6.473",
+    "@jsonstudio/rcc": "^0.89.555",
     "@lmstudio/sdk": "^1.5.0",
     "@radix-ui/react-switch": "^1.2.6",
     "@types/socket.io": "^3.0.1",

package/scripts/mock-provider/run-regressions.mjs

@@ -13,6 +13,7 @@ const MOCK_SAMPLES_DIR = resolveSamplesDir();
 const REGISTRY_PATH = path.join(MOCK_SAMPLES_DIR, '_registry', 'index.json');
 const NAME_REGEX = /^[A-Za-z0-9_-]+$/;
 const ENTRY_FILTER = parseEntryFilter();
+const NPM_CMD = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 
 function resolveSamplesDir() {
   const override = String(process.env.ROUTECODEX_MOCK_SAMPLES_DIR || '').trim();
@@ -36,13 +37,48 @@ function parseEntryFilter() {
 
 async function ensureCliAvailable() {
   const cliPath = path.join(PROJECT_ROOT, 'dist', 'cli.js');
+  if (await fileExists(cliPath)) {
+    return;
+  }
+  console.warn('[mock:regressions] dist/cli.js missing, running "npm run build:min" automatically...');
+  await runBuildForMockRegressions();
+  if (!(await fileExists(cliPath))) {
+    throw new Error('dist/cli.js missing after automatic build. Please run "npm run build:dev" manually.');
+  }
+}
+
+async function fileExists(targetPath) {
   try {
-    await fs.access(cliPath);
+    await fs.access(targetPath);
+    return true;
   } catch {
-    throw new Error('dist/cli.js missing. Please run "npm run build:dev" before mock regressions.');
+    return false;
   }
 }
 
+async function runBuildForMockRegressions() {
+  await new Promise((resolve, reject) => {
+    const child = spawn(NPM_CMD, ['run', 'build:min'], {
+      cwd: PROJECT_ROOT,
+      env: {
+        ...process.env,
+        ROUTECODEX_VERIFY_SKIP: '1'
+      },
+      stdio: 'inherit'
+    });
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`npm run build:min exited with code ${code}`));
+      }
+    });
+    child.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
 async function loadRegistry() {
   const raw = await fs.readFile(REGISTRY_PATH, 'utf-8');
   const registry = JSON.parse(raw);

package/scripts/verify-apply-patch.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * Minimal apply_patch governance verifier (CI client)
+ *
+ * 直接调用 llmswitch-core 的文本 → tool_calls → 校验链路，
+ * 用统一 diff（*** Begin Patch/*** End Patch）触发 apply_patch。
+ */
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, '..');
+const coreLoaderPath = path.join(repoRoot, 'dist', 'modules', 'llmswitch', 'core-loader.js');
+const coreLoaderUrl = pathToFileURL(coreLoaderPath).href;
+const { importCoreModule } = await import(coreLoaderUrl);
+
+async function loadCoreModule(subpath) {
+  return importCoreModule(subpath);
+}
+
+async function runApplyPatchTextCase(label, patchText) {
+  const { normalizeAssistantTextToToolCalls } = await loadCoreModule(
+    'conversion/shared/text-markup-normalizer'
+  );
+  const { canonicalizeChatResponseTools } = await loadCoreModule(
+    'conversion/shared/tool-canonicalizer'
+  );
+  const { validateToolCall } = await loadCoreModule('tools/tool-registry');
+
+  const message = {
+    role: 'assistant',
+    content: patchText
+  };
+  const normalizedMsg = normalizeAssistantTextToToolCalls(message);
+  const toolCalls = normalizedMsg?.tool_calls;
+  if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+    throw new Error(`[verify-apply-patch] ${label}: text normalizer did not produce tool_calls`);
+  }
+
+  const chatPayload = {
+    id: `chatcmpl_apply_patch_${label}`,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model: 'gpt-4.1',
+    choices: [
+      {
+        index: 0,
+        message: normalizedMsg,
+        finish_reason: 'tool_calls'
+      }
+    ]
+  };
+
+  const canonical = canonicalizeChatResponseTools(chatPayload);
+  const tc = canonical?.choices?.[0]?.message?.tool_calls?.[0];
+  if (!tc || typeof tc !== 'object') {
+    throw new Error(`[verify-apply-patch] ${label}: missing tool_calls after canonicalization`);
+  }
+
+  const fn = tc.function || {};
+  if (fn.name !== 'apply_patch') {
+    throw new Error(
+      `[verify-apply-patch] ${label}: expected apply_patch, got ${JSON.stringify(fn.name)}`
+    );
+  }
+  if (typeof fn.arguments !== 'string' || !fn.arguments.trim()) {
+    throw new Error(
+      `[verify-apply-patch] ${label}: arguments must be non-empty JSON string, got ${typeof fn.arguments}`
+    );
+  }
+  const validation = validateToolCall(fn.name, fn.arguments);
+  if (!validation?.ok) {
+    throw new Error(
+      `[verify-apply-patch] ${label}: validateToolCall failed with reason=${validation?.reason}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(validation.normalizedArgs || fn.arguments);
+  } catch (error) {
+    throw new Error(
+      `[verify-apply-patch] ${label}: normalized arguments not valid JSON: ${(error && error.message) || String(error)}`
+    );
+  }
+  if (typeof parsed.patch !== 'string' || !parsed.patch.includes('*** Begin Patch')) {
+    throw new Error(
+      `[verify-apply-patch] ${label}: normalized arguments missing patch text`
+    );
+  }
+  if (typeof parsed.input !== 'string' || !parsed.input.includes('*** Begin Patch')) {
+    throw new Error(
+      `[verify-apply-patch] ${label}: normalized arguments missing input mirror`
+    );
+  }
+}
+
+async function main() {
+  if (String(process.env.ROUTECODEX_VERIFY_SKIP || '').trim() === '1') {
+    console.log('[verify-apply-patch] 跳过（ROUTECODEX_VERIFY_SKIP=1）');
+    process.exit(0);
+  }
+
+  try {
+    const plainPatch =
+      '*** Begin Patch\n' +
+      '*** Add File: hello.txt\n' +
+      '+Hello from apply_patch\n' +
+      '*** End Patch\n';
+
+    const fencedPatch =
+      '```patch\n' +
+      '*** Begin Patch\n' +
+      '*** Add File: hello-fenced.txt\n' +
+      '+Hello from apply_patch (fenced)\n' +
+      '*** End Patch\n' +
+      '```';
+
+    await runApplyPatchTextCase('plain', plainPatch);
+    await runApplyPatchTextCase('fenced', fencedPatch);
+
+    console.log('✅ verify-apply-patch: text→tool_calls pipeline passed');
+  } catch (error) {
+    console.error(error);
+    console.error(
+      '❌ verify-apply-patch 失败:',
+      error instanceof Error ? error.message : String(error ?? 'Unknown error')
+    );
+    process.exit(1);
+  }
+}
+
+main();