@midscene/core 1.12.6-beta-20260910093036.0 → 1.12.6

package/dist/es/ai-model/service-caller/call.mjs

@@ -0,0 +1,56 @@
+import { getDebug } from "@midscene/shared/logger";
+import { assert, uuid } from "@midscene/shared/utils";
+import { chat } from "./chat-completion/call.mjs";
+import { callCodex } from "./codex/call-codex.mjs";
+import { isCodexAppServerProvider } from "./codex/codex-app-server.mjs";
+import { isModelCallRecordingEnabled, recordModelCallEvent } from "./model-call-recorder.mjs";
+import { buildUsageInfo, nextInternalCallId } from "./utils.mjs";
+async function callAI(messages, modelRuntime, options) {
+    const isStreaming = options?.stream === true;
+    if (isStreaming) assert('function' == typeof options?.onChunk, 'onChunk is required when stream is true');
+    const executionId = modelRuntime.executionId ?? `unscoped-${uuid()}`;
+    const internalCallId = nextInternalCallId();
+    const { config: modelConfig } = modelRuntime;
+    const recordEvent = isModelCallRecordingEnabled() ? (event)=>{
+        recordModelCallEvent({
+            executionId,
+            callId: internalCallId,
+            semanticRetryAttempt: options?.semanticRetryAttempt,
+            slot: modelConfig.slot,
+            intent: modelConfig.intent,
+            modelFamily: modelConfig.modelFamily,
+            ...event
+        });
+    } : void 0;
+    const context = {
+        messages,
+        modelRuntime,
+        options,
+        executionId,
+        recordEvent
+    };
+    const result = await (isCodexAppServerProvider(modelConfig.openaiBaseURL) ? callCodex(context) : chat(context));
+    const { rawUsage, timeCost, requestId, responseModelName, ...response } = result;
+    const usage = buildUsageInfo({
+        usageData: rawUsage,
+        timeCost,
+        requestId,
+        responseModelName,
+        modelName: modelConfig.modelName,
+        modelDescription: modelConfig.modelDescription,
+        slot: modelConfig.slot,
+        internalCallId
+    });
+    const debugProfileStats = getDebug('ai:profile:stats');
+    const debugProfileDetail = getDebug('ai:profile:detail');
+    debugProfileStats(`model, ${modelConfig.modelName}, mode, ${modelConfig.modelFamily || 'default'}, streaming, ${response.isStreamed}, prompt-tokens, ${usage?.prompt_tokens ?? ''}, completion-tokens, ${usage?.completion_tokens ?? ''}, total-tokens, ${usage?.total_tokens ?? ''}, cached-input, ${usage?.cached_input ?? ''}, cost-ms, ${timeCost ?? ''}, requestId, ${requestId ?? ''}, slot, ${modelConfig.slot}, configured-temperature, ${modelConfig.temperature ?? ''}`);
+    debugProfileDetail(`model usage detail: ${JSON.stringify(usage)}`);
+    if (usage && modelRuntime.onUsage) modelRuntime.onUsage(usage);
+    return {
+        ...response,
+        usage
+    };
+}
+export { callAI };
+
+//# sourceMappingURL=call.mjs.map

package/dist/es/ai-model/service-caller/call.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/service-caller/call.mjs","sources":["../../../../src/ai-model/service-caller/call.ts"],"sourcesContent":["import { getDebug } from '@midscene/shared/logger';\nimport { assert, uuid } from '@midscene/shared/utils';\nimport type { ChatCompletionMessageParam } from 'openai/resources/index';\nimport type { ModelRuntime } from '../models';\nimport { chat } from './chat-completion/call';\nimport { callCodex } from './codex/call-codex';\nimport { isCodexAppServerProvider } from './codex/codex-app-server';\nimport {\n  isModelCallRecordingEnabled,\n  recordModelCallEvent,\n} from './model-call-recorder';\nimport type { AICallResult, CallAIOptions, ModelCallContext } from './types';\nimport { buildUsageInfo, nextInternalCallId } from './utils';\n\nexport async function callAI(\n  messages: ChatCompletionMessageParam[],\n  modelRuntime: ModelRuntime,\n  options?: CallAIOptions,\n): Promise<AICallResult> {\n  const isStreaming = options?.stream === true;\n  if (isStreaming) {\n    assert(\n      typeof options?.onChunk === 'function',\n      'onChunk is required when stream is true',\n    );\n  }\n\n  // Low-level callers without a TaskRunner still need a stable ID for the\n  // lifetime of this model call (including its network retries).\n  const executionId = modelRuntime.executionId ?? `unscoped-${uuid()}`;\n\n  // Stable internal ID for this call, used by the agent to deduplicate usage\n  // across the onUsage callback and the task-dump-based collectUsageMetrics()\n  // path when the provider does not return a request_id.\n  const internalCallId = nextInternalCallId();\n\n  const { config: modelConfig } = modelRuntime;\n\n  const recordEvent = isModelCallRecordingEnabled()\n    ? (event: Record<string, unknown>) => {\n        void recordModelCallEvent({\n          executionId,\n          callId: internalCallId,\n          semanticRetryAttempt: options?.semanticRetryAttempt,\n          slot: modelConfig.slot,\n          intent: modelConfig.intent,\n          modelFamily: modelConfig.modelFamily,\n          ...event,\n        });\n      }\n    : undefined;\n\n  const context: ModelCallContext = {\n    messages,\n    modelRuntime,\n    options,\n    executionId,\n    recordEvent,\n  };\n\n  const result = await (isCodexAppServerProvider(modelConfig.openaiBaseURL)\n    ? callCodex(context)\n    : chat(context));\n\n  const { rawUsage, timeCost, requestId, responseModelName, ...response } =\n    result;\n\n  const usage = buildUsageInfo({\n    usageData: rawUsage,\n    timeCost,\n    requestId,\n    responseModelName,\n    modelName: modelConfig.modelName,\n    modelDescription: modelConfig.modelDescription,\n    slot: modelConfig.slot,\n    internalCallId,\n  });\n\n  const debugProfileStats = getDebug('ai:profile:stats');\n  const debugProfileDetail = getDebug('ai:profile:detail');\n  debugProfileStats(\n    `model, ${modelConfig.modelName}, mode, ${modelConfig.modelFamily || 'default'}, streaming, ${response.isStreamed}, prompt-tokens, ${usage?.prompt_tokens ?? ''}, completion-tokens, ${usage?.completion_tokens ?? ''}, total-tokens, ${usage?.total_tokens ?? ''}, cached-input, ${usage?.cached_input ?? ''}, cost-ms, ${timeCost ?? ''}, requestId, ${requestId ?? ''}, slot, ${modelConfig.slot}, configured-temperature, ${modelConfig.temperature ?? ''}`,\n  );\n  debugProfileDetail(`model usage detail: ${JSON.stringify(usage)}`);\n\n  if (usage && modelRuntime.onUsage) {\n    modelRuntime.onUsage(usage);\n  }\n  return { ...response, usage };\n}\n"],"names":["callAI","messages","modelRuntime","options","isStreaming","assert","executionId","uuid","internalCallId","nextInternalCallId","modelConfig","recordEvent","isModelCallRecordingEnabled","event","recordModelCallEvent","undefined","context","result","isCodexAppServerProvider","callCodex","chat","rawUsage","timeCost","requestId","responseModelName","response","usage","buildUsageInfo","debugProfileStats","getDebug","debugProfileDetail","JSON"],"mappings":";;;;;;;AAcO,eAAeA,OACpBC,QAAsC,EACtCC,YAA0B,EAC1BC,OAAuB;IAEvB,MAAMC,cAAcD,SAAS,WAAW;IACxC,IAAIC,aACFC,OACE,AAA4B,cAA5B,OAAOF,SAAS,SAChB;IAMJ,MAAMG,cAAcJ,aAAa,WAAW,IAAI,CAAC,SAAS,EAAEK,QAAQ;IAKpE,MAAMC,iBAAiBC;IAEvB,MAAM,EAAE,QAAQC,WAAW,EAAE,GAAGR;IAEhC,MAAMS,cAAcC,gCAChB,CAACC;QACMC,qBAAqB;YACxBR;YACA,QAAQE;YACR,sBAAsBL,SAAS;YAC/B,MAAMO,YAAY,IAAI;YACtB,QAAQA,YAAY,MAAM;YAC1B,aAAaA,YAAY,WAAW;YACpC,GAAGG,KAAK;QACV;IACF,IACAE;IAEJ,MAAMC,UAA4B;QAChCf;QACAC;QACAC;QACAG;QACAK;IACF;IAEA,MAAMM,SAAS,MAAOC,CAAAA,yBAAyBR,YAAY,aAAa,IACpES,UAAUH,WACVI,KAAKJ,QAAO;IAEhB,MAAM,EAAEK,QAAQ,EAAEC,QAAQ,EAAEC,SAAS,EAAEC,iBAAiB,EAAE,GAAGC,UAAU,GACrER;IAEF,MAAMS,QAAQC,eAAe;QAC3B,WAAWN;QACXC;QACAC;QACAC;QACA,WAAWd,YAAY,SAAS;QAChC,kBAAkBA,YAAY,gBAAgB;QAC9C,MAAMA,YAAY,IAAI;QACtBF;IACF;IAEA,MAAMoB,oBAAoBC,SAAS;IACnC,MAAMC,qBAAqBD,SAAS;IACpCD,kBACE,CAAC,OAAO,EAAElB,YAAY,SAAS,CAAC,QAAQ,EAAEA,YAAY,WAAW,IAAI,UAAU,aAAa,EAAEe,SAAS,UAAU,CAAC,iBAAiB,EAAEC,OAAO,iBAAiB,GAAG,qBAAqB,EAAEA,OAAO,qBAAqB,GAAG,gBAAgB,EAAEA,OAAO,gBAAgB,GAAG,gBAAgB,EAAEA,OAAO,gBAAgB,GAAG,WAAW,EAAEJ,YAAY,GAAG,aAAa,EAAEC,aAAa,GAAG,QAAQ,EAAEb,YAAY,IAAI,CAAC,0BAA0B,EAAEA,YAAY,WAAW,IAAI,IAAI;IAEjcoB,mBAAmB,CAAC,oBAAoB,EAAEC,KAAK,SAAS,CAACL,QAAQ;IAEjE,IAAIA,SAASxB,aAAa,OAAO,EAC/BA,aAAa,OAAO,CAACwB;IAEvB,OAAO;QAAE,GAAGD,QAAQ;QAAEC;IAAM;AAC9B"}

package/dist/es/ai-model/service-caller/chat-completion/call.mjs

@@ -0,0 +1,101 @@
+import { getDebug } from "@midscene/shared/logger";
+import { createChatClient } from "../openai-client.mjs";
+import { formatOpenAIAPIErrorDetails } from "../openai-error.mjs";
+import { resolveEffectiveTimeoutMs } from "../request-timeout.mjs";
+import { AIResponseParseError, getLatestResponseAttempt, stringifyForDebug } from "../utils.mjs";
+import { callChatCompletionNonStreaming } from "./non-stream.mjs";
+import { callChatCompletionStream } from "./stream.mjs";
+import { applyImageDetail } from "./utils.mjs";
+const chat = async ({ messages, modelRuntime, options, executionId, recordEvent })=>{
+    const debugCall = getDebug('ai:call');
+    const warnCall = getDebug('ai:call', {
+        console: true
+    });
+    const { config: modelConfig, adapter } = modelRuntime;
+    const isStreaming = options?.stream === true;
+    const modelCallInput = {
+        intent: modelConfig.intent,
+        userConfig: {
+            temperature: modelConfig.temperature,
+            reasoningEnabled: modelConfig.reasoningEnabled,
+            reasoningEffort: modelConfig.reasoningEffort,
+            reasoningBudget: modelConfig.reasoningBudget,
+            responseFormat: modelConfig.responseFormat
+        },
+        semanticRetryAttempt: options?.semanticRetryAttempt,
+        requiresOriginalImageDetail: options?.requiresOriginalImageDetail,
+        expectedJsonObjectResponse: options?.expectedJsonObjectResponse
+    };
+    const { config: adapterChatCompletionParams } = adapter.chatCompletion.buildChatCompletionParams(modelCallInput);
+    debugCall(`adapter chat completion params: ${stringifyForDebug({
+        config: adapterChatCompletionParams
+    })}`);
+    const requestConfig = {
+        ...adapterChatCompletionParams,
+        ...modelConfig.extraBody ?? {}
+    };
+    const imageDetail = adapter.chatCompletion.resolveImageDetail(modelCallInput);
+    const messagesWithImageDetail = applyImageDetail({
+        imageDetail,
+        messages
+    });
+    const effectiveTimeoutMs = resolveEffectiveTimeoutMs(modelConfig);
+    const { completion, modelName, openAIErrorResponseContext } = await createChatClient({
+        modelConfig,
+        executionId,
+        recordEvent
+    });
+    debugCall(`sending ${isStreaming ? 'streaming ' : ''}request to ${modelName}`);
+    const callChatCompletion = isStreaming ? callChatCompletionStream : callChatCompletionNonStreaming;
+    try {
+        const startTime = Date.now();
+        const { content, reasoningContent, rawChoiceMessage, rawUsage, requestId, responseModelName } = await callChatCompletion({
+            completion,
+            modelName,
+            openAIErrorResponseContext,
+            modelRuntime,
+            messages: messagesWithImageDetail,
+            requestConfig,
+            effectiveTimeoutMs,
+            abortSignal: options?.abortSignal,
+            onChunk: options?.onChunk,
+            recordEvent
+        });
+        const timeCost = Date.now() - startTime;
+        debugCall(`response reasoning content: ${reasoningContent}`);
+        debugCall(`response content: ${content}`);
+        recordEvent?.({
+            type: 'response',
+            attempt: getLatestResponseAttempt(openAIErrorResponseContext),
+            http: openAIErrorResponseContext.httpResponses?.at(-1),
+            final: {
+                content,
+                reasoningContent,
+                usage: rawUsage,
+                requestId,
+                timeCost,
+                responseModelName
+            }
+        });
+        return {
+            content,
+            reasoning_content: reasoningContent,
+            rawChoiceMessage,
+            rawUsage,
+            isStreamed: isStreaming,
+            timeCost,
+            requestId,
+            responseModelName
+        };
+    } catch (e) {
+        warnCall('call AI error', e);
+        if (e instanceof AIResponseParseError) throw e;
+        const newError = new Error(`failed to call ${isStreaming ? 'streaming ' : ''}AI model service (${modelName}): ${e.message}${formatOpenAIAPIErrorDetails(e, openAIErrorResponseContext)}\nTrouble shooting: https://midscenejs.com/model-provider.html`, {
+            cause: e
+        });
+        throw newError;
+    }
+};
+export { chat };
+
+//# sourceMappingURL=call.mjs.map

package/dist/es/ai-model/service-caller/chat-completion/call.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/service-caller/chat-completion/call.mjs","sources":["../../../../../src/ai-model/service-caller/chat-completion/call.ts"],"sourcesContent":["import { getDebug } from '@midscene/shared/logger';\nimport type { ChatCompletionCallInput } from '../../model-adapter/types';\nimport { createChatClient } from '../openai-client';\nimport { formatOpenAIAPIErrorDetails } from '../openai-error';\nimport { resolveEffectiveTimeoutMs } from '../request-timeout';\nimport type { ModelCallContext, ModelCallResult } from '../types';\nimport {\n  AIResponseParseError,\n  getLatestResponseAttempt,\n  stringifyForDebug,\n} from '../utils';\nimport { callChatCompletionNonStreaming } from './non-stream';\nimport { callChatCompletionStream } from './stream';\nimport { applyImageDetail } from './utils';\n\nexport const chat = async ({\n  messages,\n  modelRuntime,\n  options,\n  executionId,\n  recordEvent,\n}: ModelCallContext): Promise<ModelCallResult> => {\n  const debugCall = getDebug('ai:call');\n  const warnCall = getDebug('ai:call', { console: true });\n\n  const { config: modelConfig, adapter } = modelRuntime;\n\n  const isStreaming = options?.stream === true;\n\n  const modelCallInput: ChatCompletionCallInput = {\n    intent: modelConfig.intent,\n    userConfig: {\n      temperature: modelConfig.temperature,\n      reasoningEnabled: modelConfig.reasoningEnabled,\n      reasoningEffort: modelConfig.reasoningEffort,\n      reasoningBudget: modelConfig.reasoningBudget,\n      responseFormat: modelConfig.responseFormat,\n    },\n    semanticRetryAttempt: options?.semanticRetryAttempt,\n    requiresOriginalImageDetail: options?.requiresOriginalImageDetail,\n    expectedJsonObjectResponse: options?.expectedJsonObjectResponse,\n  };\n\n  const { config: adapterChatCompletionParams } =\n    adapter.chatCompletion.buildChatCompletionParams(modelCallInput);\n\n  debugCall(\n    `adapter chat completion params: ${stringifyForDebug({\n      config: adapterChatCompletionParams,\n    })}`,\n  );\n\n  const requestConfig = {\n    ...adapterChatCompletionParams,\n    ...(modelConfig.extraBody ?? {}),\n  };\n\n  const imageDetail = adapter.chatCompletion.resolveImageDetail(modelCallInput);\n\n  // Some adapters request original image detail to preserve screenshot\n  // resolution for localization-sensitive tasks.\n  const messagesWithImageDetail = applyImageDetail({ imageDetail, messages });\n\n  const effectiveTimeoutMs = resolveEffectiveTimeoutMs(modelConfig);\n\n  const { completion, modelName, openAIErrorResponseContext } =\n    await createChatClient({\n      modelConfig,\n      executionId,\n      recordEvent,\n    });\n\n  debugCall(\n    `sending ${isStreaming ? 'streaming ' : ''}request to ${modelName}`,\n  );\n\n  const callChatCompletion = isStreaming\n    ? callChatCompletionStream\n    : callChatCompletionNonStreaming;\n\n  try {\n    const startTime = Date.now();\n\n    const {\n      content,\n      reasoningContent,\n      rawChoiceMessage,\n      rawUsage,\n      requestId,\n      responseModelName,\n    } = await callChatCompletion({\n      completion,\n      modelName,\n      openAIErrorResponseContext,\n      modelRuntime,\n      messages: messagesWithImageDetail,\n      requestConfig,\n      effectiveTimeoutMs,\n      abortSignal: options?.abortSignal,\n      onChunk: options?.onChunk,\n      recordEvent,\n    });\n\n    const timeCost = Date.now() - startTime;\n    debugCall(`response reasoning content: ${reasoningContent}`);\n    debugCall(`response content: ${content}`);\n\n    recordEvent?.({\n      type: 'response',\n      attempt: getLatestResponseAttempt(openAIErrorResponseContext),\n      http: openAIErrorResponseContext.httpResponses?.at(-1),\n      final: {\n        content,\n        reasoningContent,\n        usage: rawUsage,\n        requestId,\n        timeCost,\n        responseModelName,\n      },\n    });\n\n    return {\n      content,\n      reasoning_content: reasoningContent,\n      rawChoiceMessage,\n      rawUsage,\n      isStreamed: isStreaming,\n      timeCost,\n      requestId,\n      responseModelName,\n    };\n  } catch (e: any) {\n    warnCall('call AI error', e);\n\n    if (e instanceof AIResponseParseError) {\n      throw e;\n    }\n\n    const newError = new Error(\n      `failed to call ${isStreaming ? 'streaming ' : ''}AI model service (${modelName}): ${e.message}${formatOpenAIAPIErrorDetails(e, openAIErrorResponseContext)}\\nTrouble shooting: https://midscenejs.com/model-provider.html`,\n      {\n        cause: e,\n      },\n    );\n    throw newError;\n  }\n};\n"],"names":["chat","messages","modelRuntime","options","executionId","recordEvent","debugCall","getDebug","warnCall","modelConfig","adapter","isStreaming","modelCallInput","adapterChatCompletionParams","stringifyForDebug","requestConfig","imageDetail","messagesWithImageDetail","applyImageDetail","effectiveTimeoutMs","resolveEffectiveTimeoutMs","completion","modelName","openAIErrorResponseContext","createChatClient","callChatCompletion","callChatCompletionStream","callChatCompletionNonStreaming","startTime","Date","content","reasoningContent","rawChoiceMessage","rawUsage","requestId","responseModelName","timeCost","getLatestResponseAttempt","e","AIResponseParseError","newError","Error","formatOpenAIAPIErrorDetails"],"mappings":";;;;;;;;AAeO,MAAMA,OAAO,OAAO,EACzBC,QAAQ,EACRC,YAAY,EACZC,OAAO,EACPC,WAAW,EACXC,WAAW,EACM;IACjB,MAAMC,YAAYC,SAAS;IAC3B,MAAMC,WAAWD,SAAS,WAAW;QAAE,SAAS;IAAK;IAErD,MAAM,EAAE,QAAQE,WAAW,EAAEC,OAAO,EAAE,GAAGR;IAEzC,MAAMS,cAAcR,SAAS,WAAW;IAExC,MAAMS,iBAA0C;QAC9C,QAAQH,YAAY,MAAM;QAC1B,YAAY;YACV,aAAaA,YAAY,WAAW;YACpC,kBAAkBA,YAAY,gBAAgB;YAC9C,iBAAiBA,YAAY,eAAe;YAC5C,iBAAiBA,YAAY,eAAe;YAC5C,gBAAgBA,YAAY,cAAc;QAC5C;QACA,sBAAsBN,SAAS;QAC/B,6BAA6BA,SAAS;QACtC,4BAA4BA,SAAS;IACvC;IAEA,MAAM,EAAE,QAAQU,2BAA2B,EAAE,GAC3CH,QAAQ,cAAc,CAAC,yBAAyB,CAACE;IAEnDN,UACE,CAAC,gCAAgC,EAAEQ,kBAAkB;QACnD,QAAQD;IACV,IAAI;IAGN,MAAME,gBAAgB;QACpB,GAAGF,2BAA2B;QAC9B,GAAIJ,YAAY,SAAS,IAAI,CAAC,CAAC;IACjC;IAEA,MAAMO,cAAcN,QAAQ,cAAc,CAAC,kBAAkB,CAACE;IAI9D,MAAMK,0BAA0BC,iBAAiB;QAAEF;QAAaf;IAAS;IAEzE,MAAMkB,qBAAqBC,0BAA0BX;IAErD,MAAM,EAAEY,UAAU,EAAEC,SAAS,EAAEC,0BAA0B,EAAE,GACzD,MAAMC,iBAAiB;QACrBf;QACAL;QACAC;IACF;IAEFC,UACE,CAAC,QAAQ,EAAEK,cAAc,eAAe,GAAG,WAAW,EAAEW,WAAW;IAGrE,MAAMG,qBAAqBd,cACvBe,2BACAC;IAEJ,IAAI;QACF,MAAMC,YAAYC,KAAK,GAAG;QAE1B,MAAM,EACJC,OAAO,EACPC,gBAAgB,EAChBC,gBAAgB,EAChBC,QAAQ,EACRC,SAAS,EACTC,iBAAiB,EAClB,GAAG,MAAMV,mBAAmB;YAC3BJ;YACAC;YACAC;YACArB;YACA,UAAUe;YACVF;YACAI;YACA,aAAahB,SAAS;YACtB,SAASA,SAAS;YAClBE;QACF;QAEA,MAAM+B,WAAWP,KAAK,GAAG,KAAKD;QAC9BtB,UAAU,CAAC,4BAA4B,EAAEyB,kBAAkB;QAC3DzB,UAAU,CAAC,kBAAkB,EAAEwB,SAAS;QAExCzB,cAAc;YACZ,MAAM;YACN,SAASgC,yBAAyBd;YAClC,MAAMA,2BAA2B,aAAa,EAAE,GAAG;YACnD,OAAO;gBACLO;gBACAC;gBACA,OAAOE;gBACPC;gBACAE;gBACAD;YACF;QACF;QAEA,OAAO;YACLL;YACA,mBAAmBC;YACnBC;YACAC;YACA,YAAYtB;YACZyB;YACAF;YACAC;QACF;IACF,EAAE,OAAOG,GAAQ;QACf9B,SAAS,iBAAiB8B;QAE1B,IAAIA,aAAaC,sBACf,MAAMD;QAGR,MAAME,WAAW,IAAIC,MACnB,CAAC,eAAe,EAAE9B,cAAc,eAAe,GAAG,kBAAkB,EAAEW,UAAU,GAAG,EAAEgB,EAAE,OAAO,GAAGI,4BAA4BJ,GAAGf,4BAA4B,8DAA8D,CAAC,EAC3N;YACE,OAAOe;QACT;QAEF,MAAME;IACR;AACF"}

package/dist/es/ai-model/service-caller/chat-completion/non-stream.mjs

@@ -0,0 +1,80 @@
+import { getDebug } from "@midscene/shared/logger";
+import { assert } from "@midscene/shared/utils";
+import { buildRequestAbortSignal, isHardTimeoutError, restoreHardTimeoutError } from "../request-timeout.mjs";
+import { AIResponseParseError, appendAIRequestFailureSummary, getLatestSuccessfulResponseRequestId, normalizeRetryCount, toError } from "../utils.mjs";
+import { hasUsableText, resolveContentWithReasoningFallback } from "./utils.mjs";
+const callChatCompletionNonStreaming = async ({ completion, modelName, openAIErrorResponseContext, modelRuntime, messages, requestConfig, effectiveTimeoutMs, abortSignal })=>{
+    const { config: modelConfig, adapter } = modelRuntime;
+    const warnCall = getDebug('ai:call', {
+        console: true
+    });
+    let content;
+    let reasoningContent = '';
+    let rawChoiceMessage;
+    let usage;
+    let requestId;
+    let responseModelName;
+    const retryCount = normalizeRetryCount(modelConfig.retryCount);
+    const retryInterval = modelConfig.retryInterval ?? 2000;
+    const maxAttempts = retryCount + 1;
+    let lastError;
+    const attemptErrors = [];
+    for(let attempt = 1; attempt <= maxAttempts; attempt++){
+        const { signal: attemptSignal, cleanup: cleanupAttemptSignal } = buildRequestAbortSignal(effectiveTimeoutMs, abortSignal);
+        try {
+            const result = await completion.create({
+                model: modelName,
+                messages,
+                ...requestConfig,
+                stream: false
+            }, {
+                signal: attemptSignal
+            });
+            requestId = getLatestSuccessfulResponseRequestId(openAIErrorResponseContext) ?? result._request_id;
+            if (!result.choices) throw new Error(`invalid response from LLM service: ${JSON.stringify(result)}`);
+            rawChoiceMessage = result.choices[0].message;
+            const parsedMessage = adapter.chatCompletion.extractContentAndReasoning(result.choices[0].message);
+            content = parsedMessage.content;
+            reasoningContent = parsedMessage.reasoning_content;
+            usage = result.usage;
+            responseModelName = result.model;
+            content = resolveContentWithReasoningFallback({
+                content,
+                reasoningContent,
+                useReasoningAsContentFallback: adapter.chatCompletion.useReasoningAsContentFallback
+            });
+            if (!hasUsableText(content)) throw new AIResponseParseError('empty content from AI model', content || '', void 0, rawChoiceMessage);
+            break;
+        } catch (error) {
+            lastError = restoreHardTimeoutError(toError(error), attemptSignal);
+            attemptErrors.push({
+                attempt,
+                error: lastError
+            });
+            const wasHardTimeout = isHardTimeoutError(lastError);
+            if (wasHardTimeout) warnCall(`AI call hit hard timeout (${effectiveTimeoutMs}ms, attempt ${attempt}/${maxAttempts}, model ${modelName}, slot ${modelConfig.slot})`);
+            if (abortSignal?.aborted) break;
+            if (attempt < maxAttempts) {
+                warnCall(`AI call failed (attempt ${attempt}/${maxAttempts}), retrying in ${retryInterval}ms... Error: ${lastError.message}`);
+                await new Promise((resolve)=>setTimeout(resolve, retryInterval));
+            }
+        } finally{
+            cleanupAttemptSignal();
+        }
+    }
+    if (!content) {
+        assert(lastError, 'AI model request failed without recording an attempt error');
+        throw appendAIRequestFailureSummary(lastError, attemptErrors, maxAttempts);
+    }
+    return {
+        content,
+        reasoningContent,
+        rawChoiceMessage,
+        rawUsage: usage,
+        requestId,
+        responseModelName
+    };
+};
+export { callChatCompletionNonStreaming };
+
+//# sourceMappingURL=non-stream.mjs.map

package/dist/es/ai-model/service-caller/chat-completion/non-stream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/service-caller/chat-completion/non-stream.mjs","sources":["../../../../../src/ai-model/service-caller/chat-completion/non-stream.ts"],"sourcesContent":["import { getDebug } from '@midscene/shared/logger';\nimport { assert } from '@midscene/shared/utils';\nimport type OpenAI from 'openai';\nimport {\n  buildRequestAbortSignal,\n  isHardTimeoutError,\n  restoreHardTimeoutError,\n} from '../request-timeout';\nimport {\n  AIResponseParseError,\n  appendAIRequestFailureSummary,\n  getLatestSuccessfulResponseRequestId,\n  normalizeRetryCount,\n  toError,\n} from '../utils';\nimport type {\n  ChatCompletionCallOptions,\n  ChatCompletionCallResult,\n} from './types';\nimport { hasUsableText, resolveContentWithReasoningFallback } from './utils';\n\nexport const callChatCompletionNonStreaming = async ({\n  completion,\n  modelName,\n  openAIErrorResponseContext,\n  modelRuntime,\n  messages,\n  requestConfig,\n  effectiveTimeoutMs,\n  abortSignal,\n}: ChatCompletionCallOptions): Promise<ChatCompletionCallResult> => {\n  const { config: modelConfig, adapter } = modelRuntime;\n  const warnCall = getDebug('ai:call', { console: true });\n  let content: string | undefined;\n  let reasoningContent = '';\n  let rawChoiceMessage: unknown;\n  let usage: OpenAI.CompletionUsage | undefined;\n  let requestId: string | null | undefined;\n  let responseModelName: string | undefined;\n\n  // Non-streaming with retry logic\n  const retryCount = normalizeRetryCount(modelConfig.retryCount);\n  const retryInterval = modelConfig.retryInterval ?? 2000;\n  const maxAttempts = retryCount + 1; // retryCount=1 means 2 total attempts (1 initial + 1 retry)\n\n  let lastError: Error | undefined;\n  const attemptErrors: Array<{ attempt: number; error: unknown }> = [];\n\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    const { signal: attemptSignal, cleanup: cleanupAttemptSignal } =\n      buildRequestAbortSignal(effectiveTimeoutMs, abortSignal);\n    try {\n      const result = await completion.create(\n        {\n          model: modelName,\n          messages,\n          ...requestConfig,\n          stream: false,\n        } as any,\n        { signal: attemptSignal },\n      );\n\n      requestId =\n        getLatestSuccessfulResponseRequestId(openAIErrorResponseContext) ??\n        result._request_id;\n\n      if (!result.choices) {\n        throw new Error(\n          `invalid response from LLM service: ${JSON.stringify(result)}`,\n        );\n      }\n\n      rawChoiceMessage = result.choices[0].message;\n      const parsedMessage = adapter.chatCompletion.extractContentAndReasoning(\n        result.choices[0].message,\n      );\n      content = parsedMessage.content;\n      reasoningContent = parsedMessage.reasoning_content;\n      usage = result.usage;\n      responseModelName = result.model;\n\n      content = resolveContentWithReasoningFallback({\n        content,\n        reasoningContent,\n        useReasoningAsContentFallback:\n          adapter.chatCompletion.useReasoningAsContentFallback,\n      });\n\n      if (!hasUsableText(content)) {\n        throw new AIResponseParseError(\n          'empty content from AI model',\n          content || '',\n          undefined,\n          rawChoiceMessage,\n        );\n      }\n\n      break; // Success, exit retry loop\n    } catch (error) {\n      lastError = restoreHardTimeoutError(toError(error), attemptSignal);\n      attemptErrors.push({ attempt, error: lastError });\n      const wasHardTimeout = isHardTimeoutError(lastError);\n      if (wasHardTimeout) {\n        warnCall(\n          `AI call hit hard timeout (${effectiveTimeoutMs}ms, attempt ${attempt}/${maxAttempts}, model ${modelName}, slot ${modelConfig.slot})`,\n        );\n      }\n      // Do not retry if the request was aborted by the caller\n      if (abortSignal?.aborted) {\n        break;\n      }\n      if (attempt < maxAttempts) {\n        warnCall(\n          `AI call failed (attempt ${attempt}/${maxAttempts}), retrying in ${retryInterval}ms... Error: ${lastError.message}`,\n        );\n        await new Promise((resolve) => setTimeout(resolve, retryInterval));\n      }\n    } finally {\n      cleanupAttemptSignal();\n    }\n  }\n\n  if (!content) {\n    assert(\n      lastError,\n      'AI model request failed without recording an attempt error',\n    );\n    throw appendAIRequestFailureSummary(lastError, attemptErrors, maxAttempts);\n  }\n  return {\n    content,\n    reasoningContent,\n    rawChoiceMessage,\n    rawUsage: usage,\n    requestId,\n    responseModelName,\n  };\n};\n"],"names":["callChatCompletionNonStreaming","completion","modelName","openAIErrorResponseContext","modelRuntime","messages","requestConfig","effectiveTimeoutMs","abortSignal","modelConfig","adapter","warnCall","getDebug","content","reasoningContent","rawChoiceMessage","usage","requestId","responseModelName","retryCount","normalizeRetryCount","retryInterval","maxAttempts","lastError","attemptErrors","attempt","attemptSignal","cleanupAttemptSignal","buildRequestAbortSignal","result","getLatestSuccessfulResponseRequestId","Error","JSON","parsedMessage","resolveContentWithReasoningFallback","hasUsableText","AIResponseParseError","undefined","error","restoreHardTimeoutError","toError","wasHardTimeout","isHardTimeoutError","Promise","resolve","setTimeout","assert","appendAIRequestFailureSummary"],"mappings":";;;;;AAqBO,MAAMA,iCAAiC,OAAO,EACnDC,UAAU,EACVC,SAAS,EACTC,0BAA0B,EAC1BC,YAAY,EACZC,QAAQ,EACRC,aAAa,EACbC,kBAAkB,EAClBC,WAAW,EACe;IAC1B,MAAM,EAAE,QAAQC,WAAW,EAAEC,OAAO,EAAE,GAAGN;IACzC,MAAMO,WAAWC,SAAS,WAAW;QAAE,SAAS;IAAK;IACrD,IAAIC;IACJ,IAAIC,mBAAmB;IACvB,IAAIC;IACJ,IAAIC;IACJ,IAAIC;IACJ,IAAIC;IAGJ,MAAMC,aAAaC,oBAAoBX,YAAY,UAAU;IAC7D,MAAMY,gBAAgBZ,YAAY,aAAa,IAAI;IACnD,MAAMa,cAAcH,aAAa;IAEjC,IAAII;IACJ,MAAMC,gBAA4D,EAAE;IAEpE,IAAK,IAAIC,UAAU,GAAGA,WAAWH,aAAaG,UAAW;QACvD,MAAM,EAAE,QAAQC,aAAa,EAAE,SAASC,oBAAoB,EAAE,GAC5DC,wBAAwBrB,oBAAoBC;QAC9C,IAAI;YACF,MAAMqB,SAAS,MAAM5B,WAAW,MAAM,CACpC;gBACE,OAAOC;gBACPG;gBACA,GAAGC,aAAa;gBAChB,QAAQ;YACV,GACA;gBAAE,QAAQoB;YAAc;YAG1BT,YACEa,qCAAqC3B,+BACrC0B,OAAO,WAAW;YAEpB,IAAI,CAACA,OAAO,OAAO,EACjB,MAAM,IAAIE,MACR,CAAC,mCAAmC,EAAEC,KAAK,SAAS,CAACH,SAAS;YAIlEd,mBAAmBc,OAAO,OAAO,CAAC,EAAE,CAAC,OAAO;YAC5C,MAAMI,gBAAgBvB,QAAQ,cAAc,CAAC,0BAA0B,CACrEmB,OAAO,OAAO,CAAC,EAAE,CAAC,OAAO;YAE3BhB,UAAUoB,cAAc,OAAO;YAC/BnB,mBAAmBmB,cAAc,iBAAiB;YAClDjB,QAAQa,OAAO,KAAK;YACpBX,oBAAoBW,OAAO,KAAK;YAEhChB,UAAUqB,oCAAoC;gBAC5CrB;gBACAC;gBACA,+BACEJ,QAAQ,cAAc,CAAC,6BAA6B;YACxD;YAEA,IAAI,CAACyB,cAActB,UACjB,MAAM,IAAIuB,qBACR,+BACAvB,WAAW,IACXwB,QACAtB;YAIJ;QACF,EAAE,OAAOuB,OAAO;YACdf,YAAYgB,wBAAwBC,QAAQF,QAAQZ;YACpDF,cAAc,IAAI,CAAC;gBAAEC;gBAAS,OAAOF;YAAU;YAC/C,MAAMkB,iBAAiBC,mBAAmBnB;YAC1C,IAAIkB,gBACF9B,SACE,CAAC,0BAA0B,EAAEJ,mBAAmB,YAAY,EAAEkB,QAAQ,CAAC,EAAEH,YAAY,QAAQ,EAAEpB,UAAU,OAAO,EAAEO,YAAY,IAAI,CAAC,CAAC,CAAC;YAIzI,IAAID,aAAa,SACf;YAEF,IAAIiB,UAAUH,aAAa;gBACzBX,SACE,CAAC,wBAAwB,EAAEc,QAAQ,CAAC,EAAEH,YAAY,eAAe,EAAED,cAAc,aAAa,EAAEE,UAAU,OAAO,EAAE;gBAErH,MAAM,IAAIoB,QAAQ,CAACC,UAAYC,WAAWD,SAASvB;YACrD;QACF,SAAU;YACRM;QACF;IACF;IAEA,IAAI,CAACd,SAAS;QACZiC,OACEvB,WACA;QAEF,MAAMwB,8BAA8BxB,WAAWC,eAAeF;IAChE;IACA,OAAO;QACLT;QACAC;QACAC;QACA,UAAUC;QACVC;QACAC;IACF;AACF"}

package/dist/es/ai-model/service-caller/chat-completion/stream.mjs

@@ -0,0 +1,87 @@
+import { assert } from "@midscene/shared/utils";
+import { buildRequestAbortSignal, restoreHardTimeoutError } from "../request-timeout.mjs";
+import { getLatestResponseAttempt, getLatestSuccessfulResponseRequestId, toError } from "../utils.mjs";
+import { resolveContentWithReasoningFallback } from "./utils.mjs";
+const callChatCompletionStream = async ({ completion, modelName, openAIErrorResponseContext, modelRuntime, messages, requestConfig, effectiveTimeoutMs, abortSignal, onChunk, recordEvent })=>{
+    assert('function' == typeof onChunk, 'onChunk is required when stream is true');
+    const { adapter } = modelRuntime;
+    let accumulated = '';
+    let accumulatedReasoning = '';
+    let usage;
+    let requestId;
+    let responseModelName;
+    const { signal: streamSignal, cleanup: cleanupStreamSignal } = buildRequestAbortSignal(effectiveTimeoutMs, abortSignal);
+    try {
+        const stream = await completion.create({
+            model: modelName,
+            messages,
+            ...requestConfig,
+            stream: true,
+            stream_options: {
+                ...requestConfig.stream_options,
+                include_usage: true
+            }
+        }, {
+            stream: true,
+            signal: streamSignal
+        });
+        requestId = getLatestSuccessfulResponseRequestId(openAIErrorResponseContext) ?? stream._request_id;
+        const streamAttempt = getLatestResponseAttempt(openAIErrorResponseContext);
+        let chunkSequence = 0;
+        for await (const chunk of stream){
+            chunkSequence += 1;
+            recordEvent?.({
+                type: 'chunk',
+                attempt: streamAttempt,
+                sequence: chunkSequence,
+                chunk
+            });
+            const parsedChunk = adapter.chatCompletion.extractContentAndReasoning(chunk.choices?.[0]?.delta);
+            const content = parsedChunk.content || '';
+            const reasoning_content = parsedChunk.reasoning_content || '';
+            if (chunk.usage) usage = chunk.usage;
+            if (chunk.model) responseModelName = chunk.model;
+            if (content || reasoning_content) {
+                accumulated += content;
+                accumulatedReasoning += reasoning_content;
+                const chunkData = {
+                    content,
+                    reasoning_content,
+                    accumulated,
+                    isComplete: false,
+                    usage: void 0
+                };
+                onChunk(chunkData);
+            }
+        }
+        const finalAccumulated = resolveContentWithReasoningFallback({
+            content: accumulated,
+            reasoningContent: accumulatedReasoning,
+            useReasoningAsContentFallback: adapter.chatCompletion.useReasoningAsContentFallback
+        });
+        accumulated = finalAccumulated || '';
+        const finalChunk = {
+            content: '',
+            accumulated,
+            reasoning_content: '',
+            isComplete: true,
+            usage
+        };
+        onChunk(finalChunk);
+    } catch (error) {
+        throw restoreHardTimeoutError(toError(error), streamSignal);
+    } finally{
+        cleanupStreamSignal();
+    }
+    return {
+        content: accumulated,
+        reasoningContent: accumulatedReasoning,
+        rawChoiceMessage: void 0,
+        rawUsage: usage,
+        requestId,
+        responseModelName
+    };
+};
+export { callChatCompletionStream };
+
+//# sourceMappingURL=stream.mjs.map

package/dist/es/ai-model/service-caller/chat-completion/stream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/service-caller/chat-completion/stream.mjs","sources":["../../../../../src/ai-model/service-caller/chat-completion/stream.ts"],"sourcesContent":["import type { CodeGenerationChunk } from '@/types';\nimport { assert } from '@midscene/shared/utils';\nimport type OpenAI from 'openai';\nimport type { Stream } from 'openai/streaming';\nimport {\n  buildRequestAbortSignal,\n  restoreHardTimeoutError,\n} from '../request-timeout';\nimport {\n  getLatestResponseAttempt,\n  getLatestSuccessfulResponseRequestId,\n  toError,\n} from '../utils';\nimport type {\n  ChatCompletionCallOptions,\n  ChatCompletionCallResult,\n} from './types';\nimport { resolveContentWithReasoningFallback } from './utils';\n\nexport const callChatCompletionStream = async ({\n  completion,\n  modelName,\n  openAIErrorResponseContext,\n  modelRuntime,\n  messages,\n  requestConfig,\n  effectiveTimeoutMs,\n  abortSignal,\n  onChunk,\n  recordEvent,\n}: ChatCompletionCallOptions): Promise<ChatCompletionCallResult> => {\n  assert(\n    typeof onChunk === 'function',\n    'onChunk is required when stream is true',\n  );\n  const { adapter } = modelRuntime;\n  let accumulated = '';\n  let accumulatedReasoning = '';\n  let usage: OpenAI.CompletionUsage | undefined;\n  let requestId: string | null | undefined;\n  let responseModelName: string | undefined;\n  const { signal: streamSignal, cleanup: cleanupStreamSignal } =\n    buildRequestAbortSignal(effectiveTimeoutMs, abortSignal);\n  try {\n    const stream = (await completion.create(\n      {\n        model: modelName,\n        messages,\n        ...requestConfig,\n        stream: true,\n        stream_options: {\n          ...(requestConfig.stream_options as\n            | Record<string, unknown>\n            | undefined),\n          include_usage: true,\n        },\n      },\n      {\n        stream: true,\n        signal: streamSignal,\n      },\n    )) as Stream<OpenAI.Chat.Completions.ChatCompletionChunk> & {\n      _request_id?: string | null;\n    };\n\n    requestId =\n      getLatestSuccessfulResponseRequestId(openAIErrorResponseContext) ??\n      stream._request_id;\n    const streamAttempt = getLatestResponseAttempt(openAIErrorResponseContext);\n\n    let chunkSequence = 0;\n    for await (const chunk of stream) {\n      chunkSequence += 1;\n      recordEvent?.({\n        type: 'chunk',\n        attempt: streamAttempt,\n        sequence: chunkSequence,\n        chunk,\n      });\n      const parsedChunk = adapter.chatCompletion.extractContentAndReasoning(\n        chunk.choices?.[0]?.delta,\n      );\n      const content = parsedChunk.content || '';\n      const reasoning_content = parsedChunk.reasoning_content || '';\n\n      // Check for usage info in any chunk (OpenAI provides usage in separate chunks)\n      if (chunk.usage) {\n        usage = chunk.usage;\n      }\n      if (chunk.model) {\n        responseModelName = chunk.model;\n      }\n\n      if (content || reasoning_content) {\n        accumulated += content;\n        accumulatedReasoning += reasoning_content;\n        const chunkData: CodeGenerationChunk = {\n          content,\n          reasoning_content,\n          accumulated,\n          isComplete: false,\n          usage: undefined,\n        };\n        onChunk(chunkData);\n      }\n    }\n\n    const finalAccumulated = resolveContentWithReasoningFallback({\n      content: accumulated,\n      reasoningContent: accumulatedReasoning,\n      useReasoningAsContentFallback:\n        adapter.chatCompletion.useReasoningAsContentFallback,\n    });\n    accumulated = finalAccumulated || '';\n\n    // Send final chunk\n    const finalChunk: CodeGenerationChunk = {\n      content: '',\n      accumulated,\n      reasoning_content: '',\n      isComplete: true,\n      usage,\n    };\n    onChunk(finalChunk);\n  } catch (error) {\n    throw restoreHardTimeoutError(toError(error), streamSignal);\n  } finally {\n    cleanupStreamSignal();\n  }\n  return {\n    content: accumulated,\n    reasoningContent: accumulatedReasoning,\n    rawChoiceMessage: undefined,\n    rawUsage: usage,\n    requestId,\n    responseModelName,\n  };\n};\n"],"names":["callChatCompletionStream","completion","modelName","openAIErrorResponseContext","modelRuntime","messages","requestConfig","effectiveTimeoutMs","abortSignal","onChunk","recordEvent","assert","adapter","accumulated","accumulatedReasoning","usage","requestId","responseModelName","streamSignal","cleanupStreamSignal","buildRequestAbortSignal","stream","getLatestSuccessfulResponseRequestId","streamAttempt","getLatestResponseAttempt","chunkSequence","chunk","parsedChunk","content","reasoning_content","chunkData","undefined","finalAccumulated","resolveContentWithReasoningFallback","finalChunk","error","restoreHardTimeoutError","toError"],"mappings":";;;;AAmBO,MAAMA,2BAA2B,OAAO,EAC7CC,UAAU,EACVC,SAAS,EACTC,0BAA0B,EAC1BC,YAAY,EACZC,QAAQ,EACRC,aAAa,EACbC,kBAAkB,EAClBC,WAAW,EACXC,OAAO,EACPC,WAAW,EACe;IAC1BC,OACE,AAAmB,cAAnB,OAAOF,SACP;IAEF,MAAM,EAAEG,OAAO,EAAE,GAAGR;IACpB,IAAIS,cAAc;IAClB,IAAIC,uBAAuB;IAC3B,IAAIC;IACJ,IAAIC;IACJ,IAAIC;IACJ,MAAM,EAAE,QAAQC,YAAY,EAAE,SAASC,mBAAmB,EAAE,GAC1DC,wBAAwBb,oBAAoBC;IAC9C,IAAI;QACF,MAAMa,SAAU,MAAMpB,WAAW,MAAM,CACrC;YACE,OAAOC;YACPG;YACA,GAAGC,aAAa;YAChB,QAAQ;YACR,gBAAgB;gBACd,GAAIA,cAAc,cAAc;gBAGhC,eAAe;YACjB;QACF,GACA;YACE,QAAQ;YACR,QAAQY;QACV;QAKFF,YACEM,qCAAqCnB,+BACrCkB,OAAO,WAAW;QACpB,MAAME,gBAAgBC,yBAAyBrB;QAE/C,IAAIsB,gBAAgB;QACpB,WAAW,MAAMC,SAASL,OAAQ;YAChCI,iBAAiB;YACjBf,cAAc;gBACZ,MAAM;gBACN,SAASa;gBACT,UAAUE;gBACVC;YACF;YACA,MAAMC,cAAcf,QAAQ,cAAc,CAAC,0BAA0B,CACnEc,MAAM,OAAO,EAAE,CAAC,EAAE,EAAE;YAEtB,MAAME,UAAUD,YAAY,OAAO,IAAI;YACvC,MAAME,oBAAoBF,YAAY,iBAAiB,IAAI;YAG3D,IAAID,MAAM,KAAK,EACbX,QAAQW,MAAM,KAAK;YAErB,IAAIA,MAAM,KAAK,EACbT,oBAAoBS,MAAM,KAAK;YAGjC,IAAIE,WAAWC,mBAAmB;gBAChChB,eAAee;gBACfd,wBAAwBe;gBACxB,MAAMC,YAAiC;oBACrCF;oBACAC;oBACAhB;oBACA,YAAY;oBACZ,OAAOkB;gBACT;gBACAtB,QAAQqB;YACV;QACF;QAEA,MAAME,mBAAmBC,oCAAoC;YAC3D,SAASpB;YACT,kBAAkBC;YAClB,+BACEF,QAAQ,cAAc,CAAC,6BAA6B;QACxD;QACAC,cAAcmB,oBAAoB;QAGlC,MAAME,aAAkC;YACtC,SAAS;YACTrB;YACA,mBAAmB;YACnB,YAAY;YACZE;QACF;QACAN,QAAQyB;IACV,EAAE,OAAOC,OAAO;QACd,MAAMC,wBAAwBC,QAAQF,QAAQjB;IAChD,SAAU;QACRC;IACF;IACA,OAAO;QACL,SAASN;QACT,kBAAkBC;QAClB,kBAAkBiB;QAClB,UAAUhB;QACVC;QACAC;IACF;AACF"}

package/dist/es/ai-model/service-caller/chat-completion/utils.mjs

@@ -0,0 +1,35 @@
+import { getDebug } from "@midscene/shared/logger";
+const applyImageDetail = ({ imageDetail, messages })=>{
+    if (!imageDetail) return messages;
+    return messages.map((msg)=>{
+        if (!Array.isArray(msg.content)) return msg;
+        const content = msg.content.map((part)=>{
+            if (part && 'image_url' === part.type && part.image_url?.url) return {
+                ...part,
+                image_url: {
+                    ...part.image_url,
+                    detail: imageDetail
+                }
+            };
+            return part;
+        });
+        return {
+            ...msg,
+            content
+        };
+    });
+};
+const hasUsableText = (value)=>'string' == typeof value && value.trim().length > 0;
+const resolveContentWithReasoningFallback = ({ content, reasoningContent, useReasoningAsContentFallback })=>{
+    if (!hasUsableText(content) && useReasoningAsContentFallback && hasUsableText(reasoningContent)) {
+        const warnCall = getDebug('ai:call', {
+            console: true
+        });
+        warnCall('empty content from AI model, using reasoning content');
+        return reasoningContent;
+    }
+    return content;
+};
+export { applyImageDetail, hasUsableText, resolveContentWithReasoningFallback };
+
+//# sourceMappingURL=utils.mjs.map

package/dist/es/ai-model/service-caller/chat-completion/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/service-caller/chat-completion/utils.mjs","sources":["../../../../../src/ai-model/service-caller/chat-completion/utils.ts"],"sourcesContent":["import { getDebug } from '@midscene/shared/logger';\nimport type { ChatCompletionMessageParam } from 'openai/resources/index';\nimport type { ImageDetail } from '../../model-adapter/types';\n\nexport const applyImageDetail = ({\n  imageDetail,\n  messages,\n}: {\n  imageDetail?: ImageDetail;\n  messages: ChatCompletionMessageParam[];\n}): ChatCompletionMessageParam[] => {\n  if (!imageDetail) {\n    return messages;\n  }\n\n  return messages.map((msg) => {\n    if (!Array.isArray(msg.content)) {\n      return msg;\n    }\n\n    const content = msg.content.map((part) => {\n      if (part && part.type === 'image_url' && part.image_url?.url) {\n        return {\n          ...part,\n          image_url: {\n            ...part.image_url,\n            detail: imageDetail,\n          },\n        };\n      }\n      return part;\n    });\n\n    return {\n      ...msg,\n      content,\n    } as ChatCompletionMessageParam;\n  });\n};\n\nexport const hasUsableText = (\n  value: string | null | undefined,\n): value is string => typeof value === 'string' && value.trim().length > 0;\n\nexport const resolveContentWithReasoningFallback = ({\n  content,\n  reasoningContent,\n  useReasoningAsContentFallback,\n}: {\n  content: string | undefined;\n  reasoningContent: string;\n  useReasoningAsContentFallback: boolean;\n}): string | undefined => {\n  if (\n    !hasUsableText(content) &&\n    useReasoningAsContentFallback &&\n    hasUsableText(reasoningContent)\n  ) {\n    const warnCall = getDebug('ai:call', { console: true });\n    warnCall('empty content from AI model, using reasoning content');\n    return reasoningContent;\n  }\n\n  return content;\n};\n"],"names":["applyImageDetail","imageDetail","messages","msg","Array","content","part","hasUsableText","value","resolveContentWithReasoningFallback","reasoningContent","useReasoningAsContentFallback","warnCall","getDebug"],"mappings":";AAIO,MAAMA,mBAAmB,CAAC,EAC/BC,WAAW,EACXC,QAAQ,EAIT;IACC,IAAI,CAACD,aACH,OAAOC;IAGT,OAAOA,SAAS,GAAG,CAAC,CAACC;QACnB,IAAI,CAACC,MAAM,OAAO,CAACD,IAAI,OAAO,GAC5B,OAAOA;QAGT,MAAME,UAAUF,IAAI,OAAO,CAAC,GAAG,CAAC,CAACG;YAC/B,IAAIA,QAAQA,AAAc,gBAAdA,KAAK,IAAI,IAAoBA,KAAK,SAAS,EAAE,KACvD,OAAO;gBACL,GAAGA,IAAI;gBACP,WAAW;oBACT,GAAGA,KAAK,SAAS;oBACjB,QAAQL;gBACV;YACF;YAEF,OAAOK;QACT;QAEA,OAAO;YACL,GAAGH,GAAG;YACNE;QACF;IACF;AACF;AAEO,MAAME,gBAAgB,CAC3BC,QACoB,AAAiB,YAAjB,OAAOA,SAAsBA,MAAM,IAAI,GAAG,MAAM,GAAG;AAElE,MAAMC,sCAAsC,CAAC,EAClDJ,OAAO,EACPK,gBAAgB,EAChBC,6BAA6B,EAK9B;IACC,IACE,CAACJ,cAAcF,YACfM,iCACAJ,cAAcG,mBACd;QACA,MAAME,WAAWC,SAAS,WAAW;YAAE,SAAS;QAAK;QACrDD,SAAS;QACT,OAAOF;IACT;IAEA,OAAOL;AACT"}

package/dist/es/ai-model/service-caller/codex/call-codex.mjs

@@ -0,0 +1,77 @@
+import { callAIWithCodexAppServer } from "./codex-app-server.mjs";
+const callCodex = async ({ messages, modelRuntime, options, recordEvent })=>{
+    const { config: modelConfig, adapter } = modelRuntime;
+    let protocolChunkSequence = 0;
+    const codexStartTime = Date.now();
+    const recordCodexEvent = recordEvent ? (event)=>{
+        if ('chunk' === event.type) {
+            protocolChunkSequence += 1;
+            recordEvent({
+                ...event,
+                attempt: 1,
+                sequence: protocolChunkSequence,
+                provider: 'codex-app-server'
+            });
+            return;
+        }
+        recordEvent({
+            ...event,
+            attempt: 1,
+            provider: 'codex-app-server'
+        });
+    } : void 0;
+    try {
+        const { config, imageDetail } = adapter.buildCodexAppServerParams({
+            intent: modelConfig.intent,
+            userConfig: {
+                reasoningEnabled: modelConfig.reasoningEnabled,
+                reasoningEffort: modelConfig.reasoningEffort,
+                reasoningBudget: modelConfig.reasoningBudget
+            },
+            requiresOriginalImageDetail: options?.requiresOriginalImageDetail
+        });
+        const codexResult = await callAIWithCodexAppServer(messages, modelConfig, {
+            stream: options?.stream,
+            onChunk: options?.onChunk,
+            params: config,
+            abortSignal: options?.abortSignal,
+            imageDetail,
+            onRecordEvent: recordCodexEvent
+        });
+        const { protocolMetadata, usage: rawUsage, ...response } = codexResult;
+        const timeCost = Date.now() - codexStartTime;
+        recordEvent?.({
+            type: 'response',
+            attempt: 1,
+            provider: 'codex-app-server',
+            final: {
+                content: response.content,
+                reasoningContent: response.reasoning_content,
+                usage: rawUsage,
+                timeCost,
+                protocol: protocolMetadata
+            }
+        });
+        return {
+            ...response,
+            rawUsage,
+            timeCost,
+            requestId: protocolMetadata.turnId
+        };
+    } catch (error) {
+        recordEvent?.({
+            type: 'error',
+            attempt: 1,
+            provider: 'codex-app-server',
+            error: error instanceof Error ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack
+            } : String(error)
+        });
+        throw error;
+    }
+};
+export { callCodex };
+
+//# sourceMappingURL=call-codex.mjs.map

package/dist/es/ai-model/service-caller/codex/call-codex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/service-caller/codex/call-codex.mjs","sources":["../../../../../src/ai-model/service-caller/codex/call-codex.ts"],"sourcesContent":["import type { ModelCallContext, ModelCallResult } from '../types';\nimport {\n  type CodexAppServerRecordEvent,\n  callAIWithCodexAppServer,\n} from './codex-app-server';\n\nexport const callCodex = async ({\n  messages,\n  modelRuntime,\n  options,\n  recordEvent,\n}: ModelCallContext): Promise<ModelCallResult> => {\n  const { config: modelConfig, adapter } = modelRuntime;\n  let protocolChunkSequence = 0;\n  const codexStartTime = Date.now();\n  const recordCodexEvent = recordEvent\n    ? (event: CodexAppServerRecordEvent) => {\n        if (event.type === 'chunk') {\n          protocolChunkSequence += 1;\n          recordEvent({\n            ...event,\n            attempt: 1,\n            sequence: protocolChunkSequence,\n            provider: 'codex-app-server',\n          });\n          return;\n        }\n\n        recordEvent({\n          ...event,\n          attempt: 1,\n          provider: 'codex-app-server',\n        });\n      }\n    : undefined;\n\n  try {\n    const { config, imageDetail } = adapter.buildCodexAppServerParams({\n      intent: modelConfig.intent,\n      userConfig: {\n        reasoningEnabled: modelConfig.reasoningEnabled,\n        reasoningEffort: modelConfig.reasoningEffort,\n        reasoningBudget: modelConfig.reasoningBudget,\n      },\n      requiresOriginalImageDetail: options?.requiresOriginalImageDetail,\n    });\n    const codexResult = await callAIWithCodexAppServer(messages, modelConfig, {\n      stream: options?.stream,\n      onChunk: options?.onChunk,\n      params: config,\n      abortSignal: options?.abortSignal,\n      imageDetail,\n      onRecordEvent: recordCodexEvent,\n    });\n    const { protocolMetadata, usage: rawUsage, ...response } = codexResult;\n    const timeCost = Date.now() - codexStartTime;\n    recordEvent?.({\n      type: 'response',\n      attempt: 1,\n      provider: 'codex-app-server',\n      final: {\n        content: response.content,\n        reasoningContent: response.reasoning_content,\n        usage: rawUsage,\n        timeCost,\n        protocol: protocolMetadata,\n      },\n    });\n    return {\n      ...response,\n      rawUsage,\n      timeCost,\n      requestId: protocolMetadata.turnId,\n    };\n  } catch (error) {\n    recordEvent?.({\n      type: 'error',\n      attempt: 1,\n      provider: 'codex-app-server',\n      error:\n        error instanceof Error\n          ? {\n              name: error.name,\n              message: error.message,\n              stack: error.stack,\n            }\n          : String(error),\n    });\n    throw error;\n  }\n};\n"],"names":["callCodex","messages","modelRuntime","options","recordEvent","modelConfig","adapter","protocolChunkSequence","codexStartTime","Date","recordCodexEvent","event","undefined","config","imageDetail","codexResult","callAIWithCodexAppServer","protocolMetadata","rawUsage","response","timeCost","error","Error","String"],"mappings":";AAMO,MAAMA,YAAY,OAAO,EAC9BC,QAAQ,EACRC,YAAY,EACZC,OAAO,EACPC,WAAW,EACM;IACjB,MAAM,EAAE,QAAQC,WAAW,EAAEC,OAAO,EAAE,GAAGJ;IACzC,IAAIK,wBAAwB;IAC5B,MAAMC,iBAAiBC,KAAK,GAAG;IAC/B,MAAMC,mBAAmBN,cACrB,CAACO;QACC,IAAIA,AAAe,YAAfA,MAAM,IAAI,EAAc;YAC1BJ,yBAAyB;YACzBH,YAAY;gBACV,GAAGO,KAAK;gBACR,SAAS;gBACT,UAAUJ;gBACV,UAAU;YACZ;YACA;QACF;QAEAH,YAAY;YACV,GAAGO,KAAK;YACR,SAAS;YACT,UAAU;QACZ;IACF,IACAC;IAEJ,IAAI;QACF,MAAM,EAAEC,MAAM,EAAEC,WAAW,EAAE,GAAGR,QAAQ,yBAAyB,CAAC;YAChE,QAAQD,YAAY,MAAM;YAC1B,YAAY;gBACV,kBAAkBA,YAAY,gBAAgB;gBAC9C,iBAAiBA,YAAY,eAAe;gBAC5C,iBAAiBA,YAAY,eAAe;YAC9C;YACA,6BAA6BF,SAAS;QACxC;QACA,MAAMY,cAAc,MAAMC,yBAAyBf,UAAUI,aAAa;YACxE,QAAQF,SAAS;YACjB,SAASA,SAAS;YAClB,QAAQU;YACR,aAAaV,SAAS;YACtBW;YACA,eAAeJ;QACjB;QACA,MAAM,EAAEO,gBAAgB,EAAE,OAAOC,QAAQ,EAAE,GAAGC,UAAU,GAAGJ;QAC3D,MAAMK,WAAWX,KAAK,GAAG,KAAKD;QAC9BJ,cAAc;YACZ,MAAM;YACN,SAAS;YACT,UAAU;YACV,OAAO;gBACL,SAASe,SAAS,OAAO;gBACzB,kBAAkBA,SAAS,iBAAiB;gBAC5C,OAAOD;gBACPE;gBACA,UAAUH;YACZ;QACF;QACA,OAAO;YACL,GAAGE,QAAQ;YACXD;YACAE;YACA,WAAWH,iBAAiB,MAAM;QACpC;IACF,EAAE,OAAOI,OAAO;QACdjB,cAAc;YACZ,MAAM;YACN,SAAS;YACT,UAAU;YACV,OACEiB,iBAAiBC,QACb;gBACE,MAAMD,MAAM,IAAI;gBAChB,SAASA,MAAM,OAAO;gBACtB,OAAOA,MAAM,KAAK;YACpB,IACAE,OAAOF;QACf;QACA,MAAMA;IACR;AACF"}

package/dist/es/ai-model/service-caller/{codex-app-server.mjs → codex/codex-app-server.mjs}

@@ -176,7 +176,6 @@ class CodexAppServerConnection {
         return this.closed;
     }
     async runTurn({ messages, modelConfig, stream, onChunk, params, abortSignal, imageDetail, onRecordEvent }) {
-        const startTime = Date.now();
         const timeoutMs = modelConfig.timeout || CODEX_DEFAULT_TIMEOUT_MS;
         const deadlineAt = Date.now() + timeoutMs;
         const isStreaming = !!(stream && onChunk);
@@ -319,12 +318,7 @@ class CodexAppServerConnection {
                     continue;
                 }
                 if ('thread/tokenUsage/updated' === method && params.threadId === threadId && params.turnId === turnId) {
-                    latestUsage = this.mapUsage({
-                        usage: params,
-                        modelConfig,
-                        turnId,
-                        startTime
-                    });
+                    latestUsage = this.mapUsage(params);
                     continue;
                 }
                 if ('turn/completed' === method && params.threadId === threadId && params.turn?.id === turnId) {
@@ -431,23 +425,20 @@ class CodexAppServerConnection {
             method: 'initialized'
         });
     }
-    mapUsage({ usage, modelConfig, turnId, startTime }) {
+    mapUsage(usage) {
         const tokenUsage = usage.tokenUsage;
         const picked = tokenUsage?.last || tokenUsage?.total;
         if (!picked) return;
         return {
-            ...picked,
             prompt_tokens: picked.inputTokens ?? 0,
             completion_tokens: picked.outputTokens ?? 0,
             total_tokens: picked.totalTokens ?? 0,
-            cached_input: picked.cachedInputTokens ?? 0,
-            time_cost: Date.now() - startTime,
-            model_name: modelConfig.modelName,
-            model_description: modelConfig.modelDescription,
-            response_model_name: void 0,
-            slot: modelConfig.slot,
-            intent: void 0,
-            request_id: turnId
+            prompt_tokens_details: {
+                cached_tokens: picked.cachedInputTokens ?? 0
+            },
+            completion_tokens_details: {
+                reasoning_tokens: picked.reasoningOutputTokens ?? 0
+            }
         };
     }
     isRequestMessage(message) {