dominds 1.22.0 → 1.22.1

package/dist/llm/gen/anthropic.js

@@ -9,7 +9,6 @@ exports.consumeAnthropicStream = consumeAnthropicStream;
 exports.reconstructAnthropicContextWrapper = reconstructAnthropicContextWrapper;
 exports.reconstructAnthropicContextWrapperAsync = reconstructAnthropicContextWrapperAsync;
 const sdk_1 = require("@anthropic-ai/sdk");
-const crypto_1 = require("crypto");
 const events_1 = require("events");
 const fs_1 = require("fs");
 const promises_1 = __importDefault(require("fs/promises"));
@@ -17,7 +16,6 @@ const path_1 = __importDefault(require("path"));
 const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
-const api_quirks_1 = require("../api-quirks");
 const artifacts_1 = require("./artifacts");
 const failure_classifier_1 = require("./failure-classifier");
 const tool_call_context_1 = require("./tool-call-context");
@@ -28,13 +26,6 @@ const ANTHROPIC_JSON_RESPONSE_TOOL_NAME = 'dominds_json_response';
 const ANTHROPIC_JSON_RESPONSE_TOOL_DESCRIPTION = 'Return the final answer as a JSON object. Do not include any non-JSON text.';
 const ANTHROPIC_COMPAT_CAPTURE_SSE_ENV = 'DOMINDS_ANTHROPIC_COMPAT_CAPTURE_SSE';
 const ANTHROPIC_COMPAT_CAPTURE_DIR_ENV = 'DOMINDS_ANTHROPIC_COMPAT_CAPTURE_DIR';
-const VOLCANO_TEXT_TOOL_USE_PATTERN = new RegExp(String.raw `(?:Function call emitted by the assistant\.\r?\n|^|\r?\n)` +
-    String.raw `Tool name:\s*([A-Za-z_][A-Za-z0-9_.:-]*)\r?\n` +
-    String.raw `Call ID:\s*(call_[A-Za-z0-9_-]+)\r?\n` +
-    String.raw `Raw arguments, verbatim:\r?\n` +
-    String.raw `<raw_arguments>(?:\r?\n)?([\s\S]*?)(?:\r?\n)?</raw_arguments>`, 'g');
-const VOLCANO_SEED_TOOL_CALL_PATTERN = /<seed:tool_call>\s*<function\s+name="([A-Za-z_][A-Za-z0-9_.:-]*)">\s*([\s\S]*?)<\/function>\s*<\/seed:tool_call>/g;
-const VOLCANO_SEED_TOOL_PARAMETER_PATTERN = /<parameter\s+name="([^"]+)"\s+string="(true|false)">([\s\S]*?)<\/parameter>/g;
 const ANTHROPIC_JSON_RESPONSE_TOOL_INPUT_SCHEMA = {
     type: 'object',
     additionalProperties: true,
@@ -463,13 +454,6 @@ function createAnthropicClient(args) {
     }
     return new sdk_1.Anthropic(options);
 }
-function resolveAnthropicStreamConsumeQuirks(providerConfig) {
-    const apiQuirks = (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig);
-    return {
-        normalizeLoneClosingBraceEmptyToolInputDelta: apiQuirks.has(api_quirks_1.GLM_VIA_VOLCANO_API_QUIRK),
-        convertVolcanoTextToolUseBlocks: apiQuirks.has(api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK),
-    };
-}
 function buildAnthropicCompatibleMessagesUrl(providerConfig) {
     if (!providerConfig.baseUrl) {
         throw new Error(`Provider '${providerConfig.name}' is missing baseUrl.`);
@@ -1295,24 +1279,11 @@ function stringifyToolUseInitialInput(input) {
     const stringified = JSON.stringify(input);
     return typeof stringified === 'string' && stringified.length > 0 ? stringified : '{}';
 }
-function isEmptyJsonObject(value) {
-    return isNonArrayRecord(value) && Object.keys(value).length === 0;
-}
-function resolveToolUseArgumentsJson(state, quirks) {
+function resolveToolUseArgumentsJson(state) {
     const trimmed = state.inputJson.trim();
     if (trimmed.length === 0) {
         return stringifyToolUseInitialInput(state.initialInput);
     }
-    if (quirks.normalizeLoneClosingBraceEmptyToolInputDelta &&
-        trimmed === '}' &&
-        isEmptyJsonObject(state.initialInput)) {
-        log.warn('ANTH quirk normalized lone closing-brace tool input delta to empty object', undefined, {
-            quirk: api_quirks_1.GLM_VIA_VOLCANO_API_QUIRK,
-            callId: state.id,
-            toolName: state.name,
-        });
-        return '{}';
-    }
     try {
         JSON.parse(trimmed);
         return state.inputJson;
@@ -1328,60 +1299,6 @@ function resolveToolUseArgumentsJson(state, quirks) {
         return state.inputJson;
     }
 }
-function createVolcanoToolCallIdRegistry(knownFunctionCallIds) {
-    return {
-        used: new Set(knownFunctionCallIds ?? []),
-        nextSuffixByCallId: new Map(),
-    };
-}
-function decodeVolcanoSeedXmlText(text) {
-    return text
-        .replace(/&quot;/g, '"')
-        .replace(/&apos;/g, "'")
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&amp;/g, '&');
-}
-function createVolcanoSeedToolCallId(args) {
-    const hash = (0, crypto_1.createHash)('sha256')
-        .update(args.name)
-        .update('\0')
-        .update(args.rawParametersText)
-        .update('\0')
-        .update(String(args.textIndex))
-        .update('\0')
-        .update(args.blockIndex === undefined ? '' : String(args.blockIndex))
-        .digest('hex')
-        .slice(0, 24);
-    if (args.genseq !== undefined) {
-        return `call_volcano_seed_g${String(args.genseq)}_${hash}`;
-    }
-    return `call_volcano_seed_${hash}`;
-}
-function uniquifyVolcanoTextToolCallId(args) {
-    const trimmed = args.callId.trim();
-    if (trimmed.length === 0 || args.idRegistry === undefined)
-        return args.callId;
-    if (!args.idRegistry.used.has(trimmed)) {
-        args.idRegistry.used.add(trimmed);
-        return trimmed;
-    }
-    for (;;) {
-        const nextSuffix = (args.idRegistry.nextSuffixByCallId.get(trimmed) ?? 0) + 1;
-        args.idRegistry.nextSuffixByCallId.set(trimmed, nextSuffix);
-        const candidate = `${trimmed}_v${String(nextSuffix)}`;
-        if (args.idRegistry.used.has(candidate))
-            continue;
-        args.idRegistry.used.add(candidate);
-        log.warn('ANTH volcano-tool-use quirk rewrote duplicate function call id', undefined, {
-            quirk: api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK,
-            originalCallId: trimmed,
-            callId: candidate,
-            toolName: args.toolName,
-        });
-        return candidate;
-    }
-}
 function assertValidAnthropicStreamGenseq(genseq) {
     if (genseq === undefined)
         return;
@@ -1389,259 +1306,6 @@ function assertValidAnthropicStreamGenseq(genseq) {
         throw new Error(`Invalid Anthropic stream genseq for tool-call correlation: ${String(genseq)}`);
     }
 }
-function parseVolcanoSeedParameterValue(args) {
-    const decoded = decodeVolcanoSeedXmlText(args.rawValueText);
-    if (args.stringFlag === 'true')
-        return decoded;
-    try {
-        return JSON.parse(decoded);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Malformed ${api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK} seed tool_call parameter JSON for ${args.name}: ${message}`);
-    }
-}
-function parseVolcanoSeedToolArgumentsJson(rawParametersText) {
-    const parameters = {};
-    let cursor = 0;
-    VOLCANO_SEED_TOOL_PARAMETER_PATTERN.lastIndex = 0;
-    for (;;) {
-        const match = VOLCANO_SEED_TOOL_PARAMETER_PATTERN.exec(rawParametersText);
-        if (!match)
-            break;
-        if (rawParametersText.slice(cursor, match.index).trim().length > 0) {
-            throw new Error(`Malformed ${api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK} seed tool_call: unexpected text between parameters`);
-        }
-        const rawName = match[1];
-        const stringFlag = match[2];
-        const rawValueText = match[3];
-        if (rawName === undefined || stringFlag === undefined || rawValueText === undefined) {
-            throw new Error(`Malformed ${api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK} seed tool_call parameter`);
-        }
-        if (stringFlag !== 'true' && stringFlag !== 'false') {
-            throw new Error(`Malformed ${api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK} seed tool_call string flag`);
-        }
-        const name = decodeVolcanoSeedXmlText(rawName);
-        if (Object.prototype.hasOwnProperty.call(parameters, name)) {
-            throw new Error(`Malformed ${api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK} seed tool_call: duplicate parameter ${name}`);
-        }
-        parameters[name] = parseVolcanoSeedParameterValue({
-            name,
-            stringFlag,
-            rawValueText,
-        });
-        cursor = VOLCANO_SEED_TOOL_PARAMETER_PATTERN.lastIndex;
-    }
-    if (cursor === 0 && rawParametersText.trim().length > 0) {
-        throw new Error(`Malformed ${api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK} seed tool_call parameters`);
-    }
-    if (rawParametersText.slice(cursor).trim().length > 0) {
-        throw new Error(`Malformed ${api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK} seed tool_call: unexpected trailing parameter text`);
-    }
-    return JSON.stringify(parameters);
-}
-function splitVolcanoTextToolUseParts(args) {
-    const parts = [];
-    const matches = [];
-    VOLCANO_TEXT_TOOL_USE_PATTERN.lastIndex = 0;
-    for (;;) {
-        const match = VOLCANO_TEXT_TOOL_USE_PATTERN.exec(args.text);
-        if (!match)
-            break;
-        const name = match[1];
-        const id = match[2];
-        const rawArguments = match[3];
-        if (name === undefined || id === undefined || rawArguments === undefined) {
-            continue;
-        }
-        matches.push({
-            index: match.index,
-            endIndex: VOLCANO_TEXT_TOOL_USE_PATTERN.lastIndex,
-            id,
-            name,
-            rawArgumentsText: rawArguments,
-        });
-    }
-    VOLCANO_SEED_TOOL_CALL_PATTERN.lastIndex = 0;
-    for (;;) {
-        const match = VOLCANO_SEED_TOOL_CALL_PATTERN.exec(args.text);
-        if (!match)
-            break;
-        const name = match[1];
-        const rawParametersText = match[2];
-        if (name === undefined || rawParametersText === undefined) {
-            continue;
-        }
-        matches.push({
-            index: match.index,
-            endIndex: VOLCANO_SEED_TOOL_CALL_PATTERN.lastIndex,
-            id: createVolcanoSeedToolCallId({
-                name,
-                rawParametersText,
-                textIndex: match.index,
-                blockIndex: args.blockIndex,
-                genseq: args.genseq,
-            }),
-            name,
-            rawArgumentsText: parseVolcanoSeedToolArgumentsJson(rawParametersText),
-        });
-    }
-    matches.sort((a, b) => a.index - b.index);
-    let cursor = 0;
-    for (const match of matches) {
-        if (match.index < cursor) {
-            throw new Error(`Malformed ${api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK} text tool_call: overlapping blocks`);
-        }
-        if (match.index > cursor) {
-            parts.push({ kind: 'text', text: args.text.slice(cursor, match.index) });
-        }
-        parts.push({
-            kind: 'tool_use',
-            id: uniquifyVolcanoTextToolCallId({
-                callId: match.id,
-                toolName: match.name,
-                idRegistry: args.idRegistry,
-            }),
-            name: match.name,
-            rawArgumentsText: match.rawArgumentsText,
-        });
-        cursor = match.endIndex;
-    }
-    if (cursor === 0)
-        return [{ kind: 'text', text: args.text }];
-    if (cursor < args.text.length) {
-        parts.push({ kind: 'text', text: args.text.slice(cursor) });
-    }
-    return parts;
-}
-async function emitTextWithVolcanoToolUseQuirk(args) {
-    let sayingStarted = args.sayingStarted;
-    let thinkingStarted = args.thinkingStarted;
-    const parts = args.quirks.convertVolcanoTextToolUseBlocks
-        ? splitVolcanoTextToolUseParts({
-            text: args.text,
-            genseq: args.genseq,
-            blockIndex: args.blockIndex,
-            idRegistry: args.idRegistry,
-        })
-        : [{ kind: 'text', text: args.text }];
-    for (const part of parts) {
-        if (part.kind === 'text') {
-            if (part.text.length === 0)
-                continue;
-            if (thinkingStarted) {
-                log.error('ANTH stream ordering violation: received text_delta while thinking stream still active', new Error('anthropic_stream_order_violation'));
-                await args.receiver.thinkingFinish();
-                thinkingStarted = false;
-            }
-            if (!sayingStarted) {
-                sayingStarted = true;
-                await args.receiver.sayingStart();
-            }
-            await args.receiver.sayingChunk(part.text);
-            continue;
-        }
-        if (sayingStarted) {
-            await args.receiver.sayingFinish();
-            sayingStarted = false;
-        }
-        log.warn('ANTH quirk converted text-rendered tool use to function call', undefined, {
-            quirk: api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK,
-            callId: part.id,
-            toolName: part.name,
-        });
-        await args.receiver.funcCall(part.id, part.name, part.rawArgumentsText);
-    }
-    return { sayingStarted, thinkingStarted };
-}
-async function emitThinkingWithVolcanoToolUseQuirk(args) {
-    let sayingStarted = args.sayingStarted;
-    let thinkingStarted = args.thinkingStarted;
-    const parts = args.quirks.convertVolcanoTextToolUseBlocks
-        ? splitVolcanoTextToolUseParts({
-            text: args.text,
-            genseq: args.genseq,
-            blockIndex: args.blockIndex,
-            idRegistry: args.idRegistry,
-        })
-        : [{ kind: 'text', text: args.text }];
-    for (const part of parts) {
-        if (part.kind === 'text') {
-            if (part.text.length === 0)
-                continue;
-            if (sayingStarted) {
-                log.error('ANTH stream ordering violation: received thinking_delta while saying stream still active', new Error('anthropic_stream_order_violation'));
-                await args.receiver.sayingFinish();
-                sayingStarted = false;
-            }
-            if (!thinkingStarted) {
-                thinkingStarted = true;
-                await args.receiver.thinkingStart();
-            }
-            await args.receiver.thinkingChunk(part.text);
-            continue;
-        }
-        if (thinkingStarted) {
-            await args.receiver.thinkingFinish();
-            thinkingStarted = false;
-        }
-        log.warn('ANTH quirk converted thinking-rendered tool use to function call', undefined, {
-            quirk: api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK,
-            callId: part.id,
-            toolName: part.name,
-        });
-        await args.receiver.funcCall(part.id, part.name, part.rawArgumentsText);
-    }
-    return { sayingStarted, thinkingStarted };
-}
-async function flushPendingVolcanoToolUseBlocks(args) {
-    let sayingStarted = args.sayingStarted;
-    let thinkingStarted = args.thinkingStarted;
-    const blockIndexes = new Set([...args.textBlocks.keys(), ...args.thinkingBlocks.keys()]);
-    for (const blockIndex of [...blockIndexes].sort((a, b) => a - b)) {
-        const pendingText = args.textBlocks.get(blockIndex);
-        const pendingThinking = args.thinkingBlocks.get(blockIndex);
-        if (pendingText !== undefined && pendingThinking !== undefined) {
-            throw new Error(`ANTH invariant violation: block ${String(blockIndex)} has both pending text and thinking`);
-        }
-        if (pendingText === undefined && pendingThinking === undefined) {
-            throw new Error(`ANTH invariant violation: block ${String(blockIndex)} has no pending text or thinking`);
-        }
-        let updated;
-        if (pendingText !== undefined) {
-            updated = await emitTextWithVolcanoToolUseQuirk({
-                text: pendingText,
-                receiver: args.receiver,
-                quirks: args.quirks,
-                sayingStarted,
-                thinkingStarted,
-                genseq: args.genseq,
-                blockIndex,
-                idRegistry: args.idRegistry,
-            });
-        }
-        else {
-            if (pendingThinking === undefined) {
-                throw new Error(`ANTH invariant violation: block ${String(blockIndex)} has no pending thinking`);
-            }
-            updated = await emitThinkingWithVolcanoToolUseQuirk({
-                text: pendingThinking,
-                receiver: args.receiver,
-                quirks: args.quirks,
-                sayingStarted,
-                thinkingStarted,
-                genseq: args.genseq,
-                blockIndex,
-                idRegistry: args.idRegistry,
-            });
-        }
-        sayingStarted = updated.sayingStarted;
-        thinkingStarted = updated.thinkingStarted;
-    }
-    args.textBlocks.clear();
-    args.thinkingBlocks.clear();
-    return { sayingStarted, thinkingStarted };
-}
 /**
  * Convert a single ChatMessage to content blocks for Anthropic SDK.
  * Returns array of content blocks (may contain multiple for complex messages).
@@ -1706,7 +1370,7 @@ function chatMessageToAnthropic(chatMsg) {
         content: contentBlocks.length === 1 ? contentBlocks : contentBlocks,
     };
 }
-function anthropicToChatMessages(message, genseq, forcedJsonToolName, quirks, knownFunctionCallIds) {
+function anthropicToChatMessages(message, genseq, forcedJsonToolName) {
     const results = [];
     if (!isRecord(message)) {
         throw new Error('Invalid Anthropic message: expected object');
@@ -1750,37 +1414,9 @@ function anthropicToChatMessages(message, genseq, forcedJsonToolName, quirks, kn
         });
     };
     if (role === 'assistant') {
-        const volcanoToolCallIdRegistry = quirks?.convertVolcanoTextToolUseBlocks === true
-            ? createVolcanoToolCallIdRegistry(knownFunctionCallIds)
-            : undefined;
         for (const block of blocks) {
             if (isRecord(block) && block.type === 'text' && typeof block.text === 'string') {
-                const parts = quirks?.convertVolcanoTextToolUseBlocks === true
-                    ? splitVolcanoTextToolUseParts({
-                        text: block.text,
-                        genseq,
-                        idRegistry: volcanoToolCallIdRegistry,
-                    })
-                    : [{ kind: 'text', text: block.text }];
-                for (const part of parts) {
-                    if (part.kind === 'text') {
-                        pushAssistantSaying(part.text);
-                        continue;
-                    }
-                    log.warn('ANTH quirk converted batch text-rendered tool use to function call', undefined, {
-                        quirk: api_quirks_1.VOLCANO_TOOL_USE_API_QUIRK,
-                        callId: part.id,
-                        toolName: part.name,
-                    });
-                    results.push({
-                        type: 'func_call_msg',
-                        id: part.id,
-                        name: part.name,
-                        arguments: part.rawArgumentsText,
-                        role: 'assistant',
-                        genseq,
-                    });
-                }
+                pushAssistantSaying(block.text);
                 continue;
             }
             if (isToolUseBlock(block)) {
@@ -1885,20 +1521,11 @@ function validateReconstructedContext(messages) {
     }
 }
 async function consumeAnthropicStream(stream, receiver, options = {}) {
-    const quirks = options.quirks ?? {
-        normalizeLoneClosingBraceEmptyToolInputDelta: false,
-        convertVolcanoTextToolUseBlocks: false,
-    };
     const { abortSignal, forcedJsonToolName, genseq } = options;
     assertValidAnthropicStreamGenseq(genseq);
-    const volcanoToolCallIdRegistry = quirks.convertVolcanoTextToolUseBlocks
-        ? createVolcanoToolCallIdRegistry(options.knownFunctionCallIds)
-        : undefined;
     // Stream lifecycle management using SDK start/stop events
     const activeContentBlocks = new Map();
     const activeToolUses = new Map();
-    const pendingVolcanoTextToolUseBlocks = new Map();
-    const pendingVolcanoThinkingToolUseBlocks = new Map();
     let sayingStarted = false;
     let thinkingStarted = false;
     let messageStarted = false;
@@ -1921,8 +1548,6 @@ async function consumeAnthropicStream(stream, receiver, options = {}) {
                         nextType: contentBlock.type,
                     });
                     activeToolUses.delete(blockIndex);
-                    pendingVolcanoTextToolUseBlocks.delete(blockIndex);
-                    pendingVolcanoThinkingToolUseBlocks.delete(blockIndex);
                 }
                 activeContentBlocks.set(blockIndex, contentBlock);
                 // Track tool use so we can emit function calls once JSON is complete
@@ -1934,12 +1559,6 @@ async function consumeAnthropicStream(stream, receiver, options = {}) {
                         initialInput: contentBlock.input,
                     });
                 }
-                else if (contentBlock.type === 'text' && quirks.convertVolcanoTextToolUseBlocks) {
-                    pendingVolcanoTextToolUseBlocks.set(blockIndex, contentBlock.text ?? '');
-                }
-                else if (contentBlock.type === 'thinking' && quirks.convertVolcanoTextToolUseBlocks) {
-                    pendingVolcanoThinkingToolUseBlocks.set(blockIndex, contentBlock.thinking ?? '');
-                }
                 break;
             }
             case 'content_block_delta': {
@@ -1958,47 +1577,31 @@ async function consumeAnthropicStream(stream, receiver, options = {}) {
                 if (delta.type === 'text_delta') {
                     const textDelta = delta.text ?? '';
                     if (textDelta) {
-                        const pendingText = pendingVolcanoTextToolUseBlocks.get(blockIndex);
-                        if (pendingText !== undefined) {
-                            pendingVolcanoTextToolUseBlocks.set(blockIndex, `${pendingText}${textDelta}`);
+                        if (thinkingStarted) {
+                            log.error('ANTH stream ordering violation: received text_delta while thinking stream still active', new Error('anthropic_stream_order_violation'));
+                            await receiver.thinkingFinish();
+                            thinkingStarted = false;
                         }
-                        else {
-                            const updated = await emitTextWithVolcanoToolUseQuirk({
-                                text: textDelta,
-                                receiver,
-                                quirks,
-                                sayingStarted,
-                                thinkingStarted,
-                                genseq,
-                                blockIndex,
-                                idRegistry: volcanoToolCallIdRegistry,
-                            });
-                            sayingStarted = updated.sayingStarted;
-                            thinkingStarted = updated.thinkingStarted;
+                        if (!sayingStarted) {
+                            sayingStarted = true;
+                            await receiver.sayingStart();
                         }
+                        await receiver.sayingChunk(textDelta);
                     }
                 }
                 else if (delta.type === 'thinking_delta') {
                     const thinkingDelta = delta.thinking ?? '';
                     if (thinkingDelta) {
-                        const pendingThinking = pendingVolcanoThinkingToolUseBlocks.get(blockIndex);
-                        if (pendingThinking !== undefined) {
-                            pendingVolcanoThinkingToolUseBlocks.set(blockIndex, `${pendingThinking}${thinkingDelta}`);
+                        if (sayingStarted) {
+                            log.error('ANTH stream ordering violation: received thinking_delta while saying stream still active', new Error('anthropic_stream_order_violation'));
+                            await receiver.sayingFinish();
+                            sayingStarted = false;
                         }
-                        else {
-                            const updated = await emitThinkingWithVolcanoToolUseQuirk({
-                                text: thinkingDelta,
-                                receiver,
-                                quirks,
-                                sayingStarted,
-                                thinkingStarted,
-                                genseq,
-                                blockIndex,
-                                idRegistry: volcanoToolCallIdRegistry,
-                            });
-                            sayingStarted = updated.sayingStarted;
-                            thinkingStarted = updated.thinkingStarted;
+                        if (!thinkingStarted) {
+                            thinkingStarted = true;
+                            await receiver.thinkingStart();
                         }
+                        await receiver.thinkingChunk(thinkingDelta);
                     }
                 }
                 else if (delta.type === 'citations_delta') {
@@ -2052,47 +1655,13 @@ async function consumeAnthropicStream(stream, receiver, options = {}) {
                             sayingStarted = false;
                         }
                         else {
-                            const argsJson = resolveToolUseArgumentsJson(activeToolUse, quirks);
+                            const argsJson = resolveToolUseArgumentsJson(activeToolUse);
                             await receiver.funcCall(activeToolUse.id, activeToolUse.name, argsJson);
                         }
                     }
                     activeToolUses.delete(blockIndex);
                 }
-                else if (activeContentBlock.type === 'text') {
-                    const pendingText = pendingVolcanoTextToolUseBlocks.get(blockIndex);
-                    if (pendingText !== undefined) {
-                        const updated = await emitTextWithVolcanoToolUseQuirk({
-                            text: pendingText,
-                            receiver,
-                            quirks,
-                            sayingStarted,
-                            thinkingStarted,
-                            genseq,
-                            blockIndex,
-                            idRegistry: volcanoToolCallIdRegistry,
-                        });
-                        sayingStarted = updated.sayingStarted;
-                        thinkingStarted = updated.thinkingStarted;
-                        pendingVolcanoTextToolUseBlocks.delete(blockIndex);
-                    }
-                }
                 else if (activeContentBlock.type === 'thinking') {
-                    const pendingThinking = pendingVolcanoThinkingToolUseBlocks.get(blockIndex);
-                    if (pendingThinking !== undefined) {
-                        const updated = await emitThinkingWithVolcanoToolUseQuirk({
-                            text: pendingThinking,
-                            receiver,
-                            quirks,
-                            sayingStarted,
-                            thinkingStarted,
-                            genseq,
-                            blockIndex,
-                            idRegistry: volcanoToolCallIdRegistry,
-                        });
-                        sayingStarted = updated.sayingStarted;
-                        thinkingStarted = updated.thinkingStarted;
-                        pendingVolcanoThinkingToolUseBlocks.delete(blockIndex);
-                    }
                     if (thinkingStarted) {
                         await receiver.thinkingFinish();
                         thinkingStarted = false;
@@ -2157,18 +1726,6 @@ async function consumeAnthropicStream(stream, receiver, options = {}) {
             }
             case 'message_stop': {
                 messageStopped = true;
-                const updated = await flushPendingVolcanoToolUseBlocks({
-                    textBlocks: pendingVolcanoTextToolUseBlocks,
-                    thinkingBlocks: pendingVolcanoThinkingToolUseBlocks,
-                    receiver,
-                    quirks,
-                    sayingStarted,
-                    thinkingStarted,
-                    genseq,
-                    idRegistry: volcanoToolCallIdRegistry,
-                });
-                sayingStarted = updated.sayingStarted;
-                thinkingStarted = updated.thinkingStarted;
                 activeContentBlocks.clear();
                 activeToolUses.clear();
                 if (thinkingStarted) {
@@ -2196,8 +1753,6 @@ async function consumeAnthropicStream(stream, receiver, options = {}) {
     if ((messageStarted && !messageStopped) ||
         activeContentBlocks.size > 0 ||
         activeToolUses.size > 0 ||
-        pendingVolcanoTextToolUseBlocks.size > 0 ||
-        pendingVolcanoThinkingToolUseBlocks.size > 0 ||
         thinkingStarted ||
         sayingStarted) {
         const detail = 'ANTH incomplete stream: provider event stream ended before a complete message lifecycle ' +
@@ -2325,9 +1880,7 @@ class AnthropicGen {
         return consumeAnthropicStream(stream, receiver, {
             abortSignal,
             forcedJsonToolName: forceJsonResponse ? ANTHROPIC_JSON_RESPONSE_TOOL_NAME : undefined,
-            quirks: resolveAnthropicStreamConsumeQuirks(providerConfig),
             genseq,
-            knownFunctionCallIds: requestContext.knownFunctionCallIds,
         });
     }
     async genMoreMessages(providerConfig, agent, systemPrompt, funcTools, requestContext, context, genseq, abortSignal) {
@@ -2403,7 +1956,7 @@ class AnthropicGen {
             totalTokens: promptTokens + completionTokens,
         };
         return {
-            messages: anthropicToChatMessages(response, genseq, forceJsonResponse ? ANTHROPIC_JSON_RESPONSE_TOOL_NAME : undefined, resolveAnthropicStreamConsumeQuirks(providerConfig), requestContext.knownFunctionCallIds),
+            messages: anthropicToChatMessages(response, genseq, forceJsonResponse ? ANTHROPIC_JSON_RESPONSE_TOOL_NAME : undefined),
             ...(outputs.length > 0 ? { outputs } : {}),
             usage,
             llmGenModel: returnedModel,

package/dist/llm/gen/openai-compatible.d.ts

@@ -13,16 +13,26 @@
 import type { ChatCompletion, ChatCompletionChunk, ChatCompletionMessageParam } from 'openai/resources/chat/completions';
 import type { Team } from '../../team';
 import type { FuncTool } from '../../tool';
-import type { ChatMessage, ProviderConfig } from '../client';
+import type { ChatMessage, ModelInfo, ProviderConfig } from '../client';
 import { type LlmBatchResult, type LlmFailureDisposition, type LlmGenerator, type LlmRequestContext, type LlmStreamReceiver, type LlmStreamResult } from '../gen';
 type OpenAiCompatibleChatExtraParams = {
     thinking?: boolean | Record<string, unknown>;
     reasoning_effort?: NonNullable<Team.ModelParams['openai-compatible']>['reasoning_effort'];
 };
+export declare function resolveOpenAiCompatibleToolChoice(funcTools: readonly FuncTool[], requestContext: LlmRequestContext, modelInfo?: ModelInfo): 'none' | 'auto' | 'required' | undefined;
 export declare function buildOpenAiCompatibleExtraParamsForTest(args: {
     agent: Team.Member;
     openAiParams: NonNullable<Team.ModelParams['openai-compatible']>;
 }): OpenAiCompatibleChatExtraParams;
+export declare function wrapOpenAiCompatibleRejectedRequestErrorForTest(args: {
+    error: unknown;
+    providerConfig: ProviderConfig;
+    agent: Team.Member;
+    requestContext: LlmRequestContext;
+    genseq: number;
+    requestKind: 'stream' | 'batch';
+    payload: unknown;
+}): Promise<unknown>;
 export declare function buildOpenAiCompatibleRequestMessagesWrapper(systemPrompt: string, context: ChatMessage[], requestContextOrOptions?: LlmRequestContext | {
     providerConfig?: ProviderConfig;
 }, optionsMaybe?: {