@jsonstudio/llms 0.6.230 → 0.6.467

package/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -11,6 +11,10 @@ import { writeCompatSnapshot } from '../../../compat/actions/snapshot.js';
 import { applyQwenRequestTransform, applyQwenResponseTransform } from '../../../compat/actions/qwen-transform.js';
 import { extractGlmToolMarkup } from '../../../compat/actions/glm-tool-extraction.js';
 import { applyGlmWebSearchRequestTransform } from '../../../compat/actions/glm-web-search.js';
+import { applyGeminiWebSearchCompat } from '../../../compat/actions/gemini-web-search.js';
+import { applyIflowWebSearchRequestTransform } from '../../../compat/actions/iflow-web-search.js';
+import { applyGlmImageContentTransform } from '../../../compat/actions/glm-image-content.js';
+import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -163,6 +167,26 @@ function applyMapping(root, mapping, state) {
                 replaceRoot(root, applyGlmWebSearchRequestTransform(root));
             }
             break;
+        case 'gemini_web_search_request':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyGeminiWebSearchCompat(root, state.adapterContext));
+            }
+            break;
+        case 'iflow_web_search_request':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyIflowWebSearchRequestTransform(root, state.adapterContext));
+            }
+            break;
+        case 'glm_image_content':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyGlmImageContentTransform(root));
+            }
+            break;
+        case 'glm_vision_prompt':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyGlmVisionPromptTransform(root));
+            }
+            break;
         default:
             break;
     }

package/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -100,6 +100,14 @@ export type MappingInstruction = {
     action: 'qwen_response_transform';
 } | {
     action: 'glm_web_search_request';
+} | {
+    action: 'glm_image_content';
+} | {
+    action: 'glm_vision_prompt';
+} | {
+    action: 'gemini_web_search_request';
+} | {
+    action: 'iflow_web_search_request';
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -21,6 +21,7 @@ import { runReqProcessStage2RouteSelect } from './stages/req_process/req_process
 import { runReqOutboundStage1SemanticMap } from './stages/req_outbound/req_outbound_stage1_semantic_map/index.js';
 import { runReqOutboundStage2FormatBuild } from './stages/req_outbound/req_outbound_stage2_format_build/index.js';
 import { runReqOutboundStage3Compat } from './stages/req_outbound/req_outbound_stage3_compat/index.js';
+import { extractSessionIdentifiersFromMetadata } from './session-identifiers.js';
 export class HubPipeline {
     routerEngine;
     config;
@@ -120,6 +121,10 @@ export class HubPipeline {
         const responsesResume = normalizedMeta && typeof normalizedMeta.responsesResume === 'object'
             ? normalizedMeta.responsesResume
             : undefined;
+        const stdMetadata = workingRequest?.metadata;
+        const serverToolRequired = stdMetadata?.webSearchEnabled === true ||
+            stdMetadata?.serverToolRequired === true;
+        const sessionIdentifiers = extractSessionIdentifiersFromMetadata(normalized.metadata);
         const metadataInput = {
             requestId: normalized.id,
             entryEndpoint: normalized.entryEndpoint,
@@ -129,7 +134,10 @@ export class HubPipeline {
             providerProtocol: normalized.providerProtocol,
             routeHint: normalized.routeHint,
             stage: normalized.stage,
-            responsesResume: responsesResume
+            responsesResume: responsesResume,
+            ...(serverToolRequired ? { serverToolRequired: true } : {}),
+            ...(sessionIdentifiers.sessionId ? { sessionId: sessionIdentifiers.sessionId } : {}),
+            ...(sessionIdentifiers.conversationId ? { conversationId: sessionIdentifiers.conversationId } : {})
         };
         const routing = runReqProcessStage2RouteSelect({
             routerEngine: this.routerEngine,
@@ -230,8 +238,25 @@ export class HubPipeline {
                 }
             });
         }
+        // 为响应侧 servertool/web_search 提供一次性 Chat 请求快照，便于在 Hub 内部实现
+        // 第三跳（将工具结果注入消息历史后重新调用主模型）。
+        let capturedChatRequest;
+        if (normalized.processMode !== 'passthrough') {
+            try {
+                capturedChatRequest = JSON.parse(JSON.stringify({
+                    model: workingRequest.model,
+                    messages: workingRequest.messages,
+                    tools: workingRequest.tools,
+                    parameters: workingRequest.parameters
+                }));
+            }
+            catch {
+                capturedChatRequest = undefined;
+            }
+        }
         const metadata = {
             ...normalized.metadata,
+            ...(capturedChatRequest ? { capturedChatRequest } : {}),
             entryEndpoint: normalized.entryEndpoint,
             providerProtocol: outboundProtocol,
             stream: normalized.stream,
@@ -351,6 +376,12 @@ export class HubPipeline {
         if (typeof metadata.assignedModelId === 'string') {
             adapterContext.modelId = metadata.assignedModelId;
         }
+        // 将 serverToolFollowup 等 ServerTool 相关标记从 normalized.metadata 透传到 AdapterContext，
+        // 便于响应侧的 convertProviderResponse 正确识别“二跳/内部跳转”并跳过 servertool 编排。
+        if (Object.prototype.hasOwnProperty.call(metadata, 'serverToolFollowup')) {
+            adapterContext.serverToolFollowup = metadata
+                .serverToolFollowup;
+        }
         if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
             adapterContext.compatibilityProfile = target.compatibilityProfile;
         }

package/dist/conversion/hub/pipeline/session-identifiers.d.ts

@@ -0,0 +1,9 @@
+export interface SessionIdentifiers {
+    sessionId?: string;
+    conversationId?: string;
+}
+export declare function extractSessionIdentifiersFromMetadata(metadata: Record<string, unknown> | undefined): SessionIdentifiers;
+export declare function coerceClientHeaders(raw: unknown): Record<string, string> | undefined;
+export declare function pickHeader(headers: Record<string, string>, candidates: string[]): string | undefined;
+export declare function findHeaderValue(headers: Record<string, string>, target: string): string | undefined;
+export declare function normalizeHeaderKey(value: string): string;

package/dist/conversion/hub/pipeline/session-identifiers.js

@@ -0,0 +1,76 @@
+export function extractSessionIdentifiersFromMetadata(metadata) {
+    const directSession = normalizeIdentifier(metadata?.sessionId);
+    const directConversation = normalizeIdentifier(metadata?.conversationId);
+    const headers = coerceClientHeaders(metadata?.clientHeaders);
+    const sessionId = directSession ||
+        (headers ? pickHeader(headers, ['session_id', 'session-id', 'x-session-id', 'anthropic-session-id']) : undefined);
+    const conversationId = directConversation ||
+        (headers
+            ? pickHeader(headers, [
+                'conversation_id',
+                'conversation-id',
+                'x-conversation-id',
+                'anthropic-conversation-id',
+                'openai-conversation-id'
+            ])
+            : undefined);
+    return {
+        ...(sessionId ? { sessionId } : {}),
+        ...(conversationId ? { conversationId } : {})
+    };
+}
+export function coerceClientHeaders(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === 'string' && value.trim()) {
+            normalized[key] = value;
+        }
+    }
+    return Object.keys(normalized).length ? normalized : undefined;
+}
+export function pickHeader(headers, candidates) {
+    for (const name of candidates) {
+        const value = findHeaderValue(headers, name);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+export function findHeaderValue(headers, target) {
+    const lowered = typeof target === 'string' ? target.toLowerCase() : '';
+    if (!lowered) {
+        return undefined;
+    }
+    const normalizedTarget = normalizeHeaderKey(lowered);
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value !== 'string') {
+            continue;
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const loweredKey = key.toLowerCase();
+        if (loweredKey === lowered) {
+            return trimmed;
+        }
+        if (normalizeHeaderKey(loweredKey) === normalizedTarget) {
+            return trimmed;
+        }
+    }
+    return undefined;
+}
+export function normalizeHeaderKey(value) {
+    return value.replace(/[\s_-]+/g, '');
+}
+function normalizeIdentifier(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js

@@ -1,5 +1,17 @@
 import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
 import { recordStage } from '../../../stages/utils.js';
+import { ProviderProtocolError } from '../../../../../shared/errors.js';
+function resolveProviderType(protocol) {
+    if (protocol === 'openai-chat')
+        return 'openai';
+    if (protocol === 'openai-responses')
+        return 'responses';
+    if (protocol === 'anthropic-messages')
+        return 'anthropic';
+    if (protocol === 'gemini-chat')
+        return 'gemini';
+    return undefined;
+}
 export async function runRespInboundStage1SseDecode(options) {
     const stream = extractSseStream(options.payload);
     if (!stream) {
@@ -15,7 +27,15 @@ export async function runRespInboundStage1SseDecode(options) {
             reason: 'protocol_unsupported',
             protocol: options.providerProtocol
         });
-        throw new Error(`[resp_inbound_stage1_sse_decode] Protocol ${options.providerProtocol} does not support SSE decoding`);
+        throw new ProviderProtocolError(`[resp_inbound_stage1_sse_decode] Protocol ${options.providerProtocol} does not support SSE decoding`, {
+            code: 'SSE_DECODE_ERROR',
+            protocol: options.providerProtocol,
+            providerType: resolveProviderType(options.providerProtocol),
+            details: {
+                phase: 'resp_inbound_stage1_sse_decode',
+                reason: 'protocol_unsupported'
+            }
+        });
     }
     try {
         const codec = defaultSseCodecRegistry.get(options.providerProtocol);
@@ -38,7 +58,16 @@ export async function runRespInboundStage1SseDecode(options) {
             protocol: options.providerProtocol,
             error: message
         });
-        throw new Error(`[resp_inbound_stage1_sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}`);
+        throw new ProviderProtocolError(`[resp_inbound_stage1_sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}`, {
+            code: 'SSE_DECODE_ERROR',
+            protocol: options.providerProtocol,
+            providerType: resolveProviderType(options.providerProtocol),
+            details: {
+                phase: 'resp_inbound_stage1_sse_decode',
+                requestId: options.adapterContext.requestId,
+                message
+            }
+        });
     }
 }
 function supportsSseProtocol(protocol) {

package/dist/conversion/hub/pipeline/target-utils.js

@@ -9,6 +9,12 @@ export function applyTargetMetadata(metadata, target, routeName, originalModel)
     metadata.providerType = target.providerType;
     metadata.modelId = target.modelId;
     metadata.processMode = target.processMode || 'chat';
+    if (target.forceWebSearch === true) {
+        metadata.forceWebSearch = true;
+    }
+    if (target.forceVision === true) {
+        metadata.forceVision = true;
+    }
     if (target.responsesConfig?.toolCallIdStyle) {
         metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
     }

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

@@ -1,5 +1,6 @@
 import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
+import { detectLastAssistantToolCategory } from '../../../router/virtual-router/tool-signals.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
     const startTime = Date.now();
@@ -71,6 +72,14 @@ async function applyRequestToolGovernance(request, context) {
             governanceTimestamp: Date.now()
         }
     };
+    if (containsImageAttachment(merged.messages)) {
+        if (!merged.metadata) {
+            merged.metadata = {
+                originalEndpoint: request.metadata?.originalEndpoint ?? '/v1/chat/completions'
+            };
+        }
+        merged.metadata.hasImageAttachment = true;
+    }
     if (typeof inboundStreamIntent === 'boolean') {
         merged.metadata = {
             ...merged.metadata,
@@ -196,6 +205,34 @@ function castSingleTool(tool) {
         }
     };
 }
+function containsImageAttachment(messages) {
+    if (!Array.isArray(messages)) {
+        return false;
+    }
+    for (const message of messages) {
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        const content = message.content;
+        if (!Array.isArray(content)) {
+            continue;
+        }
+        for (const part of content) {
+            if (!part || typeof part !== 'object') {
+                continue;
+            }
+            const typeValue = part.type;
+            if (typeof typeValue !== 'string') {
+                continue;
+            }
+            const normalized = typeValue.toLowerCase();
+            if (normalized.includes('image')) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 function castCustomTool(tool) {
     if (!isRecord(tool)) {
         return null;
@@ -277,15 +314,34 @@ function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 function maybeInjectWebSearchTool(request, metadata) {
+    // ServerTool 二/三跳（serverToolFollowup=true）不再注入 web_search 工具，
+    // 以避免在 web_search 流程内部形成循环命中。
+    if (metadata.serverToolFollowup === true) {
+        return request;
+    }
     const rawConfig = metadata.webSearch;
     if (!rawConfig || !Array.isArray(rawConfig.engines) || rawConfig.engines.length === 0) {
         return request;
     }
-    const injectPolicy = (rawConfig.injectPolicy === 'always' || rawConfig.injectPolicy === 'selective')
+    const injectPolicy = rawConfig.injectPolicy === 'always' || rawConfig.injectPolicy === 'selective'
         ? rawConfig.injectPolicy
         : 'selective';
-    if (injectPolicy === 'selective' && !detectWebSearchIntent(request)) {
-        return request;
+    const intent = detectWebSearchIntent(request);
+    if (injectPolicy === 'selective') {
+        if (!intent.hasIntent) {
+            // 当最近一条用户消息没有明显的“联网搜索”关键词时，
+            // 如果上一轮 assistant 的工具调用已经属于搜索类（如 web_search），
+            // 则仍然视为 web_search 续写场景，强制注入 web_search 工具，
+            // 以便在后续路由中按 servertool 逻辑跳过不适配的 Provider（例如 serverToolsDisabled 的 crs）。
+            const assistantMessages = Array.isArray(request.messages)
+                ? request.messages.filter((msg) => msg && msg.role === 'assistant')
+                : [];
+            const lastTool = detectLastAssistantToolCategory(assistantMessages);
+            const hasSearchToolContext = lastTool?.category === 'search';
+            if (!hasSearchToolContext) {
+                return request;
+            }
+        }
     }
     const existingTools = Array.isArray(request.tools) ? request.tools : [];
     const hasWebSearch = existingTools.some((tool) => {
@@ -295,9 +351,35 @@ function maybeInjectWebSearchTool(request, metadata) {
         return typeof fn?.name === 'string' && fn.name.trim() === 'web_search';
     });
     if (hasWebSearch) {
-        return request;
+        const nextMetadata = {
+            ...(request.metadata ?? {}),
+            webSearchEnabled: true
+        };
+        return {
+            ...request,
+            metadata: nextMetadata
+        };
+    }
+    let engines = rawConfig.engines.filter((engine) => typeof engine?.id === 'string' && !!engine.id.trim() && !engine.serverToolsDisabled);
+    // 当用户明确要求「谷歌搜索」时，只暴露 Gemini / Antigravity 类搜索后端：
+    // - providerKey 以 gemini-cli. 或 antigravity. 开头；
+    // - 或 engine id 中包含 "google"（向前兼容配置中用 id 标识 google 引擎的场景）。
+    if (intent.googlePreferred) {
+        const preferred = engines.filter((engine) => {
+            const id = engine.id.trim().toLowerCase();
+            const providerKey = (engine.providerKey || '').toLowerCase();
+            if (providerKey.startsWith('gemini-cli.') || providerKey.startsWith('antigravity.')) {
+                return true;
+            }
+            if (id.includes('google')) {
+                return true;
+            }
+            return false;
+        });
+        if (preferred.length > 0) {
+            engines = preferred;
+        }
     }
-    const engines = rawConfig.engines.filter((engine) => typeof engine?.id === 'string' && !!engine.id.trim());
     if (!engines.length) {
         return request;
     }
@@ -311,19 +393,14 @@ function maybeInjectWebSearchTool(request, metadata) {
         return desc ? `${id}: ${desc}` : id;
     })
         .join('; ');
-    const hasMultipleEngines = engineIds.length > 1;
     const parameters = {
         type: 'object',
         properties: {
-            ...(hasMultipleEngines
-                ? {
-                    engine: {
-                        type: 'string',
-                        enum: engineIds,
-                        description: engineDescriptions
-                    }
-                }
-                : {}),
+            engine: {
+                type: 'string',
+                enum: engineIds,
+                description: engineDescriptions
+            },
             query: {
                 type: 'string',
                 description: 'Search query or user question.'
@@ -340,7 +417,9 @@ function maybeInjectWebSearchTool(request, metadata) {
                 description: 'Number of results to retrieve.'
             }
         },
-        required: ['query'],
+        // 对于 Responses 内建 web_search，required 需要覆盖 properties 中的所有字段，
+        // 否则上游会报 "required is required to be supplied and to be an array including every key in properties"。
+        required: ['engine', 'query', 'recency', 'count'],
         additionalProperties: false
     };
     const webSearchTool = {
@@ -365,42 +444,109 @@ function maybeInjectWebSearchTool(request, metadata) {
 function detectWebSearchIntent(request) {
     const messages = Array.isArray(request.messages) ? request.messages : [];
     if (!messages.length) {
-        return false;
+        return { hasIntent: false, googlePreferred: false };
     }
-    const last = messages[messages.length - 1];
-    if (!last || last.role !== 'user') {
-        return false;
+    // 从末尾向前找到最近一条 user 消息，忽略 tool / assistant 的工具调用轮次，
+    // 以便在 Responses / 多轮工具调用场景下仍然根据“最近一条用户输入”判断意图。
+    let lastUser;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (candidate && candidate.role === 'user') {
+            lastUser = candidate;
+            break;
+        }
+    }
+    if (!lastUser) {
+        return { hasIntent: false, googlePreferred: false };
+    }
+    // 支持多模态 content：既可能是纯文本字符串，也可能是带 image_url 的分段数组。
+    let content = '';
+    if (typeof lastUser.content === 'string') {
+        content = lastUser.content;
+    }
+    else if (Array.isArray(lastUser.content)) {
+        const parts = lastUser.content;
+        const texts = [];
+        for (const part of parts) {
+            if (typeof part === 'string') {
+                texts.push(part);
+            }
+            else if (part && typeof part === 'object') {
+                const maybeText = part.text;
+                if (typeof maybeText === 'string' && maybeText.trim()) {
+                    texts.push(maybeText);
+                }
+            }
+        }
+        content = texts.join('\n');
     }
-    const content = typeof last.content === 'string' ? last.content : '';
     if (!content) {
-        return false;
+        return { hasIntent: false, googlePreferred: false };
+    }
+    // Hard 100% keywords (中文)：明确说明“谷歌搜索 / 谷歌一下 / 百度一下”均视为搜索意图。
+    // 其中“谷歌搜索 / 谷歌一下”会偏向 Google/Gemini 搜索后端。
+    const zh = content;
+    const hasGoogleExplicit = zh.includes('谷歌搜索') ||
+        zh.includes('谷歌一下');
+    const hasBaiduExplicit = zh.includes('百度一下');
+    if (hasGoogleExplicit || hasBaiduExplicit) {
+        // 谷歌 / 百度关键字都会优先尝试走“谷歌搜索”引擎；
+        // 只有在 Virtual Router 未配置任何谷歌相关 engine 时，才回退为普通联网搜索。
+        return {
+            hasIntent: true,
+            googlePreferred: true
+        };
     }
+    // English intent: simple substring match on lowercased text.
     const text = content.toLowerCase();
-    const keywords = [
-        // English
+    // 1) Direct patterns like "web search" / "internet search" / "/search".
+    const englishDirect = [
         'web search',
         'web_search',
         'websearch',
         'internet search',
         'search the web',
-        'online search',
-        'search online',
-        'search on the internet',
-        'search the internet',
         'web-search',
-        'online-search',
         'internet-search',
-        // Chinese
-        '联网搜索',
-        '网络搜索',
-        '上网搜索',
-        '网上搜索',
-        '网上查',
-        '网上查找',
-        '上网查',
-        '上网搜',
-        // Command-style
         '/search'
     ];
-    return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+    if (englishDirect.some((keyword) => text.includes(keyword))) {
+        return { hasIntent: true, googlePreferred: text.includes('google') };
+    }
+    // 2) Verb + noun combinations, similar to the Chinese rule:
+    //    - verb: search / find / look up / look for / google
+    //    - noun: web / internet / online / news / information / info / report / reports / article / articles
+    const verbTokensEn = ['search', 'find', 'look up', 'look for', 'google'];
+    const nounTokensEn = [
+        'web',
+        'internet',
+        'online',
+        'news',
+        'information',
+        'info',
+        'report',
+        'reports',
+        'article',
+        'articles'
+    ];
+    const hasVerbEn = verbTokensEn.some((token) => text.includes(token));
+    const hasNounEn = nounTokensEn.some((token) => text.includes(token));
+    if (hasVerbEn && hasNounEn) {
+        return { hasIntent: true, googlePreferred: text.includes('google') };
+    }
+    // 中文规则：
+    // 1. 只要文本中包含“上网”，直接命中（例如“帮我上网看看今天的新闻”）。
+    // 2. 否则，如果同时包含「搜索/查找/搜」中的任意一个动词 + 「网络/联网/新闻/信息/报道」中的任意一个名词，也判定为联网搜索意图。
+    const chineseText = content; // 中文大小写不敏感，这里直接用原文。
+    if (chineseText.includes('上网')) {
+        return { hasIntent: true, googlePreferred: false };
+    }
+    const verbTokens = ['搜索', '查找', '搜'];
+    const nounTokens = ['网络', '联网', '新闻', '信息', '报道'];
+    const hasVerb = verbTokens.some((token) => chineseText.includes(token));
+    const hasNoun = nounTokens.some((token) => chineseText.includes(token));
+    if (hasVerb && hasNoun) {
+        return { hasIntent: true, googlePreferred: false };
+    }
+    return { hasIntent: false, googlePreferred: false };
 }

package/dist/conversion/hub/response/provider-response.d.ts

@@ -2,7 +2,7 @@ import { Readable } from 'node:stream';
 import type { AdapterContext } from '../types/chat-envelope.js';
 import type { JsonObject } from '../types/json.js';
 import type { StageRecorder } from '../format-adapters/index.js';
-import type { ProviderInvoker } from './server-side-tools.js';
+import type { ProviderInvoker } from '../../../servertool/types.js';
 type ProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
 export interface ProviderResponseConversionOptions {
     providerProtocol: ProviderProtocol;
@@ -12,6 +12,18 @@ export interface ProviderResponseConversionOptions {
     wantsStream: boolean;
     stageRecorder?: StageRecorder;
     providerInvoker?: ProviderInvoker;
+    /**
+     * 可选：由 Host 注入的二次请求入口。Server-side 工具在需要发起
+     * followup 请求（例如 web_search 二跳）时，可以通过该回调将构造
+     * 好的请求体交给 Host，由 Host 走完整 HubPipeline + VirtualRouter
+     * 再返回最终客户端响应形状。
+     */
+    reenterPipeline?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<ProviderResponseConversionResult>;
 }
 export interface ProviderResponseConversionResult {
     body?: JsonObject;