mixdog 0.9.0 → 0.9.2

package/src/runtime/agent/orchestrator/providers/openai-compat.mjs

@@ -1,7 +1,8 @@
-import OpenAI from 'openai';
+import { createRequire } from 'node:module';
 import { createHash } from 'crypto';
 import { loadConfig } from '../config.mjs';
-import { withRetry } from './retry-classifier.mjs';
+import { shouldFallbackTransport, withRetry } from './retry-classifier.mjs';
+import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { sendViaWebSocket } from './openai-oauth-ws.mjs';
 import {
     consumeCompatChatCompletionStream,
@@ -32,6 +33,17 @@ import {
     customToolCallFromResponseItem,
 } from './custom-tool-wire.mjs';
 import { OPENAI_COMPAT_PRESETS } from './openai-compat-presets.mjs';
+
+const requireOpenAI = createRequire(import.meta.url);
+let _OpenAI = null;
+
+function loadOpenAI() {
+    if (!_OpenAI) {
+        const mod = requireOpenAI('openai');
+        _OpenAI = mod.default || mod.OpenAI || mod;
+    }
+    return _OpenAI;
+}
 export { OPENAI_COMPAT_PRESETS } from './openai-compat-presets.mjs';
 const PRESETS = OPENAI_COMPAT_PRESETS;
 const MODEL_LIST_TIMEOUT_MS = resolveTimeoutMs(
@@ -246,33 +258,14 @@ function _envFlag(name, fallback = true) {
     return !['0', 'false', 'off', 'no'].includes(String(raw).toLowerCase());
 }
 
+// xAI WS→HTTP transport fallback → shared shouldFallbackTransport
+// (retry-classifier.mjs). Identical deny-order + allow-list; the per-provider
+// env flag is computed here and passed via `enabled`.
 function _shouldFallbackXaiWsToHttp(err, signal) {
-    if (!_envFlag('MIXDOG_XAI_WS_HTTP_FALLBACK', true)) return false;
-    if (signal?.aborted) return false;
-    if (err?.liveTextEmitted === true) return false;
-    if (err?.emittedToolCall === true || err?.unsafeToRetry === true) return false;
-    const status = Number(err?.httpStatus || err?.status || 0);
-    if (status === 401 || status === 403 || status === 404 || status === 429) return false;
-    if (status >= 500 && status < 600) return true;
-    const code = String(err?.code || '');
-    if (['EWSACQUIRETIMEOUT', 'ETIMEDOUT', 'ESOCKETTIMEDOUT', 'ECONNRESET', 'EAI_AGAIN', 'ENOTFOUND', 'EAI_NODATA', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH', 'EPIPE'].includes(code)) {
-        return true;
-    }
-    const classifier = String(err?.retryClassifier || err?.midstreamClassifier || '');
-    if ([
-        'timeout', 'reset', 'dns', 'refused', 'network', 'acquire_timeout', 'http_5xx',
-        'first_byte_timeout', 'first_meaningful_timeout',
-        'ws_1006', 'ws_1011', 'ws_1012', 'ws_1000', 'ws_4000', 'agent_stall', 'stream_stalled',
-        'response_failed_disconnected', 'response_failed_network', 'response_failed_auth_expired',
-        'ws_send_failed',
-    ].includes(classifier)) {
-        return true;
-    }
-    if (/^http_5\d\d$/.test(classifier)) return true;
-    if (err?.firstByteTimeout) return true;
-    if (err?.firstMeaningfulTimeout) return true;
-    const msg = String(err?.message || '');
-    return /opening handshake has timed out|socket hang up|acquire timed out|no first server event|no meaningful output/i.test(msg);
+    return shouldFallbackTransport(err, {
+        signal,
+        enabled: _envFlag('MIXDOG_XAI_WS_HTTP_FALLBACK', true),
+    });
 }
 
 function useXaiResponsesWebSocketWarmup(opts, config, { previousResponseId, instructions, rawTools }) {
@@ -989,6 +982,25 @@ function nativeResponsesTools(opts) {
         ? opts.nativeTools.filter(t => t && typeof t === 'object')
         : [];
 }
+// Known tool-name sets for the leaked-tool-call guard, derived from the exact
+// request body so a recovered leaked call is only synthesized when it names a
+// tool the model was actually offered. Chat tools nest the name under
+// `function.name`; Responses tools carry a top-level `name`.
+function knownToolNamesFromOpenAITools(tools) {
+    return new Set(
+        (Array.isArray(tools) ? tools : [])
+            .map((t) => (typeof t?.function?.name === 'string' ? t.function.name
+                : typeof t?.name === 'string' ? t.name : null))
+            .filter(Boolean),
+    );
+}
+function knownToolNamesFromResponsesTools(tools) {
+    return new Set(
+        (Array.isArray(tools) ? tools : [])
+            .map((t) => (typeof t?.name === 'string' ? t.name : null))
+            .filter(Boolean),
+    );
+}
 export function parseToolCalls(choice, label) {
     const calls = choice.message?.tool_calls;
     if (!calls?.length)
@@ -1217,10 +1229,20 @@ export class OpenAICompatProvider {
         // extraHeaders behave exactly as before.
         this.defaultHeaders = { ...(preset?.extraHeaders || {}), ...(config.extraHeaders || {}) };
         this.defaultModel = preset?.defaultModel || 'default';
-        this.client = new OpenAI({
+        this.client = new (loadOpenAI())({
             baseURL,
             apiKey,
             defaultHeaders: this.defaultHeaders,
+            // The SDK's own retry loop (default 2) would nest underneath our
+            // withRetry wrapper and multiply tail latency on a transient
+            // backend. We own retry/backoff via withRetry, so disable the SDK's.
+            maxRetries: 0,
+            // Force the shared long-keepalive undici dispatcher to be installed
+            // globally (setGlobalDispatcher) so the SDK's global fetch rides a
+            // warm socket pool instead of Node's short-keepalive default. The
+            // return value is undefined once installed globally; the option is
+            // a harmless no-op then.
+            fetchOptions: { dispatcher: getLlmDispatcher() },
         });
     }
     reloadApiKey() {
@@ -1235,10 +1257,12 @@ export class OpenAICompatProvider {
                 this.baseURL = baseURL;
                 this.apiKey = newKey;
                 this.defaultHeaders = { ...(preset?.extraHeaders || {}), ...(this.config.extraHeaders || {}) };
-                this.client = new OpenAI({
+                this.client = new (loadOpenAI())({
                     baseURL,
                     apiKey: newKey,
                     defaultHeaders: this.defaultHeaders,
+                    maxRetries: 0,
+                    fetchOptions: { dispatcher: getLlmDispatcher() },
                 });
             }
         } catch { /* best effort */ }
@@ -1258,6 +1282,11 @@ export class OpenAICompatProvider {
     async _doSend(messages, model, tools, sendOpts) {
         const useModel = model || this.defaultModel;
         const opts = sendOpts || {};
+        // Re-warm a kept-alive socket to the provider origin before the turn so
+        // the request hot path lands on a live socket instead of paying a cold
+        // TLS handshake after an idle gap. Fire-and-forget; never awaited. This
+        // mirrors anthropic-oauth's send()-start preconnect.
+        preconnect(this.baseURL);
         if (this.name === 'xai' && useXaiResponsesApi(opts, this.config)) {
             if (useXaiResponsesWebSocket(opts, this.config)) {
                 try {
@@ -1358,6 +1387,11 @@ export class OpenAICompatProvider {
                         ({ signal: openSignal }) => this.client.chat.completions.create(params, { signal: openSignal }),
                         {
                             signal: attemptSignal,
+                            // Single attempt: this inner wrapper exists only to
+                            // apply the first-byte per-attempt timeout. Retry is
+                            // owned by the outer withRetry — nesting retry loops
+                            // here multiplied tail latency (5x5).
+                            maxAttempts: 1,
                             perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
                             perAttemptLabel: `${this.name} first byte`,
                         },
@@ -1370,6 +1404,10 @@ export class OpenAICompatProvider {
                         onToolCall: opts.onToolCall,
                         onTextDelta: opts.onTextDelta,
                         parseToolCalls,
+                        // Known tool names for the leaked-tool-call guard:
+                        // recovered leaked calls only synthesize when they name
+                        // a tool actually offered to this request.
+                        knownToolNames: knownToolNamesFromOpenAITools(params.tools),
                     });
                 },
                 {
@@ -1453,6 +1491,13 @@ export class OpenAICompatProvider {
             model: response.model || useModel,
             toolCalls,
             stopReason,
+            // P1 audit fix: a text-only completion that hit finish_reason=
+            // 'length' (no tool calls, so not thrown above as
+            // ProviderIncompleteError) previously returned as an ordinary
+            // success with no signal that the content is a mid-sentence
+            // cutoff. Flag it so loop.mjs can surface a one-line warning
+            // instead of silently treating a truncated answer as complete.
+            ...(stopReason === 'length' && (assembled.content || '').length > 0 ? { truncated: true } : {}),
             ...(reasoningContent ? { reasoningContent } : {}),
             usage: response.usage ? (() => {
                 const input = response.usage.prompt_tokens ?? response.usage.input_tokens ?? 0;
@@ -1535,6 +1580,9 @@ export class OpenAICompatProvider {
                             ({ signal: openSignal }) => this.client.responses.create(params, { signal: openSignal }),
                             {
                                 signal: attemptSignal,
+                                // Single attempt: first-byte timeout only; retry
+                                // is owned by the outer withRetry (see chat path).
+                                maxAttempts: 1,
                                 perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
                                 perAttemptLabel: 'xai responses first byte',
                             },
@@ -1548,6 +1596,7 @@ export class OpenAICompatProvider {
                             onTextDelta: opts.onTextDelta,
                             parseResponsesToolCalls,
                             responseOutputText,
+                            knownToolNames: knownToolNamesFromResponsesTools(params.tools),
                         });
                     },
                     {
@@ -1617,6 +1666,10 @@ export class OpenAICompatProvider {
             model: response.model || useModel,
             toolCalls,
             stopReason: streamed.stopReason || null,
+            // P1 audit fix: mirror the chat-completions truncated flag for
+            // the xAI Responses HTTP path — a max-output cutoff with real
+            // content must not look identical to a clean stop.
+            ...(streamed.stopReason === 'length' && (streamed.content || '').length > 0 ? { truncated: true } : {}),
             citations: searchSources.citations.length ? searchSources.citations : undefined,
             webSearchCalls: searchSources.webSearchCalls.length ? searchSources.webSearchCalls : undefined,
             providerState: {
@@ -1772,6 +1825,9 @@ export class OpenAICompatProvider {
             model: result.model || useModel,
             toolCalls: result.toolCalls,
             stopReason: result.stopReason || null,
+            // P1 audit fix: same truncated signal as the HTTP path (see
+            // _doSendXaiResponses above) for the WebSocket transport.
+            ...(result.stopReason === 'length' && (result.content || '').length > 0 ? { truncated: true } : {}),
             providerState: {
                 ...(opts.providerState || {}),
                 xaiResponses: {