clawmarket 0.6.0 → 0.6.1

package/dist/local-proxy.js

@@ -51,7 +51,10 @@ const MIN_BALANCE = BigInt(process.env.MIN_BALANCE || DEFAULT_CONFIG.minBalance.
 const CHANNEL_DEPOSIT = BigInt(process.env.CHANNEL_DEPOSIT || DEFAULT_CONFIG.channelDeposit.toString());
 const CHANNEL_DURATION = BigInt(7 * 24 * 60 * 60);
 const COST_PER_REQUEST = 100000n; // 初始 ticket 0.1 USDC（预授权）
+const RECOVER_NONCE_STEP = 10000n; // 0.01 USDC，恢复时用于生成安全的 nonce 基线
 const SKIP_SELLER_STAKE_CHECK = false;
+// 默认关闭自动恢复旧通道，避免链上 settledAmount 与卖家本地票据状态不一致导致 nonce/increment 错误。
+const ENABLE_CHANNEL_RECOVERY = process.env.CLAW_ENABLE_CHANNEL_RECOVERY === 'true';
 // ============ 模型路由配置 ============
 const MODEL_FALLBACK = {
     'claude-opus-4-6': ['MiniMax-M2.5'],
@@ -60,6 +63,7 @@ const MODEL_FALLBACK = {
 // 默认禁用跨模型/静态模型降级，避免把用户请求切到其它模型。
 const ENABLE_CROSS_MODEL_FALLBACK = process.env.CLAW_ENABLE_CROSS_MODEL_FALLBACK === 'true';
 const ENABLE_STATIC_MODEL_FALLBACK = process.env.CLAW_ENABLE_STATIC_MODEL_FALLBACK === 'true';
+const ENABLE_FORCED_BROWSER_OPEN = process.env.CLAW_ENABLE_FORCED_BROWSER_OPEN === 'true';
 const MARKET_CACHE_TTL_MS = 10_000;
 const MARKET_FETCH_TIMEOUT_MS = 4_000;
 const RELAY_CONNECT_TIMEOUT_MS = 8_000;
@@ -67,9 +71,11 @@ const RELAY_ACCEPT_TIMEOUT_MS = 12_000;
 const STREAM_FIRST_CHUNK_TIMEOUT_MS = readMsEnv('CLAW_STREAM_FIRST_CHUNK_TIMEOUT_MS', 300_000);
 const STREAM_IDLE_TIMEOUT_MS = readMsEnv('CLAW_STREAM_IDLE_TIMEOUT_MS', 300_000);
 const STREAM_MAX_DURATION_MS = readMsEnv('CLAW_STREAM_MAX_DURATION_MS', 300_000);
+const SSE_HEARTBEAT_MS = readMsEnv('CLAW_SSE_HEARTBEAT_MS', 10_000);
 const SELLER_FAILURE_BACKOFF_BASE_MS = 15_000;
 const SELLER_FAILURE_BACKOFF_MAX_MS = 300_000;
 const SHOW_MODEL_FALLBACK_NOTICE = process.env.CLAW_SHOW_MODEL_FALLBACK_NOTICE !== 'false';
+const DEBUG_BRIDGE = process.env.CLAW_DEBUG_BRIDGE === '1';
 const CANDIDATE_ROUTE_TIMEOUT_MS = readMsEnv('CLAW_CANDIDATE_ROUTE_TIMEOUT_MS', 20_000);
 const MODEL_CANDIDATE_ROUTE_TIMEOUT_MS = {
     'gpt-5.2': readMsEnv('CLAW_GPT52_CANDIDATE_ROUTE_TIMEOUT_MS', 300_000),
@@ -102,6 +108,18 @@ let defaultSeller = '0x3137cE5612af147f1BA17eBba7e8B46594ed3e26';
 let marketCache = { fetchedAt: 0, sellers: [] };
 let sellerRuntime = new Map();
 const ticketSignLocks = new Map();
+const channelOpenLocks = new Map();
+const sseHeartbeats = new WeakMap();
+function debugBridge(tag, data) {
+    if (!DEBUG_BRIDGE)
+        return;
+    try {
+        console.log(`[bridge:${tag}] ${JSON.stringify(data)}`);
+    }
+    catch {
+        console.log(`[bridge:${tag}]`);
+    }
+}
 async function withTicketSignLock(channelId, fn) {
     const key = channelId.toLowerCase();
     const previous = ticketSignLocks.get(key) ?? Promise.resolve();
@@ -339,14 +357,29 @@ function getSellerCandidates(sellers, model) {
 }
 async function ensureChannelForSeller(sellerAddress) {
     const key = sellerAddress.toLowerCase();
-    let channel = channels.get(key);
-    if (channel && (channel.expiresAt < Date.now() / 1000 || channel.spent + COST_PER_REQUEST > channel.deposit)) {
-        channels.delete(key);
-        channel = undefined;
+    const existingLock = channelOpenLocks.get(key);
+    if (existingLock) {
+        return existingLock;
+    }
+    const task = (async () => {
+        let channel = channels.get(key);
+        if (channel && (channel.expiresAt < Date.now() / 1000 || channel.spent + COST_PER_REQUEST > channel.deposit)) {
+            channels.delete(key);
+            channel = undefined;
+        }
+        if (channel)
+            return channel;
+        return openChannel(sellerAddress);
+    })();
+    channelOpenLocks.set(key, task);
+    try {
+        return await task;
+    }
+    finally {
+        if (channelOpenLocks.get(key) === task) {
+            channelOpenLocks.delete(key);
+        }
     }
-    if (channel)
-        return channel;
-    return openChannel(sellerAddress);
 }
 function isBuyerMismatchError(reason) {
     const normalized = reason.toLowerCase();
@@ -354,6 +387,15 @@ function isBuyerMismatchError(reason) {
         normalized.includes('signer mismatch') ||
         normalized.includes('channel buyer mismatch'));
 }
+function isChannelStateSyncError(reason) {
+    const normalized = reason.toLowerCase();
+    return (normalized.includes('nonce not increasing') ||
+        normalized.includes('nonce too low') ||
+        normalized.includes('invalid nonce') ||
+        normalized.includes('increment too small') ||
+        normalized.includes('amount not increasing') ||
+        normalized.includes('ticket amount must increase'));
+}
 function invalidateSellerChannel(sellerAddress, reason) {
     const key = sellerAddress.toLowerCase();
     const existing = channels.get(key);
@@ -396,10 +438,25 @@ async function recoverChannelFromChain(sellerAddress) {
                 const channelData = await publicClient.readContract({ address: CHANNEL_CONTRACT, abi: CHANNEL_ABI, functionName: 'channels', args: [channelId] });
                 if (!channelData[6])
                     continue;
+                const deposit = channelData[2];
+                const settledAmount = channelData[3];
+                // 已经没有可用额度的通道不要恢复，避免反复命中 Amount > deposit。
+                if (settledAmount + COST_PER_REQUEST > deposit)
+                    continue;
                 const expiresAt = Number(channelData[4]);
                 if (expiresAt < Math.floor(Date.now() / 1000))
                     continue;
-                const channel = { channelId, seller: sellerAddress, deposit: channelData[2], spent: channelData[3], nonce: 0n, expiresAt };
+                // 卖家侧只要求 nonce 递增，不要求从 1 开始；恢复时给一个保守较大的基线，
+                // 避免本地丢状态后出现 Nonce not increasing。
+                const recoveredNonce = settledAmount / RECOVER_NONCE_STEP;
+                const channel = {
+                    channelId,
+                    seller: sellerAddress,
+                    deposit,
+                    spent: settledAmount,
+                    nonce: recoveredNonce,
+                    expiresAt,
+                };
                 channels.set(sellerAddress.toLowerCase(), channel);
                 saveChannels();
                 console.log('[恢复] 通道:', channelId.slice(0, 18) + '...');
@@ -414,9 +471,11 @@ async function recoverChannelFromChain(sellerAddress) {
 }
 async function openChannel(sellerAddress) {
     console.log('[链上] 开通道到:', sellerAddress);
-    const recovered = await recoverChannelFromChain(sellerAddress);
-    if (recovered)
-        return recovered;
+    if (ENABLE_CHANNEL_RECOVERY) {
+        const recovered = await recoverChannelFromChain(sellerAddress);
+        if (recovered)
+            return recovered;
+    }
     const ethBalance = await getETHBalance();
     if (ethBalance < parseUnits('0.001', 18))
         throw new Error('ETH 不足');
@@ -486,6 +545,180 @@ function parseRelayErrorPayload(payload) {
     }
     return 'unknown relay error';
 }
+function parseRelayAnthropicEventChunk(payload) {
+    let parsed = payload;
+    if (typeof parsed === 'string') {
+        try {
+            parsed = JSON.parse(parsed);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const chunk = parsed;
+    if (chunk.__clawmarket_stream_v1 !== true)
+        return null;
+    if (chunk.kind !== 'anthropic_event')
+        return null;
+    if (typeof chunk.event !== 'string' || !chunk.event.trim())
+        return null;
+    if (!chunk.data || typeof chunk.data !== 'object')
+        return null;
+    return {
+        event: chunk.event,
+        data: chunk.data,
+    };
+}
+function parseRelayOpenAIEventChunk(payload) {
+    let parsed = payload;
+    if (typeof parsed === 'string') {
+        try {
+            parsed = JSON.parse(parsed);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const chunk = parsed;
+    if (chunk.__clawmarket_stream_v1 !== true)
+        return null;
+    if (chunk.kind !== 'openai_event')
+        return null;
+    if (!chunk.data || typeof chunk.data !== 'object')
+        return null;
+    return {
+        data: chunk.data,
+    };
+}
+function extractJsonObjectsFromConcatenatedText(text) {
+    const out = [];
+    if (!text || typeof text !== 'string')
+        return out;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let start = -1;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === '{') {
+            if (depth === 0)
+                start = i;
+            depth++;
+            continue;
+        }
+        if (ch === '}') {
+            if (depth <= 0)
+                continue;
+            depth--;
+            if (depth === 0 && start >= 0) {
+                const candidate = text.slice(start, i + 1).trim();
+                start = -1;
+                if (!candidate)
+                    continue;
+                try {
+                    const parsed = JSON.parse(candidate);
+                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                        out.push(parsed);
+                    }
+                }
+                catch {
+                    // ignore invalid segment
+                }
+            }
+        }
+    }
+    return out;
+}
+function parseRelayStructuredChunks(payload) {
+    const chunks = [];
+    const anthropicSingle = parseRelayAnthropicEventChunk(payload);
+    if (anthropicSingle) {
+        chunks.push({
+            kind: 'anthropic',
+            event: anthropicSingle.event,
+            data: anthropicSingle.data,
+        });
+        return chunks;
+    }
+    const openAISingle = parseRelayOpenAIEventChunk(payload);
+    if (openAISingle) {
+        chunks.push({
+            kind: 'openai',
+            data: openAISingle.data,
+        });
+        return chunks;
+    }
+    if (typeof payload !== 'string')
+        return chunks;
+    const text = payload.trim();
+    if (!text.includes('__clawmarket_stream_v1'))
+        return chunks;
+    const objects = extractJsonObjectsFromConcatenatedText(text);
+    for (const obj of objects) {
+        const anthropicChunk = parseRelayAnthropicEventChunk(obj);
+        if (anthropicChunk) {
+            chunks.push({
+                kind: 'anthropic',
+                event: anthropicChunk.event,
+                data: anthropicChunk.data,
+            });
+            continue;
+        }
+        const openAIChunk = parseRelayOpenAIEventChunk(obj);
+        if (openAIChunk) {
+            chunks.push({
+                kind: 'openai',
+                data: openAIChunk.data,
+            });
+        }
+    }
+    return chunks;
+}
+function extractAnthropicTextDelta(eventName, eventData) {
+    if (eventName !== 'content_block_delta')
+        return '';
+    const delta = eventData.delta;
+    if (!delta || typeof delta !== 'object')
+        return '';
+    const anyDelta = delta;
+    const deltaType = typeof anyDelta.type === 'string' ? anyDelta.type : '';
+    if (deltaType && deltaType !== 'text_delta')
+        return '';
+    return typeof anyDelta.text === 'string' ? anyDelta.text : '';
+}
+function extractOpenAITextDelta(eventData) {
+    const choices = eventData.choices;
+    if (!Array.isArray(choices) || choices.length === 0)
+        return '';
+    const first = choices[0];
+    if (!first || typeof first !== 'object')
+        return '';
+    const delta = first.delta;
+    if (!delta || typeof delta !== 'object')
+        return '';
+    const content = delta.content;
+    return typeof content === 'string' ? content : '';
+}
 function isFundingError(message) {
     return message.includes('USDC 不足') || message.includes('ETH 不足');
 }
@@ -497,9 +730,45 @@ function isRetryableRouteError(reason) {
         || normalized === 'relay_connect_timeout'
         || normalized === 'relay_closed_before_stream'
         || normalized === 'empty_response_before_content'
+        || normalized.includes('nonce not increasing')
+        || normalized.includes('nonce too low')
+        || normalized.includes('invalid nonce')
+        || normalized.includes('seller busy')
+        || normalized.includes('upstream api error')
+        || normalized.includes('upstream done without visible content')
+        || normalized.includes('codex_exec_silence_timeout')
         || normalized.startsWith('relay_ws_error');
 }
-function startAnthropicSSE(res, messageId, requestedModel, servedModel, sellerId) {
+function stopSSEHeartbeat(res) {
+    const timer = sseHeartbeats.get(res);
+    if (!timer)
+        return;
+    clearInterval(timer);
+    sseHeartbeats.delete(res);
+}
+function startSSEHeartbeat(res) {
+    if (!Number.isFinite(SSE_HEARTBEAT_MS) || SSE_HEARTBEAT_MS <= 0)
+        return;
+    stopSSEHeartbeat(res);
+    const timer = setInterval(() => {
+        if (res.writableEnded || res.destroyed) {
+            stopSSEHeartbeat(res);
+            return;
+        }
+        try {
+            // SSE 注释行作为 keepalive，不影响上层解析。
+            res.write(': keep-alive\n\n');
+        }
+        catch {
+            stopSSEHeartbeat(res);
+        }
+    }, SSE_HEARTBEAT_MS);
+    if (typeof timer.unref === 'function') {
+        timer.unref();
+    }
+    sseHeartbeats.set(res, timer);
+}
+function startAnthropicSSE(res, requestedModel, servedModel, sellerId) {
     const downgraded = requestedModel !== servedModel;
     res.writeHead(200, {
         'Content-Type': 'text/event-stream',
@@ -515,6 +784,17 @@ function startAnthropicSSE(res, messageId, requestedModel, servedModel, sellerId
         served_model: servedModel,
         seller_id: sellerId,
     })}\n\n`);
+    startSSEHeartbeat(res);
+}
+function ensureAnthropicTextStreamStarted(res, messageId, servedModel) {
+    writeAnthropicMessageStart(res, messageId, servedModel);
+    res.write(`event: content_block_start\ndata: ${JSON.stringify({
+        type: 'content_block_start',
+        index: 0,
+        content_block: { type: 'text', text: '' },
+    })}\n\n`);
+}
+function writeAnthropicMessageStart(res, messageId, servedModel) {
     res.write(`event: message_start\ndata: ${JSON.stringify({
         type: 'message_start',
         message: {
@@ -526,14 +806,6 @@ function startAnthropicSSE(res, messageId, requestedModel, servedModel, sellerId
             usage: { input_tokens: 0, output_tokens: 0 },
         },
     })}\n\n`);
-    res.write(`event: content_block_start\ndata: ${JSON.stringify({
-        type: 'content_block_start',
-        index: 0,
-        content_block: { type: 'text', text: '' },
-    })}\n\n`);
-    if (SHOW_MODEL_FALLBACK_NOTICE && downgraded) {
-        writeAnthropicDelta(res, `[ClawMarket 测试提示] 请求模型 ${requestedModel} 当前不可用，已自动切换到 ${servedModel}。\n\n`);
-    }
 }
 function writeAnthropicDelta(res, text) {
     res.write(`event: content_block_delta\ndata: ${JSON.stringify({
@@ -542,7 +814,12 @@ function writeAnthropicDelta(res, text) {
         delta: { type: 'text_delta', text },
     })}\n\n`);
 }
+function writeAnthropicEvent(res, eventName, eventData) {
+    const safeName = eventName.trim() || 'message_delta';
+    res.write(`event: ${safeName}\ndata: ${JSON.stringify(eventData)}\n\n`);
+}
 function endAnthropicSSE(res, outputTokens) {
+    stopSSEHeartbeat(res);
     res.write(`event: content_block_stop\ndata: ${JSON.stringify({ type: 'content_block_stop', index: 0 })}\n\n`);
     res.write(`event: message_delta\ndata: ${JSON.stringify({
         type: 'message_delta',
@@ -553,6 +830,7 @@ function endAnthropicSSE(res, outputTokens) {
     res.end();
 }
 function failAnthropicSSE(res, message) {
+    stopSSEHeartbeat(res);
     if (!res.headersSent) {
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
@@ -594,6 +872,7 @@ function startOpenAISSE(res, completionId, createdAt, requestedModel, servedMode
             },
         ],
     });
+    startSSEHeartbeat(res);
     if (SHOW_MODEL_FALLBACK_NOTICE && downgraded) {
         writeOpenAIDelta(res, completionId, createdAt, servedModel, `[ClawMarket 测试提示] 请求模型 ${requestedModel} 当前不可用，已自动切换到 ${servedModel}。\n\n`);
     }
@@ -613,7 +892,91 @@ function writeOpenAIDelta(res, completionId, createdAt, servedModel, text) {
         ],
     });
 }
-function endOpenAISSE(res, completionId, createdAt, servedModel, outputTokens) {
+function sanitizeOpenAIToolCallDelta(raw, fallbackIndex) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const tool = raw;
+    const index = Number.isFinite(Number(tool.index)) ? Number(tool.index) : fallbackIndex;
+    const functionData = tool.function && typeof tool.function === 'object'
+        ? tool.function
+        : {};
+    const rawArguments = functionData.arguments;
+    let argsText = '';
+    if (typeof rawArguments === 'string') {
+        argsText = rawArguments;
+    }
+    else if (rawArguments !== undefined) {
+        try {
+            argsText = JSON.stringify(rawArguments);
+        }
+        catch {
+            argsText = String(rawArguments);
+        }
+    }
+    const name = typeof functionData.name === 'string' ? functionData.name : undefined;
+    const id = typeof tool.id === 'string' ? tool.id : undefined;
+    return {
+        index,
+        ...(id ? { id } : {}),
+        ...(name ? { name } : {}),
+        ...(argsText ? { arguments: argsText } : {}),
+    };
+}
+function writeOpenAIToolCallDelta(res, completionId, createdAt, servedModel, calls) {
+    if (calls.length === 0)
+        return;
+    const toolCalls = calls.map((call) => ({
+        index: call.index,
+        ...(call.id ? { id: call.id } : {}),
+        type: 'function',
+        function: {
+            ...(call.name ? { name: call.name } : {}),
+            arguments: call.arguments ?? '',
+        },
+    }));
+    writeOpenAIChunk(res, {
+        id: completionId,
+        object: 'chat.completion.chunk',
+        created: createdAt,
+        model: servedModel,
+        choices: [
+            {
+                index: 0,
+                delta: { tool_calls: toolCalls },
+                finish_reason: null,
+            },
+        ],
+    });
+}
+function applyOpenAIToolCallDelta(toolCalls, delta) {
+    const current = toolCalls.get(delta.index) || {
+        index: delta.index,
+        id: delta.id || `call_${delta.index}`,
+        name: delta.name || 'tool',
+        arguments: '',
+    };
+    if (delta.id)
+        current.id = delta.id;
+    if (delta.name)
+        current.name = delta.name;
+    if (delta.arguments)
+        current.arguments += delta.arguments;
+    toolCalls.set(delta.index, current);
+}
+function toolCallStateToOpenAIList(toolCalls) {
+    return [...toolCalls.values()]
+        .sort((a, b) => a.index - b.index)
+        .map((call) => ({
+        id: call.id,
+        type: 'function',
+        function: {
+            name: call.name,
+            arguments: call.arguments || '',
+        },
+    }));
+}
+function endOpenAISSE(res, completionId, createdAt, servedModel, outputTokens, finishReason = 'stop') {
+    stopSSEHeartbeat(res);
     writeOpenAIChunk(res, {
         id: completionId,
         object: 'chat.completion.chunk',
@@ -623,7 +986,7 @@ function endOpenAISSE(res, completionId, createdAt, servedModel, outputTokens) {
             {
                 index: 0,
                 delta: {},
-                finish_reason: 'stop',
+                finish_reason: finishReason,
             },
         ],
         usage: {
@@ -636,6 +999,7 @@ function endOpenAISSE(res, completionId, createdAt, servedModel, outputTokens) {
     res.end();
 }
 function failOpenAISSE(res, message) {
+    stopSSEHeartbeat(res);
     if (!res.headersSent) {
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
@@ -679,11 +1043,34 @@ function normalizeOpenAIMessages(rawMessages, rawInput) {
             if (!raw || typeof raw !== 'object')
                 continue;
             const msg = raw;
-            const text = extractTextFromOpenAIContent(msg.content).trim();
-            if (!text)
+            const role = typeof msg.role === 'string' ? msg.role : 'user';
+            const normalizedMsg = { role };
+            if ('content' in msg) {
+                normalizedMsg.content = msg.content ?? null;
+            }
+            if (typeof msg.tool_call_id === 'string' && msg.tool_call_id.trim()) {
+                normalizedMsg.tool_call_id = msg.tool_call_id.trim();
+            }
+            if (Array.isArray(msg.tool_calls)) {
+                normalizedMsg.tool_calls = msg.tool_calls;
+            }
+            if (msg.function_call && typeof msg.function_call === 'object') {
+                normalizedMsg.function_call = msg.function_call;
+            }
+            if (typeof msg.name === 'string' && msg.name.trim()) {
+                normalizedMsg.name = msg.name.trim();
+            }
+            if (!('content' in normalizedMsg)) {
+                const text = extractTextFromOpenAIContent(msg.content).trim();
+                if (text)
+                    normalizedMsg.content = text;
+            }
+            if (!('content' in normalizedMsg)
+                && !('tool_calls' in normalizedMsg)
+                && !('function_call' in normalizedMsg)) {
                 continue;
-            const role = msg.role === 'assistant' ? 'assistant' : 'user';
-            normalized.push({ role, content: text });
+            }
+            normalized.push(normalizedMsg);
         }
     }
     if (normalized.length === 0) {
@@ -713,6 +1100,7 @@ function normalizeOpenAIRequest(rawRequest) {
         model: requestedModel,
         stream: true,
         messages,
+        _openai_compat: true,
     };
     const maxCompletionTokens = Number(rawRequest.max_completion_tokens);
     const maxTokens = Number(rawRequest.max_tokens);
@@ -730,6 +1118,18 @@ function normalizeOpenAIRequest(rawRequest) {
     if (Number.isFinite(topP)) {
         requestPayload.top_p = topP;
     }
+    if (Array.isArray(rawRequest.tools)) {
+        requestPayload.tools = rawRequest.tools;
+    }
+    if (rawRequest.tool_choice !== undefined) {
+        requestPayload.tool_choice = rawRequest.tool_choice;
+    }
+    if (typeof rawRequest.parallel_tool_calls === 'boolean') {
+        requestPayload.parallel_tool_calls = rawRequest.parallel_tool_calls;
+    }
+    if (rawRequest.response_format && typeof rawRequest.response_format === 'object') {
+        requestPayload.response_format = rawRequest.response_format;
+    }
     return {
         requestedModel,
         stream,
@@ -809,6 +1209,233 @@ function isCursorOpenAIChallenge(rawRequest) {
     const content = extractTextFromOpenAIContent(last.content).toLowerCase();
     return content.includes('test prompt using gpt-3.5-turbo');
 }
+function isAnthropicLikeModelName(model) {
+    const lower = model.toLowerCase();
+    return (lower.includes('claude')
+        || lower.includes('anthropic')
+        || lower.includes('minimax')
+        || lower.includes('m2'));
+}
+function parseToolArguments(raw) {
+    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string') {
+        const text = raw.trim();
+        if (!text)
+            return {};
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            return { value: parsed };
+        }
+        catch {
+            return { raw: text };
+        }
+    }
+    if (raw === undefined || raw === null)
+        return {};
+    return { value: raw };
+}
+function convertOpenAIToolsToAnthropic(rawTools) {
+    if (!Array.isArray(rawTools))
+        return [];
+    const tools = [];
+    for (const item of rawTools) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const tool = item;
+        if (tool.type === 'function' && tool.function && typeof tool.function === 'object') {
+            const func = tool.function;
+            if (typeof func.name !== 'string' || !func.name.trim())
+                continue;
+            const inputSchema = (func.parameters && typeof func.parameters === 'object')
+                ? func.parameters
+                : { type: 'object', properties: {}, additionalProperties: true };
+            tools.push({
+                name: func.name.trim(),
+                ...(typeof func.description === 'string' && func.description.trim()
+                    ? { description: func.description.trim() }
+                    : {}),
+                input_schema: inputSchema,
+            });
+            continue;
+        }
+        if (typeof tool.name === 'string' && tool.name.trim()) {
+            const inputSchema = (tool.input_schema && typeof tool.input_schema === 'object')
+                ? tool.input_schema
+                : { type: 'object', properties: {}, additionalProperties: true };
+            tools.push({
+                name: tool.name.trim(),
+                ...(typeof tool.description === 'string' && tool.description.trim()
+                    ? { description: tool.description.trim() }
+                    : {}),
+                input_schema: inputSchema,
+            });
+        }
+    }
+    return tools;
+}
+function mapOpenAIToolChoiceToAnthropic(rawToolChoice) {
+    if (typeof rawToolChoice === 'string') {
+        if (rawToolChoice === 'auto')
+            return { type: 'auto' };
+        if (rawToolChoice === 'required')
+            return { type: 'any' };
+        return undefined;
+    }
+    if (!rawToolChoice || typeof rawToolChoice !== 'object')
+        return undefined;
+    const choice = rawToolChoice;
+    if (choice.type === 'function' && choice.function && typeof choice.function === 'object') {
+        const func = choice.function;
+        if (typeof func.name === 'string' && func.name.trim()) {
+            return { type: 'tool', name: func.name.trim() };
+        }
+    }
+    if (choice.type === 'tool' && typeof choice.name === 'string' && choice.name.trim()) {
+        return { type: 'tool', name: choice.name.trim() };
+    }
+    if (choice.type === 'auto' || choice.type === 'any') {
+        return { type: choice.type };
+    }
+    return undefined;
+}
+function convertOpenAIRequestToAnthropic(baseRequest, servedModel) {
+    const anthropicRequest = {
+        model: servedModel,
+        stream: true,
+    };
+    const maxTokens = Number(baseRequest.max_tokens);
+    if (Number.isFinite(maxTokens) && maxTokens > 0) {
+        anthropicRequest.max_tokens = Math.floor(maxTokens);
+    }
+    const temperature = Number(baseRequest.temperature);
+    if (Number.isFinite(temperature)) {
+        anthropicRequest.temperature = temperature;
+    }
+    const topP = Number(baseRequest.top_p);
+    if (Number.isFinite(topP)) {
+        anthropicRequest.top_p = topP;
+    }
+    const systemParts = [];
+    const messages = [];
+    const rawMessages = Array.isArray(baseRequest.messages) ? baseRequest.messages : [];
+    for (let idx = 0; idx < rawMessages.length; idx++) {
+        const raw = rawMessages[idx];
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const msg = raw;
+        const role = typeof msg.role === 'string' ? msg.role : 'user';
+        if (role === 'system') {
+            const systemText = extractTextFromOpenAIContent(msg.content).trim();
+            if (systemText)
+                systemParts.push(systemText);
+            continue;
+        }
+        if (role === 'tool') {
+            const toolResultText = extractTextFromOpenAIContent(msg.content).trim()
+                || (typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content ?? ''));
+            const toolUseId = typeof msg.tool_call_id === 'string' && msg.tool_call_id.trim()
+                ? msg.tool_call_id.trim()
+                : `tool_${idx}`;
+            messages.push({
+                role: 'user',
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: toolUseId,
+                        content: toolResultText,
+                    },
+                ],
+            });
+            continue;
+        }
+        if (role === 'assistant') {
+            const blocks = [];
+            const text = extractTextFromOpenAIContent(msg.content).trim();
+            if (text) {
+                blocks.push({ type: 'text', text });
+            }
+            if (Array.isArray(msg.tool_calls)) {
+                for (let toolIndex = 0; toolIndex < msg.tool_calls.length; toolIndex++) {
+                    const rawToolCall = msg.tool_calls[toolIndex];
+                    if (!rawToolCall || typeof rawToolCall !== 'object')
+                        continue;
+                    const toolCall = rawToolCall;
+                    const fn = toolCall.function && typeof toolCall.function === 'object'
+                        ? toolCall.function
+                        : {};
+                    const name = typeof fn.name === 'string' && fn.name.trim() ? fn.name.trim() : 'tool';
+                    const input = parseToolArguments(fn.arguments);
+                    const toolId = typeof toolCall.id === 'string' && toolCall.id.trim()
+                        ? toolCall.id.trim()
+                        : `tool_${idx}_${toolIndex}`;
+                    blocks.push({
+                        type: 'tool_use',
+                        id: toolId,
+                        name,
+                        input,
+                    });
+                }
+            }
+            else if (msg.function_call && typeof msg.function_call === 'object') {
+                const fn = msg.function_call;
+                const name = typeof fn.name === 'string' && fn.name.trim() ? fn.name.trim() : 'tool';
+                const input = parseToolArguments(fn.arguments);
+                blocks.push({
+                    type: 'tool_use',
+                    id: `tool_${idx}`,
+                    name,
+                    input,
+                });
+            }
+            if (blocks.length > 0) {
+                messages.push({ role: 'assistant', content: blocks });
+            }
+            continue;
+        }
+        const userText = extractTextFromOpenAIContent(msg.content).trim();
+        if (userText) {
+            messages.push({ role: 'user', content: userText });
+        }
+    }
+    if (messages.length === 0) {
+        const fallbackInput = extractTextFromOpenAIContent(baseRequest.input).trim();
+        const fallbackPrompt = typeof baseRequest.prompt === 'string' ? baseRequest.prompt.trim() : '';
+        const fallback = fallbackInput || fallbackPrompt;
+        if (fallback) {
+            messages.push({ role: 'user', content: fallback });
+        }
+    }
+    anthropicRequest.messages = messages.length > 0 ? messages : [{ role: 'user', content: '...' }];
+    if (systemParts.length > 0) {
+        anthropicRequest.system = systemParts.join('\n\n');
+    }
+    const tools = convertOpenAIToolsToAnthropic(baseRequest.tools);
+    if (tools.length > 0) {
+        anthropicRequest.tools = tools;
+    }
+    const toolChoice = mapOpenAIToolChoiceToAnthropic(baseRequest.tool_choice);
+    if (toolChoice) {
+        anthropicRequest.tool_choice = toolChoice;
+    }
+    return anthropicRequest;
+}
+function buildRequestPayloadForSeller(baseRequest, servedModel, candidateModel) {
+    if (baseRequest._openai_compat === true && isAnthropicLikeModelName(candidateModel || servedModel)) {
+        return convertOpenAIRequestToAnthropic(baseRequest, servedModel);
+    }
+    const requestPayload = {
+        ...baseRequest,
+        model: servedModel,
+        stream: true,
+    };
+    delete requestPayload._openai_compat;
+    return requestPayload;
+}
 async function streamFromSellerAttempt(req, res, baseRequest, servedModel, candidate, isClientClosed, attemptBudgetMs, firstChunkBudgetMs, hooks) {
     if (isClientClosed()) {
         return { ok: false, streamStarted: false, error: 'client_disconnected', fatal: true };
@@ -831,8 +1458,7 @@ async function streamFromSellerAttempt(req, res, baseRequest, servedModel, candi
     }
     console.log(`[Ticket] 初始 #${initialTicket.nonce} 累计: ${formatUnits(BigInt(initialTicket.amount), 6)} USDC`);
     const requestPayload = {
-        ...baseRequest,
-        model: servedModel,
+        ...buildRequestPayloadForSeller(baseRequest, servedModel, candidate.model),
         _clawmarket: initialTicket,
     };
     const wsUrl = `${RELAY_WS_URL}/relay/stream?seller_id=${encodeURIComponent(candidate.sellerId)}`;
@@ -844,6 +1470,8 @@ async function streamFromSellerAttempt(req, res, baseRequest, servedModel, candi
         let upstreamModel = servedModel;
         let hasAccepted = false;
         let hasVisibleChunk = false;
+        let hasStructuredAnthropicChunk = false;
+        let hasStructuredOpenAIChunk = false;
         let connectTimer = null;
         let acceptTimer = null;
         let firstChunkTimer = null;
@@ -960,10 +1588,51 @@ async function streamFromSellerAttempt(req, res, baseRequest, servedModel, candi
                             // ignore invalid payload
                         }
                     }
+                    // 上游已确认开始，立即打开 SSE，避免客户端长时间“无响应”。
+                    ensureStreamStarted();
                     armFirstChunkTimer();
                     return;
                 }
                 if (messageType === 'stream_chunk') {
+                    const structuredChunks = parseRelayStructuredChunks(msg.payload);
+                    if (structuredChunks.length > 0) {
+                        let handledStructured = false;
+                        for (const structuredChunk of structuredChunks) {
+                            if (structuredChunk.kind === 'anthropic') {
+                                if (!hooks.onAnthropicEvent)
+                                    continue;
+                                handledStructured = true;
+                                hasStructuredAnthropicChunk = true;
+                                ensureStreamStarted();
+                                firstChunkTimer = clearTimer(firstChunkTimer);
+                                hooks.onAnthropicEvent(structuredChunk.event, structuredChunk.data);
+                                const textDelta = extractAnthropicTextDelta(structuredChunk.event, structuredChunk.data);
+                                if (/\S/.test(textDelta)) {
+                                    hasVisibleChunk = true;
+                                }
+                                armIdleTimer();
+                                continue;
+                            }
+                            handledStructured = true;
+                            hasStructuredOpenAIChunk = true;
+                            ensureStreamStarted();
+                            firstChunkTimer = clearTimer(firstChunkTimer);
+                            if (hooks.onOpenAIEvent) {
+                                hooks.onOpenAIEvent(structuredChunk.data);
+                            }
+                            const textDelta = extractOpenAITextDelta(structuredChunk.data);
+                            if (/\S/.test(textDelta)) {
+                                hasVisibleChunk = true;
+                                if (!hooks.onOpenAIEvent) {
+                                    hooks.onDelta(textDelta);
+                                }
+                            }
+                            armIdleTimer();
+                        }
+                        if (handledStructured) {
+                            return;
+                        }
+                    }
                     const chunkText = typeof msg.payload === 'string' ? msg.payload : String(msg.payload ?? '');
                     const visible = /\S/.test(chunkText);
                     if (!visible) {
@@ -994,11 +1663,6 @@ async function streamFromSellerAttempt(req, res, baseRequest, servedModel, candi
                 if (messageType === 'stream_end') {
                     firstChunkTimer = clearTimer(firstChunkTimer);
                     idleTimer = clearTimer(idleTimer);
-                    if (!hasVisibleChunk) {
-                        failBeforeStream('empty_response_before_content');
-                        return;
-                    }
-                    ensureStreamStarted();
                     let inputTokens = 0;
                     let outputTokens = 0;
                     if (typeof msg.payload === 'string') {
@@ -1011,6 +1675,17 @@ async function streamFromSellerAttempt(req, res, baseRequest, servedModel, candi
                             // ignore invalid usage payload
                         }
                     }
+                    // 上游偶发“无可见内容 + output_tokens=0”，这会让客户端看起来像卡死。
+                    // 这里改为路由层重试（最多 1 次），避免静默空回复。
+                    if (!hasVisibleChunk && outputTokens === 0 && !hasStructuredAnthropicChunk && !hasStructuredOpenAIChunk) {
+                        console.log('[路由] 上游空响应（无可见内容），触发重试');
+                        finish({ ok: false, streamStarted: false, error: 'empty_response_before_content' });
+                        return;
+                    }
+                    if (!hasVisibleChunk) {
+                        console.log('[路由] 上游无可见 chunk，但含 usage，按成功结束处理');
+                    }
+                    ensureStreamStarted();
                     const actualCostUsd = (inputTokens / 1_000_000) * candidate.inputPer1m + (outputTokens / 1_000_000) * candidate.outputPer1m;
                     const actualCostUsdc = BigInt(Math.ceil(actualCostUsd * 1_000_000));
                     if (actualCostUsdc > COST_PER_REQUEST) {
@@ -1154,7 +1829,7 @@ async function routeStreamRequest(req, res, request, requestedModel, hooks) {
                     return;
                 }
                 const errReason = result.error || 'unknown_error';
-                if (!result.streamStarted && retry === 0 && isBuyerMismatchError(errReason)) {
+                if (!result.streamStarted && retry === 0 && (isBuyerMismatchError(errReason) || isChannelStateSyncError(errReason))) {
                     invalidateSellerChannel(candidate.walletAddress, errReason);
                     continue;
                 }
@@ -1185,31 +1860,395 @@ async function routeStreamRequest(req, res, request, requestedModel, hooks) {
 async function handleAnthropicStreamRequest(req, res, body) {
     const request = JSON.parse(body);
     const requestModel = typeof request.model === 'string' ? request.model.trim() : '';
-    const requestedModel = requestModel || 'claude-opus-4-5';
+    const requestedModel = normalizeRequestedModelId(requestModel || 'claude-opus-4-5');
+    const preferredToolName = resolvePreferredToolNameFromRequest(request);
+    const toolNames = extractToolNamesFromRequest(request);
+    const browserActionEnum = extractBrowserActionEnumFromRequest(request);
+    const toolInputFallbacks = deriveToolInputFallbacksFromRequest(request);
+    debugBridge('anthropic_stream_req', {
+        model: requestedModel,
+        preferredToolName: preferredToolName || null,
+        toolCount: toolNames.length,
+        toolNames: toolNames.slice(0, 12),
+        browserActionEnum: browserActionEnum.slice(0, 20),
+        fallbackExecCommand: toolInputFallbacks.execCommand || null,
+        fallbackWebFetchUrl: toolInputFallbacks.webFetchUrl || null,
+        fallbackBrowserProfile: toolInputFallbacks.browserProfile || null,
+    });
     console.log(`[请求] Model: ${requestedModel}, Stream: true`);
     const messageId = `msg_${Math.random().toString(36).slice(2, 12)}`;
-    await routeStreamRequest(req, res, request, requestedModel, {
-        onStart: (servedModel, sellerId) => {
-            if (res.writableEnded)
-                return;
-            startAnthropicSSE(res, messageId, requestedModel, servedModel, sellerId);
-        },
-        onDelta: (text) => {
-            if (res.writableEnded)
-                return;
-            writeAnthropicDelta(res, text);
-        },
-        onEnd: (outputTokens) => {
-            if (res.writableEnded)
+    let servedModel = requestedModel;
+    let textStreamStarted = false;
+    let sawStructuredAnthropicEvent = false;
+    let sawMessageStop = false;
+    let probeMode = 'probe';
+    let probeBuffer = '';
+    let toolCandidateBuffer = '';
+    let passthroughBuffer = '';
+    let textTranscript = '';
+    let nextToolIndex = 0;
+    const toolCalls = new Map();
+    const ensureTextStreamStarted = () => {
+        if (textStreamStarted || res.writableEnded)
+            return;
+        textStreamStarted = true;
+        ensureAnthropicTextStreamStarted(res, messageId, servedModel);
+    };
+    const appendParsedToolCall = (tool) => {
+        const normalizedBaseName = normalizeToolNameForRequest(tool.name, preferredToolName, toolNames) || tool.name || 'tool';
+        const normalizedName = coerceToolNameByArguments(normalizedBaseName, tool.arguments, toolNames);
+        const normalizedInput = parseToolArgumentsAsAnthropicInput(tool.arguments, normalizedName, toolInputFallbacks);
+        const toolIndex = nextToolIndex++;
+        applyOpenAIToolCallDelta(toolCalls, {
+            index: toolIndex,
+            id: `toolu_${Math.random().toString(36).slice(2, 12)}`,
+            name: normalizedName,
+            arguments: JSON.stringify(normalizedInput),
+        });
+    };
+    const emitTextDelta = (text) => {
+        if (!text)
+            return;
+        ensureTextStreamStarted();
+        writeAnthropicDelta(res, text);
+    };
+    const flushPassthroughBuffer = (final) => {
+        while (passthroughBuffer.length > 0) {
+            const minimaxStartMatch = findMinimaxToolStart(passthroughBuffer);
+            const minimaxStart = minimaxStartMatch ? minimaxStartMatch.index : -1;
+            const bracketStart = passthroughBuffer.indexOf(BRACKET_TOOL_START);
+            const hasMinimax = minimaxStart >= 0;
+            const hasBracket = bracketStart >= 0;
+            const start = !hasMinimax
+                ? bracketStart
+                : (!hasBracket || minimaxStart <= bracketStart ? minimaxStart : bracketStart);
+            if (start < 0) {
+                if (!final) {
+                    const keepLen = Math.min(Math.max(0, Math.max(MINIMAX_TOOL_START.length, BRACKET_TOOL_START.length) - 1), passthroughBuffer.length);
+                    const emitLen = passthroughBuffer.length - keepLen;
+                    if (emitLen > 0) {
+                        emitTextDelta(passthroughBuffer.slice(0, emitLen));
+                    }
+                    passthroughBuffer = passthroughBuffer.slice(emitLen);
+                    return;
+                }
+                emitTextDelta(passthroughBuffer);
+                passthroughBuffer = '';
                 return;
-            endAnthropicSSE(res, outputTokens);
-        },
-        onError: (message) => {
-            if (res.writableEnded)
+            }
+            if (start > 0) {
+                emitTextDelta(passthroughBuffer.slice(0, start));
+                passthroughBuffer = passthroughBuffer.slice(start);
+            }
+            const usesMinimaxBlock = minimaxStartMatch !== null && minimaxStartMatch.index === 0;
+            const minimaxEndMatch = usesMinimaxBlock ? findMinimaxToolEnd(passthroughBuffer) : null;
+            const bracketEnd = usesMinimaxBlock ? -1 : passthroughBuffer.indexOf(BRACKET_TOOL_END);
+            if ((usesMinimaxBlock && !minimaxEndMatch) || (!usesMinimaxBlock && bracketEnd < 0)) {
+                if (final) {
+                    emitTextDelta(passthroughBuffer);
+                    passthroughBuffer = '';
+                }
                 return;
-            failAnthropicSSE(res, message);
-        },
-    });
+            }
+            const blockEndIndex = usesMinimaxBlock
+                ? (minimaxEndMatch.index + minimaxEndMatch.token.length)
+                : (bracketEnd + BRACKET_TOOL_END.length);
+            const block = passthroughBuffer.slice(0, blockEndIndex);
+            passthroughBuffer = passthroughBuffer.slice(blockEndIndex);
+            const parsedCalls = usesMinimaxBlock
+                ? parseMinimaxToolBlock(block, preferredToolName)
+                : parseBracketToolBlock(block, preferredToolName);
+            if (parsedCalls.length === 0) {
+                emitTextDelta(block);
+                continue;
+            }
+            for (const parsedCall of parsedCalls) {
+                appendParsedToolCall(parsedCall);
+            }
+        }
+    };
+    const flushProbeBufferAsText = () => {
+        if (probeBuffer.length === 0)
+            return;
+        passthroughBuffer += probeBuffer;
+        flushPassthroughBuffer(false);
+        probeBuffer = '';
+    };
+    const handleTextDelta = (text) => {
+        if (!text || res.writableEnded || sawStructuredAnthropicEvent)
+            return;
+        textTranscript += text;
+        if (probeMode === 'passthrough') {
+            passthroughBuffer += text;
+            flushPassthroughBuffer(false);
+            return;
+        }
+        if (probeMode === 'tool_buffer') {
+            toolCandidateBuffer += text;
+            return;
+        }
+        probeBuffer += text;
+        const trimmed = probeBuffer.trimStart();
+        if (!trimmed)
+            return;
+        const looksLikeToolPayload = trimmed.startsWith(MINIMAX_TOOL_START)
+            || trimmed.startsWith('<minimax:tool_call')
+            || trimmed.startsWith(BRACKET_TOOL_START)
+            || trimmed.startsWith('{')
+            || trimmed.startsWith('```');
+        if (looksLikeToolPayload) {
+            probeMode = 'tool_buffer';
+            toolCandidateBuffer = probeBuffer;
+            probeBuffer = '';
+            return;
+        }
+        probeMode = 'passthrough';
+        flushProbeBufferAsText();
+    };
+    const emitAnthropicToolUseFromCalls = (outputTokens) => {
+        const normalizedToolCalls = toolCallStateToOpenAIList(toolCalls);
+        if (normalizedToolCalls.length === 0)
+            return false;
+        ensureTextStreamStarted();
+        writeAnthropicEvent(res, 'content_block_stop', {
+            type: 'content_block_stop',
+            index: 0,
+        });
+        let toolBlockIndex = 1;
+        for (const call of normalizedToolCalls) {
+            const toolObj = call;
+            const toolId = typeof toolObj.id === 'string' && toolObj.id.trim()
+                ? toolObj.id.trim()
+                : `toolu_${Math.random().toString(36).slice(2, 12)}`;
+            const fn = toolObj.function && typeof toolObj.function === 'object'
+                ? toolObj.function
+                : {};
+            const toolNameRaw = typeof fn.name === 'string' && fn.name.trim() ? fn.name.trim() : 'tool';
+            const rawArgs = fn.arguments;
+            let argumentsText = '';
+            if (typeof rawArgs === 'string') {
+                argumentsText = rawArgs;
+            }
+            else if (rawArgs !== undefined) {
+                try {
+                    argumentsText = JSON.stringify(rawArgs);
+                }
+                catch {
+                    argumentsText = String(rawArgs);
+                }
+            }
+            const normalizedBaseName = normalizeToolNameForRequest(toolNameRaw, preferredToolName, toolNames) || toolNameRaw;
+            const toolName = coerceToolNameByArguments(normalizedBaseName, argumentsText, toolNames);
+            const normalizedInput = parseToolArgumentsAsAnthropicInput(argumentsText, toolName, toolInputFallbacks);
+            let serializedInput = '{}';
+            try {
+                serializedInput = JSON.stringify(normalizedInput);
+            }
+            catch {
+                serializedInput = '{}';
+            }
+            writeAnthropicEvent(res, 'content_block_start', {
+                type: 'content_block_start',
+                index: toolBlockIndex,
+                content_block: {
+                    type: 'tool_use',
+                    id: toolId,
+                    name: toolName,
+                    input: {},
+                },
+            });
+            writeAnthropicEvent(res, 'content_block_delta', {
+                type: 'content_block_delta',
+                index: toolBlockIndex,
+                delta: {
+                    type: 'input_json_delta',
+                    partial_json: serializedInput,
+                },
+            });
+            debugBridge('anthropic_emit_tool_use', {
+                toolName,
+                toolId,
+                argumentsText,
+                normalizedInput,
+                serializedInput,
+            });
+            writeAnthropicEvent(res, 'content_block_stop', {
+                type: 'content_block_stop',
+                index: toolBlockIndex,
+            });
+            toolBlockIndex++;
+        }
+        writeAnthropicEvent(res, 'message_delta', {
+            type: 'message_delta',
+            delta: { stop_reason: 'tool_use', stop_sequence: null },
+            usage: { output_tokens: outputTokens },
+        });
+        writeAnthropicEvent(res, 'message_stop', { type: 'message_stop' });
+        stopSSEHeartbeat(res);
+        res.end();
+        return true;
+    };
+    await routeStreamRequest(req, res, request, requestedModel, {
+        onStart: (nextServedModel, sellerId) => {
+            if (res.writableEnded)
+                return;
+            servedModel = nextServedModel;
+            startAnthropicSSE(res, requestedModel, servedModel, sellerId);
+        },
+        onDelta: (text) => {
+            handleTextDelta(text);
+        },
+        onAnthropicEvent: (eventName, eventData) => {
+            if (res.writableEnded)
+                return;
+            let normalizedEventData = eventData;
+            if (eventName === 'content_block_start') {
+                const block = eventData.content_block;
+                if (block && typeof block === 'object') {
+                    const blockObj = block;
+                    if (blockObj.type === 'tool_use') {
+                        const toolName = typeof blockObj.name === 'string' ? blockObj.name : undefined;
+                        const normalizedToolName = normalizeToolNameForRequest(toolName || '', preferredToolName, toolNames)
+                            || toolName
+                            || preferredToolName
+                            || 'tool';
+                        let argumentsText = '';
+                        if (blockObj.input !== undefined) {
+                            try {
+                                argumentsText = JSON.stringify(blockObj.input);
+                            }
+                            catch {
+                                argumentsText = String(blockObj.input);
+                            }
+                        }
+                        const coercedToolName = coerceToolNameByArguments(normalizedToolName, argumentsText, toolNames);
+                        const normalizedInput = parseToolArgumentsAsAnthropicInput(argumentsText, coercedToolName, toolInputFallbacks);
+                        debugBridge('anthropic_struct_tool_use', {
+                            toolName: toolName || null,
+                            normalizedToolName,
+                            coercedToolName,
+                            rawInput: blockObj.input ?? null,
+                            normalizedInput,
+                        });
+                        let serializedInput = '{}';
+                        try {
+                            serializedInput = JSON.stringify(normalizedInput);
+                        }
+                        catch {
+                            serializedInput = '{}';
+                        }
+                        normalizedEventData = {
+                            ...eventData,
+                            content_block: {
+                                ...blockObj,
+                                name: coercedToolName,
+                                input: {},
+                            },
+                        };
+                        sawStructuredAnthropicEvent = true;
+                        writeAnthropicEvent(res, eventName, normalizedEventData);
+                        writeAnthropicEvent(res, 'content_block_delta', {
+                            type: 'content_block_delta',
+                            index: eventData.index,
+                            delta: {
+                                type: 'input_json_delta',
+                                partial_json: serializedInput,
+                            },
+                        });
+                        return;
+                    }
+                }
+            }
+            sawStructuredAnthropicEvent = true;
+            writeAnthropicEvent(res, eventName, normalizedEventData);
+            if (eventName === 'message_stop') {
+                sawMessageStop = true;
+            }
+        },
+        onOpenAIEvent: (eventData) => {
+            if (res.writableEnded || sawStructuredAnthropicEvent)
+                return;
+            const textDelta = extractOpenAITextDelta(eventData);
+            if (textDelta.length > 0) {
+                handleTextDelta(textDelta);
+            }
+            const toolDeltas = extractOpenAIToolCallDeltas(eventData);
+            for (const delta of toolDeltas) {
+                applyOpenAIToolCallDelta(toolCalls, delta);
+            }
+        },
+        onEnd: (outputTokens) => {
+            if (res.writableEnded)
+                return;
+            if (sawStructuredAnthropicEvent) {
+                stopSSEHeartbeat(res);
+                if (!sawMessageStop) {
+                    writeAnthropicEvent(res, 'message_stop', { type: 'message_stop' });
+                }
+                res.end();
+                return;
+            }
+            if (probeMode === 'probe') {
+                probeMode = 'passthrough';
+                flushProbeBufferAsText();
+            }
+            else if (probeMode === 'tool_buffer') {
+                const buffered = toolCandidateBuffer;
+                toolCandidateBuffer = '';
+                probeMode = 'passthrough';
+                const parsed = extractToolCallsFromText(buffered, preferredToolName);
+                if (parsed.calls.length > 0) {
+                    for (const call of parsed.calls) {
+                        appendParsedToolCall(call);
+                    }
+                    if (parsed.cleanText.trim().length > 0) {
+                        passthroughBuffer += parsed.cleanText;
+                        flushPassthroughBuffer(false);
+                    }
+                }
+                else if (buffered.length > 0) {
+                    passthroughBuffer += buffered;
+                    flushPassthroughBuffer(false);
+                }
+            }
+            flushPassthroughBuffer(true);
+            if (toolCalls.size === 0 && textTranscript.trim().length > 0) {
+                const parsedFallback = extractToolCallsFromText(textTranscript, preferredToolName);
+                for (const call of parsedFallback.calls) {
+                    appendParsedToolCall(call);
+                }
+            }
+            if (ENABLE_FORCED_BROWSER_OPEN && toolCalls.size === 0 && shouldForceBrowserOpenToolCall(textTranscript, toolNames, toolInputFallbacks.webFetchUrl || '')) {
+                const browserToolName = findMatchingAvailableToolName('browser', toolNames) || 'browser';
+                const forcedInput = parseToolArgumentsAsAnthropicInput(JSON.stringify({
+                    action: 'open',
+                    url: toolInputFallbacks.webFetchUrl,
+                    ...(toolInputFallbacks.browserProfile ? { profile: toolInputFallbacks.browserProfile } : {}),
+                }), browserToolName, toolInputFallbacks);
+                const toolIndex = nextToolIndex++;
+                applyOpenAIToolCallDelta(toolCalls, {
+                    index: toolIndex,
+                    id: `toolu_${Math.random().toString(36).slice(2, 12)}`,
+                    name: browserToolName,
+                    arguments: JSON.stringify(forcedInput),
+                });
+                debugBridge('anthropic_forced_browser_tool_use', {
+                    toolName: browserToolName,
+                    forcedInput,
+                });
+            }
+            if (emitAnthropicToolUseFromCalls(outputTokens)) {
+                return;
+            }
+            ensureTextStreamStarted();
+            endAnthropicSSE(res, outputTokens);
+        },
+        onError: (message) => {
+            if (res.writableEnded)
+                return;
+            failAnthropicSSE(res, message);
+        },
+    });
 }
 // ============ OpenAI 接口 ============
 async function handleOpenAIStreamRequest(req, res, rawRequest) {
@@ -1218,55 +2257,1845 @@ async function handleOpenAIStreamRequest(req, res, rawRequest) {
         failOpenAISSE(res, 'messages 不能为空');
         return;
     }
-    const routeModel = await resolveOpenAIRouteModel(normalized.requestedModel);
-    const translated = routeModel !== normalized.requestedModel;
-    const routeRequest = {
-        ...normalized.requestPayload,
-        model: routeModel,
-    };
-    if (translated) {
-        console.log(`[请求] Model: ${normalized.requestedModel} -> ${routeModel}, Stream: true (openai)`);
+    const preferredToolName = resolvePreferredToolNameFromRequest(normalized.requestPayload);
+    const availableToolNames = extractToolNamesFromRequest(normalized.requestPayload);
+    const toolInputFallbacks = deriveToolInputFallbacksFromRequest(normalized.requestPayload);
+    const routeModel = await resolveOpenAIRouteModel(normalized.requestedModel);
+    const translated = routeModel !== normalized.requestedModel;
+    const routeRequest = {
+        ...normalized.requestPayload,
+        model: routeModel,
+    };
+    if (translated) {
+        console.log(`[请求] Model: ${normalized.requestedModel} -> ${routeModel}, Stream: true (openai)`);
+    }
+    else {
+        console.log(`[请求] Model: ${normalized.requestedModel}, Stream: true (openai)`);
+    }
+    const completionId = `chatcmpl_${Math.random().toString(36).slice(2, 12)}`;
+    const createdAt = Math.floor(Date.now() / 1000);
+    let servedModel = routeModel;
+    let sawToolCall = false;
+    let nextToolIndex = 0;
+    const toolCalls = new Map();
+    const anthropicToolBlockMap = new Map();
+    let minimaxTextBuffer = '';
+    const allocateToolIndex = (anthropicBlockIndex) => {
+        const existing = anthropicToolBlockMap.get(anthropicBlockIndex);
+        if (existing !== undefined)
+            return existing;
+        const idx = nextToolIndex++;
+        anthropicToolBlockMap.set(anthropicBlockIndex, idx);
+        return idx;
+    };
+    const emitParsedToolCall = (tool) => {
+        const normalizedBaseName = normalizeToolNameForRequest(tool.name, preferredToolName, availableToolNames) || tool.name || 'tool';
+        const normalizedName = coerceToolNameByArguments(normalizedBaseName, tool.arguments, availableToolNames);
+        const normalizedInput = parseToolArgumentsAsAnthropicInput(tool.arguments, normalizedName, toolInputFallbacks);
+        const toolIndex = nextToolIndex++;
+        const delta = {
+            index: toolIndex,
+            id: `call_${completionId}_${toolIndex}`,
+            name: normalizedName,
+            arguments: JSON.stringify(normalizedInput),
+        };
+        applyOpenAIToolCallDelta(toolCalls, delta);
+        writeOpenAIToolCallDelta(res, completionId, createdAt, servedModel, [delta]);
+        sawToolCall = true;
+    };
+    const flushMinimaxTextBuffer = (final) => {
+        while (minimaxTextBuffer.length > 0) {
+            const startMatch = findMinimaxToolStart(minimaxTextBuffer);
+            const start = startMatch ? startMatch.index : -1;
+            if (start < 0) {
+                writeOpenAIDelta(res, completionId, createdAt, servedModel, minimaxTextBuffer);
+                minimaxTextBuffer = '';
+                return;
+            }
+            if (start > 0) {
+                const prefix = minimaxTextBuffer.slice(0, start);
+                writeOpenAIDelta(res, completionId, createdAt, servedModel, prefix);
+                minimaxTextBuffer = minimaxTextBuffer.slice(start);
+            }
+            const endMatch = findMinimaxToolEnd(minimaxTextBuffer);
+            if (!endMatch) {
+                if (final) {
+                    writeOpenAIDelta(res, completionId, createdAt, servedModel, minimaxTextBuffer);
+                    minimaxTextBuffer = '';
+                }
+                return;
+            }
+            const block = minimaxTextBuffer.slice(0, endMatch.index + endMatch.token.length);
+            minimaxTextBuffer = minimaxTextBuffer.slice(endMatch.index + endMatch.token.length);
+            const parsedCalls = parseMinimaxToolBlock(block, preferredToolName);
+            if (parsedCalls.length === 0) {
+                writeOpenAIDelta(res, completionId, createdAt, servedModel, block);
+                continue;
+            }
+            parsedCalls.forEach((tool) => emitParsedToolCall(tool));
+        }
+    };
+    const handleTextDelta = (text) => {
+        minimaxTextBuffer += text;
+        flushMinimaxTextBuffer(false);
+    };
+    await routeStreamRequest(req, res, routeRequest, routeModel, {
+        onStart: (nextServedModel, sellerId) => {
+            if (res.writableEnded)
+                return;
+            servedModel = nextServedModel;
+            startOpenAISSE(res, completionId, createdAt, normalized.requestedModel, servedModel, sellerId);
+        },
+        onDelta: (text) => {
+            if (res.writableEnded)
+                return;
+            handleTextDelta(text);
+        },
+        onAnthropicEvent: (eventName, eventData) => {
+            if (res.writableEnded)
+                return;
+            if (eventName === 'content_block_start') {
+                const block = eventData.content_block;
+                const blockIndex = Number.isFinite(Number(eventData.index)) ? Number(eventData.index) : -1;
+                if (block && typeof block === 'object') {
+                    const anyBlock = block;
+                    if (anyBlock.type === 'tool_use') {
+                        const toolIndex = blockIndex >= 0 ? allocateToolIndex(blockIndex) : nextToolIndex++;
+                        const toolId = typeof anyBlock.id === 'string' && anyBlock.id.trim()
+                            ? anyBlock.id.trim()
+                            : `call_${completionId}_${toolIndex}`;
+                        const rawToolName = typeof anyBlock.name === 'string' && anyBlock.name.trim()
+                            ? anyBlock.name.trim()
+                            : 'tool';
+                        const toolName = normalizeToolNameForRequest(rawToolName, preferredToolName, availableToolNames) || rawToolName;
+                        let initialArgs = '';
+                        if (anyBlock.input !== undefined) {
+                            try {
+                                initialArgs = JSON.stringify(anyBlock.input);
+                            }
+                            catch {
+                                initialArgs = String(anyBlock.input);
+                            }
+                        }
+                        const coercedToolName = coerceToolNameByArguments(toolName, initialArgs, availableToolNames);
+                        const normalizedInput = parseToolArgumentsAsAnthropicInput(initialArgs, coercedToolName, toolInputFallbacks);
+                        const delta = {
+                            index: toolIndex,
+                            id: toolId,
+                            name: coercedToolName,
+                            arguments: JSON.stringify(normalizedInput),
+                        };
+                        applyOpenAIToolCallDelta(toolCalls, delta);
+                        writeOpenAIToolCallDelta(res, completionId, createdAt, servedModel, [delta]);
+                        sawToolCall = true;
+                        return;
+                    }
+                    if (anyBlock.type === 'text' && typeof anyBlock.text === 'string' && anyBlock.text.length > 0) {
+                        handleTextDelta(anyBlock.text);
+                        return;
+                    }
+                }
+            }
+            if (eventName === 'content_block_delta') {
+                const delta = eventData.delta;
+                if (!delta || typeof delta !== 'object')
+                    return;
+                const anyDelta = delta;
+                if ((anyDelta.type === 'text_delta' || anyDelta.type === undefined) && typeof anyDelta.text === 'string' && anyDelta.text.length > 0) {
+                    handleTextDelta(anyDelta.text);
+                    return;
+                }
+                if (anyDelta.type === 'input_json_delta' && typeof anyDelta.partial_json === 'string') {
+                    const blockIndex = Number.isFinite(Number(eventData.index)) ? Number(eventData.index) : -1;
+                    const toolIndex = blockIndex >= 0 ? allocateToolIndex(blockIndex) : nextToolIndex++;
+                    const existing = toolCalls.get(toolIndex);
+                    if (!existing) {
+                        const startDelta = {
+                            index: toolIndex,
+                            id: `call_${completionId}_${toolIndex}`,
+                            name: preferredToolName || 'tool',
+                            arguments: '',
+                        };
+                        applyOpenAIToolCallDelta(toolCalls, startDelta);
+                        writeOpenAIToolCallDelta(res, completionId, createdAt, servedModel, [startDelta]);
+                    }
+                    const argsDelta = {
+                        index: toolIndex,
+                        arguments: anyDelta.partial_json,
+                    };
+                    applyOpenAIToolCallDelta(toolCalls, argsDelta);
+                    writeOpenAIToolCallDelta(res, completionId, createdAt, servedModel, [argsDelta]);
+                    sawToolCall = true;
+                    return;
+                }
+            }
+            if (eventName === 'message_delta') {
+                const delta = eventData.delta;
+                if (delta && typeof delta === 'object') {
+                    const stopReason = delta.stop_reason;
+                    if (stopReason === 'tool_use') {
+                        sawToolCall = true;
+                    }
+                }
+            }
+        },
+        onOpenAIEvent: (eventData) => {
+            if (res.writableEnded)
+                return;
+            const textDelta = extractOpenAITextDelta(eventData);
+            if (textDelta.length > 0) {
+                handleTextDelta(textDelta);
+            }
+            const toolDeltas = extractOpenAIToolCallDeltas(eventData);
+            if (toolDeltas.length > 0) {
+                const normalizedDeltas = toolDeltas.map((delta) => {
+                    if (!delta.name)
+                        return delta;
+                    const argsText = typeof delta.arguments === 'string' ? delta.arguments : '';
+                    const normalizedBaseName = normalizeToolNameForRequest(delta.name, preferredToolName, availableToolNames) || delta.name;
+                    const coercedName = coerceToolNameByArguments(normalizedBaseName, argsText, availableToolNames);
+                    return {
+                        ...delta,
+                        name: coercedName,
+                    };
+                });
+                normalizedDeltas.forEach((delta) => applyOpenAIToolCallDelta(toolCalls, delta));
+                writeOpenAIToolCallDelta(res, completionId, createdAt, servedModel, normalizedDeltas);
+                sawToolCall = true;
+            }
+            if (extractOpenAIFinishReason(eventData) === 'tool_calls') {
+                sawToolCall = true;
+            }
+        },
+        onEnd: (outputTokens) => {
+            if (res.writableEnded)
+                return;
+            flushMinimaxTextBuffer(true);
+            const finishReason = sawToolCall ? 'tool_calls' : 'stop';
+            endOpenAISSE(res, completionId, createdAt, servedModel, outputTokens, finishReason);
+        },
+        onError: (message) => {
+            if (res.writableEnded)
+                return;
+            failOpenAISSE(res, message);
+        },
+    });
+}
+function sendOpenAIJsonError(res, status, message) {
+    if (res.writableEnded)
+        return;
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+        error: {
+            type: 'api_error',
+            message,
+        },
+    }));
+}
+function extractOpenAIToolCallDeltas(eventData) {
+    const choices = eventData.choices;
+    if (!Array.isArray(choices) || choices.length === 0)
+        return [];
+    const first = choices[0];
+    if (!first || typeof first !== 'object')
+        return [];
+    const delta = first.delta;
+    if (!delta || typeof delta !== 'object')
+        return [];
+    const rawCalls = delta.tool_calls;
+    if (!Array.isArray(rawCalls))
+        return [];
+    const toolDeltas = [];
+    rawCalls.forEach((call, idx) => {
+        const normalized = sanitizeOpenAIToolCallDelta(call, idx);
+        if (normalized)
+            toolDeltas.push(normalized);
+    });
+    return toolDeltas;
+}
+function extractOpenAIFinishReason(eventData) {
+    const choices = eventData.choices;
+    if (!Array.isArray(choices) || choices.length === 0)
+        return null;
+    const first = choices[0];
+    if (!first || typeof first !== 'object')
+        return null;
+    const reason = first.finish_reason;
+    return typeof reason === 'string' ? reason : null;
+}
+const MINIMAX_TOOL_START = '<minimax:tool_call>';
+const MINIMAX_TOOL_END = '</minimax:tool_call>';
+const MINIMAX_TOOL_START_PATTERN = /<minimax:tool_call\b[^>]*>/i;
+const MINIMAX_TOOL_END_PATTERN = /<\/minimax:tool_call>/i;
+const BRACKET_TOOL_START = '[TOOL_CALL]';
+const BRACKET_TOOL_END = '[/TOOL_CALL]';
+const FUNCTION_CALL_START = '<FunctionCall>';
+const FUNCTION_CALL_END = '</FunctionCall>';
+const EXEC_TOOL_ALIASES = new Set([
+    'exec',
+    'bash',
+    'sh',
+    'zsh',
+    'shell',
+    'terminal',
+    'cmd',
+    'powershell',
+    'command',
+    'run_command',
+    'run-command',
+    'execute_command',
+    'execute-command',
+    'cli-mcp-server_run_command',
+    'cli-mcp-server_execute_command',
+]);
+const WEB_FETCH_TOOL_ALIASES = new Set([
+    'web_fetch',
+    'web-fetch',
+    'webfetch',
+    'fetch_url',
+    'fetch-url',
+    'url_fetch',
+    'url-fetch',
+]);
+function findMinimaxToolStart(text) {
+    const match = MINIMAX_TOOL_START_PATTERN.exec(text);
+    MINIMAX_TOOL_START_PATTERN.lastIndex = 0;
+    if (!match || match.index === undefined)
+        return null;
+    return { index: match.index, token: match[0] || MINIMAX_TOOL_START };
+}
+function findMinimaxToolEnd(text) {
+    const match = MINIMAX_TOOL_END_PATTERN.exec(text);
+    MINIMAX_TOOL_END_PATTERN.lastIndex = 0;
+    if (!match || match.index === undefined)
+        return null;
+    return { index: match.index, token: match[0] || MINIMAX_TOOL_END };
+}
+function normalizeBrokenMinimaxToolMarkup(block) {
+    let normalized = block;
+    // Some sellers emit `invoke name="..."` without an opening `<`.
+    normalized = normalized.replace(/(^|\n|\r)\s*invoke(\s+name=["'][^"']+["'][^>]*>)/gi, '$1<invoke$2');
+    if (/<invoke\b/i.test(normalized) && !/<\/invoke>/i.test(normalized)) {
+        const endMatch = findMinimaxToolEnd(normalized);
+        if (endMatch) {
+            normalized = `${normalized.slice(0, endMatch.index)}</invoke>${normalized.slice(endMatch.index)}`;
+        }
+        else {
+            normalized = `${normalized}</invoke>`;
+        }
+    }
+    return normalized;
+}
+function isExecLikeToolName(name) {
+    const lowered = name.trim().toLowerCase();
+    if (!lowered)
+        return false;
+    if (EXEC_TOOL_ALIASES.has(lowered))
+        return true;
+    if (lowered.startsWith('cli-mcp-server_'))
+        return true;
+    if (/([_-]|^)run[_-]?command$/i.test(lowered))
+        return true;
+    if (/([_-]|^)execute[_-]?command$/i.test(lowered))
+        return true;
+    if ((lowered.includes('shell') || lowered.includes('terminal')) && lowered.includes('command'))
+        return true;
+    return false;
+}
+function isWebFetchLikeToolName(name) {
+    const lowered = name.trim().toLowerCase();
+    if (!lowered)
+        return false;
+    if (WEB_FETCH_TOOL_ALIASES.has(lowered))
+        return true;
+    if ((lowered.includes('web') || lowered.includes('url')) && lowered.includes('fetch'))
+        return true;
+    return false;
+}
+function decodeXmlEntities(text) {
+    return text
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'");
+}
+function normalizeToolName(name, fallbackToolName) {
+    const trimmed = name.trim();
+    const fallback = typeof fallbackToolName === 'string' ? fallbackToolName.trim() : '';
+    if (!trimmed)
+        return fallback;
+    if (isExecLikeToolName(trimmed)) {
+        return fallback && fallback.toLowerCase() === 'exec' ? fallback : 'exec';
+    }
+    if (isWebFetchLikeToolName(trimmed)) {
+        return fallback && fallback.toLowerCase() === 'web_fetch' ? fallback : 'web_fetch';
+    }
+    if (!fallback)
+        return trimmed;
+    if (trimmed.toLowerCase() === fallback.toLowerCase())
+        return fallback;
+    return fallback;
+}
+function parseMinimaxToolBlock(block, fallbackToolName) {
+    const invokes = [];
+    const normalizedBlock = normalizeBrokenMinimaxToolMarkup(block);
+    const invokeRegex = /<invoke\s+name=["']([^"']+)["'][^>]*>([\s\S]*?)<\/invoke>/gi;
+    let invokeMatch = null;
+    while ((invokeMatch = invokeRegex.exec(normalizedBlock)) !== null) {
+        const toolName = normalizeToolName(decodeXmlEntities(invokeMatch[1] || ''), fallbackToolName);
+        if (!toolName)
+            continue;
+        const invokeBody = invokeMatch[2] || '';
+        const params = {};
+        const paramRegex = /<parameter\s+name=["']([^"']+)["'][^>]*>([\s\S]*?)<\/parameter>/gi;
+        let paramMatch = null;
+        while ((paramMatch = paramRegex.exec(invokeBody)) !== null) {
+            const key = decodeXmlEntities(paramMatch[1] || '').trim();
+            if (!key)
+                continue;
+            const value = decodeXmlEntities(paramMatch[2] || '').trim();
+            params[key] = value;
+        }
+        invokes.push({
+            name: toolName,
+            arguments: JSON.stringify(params),
+        });
+    }
+    return invokes;
+}
+function parseBracketToolBody(body, fallbackToolName) {
+    let candidate = body.trim();
+    if (!candidate)
+        return [];
+    const fenced = candidate.match(/^```(?:[a-z0-9_-]+)?\s*([\s\S]*?)\s*```$/i);
+    if (fenced && fenced[1]) {
+        candidate = fenced[1].trim();
+    }
+    const jsonCalls = parseJsonToolCallsFromText(candidate, fallbackToolName);
+    if (jsonCalls.length > 0)
+        return jsonCalls;
+    const toolNameMatch = candidate.match(/\btool\s*=>\s*["']([^"']+)["']/i)
+        || candidate.match(/\bname\s*=>\s*["']([^"']+)["']/i)
+        || candidate.match(/"tool"\s*:\s*"([^"]+)"/i)
+        || candidate.match(/"name"\s*:\s*"([^"]+)"/i);
+    const rawToolName = toolNameMatch?.[1] ?? '';
+    const toolName = normalizeToolName(rawToolName, fallbackToolName);
+    if (!toolName)
+        return [];
+    const commandMatch = candidate.match(/--command\s+"([^"]+)"/i)
+        || candidate.match(/--command\s+'([^']+)'/i)
+        || candidate.match(/"command"\s*:\s*"([^"]+)"/i)
+        || candidate.match(/'command'\s*:\s*'([^']+)'/i)
+        || candidate.match(/\bcommand\s*=>\s*"([^"]+)"/i)
+        || candidate.match(/\bcommand\s*=>\s*'([^']+)'/i);
+    if (commandMatch?.[1]) {
+        return [{
+                name: toolName,
+                arguments: JSON.stringify({ command: commandMatch[1] }),
+            }];
+    }
+    const argsJson = candidate.match(/\bargs\s*=>\s*(\{[\s\S]*\})/i)
+        || candidate.match(/"args"\s*:\s*(\{[\s\S]*\})/i);
+    if (argsJson?.[1]) {
+        return [{
+                name: toolName,
+                arguments: argsJson[1],
+            }];
+    }
+    if (toolName.toLowerCase() === 'exec') {
+        return [];
+    }
+    return [{
+            name: toolName,
+            arguments: '{}',
+        }];
+}
+function parseBracketToolBlock(block, fallbackToolName) {
+    const invokes = [];
+    const blockRegex = /\[TOOL_CALL\]([\s\S]*?)\[\/TOOL_CALL\]/gi;
+    let blockMatch = null;
+    while ((blockMatch = blockRegex.exec(block)) !== null) {
+        const parsed = parseBracketToolBody(blockMatch[1] || '', fallbackToolName);
+        if (parsed.length > 0) {
+            invokes.push(...parsed);
+        }
+    }
+    return invokes;
+}
+function parseFunctionCallBody(body, fallbackToolName) {
+    let candidate = body.trim();
+    if (!candidate)
+        return [];
+    const fenced = candidate.match(/^```(?:[a-z0-9_-]+)?\s*([\s\S]*?)\s*```$/i);
+    if (fenced?.[1]) {
+        candidate = fenced[1].trim();
+    }
+    const toolNameMatch = candidate.match(/['"]?tool['"]?\s*[:=]\s*['"]([^'"]+)['"]/i)
+        || candidate.match(/['"]?name['"]?\s*[:=]\s*['"]([^'"]+)['"]/i)
+        || candidate.match(/"tool"\s*:\s*"([^"]+)"/i)
+        || candidate.match(/"name"\s*:\s*"([^"]+)"/i);
+    const rawToolName = toolNameMatch?.[1] ?? '';
+    const toolName = normalizeToolName(rawToolName, fallbackToolName);
+    if (!toolName)
+        return [];
+    const parseCommand = (text) => {
+        const commandMatch = text.match(/--command\s+"([^"]+)"/i)
+            || text.match(/--command\s+'([^']+)'/i)
+            || text.match(/['"]command['"]?\s*[:=]\s*['"]([^'"]+)['"]/i);
+        if (!commandMatch?.[1])
+            return null;
+        const command = sanitizeExtractedExecCommand(commandMatch[1]
+            .replace(/\\n/g, '\n')
+            .replace(/\\"/g, '"')
+            .replace(/\\'/g, "'"));
+        return command || null;
+    };
+    const directCommand = parseCommand(candidate);
+    if (directCommand) {
+        return [{
+                name: toolName,
+                arguments: JSON.stringify({ command: directCommand }),
+            }];
+    }
+    const argsStringMatch = candidate.match(/['"]?args['"]?\s*[:=]\s*'([\s\S]*?)'/i)
+        || candidate.match(/['"]?args['"]?\s*[:=]\s*"([\s\S]*?)"/i);
+    if (argsStringMatch?.[1]) {
+        const argsBody = argsStringMatch[1];
+        const command = parseCommand(argsBody);
+        if (command) {
+            return [{
+                    name: toolName,
+                    arguments: JSON.stringify({ command }),
+                }];
+        }
+    }
+    if (toolName === 'exec')
+        return [];
+    return [{
+            name: toolName,
+            arguments: '{}',
+        }];
+}
+function extractFunctionCallToolCallsFromText(text, fallbackToolName) {
+    let remaining = text;
+    let cleanText = '';
+    const calls = [];
+    while (remaining.length > 0) {
+        const start = remaining.indexOf(FUNCTION_CALL_START);
+        if (start < 0) {
+            cleanText += remaining;
+            break;
+        }
+        if (start > 0) {
+            cleanText += remaining.slice(0, start);
+            remaining = remaining.slice(start);
+        }
+        const end = remaining.indexOf(FUNCTION_CALL_END);
+        if (end < 0) {
+            cleanText += remaining;
+            break;
+        }
+        const block = remaining.slice(0, end + FUNCTION_CALL_END.length);
+        remaining = remaining.slice(end + FUNCTION_CALL_END.length);
+        const body = block
+            .slice(FUNCTION_CALL_START.length, block.length - FUNCTION_CALL_END.length)
+            .trim();
+        const parsedInvokes = parseFunctionCallBody(body, fallbackToolName);
+        if (parsedInvokes.length === 0) {
+            cleanText += block;
+            continue;
+        }
+        calls.push(...parsedInvokes);
+    }
+    return { cleanText, calls };
+}
+function extractMinimaxToolCallsFromText(text, fallbackToolName) {
+    let remaining = text;
+    let cleanText = '';
+    const calls = [];
+    while (remaining.length > 0) {
+        const startMatch = findMinimaxToolStart(remaining);
+        const start = startMatch ? startMatch.index : -1;
+        if (start < 0) {
+            cleanText += remaining;
+            break;
+        }
+        if (start > 0) {
+            cleanText += remaining.slice(0, start);
+            remaining = remaining.slice(start);
+        }
+        const endMatch = findMinimaxToolEnd(remaining);
+        if (!endMatch) {
+            cleanText += remaining;
+            break;
+        }
+        const block = remaining.slice(0, endMatch.index + endMatch.token.length);
+        remaining = remaining.slice(endMatch.index + endMatch.token.length);
+        const parsedInvokes = parseMinimaxToolBlock(block, fallbackToolName);
+        if (parsedInvokes.length === 0) {
+            cleanText += block;
+            continue;
+        }
+        calls.push(...parsedInvokes);
+    }
+    return { cleanText, calls };
+}
+function extractBracketToolCallsFromText(text, fallbackToolName) {
+    let remaining = text;
+    let cleanText = '';
+    const calls = [];
+    while (remaining.length > 0) {
+        const start = remaining.indexOf(BRACKET_TOOL_START);
+        if (start < 0) {
+            cleanText += remaining;
+            break;
+        }
+        if (start > 0) {
+            cleanText += remaining.slice(0, start);
+            remaining = remaining.slice(start);
+        }
+        const end = remaining.indexOf(BRACKET_TOOL_END);
+        if (end < 0) {
+            cleanText += remaining;
+            break;
+        }
+        const block = remaining.slice(0, end + BRACKET_TOOL_END.length);
+        remaining = remaining.slice(end + BRACKET_TOOL_END.length);
+        const parsedInvokes = parseBracketToolBlock(block, fallbackToolName);
+        if (parsedInvokes.length === 0) {
+            cleanText += block;
+            continue;
+        }
+        calls.push(...parsedInvokes);
+    }
+    return { cleanText, calls };
+}
+function normalizeParsedInvoke(rawName, rawArguments, fallbackToolName) {
+    if (typeof rawName !== 'string' || !rawName.trim())
+        return null;
+    const toolName = normalizeToolName(rawName, fallbackToolName);
+    if (!toolName)
+        return null;
+    let argumentsText = '{}';
+    if (typeof rawArguments === 'string') {
+        argumentsText = rawArguments;
+    }
+    else if (rawArguments !== undefined) {
+        try {
+            argumentsText = JSON.stringify(rawArguments);
+        }
+        catch {
+            argumentsText = String(rawArguments);
+        }
+    }
+    return {
+        name: toolName,
+        arguments: argumentsText,
+    };
+}
+function extractToolCallsFromJsonValue(value, fallbackToolName) {
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => extractToolCallsFromJsonValue(item, fallbackToolName));
+    }
+    if (!value || typeof value !== 'object')
+        return [];
+    const obj = value;
+    const calls = [];
+    const push = (name, args) => {
+        const parsed = normalizeParsedInvoke(name, args, fallbackToolName);
+        if (parsed)
+            calls.push(parsed);
+    };
+    if (Array.isArray(obj.tool_calls)) {
+        for (const rawCall of obj.tool_calls) {
+            if (!rawCall || typeof rawCall !== 'object')
+                continue;
+            const call = rawCall;
+            const fn = call.function && typeof call.function === 'object'
+                ? call.function
+                : null;
+            push(fn?.name ?? call.name, fn?.arguments ?? call.arguments ?? call.input);
+        }
+    }
+    if (Array.isArray(obj.calls)) {
+        for (const rawCall of obj.calls) {
+            if (!rawCall || typeof rawCall !== 'object')
+                continue;
+            const call = rawCall;
+            const fn = call.function && typeof call.function === 'object'
+                ? call.function
+                : null;
+            push(fn?.name ?? call.name, fn?.arguments ?? call.arguments ?? call.input);
+        }
+    }
+    if (obj.invoke && typeof obj.invoke === 'object') {
+        const invoke = obj.invoke;
+        push(invoke.name, invoke.parameters ?? invoke.arguments ?? invoke.input);
+    }
+    const directFunction = obj.function && typeof obj.function === 'object'
+        ? obj.function
+        : null;
+    push(obj.name ?? obj.tool_name ?? directFunction?.name, obj.arguments ?? obj.input ?? obj.parameters ?? obj.params ?? directFunction?.arguments);
+    const dedup = new Set();
+    const normalizedCalls = [];
+    for (const call of calls) {
+        const key = `${call.name}\u0000${call.arguments}`;
+        if (dedup.has(key))
+            continue;
+        dedup.add(key);
+        normalizedCalls.push(call);
+    }
+    return normalizedCalls;
+}
+function parseJsonToolCallsFromText(text, fallbackToolName) {
+    const inferToolNameFromJsonArguments = (value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return null;
+        const obj = value;
+        const hasExecShape = (typeof obj.command === 'string'
+            || typeof obj.cmd === 'string');
+        if (hasExecShape) {
+            return normalizeToolName('exec', fallbackToolName);
+        }
+        const hasBrowserShape = (typeof obj.action === 'string'
+            || typeof obj.url === 'string'
+            || typeof obj.targetUrl === 'string'
+            || typeof obj.targetId === 'string'
+            || typeof obj.query === 'string');
+        if (hasBrowserShape) {
+            return normalizeToolName('browser', fallbackToolName);
+        }
+        const hasReadShape = (typeof obj.path === 'string'
+            || typeof obj.file_path === 'string');
+        if (hasReadShape) {
+            return normalizeToolName('read', fallbackToolName);
+        }
+        const hasMessageShape = (typeof obj.to === 'string'
+            && (typeof obj.body === 'string' || typeof obj.subject === 'string'));
+        if (hasMessageShape) {
+            return normalizeToolName('message', fallbackToolName);
+        }
+        if (typeof fallbackToolName === 'string' && fallbackToolName.trim()) {
+            return normalizeToolName(fallbackToolName, null);
+        }
+        return null;
+    };
+    const trimmed = text.trim();
+    if (!trimmed)
+        return [];
+    const candidates = [trimmed];
+    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    if (fenced && fenced[1]) {
+        candidates.push(fenced[1].trim());
+    }
+    for (const candidateRaw of candidates) {
+        const candidate = candidateRaw.trim();
+        if (!candidate)
+            continue;
+        if (!(candidate.startsWith('{') || candidate.startsWith('[')))
+            continue;
+        try {
+            const parsed = JSON.parse(candidate);
+            const calls = extractToolCallsFromJsonValue(parsed, fallbackToolName);
+            if (calls.length > 0)
+                return calls;
+            const inferredToolName = inferToolNameFromJsonArguments(parsed);
+            if (inferredToolName) {
+                return [{
+                        name: inferredToolName,
+                        arguments: JSON.stringify(parsed),
+                    }];
+            }
+            if (fallbackToolName
+                && parsed
+                && typeof parsed === 'object'
+                && !Array.isArray(parsed)) {
+                return [{
+                        name: fallbackToolName,
+                        arguments: JSON.stringify(parsed),
+                    }];
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return [];
+}
+function extractJsonToolCallsFromText(text, fallbackToolName) {
+    const calls = parseJsonToolCallsFromText(text, fallbackToolName);
+    if (calls.length === 0) {
+        return { cleanText: text, calls: [] };
+    }
+    return { cleanText: '', calls };
+}
+function isLikelyShellCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    return /^[A-Za-z0-9_./:-]+(?:\s+[A-Za-z0-9_./:=@%+,-]+){0,20}$/.test(trimmed);
+}
+function sanitizeExtractedExecCommand(raw) {
+    let cmd = raw.trim().replace(/^`+|`+$/g, '').trim();
+    if (!cmd)
+        return '';
+    const punctuationCut = cmd.match(/^([^。；，]+)[。；，]/);
+    if (punctuationCut?.[1] && isLikelyShellCommand(punctuationCut[1])) {
+        cmd = punctuationCut[1].trim();
+    }
+    const cjkIndex = cmd.search(/[\u4e00-\u9fff]/);
+    if (cjkIndex > 0) {
+        const prefix = cmd.slice(0, cjkIndex).replace(/[，。；\s]+$/g, '').trim();
+        if (isLikelyShellCommand(prefix)) {
+            cmd = prefix;
+        }
+    }
+    cmd = cmd.replace(/[，。；.!?]+$/g, '').trim();
+    return cmd;
+}
+function extractExecCommandFromNarrativeText(text) {
+    const fencedRegex = /```(?:bash|sh|zsh|shell|cmd|powershell)?\s*([\s\S]*?)```/gi;
+    let fencedMatch = null;
+    while ((fencedMatch = fencedRegex.exec(text)) !== null) {
+        const body = fencedMatch[1] || '';
+        const lines = body.split('\n');
+        for (const rawLine of lines) {
+            const line = rawLine.trim().replace(/^\$\s*/, '');
+            if (!line)
+                continue;
+            if (line.startsWith('#') || line.startsWith('//'))
+                continue;
+            if (!/^[A-Za-z0-9_./:-]+(?:\s+.+)?$/.test(line))
+                continue;
+            if (/^(python|javascript|typescript|json|yaml|xml)\b/i.test(line))
+                continue;
+            const cleaned = sanitizeExtractedExecCommand(line);
+            if (cleaned)
+                return cleaned;
+        }
+    }
+    const inlineMatch = text.match(/(?:command|命令)\s*[:：]\s*`?([^\n`]+)`?/i);
+    if (inlineMatch?.[1]) {
+        const cmd = sanitizeExtractedExecCommand(inlineMatch[1]);
+        if (cmd)
+            return cmd;
+    }
+    return null;
+}
+function extractNarrativeExecToolCallsFromText(text, fallbackToolName) {
+    const fallback = (fallbackToolName || '').trim();
+    if (fallback.toLowerCase() !== 'exec')
+        return [];
+    const command = extractExecCommandFromNarrativeText(text);
+    if (!command)
+        return [];
+    return [{
+            name: fallback,
+            arguments: JSON.stringify({ command }),
+        }];
+}
+function extractTextFromMessageContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (content && typeof content === 'object' && !Array.isArray(content)) {
+        const obj = content;
+        if (typeof obj.text === 'string')
+            return obj.text;
+        if (obj.text && typeof obj.text === 'object') {
+            const nested = obj.text;
+            if (typeof nested.value === 'string')
+                return nested.value;
+        }
+        return '';
+    }
+    if (!Array.isArray(content))
+        return '';
+    let text = '';
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const obj = block;
+        if (typeof obj.text === 'string') {
+            text += `${obj.text}\n`;
+            continue;
+        }
+        if (obj.text && typeof obj.text === 'object') {
+            const nested = obj.text;
+            if (typeof nested.value === 'string') {
+                text += `${nested.value}\n`;
+            }
+        }
+    }
+    return text.trim();
+}
+function collectRequestText(request) {
+    const messages = request.messages;
+    if (!Array.isArray(messages))
+        return '';
+    const parts = [];
+    for (const item of messages) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const msg = item;
+        const role = typeof msg.role === 'string' ? msg.role : '';
+        if (role !== 'user' && role !== 'system')
+            continue;
+        const content = extractTextFromMessageContent(msg.content);
+        if (content)
+            parts.push(content);
+    }
+    return parts.join('\n').trim();
+}
+function extractFirstUrl(text) {
+    const match = text.match(/https?:\/\/[^\s"'`<>，。；,]+/i);
+    return match?.[0] || null;
+}
+function extractBrowserProfileFromPromptText(text) {
+    const match = text.match(/profile\s*=\s*([a-z0-9_.-]+)/i);
+    if (!match?.[1])
+        return null;
+    const profile = match[1].trim();
+    return profile || null;
+}
+function extractExecCommandFromPromptText(text) {
+    if (!text.trim())
+        return null;
+    const fromNarrative = extractExecCommandFromNarrativeText(text);
+    if (fromNarrative)
+        return fromNarrative;
+    const commandField = text.match(/(?:command|命令)\s*[:：=]\s*([^\n]+)/i);
+    if (commandField?.[1]) {
+        const raw = sanitizeExtractedExecCommand(commandField[1]);
+        if (raw)
+            return raw;
+    }
+    const execVerb = text.match(/(?:执行|运行)\s+([a-z0-9_./-]+(?:\s+[a-z0-9_./:=@%-]+){0,8})/i);
+    if (execVerb?.[1]) {
+        const raw = sanitizeExtractedExecCommand(execVerb[1]);
+        if (raw)
+            return raw;
+    }
+    if (/\bdate\b/i.test(text))
+        return 'date';
+    return null;
+}
+function deriveToolInputFallbacksFromRequest(request) {
+    const browserActionEnum = extractBrowserActionEnumFromRequest(request);
+    const browserRequestKindEnum = extractBrowserRequestKindEnumFromRequest(request);
+    const text = collectRequestText(request);
+    if (!text) {
+        if (browserActionEnum.length > 0 || browserRequestKindEnum.length > 0) {
+            return {
+                ...(browserActionEnum.length > 0 ? { browserActionEnum } : {}),
+                ...(browserRequestKindEnum.length > 0 ? { browserRequestKindEnum } : {}),
+            };
+        }
+        return {};
+    }
+    const execCommand = extractExecCommandFromPromptText(text) || undefined;
+    const webFetchUrl = extractFirstUrl(text) || undefined;
+    const browserProfile = extractBrowserProfileFromPromptText(text) || undefined;
+    return {
+        execCommand,
+        webFetchUrl,
+        browserProfile,
+        browserActionEnum: browserActionEnum.length > 0 ? browserActionEnum : undefined,
+        browserRequestKindEnum: browserRequestKindEnum.length > 0 ? browserRequestKindEnum : undefined,
+    };
+}
+function extractToolCallsFromText(text, fallbackToolName) {
+    const minimax = extractMinimaxToolCallsFromText(text, fallbackToolName);
+    const bracket = extractBracketToolCallsFromText(minimax.cleanText, fallbackToolName);
+    const functionCall = extractFunctionCallToolCallsFromText(bracket.cleanText, fallbackToolName);
+    const json = extractJsonToolCallsFromText(functionCall.cleanText, fallbackToolName);
+    const combinedCalls = [...minimax.calls, ...bracket.calls, ...functionCall.calls, ...json.calls];
+    if (combinedCalls.length === 0) {
+        const narrativeExec = extractNarrativeExecToolCallsFromText(json.cleanText, fallbackToolName);
+        if (narrativeExec.length > 0) {
+            return {
+                cleanText: '',
+                calls: narrativeExec,
+            };
+        }
+    }
+    return {
+        cleanText: json.cleanText,
+        calls: combinedCalls,
+    };
+}
+function resolvePreferredToolNameFromRequest(request) {
+    const toolChoice = request.tool_choice;
+    if (toolChoice && typeof toolChoice === 'object') {
+        const choice = toolChoice;
+        if (typeof choice.name === 'string' && choice.name.trim()) {
+            return choice.name.trim();
+        }
+        if (choice.type === 'tool' && typeof choice.name === 'string' && choice.name.trim()) {
+            return choice.name.trim();
+        }
+        if (choice.function && typeof choice.function === 'object') {
+            const fn = choice.function;
+            if (typeof fn.name === 'string' && fn.name.trim()) {
+                return fn.name.trim();
+            }
+        }
+    }
+    const tools = request.tools;
+    if (Array.isArray(tools) && tools.length === 1) {
+        const firstTool = tools[0];
+        if (firstTool && typeof firstTool === 'object') {
+            const toolObj = firstTool;
+            if (typeof toolObj.name === 'string' && toolObj.name.trim()) {
+                return toolObj.name.trim();
+            }
+            if (toolObj.function && typeof toolObj.function === 'object') {
+                const fn = toolObj.function;
+                if (typeof fn.name === 'string' && fn.name.trim()) {
+                    return fn.name.trim();
+                }
+            }
+        }
+    }
+    return null;
+}
+function extractToolNamesFromRequest(request) {
+    const tools = request.tools;
+    if (!Array.isArray(tools))
+        return [];
+    const names = [];
+    for (const rawTool of tools) {
+        if (!rawTool || typeof rawTool !== 'object')
+            continue;
+        const tool = rawTool;
+        if (typeof tool.name === 'string' && tool.name.trim()) {
+            names.push(tool.name.trim());
+            continue;
+        }
+        if (tool.function && typeof tool.function === 'object') {
+            const fn = tool.function;
+            if (typeof fn.name === 'string' && fn.name.trim()) {
+                names.push(fn.name.trim());
+            }
+        }
+    }
+    return [...new Set(names)];
+}
+function extractBrowserActionEnumFromRequest(request) {
+    const tools = request.tools;
+    if (!Array.isArray(tools))
+        return [];
+    for (const rawTool of tools) {
+        if (!rawTool || typeof rawTool !== 'object')
+            continue;
+        const tool = rawTool;
+        const rawName = typeof tool.name === 'string'
+            ? tool.name
+            : (tool.function && typeof tool.function === 'object'
+                ? String(tool.function.name || '')
+                : '');
+        if (rawName.trim().toLowerCase() !== 'browser')
+            continue;
+        const schema = (tool.input_schema && typeof tool.input_schema === 'object'
+            ? tool.input_schema
+            : (tool.function && typeof tool.function === 'object'
+                ? tool.function.parameters
+                : null));
+        if (!schema || typeof schema !== 'object')
+            return [];
+        const properties = schema.properties;
+        if (!properties || typeof properties !== 'object')
+            return [];
+        const actionProp = properties.action;
+        if (!actionProp || typeof actionProp !== 'object')
+            return [];
+        const actionObj = actionProp;
+        const enums = actionObj.enum;
+        if (!Array.isArray(enums))
+            return [];
+        return enums
+            .map((item) => (typeof item === 'string' ? item.trim() : ''))
+            .filter((item) => item.length > 0);
     }
-    else {
-        console.log(`[请求] Model: ${normalized.requestedModel}, Stream: true (openai)`);
+    return [];
+}
+function extractBrowserRequestKindEnumFromRequest(request) {
+    const tools = request.tools;
+    if (!Array.isArray(tools))
+        return [];
+    for (const rawTool of tools) {
+        if (!rawTool || typeof rawTool !== 'object')
+            continue;
+        const tool = rawTool;
+        const rawName = typeof tool.name === 'string'
+            ? tool.name
+            : (tool.function && typeof tool.function === 'object'
+                ? String(tool.function.name || '')
+                : '');
+        if (rawName.trim().toLowerCase() !== 'browser')
+            continue;
+        const schema = (tool.input_schema && typeof tool.input_schema === 'object'
+            ? tool.input_schema
+            : (tool.function && typeof tool.function === 'object'
+                ? tool.function.parameters
+                : null));
+        if (!schema || typeof schema !== 'object')
+            return [];
+        const properties = schema.properties;
+        if (!properties || typeof properties !== 'object')
+            return [];
+        const requestProp = properties.request;
+        if (!requestProp || typeof requestProp !== 'object')
+            return [];
+        const requestObj = requestProp;
+        const requestProperties = requestObj.properties;
+        if (!requestProperties || typeof requestProperties !== 'object')
+            return [];
+        const kindProp = requestProperties.kind;
+        if (!kindProp || typeof kindProp !== 'object')
+            return [];
+        const kindObj = kindProp;
+        const enums = kindObj.enum;
+        if (!Array.isArray(enums))
+            return [];
+        return enums
+            .map((item) => (typeof item === 'string' ? item.trim() : ''))
+            .filter((item) => item.length > 0);
     }
-    const completionId = `chatcmpl_${Math.random().toString(36).slice(2, 12)}`;
-    const createdAt = Math.floor(Date.now() / 1000);
-    let servedModel = routeModel;
-    await routeStreamRequest(req, res, routeRequest, routeModel, {
-        onStart: (nextServedModel, sellerId) => {
-            if (res.writableEnded)
-                return;
-            servedModel = nextServedModel;
-            startOpenAISSE(res, completionId, createdAt, normalized.requestedModel, servedModel, sellerId);
-        },
-        onDelta: (text) => {
-            if (res.writableEnded)
-                return;
-            writeOpenAIDelta(res, completionId, createdAt, servedModel, text);
-        },
-        onEnd: (outputTokens) => {
-            if (res.writableEnded)
-                return;
-            endOpenAISSE(res, completionId, createdAt, servedModel, outputTokens);
-        },
-        onError: (message) => {
-            if (res.writableEnded)
-                return;
-            failOpenAISSE(res, message);
-        },
+    return [];
+}
+function findMatchingAvailableToolName(candidate, availableToolNames) {
+    const normalizedAvailable = availableToolNames
+        .map((name) => name.trim())
+        .filter((name) => name.length > 0);
+    if (normalizedAvailable.length === 0)
+        return null;
+    const loweredCandidate = candidate.trim().toLowerCase();
+    if (!loweredCandidate)
+        return null;
+    const exact = normalizedAvailable.find((name) => name.toLowerCase() === loweredCandidate);
+    if (exact)
+        return exact;
+    const separatorMatch = normalizedAvailable.find((name) => {
+        const lowered = name.toLowerCase();
+        return loweredCandidate.startsWith(`${lowered}_`)
+            || loweredCandidate.startsWith(`${lowered}-`)
+            || loweredCandidate.endsWith(`_${lowered}`)
+            || loweredCandidate.endsWith(`-${lowered}`);
     });
+    if (separatorMatch)
+        return separatorMatch;
+    if (/(?:browse|browser|navigate|open_url|open-url)/i.test(loweredCandidate)) {
+        const browserTool = normalizedAvailable.find((name) => name.toLowerCase() === 'browser');
+        if (browserTool)
+            return browserTool;
+    }
+    if (/search/i.test(loweredCandidate)) {
+        const searchTool = normalizedAvailable.find((name) => name.toLowerCase() === 'search');
+        if (searchTool)
+            return searchTool;
+    }
+    if (/(?:exec|command|shell|terminal|bash|sh)/i.test(loweredCandidate)) {
+        const execTool = normalizedAvailable.find((name) => name.toLowerCase() === 'exec');
+        if (execTool)
+            return execTool;
+    }
+    return null;
 }
-function sendOpenAIJsonError(res, status, message) {
-    if (res.writableEnded)
-        return;
-    res.writeHead(status, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({
-        error: {
-            type: 'api_error',
-            message,
-        },
-    }));
+function normalizeToolNameForRequest(rawName, fallbackToolName, availableToolNames) {
+    const normalized = normalizeToolName(rawName, fallbackToolName);
+    const matched = findMatchingAvailableToolName(normalized || rawName, availableToolNames);
+    if (matched)
+        return matched;
+    return normalized;
+}
+function parseArgumentsTextToObject(argumentsText) {
+    const trimmed = argumentsText.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function coerceToolNameByArguments(toolName, argumentsText, availableToolNames) {
+    if (findMatchingAvailableToolName(toolName, availableToolNames)) {
+        return toolName;
+    }
+    const argsObj = parseArgumentsTextToObject(argumentsText) || {};
+    const hasBrowserShape = (typeof argsObj.url === 'string'
+        || typeof argsObj.targetUrl === 'string'
+        || typeof argsObj.targetId === 'string'
+        || typeof argsObj.action === 'string');
+    if (hasBrowserShape) {
+        const browserTool = findMatchingAvailableToolName('browser', availableToolNames);
+        if (browserTool)
+            return browserTool;
+    }
+    const hasExecShape = (typeof argsObj.command === 'string'
+        || typeof argsObj.cmd === 'string'
+        || typeof argsObj.path === 'string'
+        || typeof argsObj.file_path === 'string');
+    if (hasExecShape) {
+        const execTool = findMatchingAvailableToolName('exec', availableToolNames);
+        if (execTool)
+            return execTool;
+    }
+    if (typeof argsObj.path === 'string'
+        || typeof argsObj.file_path === 'string'
+        || typeof argsObj.targetId === 'string') {
+        const readTool = findMatchingAvailableToolName('read', availableToolNames);
+        if (readTool)
+            return readTool;
+    }
+    if (typeof argsObj.to === 'string'
+        && (typeof argsObj.body === 'string' || typeof argsObj.subject === 'string')) {
+        const messageTool = findMatchingAvailableToolName('message', availableToolNames);
+        if (messageTool)
+            return messageTool;
+    }
+    if (availableToolNames.length === 1) {
+        return availableToolNames[0] || toolName;
+    }
+    return toolName;
+}
+function shouldForceBrowserOpenToolCall(text, availableToolNames, fallbackUrl) {
+    if (!fallbackUrl)
+        return false;
+    if (!findMatchingAvailableToolName('browser', availableToolNames))
+        return false;
+    if (!text.trim())
+        return false;
+    const refusalPattern = /(?:无法|不能|没法|不具备|cannot|can't|unable|not able|no ability)/i;
+    const browserPattern = /(?:浏览器|browser|网页|website|x\.com|twitter)/i;
+    return refusalPattern.test(text) && browserPattern.test(text);
+}
+function parseToolArgumentsAsAnthropicInput(argumentsText, toolName, fallbacks) {
+    const normalizedToolName = normalizeToolName(toolName || '', null);
+    const isExecTool = normalizedToolName === 'exec';
+    const isWebFetchTool = normalizedToolName === 'web_fetch';
+    const isBrowserTool = normalizedToolName === 'browser';
+    const trimmed = argumentsText.trim();
+    const fallbackExecCommand = typeof fallbacks?.execCommand === 'string'
+        ? sanitizeExtractedExecCommand(fallbacks.execCommand)
+        : '';
+    const fallbackWebFetchUrl = typeof fallbacks?.webFetchUrl === 'string'
+        ? fallbacks.webFetchUrl.trim()
+        : '';
+    const fallbackBrowserProfile = typeof fallbacks?.browserProfile === 'string'
+        ? fallbacks.browserProfile.trim()
+        : '';
+    const fallbackBrowserActionEnum = Array.isArray(fallbacks?.browserActionEnum)
+        ? fallbacks.browserActionEnum
+            .map((item) => (typeof item === 'string' ? item.trim().toLowerCase() : ''))
+            .filter((item) => item.length > 0)
+        : [];
+    const fallbackBrowserRequestKindEnum = Array.isArray(fallbacks?.browserRequestKindEnum)
+        ? fallbacks.browserRequestKindEnum
+            .map((item) => (typeof item === 'string' ? item.trim().toLowerCase() : ''))
+            .filter((item) => item.length > 0)
+        : [];
+    const normalizeExecCommand = (raw) => {
+        let cmd = sanitizeExtractedExecCommand(raw);
+        if (!cmd)
+            return cmd;
+        if (/^openclaw(\s|$)/i.test(cmd)) {
+            cmd = cmd.replace(/^openclaw\b/i, '/usr/local/bin/node /usr/local/bin/openclaw');
+        }
+        else if (/^\/usr\/local\/bin\/openclaw(\s|$)/i.test(cmd)) {
+            cmd = cmd.replace(/^\/usr\/local\/bin\/openclaw\b/i, '/usr/local/bin/node /usr/local/bin/openclaw');
+        }
+        if (/^\/usr\/local\/bin\/node\s+\/usr\/local\/bin\/openclaw\s+cron\s+run\b/i.test(cmd) && !/\s--timeout\b/i.test(cmd)) {
+            cmd = `${cmd} --timeout 300000`;
+        }
+        return cmd;
+    };
+    const normalizeExecInput = (value) => {
+        if (typeof value === 'string') {
+            const cmd = normalizeExecCommand(value);
+            if (cmd)
+                return { command: cmd };
+            if (fallbackExecCommand)
+                return { command: normalizeExecCommand(fallbackExecCommand) };
+            return {};
+        }
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const obj = value;
+            if (typeof obj.command === 'string' && obj.command.trim()) {
+                const normalized = { ...obj };
+                normalized.command = normalizeExecCommand(obj.command);
+                return normalized;
+            }
+            if (typeof obj.cmd === 'string' && obj.cmd.trim()) {
+                const normalized = { ...obj };
+                normalized.command = normalizeExecCommand(obj.cmd);
+                return normalized;
+            }
+            if (typeof obj.value === 'string' && obj.value.trim()) {
+                return { command: normalizeExecCommand(obj.value) };
+            }
+            if (typeof obj.path === 'string' && obj.path.trim()) {
+                const escaped = obj.path.replace(/"/g, '\\"');
+                return { command: normalizeExecCommand(`cat "${escaped}"`) };
+            }
+            if (typeof obj.file_path === 'string' && obj.file_path.trim()) {
+                const escaped = obj.file_path.replace(/"/g, '\\"');
+                return { command: normalizeExecCommand(`cat "${escaped}"`) };
+            }
+            if (fallbackExecCommand) {
+                return {
+                    ...obj,
+                    command: normalizeExecCommand(fallbackExecCommand),
+                };
+            }
+            return obj;
+        }
+        if (value === null || value === undefined) {
+            if (fallbackExecCommand)
+                return { command: normalizeExecCommand(fallbackExecCommand) };
+            return {};
+        }
+        const stringValue = normalizeExecCommand(String(value));
+        if (stringValue)
+            return { command: stringValue };
+        if (fallbackExecCommand)
+            return { command: normalizeExecCommand(fallbackExecCommand) };
+        return {};
+    };
+    const normalizeWebFetchInput = (value) => {
+        if (typeof value === 'string') {
+            const url = value.trim();
+            if (url)
+                return { url };
+            if (fallbackWebFetchUrl)
+                return { url: fallbackWebFetchUrl };
+            return {};
+        }
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const obj = value;
+            if (typeof obj.url === 'string' && obj.url.trim()) {
+                return { ...obj, url: obj.url.trim() };
+            }
+            if (fallbackWebFetchUrl) {
+                return { ...obj, url: fallbackWebFetchUrl };
+            }
+            return obj;
+        }
+        if (fallbackWebFetchUrl)
+            return { url: fallbackWebFetchUrl };
+        return {};
+    };
+    const normalizeBrowserInput = (value) => {
+        if (typeof value === 'string') {
+            const url = value.trim();
+            if (!url)
+                return {};
+            return { action: 'open', url, targetUrl: url };
+        }
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const obj = value;
+            const normalized = { ...obj };
+            if (typeof normalized.url === 'string') {
+                normalized.url = normalized.url.trim();
+            }
+            if (typeof normalized.targetUrl === 'string') {
+                normalized.targetUrl = normalized.targetUrl.trim();
+            }
+            const toFiniteNumber = (raw) => {
+                if (typeof raw === 'number' && Number.isFinite(raw))
+                    return raw;
+                if (typeof raw === 'string' && raw.trim()) {
+                    const parsed = Number(raw.trim());
+                    if (Number.isFinite(parsed))
+                        return parsed;
+                }
+                return undefined;
+            };
+            const parseWaitMs = () => {
+                const directRaw = normalized.timeMs ?? normalized.waitMs ?? normalized.wait ?? normalized.time;
+                const directValue = toFiniteNumber(directRaw);
+                if (directValue !== undefined && directValue > 0) {
+                    return Math.round(directValue);
+                }
+                const durationRaw = normalized.duration ?? normalized.delay ?? normalized.sleep;
+                const durationValue = toFiniteNumber(durationRaw);
+                if (durationValue !== undefined && durationValue > 0) {
+                    // Most model outputs express "duration" in seconds.
+                    if (durationValue <= 60)
+                        return Math.round(durationValue * 1000);
+                    return Math.round(durationValue);
+                }
+                return undefined;
+            };
+            const parseTimeoutMs = () => {
+                const timeoutRaw = normalized.timeoutMs ?? normalized.timeout;
+                const timeoutValue = toFiniteNumber(timeoutRaw);
+                if (timeoutValue === undefined || timeoutValue <= 0)
+                    return undefined;
+                if (timeoutValue <= 60)
+                    return Math.round(timeoutValue * 1000);
+                return Math.round(timeoutValue);
+            };
+            const parseLoadState = () => {
+                const rawLoadState = (normalized.loadState
+                    ?? normalized.state
+                    ?? normalized.load);
+                if (typeof rawLoadState !== 'string')
+                    return undefined;
+                const lowered = rawLoadState.trim().toLowerCase();
+                if (!lowered)
+                    return undefined;
+                if (lowered === 'load' || lowered === 'domcontentloaded' || lowered === 'networkidle') {
+                    return lowered;
+                }
+                return undefined;
+            };
+            const parseRequestObject = () => {
+                if (normalized.request && typeof normalized.request === 'object' && !Array.isArray(normalized.request)) {
+                    return { ...normalized.request };
+                }
+                if (typeof normalized.request === 'string') {
+                    const requestText = normalized.request.trim();
+                    if (requestText.startsWith('{') || requestText.startsWith('[')) {
+                        try {
+                            const parsedRequest = JSON.parse(requestText);
+                            if (parsedRequest && typeof parsedRequest === 'object' && !Array.isArray(parsedRequest)) {
+                                return { ...parsedRequest };
+                            }
+                        }
+                        catch {
+                            // Keep fallback empty object when request text is not valid JSON.
+                        }
+                    }
+                }
+                return {};
+            };
+            let action = '';
+            if (typeof normalized.action === 'string' && normalized.action.trim()) {
+                action = normalized.action.trim().toLowerCase();
+            }
+            else if (typeof normalized.url === 'string' && normalized.url) {
+                action = 'open';
+            }
+            else if (typeof normalized.query === 'string' && normalized.query.trim()) {
+                action = 'search';
+            }
+            const allowedActions = new Set((fallbackBrowserActionEnum.length > 0
+                ? fallbackBrowserActionEnum
+                : [
+                    'open',
+                    'close',
+                    'stop',
+                    'start',
+                    'console',
+                    'status',
+                    'navigate',
+                    'profiles',
+                    'focus',
+                    'upload',
+                    'tabs',
+                    'screenshot',
+                    'snapshot',
+                    'pdf',
+                    'dialog',
+                    'act',
+                ])
+                .map((item) => item.toLowerCase()));
+            const allowedRequestKinds = new Set((fallbackBrowserRequestKindEnum.length > 0
+                ? fallbackBrowserRequestKindEnum
+                : [
+                    'fill',
+                    'close',
+                    'type',
+                    'resize',
+                    'wait',
+                    'select',
+                    'click',
+                    'drag',
+                    'evaluate',
+                    'hover',
+                    'press',
+                ])
+                .map((item) => item.toLowerCase()));
+            const isAllowedAction = (candidate) => {
+                if (!candidate)
+                    return false;
+                return allowedActions.has(candidate.toLowerCase());
+            };
+            const isAllowedRequestKind = (candidate) => {
+                if (!candidate)
+                    return false;
+                return allowedRequestKinds.has(candidate.toLowerCase());
+            };
+            const asNonEmptyString = (raw) => {
+                if (typeof raw !== 'string')
+                    return undefined;
+                const value = raw.trim();
+                return value || undefined;
+            };
+            const resolveRef = () => (asNonEmptyString(normalized.ref)
+                || asNonEmptyString(normalized.targetId)
+                || asNonEmptyString(normalized.element));
+            const resolveTextValue = () => (asNonEmptyString(normalized.text)
+                || asNonEmptyString(normalized.value)
+                || asNonEmptyString(normalized.input)
+                || asNonEmptyString(normalized.content)
+                || asNonEmptyString(normalized.query));
+            const resolveActKind = (kind) => {
+                const lowered = kind.trim().toLowerCase();
+                if (isAllowedRequestKind(lowered))
+                    return lowered;
+                const kindAlias = {
+                    input: 'type',
+                    tap: 'click',
+                    dblclick: 'click',
+                    doubleclick: 'click',
+                    double_click: 'click',
+                    keypress: 'press',
+                    execute: 'evaluate',
+                    execute_js: 'evaluate',
+                    'execute-js': 'evaluate',
+                    eval: 'evaluate',
+                    scroll: 'press',
+                    scrolldown: 'press',
+                    scrollup: 'press',
+                    scrollintoview: 'hover',
+                    'scroll-into-view': 'hover',
+                    wait_for_load_state: 'wait',
+                    waitforloadstate: 'wait',
+                    wait_for_selector: 'wait',
+                    waitforselector: 'wait',
+                };
+                const aliased = kindAlias[lowered];
+                if (aliased && isAllowedRequestKind(aliased))
+                    return aliased;
+                if (isAllowedRequestKind('wait'))
+                    return 'wait';
+                const [firstAllowed] = [...allowedRequestKinds];
+                return firstAllowed || 'wait';
+            };
+            const setAction = (nextAction) => {
+                action = nextAction.toLowerCase();
+                normalized.action = action;
+            };
+            const setActRequest = (kind, extras = {}) => {
+                const request = parseRequestObject();
+                request.kind = resolveActKind(kind);
+                for (const [key, rawValue] of Object.entries(extras)) {
+                    if (rawValue === undefined)
+                        continue;
+                    request[key] = rawValue;
+                }
+                normalized.request = request;
+                setAction('act');
+            };
+            const actionAlias = {
+                launch: 'open',
+                start: 'open',
+                goto: 'open',
+                'open-url': 'open',
+                open_url: 'open',
+                openurl: 'open',
+                'wait-for-load-state': 'wait',
+                wait_for_load_state: 'wait',
+                waitforloadstate: 'wait',
+                'wait-for-selector': 'wait',
+                wait_for_selector: 'wait',
+                waitforselector: 'wait',
+                sleep: 'wait',
+                delay: 'wait',
+                pause: 'wait',
+                scrolldown: 'scroll',
+                scroll_down: 'scroll',
+                scrollup: 'scroll',
+                scroll_up: 'scroll',
+                eval: 'evaluate',
+                execute: 'evaluate',
+                execute_js: 'evaluate',
+                'execute-js': 'evaluate',
+                extract: 'snapshot',
+                scrape: 'snapshot',
+                read: 'snapshot',
+                html: 'snapshot',
+                dom: 'snapshot',
+                content: 'snapshot',
+                input: 'type',
+                tap: 'click',
+            };
+            const aliasedAction = action ? actionAlias[action] : undefined;
+            if (typeof aliasedAction === 'string' && aliasedAction) {
+                setAction(aliasedAction);
+            }
+            if (!action) {
+                if (typeof normalized.url === 'string' && normalized.url && isAllowedAction('open')) {
+                    setAction('open');
+                }
+                else if (typeof normalized.query === 'string' && normalized.query.trim() && isAllowedAction('search')) {
+                    setAction('search');
+                }
+            }
+            if (action && !isAllowedAction(action)) {
+                if (isAllowedAction('act')) {
+                    if (action === 'wait') {
+                        const waitExtras = {};
+                        const waitMs = parseWaitMs();
+                        const timeoutMs = parseTimeoutMs();
+                        const loadState = parseLoadState();
+                        if (waitMs !== undefined)
+                            waitExtras.timeMs = waitMs;
+                        if (timeoutMs !== undefined)
+                            waitExtras.timeoutMs = timeoutMs;
+                        if (typeof normalized.selector === 'string' && normalized.selector.trim()) {
+                            waitExtras.selector = normalized.selector.trim();
+                        }
+                        if (typeof normalized.text === 'string' && normalized.text.trim()) {
+                            waitExtras.text = normalized.text.trim();
+                        }
+                        if (typeof normalized.textGone === 'string' && normalized.textGone.trim()) {
+                            waitExtras.textGone = normalized.textGone.trim();
+                        }
+                        if (loadState)
+                            waitExtras.loadState = loadState;
+                        if (Object.keys(waitExtras).length === 0) {
+                            waitExtras.timeMs = 1000;
+                        }
+                        setActRequest('wait', waitExtras);
+                    }
+                    else if (action === 'click') {
+                        setActRequest('click', {
+                            ...(resolveRef() ? { ref: resolveRef() } : {}),
+                            ...(asNonEmptyString(normalized.selector) ? { selector: asNonEmptyString(normalized.selector) } : {}),
+                            ...(typeof normalized.doubleClick === 'boolean' ? { doubleClick: normalized.doubleClick } : {}),
+                            ...(asNonEmptyString(normalized.button) ? { button: asNonEmptyString(normalized.button) } : {}),
+                        });
+                    }
+                    else if (action === 'type' || action === 'fill') {
+                        setActRequest(action === 'fill' ? 'fill' : 'type', {
+                            ...(resolveRef() ? { ref: resolveRef() } : {}),
+                            ...(asNonEmptyString(normalized.selector) ? { selector: asNonEmptyString(normalized.selector) } : {}),
+                            ...(resolveTextValue() ? { text: resolveTextValue() } : {}),
+                        });
+                    }
+                    else if (action === 'press') {
+                        setActRequest('press', {
+                            ...(asNonEmptyString(normalized.key) ? { key: asNonEmptyString(normalized.key) } : { key: 'Enter' }),
+                        });
+                    }
+                    else if (action === 'hover') {
+                        setActRequest('hover', {
+                            ...(resolveRef() ? { ref: resolveRef() } : {}),
+                            ...(asNonEmptyString(normalized.selector) ? { selector: asNonEmptyString(normalized.selector) } : {}),
+                        });
+                    }
+                    else if (action === 'select') {
+                        const values = Array.isArray(normalized.values)
+                            ? normalized.values
+                                .map((item) => (typeof item === 'string' ? item.trim() : ''))
+                                .filter((item) => item.length > 0)
+                            : [];
+                        const value = asNonEmptyString(normalized.value);
+                        setActRequest('select', {
+                            ...(resolveRef() ? { ref: resolveRef() } : {}),
+                            ...(asNonEmptyString(normalized.selector) ? { selector: asNonEmptyString(normalized.selector) } : {}),
+                            ...(values.length > 0 ? { values } : (value ? { values: [value] } : {})),
+                        });
+                    }
+                    else if (action === 'resize') {
+                        const width = toFiniteNumber(normalized.width);
+                        const height = toFiniteNumber(normalized.height);
+                        setActRequest('resize', {
+                            ...(width !== undefined ? { width: Math.round(width) } : {}),
+                            ...(height !== undefined ? { height: Math.round(height) } : {}),
+                        });
+                    }
+                    else if (action === 'drag') {
+                        setActRequest('drag', {
+                            ...(asNonEmptyString(normalized.startRef) ? { startRef: asNonEmptyString(normalized.startRef) } : {}),
+                            ...(asNonEmptyString(normalized.endRef) ? { endRef: asNonEmptyString(normalized.endRef) } : {}),
+                        });
+                    }
+                    else if (action === 'navigate' || action === 'search' || action === 'open') {
+                        if (isAllowedAction('open') && typeof normalized.url === 'string' && normalized.url) {
+                            setAction('open');
+                        }
+                    }
+                    else if ((action === 'scroll' || action === 'evaluate')) {
+                        const direction = typeof normalized.direction === 'string' ? normalized.direction.trim().toLowerCase() : '';
+                        const script = typeof normalized.script === 'string'
+                            ? normalized.script.trim()
+                            : (typeof normalized.fn === 'string' ? normalized.fn.trim() : '');
+                        if (action === 'evaluate' && script && !/scroll/i.test(script)) {
+                            const timeoutMs = parseTimeoutMs();
+                            setActRequest('evaluate', {
+                                fn: script,
+                                ...(resolveRef() ? { ref: resolveRef() } : {}),
+                                ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+                            });
+                        }
+                        else {
+                            setActRequest('press', { key: direction === 'up' ? 'PageUp' : 'PageDown' });
+                        }
+                    }
+                    else if (action === 'scrollintoview') {
+                        setActRequest('hover', {
+                            ...(resolveRef() ? { ref: resolveRef() } : {}),
+                            ...(asNonEmptyString(normalized.selector) ? { selector: asNonEmptyString(normalized.selector) } : {}),
+                        });
+                    }
+                    else if (action === 'snapshot' && isAllowedAction('screenshot')) {
+                        setAction('screenshot');
+                    }
+                    else if (action === 'close') {
+                        setActRequest('close');
+                    }
+                }
+                else if (action === 'navigate' || action === 'search') {
+                    if (isAllowedAction('open') && typeof normalized.url === 'string' && normalized.url) {
+                        setAction('open');
+                    }
+                }
+                else if (action === 'snapshot' && !isAllowedAction('snapshot') && isAllowedAction('screenshot')) {
+                    setAction('screenshot');
+                }
+            }
+            if (action && !isAllowedAction(action)) {
+                const navLikeAction = new Set([
+                    'open',
+                    'navigate',
+                    'search',
+                    'goto',
+                    'launch',
+                    'start',
+                ]);
+                if (navLikeAction.has(action)
+                    && isAllowedAction('open')
+                    && typeof normalized.url === 'string'
+                    && normalized.url) {
+                    setAction('open');
+                }
+                else if (isAllowedAction('act')) {
+                    const waitMs = parseWaitMs();
+                    setActRequest('wait', { timeMs: waitMs ?? 1000 });
+                }
+                else if (isAllowedAction('snapshot')) {
+                    setAction('snapshot');
+                }
+                else if (isAllowedAction('screenshot')) {
+                    setAction('screenshot');
+                }
+                else {
+                    const [firstAllowed] = [...allowedActions];
+                    if (firstAllowed)
+                        setAction(firstAllowed);
+                }
+            }
+            if (!normalized.url && fallbackWebFetchUrl) {
+                normalized.url = fallbackWebFetchUrl;
+                if (!action && isAllowedAction('open')) {
+                    setAction('open');
+                }
+            }
+            if (!normalized.targetUrl && typeof normalized.url === 'string' && normalized.url) {
+                normalized.targetUrl = normalized.url;
+            }
+            if (!normalized.profile && fallbackBrowserProfile) {
+                normalized.profile = fallbackBrowserProfile;
+            }
+            return normalized;
+        }
+        if (fallbackWebFetchUrl) {
+            return {
+                action: 'open',
+                url: fallbackWebFetchUrl,
+                targetUrl: fallbackWebFetchUrl,
+                ...(fallbackBrowserProfile ? { profile: fallbackBrowserProfile } : {}),
+            };
+        }
+        return {};
+    };
+    if (!trimmed) {
+        if (isExecTool && fallbackExecCommand) {
+            return { command: normalizeExecCommand(fallbackExecCommand) };
+        }
+        if (isWebFetchTool && fallbackWebFetchUrl) {
+            return { url: fallbackWebFetchUrl };
+        }
+        if (isBrowserTool && fallbackWebFetchUrl) {
+            return {
+                action: 'open',
+                url: fallbackWebFetchUrl,
+                targetUrl: fallbackWebFetchUrl,
+                ...(fallbackBrowserProfile ? { profile: fallbackBrowserProfile } : {}),
+            };
+        }
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (isExecTool) {
+            return normalizeExecInput(parsed);
+        }
+        if (isWebFetchTool) {
+            return normalizeWebFetchInput(parsed);
+        }
+        if (isBrowserTool) {
+            return normalizeBrowserInput(parsed);
+        }
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return { value: parsed };
+    }
+    catch {
+        if (isExecTool) {
+            const commandMatch = trimmed.match(/"command"\s*:\s*"([^"]+)"/i);
+            if (commandMatch && commandMatch[1]) {
+                return { command: normalizeExecCommand(commandMatch[1]) };
+            }
+            const cmdMatch = trimmed.match(/"cmd"\s*:\s*"([^"]+)"/i);
+            if (cmdMatch && cmdMatch[1]) {
+                return { command: normalizeExecCommand(cmdMatch[1]) };
+            }
+            const normalized = normalizeExecCommand(trimmed);
+            if (normalized)
+                return { command: normalized };
+            if (fallbackExecCommand)
+                return { command: normalizeExecCommand(fallbackExecCommand) };
+            return {};
+        }
+        if (isWebFetchTool) {
+            const urlMatch = trimmed.match(/"url"\s*:\s*"([^"]+)"/i);
+            if (urlMatch?.[1])
+                return { url: urlMatch[1].trim() };
+            const inline = extractFirstUrl(trimmed);
+            if (inline)
+                return { url: inline };
+            if (fallbackWebFetchUrl)
+                return { url: fallbackWebFetchUrl };
+            return {};
+        }
+        if (isBrowserTool) {
+            const inline = extractFirstUrl(trimmed);
+            if (inline)
+                return { action: 'open', url: inline, targetUrl: inline };
+            if (fallbackWebFetchUrl) {
+                return {
+                    action: 'open',
+                    url: fallbackWebFetchUrl,
+                    targetUrl: fallbackWebFetchUrl,
+                    ...(fallbackBrowserProfile ? { profile: fallbackBrowserProfile } : {}),
+                };
+            }
+            return {};
+        }
+        return { value: trimmed };
+    }
 }
 async function handleOpenAINonStreamRequest(req, res, rawRequest) {
     const normalized = normalizeOpenAIRequest(rawRequest);
@@ -1274,6 +4103,9 @@ async function handleOpenAINonStreamRequest(req, res, rawRequest) {
         sendOpenAIJsonError(res, 400, 'messages 不能为空');
         return;
     }
+    const preferredToolName = resolvePreferredToolNameFromRequest(normalized.requestPayload);
+    const availableToolNames = extractToolNamesFromRequest(normalized.requestPayload);
+    const toolInputFallbacks = deriveToolInputFallbacksFromRequest(normalized.requestPayload);
     if (isCursorOpenAIChallenge(rawRequest)) {
         const completionId = `chatcmpl_${Math.random().toString(36).slice(2, 12)}`;
         const createdAt = Math.floor(Date.now() / 1000);
@@ -1323,6 +4155,18 @@ async function handleOpenAINonStreamRequest(req, res, rawRequest) {
     let sellerId = '';
     let outputText = '';
     let finished = false;
+    let sawToolCall = false;
+    let nextToolIndex = 0;
+    const toolCalls = new Map();
+    const anthropicToolBlockMap = new Map();
+    const allocateToolIndex = (anthropicBlockIndex) => {
+        const existing = anthropicToolBlockMap.get(anthropicBlockIndex);
+        if (existing !== undefined)
+            return existing;
+        const idx = nextToolIndex++;
+        anthropicToolBlockMap.set(anthropicBlockIndex, idx);
+        return idx;
+    };
     const finishWithError = (message) => {
         if (finished)
             return;
@@ -1343,6 +4187,62 @@ async function handleOpenAINonStreamRequest(req, res, rawRequest) {
         if (sellerId) {
             headers['x-clawmarket-seller'] = sellerId;
         }
+        const parsedFromText = extractToolCallsFromText(outputText, preferredToolName);
+        outputText = parsedFromText.cleanText;
+        for (const tool of parsedFromText.calls) {
+            const normalizedBaseName = normalizeToolNameForRequest(tool.name, preferredToolName, availableToolNames) || tool.name || 'tool';
+            const normalizedToolName = coerceToolNameByArguments(normalizedBaseName, tool.arguments, availableToolNames);
+            const normalizedInput = parseToolArgumentsAsAnthropicInput(tool.arguments, normalizedToolName, toolInputFallbacks);
+            const toolIndex = nextToolIndex++;
+            applyOpenAIToolCallDelta(toolCalls, {
+                index: toolIndex,
+                id: `call_${completionId}_${toolIndex}`,
+                name: normalizedToolName,
+                arguments: JSON.stringify(normalizedInput),
+            });
+            sawToolCall = true;
+        }
+        const normalizedToolCalls = toolCallStateToOpenAIList(toolCalls).map((call) => {
+            if (!call || typeof call !== 'object')
+                return call;
+            const callObj = call;
+            const fn = callObj.function && typeof callObj.function === 'object'
+                ? callObj.function
+                : {};
+            const rawToolName = typeof fn.name === 'string' ? fn.name : '';
+            let argumentsText = '';
+            if (typeof fn.arguments === 'string') {
+                argumentsText = fn.arguments;
+            }
+            else if (fn.arguments !== undefined) {
+                try {
+                    argumentsText = JSON.stringify(fn.arguments);
+                }
+                catch {
+                    argumentsText = String(fn.arguments);
+                }
+            }
+            const normalizedBaseName = normalizeToolNameForRequest(rawToolName, preferredToolName, availableToolNames) || rawToolName || 'tool';
+            const normalizedToolName = coerceToolNameByArguments(normalizedBaseName, argumentsText, availableToolNames);
+            const normalizedInput = parseToolArgumentsAsAnthropicInput(argumentsText, normalizedToolName, toolInputFallbacks);
+            return {
+                ...callObj,
+                function: {
+                    ...fn,
+                    name: normalizedToolName,
+                    arguments: JSON.stringify(normalizedInput),
+                },
+            };
+        });
+        const hasToolCalls = normalizedToolCalls.length > 0;
+        const finishReason = hasToolCalls || sawToolCall ? 'tool_calls' : 'stop';
+        const assistantMessage = {
+            role: 'assistant',
+            content: outputText || (finishReason === 'tool_calls' ? null : ''),
+        };
+        if (hasToolCalls) {
+            assistantMessage.tool_calls = normalizedToolCalls;
+        }
         res.writeHead(200, headers);
         res.end(JSON.stringify({
             id: completionId,
@@ -1352,11 +4252,8 @@ async function handleOpenAINonStreamRequest(req, res, rawRequest) {
             choices: [
                 {
                     index: 0,
-                    message: {
-                        role: 'assistant',
-                        content: outputText,
-                    },
-                    finish_reason: 'stop',
+                    message: assistantMessage,
+                    finish_reason: finishReason,
                 },
             ],
             usage: {
@@ -1374,6 +4271,111 @@ async function handleOpenAINonStreamRequest(req, res, rawRequest) {
         onDelta: (text) => {
             outputText += text;
         },
+        onAnthropicEvent: (eventName, eventData) => {
+            if (eventName === 'content_block_start') {
+                const block = eventData.content_block;
+                const blockIndex = Number.isFinite(Number(eventData.index)) ? Number(eventData.index) : -1;
+                if (block && typeof block === 'object') {
+                    const anyBlock = block;
+                    if (anyBlock.type === 'tool_use') {
+                        const toolIndex = blockIndex >= 0 ? allocateToolIndex(blockIndex) : nextToolIndex++;
+                        const delta = {
+                            index: toolIndex,
+                            id: typeof anyBlock.id === 'string' && anyBlock.id.trim()
+                                ? anyBlock.id.trim()
+                                : `call_${completionId}_${toolIndex}`,
+                            name: normalizeToolNameForRequest(typeof anyBlock.name === 'string' && anyBlock.name.trim()
+                                ? anyBlock.name.trim()
+                                : 'tool', preferredToolName, availableToolNames) || 'tool',
+                        };
+                        let argumentsText = '';
+                        if (anyBlock.input !== undefined) {
+                            try {
+                                argumentsText = JSON.stringify(anyBlock.input);
+                            }
+                            catch {
+                                argumentsText = String(anyBlock.input);
+                            }
+                        }
+                        const coercedName = coerceToolNameByArguments(delta.name || 'tool', argumentsText, availableToolNames);
+                        const normalizedInput = parseToolArgumentsAsAnthropicInput(argumentsText, coercedName, toolInputFallbacks);
+                        delta.name = coercedName;
+                        delta.arguments = JSON.stringify(normalizedInput);
+                        applyOpenAIToolCallDelta(toolCalls, delta);
+                        sawToolCall = true;
+                        return;
+                    }
+                    if (anyBlock.type === 'text' && typeof anyBlock.text === 'string' && anyBlock.text.length > 0) {
+                        outputText += anyBlock.text;
+                        return;
+                    }
+                }
+            }
+            if (eventName === 'content_block_delta') {
+                const delta = eventData.delta;
+                if (!delta || typeof delta !== 'object')
+                    return;
+                const anyDelta = delta;
+                if ((anyDelta.type === 'text_delta' || anyDelta.type === undefined) && typeof anyDelta.text === 'string') {
+                    outputText += anyDelta.text;
+                    return;
+                }
+                if (anyDelta.type === 'input_json_delta' && typeof anyDelta.partial_json === 'string') {
+                    const blockIndex = Number.isFinite(Number(eventData.index)) ? Number(eventData.index) : -1;
+                    const toolIndex = blockIndex >= 0 ? allocateToolIndex(blockIndex) : nextToolIndex++;
+                    const existing = toolCalls.get(toolIndex);
+                    if (!existing) {
+                        applyOpenAIToolCallDelta(toolCalls, {
+                            index: toolIndex,
+                            id: `call_${completionId}_${toolIndex}`,
+                            name: preferredToolName || 'tool',
+                            arguments: '',
+                        });
+                    }
+                    applyOpenAIToolCallDelta(toolCalls, { index: toolIndex, arguments: anyDelta.partial_json });
+                    sawToolCall = true;
+                }
+                return;
+            }
+            if (eventName === 'message_delta') {
+                const delta = eventData.delta;
+                if (delta && typeof delta === 'object') {
+                    const stopReason = delta.stop_reason;
+                    if (stopReason === 'tool_use') {
+                        sawToolCall = true;
+                    }
+                }
+            }
+        },
+        onOpenAIEvent: (eventData) => {
+            const textDelta = extractOpenAITextDelta(eventData);
+            if (textDelta.length > 0) {
+                outputText += textDelta;
+            }
+            const toolDeltas = extractOpenAIToolCallDeltas(eventData);
+            if (toolDeltas.length > 0) {
+                toolDeltas.forEach((delta) => {
+                    const argsText = typeof delta.arguments === 'string' ? delta.arguments : '';
+                    const normalizedBaseName = delta.name
+                        ? (normalizeToolNameForRequest(delta.name, preferredToolName, availableToolNames) || delta.name)
+                        : undefined;
+                    const coercedName = normalizedBaseName
+                        ? coerceToolNameByArguments(normalizedBaseName, argsText, availableToolNames)
+                        : undefined;
+                    const normalizedDelta = {
+                        ...delta,
+                        ...(delta.name
+                            ? { name: coercedName || delta.name }
+                            : {}),
+                    };
+                    applyOpenAIToolCallDelta(toolCalls, normalizedDelta);
+                });
+                sawToolCall = true;
+            }
+            if (extractOpenAIFinishReason(eventData) === 'tool_calls') {
+                sawToolCall = true;
+            }
+        },
         onEnd: (outputTokens) => {
             finishWithSuccess(outputTokens);
         },
@@ -1383,7 +4385,80 @@ async function handleOpenAINonStreamRequest(req, res, rawRequest) {
     });
 }
 // ============ 非流式兼容（走 Gateway HTTP） ============
-function proxyRequestHTTP(req, res, body, ticket) {
+function bridgeAnthropicNonStreamResponse(payload, requestPayload) {
+    const preferredToolName = resolvePreferredToolNameFromRequest(requestPayload);
+    const availableToolNames = extractToolNamesFromRequest(requestPayload);
+    const toolInputFallbacks = deriveToolInputFallbacksFromRequest(requestPayload);
+    const sourceContent = Array.isArray(payload.content) ? payload.content : [];
+    const bridgedContent = [];
+    let sawToolUse = false;
+    const pushToolUse = (toolNameRaw, argumentsRaw, toolIdRaw) => {
+        const normalizedBaseName = normalizeToolNameForRequest(String(toolNameRaw || '').trim(), preferredToolName, availableToolNames);
+        let argumentsText = '';
+        if (typeof argumentsRaw === 'string') {
+            argumentsText = argumentsRaw;
+        }
+        else if (argumentsRaw !== undefined) {
+            try {
+                argumentsText = JSON.stringify(argumentsRaw);
+            }
+            catch {
+                argumentsText = String(argumentsRaw);
+            }
+        }
+        const normalizedName = coerceToolNameByArguments(normalizedBaseName, argumentsText, availableToolNames);
+        if (!normalizedName)
+            return;
+        bridgedContent.push({
+            type: 'tool_use',
+            id: (typeof toolIdRaw === 'string' && toolIdRaw.trim())
+                ? toolIdRaw
+                : `toolu_${Math.random().toString(36).slice(2, 12)}`,
+            name: normalizedName,
+            input: parseToolArgumentsAsAnthropicInput(argumentsText, normalizedName, toolInputFallbacks),
+        });
+        sawToolUse = true;
+    };
+    for (const block of sourceContent) {
+        if (!block || typeof block !== 'object') {
+            continue;
+        }
+        const blockObj = block;
+        if (blockObj.type === 'text' && typeof blockObj.text === 'string') {
+            const parsed = extractToolCallsFromText(blockObj.text, preferredToolName);
+            if (parsed.cleanText.trim().length > 0) {
+                bridgedContent.push({
+                    ...blockObj,
+                    text: parsed.cleanText,
+                });
+            }
+            for (const call of parsed.calls) {
+                pushToolUse(call.name, call.arguments);
+            }
+            continue;
+        }
+        if (blockObj.type === 'tool_use') {
+            pushToolUse(blockObj.name, blockObj.input, blockObj.id);
+            continue;
+        }
+        bridgedContent.push(blockObj);
+    }
+    if (!sawToolUse) {
+        return payload;
+    }
+    return {
+        ...payload,
+        content: bridgedContent,
+        stop_reason: 'tool_use',
+        stop_sequence: null,
+    };
+}
+function proxyAnthropicNonStreamRequest(res, body, requestPayload, ticket) {
+    debugBridge('anthropic_nonstream_req', {
+        model: typeof requestPayload.model === 'string' ? requestPayload.model : null,
+        preferredToolName: resolvePreferredToolNameFromRequest(requestPayload) || null,
+        fallbackExecCommand: deriveToolInputFallbacksFromRequest(requestPayload).execCommand || null,
+    });
     const url = new URL(GATEWAY_URL);
     const mod = url.protocol === 'https:' ? https : http;
     const headers = { 'Content-Type': 'application/json', 'x-api-key': wallet.address, 'anthropic-version': '2023-06-01' };
@@ -1394,8 +4469,34 @@ function proxyRequestHTTP(req, res, body, ticket) {
         headers['x-clawmarket-signature'] = ticket.signature;
     }
     const proxyReq = mod.request({ hostname: url.hostname, port: url.port || (url.protocol === 'https:' ? 443 : 80), path: '/v1/messages', method: 'POST', headers }, (proxyRes) => {
-        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-        proxyRes.pipe(res);
+        let raw = '';
+        proxyRes.on('data', (chunk) => {
+            raw += chunk.toString();
+        });
+        proxyRes.on('end', () => {
+            const status = proxyRes.statusCode || 200;
+            if (status >= 400) {
+                res.writeHead(status, { 'Content-Type': 'application/json' });
+                res.end(raw);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(raw);
+                const bridged = bridgeAnthropicNonStreamResponse(parsed, requestPayload);
+                debugBridge('anthropic_nonstream_resp', {
+                    stopReason: bridged.stop_reason ?? null,
+                    contentTypes: Array.isArray(bridged.content)
+                        ? bridged.content.map((item) => (item && typeof item === 'object' ? item.type ?? null : null))
+                        : [],
+                });
+                res.writeHead(status, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(bridged));
+            }
+            catch {
+                res.writeHead(status, { 'Content-Type': proxyRes.headers['content-type'] || 'application/json' });
+                res.end(raw);
+            }
+        });
     });
     proxyReq.setTimeout(30_000, () => {
         proxyReq.destroy(new Error('gateway_timeout'));
@@ -1467,12 +4568,27 @@ async function handleRequest(req, res) {
         req.on('end', async () => {
             try {
                 const request = JSON.parse(body);
+                const requestRecord = request;
+                const toolNames = extractToolNamesFromRequest(requestRecord);
+                debugBridge('incoming_messages', {
+                    stream: request?.stream === true,
+                    model: typeof request?.model === 'string' ? request.model : null,
+                    preferredToolName: resolvePreferredToolNameFromRequest(requestRecord) || null,
+                    toolCount: toolNames.length,
+                    toolNames: toolNames.slice(0, 12),
+                });
                 // 流式请求走 WebSocket
                 if (request.stream) {
                     await handleAnthropicStreamRequest(req, res, body);
                     return;
                 }
                 // 非流式走旧路径
+                const rawAnthropicModel = typeof requestRecord.model === 'string' ? requestRecord.model : '';
+                const normalizedAnthropicModel = normalizeRequestedModelId(rawAnthropicModel);
+                if (normalizedAnthropicModel) {
+                    requestRecord.model = normalizedAnthropicModel;
+                }
+                const normalizedAnthropicBody = JSON.stringify(requestRecord);
                 const sellerAddress = defaultSeller.toLowerCase();
                 let channel = null;
                 try {
@@ -1486,7 +4602,7 @@ async function handleRequest(req, res) {
                     ticket = await signTicket(channel, COST_PER_REQUEST);
                     console.log(`[Ticket] #${ticket.nonce} 累计: ${formatUnits(BigInt(ticket.amount), 6)} USDC`);
                 }
-                proxyRequestHTTP(req, res, body, ticket);
+                proxyAnthropicNonStreamRequest(res, normalizedAnthropicBody, requestRecord, ticket);
             }
             catch (err) {
                 res.writeHead(500, { 'Content-Type': 'application/json' });
@@ -1655,6 +4771,7 @@ async function main() {
     }
     console.log('[路由] 静态模型 fallback:', ENABLE_STATIC_MODEL_FALLBACK ? '开启' : '关闭');
     console.log('[路由] 跨模型 fallback:', ENABLE_CROSS_MODEL_FALLBACK ? '开启' : '关闭');
+    console.log('[路由] 强制 browser open 兜底:', ENABLE_FORCED_BROWSER_OPEN ? '开启' : '关闭');
     const server = http.createServer((req, res) => {
         handleRequest(req, res).catch((err) => {
             if (!res.headersSent) {