@jsonstudio/rcc 0.89.333 → 0.89.548

package/node_modules/@jsonstudio/llms/dist/telemetry/stats-center.d.ts

@@ -0,0 +1,73 @@
+export interface VirtualRouterHitEvent {
+    requestId: string;
+    timestamp: number;
+    entryEndpoint: string;
+    routeName: string;
+    pool: string;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType?: string;
+    modelId?: string;
+}
+export interface ProviderUsageEvent {
+    requestId: string;
+    timestamp: number;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType: string;
+    modelId?: string;
+    routeName?: string;
+    entryEndpoint?: string;
+    success: boolean;
+    latencyMs: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+}
+export interface RouterStatsBucket {
+    requestCount: number;
+    poolHitCount: Record<string, number>;
+    routeHitCount: Record<string, number>;
+    providerHitCount: Record<string, number>;
+}
+export interface RouterStatsSnapshot {
+    global: RouterStatsBucket;
+    byEntryEndpoint: Record<string, RouterStatsBucket>;
+}
+export interface ProviderStatsBucket {
+    requestCount: number;
+    successCount: number;
+    errorCount: number;
+    latencySumMs: number;
+    minLatencyMs: number;
+    maxLatencyMs: number;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export interface ProviderStatsSnapshot {
+    global: ProviderStatsBucket;
+    byProviderKey: Record<string, ProviderStatsBucket>;
+    byRoute: Record<string, ProviderStatsBucket>;
+    byEntryEndpoint: Record<string, ProviderStatsBucket>;
+}
+export interface StatsSnapshot {
+    router: RouterStatsSnapshot;
+    providers: ProviderStatsSnapshot;
+}
+export interface StatsCenterOptions {
+    enable?: boolean;
+    autoPrintOnExit?: boolean;
+    persistPath?: string | null;
+}
+export interface StatsCenter {
+    recordVirtualRouterHit(ev: VirtualRouterHitEvent): void;
+    recordProviderUsage(ev: ProviderUsageEvent): void;
+    getSnapshot(): StatsSnapshot;
+    flushToDisk(): Promise<void>;
+    reset(): void;
+}
+export declare function initStatsCenter(options?: StatsCenterOptions): StatsCenter;
+export declare function getStatsCenter(): StatsCenter;

package/node_modules/@jsonstudio/llms/dist/telemetry/stats-center.js

@@ -0,0 +1,280 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+function createEmptyRouterBucket() {
+    return {
+        requestCount: 0,
+        poolHitCount: {},
+        routeHitCount: {},
+        providerHitCount: {}
+    };
+}
+function createEmptyProviderBucket() {
+    return {
+        requestCount: 0,
+        successCount: 0,
+        errorCount: 0,
+        latencySumMs: 0,
+        minLatencyMs: Number.POSITIVE_INFINITY,
+        maxLatencyMs: 0,
+        usage: {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+        }
+    };
+}
+function createEmptySnapshot() {
+    return {
+        router: {
+            global: createEmptyRouterBucket(),
+            byEntryEndpoint: {}
+        },
+        providers: {
+            global: createEmptyProviderBucket(),
+            byProviderKey: {},
+            byRoute: {},
+            byEntryEndpoint: {}
+        }
+    };
+}
+class NoopStatsCenter {
+    recordVirtualRouterHit() { }
+    recordProviderUsage() { }
+    getSnapshot() { return createEmptySnapshot(); }
+    async flushToDisk() { }
+    reset() { }
+}
+class DefaultStatsCenter {
+    snapshot = createEmptySnapshot();
+    dirty = false;
+    flushInFlight = false;
+    persistPath;
+    constructor(persistPath) {
+        if (persistPath === null) {
+            this.persistPath = null;
+        }
+        else if (typeof persistPath === 'string' && persistPath.trim().length) {
+            this.persistPath = persistPath.trim();
+        }
+        else {
+            const base = path.join(os.homedir(), '.routecodex', 'stats');
+            this.persistPath = path.join(base, 'stats.json');
+        }
+    }
+    recordVirtualRouterHit(ev) {
+        if (!ev || !ev.routeName || !ev.providerKey) {
+            return;
+        }
+        const snap = this.snapshot;
+        this.applyRouterHitToBucket(snap.router.global, ev);
+        const entryKey = ev.entryEndpoint || 'unknown';
+        if (!snap.router.byEntryEndpoint[entryKey]) {
+            snap.router.byEntryEndpoint[entryKey] = createEmptyRouterBucket();
+        }
+        this.applyRouterHitToBucket(snap.router.byEntryEndpoint[entryKey], ev);
+        this.dirty = true;
+    }
+    recordProviderUsage(ev) {
+        if (!ev || !ev.providerKey || !ev.providerType) {
+            return;
+        }
+        const snap = this.snapshot;
+        this.applyProviderUsageToBucket(snap.providers.global, ev);
+        const providerKey = ev.providerKey;
+        if (!snap.providers.byProviderKey[providerKey]) {
+            snap.providers.byProviderKey[providerKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byProviderKey[providerKey], ev);
+        const routeKey = ev.routeName || 'unknown';
+        if (!snap.providers.byRoute[routeKey]) {
+            snap.providers.byRoute[routeKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byRoute[routeKey], ev);
+        const entryKey = ev.entryEndpoint || 'unknown';
+        if (!snap.providers.byEntryEndpoint[entryKey]) {
+            snap.providers.byEntryEndpoint[entryKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byEntryEndpoint[entryKey], ev);
+        this.dirty = true;
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    reset() {
+        this.snapshot = createEmptySnapshot();
+        this.dirty = false;
+    }
+    async flushToDisk() {
+        if (!this.persistPath || !this.dirty || this.flushInFlight) {
+            return;
+        }
+        this.flushInFlight = true;
+        try {
+            const dir = path.dirname(this.persistPath);
+            await fs.mkdir(dir, { recursive: true });
+            const payload = JSON.stringify(this.snapshot, null, 2);
+            await fs.writeFile(this.persistPath, payload, 'utf-8');
+            this.dirty = false;
+        }
+        catch {
+            // ignore persistence errors
+        }
+        finally {
+            this.flushInFlight = false;
+        }
+    }
+    applyRouterHitToBucket(bucket, ev) {
+        bucket.requestCount += 1;
+        if (ev.pool) {
+            bucket.poolHitCount[ev.pool] = (bucket.poolHitCount[ev.pool] || 0) + 1;
+        }
+        if (ev.routeName) {
+            bucket.routeHitCount[ev.routeName] = (bucket.routeHitCount[ev.routeName] || 0) + 1;
+        }
+        if (ev.providerKey) {
+            bucket.providerHitCount[ev.providerKey] = (bucket.providerHitCount[ev.providerKey] || 0) + 1;
+        }
+    }
+    applyProviderUsageToBucket(bucket, ev) {
+        bucket.requestCount += 1;
+        if (ev.success) {
+            bucket.successCount += 1;
+        }
+        else {
+            bucket.errorCount += 1;
+        }
+        if (Number.isFinite(ev.latencyMs) && ev.latencyMs >= 0) {
+            bucket.latencySumMs += ev.latencyMs;
+            if (ev.latencyMs < bucket.minLatencyMs) {
+                bucket.minLatencyMs = ev.latencyMs;
+            }
+            if (ev.latencyMs > bucket.maxLatencyMs) {
+                bucket.maxLatencyMs = ev.latencyMs;
+            }
+        }
+        if (typeof ev.promptTokens === 'number' && Number.isFinite(ev.promptTokens)) {
+            bucket.usage.promptTokens += Math.max(0, ev.promptTokens);
+        }
+        if (typeof ev.completionTokens === 'number' && Number.isFinite(ev.completionTokens)) {
+            bucket.usage.completionTokens += Math.max(0, ev.completionTokens);
+        }
+        if (typeof ev.totalTokens === 'number' && Number.isFinite(ev.totalTokens)) {
+            bucket.usage.totalTokens += Math.max(0, ev.totalTokens);
+        }
+        else {
+            const derivedTotal = (typeof ev.promptTokens === 'number' ? Math.max(0, ev.promptTokens) : 0) +
+                (typeof ev.completionTokens === 'number' ? Math.max(0, ev.completionTokens) : 0);
+            bucket.usage.totalTokens += derivedTotal;
+        }
+    }
+}
+let instance = null;
+function resolveEnableFlag(defaultValue) {
+    const raw = process.env.ROUTECODEX_STATS;
+    if (!raw)
+        return defaultValue;
+    const normalized = raw.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return defaultValue;
+}
+function printStatsToConsole(snapshot) {
+    const router = snapshot.router;
+    const providers = snapshot.providers;
+    const totalRequests = router.global.requestCount;
+    const poolEntries = Object.entries(router.global.poolHitCount);
+    const providerEntries = Object.entries(router.global.providerHitCount);
+    // Router summary
+    // eslint-disable-next-line no-console
+    console.log('[stats] Virtual Router:');
+    // eslint-disable-next-line no-console
+    console.log(`  total requests: ${totalRequests}`);
+    if (poolEntries.length) {
+        // eslint-disable-next-line no-console
+        console.log('  pools:');
+        for (const [pool, count] of poolEntries) {
+            const ratio = totalRequests > 0 ? (count / totalRequests) * 100 : 0;
+            // eslint-disable-next-line no-console
+            console.log(`    ${pool}: ${count} (${ratio.toFixed(2)}%)`);
+        }
+    }
+    if (providerEntries.length) {
+        // eslint-disable-next-line no-console
+        console.log('  top providers:');
+        const sorted = providerEntries.sort((a, b) => b[1] - a[1]).slice(0, 5);
+        for (const [providerKey, count] of sorted) {
+            // eslint-disable-next-line no-console
+            console.log(`    ${providerKey}: ${count}`);
+        }
+    }
+    const globalProvider = providers.global;
+    const totalProviderRequests = globalProvider.requestCount;
+    const avgLatency = globalProvider.successCount > 0 ? globalProvider.latencySumMs / globalProvider.successCount : 0;
+    // Provider summary
+    // eslint-disable-next-line no-console
+    console.log('\n[stats] Providers:');
+    // eslint-disable-next-line no-console
+    console.log(`  total requests : ${totalProviderRequests} (success=${globalProvider.successCount}, error=${globalProvider.errorCount})`);
+    // eslint-disable-next-line no-console
+    console.log(`  avg latency    : ${avgLatency.toFixed(1)} ms`);
+    // eslint-disable-next-line no-console
+    console.log(`  total tokens   : prompt=${globalProvider.usage.promptTokens} completion=${globalProvider.usage.completionTokens} total=${globalProvider.usage.totalTokens}`);
+}
+export function initStatsCenter(options) {
+    if (instance) {
+        return instance;
+    }
+    const enabled = resolveEnableFlag(options?.enable ?? true);
+    if (!enabled) {
+        instance = new NoopStatsCenter();
+        return instance;
+    }
+    const center = new DefaultStatsCenter(options?.persistPath);
+    instance = center;
+    const autoPrint = options?.autoPrintOnExit !== false;
+    if (autoPrint && typeof process !== 'undefined' && typeof process.on === 'function') {
+        const handler = async () => {
+            try {
+                await center.flushToDisk();
+            }
+            catch {
+                // ignore
+            }
+            try {
+                const snapshot = center.getSnapshot();
+                printStatsToConsole(snapshot);
+            }
+            catch {
+                // ignore
+            }
+        };
+        try {
+            process.once('beforeExit', handler);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            process.once('SIGINT', handler);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            process.once('SIGTERM', handler);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return instance;
+}
+export function getStatsCenter() {
+    if (!instance) {
+        return initStatsCenter();
+    }
+    return instance;
+}

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/rcc",
-  "version": "0.89.333",
+  "version": "0.89.548",
   "description": "Multi-provider OpenAI proxy server with anthropic/responses/chat support (dev)",
   "type": "module",
   "main": "dist/index.js",
@@ -126,7 +126,8 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.65.0",
-    "@jsonstudio/llms": "^0.6.203",
+    "@jsonstudio/llms": "^0.6.375",
+    "@jsonstudio/rcc": "^0.89.524",
     "@lmstudio/sdk": "^1.5.0",
     "@radix-ui/react-switch": "^1.2.6",
     "@types/socket.io": "^3.0.1",

package/scripts/pack-mode.mjs

@@ -59,11 +59,12 @@ try {
   if (args.name === 'routecodex' || args.name === 'rcc') {
     mutated.bundledDependencies = [];
     mutated.bundleDependencies = [];
+    const llmsVersion = original.dependencies?.['@jsonstudio/llms'] || '^0.6.230';
     mutated.dependencies = {
       ...(original.dependencies || {}),
       "ajv": original.dependencies?.ajv || "^8.17.1",
       "zod": original.dependencies?.zod || "^3.23.8",
-      "@jsonstudio/llms": original.dependencies?.["@jsonstudio/llms"] || "^0.4.3"
+      "@jsonstudio/llms": llmsVersion
     };
   }
   fs.writeFileSync(pkgPath, JSON.stringify(mutated, null, 2));

package/scripts/publish-rcc.mjs

@@ -7,10 +7,7 @@ import { fileURLToPath } from 'node:url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '..');
 const PACK_SCRIPT = path.join(PROJECT_ROOT, 'scripts', 'pack-mode.mjs');
-const packageJson = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf-8'));
-const version = packageJson.version;
-const tarballName = `jsonstudio-rcc-${version}.tgz`;
-const tarballPath = path.join(PROJECT_ROOT, tarballName);
+const pkgPath = path.join(PROJECT_ROOT, 'package.json');
 
 function run(command, args, options = {}) {
   const res = spawnSync(command, args, { stdio: 'inherit', ...options });
@@ -20,11 +17,30 @@ function run(command, args, options = {}) {
 }
 
 try {
+  // 1) 使用 release 模式构建 dist（依赖 npm 上的 @jsonstudio/llms）
+  run('npm', ['run', 'build:min'], {
+    cwd: PROJECT_ROOT,
+    env: { ...process.env, BUILD_MODE: 'release' }
+  });
+
+  // 2) 通过 pack-mode 生成 rcc tarball（内部会临时切换 package.json.name/bin 并确保 llms 为 release 包）
   run(process.execPath, [PACK_SCRIPT, '--name', '@jsonstudio/rcc', '--bin', 'rcc'], { cwd: PROJECT_ROOT });
+
+  // 构建过程中版本号可能被 bump（gen-build-info 会 auto-bump），因此需要在 pack 之后重新读取版本号
+  const updatedPkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  const version = updatedPkg.version;
+  const tarballName = `jsonstudio-rcc-${version}.tgz`;
+  const tarballPath = path.join(PROJECT_ROOT, tarballName);
+
   if (!fs.existsSync(tarballPath)) {
     throw new Error(`tarball not found: ${tarballPath}`);
   }
+
+  // 3) 发布 npm 包
   run('npm', ['publish', tarballName], { cwd: PROJECT_ROOT });
+
+  // 4) pack-mode 会在内部检测 dev 链接并调用 ensure-llmswitch-mode 恢复 dev 模式，
+  //    因此此处不再额外修改 BUILD_MODE 或重新 link。后续本地如需 dev build，可单独运行 `npm run build:dev`。
 } catch (err) {
   console.error('[publish-rcc] failed:', err.message);
   process.exit(1);

package/scripts/test-iflow-web-search.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * IFlow web_search 直连测试脚本（不经过 RouteCodex pipeline）
+ *
+ * 目标：完全复用 iFlow CLI 内置 WebSearchTool 的请求协议，验证
+ * `https://apis.iflow.cn/v1/chat/retrieve` 能否正常返回搜索结果。
+ *
+ * 用法：
+ *   node scripts/test-iflow-web-search.mjs
+ *
+ * 可选环境变量：
+ *   IFLOW_SETTINGS_PATH   自定义 settings.json 路径（默认 ~/.iflow/settings.json）
+ *   IFLOW_SEARCH_QUERY    搜索关键词（默认: "today international news 2025"）
+ */
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+async function main() {
+  const settingsPath =
+    process.env.IFLOW_SETTINGS_PATH ||
+    path.join(os.homedir(), '.iflow', 'settings.json');
+  const query =
+    process.env.IFLOW_SEARCH_QUERY || 'today international news 2025';
+
+  console.log(
+    `[iflow-web-search] Using settings: ${settingsPath}, query="${query}"`
+  );
+
+  const settingsRaw = await fs.readFile(settingsPath, 'utf-8');
+  const settings = JSON.parse(settingsRaw);
+
+  const baseUrl =
+    (typeof settings.baseUrl === 'string' && settings.baseUrl.trim()) ||
+    'https://apis.iflow.cn/v1';
+  const searchApiKey =
+    (typeof settings.searchApiKey === 'string' &&
+      settings.searchApiKey.trim()) ||
+    (typeof settings.apiKey === 'string' && settings.apiKey.trim()) ||
+    null;
+
+  if (!searchApiKey) {
+    console.error(
+      '[iflow-web-search] ERROR: searchApiKey/apiKey not found in settings.json'
+    );
+    process.exit(1);
+  }
+
+  const url = `${baseUrl.replace(/\/$/, '')}/chat/retrieve`;
+
+  // Body 对齐 iFlow CLI WebSearchTool.executeInternal
+  const body = {
+    query,
+    history: {},
+    userId: 2,
+    userIp: '42.120.74.197',
+    appCode: 'SEARCH_CHATBOT',
+    chatId: Date.now(), // 使用时间戳作为 chatId 即可
+    phase: 'UNIFY',
+    enableQueryRewrite: false,
+    enableRetrievalSecurity: false,
+    enableIntention: false,
+    searchEngineList: ['GOOGLE', 'BING', 'SCHOLAR', 'AIPGC', 'PDF']
+  };
+
+  console.log(`[iflow-web-search] POST ${url}`);
+
+  const controller = new AbortController();
+  const timeoutMs = Number(process.env.IFLOW_SEARCH_TIMEOUT_MS || '30000');
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${searchApiKey}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+
+    clearTimeout(timeoutId);
+
+    console.log(`[iflow-web-search] HTTP ${res.status}`);
+    const json = await res.json().catch(async () => {
+      const text = await res.text();
+      console.error('[iflow-web-search] Non-JSON response:', text.slice(0, 500));
+      throw new Error('Response is not valid JSON');
+    });
+
+    const dataArray = Array.isArray(json?.data) ? json.data : [];
+    console.log(
+      `[iflow-web-search] data.length = ${dataArray.length}, keys=${Object.keys(
+        json || {}
+      ).join(',')}`
+    );
+
+    if (!res.ok) {
+      console.error(
+        '[iflow-web-search] ERROR: upstream returned non-200 status',
+        JSON.stringify(json, null, 2).slice(0, 2000)
+      );
+      process.exit(1);
+    }
+
+    if (!dataArray.length) {
+      console.warn(
+        '[iflow-web-search] WARN: data array is empty, check query or account permissions.'
+      );
+    } else {
+      const first = dataArray[0] || {};
+      console.log(
+        '[iflow-web-search] First item:',
+        JSON.stringify(
+          {
+            title: first.title,
+            url: first.url,
+            time: first.time,
+            abstractInfo: first.abstractInfo
+          },
+          null,
+          2
+        )
+      );
+    }
+
+    console.log('[iflow-web-search] ✅ connectivity OK');
+  } catch (error) {
+    clearTimeout(timeoutId);
+    console.error('[iflow-web-search] ❌ request failed:', error);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('[iflow-web-search] ❌ unexpected error:', error);
+  process.exit(1);
+});
+

package/scripts/test-iflow.mjs

@@ -32,7 +32,8 @@ const args = Object.fromEntries(process.argv.slice(2).map(kv => {
 const MODE = String(args.mode || process.env.MODE || 'proxy');
 const RC_BASE = String(process.env.RC_BASE || 'http://127.0.0.1:5506').replace(/\/$/, '');
 const RC_ENDPOINT = String(args.endpoint || process.env.RC_ENDPOINT || '/v1/chat/completions');
-const IFLOW_MODEL = String(process.env.IFLOW_MODEL || 'gpt-4o-mini');
+// 默认模型更新为 iFlow-ROME-30BA3B，除非通过 IFLOW_MODEL 显式覆盖。
+const IFLOW_MODEL = String(process.env.IFLOW_MODEL || 'iFlow-ROME-30BA3B');
 const TEXT = String(process.env.TEXT || 'hello from RouteCodex test');
 const RUN_TOOLS = !!args.tools;
 const CONFIG_PATH = expandHome(String(process.env.CONFIG || args.config || path.join(os.homedir(), '.routecodex', 'config', 'v2', 'iflow-only.json')));
@@ -170,6 +171,93 @@ async function requestUpstreamChat(oauth, token) {
   try { console.log(JSON.stringify(JSON.parse(body), null, 2)); } catch { console.log(body); }
 }
 
+async function requestUpstreamWebSearch(oauth, token) {
+  const url = `${oauth.apiBase.replace(/\/$/, '')}/chat/completions`;
+  const payload = {
+    model: IFLOW_MODEL,
+    messages: [
+      {
+        role: 'system',
+        content: 'You are an up-to-date web search engine. Call the web_search tool to fetch current results, then answer based on the tool output.'
+      },
+      {
+        role: 'user',
+        content: `${TEXT}. 请先调用 web_search 工具检索相关信息，再根据搜索结果回答。`
+      }
+    ],
+    tools: [
+      {
+        type: 'function',
+        function: {
+          name: 'web_search',
+          description: 'Perform web search over the public internet and return up-to-date results.',
+          parameters: {
+            type: 'object',
+            properties: {
+              query: {
+                type: 'string',
+                description: 'Search query string.'
+              },
+              recency: {
+                type: 'string',
+                description: 'Optional recency filter such as "day", "week", or "month".'
+              },
+              count: {
+                type: 'integer',
+                minimum: 1,
+                maximum: 50,
+                description: 'Maximum number of search results to retrieve (1-50).'
+              }
+            },
+            required: ['query']
+          }
+        }
+      }
+    ],
+    tool_choice: {
+      type: 'function',
+      function: {
+        name: 'web_search'
+      }
+    },
+    stream: false
+  };
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${token.access_token}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(payload)
+  });
+  const text = await res.text();
+  console.log(`[UPSTREAM][web_search] status=${res.status}`);
+  let json = null;
+  try {
+    json = JSON.parse(text);
+    console.log(JSON.stringify(json, null, 2));
+  } catch {
+    console.log(text);
+    throw new Error('iflow web_search returned non-JSON payload');
+  }
+  if (!res.ok) {
+    throw new Error(`iflow web_search failed: HTTP ${res.status}`);
+  }
+  const firstChoice = Array.isArray(json.choices) ? json.choices[0] : null;
+  const msg = firstChoice?.message || {};
+  const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+  console.log(`[UPSTREAM][web_search] tool_calls=${toolCalls.length}`);
+  if (!toolCalls.length) {
+    console.warn('[UPSTREAM][web_search] no tool_calls returned, web_search tool may not be enabled for this model.');
+  } else {
+    const names = toolCalls
+      .map((tc) => (tc && tc.function && typeof tc.function.name === 'string' ? tc.function.name : ''))
+      .filter(Boolean);
+    console.log(`[UPSTREAM][web_search] tool names: ${names.join(', ')}`);
+  }
+}
+
 async function requestProxyChat() {
   const url = `${RC_BASE}${RC_ENDPOINT}`;
   const payload = { model: IFLOW_MODEL, messages: [{ role: 'user', content: TEXT }], stream: false };
@@ -276,6 +364,10 @@ async function main() {
     await requestUpstreamChat(oauth, token);
     return;
   }
+  if (MODE === 'websearch') {
+    await requestUpstreamWebSearch(oauth, token);
+    return;
+  }
   if (RUN_TOOLS) {
     await requestProxyChat(); // warmup
     await runResponsesToolLoop();