mixdog 0.9.151 → 0.9.153

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

@@ -13,6 +13,12 @@ import {
     _withCodexWsClientMetadata,
 } from './openai-codex-metadata.mjs';
 import { codexOriginator, codexUserAgent } from './codex-client-meta.mjs';
+import { _captureTurnStateFromEvent } from './openai-ws-stream.mjs';
+import { _buildOpenAIHttpFallbackHeaders } from './openai-oauth-http-sse.mjs';
+import {
+    _clearCodexTurnStatesForTest,
+    retireCodexTurnStateOwner,
+} from './openai-turn-state.mjs';
 
 test('Codex wire identity is a real time-based UUIDv7 and remains session-stable', () => {
     const now = Date.now();
@@ -151,3 +157,68 @@ test('compaction shares the session identity and cache slot with its turns', ()
     assert.equal(turnMetadata.session_id, turn.codexSessionId);
     assert.equal(turnMetadata.thread_id, turn.codexThreadId);
 });
+
+test('Codex turn state follows the logical turn across WS reconnect and HTTP fallback', (t) => {
+    _clearCodexTurnStatesForTest();
+    t.after(_clearCodexTurnStatesForTest);
+    const poolKey = 'turn-state-parity-session';
+    const cacheKey = mintUuidV7();
+    const turnId = mintUuidV7();
+    const nextTurnId = mintUuidV7();
+    const context = {
+        poolKey,
+        cacheKey,
+        sendOpts: { turnId },
+    };
+
+    const firstEntry = {};
+    const firstFrame = _withCodexWsClientMetadata({}, firstEntry, true, context);
+    assert.equal(firstFrame.client_metadata['x-codex-turn-state'], undefined);
+
+    _captureTurnStateFromEvent(firstEntry, {
+        type: 'response.metadata',
+        headers: { 'x-codex-turn-state': 'ts-first' },
+    });
+    _captureTurnStateFromEvent(firstEntry, {
+        type: 'response.metadata',
+        headers: { 'x-codex-turn-state': 'ts-later' },
+    });
+
+    const siblingEntry = {};
+    const siblingFrame = _withCodexWsClientMetadata({}, siblingEntry, true, context);
+    assert.equal(siblingFrame.client_metadata['x-codex-turn-state'], undefined);
+
+    const httpHeaders = _buildOpenAIHttpFallbackHeaders({
+        auth: { type: 'openai-oauth', access_token: 'token', account_id: 'account' },
+        cacheKey,
+        poolKey,
+        turnId,
+    });
+    assert.equal(httpHeaders['x-codex-turn-state'], 'ts-first');
+
+    retireCodexTurnStateOwner(poolKey, firstEntry);
+    const reconnectEntry = {};
+    const reconnectFrame = _withCodexWsClientMetadata({}, reconnectEntry, true, context);
+    assert.equal(reconnectFrame.client_metadata['x-codex-turn-state'], 'ts-first');
+
+    const nextTurnFrame = _withCodexWsClientMetadata({}, reconnectEntry, true, {
+        ...context,
+        sendOpts: { turnId: nextTurnId },
+    });
+    assert.equal(nextTurnFrame.client_metadata['x-codex-turn-state'], undefined);
+    const nextTurnHttpHeaders = _buildOpenAIHttpFallbackHeaders({
+        auth: { type: 'openai-oauth', access_token: 'token', account_id: 'account' },
+        cacheKey,
+        poolKey,
+        turnId: nextTurnId,
+    });
+    assert.equal(nextTurnHttpHeaders['x-codex-turn-state'], undefined);
+
+    const directHeaders = _buildOpenAIHttpFallbackHeaders({
+        auth: { type: 'openai-direct', apiKey: 'key' },
+        cacheKey,
+        poolKey,
+        turnId,
+    });
+    assert.equal(directHeaders['x-codex-turn-state'], undefined);
+});

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

@@ -6,6 +6,7 @@ import { createHash, randomUUID } from 'crypto';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { getPluginData } from '../config.mjs';
+import { activateCodexTurnState } from './openai-turn-state.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;
@@ -206,39 +207,30 @@ 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 explicitLogicalTurnId = _cleanMetaString(
+        context?.sendOpts?.turnId
+        || context?.sendOpts?.codexTurnId
+        || context?.sendOpts?.session?.turnId,
+    );
+    const logicalTurnId = explicitLogicalTurnId
+        ? _codexUuidV7(explicitLogicalTurnId)
+        : base.turn_id;
+    const turnStateScope = _cleanMetaString(context?.poolKey);
     const metadata = {
         ...base,
         ...(frame.client_metadata && typeof frame.client_metadata === 'object' ? frame.client_metadata : {}),
         'x-codex-ws-stream-request-start-ms': String(Date.now()),
     };
     if (entry && typeof entry === 'object') {
-        // x-codex-turn-state is scoped to ONE turn while
-        // pooled sockets span turns: attribute a captured token to the FIRST
-        // turn that observes it, then drop it once turn_id moves on. An empty
-        // turn_id (parity prewarm) is a valid owner, so the check is against
-        // null rather than falsiness.
-        if (entry.turnState) {
-            if (entry.turnStateTurnId == null) {
-                entry.turnStateTurnId = base.turn_id;
-            } else if (entry.turnStateTurnId !== base.turn_id) {
-                // 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;
+        const priorTurnId = entry.turnStateTurnId;
+        if (turnStateScope && logicalTurnId) {
+            entry.turnState = activateCodexTurnState(turnStateScope, logicalTurnId, entry);
+        } else if (priorTurnId != null && priorTurnId !== logicalTurnId) {
+            entry.turnState = null;
         }
-        entry.currentTurnId = base.turn_id;
+        entry.turnStateScope = turnStateScope || null;
+        entry.turnStateTurnId = logicalTurnId || null;
+        entry.currentTurnId = logicalTurnId || null;
     }
     if (entry?.turnState) metadata['x-codex-turn-state'] = String(entry.turnState);
     return { ...frame, client_metadata: metadata };

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

@@ -14,6 +14,14 @@ export const OPENAI_COMPAT_PRESETS = {
         baseURL: 'https://opencode.ai/zen/go/v1',
         defaultModel: 'glm-5.2',
     },
+    openrouter: {
+        baseURL: 'https://openrouter.ai/api/v1',
+        defaultModel: 'openrouter/auto',
+        extraHeaders: {
+            'HTTP-Referer': 'https://github.com/tribgames/mixdog',
+            'X-OpenRouter-Title': 'mixdog',
+        },
+    },
     ollama: {
         baseURL: 'http://localhost:11434/v1',
         defaultModel: 'llama3.3:latest',

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

@@ -296,6 +296,7 @@ export async function consumeCompatChatCompletionStream(stream, {
     let sawFirstEvent = false;
     let content = '';
     let reasoningContent = '';
+    const reasoningDetails = [];
     // Invariant flag for the gateway live-text relay: set once a non-empty
     // text chunk has been forwarded to the client. A failure after this point
     // must be treated as permanent — the rendered text cannot be withdrawn and
@@ -435,6 +436,10 @@ export async function consumeCompatChatCompletionStream(stream, {
             // use reasoning, and some local compatibility shims expose
             // thinking. They are aliases, never concatenate multiple aliases
             // from the same chunk.
+            if (Array.isArray(choice?.delta?.reasoning_details) && choice.delta.reasoning_details.length) {
+                reasoningDetails.push(...choice.delta.reasoning_details);
+                reportProgress('reasoning');
+            }
             const reasoningDelta = typeof choice?.delta?.reasoning_content === 'string'
                 ? choice.delta.reasoning_content
                 : typeof choice?.delta?.reasoning === 'string'
@@ -513,6 +518,7 @@ export async function consumeCompatChatCompletionStream(stream, {
     const message = {
         content: content || null,
         ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
+        ...(reasoningDetails.length ? { reasoning_details: reasoningDetails } : {}),
     };
     const rawToolCalls = [...toolAcc.values()]
         .sort((a, b) => a._order - b._order)
@@ -557,6 +563,7 @@ export async function consumeCompatChatCompletionStream(stream, {
         toolCalls,
         stopReason,
         reasoningContent: reasoningContent || null,
+        reasoningDetails: reasoningDetails.length ? reasoningDetails : null,
         rawUsage,
     };
 }

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

@@ -20,6 +20,7 @@ import {
 import {
     customToolCallFromResponseItem,
 } from './custom-tool-wire.mjs';
+import { providerReplayItems } from './lib/provider-replay.mjs';
 
 export function positiveTokenInt(value) {
     const n = Number(value);
@@ -56,6 +57,12 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
         || providerName === 'xai';
     const out = [];
     const pendingToolMedia = [];
+    const openRouterReasoningDetails = (message) => {
+        if (providerName !== 'openrouter') return null;
+        const metadata = message?.providerMetadata?.openrouter;
+        const details = metadata?.reasoning_details ?? metadata?.reasoningDetails;
+        return Array.isArray(details) && details.length ? details : null;
+    };
     const flushToolMedia = () => {
         if (!pendingToolMedia.length) return;
         out.push({ role: 'user', content: pendingToolMedia.splice(0) });
@@ -83,11 +90,20 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
                 })),
             };
             if (replaysReasoningContent && m.reasoningContent) msg.reasoning_content = m.reasoningContent;
+            const reasoningDetails = openRouterReasoningDetails(m);
+            if (reasoningDetails) msg.reasoning_details = reasoningDetails;
             out.push(msg);
             continue;
         }
-        if (m.role === 'assistant' && replaysReasoningContent && m.reasoningContent) {
-            out.push({ role: m.role, content: normalizeContentForOpenAIChat(m.content, { role: 'assistant' }), reasoning_content: m.reasoningContent });
+        const reasoningDetails = m.role === 'assistant' ? openRouterReasoningDetails(m) : null;
+        if (m.role === 'assistant' && ((replaysReasoningContent && m.reasoningContent) || reasoningDetails)) {
+            const msg = {
+                role: m.role,
+                content: normalizeContentForOpenAIChat(m.content, { role: 'assistant' }),
+            };
+            if (replaysReasoningContent && m.reasoningContent) msg.reasoning_content = m.reasoningContent;
+            if (reasoningDetails) msg.reasoning_details = reasoningDetails;
+            out.push(msg);
             continue;
         }
         out.push({ role: m.role, content: normalizeContentForOpenAIChat(m.content, { role: m.role }) });
@@ -392,6 +408,13 @@ export function toXaiResponsesInput(messages, providerState, options = {}) {
         const m = messages[messageIndex];
         if (!includeSystem && m.role === 'system') continue;
         if (m.role !== 'tool') flushToolMedia();
+        const orderedReplay = m.role === 'assistant'
+            ? providerReplayItems(m, 'xai-responses')
+            : undefined;
+        if (orderedReplay?.length) {
+            input.push(...orderedReplay);
+            continue;
+        }
         const reasoningItems = reasoningByMessageIndex.get(messageIndex);
         if (reasoningItems) input.push(...reasoningItems);
         if (dropToolHistory && m.role === 'tool') continue;

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

@@ -64,6 +64,7 @@ import {
     writeXaiResponsesCacheTrace,
 } from './openai-compat-xai.mjs';
 import { envFlag as _envFlag } from './lib/env-utils.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
 
 const requireOpenAI = createRequire(import.meta.url);
 let _OpenAI = null;
@@ -168,10 +169,33 @@ function normalizeReasoningEffort(value, allowed) {
     return allowed.includes(effort) ? effort : null;
 }
 
+export function compatReportedCostUsd(providerName, usage) {
+    if (providerName === 'openrouter') {
+        const cost = Number(usage?.cost);
+        return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
+    }
+    if (providerName === 'xai') {
+        const ticks = Number(usage?.cost_in_usd_ticks);
+        return Number.isFinite(ticks) && ticks >= 0
+            ? Number((ticks * 1e-10).toFixed(8))
+            : undefined;
+    }
+    return undefined;
+}
+
 // Keep provider extensions isolated: fields accepted by one OpenAI-compatible
 // backend are frequently rejected by another even when the core Chat schema is
 // shared.
 export function applyCompatProviderChatOptions(params, providerName, opts = {}, config = {}, modelInfo = null) {
+    if (providerName === 'openrouter') {
+        const effort = normalizeReasoningEffort(
+            opts.openRouterReasoningEffort ?? opts.effort ?? config?.reasoningEffort,
+            ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'],
+        );
+        if (effort === 'none') params.reasoning = { enabled: false };
+        else if (effort) params.reasoning = { enabled: true, effort };
+        return params;
+    }
     if (providerName === 'xai') {
         const reasoningEffort = normalizeXaiReasoningEffort(opts.xaiReasoningEffort
             ?? opts.effort
@@ -594,6 +618,9 @@ export class OpenAICompatProvider {
         const reasoningContent = (capturesReasoningContent && typeof assembled.reasoningContent === 'string')
             ? assembled.reasoningContent
             : null;
+        const reasoningDetails = this.name === 'openrouter' && Array.isArray(choice?.message?.reasoning_details)
+            ? choice.message.reasoning_details
+            : null;
         return {
             content: assembled.content || '',
             // Streamed chunks can omit `model`; fall back to the requested
@@ -609,6 +636,9 @@ export class OpenAICompatProvider {
             // instead of silently treating a truncated answer as complete.
             ...(stopReason === 'length' && (assembled.content || '').length > 0 ? { truncated: true } : {}),
             ...(reasoningContent ? { reasoningContent } : {}),
+            ...(reasoningDetails?.length ? {
+                providerMetadata: { openrouter: { reasoning_details: reasoningDetails } },
+            } : {}),
             usage: response.usage ? (() => {
                 const input = response.usage.prompt_tokens ?? response.usage.input_tokens ?? 0;
                 const cached = extractCompatCachedTokens(response.usage);
@@ -616,10 +646,7 @@ export class OpenAICompatProvider {
                 // (1 tick = $1e-10, per docs.x.ai). Surface it as costUsd so the
                 // session manager skips the catalog-rate fallback and records the
                 // provider-billed value verbatim.
-                const ticks = response.usage.cost_in_usd_ticks;
-                const costUsd = typeof ticks === 'number' && ticks >= 0
-                    ? Number((ticks * 1e-10).toFixed(8))
-                    : undefined;
+                const costUsd = compatReportedCostUsd(this.name, response.usage);
                 return {
                     inputTokens: input,
                     outputTokens: response.usage.completion_tokens ?? response.usage.output_tokens ?? 0,
@@ -884,6 +911,7 @@ export class OpenAICompatProvider {
         // any rejection as a provider-side drop.)
         const nextPreviousResponseId = response.id;
         const encryptedReasoningItems = encryptedXaiReasoningItems(response.output);
+        const providerReplay = createProviderReplay('xai-responses', response.output);
         const encryptedReasoningHistory = [
             ...(Array.isArray(opts.providerState?.xaiResponses?.encryptedReasoningHistory)
                 ? opts.providerState.xaiResponses.encryptedReasoningHistory
@@ -904,6 +932,7 @@ export class OpenAICompatProvider {
             ...(streamed.stopReason === 'length' && (streamed.content || '').length > 0 ? { truncated: true } : {}),
             citations: searchSources.citations.length ? searchSources.citations : undefined,
             webSearchCalls: searchSources.webSearchCalls.length ? searchSources.webSearchCalls : undefined,
+            providerReplay,
             providerState: {
                 ...(opts.providerState || {}),
                 xaiResponses: {
@@ -1022,6 +1051,7 @@ export class OpenAICompatProvider {
         // Same rationale as the HTTP path above: `length` stop keeps the chain.
         const nextPreviousResponseId = responseId;
         const encryptedReasoningItems = encryptedXaiReasoningItems(result.responseItems);
+        const providerReplay = createProviderReplay('xai-responses', result.responseItems);
         const encryptedReasoningHistory = [
             ...(Array.isArray(opts.providerState?.xaiResponses?.encryptedReasoningHistory)
                 ? opts.providerState.xaiResponses.encryptedReasoningHistory
@@ -1080,6 +1110,7 @@ export class OpenAICompatProvider {
             // 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 } : {}),
+            providerReplay,
             providerState: {
                 ...(opts.providerState || {}),
                 xaiResponses: {

package/src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs

@@ -38,8 +38,13 @@ import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './ant
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
 import { CODEX_OAUTH_ORIGINATOR, CODEX_RESPONSES_URL, _displayCodexModel } from './openai-oauth.mjs';
 import { createActiveToolItemTracker } from './tool-stream-state.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
 import { parseProviderJsonBatch } from './stream-json-pool.mjs';
 import { envFlag as _envFlag } from './lib/env-utils.mjs';
+import {
+    activateCodexTurnState,
+    captureCodexTurnState,
+} from './openai-turn-state.mjs';
 export { envPositiveInt as _envPositiveInt } from './lib/env-utils.mjs';
 export { _envFlag };
 
@@ -163,7 +168,13 @@ function _pushOutputTextAnnotations(part, citations, citationKeys) {
     }
 }
 
-function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey, statelessConversation = false }) {
+export function _buildOpenAIHttpFallbackHeaders({
+    auth,
+    cacheKey,
+    statelessConversation = false,
+    poolKey = null,
+    turnId = null,
+}) {
     if (auth?.type === 'openai-direct') {
         // Public API-key auth: Bearer <OPENAI_API_KEY>, no chatgpt-account-id /
         // originator (mirrors openai-ws-pool _buildHandshakeHeaders' direct
@@ -194,6 +205,8 @@ function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey, statelessConversation
         headers['session-id'] = sid;
         headers['thread-id'] = sid;
     }
+    const turnState = activateCodexTurnState(poolKey, turnId);
+    if (turnState) headers['x-codex-turn-state'] = turnState;
     return headers;
 }
 
@@ -250,7 +263,14 @@ export async function sendViaHttpSse({
     const totalTimeout = createPassthroughSignal(externalSignal);
     const statelessConversation = opts?.statelessConversation === true
         || _envFlag('MIXDOG_OAI_STATELESS_HTTP', false);
-    const headers = _buildOpenAIHttpFallbackHeaders({ auth, cacheKey, statelessConversation });
+    const turnId = opts?.turnId || opts?.codexTurnId || opts?.session?.turnId || null;
+    const headers = _buildOpenAIHttpFallbackHeaders({
+        auth,
+        cacheKey,
+        statelessConversation,
+        poolKey,
+        turnId,
+    });
     const fetchStartedAt = Date.now();
     const responsesUrl = auth?.type === 'openai-direct'
         ? OPENAI_DIRECT_RESPONSES_URL
@@ -379,6 +399,10 @@ export async function sendViaHttpSse({
         totalTimeout.cleanup();
         throw err;
     }
+    if (auth?.type !== 'openai-direct') {
+        const responseTurnState = response.headers?.get?.('x-codex-turn-state');
+        if (responseTurnState) captureCodexTurnState(poolKey, turnId, responseTurnState);
+    }
     if (!response.body) {
         totalTimeout.cleanup();
         throw Object.assign(new Error('OpenAI OAuth HTTP fallback returned no response body'), { initialResponseError: true });
@@ -504,6 +528,8 @@ export async function sendViaHttpSse({
     const clearActiveToolItem = _toolTracker.clear;
     let _toolInFlight = false;
     const reasoningItems = [];
+    const responseItems = [];
+    const responseItemKeys = new Set();
     const citations = [];
     const citationKeys = new Set();
     const webSearchCalls = [];
@@ -663,6 +689,16 @@ export async function sendViaHttpSse({
             });
         }
     };
+    const pushResponseItem = (item) => {
+        if (!item || typeof item !== 'object') return;
+        let fallbackKey = '';
+        try { fallbackKey = JSON.stringify(item); } catch {}
+        const key = `${item.type || 'unknown'}:${item.id || item.call_id || fallbackKey}`;
+        if (responseItemKeys.has(key)) return;
+        responseItemKeys.add(key);
+        try { responseItems.push(structuredClone(item)); }
+        catch { responseItems.push({ ...item }); }
+    };
     const pushToolSearchCall = (item) => {
         if (!item || item.type !== 'tool_search_call') return;
         const callId = item.call_id || item.id || '';
@@ -800,6 +836,7 @@ export async function sendViaHttpSse({
                 break;
             case 'response.output_item.done': {
                 const item = event.item || {};
+                pushResponseItem(item);
                 pushReasoningItem(item);
                 pushWebSearchCall(item);
                 if (item.type === 'function_call') {
@@ -852,6 +889,7 @@ export async function sendViaHttpSse({
                 }
                 let reportedBundleProgress = false;
                 for (const item of resp.output || []) {
+                    pushResponseItem(item);
                     if (item.type === 'message') {
                         for (const part of item.content || []) {
                             if (!content && part.type === 'output_text') {
@@ -1060,6 +1098,11 @@ export async function sendViaHttpSse({
         // trailing text is never lost (streamed-text path).
         flushLeak();
     } catch (err) {
+        if (err && !err.partialProviderReplay) {
+            try {
+                err.partialProviderReplay = createProviderReplay('openai-responses', responseItems);
+            } catch {}
+        }
         // Live-text invariant: once a non-empty chunk has been relayed it
         // cannot be withdrawn — flag the error so no upstream layer retries.
         if (emittedText && err) { try { err.liveTextEmitted = true; err.unsafeToRetry = true; } catch {} }
@@ -1100,6 +1143,7 @@ export async function sendViaHttpSse({
         try {
             err.partialContent = content;
             err.partialToolCalls = toolCalls.length ? toolCalls.slice() : undefined;
+            err.partialProviderReplay = createProviderReplay('openai-responses', responseItems);
             err.partialModel = model || undefined;
             err.pendingToolUse = pendingCalls.size > 0 || activeToolItems.size > 0 || _toolInFlight === true;
         } catch { /* best-effort enrichment */ }
@@ -1141,6 +1185,7 @@ export async function sendViaHttpSse({
         content,
         model: liveModel,
         reasoningItems: reasoningItems.length ? reasoningItems : undefined,
+        providerReplay: createProviderReplay('openai-responses', responseItems),
         toolCalls: _returnedToolCalls,
         citations: citations.length ? citations : undefined,
         webSearchCalls: webSearchCalls.length ? webSearchCalls : undefined,