@jsonstudio/rcc 0.89.1205 → 0.89.1457

package/scripts/tools-dev/responses-debug-client/run.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import OpenAI from 'openai';
+
+function parseArgs(argv){ const out={}; for(let i=2;i<argv.length;i++){ const a=argv[i]; if(!a) continue; if(a.startsWith('--')){ const [k,v]=a.split('='); const key=k.replace(/^--/,''); if(typeof v==='string'&&v.length) out[key]=v; else if(i+1<argv.length && !argv[i+1].startsWith('--')) out[key]=argv[++i]; else out[key]=true; } } return out; }
+function short(s,n=60){ return s.length<=n?s:(s.slice(0,n)+'…'); }
+function nowIso(){ return new Date().toISOString(); }
+async function readJson(file){ const abs=path.isAbsolute(file)?file:path.resolve(process.cwd(),file); const raw=await fs.readFile(abs,'utf-8'); return JSON.parse(raw); }
+
+async function main(){
+  const args=parseArgs(process.argv);
+  const file=String(args.file||args.f||'');
+  if(!file){ console.error('Usage: node scripts/tools-dev/responses-debug-client/run.mjs --file <payload.json> [--baseURL URL] [--apiKey KEY] [--timeout 120] [--raw]'); process.exit(1); }
+  const baseURL=String(args.baseURL||'http://127.0.0.1:5520/v1');
+  const apiKey=String(args.apiKey||'dummy');
+  const timeoutSec=Number(args.timeout||120);
+  const raw=!!args.raw;
+
+  const body=await readJson(file);
+  if (body.stream == null) body.stream = true;
+  // attach client_request_id and snapshot request body
+  const clientRequestId = `cli_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;
+  try{
+    const meta = (body && typeof body==='object' && body.metadata && typeof body.metadata==='object') ? body.metadata : {};
+    body.metadata = { ...meta, client_request_id: clientRequestId };
+  }catch{}
+  try{
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    const dir = path.join(String(home), '.routecodex', 'codex-samples', 'responses-client');
+    await fs.mkdir(dir, { recursive: true });
+    const out = path.join(dir, `${clientRequestId}_client-request.json`);
+    await fs.writeFile(out, JSON.stringify({ timestamp: new Date().toISOString(), baseURL, request: body }, null, 2), 'utf-8');
+    if(!raw) console.log('saved client snapshot:', out);
+  }catch{}
+
+  const client=new OpenAI({ apiKey, baseURL });
+  console.log(`[${nowIso()}] connect baseURL=${baseURL}`);
+  const start=Date.now();
+  const stream=await client.responses.stream(body);
+  let responseId='';
+  let model='';
+  let text='';
+
+  const timer=setTimeout(()=>{ try{ stream.controller?.abort?.(); }catch{}; console.error('timeout'); process.exitCode=3; }, timeoutSec*1000);
+
+  for await (const ev of stream){
+    const t=ev?.type||'event';
+    const d=ev?.data ?? ev;
+    if(raw){ console.log('evt', t, JSON.stringify(d)); }
+    switch(t){
+      case 'response.created': responseId=String(d?.response?.id||responseId); model=String(d?.response?.model||model); console.log('created', responseId, model); break;
+      case 'response.output_text.delta': { const s=String(d?.delta||''); text+=s; console.log('textΔ', s.length, short(s)); break; }
+      case 'response.output_text.done': console.log('text✓ total', text.length); break;
+      case 'response.completed': console.log('completed', JSON.stringify(d?.response?.usage||{})); break;
+      case 'response.required_action': console.log('required_action', JSON.stringify(d?.required_action||d)); break;
+      case 'response.error': console.error('error', JSON.stringify(d?.error||d)); process.exitCode=2; break;
+      case 'response.done': { const ms=Date.now()-start; console.log('done', ms,'ms'); clearTimeout(timer); return; }
+      default: break;
+    }
+  }
+}
+
+main().catch(e=>{ console.error('fatal', e?.message||String(e)); process.exit(2); });

package/scripts/tools-dev/responses-debug-client/src/index.ts

@@ -0,0 +1,281 @@
+#!/usr/bin/env tsx
+/**
+ * Responses Debug Client
+ * - Connects to RCC server (baseURL) using OpenAI SDK Responses stream
+ * - Consumes SSE named events, prints concise logs
+ * - Completes a minimal tool-calls loop by executing local tools and submitting outputs
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import OpenAI from 'openai';
+
+type Unknown = Record<string, any>;
+
+function parseArgs(argv: string[]): Record<string, string | boolean> {
+  const out: Record<string, string | boolean> = {};
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a) continue;
+    if (a.startsWith('--')) {
+      const [k, v] = a.split('=');
+      const key = k.replace(/^--/, '');
+      if (typeof v === 'string' && v.length) out[key] = v;
+      else if (i + 1 < argv.length && !argv[i + 1].startsWith('--')) { out[key] = argv[++i]; }
+      else out[key] = true;
+    }
+  }
+  return out;
+}
+
+function short(s: string, n = 60): string {
+  if (s.length <= n) return s;
+  return s.slice(0, n) + '…';
+}
+
+function nowIso(): string { return new Date().toISOString(); }
+
+async function readJson(file: string): Promise<Unknown> {
+  const abs = path.isAbsolute(file) ? file : path.resolve(process.cwd(), file);
+  const raw = await fs.readFile(abs, 'utf-8');
+  return JSON.parse(raw) as Unknown;
+}
+
+type ToolOutput = { tool_call_id: string; output: string };
+
+function safeJsonParse(s: string): any {
+  try { return JSON.parse(s); } catch { return s; }
+}
+
+// Minimal local tool handlers
+const localTools: Record<string, (args: any) => Promise<string> | string> = {
+  echo: (args: any) => {
+    if (typeof args?.text === 'string') return String(args.text);
+    return typeof args === 'string' ? args : JSON.stringify(args ?? {});
+  },
+  sum: (args: any) => {
+    const arr = Array.isArray(args?.numbers) ? args.numbers : [];
+    const total = arr.reduce((a: number, b: any) => a + (typeof b === 'number' ? b : 0), 0);
+    return String(total);
+  },
+  time: () => new Date().toISOString(),
+};
+
+async function executeTool(name: string, argStr: string): Promise<string> {
+  const n = String(name || '').trim();
+  const handler = localTools[n] || (async () => `Unsupported tool: ${n}`);
+  const args = typeof argStr === 'string' ? safeJsonParse(argStr) : argStr;
+  try { return await handler(args); } catch (e: any) { return `Tool error: ${e?.message || String(e)}`; }
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  const file = String(args.file || args.f || '');
+  if (!file) {
+    console.error('Usage: tsx scripts/tools-dev/responses-debug-client/src/index.ts --file <payload.json> [--baseURL URL] [--apiKey KEY] [--timeout 120] [--raw] [--save] [--maxRounds 3]');
+    process.exit(1);
+  }
+  const baseURL = String(args.baseURL || 'http://127.0.0.1:5520/v1');
+  const apiKey = String(args.apiKey || 'dummy');
+  const timeoutSec = Number(args.timeout || 120);
+  const raw = !!args.raw;
+  const save = !!args.save;
+  const maxRounds = Math.max(1, Number(args.maxRounds || 3));
+
+  const reqBody = await readJson(file);
+  if (reqBody.stream == null) reqBody.stream = true;
+
+  // Attach a client-side request id into payload.metadata for correlation
+  const clientRequestId = `cli_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    const meta = (reqBody && typeof reqBody === 'object' && (reqBody as any).metadata && typeof (reqBody as any).metadata === 'object')
+      ? (reqBody as any).metadata : {};
+    (reqBody as any).metadata = { ...meta, client_request_id: clientRequestId };
+  } catch { /* ignore */ }
+
+  // Snapshot exact client request body to ~/.routecodex/codex-samples/responses-client/
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    const dir = path.join(String(home), '.routecodex', 'codex-samples', 'responses-client');
+    await fs.mkdir(dir, { recursive: true });
+    const out = path.join(dir, `${clientRequestId}_client-request.json`);
+    await fs.writeFile(out, JSON.stringify({
+      timestamp: new Date().toISOString(),
+      baseURL,
+      request: reqBody
+    }, null, 2), 'utf-8');
+    if (!raw) console.log(`[${nowIso()}] saved client snapshot: ${out}`);
+  } catch { /* non-blocking */ }
+
+  const client = new OpenAI({ apiKey, baseURL });
+  const start = Date.now();
+  console.log(`[${nowIso()}] connect baseURL=${baseURL}`);
+
+  const stream: any = await client.responses.stream(reqBody as any);
+  let responseId = '';
+  let model = '';
+  let round = 1;
+  const textBuf: string[] = [];
+
+  // tool state
+  const toolArgs: Record<string, string> = {};
+  const toolMeta: Record<string, { name?: string; output_index?: number; type?: string }> = {};
+  let sawRequiredAction = false;
+  let submittedThisRound = false;
+  const seqCheck = { last: -1 };
+
+  const writeLine = async (o: any) => {
+    if (!save) return;
+    try {
+      const dir = path.resolve(process.cwd(), 'logs', 'responses-debug', responseId || 'unknown');
+      await fs.mkdir(dir, { recursive: true });
+      await fs.appendFile(path.join(dir, 'events.jsonl'), JSON.stringify({ ts: Date.now(), ...o }) + '\n', 'utf-8');
+    } catch { /* ignore */ }
+  };
+
+  const submitToolOutputs = async (requiredAction: any) => {
+    const tc = Array.isArray(requiredAction?.submit_tool_outputs?.tool_calls)
+      ? requiredAction.submit_tool_outputs.tool_calls : [];
+    const outputs: ToolOutput[] = [];
+    for (const call of tc) {
+      const id = String(call?.id || '');
+      const name = String(call?.function?.name || '');
+      const argStr = String(call?.function?.arguments || '');
+      const out = await executeTool(name, argStr);
+      outputs.push({ tool_call_id: id, output: out });
+      console.log(` ↳ tool[${name}] id=${id} -> output(${out.length})`);
+    }
+    if (typeof stream.submitToolOutputs === 'function') {
+      console.log(` -> submitToolOutputs(${outputs.length}) via stream`);
+      await stream.submitToolOutputs({ tool_outputs: outputs, stream: true });
+      return;
+    }
+    throw new Error('SDK stream.submitToolOutputs unavailable; please upgrade openai package');
+  };
+
+  const dumpEvent = (ev: any) => {
+    const t = ev?.type || 'event';
+    const d = ev?.data ?? ev;
+    const seq = typeof d?.sequence_number === 'number' ? d.sequence_number : undefined;
+    if (typeof seq === 'number') {
+      if (seq <= seqCheck.last) console.warn(` ! sequence rollback: ${seqCheck.last} -> ${seq}`);
+      seqCheck.last = seq;
+    }
+    if (raw) console.log('evt', t, JSON.stringify(d));
+  };
+
+  for await (const ev of stream) {
+    await writeLine({ type: ev?.type || 'event', data: ev });
+    dumpEvent(ev);
+
+    switch (ev?.type) {
+      case 'response.created': {
+        responseId = String(ev?.data?.response?.id || responseId);
+        model = String(ev?.data?.response?.model || model);
+        console.log(`created id=${responseId} model=${model}`);
+        break;
+      }
+      case 'response.in_progress': {
+        break;
+      }
+      case 'response.output_text.delta': {
+        const s = String(ev?.data?.delta || '');
+        textBuf.push(s);
+        console.log(` textΔ(${s.length}): ${short(s)}`);
+        break;
+      }
+      case 'response.output_text.done': {
+        console.log(` text✓ (total=${textBuf.join('').length})`);
+        break;
+      }
+      case 'response.output_item.added': {
+        const item = ev?.data?.item || {};
+        const id = String(item?.id || '');
+        toolMeta[id] = { name: item?.name, output_index: ev?.data?.output_index, type: item?.type };
+        toolArgs[id] = toolArgs[id] || '';
+        console.log(` tool+ id=${id} name=${item?.name || ''}`);
+        break;
+      }
+      case 'response.function_call_arguments.delta': {
+        const id = String(ev?.data?.id || ev?.data?.item_id || '');
+        const d = String(ev?.data?.delta || '');
+        toolArgs[id] = (toolArgs[id] || '') + d;
+        console.log(` argsΔ id=${id} (+${d.length})`);
+        break;
+      }
+      case 'response.function_call_arguments.done': {
+        const id = String(ev?.data?.id || ev?.data?.item_id || '');
+        const total = (toolArgs[id] || '').length;
+        console.log(` args✓ id=${id} (${total})`);
+        break;
+      }
+      case 'response.output_item.done': {
+        const item = ev?.data?.item || {};
+        const id = String(item?.id || '');
+        console.log(` tool✓ id=${id}`);
+        // Fallback path for providers不发 required_action：在 function_call 完成后立即提交工具输出
+        if (!sawRequiredAction && !submittedThisRound && (toolMeta[id]?.type === 'function_call')) {
+          const name = toolMeta[id]?.name || item?.name || '';
+          const argStr = item?.arguments || toolArgs[id] || '';
+          const outputs: ToolOutput[] = [{ tool_call_id: id, output: await executeTool(name, String(argStr)) }];
+          if (typeof stream.submitToolOutputs === 'function') {
+            console.log(` -> submitToolOutputs(fallback, ${outputs.length}) via stream [round ${round}]`);
+            await stream.submitToolOutputs({ tool_outputs: outputs, stream: true });
+            submittedThisRound = true;
+            round++;
+            if (round > maxRounds) throw new Error(`Exceeded maxRounds=${maxRounds}`);
+          }
+        }
+        break;
+      }
+      case 'response.required_action': {
+        const ra = ev?.data?.required_action || ev?.data; // SDK shape varies
+        const count = Array.isArray(ra?.submit_tool_outputs?.tool_calls) ? ra.submit_tool_outputs.tool_calls.length : 0;
+        console.log(` required_action submit_tool_outputs(${count}) [round ${round}]`);
+        sawRequiredAction = true;
+        await submitToolOutputs(ra);
+        round++;
+        if (round > maxRounds) throw new Error(`Exceeded maxRounds=${maxRounds}`);
+        break;
+      }
+      case 'response.completed': {
+        const u = ev?.data?.response?.usage || {};
+        const iu = Number(u?.input_tokens || 0);
+        const ou = Number(u?.output_tokens || 0);
+        const tt = Number(u?.total_tokens || 0);
+        console.log(` completed usage: in=${iu} out=${ou} total=${tt}`);
+        // Reset per-round flags to allow下一轮
+        submittedThisRound = false;
+        sawRequiredAction = false;
+        break;
+      }
+      case 'response.error': {
+        console.error(' error:', ev?.data?.error);
+        process.exitCode = 2;
+        break;
+      }
+      case 'response.done': {
+        const ms = Date.now() - start;
+        console.log(` done in ${ms} ms`);
+        return;
+      }
+      default: {
+        // Heartbeat or unknown event
+        const d = ev?.data;
+        if (d && typeof d === 'object' && d.type === 'heartbeat') {
+          // ignore
+        } else if (!raw) {
+          // print brief unknowns
+          const t = String(ev?.type || 'evt');
+          console.log(` ${t}`);
+        }
+      }
+    }
+  }
+}
+
+main().catch((e) => {
+  console.error('fatal:', e?.message || String(e));
+  process.exit(2);
+});

package/scripts/tools-dev/run-llmswitch-chat.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// Quick llmswitch-core Chat filter runner: runStandardChatRequestFilters without starting server.
+// Usage:
+//   node scripts/tools-dev/run-llmswitch-chat.mjs path/to/chat-request.json [/v1/chat|/v1/messages|/v1/responses]
+
+import fs from 'fs';
+import path from 'path';
+import url from 'url';
+import { runStandardChatRequestFilters } from '../../sharedmodule/llmswitch-core/dist/conversion/index.js';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+async function main() {
+  const file = process.argv[2];
+  const endpoint = process.argv[3] || '/v1/chat/completions';
+
+  if (!file) {
+    console.error('Usage: node scripts/tools-dev/run-llmswitch-chat.mjs <payload.json> [endpoint]');
+    process.exit(1);
+  }
+
+  const abs = path.isAbsolute(file) ? file : path.join(process.cwd(), file);
+  const txt = fs.readFileSync(abs, 'utf8');
+  const raw = JSON.parse(txt);
+
+  // Allow passing either a raw chat body, or a provider-request snapshot with { endpoint, data: { body } }
+  let payload = raw;
+  if (raw && typeof raw === 'object' && raw.data && typeof raw.data === 'object' && raw.data.body) {
+    payload = raw.data.body;
+  }
+
+  const requestId = `req_${Date.now()}`;
+  const profile = {
+    id: 'test-profile',
+    incomingProtocol: 'openai-chat',
+    outgoingProtocol: 'openai-chat'
+  };
+
+  const context = {
+    requestId,
+    entryEndpoint: endpoint,
+    endpoint,
+    metadata: {}
+  };
+
+  const out = await runStandardChatRequestFilters(payload, profile, context);
+  process.stdout.write(JSON.stringify(out, null, 2) + '\n');
+}
+
+main().catch(err => {
+  console.error('Error running llmswitch filters:', err);
+  process.exit(1);
+});

package/scripts/tools-dev/server-tools-dev/run-web-fetch.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import path from 'node:path';
+
+function parseArgs(argv) {
+  const out = { url: null, timeout: null, maxBytes: null, follow: true, headers: {} };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if ((a === '--url' || a === '-u') && i + 1 < argv.length) { out.url = argv[++i]; continue; }
+    if ((a === '--timeout' || a === '-t') && i + 1 < argv.length) { out.timeout = Number(argv[++i]); continue; }
+    if (a === '--no-follow') { out.follow = false; continue; }
+    if ((a === '--max-bytes' || a === '-m') && i + 1 < argv.length) { out.maxBytes = Number(argv[++i]); continue; }
+    if ((a === '--header' || a === '-H') && i + 1 < argv.length) {
+      const kv = String(argv[++i]);
+      const idx = kv.indexOf(':');
+      if (idx > 0) { const k = kv.slice(0, idx).trim(); const v = kv.slice(idx + 1).trim(); if (k) out.headers[k] = v; }
+      continue;
+    }
+    if (a === '--help' || a === '-h') { out.help = true; }
+  }
+  return out;
+}
+
+function usage() {
+  console.log('Usage: node scripts/tools-dev/server-tools-dev/run-web-fetch.mjs --url <URL> [--timeout 12000] [--max-bytes 524288] [--no-follow] [--header "Key: Value"]');
+}
+
+async function importCoreFetcher() {
+  // Prefer local sharedmodule path if exists; fallback to installed package
+  const __filename = fileURLToPath(import.meta.url);
+  const repoRoot = path.resolve(path.dirname(__filename), '../..');
+  const local = path.resolve(repoRoot, 'sharedmodule/llmswitch-core/dist/tools/web-fetch-html.js');
+  try {
+    const mod = await import(pathToFileURL(local).href);
+    if (typeof mod?.fetchRawHtml === 'function') return mod.fetchRawHtml;
+  } catch {}
+  throw new Error('Cannot locate fetchRawHtml in sharedmodule/llmswitch-core/dist。请先构建 sharedmodule/llmswitch-core。');
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help || !args.url) { usage(); process.exit(args.help ? 0 : 1); }
+  const fetchRawHtml = await importCoreFetcher();
+  const res = await fetchRawHtml(args.url, {
+    timeoutMs: args.timeout || undefined,
+    followRedirects: args.follow,
+    maxBytes: args.maxBytes || undefined,
+    headers: Object.keys(args.headers).length ? args.headers : undefined,
+  });
+  if (res.ok) {
+    console.log('OK');
+    console.log(`status: ${res.status}`);
+    console.log(`content-type: ${res.contentType}`);
+    const preview = res.html ?? '';
+    console.log('--- html (first 2048 chars) ---');
+    console.log(preview.slice(0, 2048));
+  } else {
+    console.log('FAIL');
+    console.log(`error: ${res.error}`);
+    if (res.status) console.log(`status: ${res.status}`);
+    if (res.contentType) console.log(`content-type: ${res.contentType}`);
+  }
+}
+
+main().catch((e) => { console.error(e); process.exit(99); });

package/scripts/unified-hub-shadow-compare.mjs

@@ -141,6 +141,14 @@ function stableStringify(value) {
   );
 }
 
+function cloneJsonSafe(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+
 function diffPayloads(expected, actual, p = '<root>') {
   if (Object.is(expected, actual)) return [];
   if (typeof expected !== typeof actual) {
@@ -254,12 +262,12 @@ async function bootstrapVirtualRouterConfig(rawConfig) {
   return mod.bootstrapVirtualRouterConfig(rawConfig);
 }
 
-async function runOnce({ requestId, mode, entryEndpoint, routeHint, payload }) {
+async function runOnce({ requestId, candidateMode, baselineMode, entryEndpoint, routeHint, payload }) {
   const HubPipeline = await importHubPipelineCtor();
   const artifacts = await bootstrapVirtualRouterConfig(buildVirtualRouterConfig());
   const pipeline = new HubPipeline({
     virtualRouter: artifacts.config,
-    policy: { mode }
+    policy: { mode: candidateMode }
   });
   const providerProtocol = normalizeEntryProviderProtocol(entryEndpoint);
   const result = await pipeline.execute({
@@ -269,7 +277,10 @@ async function runOnce({ requestId, mode, entryEndpoint, routeHint, payload }) {
     metadata: {
       entryEndpoint,
       providerProtocol,
-      routeHint
+      routeHint,
+      __hubShadowCompare: {
+        baselineMode
+      }
     }
   });
   return result;
@@ -300,18 +311,24 @@ async function main() {
   const candidateMode = String(opts.candidateMode);
   const requestId = `shadow_unified_hub_${Date.now()}`;
 
-  const baseline = await runOnce({ requestId, mode: baselineMode, entryEndpoint, routeHint, payload });
-  const candidate = await runOnce({ requestId, mode: candidateMode, entryEndpoint, routeHint, payload });
+  const candidate = await runOnce({ requestId, candidateMode, baselineMode, entryEndpoint, routeHint, payload });
+  const shadow = candidate && candidate.metadata && typeof candidate.metadata === 'object'
+    ? candidate.metadata.hubShadowCompare
+    : undefined;
+  const baselineProviderPayload =
+    shadow && typeof shadow === 'object' && shadow && !Array.isArray(shadow)
+      ? shadow.baselineProviderPayload
+      : undefined;
 
   const baselineOut = {
-    providerPayload: baseline.providerPayload,
-    target: baseline.target,
+    providerPayload: baselineProviderPayload,
+    target: candidate.target,
     metadata: {
-      entryEndpoint: baseline.metadata?.entryEndpoint,
-      providerProtocol: baseline.metadata?.providerProtocol,
-      processMode: baseline.metadata?.processMode,
-      stream: baseline.metadata?.stream,
-      routeHint: baseline.metadata?.routeHint
+      entryEndpoint: candidate.metadata?.entryEndpoint,
+      providerProtocol: candidate.metadata?.providerProtocol,
+      processMode: candidate.metadata?.processMode,
+      stream: candidate.metadata?.stream,
+      routeHint: candidate.metadata?.routeHint
     }
   };
   const candidateOut = {
@@ -326,7 +343,10 @@ async function main() {
     }
   };
 
-  const diffs = diffPayloads(baselineOut, candidateOut);
+  if (!baselineProviderPayload || typeof baselineProviderPayload !== 'object') {
+    throw new Error('[unified-hub-shadow-compare] hubShadowCompare.baselineProviderPayload missing; ensure llmswitch-core is rebuilt.');
+  }
+  const diffs = diffPayloads(cloneJsonSafe(baselineOut), cloneJsonSafe(candidateOut));
   if (!diffs.length) {
     console.log('[unified-hub-shadow-compare] OK diff=0');
     return;

package/scripts/vendor-core.mjs

@@ -12,12 +12,18 @@ async function rmrf(p) {
 
 async function main() {
   const root = process.cwd();
+  const rawMode = String(process.env.BUILD_MODE || process.env.RCC_BUILD_MODE || 'release').toLowerCase();
+  const mode = rawMode === 'dev' ? 'dev' : 'release';
   const sharedDist = path.join(root, 'sharedmodule', 'llmswitch-core', 'dist');
   const legacyVendorDir = path.join(root, 'vendor', 'rcc-llmswitch-core');
   const scopedVendorDir = path.join(root, 'vendor', '@jsonstudio', 'llms');
 
-  if (!await exists(sharedDist)) {
-    console.error('[vendor-core] ERROR: 未找到 sharedmodule/llmswitch-core/dist');
+  // In release mode we rely on npm-installed `@jsonstudio/llms`, so the local sharedmodule dist
+  // is optional and must not block CI (where sharedmodule often doesn't exist).
+  // In dev mode, `node_modules/@jsonstudio/llms` is typically symlinked to sharedmodule/llmswitch-core,
+  // so we keep a hard requirement for the dist output.
+  if (mode === 'dev' && !await exists(sharedDist)) {
+    console.error('[vendor-core] ERROR: 未找到 sharedmodule/llmswitch-core/dist (BUILD_MODE=dev)');
     console.error('[vendor-core] 请先进入 sharedmodule/llmswitch-core 并运行 `npm run build`。');
     process.exit(2);
   }
@@ -31,7 +37,11 @@ async function main() {
     console.log('[vendor-core] removed legacy vendor/@jsonstudio/llms directory');
   }
 
-  console.log('[vendor-core] sharedmodule/llmswitch-core/dist 将被直接引用，已停止生成 vendor 副本。');
+  if (mode === 'dev') {
+    console.log('[vendor-core] sharedmodule/llmswitch-core/dist 将被直接引用，已停止生成 vendor 副本。');
+  } else {
+    console.log('[vendor-core] BUILD_MODE=release: using npm-installed @jsonstudio/llms (no vendor copy).');
+  }
 }
 
 main().catch((err) => {