mixdog 0.9.147 → 0.9.149

package/src/runtime/agent/orchestrator/providers/openai-codex-identity.test.mjs

@@ -8,7 +8,10 @@ import {
     mintUuidV7,
 } from '../session/manager/session-id.mjs';
 import { buildStableProviderPromptCacheKey } from '../agent-runtime/cache-strategy.mjs';
-import { _withCodexWsClientMetadata } from './openai-codex-metadata.mjs';
+import {
+    _codexWsCompatibilityHeaders,
+    _withCodexWsClientMetadata,
+} from './openai-codex-metadata.mjs';
 import { codexOriginator, codexUserAgent } from './codex-client-meta.mjs';
 
 test('Codex wire identity is a real time-based UUIDv7 and remains session-stable', () => {
@@ -26,14 +29,7 @@ test('Codex wire identity is a real time-based UUIDv7 and remains session-stable
     assert.equal(ensureCodexWireSessionId(session), sessionId);
 });
 
-test('Codex cache key and every wire session identity use the same UUIDv7', (t) => {
-    const previousParity = process.env.MIXDOG_OAI_CODEX_WIRE_PARITY;
-    process.env.MIXDOG_OAI_CODEX_WIRE_PARITY = '1';
-    t.after(() => {
-        if (previousParity == null) delete process.env.MIXDOG_OAI_CODEX_WIRE_PARITY;
-        else process.env.MIXDOG_OAI_CODEX_WIRE_PARITY = previousParity;
-    });
-
+test('Codex cache key and every wire session identity use the same UUIDv7', () => {
     const sessionId = mintUuidV7();
     const turnStartedAtUnixMs = Date.now();
     const turnId = mintUuidV7(turnStartedAtUnixMs);
@@ -80,11 +76,38 @@ test('Codex cache key and every wire session identity use the same UUIDv7', (t)
     assert.equal(turnMetadata.session_id, sessionId);
     assert.equal(turnMetadata.thread_id, sessionId);
     assert.equal(turnMetadata.turn_id, turnId);
+    assert.match(turnMetadata.installation_id, /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
     assert.equal(turnMetadata.agent_name, '/root');
     assert.equal(turnMetadata.sandbox, 'none');
     assert.equal(turnMetadata.sandbox_mode, 'danger-full-access');
     assert.equal(turnMetadata.auto_review_enabled, false);
+    assert.equal(turnMetadata.node_repl_auto_review_required, false);
+    assert.equal(turnMetadata.node_repl_disabled, false);
     assert.equal(turnMetadata.turn_started_at_unix_ms, turnStartedAtUnixMs);
+
+    const prewarmHeaders = _codexWsCompatibilityHeaders({
+        cacheKey: promptCacheKey,
+        poolKey: session.id,
+        model: 'gpt-5.6-sol',
+        handshake: true,
+        useResponsesLite: true,
+        sendOpts: {
+            codexSessionId: sessionId,
+            codexThreadId: sessionId,
+            requestKind: 'prewarm',
+            session,
+        },
+    });
+    assert.equal(prewarmHeaders['session-id'], sessionId);
+    assert.equal(prewarmHeaders['thread-id'], sessionId);
+    assert.equal(prewarmHeaders['x-client-request-id'], sessionId);
+    assert.equal('x-codex-installation-id' in prewarmHeaders, false);
+    assert.equal('x-openai-internal-codex-responses-lite' in prewarmHeaders, false);
+    const prewarmMetadata = JSON.parse(prewarmHeaders['x-codex-turn-metadata']);
+    assert.equal(prewarmMetadata.request_kind, 'prewarm');
+    assert.equal(prewarmMetadata.turn_id, '');
+    assert.equal(prewarmMetadata.installation_id, turnMetadata.installation_id);
+    assert.equal('turn_started_at_unix_ms' in prewarmMetadata, false);
 });
 
 // A compaction summary is a request of the same session: same thread identity,

package/src/runtime/agent/orchestrator/providers/openai-codex-metadata.mjs

@@ -2,7 +2,13 @@
 // installation/session/thread/turn identity block that rides every frame, its
 // handshake-header projection, and the per-turn x-codex-turn-state guard.
 // Extracted from openai-oauth-ws.mjs, which now owns transport flow only.
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getPluginData } from '../config.mjs';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+let _installationId = null;
 
 function _cleanMetaString(value) {
     return typeof value === 'string' ? value.trim() : '';
@@ -49,8 +55,38 @@ function _codexRequestKind(sendOpts, sessionId) {
 }
 
 function _codexInstallationId(sendOpts) {
-    return _cleanMetaString(sendOpts?.installationId || sendOpts?.codexInstallationId || process.env.MIXDOG_CODEX_INSTALLATION_ID)
-        || `mixdog-${_hashText(`${process.env.USERPROFILE || process.env.HOME || ''}:${process.cwd()}`, 32)}`;
+    const explicit = _cleanMetaString(
+        sendOpts?.installationId
+        || sendOpts?.codexInstallationId
+        || process.env.MIXDOG_CODEX_INSTALLATION_ID,
+    ).toLowerCase();
+    if (UUID_RE.test(explicit)) return explicit;
+    if (_installationId) return _installationId;
+    const dir = getPluginData();
+    const file = join(dir, 'installation_id');
+    try {
+        const existing = existsSync(file) ? readFileSync(file, 'utf8').trim().toLowerCase() : '';
+        if (UUID_RE.test(existing)) {
+            _installationId = existing;
+            return _installationId;
+        }
+    } catch {}
+    const generated = randomUUID();
+    try {
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+        try {
+            writeFileSync(file, generated, { encoding: 'utf8', flag: 'wx', mode: 0o644 });
+        } catch {
+            const winner = readFileSync(file, 'utf8').trim().toLowerCase();
+            if (UUID_RE.test(winner)) {
+                _installationId = winner;
+                return _installationId;
+            }
+            writeFileSync(file, generated, { encoding: 'utf8', mode: 0o644 });
+        }
+    } catch {}
+    _installationId = generated;
+    return _installationId;
 }
 
 // The identity block is rebuilt per request: never cached on the pooled
@@ -75,51 +111,42 @@ function _codexMetadataBase(entry, { poolKey, cacheKey, sendOpts, handshake = fa
     )
         || rawSessionId;
     const rawInstallationId = _codexInstallationId(sendOpts);
-    const wireParity = process.env.MIXDOG_OAI_CODEX_WIRE_PARITY === '1';
-    const sessionId = wireParity ? _codexUuidV7(rawSessionId) : rawSessionId;
-    const threadId = wireParity ? _codexUuidV7(rawThreadId) : rawThreadId;
-    const installationId = wireParity ? _codexUuidV7(rawInstallationId) : rawInstallationId;
+    const sessionId = _codexUuidV7(rawSessionId);
+    const threadId = _codexUuidV7(rawThreadId);
+    const installationId = rawInstallationId;
     const startedAt = Number.isFinite(Number(sendOpts?.turnStartedAtUnixMs))
         ? Math.floor(Number(sendOpts.turnStartedAtUnixMs))
         : _sessionStartedAtUnixMs(rawSessionId);
     const requestKind = _codexRequestKind(sendOpts, rawSessionId);
     // The reference client opens the WS with a prewarm (empty turn_id) BEFORE
-    // the real turn. Under wire parity the handshake IS that prewarm, so its
-    // turn_id empties and its request_kind becomes 'prewarm' instead of
-    // presenting the handshake as a live turn. Parity off is unchanged.
+    // the real turn, so the handshake is always identified as a prewarm rather
+    // than as a live turn.
     const isPrewarm = requestKind === 'prewarm' || handshake === true;
     const rawExplicitTurnId = _cleanMetaString(sendOpts?.turnId || sendOpts?.codexTurnId || sendOpts?.session?.turnId);
     const explicitWindowId = _cleanMetaString(sendOpts?.windowId || sendOpts?.codexWindowId || sendOpts?.session?.windowId);
-    const turnId = wireParity && isPrewarm
+    const turnId = isPrewarm
         ? ''
-        : wireParity
-            ? _codexUuidV7(rawExplicitTurnId || `${rawSessionId}:turn`)
-            : (rawExplicitTurnId || sessionId);
-    const effectiveRequestKind = wireParity && isPrewarm ? 'prewarm' : requestKind;
+        : _codexUuidV7(rawExplicitTurnId || `${rawSessionId}:turn`);
+    const effectiveRequestKind = isPrewarm ? 'prewarm' : requestKind;
     // Window id is `<thread-id>:<auto-compact window number>`, and that counter
     // starts at 0: a thread that never auto-compacted reports generation 0 and
-    // only advances when a new context window opens. The legacy non-parity
-    // wire kept :1 and is left alone so measured default behavior is unchanged.
-    const windowId = explicitWindowId || `${threadId}:${wireParity ? 0 : 1}`;
+    // only advances when a new context window opens.
+    const windowId = explicitWindowId || `${threadId}:0`;
     const turnMetadata = {
         installation_id: installationId,
         session_id: sessionId,
         thread_id: threadId,
+        agent_name: '/root',
         turn_id: turnId,
         window_id: windowId,
         request_kind: effectiveRequestKind,
-        // Turn-metadata fields the reference client fills on every request.
-        // They were behind a probe knob after a 2026-07-04 A/B showed no
-        // isolated effect; they are unconditional now because a partial blob is
-        // a shape no real client sends. Absolute agent path, not a bare name;
-        // the sandbox pair reports this runtime honestly (tools run with full
-        // host access, so there is no sandbox to declare).
-        agent_name: '/root',
         thread_source: 'user',
         sandbox: 'none',
         sandbox_mode: 'danger-full-access',
         auto_review_enabled: false,
-        turn_started_at_unix_ms: startedAt,
+        node_repl_auto_review_required: false,
+        node_repl_disabled: false,
+        ...(!isPrewarm ? { turn_started_at_unix_ms: startedAt } : {}),
     };
     return {
         'x-codex-installation-id': installationId,
@@ -144,16 +171,18 @@ export function _metadataTrace(metadata) {
     };
 }
 
-// Handshake projection of the same identity: window id, the turn-metadata
-// blob, the installation id, and the routing hint. The reference client sends
-// all of them on every request, and a 2026-07-04 A/B measured the blob alone
-// lifting prefix-cache hits.
+// The WebSocket handshake carries compatibility identity and routing fields.
+// Installation and Responses Lite data stay in per-request client_metadata.
 export function _codexWsCompatibilityHeaders(context = {}) {
     const metadata = _codexMetadataBase(null, context);
     const headers = {};
+    if (metadata.session_id) headers['session-id'] = metadata.session_id;
+    if (metadata.thread_id) {
+        headers['thread-id'] = metadata.thread_id;
+        headers['x-client-request-id'] = metadata.thread_id;
+    }
     if (metadata['x-codex-window-id']) headers['x-codex-window-id'] = metadata['x-codex-window-id'];
     if (metadata['x-codex-turn-metadata']) headers['x-codex-turn-metadata'] = metadata['x-codex-turn-metadata'];
-    if (metadata['x-codex-installation-id']) headers['x-codex-installation-id'] = metadata['x-codex-installation-id'];
     // Routing hint. The reference client attaches this to EVERY request whose
     // auth is the ChatGPT backend — no flag, no mode, and with `model=` alone
     // when no service tier is selected. It is how the backend lands the request
@@ -177,9 +206,14 @@ export function _codexWsCompatibilityHeaders(context = {}) {
 export function _withCodexWsClientMetadata(frame, entry, enabled, context = {}) {
     if (!enabled || !frame || typeof frame !== 'object') return frame;
     const base = _codexMetadataBase(entry, context);
+    const requestKind = _codexRequestKind(context?.sendOpts, context?.poolKey || '');
+    const isPrewarmRequest = requestKind === 'prewarm';
     const metadata = {
         ...base,
         ...(frame.client_metadata && typeof frame.client_metadata === 'object' ? frame.client_metadata : {}),
+        ...(context?.useResponsesLite === true
+            ? { ws_request_header_x_openai_internal_codex_responses_lite: 'true' }
+            : {}),
         'x-codex-ws-stream-request-start-ms': String(Date.now()),
     };
     if (entry && typeof entry === 'object') {
@@ -192,10 +226,21 @@ export function _withCodexWsClientMetadata(frame, entry, enabled, context = {})
             if (entry.turnStateTurnId == null) {
                 entry.turnStateTurnId = base.turn_id;
             } else if (entry.turnStateTurnId !== base.turn_id) {
-                entry.turnState = null;
-                entry.turnStateTurnId = null;
+                // Codex startup prewarm owns the handshake turn-state until
+                // the first real turn consumes that prewarmed client session.
+                // Adopt it once across prewarm→turn; ordinary turn changes
+                // still retire the old token.
+                if (entry.turnStateFromPrewarm === true && !isPrewarmRequest) {
+                    entry.turnStateTurnId = base.turn_id;
+                } else {
+                    entry.turnState = null;
+                    entry.turnStateTurnId = null;
+                }
             }
         }
+        if (!isPrewarmRequest && entry.turnStateFromPrewarm === true) {
+            entry.turnStateFromPrewarm = false;
+        }
         entry.currentTurnId = base.turn_id;
     }
     if (entry?.turnState) metadata['x-codex-turn-state'] = String(entry.turnState);

package/src/runtime/agent/orchestrator/providers/openai-codex-model.mjs

@@ -7,6 +7,23 @@
  * _displayCodexModel for existing importers.
  */
 
+const CODEX_RESPONSES_LITE_CAPABILITY = Object.freeze({
+    'gpt-5.6-sol': true,
+    'gpt-5.6-terra': true,
+    'gpt-5.6-luna': true,
+    'gpt-5.5': false,
+    'gpt-5.4': false,
+    'gpt-5.4-mini': false,
+    'gpt-5.2': false,
+    'codex-auto-review': false,
+});
+
+export function _codexUsesResponsesLite(id, modelInfo = null) {
+    const explicit = modelInfo?.useResponsesLite ?? modelInfo?.use_responses_lite;
+    if (typeof explicit === 'boolean') return explicit;
+    return CODEX_RESPONSES_LITE_CAPABILITY[String(id || '').trim()] === true;
+}
+
 // OAuth catalog returns dated ids (gpt-5.4-mini-2026-03-17). Strip the trailing
 // -YYYY-MM-DD to get the version alias (gpt-5.4-mini). Unknown shapes pass
 // through unchanged.
@@ -82,6 +99,10 @@ export function _normalizeCodexModel(m) {
         latest: false,
         description: m?.description || '',
         reasoningLevels: (m?.supported_reasoning_levels || []).map(r => r.effort),
+        supportVerbosity: m?.support_verbosity === true,
+        defaultVerbosity: m?.default_verbosity || null,
+        useResponsesLite: m?.use_responses_lite === true,
+        supportsReasoningSummaries: m?.supports_reasoning_summaries === true,
         serviceTiers,
         defaultServiceTier: m?.default_service_tier || null,
         additionalSpeedTiers,

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

@@ -152,11 +152,16 @@ function mergeToolCallDelta(accByIndex, deltaCalls, bucketState) {
         } else if (tc.function?.name) {
             const anonId = ++bucketState._nextAnonId;
             key = `anon:${anonId}`;
-            bucketState._lastAnonKey = key;
         } else {
             key = bucketState._lastAnonKey;
             if (!key) continue;
         }
+        // Whatever bucket this chunk resolved to becomes the continuation
+        // target for later argument-only chunks (no index, no id, no name).
+        // Only the anonymous branch used to record it, so a provider that
+        // identifies a tool call by id alone and then streams bare argument
+        // deltas had every one of those deltas silently discarded.
+        bucketState._lastAnonKey = key;
         let prev = accByIndex.get(key);
         if (!prev) {
             prev = {
@@ -210,7 +215,7 @@ function emitCompatToolCallOnce(state, call, onToolCall) {
     // Fix 2: cross-path name+args dedupe. A synthesized text-leaked call and an
     // identical native tool_call must fire onToolCall exactly once. state._toolDedupe
     // is created per stream; when absent (older callers) behavior is unchanged.
-    if (state._toolDedupe && !state._toolDedupe.shouldDispatch(call.name, call.arguments)) {
+    if (state._toolDedupe && !state._toolDedupe.shouldDispatch(call.name, call.arguments, call.id)) {
         // Still mark the id as emitted so later id-frames for the same native
         // call don't retry, but do NOT invoke onToolCall (already dispatched).
         state.emittedToolCallKeys.add(key);
@@ -556,6 +561,33 @@ export async function consumeCompatChatCompletionStream(stream, {
     };
 }
 
+// Reconcile a COMPLETED function_call item into state.toolCalls: fill in the
+// id/name a streamed call may still be missing, or adopt the item as a new
+// call. `response.output_item.done` and the `response.completed` sweep see the
+// same item shape and must land on the same single emit, so both route here.
+// Returns the item id the done-branch still needs for its pendingCalls /
+// tool-tracker bookkeeping.
+function reconcileCompatFunctionCallItem(state, item, label, onToolCall) {
+    const itemId = item.id || '';
+    const tc = state.toolCalls.find(t => t._pendingItemId === itemId)
+        || (item.call_id ? state.toolCalls.find(t => t.id === item.call_id) : null);
+    if (tc) {
+        if (!tc.id && item.call_id) tc.id = item.call_id;
+        if (!tc.name && item.name) tc.name = item.name;
+        if (tc.id && tc.name) delete tc._pendingItemId;
+        emitCompatToolCallOnce(state, tc, onToolCall);
+    } else if (item.call_id && item.name) {
+        const call = {
+            id: item.call_id,
+            name: item.name,
+            arguments: parseCompletedToolCallArgumentsJson(item.arguments, label, { id: item.call_id, name: item.name, finishReason: 'done' }),
+        };
+        state.toolCalls.push(call);
+        emitCompatToolCallOnce(state, call, onToolCall);
+    }
+    return itemId;
+}
+
 function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesToolCalls, responseOutputText, onStreamDelta, onToolCall, onTextDelta, relayLeakText }) {
     if (!event || typeof event.type !== 'string') return;
     const pushToolSearchCall = (item) => {
@@ -671,23 +703,7 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         case 'response.output_item.done': {
             const item = event.item || {};
             if (item.type === 'function_call') {
-                const itemId = item.id || '';
-                const tc = state.toolCalls.find(t => t._pendingItemId === itemId)
-                    || (item.call_id ? state.toolCalls.find(t => t.id === item.call_id) : null);
-                if (tc) {
-                    if (!tc.id && item.call_id) tc.id = item.call_id;
-                    if (!tc.name && item.name) tc.name = item.name;
-                    if (tc.id && tc.name) delete tc._pendingItemId;
-                    emitCompatToolCallOnce(state, tc, onToolCall);
-                } else if (item.call_id && item.name) {
-                    const call = {
-                        id: item.call_id,
-                        name: item.name,
-                        arguments: parseCompletedToolCallArgumentsJson(item.arguments, label, { id: item.call_id, name: item.name, finishReason: 'done' }),
-                    };
-                    state.toolCalls.push(call);
-                    emitCompatToolCallOnce(state, call, onToolCall);
-                }
+                const itemId = reconcileCompatFunctionCallItem(state, item, label, onToolCall);
                 // Drop the resolved function item from pendingCalls before
                 // recomputing toolInFlight — otherwise a completed call keeps
                 // pendingCalls.size > 0 and the latch never clears, so a later
@@ -732,23 +748,7 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
             }
             for (const item of resp.output || []) {
                 if (item?.type === 'function_call') {
-                    const itemId = item.id || '';
-                    const tc = state.toolCalls.find(t => t._pendingItemId === itemId)
-                        || (item.call_id ? state.toolCalls.find(t => t.id === item.call_id) : null);
-                    if (tc) {
-                        if (!tc.id && item.call_id) tc.id = item.call_id;
-                        if (!tc.name && item.name) tc.name = item.name;
-                        if (tc.id && tc.name) delete tc._pendingItemId;
-                        emitCompatToolCallOnce(state, tc, onToolCall);
-                    } else if (item.call_id && item.name) {
-                        const call = {
-                            id: item.call_id,
-                            name: item.name,
-                            arguments: parseCompletedToolCallArgumentsJson(item.arguments, label, { id: item.call_id, name: item.name, finishReason: 'done' }),
-                        };
-                        state.toolCalls.push(call);
-                        emitCompatToolCallOnce(state, call, onToolCall);
-                    }
+                    reconcileCompatFunctionCallItem(state, item, label, onToolCall);
                     try { onStreamDelta?.('tool'); } catch {}
                     reportedBundleProgress = true;
                 } else if (item?.type === 'tool_search_call') {

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

@@ -44,13 +44,15 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
     // strict providers (xai) reject unknown roles/types and would 400 the
     // request. Documented in v0.1.160 (GPT reasoning replay).
     //
-    // DeepSeek thinking models require the prior turn's `reasoning_content`
-    // string to be echoed back inside the assistant message, otherwise the API
-    // returns 400. xAI reasoning models also preserve their official multi-turn
-    // shape and cache prefix stability when prior assistant reasoning_content
-    // is replayed; reasoning_effort itself remains caller/user-selected.
+    // DeepSeek splits by model: thinking-mode models with tools REQUIRE the
+    // prior turn's `reasoning_content` echoed back (400 without it), while
+    // `deepseek-reasoner` REJECTS it with a 400. The caller decides per model
+    // through options.replaysReasoningContent — see
+    // deepseekReplaysReasoningContent below. xAI reasoning models preserve
+    // their official multi-turn shape and cache prefix stability when prior
+    // assistant reasoning_content is replayed; reasoning_effort itself remains
+    // caller/user-selected.
     const replaysReasoningContent = options.replaysReasoningContent === true
-        || providerName === 'deepseek'
         || providerName === 'xai';
     const out = [];
     const pendingToolMedia = [];
@@ -94,6 +96,14 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
     return out;
 }
 
+// deepseek-reasoner returns 400 when `reasoning_content` appears in the input
+// messages; every other DeepSeek thinking model needs it back once tools are in
+// play. Unknown DeepSeek ids default to replaying: a missing echo breaks the
+// tool loop, while a stray field on a non-thinking model is ignored.
+export function deepseekReplaysReasoningContent(model) {
+    return !/reasoner/.test(String(model || '').trim().toLowerCase());
+}
+
 export function toOpenAITools(tools) {
     return tools.map((t) => ({
         type: 'function',