dominds 1.22.0 → 1.23.0

package/dist/llm/gen/openai-compatible.js

@@ -16,7 +16,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAiCompatibleGen = void 0;
+exports.resolveOpenAiCompatibleToolChoice = resolveOpenAiCompatibleToolChoice;
 exports.buildOpenAiCompatibleExtraParamsForTest = buildOpenAiCompatibleExtraParamsForTest;
+exports.wrapOpenAiCompatibleRejectedRequestErrorForTest = wrapOpenAiCompatibleRejectedRequestErrorForTest;
 exports.buildOpenAiCompatibleRequestMessagesWrapper = buildOpenAiCompatibleRequestMessagesWrapper;
 exports.consumeOpenAiCompatibleChatCompletionStreamForTest = consumeOpenAiCompatibleChatCompletionStreamForTest;
 exports.chatCompletionToChatMessagesForTest = chatCompletionToChatMessagesForTest;
@@ -28,6 +30,8 @@ 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 dominds_running_version_1 = require("../../server/dominds-running-version");
+const api_quirks_1 = require("../api-quirks");
 const gen_1 = require("../gen");
 const stop_reason_i18n_1 = require("../stop-reason-i18n");
 const artifacts_1 = require("./artifacts");
@@ -38,15 +42,60 @@ const tool_result_image_ingest_1 = require("./tool-result-image-ingest");
 const log = (0, log_1.createLogger)('llm/openai-compatible');
 const OPENAI_COMPAT_CAPTURE_SSE_ENV = 'DOMINDS_OPENAI_COMPAT_CAPTURE_SSE';
 const OPENAI_COMPAT_CAPTURE_DIR_ENV = 'DOMINDS_OPENAI_COMPAT_CAPTURE_DIR';
+const OPENAI_COMPAT_REJECTED_DIR_ENV = 'DOMINDS_OPENAI_COMPAT_REJECTED_DIR';
 const OPENAI_COMPATIBLE_MALFORMED_BATCH_TOOL_CALL_ERROR_CODE = 'OPENAI_COMPATIBLE_MALFORMED_BATCH_TOOL_CALL';
-function resolveOpenAiCompatibleToolChoice(funcTools, requestContext) {
+const OPENAI_COMPATIBLE_REJECTED_REQUEST_ERROR_CODE = 'OPENAI_COMPATIBLE_REJECTED_REQUEST';
+const KIMI_CODE_API_QUIRK = 'kimi-code';
+const KIMI_CODE_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
+const KIMI_CLI_CLOAK_API_QUIRK = 'kimi-cli-cloak';
+const KIMI_CLI_USER_AGENT = 'KimiCLI/1.41.0';
+const DISABLE_ASSISTANT_TOOL_CALL_REASONING_CONTENT_API_QUIRK = 'disable-assistant-tool-call-reasoning-content';
+const JSON_SCHEMA_COMBINATOR_KEYS = new Set([
+    'anyOf',
+    'oneOf',
+    'allOf',
+    'not',
+    'if',
+    'then',
+    'else',
+    '$ref',
+]);
+const JSON_SCHEMA_BRANCH_ARRAY_KEYS = ['anyOf', 'oneOf', 'allOf'];
+const JSON_SCHEMA_OBJECT_KEYS = new Set([
+    'properties',
+    'additionalProperties',
+    'patternProperties',
+    'propertyNames',
+    'required',
+    'minProperties',
+    'maxProperties',
+]);
+const JSON_SCHEMA_ARRAY_KEYS = new Set([
+    'items',
+    'prefixItems',
+    'minItems',
+    'maxItems',
+    'uniqueItems',
+    'contains',
+]);
+const JSON_SCHEMA_STRING_KEYS = new Set(['minLength', 'maxLength', 'pattern', 'format']);
+const JSON_SCHEMA_NUMERIC_KEYS = new Set([
+    'minimum',
+    'maximum',
+    'multipleOf',
+    'exclusiveMinimum',
+    'exclusiveMaximum',
+]);
+function resolveOpenAiCompatibleToolChoice(funcTools, requestContext, modelInfo) {
     const requirement = requestContext.toolUseRequirement ?? 'auto';
     if (funcTools.length === 0) {
         if (requirement === 'required') {
             throw new Error(`OpenAI-compatible request invariant violation: toolUseRequirement=required but no tools are available (dialog=${requestContext.dialogSelfId})`);
         }
-        return 'none';
+        return modelInfo?.supports_tool_choice === false ? undefined : 'none';
     }
+    if (modelInfo?.supports_tool_choice === false)
+        return undefined;
     if (requirement === 'none')
         return 'none';
     if (requirement === 'required')
@@ -56,6 +105,23 @@ function resolveOpenAiCompatibleToolChoice(funcTools, requestContext) {
 function resolveOpenAiCompatibleRequestTools(funcTools, requestContext) {
     return (requestContext.toolUseRequirement ?? 'auto') === 'none' ? [] : [...funcTools];
 }
+function resolveOpenAiCompatibleRequestModelInfo(providerConfig, agent, requestContext) {
+    const requestModelKey = requestContext.modelKey;
+    const modelKey = typeof requestModelKey === 'string' && requestModelKey.trim() !== ''
+        ? requestModelKey
+        : agent.model;
+    if (typeof modelKey !== 'string' || modelKey.trim() === '')
+        return undefined;
+    return providerConfig.models[modelKey];
+}
+function resolveOpenAiCompatibleParallelToolCalls(args) {
+    if (args.openAiParams.parallel_tool_calls !== undefined) {
+        return args.openAiParams.parallel_tool_calls;
+    }
+    if (isKimiCodeProvider(args.providerConfig))
+        return undefined;
+    return true;
+}
 function isOpenAiCompatibleSseCaptureEnabled() {
     const configured = process.env[OPENAI_COMPAT_CAPTURE_SSE_ENV]?.trim().toLowerCase();
     return configured === '1' || configured === 'true' || configured === 'yes' || configured === 'on';
@@ -66,12 +132,25 @@ function resolveOpenAiCompatibleCaptureDir() {
         return path_1.default.resolve(configured);
     return path_1.default.resolve(process.cwd(), '.dialogs', 'debug', 'openai-compatible-sse');
 }
+function resolveOpenAiCompatibleRejectedDir() {
+    const configured = process.env[OPENAI_COMPAT_REJECTED_DIR_ENV]?.trim();
+    if (configured && configured.length > 0)
+        return path_1.default.resolve(configured);
+    return path_1.default.resolve(process.cwd(), '.dialogs', 'debug', 'openai-compatible-rejected');
+}
 function sanitizeCapturePathPart(value) {
     const sanitized = value.replace(/[^a-zA-Z0-9_.-]+/g, '_').replace(/^_+|_+$/g, '');
     if (sanitized.length === 0)
         return 'unknown';
     return sanitized.slice(0, 96);
 }
+function formatRejectedCaptureFailureDetail(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    const compact = raw.replace(/\s+/g, ' ').trim();
+    if (compact.length === 0)
+        return 'unknown debug capture failure';
+    return compact.slice(0, 500);
+}
 function buildOpenAiCompatibleCaptureId(context) {
     const now = new Date().toISOString().replace(/[:.]/g, '-');
     const suffix = Math.random().toString(36).slice(2, 10);
@@ -84,6 +163,19 @@ function buildOpenAiCompatibleCaptureId(context) {
         suffix,
     ].join('__');
 }
+function buildOpenAiCompatibleRejectedCaptureId(context) {
+    const now = new Date().toISOString().replace(/[:.]/g, '-');
+    const suffix = Math.random().toString(36).slice(2, 10);
+    return [
+        now,
+        sanitizeCapturePathPart(context.providerKey ?? context.providerName),
+        sanitizeCapturePathPart(context.model),
+        sanitizeCapturePathPart(context.dialogSelfId),
+        `g${String(context.genseq)}`,
+        context.requestKind,
+        suffix,
+    ].join('__');
+}
 function redactHttpHeader(name, value) {
     const normalized = name.toLowerCase();
     if (normalized === 'authorization' ||
@@ -206,6 +298,52 @@ async function startOpenAiCompatibleCapture(context, input, init) {
     });
     return record;
 }
+async function writeOpenAiCompatibleRejectedCapture(args) {
+    const captureRoot = resolveOpenAiCompatibleRejectedDir();
+    const id = buildOpenAiCompatibleRejectedCaptureId(args.context);
+    const dir = path_1.default.join(captureRoot, id);
+    await promises_1.default.mkdir(dir, { recursive: true });
+    const record = {
+        id,
+        dir,
+        metaPath: path_1.default.join(dir, 'meta.json'),
+        requestPayloadPath: path_1.default.join(dir, 'request-payload.json'),
+    };
+    await writeCaptureJson(record.requestPayloadPath, args.payload);
+    await writeCaptureJson(record.metaPath, {
+        id,
+        capturedAt: new Date().toISOString(),
+        context: args.context,
+        request: {
+            payloadPath: record.requestPayloadPath,
+        },
+        error: {
+            name: args.error instanceof Error ? args.error.name : undefined,
+            message: args.context.upstreamMessage,
+            status: args.context.status,
+            code: args.context.code,
+        },
+    });
+    return record;
+}
+async function tryWriteOpenAiCompatibleRejectedCapture(args) {
+    try {
+        return { kind: 'captured', record: await writeOpenAiCompatibleRejectedCapture(args) };
+    }
+    catch (error) {
+        const detail = formatRejectedCaptureFailureDetail(error);
+        log.error('OPENAI-COMPATIBLE rejected request debug capture failed', error, {
+            providerKey: args.context.providerKey,
+            providerName: args.context.providerName,
+            model: args.context.model,
+            rootId: args.context.dialogRootId,
+            selfId: args.context.dialogSelfId,
+            genseq: args.context.genseq,
+            requestKind: args.context.requestKind,
+        });
+        return { kind: 'capture_failed', detail };
+    }
+}
 function parseSseFrameData(frame) {
     const lines = frame.split(/\r?\n/);
     const eventLine = lines.find((line) => line.startsWith('event:'));
@@ -438,6 +576,16 @@ function createOpenAiCompatibleClient(args) {
         apiKey: args.apiKey,
         baseURL: args.providerConfig.baseUrl,
     };
+    if (isKimiCliCloakProvider(args.providerConfig)) {
+        options.defaultHeaders = {
+            'User-Agent': KIMI_CLI_USER_AGENT,
+        };
+    }
+    else if (isKimiCodeProvider(args.providerConfig)) {
+        options.defaultHeaders = {
+            'User-Agent': `Dominds/${dominds_running_version_1.DOMINDS_RUNNING_VERSION || 'dev'}`,
+        };
+    }
     if (args.providerConfig.apiType === 'openai-compatible' &&
         isOpenAiCompatibleSseCaptureEnabled()) {
         options.fetch = buildOpenAiCompatibleCaptureFetch({
@@ -466,6 +614,129 @@ function limitOpenAiCompatibleToolOutputText(text, msg, limitChars) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isKimiCodeProvider(providerConfig) {
+    return (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(KIMI_CODE_API_QUIRK);
+}
+function isKimiCliCloakProvider(providerConfig) {
+    return (0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(KIMI_CLI_CLOAK_API_QUIRK);
+}
+function isKimiCodeReasoningEffort(value) {
+    return typeof value === 'string' && KIMI_CODE_REASONING_EFFORTS.has(value);
+}
+function isKimiCodeThinkingMode(value) {
+    return (value === 'auto' || value === 'off' || value === 'low' || value === 'medium' || value === 'high');
+}
+function cloneJsonSchemaValue(value) {
+    if (Array.isArray(value))
+        return value.map((item) => cloneJsonSchemaValue(item));
+    if (isRecord(value)) {
+        const out = {};
+        for (const [key, child] of Object.entries(value)) {
+            out[key] = cloneJsonSchemaValue(child);
+        }
+        return out;
+    }
+    return value;
+}
+function hasAnyOwnKey(value, keys) {
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(value, key))
+            return true;
+    }
+    return false;
+}
+function inferJsonSchemaTypeFromValues(values) {
+    const inferred = new Set();
+    for (const value of values) {
+        if (typeof value === 'boolean')
+            inferred.add('boolean');
+        else if (typeof value === 'number')
+            inferred.add(Number.isInteger(value) ? 'integer' : 'number');
+        else if (typeof value === 'string')
+            inferred.add('string');
+        else if (value === null)
+            inferred.add('null');
+        else if (Array.isArray(value))
+            inferred.add('array');
+        else if (isRecord(value))
+            inferred.add('object');
+        else
+            return 'string';
+    }
+    if (inferred.size === 1) {
+        const only = [...inferred][0];
+        return only ?? 'string';
+    }
+    if (inferred.size === 2 && inferred.has('integer') && inferred.has('number')) {
+        return 'number';
+    }
+    return 'string';
+}
+function inferJsonSchemaTypeFromStructure(value) {
+    if (hasAnyOwnKey(value, JSON_SCHEMA_OBJECT_KEYS))
+        return 'object';
+    if (hasAnyOwnKey(value, JSON_SCHEMA_ARRAY_KEYS))
+        return 'array';
+    if (hasAnyOwnKey(value, JSON_SCHEMA_STRING_KEYS))
+        return 'string';
+    if (hasAnyOwnKey(value, JSON_SCHEMA_NUMERIC_KEYS))
+        return 'number';
+    return 'string';
+}
+function normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(value) {
+    if (!isRecord(value))
+        return;
+    if (!Object.prototype.hasOwnProperty.call(value, 'type') &&
+        !hasAnyOwnKey(value, JSON_SCHEMA_COMBINATOR_KEYS)) {
+        const enumValues = value.enum;
+        if (Array.isArray(enumValues) && enumValues.length > 0) {
+            value.type = inferJsonSchemaTypeFromValues(enumValues);
+        }
+        else if (Object.prototype.hasOwnProperty.call(value, 'const')) {
+            value.type = inferJsonSchemaTypeFromValues([value.const]);
+        }
+        else {
+            value.type = inferJsonSchemaTypeFromStructure(value);
+        }
+    }
+    normalizeOpenAiCompatibleKimiCodeJsonSchemaContainer(value);
+}
+function normalizeOpenAiCompatibleKimiCodeJsonSchemaContainer(value) {
+    if (!isRecord(value))
+        return;
+    const properties = value.properties;
+    if (isRecord(properties)) {
+        for (const property of Object.values(properties)) {
+            normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(property);
+        }
+    }
+    const items = value.items;
+    if (isRecord(items)) {
+        normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(items);
+    }
+    else if (Array.isArray(items)) {
+        for (const item of items) {
+            normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(item);
+        }
+    }
+    const additionalProperties = value.additionalProperties;
+    if (isRecord(additionalProperties)) {
+        normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(additionalProperties);
+    }
+    for (const key of JSON_SCHEMA_BRANCH_ARRAY_KEYS) {
+        const branches = value[key];
+        if (!Array.isArray(branches))
+            continue;
+        for (const branch of branches) {
+            normalizeOpenAiCompatibleKimiCodeJsonSchemaProperty(branch);
+        }
+    }
+}
+function normalizeOpenAiCompatibleKimiCodeJsonSchema(value) {
+    const cloned = cloneJsonSchemaValue(value);
+    normalizeOpenAiCompatibleKimiCodeJsonSchemaContainer(cloned);
+    return cloned;
+}
 function isLlmRequestContext(value) {
     return (isRecord(value) &&
         typeof value.dialogSelfId === 'string' &&
@@ -531,8 +802,14 @@ function buildReasoningPayloadFromText(text) {
     };
 }
 function buildOpenAiCompatibleExtraParams(args) {
+    if (args.providerConfig !== undefined && isKimiCodeProvider(args.providerConfig)) {
+        return buildKimiCodeOpenAiCompatibleExtraParams(args);
+    }
     const model = args.agent.model ?? '';
     const thinking = args.openAiParams.thinking;
+    if (typeof thinking === 'string') {
+        throw new Error(`Invalid openai-compatible model_params: string thinking mode '${thinking}' requires apiQuirks: ${KIMI_CODE_API_QUIRK} for model '${model}'.`);
+    }
     const reasoningEffort = args.openAiParams.reasoning_effort;
     const thinkingDisabled = thinking === false || (isRecord(thinking) && thinking.type === 'disabled');
     if (thinkingDisabled && reasoningEffort !== undefined) {
@@ -546,9 +823,119 @@ function buildOpenAiCompatibleExtraParams(args) {
         ...(reasoningEffort !== undefined ? { reasoning_effort: reasoningEffort } : {}),
     };
 }
+function buildKimiCodeOpenAiCompatibleExtraParams(args) {
+    const model = args.agent.model ?? '';
+    const thinking = args.openAiParams.thinking;
+    const reasoningEffort = args.openAiParams.reasoning_effort;
+    const promptCacheKey = args.requestContext?.promptCacheKey?.trim();
+    if (reasoningEffort !== undefined && !isKimiCodeReasoningEffort(reasoningEffort)) {
+        throw new Error(`Invalid Kimi Code openai-compatible model_params: reasoning_effort=${reasoningEffort} is not supported for model '${model}'; expected low|medium|high.`);
+    }
+    const base = promptCacheKey !== undefined && promptCacheKey.length > 0
+        ? { prompt_cache_key: promptCacheKey }
+        : {};
+    if (thinking === undefined) {
+        return {
+            ...base,
+            ...(reasoningEffort !== undefined
+                ? { thinking: { type: 'enabled' }, reasoning_effort: reasoningEffort }
+                : {}),
+        };
+    }
+    if (thinking === 'auto' || thinking === 'off') {
+        if (reasoningEffort !== undefined) {
+            throw new Error(`Invalid Kimi Code openai-compatible model_params: thinking=${thinking} conflicts with reasoning_effort=${reasoningEffort} for model '${model}'.`);
+        }
+        if (thinking === 'auto')
+            return base;
+        return {
+            ...base,
+            thinking: { type: 'disabled' },
+        };
+    }
+    if (isKimiCodeThinkingMode(thinking)) {
+        if (reasoningEffort !== undefined && reasoningEffort !== thinking) {
+            throw new Error(`Invalid Kimi Code openai-compatible model_params: thinking=${thinking} conflicts with reasoning_effort=${reasoningEffort} for model '${model}'.`);
+        }
+        return {
+            ...base,
+            thinking: { type: 'enabled' },
+            reasoning_effort: thinking,
+        };
+    }
+    const thinkingDisabled = thinking === false || (isRecord(thinking) && thinking.type === 'disabled');
+    if (thinkingDisabled && reasoningEffort !== undefined) {
+        throw new Error(`Invalid Kimi Code openai-compatible model_params: thinking disabled conflicts with reasoning_effort=${reasoningEffort} for model '${model}'.`);
+    }
+    const thinkingPayload = typeof thinking === 'boolean' ? { type: thinking ? 'enabled' : 'disabled' } : thinking;
+    return {
+        ...base,
+        ...(thinkingPayload !== undefined ? { thinking: thinkingPayload } : {}),
+        ...(reasoningEffort !== undefined ? { reasoning_effort: reasoningEffort } : {}),
+    };
+}
+async function wrapOpenAiCompatibleRejectedRequestError(args) {
+    const status = (0, failure_classifier_1.readErrorStatus)(args.error);
+    if (status !== 400)
+        return args.error;
+    const providerKey = args.requestContext.providerKey ?? args.providerConfig.name;
+    const modelKey = args.requestContext.modelKey ?? args.agent.model ?? 'unknown';
+    const code = (0, failure_classifier_1.readErrorCode)(args.error);
+    const upstreamMessage = args.error instanceof Error ? args.error.message : String(args.error);
+    const captureContext = {
+        providerKey,
+        providerName: args.providerConfig.name.trim().length > 0 ? args.providerConfig.name : providerKey,
+        model: modelKey,
+        dialogRootId: args.requestContext.dialogRootId,
+        dialogSelfId: args.requestContext.dialogSelfId,
+        requestKind: args.requestKind,
+        genseq: args.genseq,
+        status,
+        ...(code !== undefined && { code }),
+        upstreamMessage,
+    };
+    const capture = await tryWriteOpenAiCompatibleRejectedCapture({
+        context: captureContext,
+        payload: args.payload,
+        error: args.error,
+    });
+    const captureMessageLines = capture.kind === 'captured'
+        ? [
+            `debugPath=${capture.record.dir}`,
+            `requestPayloadPath=${capture.record.requestPayloadPath}`,
+        ]
+        : [`debugCaptureError=${capture.detail}`];
+    const message = [
+        `OPENAI-compatible provider rejected ${args.requestKind} request with HTTP 400.`,
+        `provider=${providerKey}`,
+        `model=${modelKey}`,
+        `rootId=${args.requestContext.dialogRootId}`,
+        `selfId=${args.requestContext.dialogSelfId}`,
+        `genseq=${String(args.genseq)}`,
+        `upstream=${upstreamMessage}`,
+        ...captureMessageLines,
+    ].join('\n');
+    const wrapped = new Error(message);
+    wrapped.name = 'OpenAiCompatibleRejectedRequestError';
+    wrapped.cause = args.error;
+    wrapped.status = status;
+    wrapped.statusCode = status;
+    wrapped.code = code ?? OPENAI_COMPATIBLE_REJECTED_REQUEST_ERROR_CODE;
+    if (capture.kind === 'captured') {
+        wrapped.debugPath = capture.record.dir;
+        wrapped.requestPayloadPath = capture.record.requestPayloadPath;
+    }
+    else {
+        wrapped.debugCaptureError = capture.detail;
+    }
+    return wrapped;
+}
 function buildOpenAiCompatibleExtraParamsForTest(args) {
     return buildOpenAiCompatibleExtraParams(args);
 }
+async function wrapOpenAiCompatibleRejectedRequestErrorForTest(args) {
+    return await wrapOpenAiCompatibleRejectedRequestError(args);
+}
 function extractThinkingReasoningText(msg) {
     const fromSummary = msg.reasoning?.summary.map((part) => part.text).join('') ?? '';
     const fromContent = msg.reasoning?.content?.map((part) => part.text).join('') ?? '';
@@ -573,10 +960,18 @@ function attachReasoningContent(message, reasoningContent) {
         reasoning_content: reasoningContent,
     };
 }
-function funcToolToChatCompletionTool(funcTool) {
+function shouldAttachReasoningContentToAssistantToolCalls(providerConfig) {
+    if (providerConfig === undefined)
+        return true;
+    return !(0, api_quirks_1.normalizeProviderApiQuirks)(providerConfig).has(DISABLE_ASSISTANT_TOOL_CALL_REASONING_CONTENT_API_QUIRK);
+}
+function funcToolToChatCompletionTool(funcTool, providerConfig) {
     // MCP schemas are passed through to providers. Chat Completions expects a narrower JSON schema
     // shape; runtime compatibility is handled by provider validation + the driver stop policy.
-    const parameters = funcTool.parameters;
+    const rawParameters = funcTool.parameters;
+    const parameters = (providerConfig !== undefined && isKimiCodeProvider(providerConfig)
+        ? normalizeOpenAiCompatibleKimiCodeJsonSchema(rawParameters)
+        : rawParameters);
     const description = (0, i18n_text_1.getTextForLanguage)({ i18n: funcTool.descriptionI18n, fallback: funcTool.description }, (0, work_language_1.getWorkLanguage)());
     return {
         type: 'function',
@@ -602,7 +997,6 @@ function chatMessageToChatCompletionMessage(msg) {
         case 'func_call_msg':
             return {
                 role: 'assistant',
-                content: null,
                 tool_calls: [
                     {
                         id: msg.id,
@@ -956,7 +1350,9 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
     const input = [];
     const toolResultMaxChars = (0, tool_output_limit_1.resolveProviderToolResultMaxChars)(options?.providerConfig);
     const allowedImageKeys = (0, tool_result_image_ingest_1.selectLatestImagesWithinBudget)(normalized, tool_result_image_ingest_1.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES);
+    const attachToolCallReasoning = shouldAttachReasoningContentToAssistantToolCalls(options?.providerConfig);
     let pendingReasoningContent;
+    let assistantTurnReasoningContent;
     const takePendingReasoningContent = () => {
         const current = pendingReasoningContent;
         pendingReasoningContent = undefined;
@@ -970,10 +1366,16 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
                 ? `${pendingReasoningContent}\n${value}`
                 : value;
     };
+    const noteAssistantTurnReasoningContent = (value) => {
+        if (!value)
+            return;
+        assistantTurnReasoningContent = value;
+    };
     const flushPendingReasoningAsAssistantMessage = () => {
         const reasoningContent = takePendingReasoningContent();
         if (!reasoningContent)
             return;
+        noteAssistantTurnReasoningContent(reasoningContent);
         input.push(attachReasoningContent({
             role: 'assistant',
             content: '',
@@ -989,7 +1391,12 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
         }
         if (msg.type === 'func_call_msg') {
             const mapped = chatMessageToChatCompletionMessage(msg);
-            input.push(attachReasoningContent(mapped, takePendingReasoningContent()));
+            const pending = takePendingReasoningContent();
+            noteAssistantTurnReasoningContent(pending);
+            const reasoningContent = attachToolCallReasoning
+                ? (pending ?? assistantTurnReasoningContent)
+                : undefined;
+            input.push(attachReasoningContent(mapped, reasoningContent));
             continue;
         }
         if (msg.type === 'func_result_msg') {
@@ -997,6 +1404,12 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
             input.push(...(await funcResultToChatCompletionMessages(msg, toolResultMaxChars, requestContext, options?.providerConfig, allowedImageKeys, options?.onToolResultImageIngest)));
             continue;
         }
+        if (msg.type === 'environment_msg' ||
+            msg.type === 'prompting_msg' ||
+            msg.type === 'tellask_result_msg' ||
+            msg.type === 'tellask_carryover_msg') {
+            assistantTurnReasoningContent = undefined;
+        }
         const mapped = (msg.type === 'prompting_msg' ||
             msg.type === 'tellask_result_msg' ||
             msg.type === 'tellask_carryover_msg') &&
@@ -1004,7 +1417,9 @@ async function buildChatCompletionMessages(systemPrompt, context, requestContext
             msg.contentItems.length > 0
             ? await userLikeMessageToChatCompletionMessageWithImages(msg, requestContext, options?.providerConfig, allowedImageKeys, options?.onUserImageIngest)
             : chatMessageToChatCompletionMessage(msg);
-        input.push(attachReasoningContent(mapped, takePendingReasoningContent()));
+        const reasoningContent = takePendingReasoningContent();
+        noteAssistantTurnReasoningContent(reasoningContent);
+        input.push(attachReasoningContent(mapped, reasoningContent));
     }
     flushPendingReasoningAsAssistantMessage();
     return mergeAdjacentMessages(input);
@@ -1360,12 +1775,19 @@ class OpenAiCompatibleGen {
             onUserImageIngest: receiver.userImageIngest,
         });
         const openAiParams = agent.model_params?.['openai-compatible'] || {};
-        const parallelToolCalls = openAiParams.parallel_tool_calls ?? true;
+        const parallelToolCalls = resolveOpenAiCompatibleParallelToolCalls({
+            providerConfig,
+            openAiParams,
+        });
         const responseFormat = buildChatCompletionResponseFormat(openAiParams);
         const requestTools = resolveOpenAiCompatibleRequestTools(funcTools, requestContext);
+        const modelInfo = resolveOpenAiCompatibleRequestModelInfo(providerConfig, agent, requestContext);
+        const toolChoice = resolveOpenAiCompatibleToolChoice(requestTools, requestContext, modelInfo);
         const openAiCompatibleExtraParams = buildOpenAiCompatibleExtraParams({
+            providerConfig,
             agent,
             openAiParams,
+            requestContext,
         });
         const payload = {
             model: agent.model,
@@ -1380,9 +1802,11 @@ class OpenAiCompatibleGen {
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...openAiCompatibleExtraParams,
             ...(responseFormat !== undefined && { response_format: responseFormat }),
-            ...(requestTools.length > 0 ? { tools: requestTools.map(funcToolToChatCompletionTool) } : {}),
-            tool_choice: resolveOpenAiCompatibleToolChoice(requestTools, requestContext),
-            parallel_tool_calls: parallelToolCalls,
+            ...(requestTools.length > 0
+                ? { tools: requestTools.map((tool) => funcToolToChatCompletionTool(tool, providerConfig)) }
+                : {}),
+            ...(toolChoice !== undefined && { tool_choice: toolChoice }),
+            ...(parallelToolCalls !== undefined && { parallel_tool_calls: parallelToolCalls }),
         };
         try {
             const stream = await client.chat.completions.create(payload, {
@@ -1396,8 +1820,23 @@ class OpenAiCompatibleGen {
             });
         }
         catch (error) {
-            log.warn('OPENAI-COMPATIBLE streaming error', error);
-            throw error;
+            const enrichedError = await wrapOpenAiCompatibleRejectedRequestError({
+                error,
+                providerConfig,
+                agent,
+                requestContext,
+                genseq,
+                requestKind: 'stream',
+                payload,
+            });
+            log.warn('OPENAI-COMPATIBLE streaming error', enrichedError, {
+                providerKey: requestContext.providerKey ?? providerConfig.name,
+                model: requestContext.modelKey ?? agent.model,
+                rootId: requestContext.dialogRootId,
+                selfId: requestContext.dialogSelfId,
+                genseq,
+            });
+            throw enrichedError;
         }
     }
     async genMoreMessages(providerConfig, agent, systemPrompt, funcTools, requestContext, context, genseq, abortSignal) {
@@ -1425,12 +1864,19 @@ class OpenAiCompatibleGen {
             },
         });
         const openAiParams = agent.model_params?.['openai-compatible'] || {};
-        const parallelToolCalls = openAiParams.parallel_tool_calls ?? true;
+        const parallelToolCalls = resolveOpenAiCompatibleParallelToolCalls({
+            providerConfig,
+            openAiParams,
+        });
         const responseFormat = buildChatCompletionResponseFormat(openAiParams);
         const requestTools = resolveOpenAiCompatibleRequestTools(funcTools, requestContext);
+        const modelInfo = resolveOpenAiCompatibleRequestModelInfo(providerConfig, agent, requestContext);
+        const toolChoice = resolveOpenAiCompatibleToolChoice(requestTools, requestContext, modelInfo);
         const openAiCompatibleExtraParams = buildOpenAiCompatibleExtraParams({
+            providerConfig,
             agent,
             openAiParams,
+            requestContext,
         });
         const payload = {
             model: agent.model,
@@ -1443,9 +1889,11 @@ class OpenAiCompatibleGen {
             ...(openAiParams.top_p !== undefined && { top_p: openAiParams.top_p }),
             ...openAiCompatibleExtraParams,
             ...(responseFormat !== undefined && { response_format: responseFormat }),
-            ...(requestTools.length > 0 && { tools: requestTools.map(funcToolToChatCompletionTool) }),
-            tool_choice: resolveOpenAiCompatibleToolChoice(requestTools, requestContext),
-            parallel_tool_calls: parallelToolCalls,
+            ...(requestTools.length > 0 && {
+                tools: requestTools.map((tool) => funcToolToChatCompletionTool(tool, providerConfig)),
+            }),
+            ...(toolChoice !== undefined && { tool_choice: toolChoice }),
+            ...(parallelToolCalls !== undefined && { parallel_tool_calls: parallelToolCalls }),
         };
         try {
             const response = await client.chat.completions.create(payload, {
@@ -1466,8 +1914,23 @@ class OpenAiCompatibleGen {
             };
         }
         catch (error) {
-            log.warn('OPENAI-COMPATIBLE batch error', error);
-            throw error;
+            const enrichedError = await wrapOpenAiCompatibleRejectedRequestError({
+                error,
+                providerConfig,
+                agent,
+                requestContext,
+                genseq,
+                requestKind: 'batch',
+                payload,
+            });
+            log.warn('OPENAI-COMPATIBLE batch error', enrichedError, {
+                providerKey: requestContext.providerKey ?? providerConfig.name,
+                model: requestContext.modelKey ?? agent.model,
+                rootId: requestContext.dialogRootId,
+                selfId: requestContext.dialogSelfId,
+                genseq,
+            });
+            throw enrichedError;
         }
     }
 }