dominds 1.22.0 → 1.22.1

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;
@@ -38,15 +40,19 @@ 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';
+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 +62,15 @@ 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 isOpenAiCompatibleSseCaptureEnabled() {
     const configured = process.env[OPENAI_COMPAT_CAPTURE_SSE_ENV]?.trim().toLowerCase();
     return configured === '1' || configured === 'true' || configured === 'yes' || configured === 'on';
@@ -66,12 +81,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 +112,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 +247,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:'));
@@ -546,9 +633,68 @@ function buildOpenAiCompatibleExtraParams(args) {
         ...(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('') ?? '';
@@ -1363,6 +1509,8 @@ class OpenAiCompatibleGen {
         const parallelToolCalls = openAiParams.parallel_tool_calls ?? true;
         const responseFormat = buildChatCompletionResponseFormat(openAiParams);
         const requestTools = resolveOpenAiCompatibleRequestTools(funcTools, requestContext);
+        const modelInfo = resolveOpenAiCompatibleRequestModelInfo(providerConfig, agent, requestContext);
+        const toolChoice = resolveOpenAiCompatibleToolChoice(requestTools, requestContext, modelInfo);
         const openAiCompatibleExtraParams = buildOpenAiCompatibleExtraParams({
             agent,
             openAiParams,
@@ -1381,7 +1529,7 @@ class OpenAiCompatibleGen {
             ...openAiCompatibleExtraParams,
             ...(responseFormat !== undefined && { response_format: responseFormat }),
             ...(requestTools.length > 0 ? { tools: requestTools.map(funcToolToChatCompletionTool) } : {}),
-            tool_choice: resolveOpenAiCompatibleToolChoice(requestTools, requestContext),
+            ...(toolChoice !== undefined && { tool_choice: toolChoice }),
             parallel_tool_calls: parallelToolCalls,
         };
         try {
@@ -1396,8 +1544,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) {
@@ -1428,6 +1591,8 @@ class OpenAiCompatibleGen {
         const parallelToolCalls = openAiParams.parallel_tool_calls ?? true;
         const responseFormat = buildChatCompletionResponseFormat(openAiParams);
         const requestTools = resolveOpenAiCompatibleRequestTools(funcTools, requestContext);
+        const modelInfo = resolveOpenAiCompatibleRequestModelInfo(providerConfig, agent, requestContext);
+        const toolChoice = resolveOpenAiCompatibleToolChoice(requestTools, requestContext, modelInfo);
         const openAiCompatibleExtraParams = buildOpenAiCompatibleExtraParams({
             agent,
             openAiParams,
@@ -1444,7 +1609,7 @@ class OpenAiCompatibleGen {
             ...openAiCompatibleExtraParams,
             ...(responseFormat !== undefined && { response_format: responseFormat }),
             ...(requestTools.length > 0 && { tools: requestTools.map(funcToolToChatCompletionTool) }),
-            tool_choice: resolveOpenAiCompatibleToolChoice(requestTools, requestContext),
+            ...(toolChoice !== undefined && { tool_choice: toolChoice }),
             parallel_tool_calls: parallelToolCalls,
         };
         try {
@@ -1466,8 +1631,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;
         }
     }
 }

package/dist/llm/gen.d.ts

@@ -56,7 +56,6 @@ export interface LlmRequestContext {
     modelKey?: string;
     promptCacheKey?: string;
     toolUseRequirement?: 'none' | 'auto' | 'required';
-    knownFunctionCallIds?: ReadonlySet<string>;
 }
 export type ToolResultImageIngest = {
     toolCallId: string;
@@ -146,7 +145,10 @@ export interface LlmStreamReceiver {
     sayingStart: () => Promise<void>;
     sayingChunk: (chunk: string) => Promise<void>;
     sayingFinish: () => Promise<void>;
-    funcCall: (callId: string, name: string, args: string) => Promise<void>;
+    funcCall: (callId: string, name: string, args: string, ids?: {
+        rawCallId?: string;
+        effectiveCallId?: string;
+    }) => Promise<void>;
     webSearchCall?: (call: LlmWebSearchCall) => Promise<void>;
     nativeToolCall?: (call: OpenAiResponsesNativeToolCall) => Promise<void>;
     toolResultImageIngest?: (ingest: ToolResultImageIngest) => Promise<void>;