mixdog 0.7.8 → 0.7.12

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

@@ -3,10 +3,16 @@ import { createHash } from 'crypto';
 import { loadConfig } from '../config.mjs';
 import { withRetry } from './retry-classifier.mjs';
 import { sendViaWebSocket } from './openai-oauth-ws.mjs';
+import {
+    consumeCompatChatCompletionStream,
+    consumeCompatResponsesStream,
+    parseCompletedToolCallArgumentsJson,
+} from './openai-compat-stream.mjs';
 import { appendBridgeTrace, traceBridgeUsage } from '../bridge-trace.mjs';
 import { resolveProviderCacheKey } from '../smart-bridge/cache-strategy.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+    PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
     PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
     createTimeoutSignal,
     resolveTimeoutMs,
@@ -23,9 +29,16 @@ export const OPENAI_COMPAT_PRESETS = {
         baseURL: 'https://api.x.ai/v1',
         defaultModel: 'grok-4.3',
     },
-    nvidia: {
-        baseURL: 'https://integrate.api.nvidia.com/v1',
-        defaultModel: 'meta/llama-3.3-70b-instruct',
+    // OpenCode Go — low-cost coding-model subscription gateway. The Go
+    // gateway exposes a unified OpenAI-compatible /chat/completions surface
+    // that transparently fronts every Go model (GLM / Kimi / DeepSeek / MiMo
+    // and the anthropic-native MiniMax / Qwen), including tool-calling and
+    // server-side prefix caching (cached_tokens), so no separate Anthropic
+    // transport is needed. Auth is a single OPENCODE_API_KEY (Bearer).
+    // listModels() pulls the live roster from {baseURL}/models.
+    'opencode-go': {
+        baseURL: 'https://opencode.ai/zen/go/v1',
+        defaultModel: 'glm-5.2',
     },
     ollama: {
         baseURL: 'http://localhost:11434/v1',
@@ -841,7 +854,7 @@ function toResponsesTools(tools) {
         parameters: t.inputSchema,
     }));
 }
-function parseToolCalls(choice) {
+function parseToolCalls(choice, label) {
     const calls = choice.message?.tool_calls;
     if (!calls?.length)
         return undefined;
@@ -850,7 +863,7 @@ function parseToolCalls(choice) {
         .map((tc) => ({
         id: tc.id,
         name: tc.function.name,
-        arguments: JSON.parse(tc.function.arguments || '{}'),
+        arguments: parseCompletedToolCallArgumentsJson(tc.function.arguments, label),
     }));
 }
 function parseJsonObject(value) {
@@ -861,14 +874,14 @@ function parseJsonObject(value) {
         return {};
     }
 }
-function parseResponsesToolCalls(response) {
+function parseResponsesToolCalls(response, label) {
     const out = [];
     for (const item of response?.output || []) {
         if (item?.type !== 'function_call') continue;
         out.push({
             id: item.call_id || item.id,
             name: item.name,
-            arguments: parseJsonObject(item.arguments),
+            arguments: parseCompletedToolCallArgumentsJson(item.arguments, label),
         });
     }
     return out.length ? out : undefined;
@@ -1025,7 +1038,7 @@ export class OpenAICompatProvider {
                 ?? process.env.MIXDOG_XAI_REASONING_EFFORT);
             if (reasoningEffort) params.reasoning_effort = reasoningEffort;
         }
-        const totalSignal = createTimeoutSignal(signal, PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, `${this.name} total`);
+        const totalSignal = createTimeoutSignal(signal, PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS, `${this.name} total`);
         const cacheRouting = this.name === 'xai'
             ? xaiCacheRouting(opts, params, tools || [], useModel)
             : null;
@@ -1040,14 +1053,31 @@ export class OpenAICompatProvider {
         // their own load balancers and emit 5xx / "overloaded" under burst
         // traffic. The withRetry wrapper preserves abort behavior via
         // mergedSignal and only retries when classifyError() says transient.
-        let response;
+        params.stream = true;
+        params.stream_options = { include_usage: true };
+        let assembled;
         try {
-            response = await withRetry(
-                ({ signal: attemptSignal }) => this.client.chat.completions.create(params, { signal: attemptSignal }),
+            assembled = await withRetry(
+                async ({ signal: attemptSignal }) => {
+                    try { opts.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
+                    const stream = await withRetry(
+                        ({ signal: openSignal }) => this.client.chat.completions.create(params, { signal: openSignal }),
+                        {
+                            signal: attemptSignal,
+                            perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+                            perAttemptLabel: `${this.name} first byte`,
+                        },
+                    );
+                    try { opts.onStageChange?.('streaming'); } catch { /* heartbeat best-effort */ }
+                    return consumeCompatChatCompletionStream(stream, {
+                        signal: attemptSignal,
+                        label: this.name,
+                        onStreamDelta: opts.onStreamDelta,
+                        parseToolCalls,
+                    });
+                },
                 {
                     signal: totalSignal.signal,
-                    perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-                    perAttemptLabel: `${this.name} first byte`,
                     onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
                         const delayLabel = Number.isFinite(Number(delayMs)) ? `, delay ${delayMs}ms${delayReason ? ` (${delayReason})` : ''}` : '';
                         process.stderr.write(`[${this.name}] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}${delayLabel}\n`);
@@ -1057,8 +1087,9 @@ export class OpenAICompatProvider {
         } finally {
             totalSignal.cleanup();
         }
+        const response = assembled.response;
         const choice = response.choices[0];
-        const toolCalls = choice ? parseToolCalls(choice) : undefined;
+        const toolCalls = assembled.toolCalls;
         // Capture finish_reason early so we can refuse to return an
         // incomplete completion as final content. OpenAI-compat backends use
         // `length` (max_tokens / model context overflow) and `content_filter`
@@ -1115,11 +1146,11 @@ export class OpenAICompatProvider {
         // assistant message and echo it back next turn for providers that
         // require or benefit from that official multi-turn shape.
         const capturesReasoningContent = this.name === 'deepseek' || this.name === 'xai';
-        const reasoningContent = (capturesReasoningContent && typeof choice?.message?.reasoning_content === 'string')
-            ? choice.message.reasoning_content
+        const reasoningContent = (capturesReasoningContent && typeof assembled.reasoningContent === 'string')
+            ? assembled.reasoningContent
             : null;
         return {
-            content: choice?.message?.content || '',
+            content: assembled.content || '',
             model: response.model,
             toolCalls,
             stopReason,
@@ -1165,17 +1196,15 @@ export class OpenAICompatProvider {
         };
         if (previousResponseId) params.previous_response_id = previousResponseId;
         if (tools?.length) params.tools = toResponsesTools(tools);
-        // Non-streaming transport: there are no deltas to report, so without
-        // an explicit stage the session sits on the loop's per-iteration
-        // 'connecting' reset for the whole generation (bridge list shows a
-        // working session as stuck). Report 'requesting' for the in-flight
-        // window and fire one delta on arrival to feed the stall watchdog.
+        // SSE transport: report 'requesting' until the stream opens, then
+        // per-chunk onStreamDelta feeds the bridge stall watchdog.
         try { opts.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
         const reasoningEffort = normalizeXaiReasoningEffort(opts.xaiReasoningEffort
             ?? opts.effort
             ?? this.config?.reasoningEffort
             ?? process.env.MIXDOG_XAI_REASONING_EFFORT);
         if (reasoningEffort) params.reasoning = { effort: reasoningEffort };
+        params.stream = true;
         let response;
         let cacheLane = null;
         const scheduled = await withXaiResponsesCacheLane({
@@ -1189,14 +1218,29 @@ export class OpenAICompatProvider {
             signal,
         }, async (laneMeta) => {
             cacheLane = laneMeta;
-            const totalSignal = createTimeoutSignal(signal, PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, 'xai responses total');
+            const totalSignal = createTimeoutSignal(signal, PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS, 'xai responses total');
             try {
                 return await withRetry(
-                    ({ signal: attemptSignal }) => this.client.responses.create(params, { signal: attemptSignal }),
+                    async ({ signal: attemptSignal }) => {
+                        const stream = await withRetry(
+                            ({ signal: openSignal }) => this.client.responses.create(params, { signal: openSignal }),
+                            {
+                                signal: attemptSignal,
+                                perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+                                perAttemptLabel: 'xai responses first byte',
+                            },
+                        );
+                        try { opts.onStageChange?.('streaming'); } catch { /* heartbeat best-effort */ }
+                        return consumeCompatResponsesStream(stream, {
+                            signal: attemptSignal,
+                            label: 'xai:responses',
+                            onStreamDelta: opts.onStreamDelta,
+                            parseResponsesToolCalls,
+                            responseOutputText,
+                        });
+                    },
                     {
                         signal: totalSignal.signal,
-                        perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-                        perAttemptLabel: 'xai responses first byte',
                         onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
                             const delayLabel = Number.isFinite(Number(delayMs)) ? `, delay ${delayMs}ms${delayReason ? ` (${delayReason})` : ''}` : '';
                             process.stderr.write(`[xai:responses] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}${delayLabel}\n`);
@@ -1207,10 +1251,10 @@ export class OpenAICompatProvider {
                 totalSignal.cleanup();
             }
         });
-        response = scheduled.value;
+        const streamed = scheduled.value;
+        response = streamed.response;
         cacheLane = cacheLane || scheduled.laneMeta;
-        try { opts.onStreamDelta?.(); } catch { /* heartbeat best-effort */ }
-        const toolCalls = parseResponsesToolCalls(response);
+        const toolCalls = streamed.toolCalls;
         writeXaiResponsesCacheTrace({
             model: useModel,
             opts,
@@ -1254,7 +1298,7 @@ export class OpenAICompatProvider {
             });
         }
         return {
-            content: responseOutputText(response),
+            content: streamed.content,
             model: response.model || useModel,
             toolCalls,
             providerState: {

package/src/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -43,6 +43,7 @@ import {
 } from '../stall-policy.mjs';
 
 const CODEX_WS_URL = 'wss://chatgpt.com/backend-api/codex/responses';
+const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const OPENAI_WS_URL = 'wss://api.openai.com/v1/responses';
 const XAI_WS_URL = 'wss://api.x.ai/v1/responses';
 const WS_IDLE_MS = 5 * 60_000;
@@ -202,7 +203,7 @@ function _buildHandshakeHeaders({ auth, sessionToken, turnState, cacheKey }) {
         : {
             'Authorization': `Bearer ${auth.access_token}`,
             'chatgpt-account-id': auth.account_id || '',
-            'originator': 'mixdog',
+            'originator': CODEX_OAUTH_ORIGINATOR,
             'OpenAI-Beta': 'responses_websockets=2026-02-06',
         };
     if (sessionToken) {

package/src/agent/orchestrator/providers/openai-oauth.mjs

@@ -33,6 +33,7 @@ import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 // --- Constants ---
 const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const TOKEN_URL = 'https://auth.openai.com/oauth/token';
 const CODEX_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
 // Version string baked into the models endpoint query — Codex rejects the
@@ -69,26 +70,33 @@ async function _resolveCodexClientVersion() {
     return CODEX_CLIENT_VERSION_FLOOR;
 }
 const CODEX_MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
+const CODEX_MODEL_CACHE_SCHEMA_VERSION = 2;
 const TOKEN_REFRESH_SKEW_MS = 5 * 60_000;
 
 function _codexModelCachePath() {
     return join(getPluginData(), 'openai-oauth-models.json');
 }
 
-async function _loadCodexModelCache() {
+function _loadCodexModelCacheSync() {
     const path = _codexModelCachePath();
     if (!existsSync(path)) return null;
     try {
         const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        if (raw?.version !== CODEX_MODEL_CACHE_SCHEMA_VERSION) return null;
         if (!raw?.fetchedAt || !Array.isArray(raw.models)) return null;
         if (Date.now() - raw.fetchedAt > CODEX_MODEL_CACHE_TTL_MS) return null;
         return raw.models;
     } catch { return null; }
 }
 
+async function _loadCodexModelCache() {
+    return _loadCodexModelCacheSync();
+}
+
 async function _saveCodexModelCache(models) {
     try {
         writeJsonAtomicSync(_codexModelCachePath(), {
+            version: CODEX_MODEL_CACHE_SCHEMA_VERSION,
             fetchedAt: Date.now(),
             models,
         }, { lock: true, fsyncDir: true });
@@ -112,6 +120,34 @@ function _codexCatalogHas(id) {
     return _inMemoryCodexCatalog.some(m => m.id === id);
 }
 
+function _findCachedCodexModel(id) {
+    if (!id) return null;
+    if (!Array.isArray(_inMemoryCodexCatalog)) {
+        _inMemoryCodexCatalog = _loadCodexModelCacheSync();
+    }
+    if (!Array.isArray(_inMemoryCodexCatalog)) return null;
+    return _inMemoryCodexCatalog.find(m => m?.id === id) || null;
+}
+
+function _codexServiceTiers(modelInfo) {
+    return Array.isArray(modelInfo?.serviceTiers) ? modelInfo.serviceTiers : [];
+}
+
+function _codexModelBlocksServiceTier(id, serviceTier) {
+    if (serviceTier !== 'priority') return false;
+    const family = _codexFamily(id);
+    return family === 'gpt-mini' || family === 'gpt-nano' || family === 'gpt-codex';
+}
+
+export function codexModelSupportsServiceTier(id, serviceTier) {
+    if (_codexModelBlocksServiceTier(id, serviceTier)) return false;
+    const info = _findCachedCodexModel(id);
+    if (!info) return true;
+    const tiers = _codexServiceTiers(info);
+    if (!tiers.length) return false;
+    return tiers.some(t => t?.id === serviceTier);
+}
+
 // Codex 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.
@@ -123,6 +159,18 @@ function _displayCodexModel(id) {
 function _normalizeCodexModel(m) {
     const id = m?.slug || m?.id;
     const family = _codexFamily(id);
+    const serviceTiers = Array.isArray(m?.service_tiers)
+        ? m.service_tiers
+            .map(t => ({
+                id: String(t?.id || '').trim(),
+                name: String(t?.name || '').trim(),
+                description: String(t?.description || '').trim(),
+            }))
+            .filter(t => t.id)
+        : [];
+    const additionalSpeedTiers = Array.isArray(m?.additional_speed_tiers)
+        ? m.additional_speed_tiers.map(t => String(t || '').trim()).filter(Boolean)
+        : [];
     // Codex doesn't use dated ids — everything is effectively a version alias.
     return {
         id,
@@ -130,12 +178,17 @@ function _normalizeCodexModel(m) {
         display: m?.display_name || id,
         family,
         provider: 'openai-oauth',
-        contextWindow: m?.context_window || 1000000,
+        contextWindow: m?.context_window || m?.max_context_window || 1000000,
+        maxContextWindow: m?.max_context_window || null,
         outputTokens: m?.auto_compact_token_limit || 32768,
+        autoCompactTokenLimit: m?.auto_compact_token_limit || null,
         tier: 'version',
         latest: false,
         description: m?.description || '',
         reasoningLevels: (m?.supported_reasoning_levels || []).map(r => r.effort),
+        serviceTiers,
+        defaultServiceTier: m?.default_service_tier || null,
+        additionalSpeedTiers,
     };
 }
 
@@ -482,10 +535,11 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     if (opts.fast === true) {
         // 'priority' is the only fast-class value the Codex OAuth backend
         // accepts on the wire: 'fast' is hard-rejected ("Unsupported
-        // service_tier: fast", probed 2026-06-11), and 'priority' is accepted
-        // but downgraded to 'default' unless the account is entitled to
-        // priority processing. Keep sending it so entitled accounts benefit.
-        body.service_tier = 'priority';
+        // service_tier: fast", probed 2026-06-11). Match official Codex:
+        // only send the request value when the model catalog advertises it.
+        if (codexModelSupportsServiceTier(model, 'priority')) {
+            body.service_tier = 'priority';
+        }
     }
     // Add tools
     if (tools?.length) {
@@ -564,7 +618,7 @@ function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
         'Content-Type': 'application/json',
         Accept: 'text/event-stream',
         'OpenAI-Beta': 'responses=experimental',
-        originator: 'mixdog',
+        originator: CODEX_OAUTH_ORIGINATOR,
         'chatgpt-account-id': auth.account_id || '',
         'x-client-request-id': randomBytes(16).toString('hex'),
     };
@@ -954,6 +1008,9 @@ export class OpenAIOAuthProvider {
         // request skips the cold TLS handshake. Best-effort; never throws.
         preconnect('https://chatgpt.com');
     }
+    getCachedModelInfo(model) {
+        return _findCachedCodexModel(model);
+    }
     async ensureAuth({ forceRefresh = false, reason = 'preemptive' } = {}) {
         if (!this.tokens) this.tokens = loadTokens();
         if (!this.tokens)
@@ -1308,7 +1365,6 @@ export class OpenAIOAuthProvider {
 
 const AUTHORIZE_URL = 'https://auth.openai.com/oauth/authorize';
 const CODEX_OAUTH_SCOPE = 'openid profile email offline_access api.connectors.read api.connectors.invoke';
-const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const CALLBACK_HOST = '127.0.0.1';
 const CALLBACK_PORT = 1455;
 const CALLBACK_PATH = '/auth/callback';
@@ -1337,11 +1393,8 @@ export async function loginOAuth() {
     url.searchParams.set('state', state);
     url.searchParams.set('originator', CODEX_OAUTH_ORIGINATOR);
     process.stderr.write(`\n[openai-oauth] Open this URL to log in to ChatGPT (Codex):\n${url.toString()}\n\n`);
-    try {
-        const { exec } = await import('child_process');
-        const opener = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
-        exec(`${opener} "${url.toString()}"`, { windowsHide: true });
-    } catch { /* user opens manually */ }
+        const { openInBrowser } = await import('../../../shared/open-url.mjs');
+        openInBrowser(url.toString());
 
     return new Promise((resolve) => {
         const timeout = setTimeout(() => { server.close(); resolve(null); }, LOGIN_TIMEOUT_MS);

package/src/agent/orchestrator/providers/openai-ws.mjs

@@ -16,6 +16,24 @@ import { sendViaWebSocket } from './openai-oauth-ws.mjs';
 import { buildRequestBody } from './openai-oauth.mjs';
 import { resolveProviderCacheKey } from '../smart-bridge/cache-strategy.mjs';
 
+const OPENAI_DIRECT_PRIORITY_MODEL_PATTERNS = Object.freeze([
+    /^gpt-5\.5(?:-\d{4}|$)/,
+    /^gpt-5\.4(?:-\d{4}|$)/,
+    /^gpt-5\.4-mini(?:-\d{4}|$)/,
+]);
+
+export function openAiDirectSupportsPriority(model) {
+    const id = String(model || '').trim();
+    return OPENAI_DIRECT_PRIORITY_MODEL_PATTERNS.some(re => re.test(id));
+}
+
+export function applyOpenAIDirectFastTier(body, model, opts) {
+    if (opts?.fast === true && openAiDirectSupportsPriority(model)) {
+        body.service_tier = 'priority';
+    }
+    return body;
+}
+
 export class OpenAIDirectProvider {
     // input_tokens INCLUDES cached tokens (OpenAI convention). See registry.mjs.
     static inputExcludesCache = false;
@@ -38,6 +56,11 @@ export class OpenAIDirectProvider {
         const apiKey = this._ensureKey();
         const useModel = model || 'gpt-5.5';
         const body = buildRequestBody(messages, useModel, tools, sendOpts);
+        // Public OpenAI API priority support is documented separately from the
+        // Codex OAuth catalog. Keep this provider's service-tier decision local
+        // so gpt-5.4-mini can opt into Priority even when the Codex catalog does
+        // not advertise a Fast tier for its OAuth endpoint.
+        applyOpenAIDirectFastTier(body, useModel, opts);
         // Public Responses API supports prompt_cache_retention='24h' at no
         // extra cost (same cached_input_tokens billing as the default 5–10
         // min in-memory cache). Codex/oauth rejects the parameter, so it's

package/src/agent/orchestrator/session/manager.mjs

@@ -357,9 +357,10 @@ let nextId = Date.now();
 // without buying anything.
 const CONTEXT_WINDOWS = {
     // OpenAI GPT-5.x family
-    'gpt-5.5': 1000000,
-    'gpt-5.4-mini': 1000000,
-    'gpt-5.4-nano': 1000000,
+    'gpt-5.5': 272000,
+    'gpt-5.4': 272000,
+    'gpt-5.4-mini': 272000,
+    'gpt-5.4-nano': 272000,
     // Anthropic Claude 4.x
     'claude-opus-4-8': 1000000,
     'claude-opus-4-7': 1000000,
@@ -378,6 +379,18 @@ function guessContextWindow(model) {
         return 8192;
     return 128000;
 }
+function positiveContextWindow(value) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+function resolveSessionContextWindow(provider, model) {
+    const info = typeof provider?.getCachedModelInfo === 'function'
+        ? provider.getCachedModelInfo(model)
+        : null;
+    return positiveContextWindow(info?.contextWindow)
+        || positiveContextWindow(info?.context_window)
+        || guessContextWindow(model);
+}
 // Provider-scoped unified cache key. Goal: all orchestrator-internal
 // dispatches (bridge/maintenance/mcp/scheduler/webhook) targeting the
 // same provider land in a single server-side cache shard, so the
@@ -902,7 +915,7 @@ export function createSession(opts) {
         provider: providerName,
         model: modelName,
         messages,
-        contextWindow: guessContextWindow(modelName),
+        contextWindow: resolveSessionContextWindow(provider, modelName),
         tools,
         preset: toolPreset,
         presetName: presetObj?.name || null,
@@ -1417,6 +1430,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             runtime.session = session;
             if (!provider)
                 throw new Error(`Provider "${session.provider}" not available`);
+            session.contextWindow = resolveSessionContextWindow(provider, session.model);
             // Cap caller-supplied / prefetched context so an oversized
             // payload can't blow the session token budget before the
             // first model call. 32 KB ~ 8k tokens at the 4 B/tok

package/src/agent/orchestrator/stall-policy.mjs

@@ -70,6 +70,12 @@ export const PROVIDER_GENERATE_TOTAL_TIMEOUT_MS = resolveTimeoutMs(
     { minMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
 );
 
+export const PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS = resolveTimeoutMs(
+    ['MIXDOG_NONSTREAM_TOTAL_TIMEOUT_MS', 'MIXDOG_COMPAT_NONSTREAM_TOTAL_TIMEOUT_MS'],
+    480_000,
+    { minMs: PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, maxMs: STALL_ABORT_MS },
+);
+
 export const PROVIDER_CACHE_CREATE_TIMEOUT_MS = resolveTimeoutMs(
     'MIXDOG_PROVIDER_CACHE_CREATE_TIMEOUT_MS',
     Math.min(120_000, PROVIDER_GENERATE_TOTAL_TIMEOUT_MS),

package/src/agent/orchestrator/tools/builtin/native-edit-runner.mjs

@@ -19,21 +19,35 @@ export function nativeEditMode() {
     return String(process.env.MIXDOG_EDIT_NATIVE || 'auto').toLowerCase();
 }
 
-export function nativeEditBinPath() {
+function nativeEditBinCandidate() {
     const override = process.env.MIXDOG_EDIT_NATIVE_BIN || process.env.MIXDOG_PATCH_NATIVE_BIN;
-    if (override) return override;
-    if (existsSync(NATIVE_EDIT_DEFAULT_BIN)) return NATIVE_EDIT_DEFAULT_BIN;
-    return findCachedPatchBinary(getPluginData()) || NATIVE_EDIT_DEFAULT_BIN;
+    if (override) return { path: override, kind: 'override' };
+    if (existsSync(NATIVE_EDIT_DEFAULT_BIN)) return { path: NATIVE_EDIT_DEFAULT_BIN, kind: 'local' };
+    const cached = findCachedPatchBinary(getPluginData());
+    if (cached) return { path: cached, kind: 'cached' };
+    return { path: NATIVE_EDIT_DEFAULT_BIN, kind: 'missing' };
+}
+
+export function nativeEditBinPath() {
+    return nativeEditBinCandidate().path;
 }
 
 export function nativeEditShouldAttempt({ editSnapshot, oldStr, newStr, preloadedContent, preloadedRawBuf }) {
     const mode = nativeEditMode();
     if (/^(0|false|no|off|js|legacy)$/i.test(mode)) return false;
-    if (!existsSync(nativeEditBinPath())) return false;
+    const forcedNative = /^(1|true|yes|on|native)$/i.test(mode);
+    const candidate = nativeEditBinCandidate();
+    if (!existsSync(candidate.path)) return false;
+    // Cached release prebuilds are guaranteed valid for apply_patch, but older
+    // manifests (currently v0.6.5 in clean CI) predate the EDIT server protocol.
+    // In auto mode, native edit is only an acceleration, so require either a
+    // local cargo build or an explicit override. If a user forces native mode,
+    // still try the cached binary and surface any protocol failure.
+    if (candidate.kind === 'cached' && !forcedNative) return false;
     if (!snapshotCoversFullFile(editSnapshot)) return false;
     if (preloadedContent !== null || preloadedRawBuf !== null) return false;
     if (typeof oldStr !== 'string' || oldStr.length === 0 || typeof newStr !== 'string') return false;
-    if (/^(1|true|yes|on|native)$/i.test(mode)) return true;
+    if (forcedNative) return true;
     // auto: the persistent server removed per-call spawn cost, so route edits to
     // native edit2 by default (B3). Same-size edits keep the JS in-place partial
     // write, which rewrites bytes in place instead of the whole file.
@@ -44,6 +58,7 @@ export function nativeEditShouldAttempt({ editSnapshot, oldStr, newStr, preloade
 }
 
 export async function runNativeExactEdit({ fullPath, oldStr, newStr, replaceAll, signal = null }) {
+    const forcedNative = /^(1|true|yes|on|native)$/i.test(nativeEditMode());
     if (signal?.aborted) {
         return { ok: false, fallback: false, error: signal.reason?.message || signal.reason || 'native edit aborted' };
     }
@@ -82,8 +97,14 @@ export async function runNativeExactEdit({ fullPath, oldStr, newStr, replaceAll,
         }
         const msg = String(err?.message || err);
         // Tier misses and not-found map to a JS fallback; transport/spawn errors
-        // also fall back so a server hiccup never blocks an edit.
-        const fallback = /old_string (?:not found|found \d+ times)|not valid UTF-8|no exact match|not found|server/i.test(msg);
+        // also fall back so a server hiccup never blocks an edit. Older cached
+        // mixdog-patch binaries (for example the v0.6.5 release prebuilds used
+        // by clean CI before a local cargo build exists) support APPLY but not
+        // the EDIT server protocol, and answer EDIT with the APPLY parser's
+        // "bad header" error. In auto mode that means "native edit unavailable",
+        // not "the edit is invalid", so fall through to the JS editor. When the
+        // user explicitly forces native mode, keep surfacing the native failure.
+        const fallback = !forcedNative && /old_string (?:not found|found \d+ times)|not valid UTF-8|no exact match|not found|server|bad header|bad edit header/i.test(msg);
         return { ok: false, fallback, error: msg };
     }
 }

package/src/agent/orchestrator/tools/graph-manifest.json

@@ -1,26 +1,26 @@
 {
-  "version": "0.6.5",
+  "version": "0.7.12",
   "_comment": "Rewritten by .github/workflows/graph-release.yml on each tagged release. assets maps platformKey (process.platform-process.arch, e.g. win32-x64, linux-x64, darwin-arm64) to { url, sha256 } of the mixdog-graph binary on the GitHub release. A local cargo build under native/mixdog-graph/target/release always takes precedence at runtime. (v0.5.236 entries were filled manually after CI's commit step hit detached HEAD; the workflow now checks out ref: main so future releases self-update.)",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.6.5/mixdog-graph-darwin-arm64",
-      "sha256": "7016c273a07d19ca9e2f56e8fa7f273fdd40fc41bdc7fef206bf23e31a21a736"
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.7.12/mixdog-graph-darwin-arm64",
+      "sha256": "75bfdd200b2f8553b72dc877ec2637208f581800083d1ee5f9caf33f87792bf7"
     },
     "darwin-x64": {
-      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.6.5/mixdog-graph-darwin-x64",
-      "sha256": "d076e97da4420f49a6c726bc088a3321e2e7f6a9bfb32d39162c8c53045cfcdb"
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.7.12/mixdog-graph-darwin-x64",
+      "sha256": "04742fbb4cbe09bb76943f312ee129c05814543e7bc9d37e1241fb4e65b97137"
     },
     "linux-arm64": {
-      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.6.5/mixdog-graph-linux-arm64",
-      "sha256": "74754562b3c080868738c032c5b6e0e13bc53d7a5277002176b036f8d6681f39"
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.7.12/mixdog-graph-linux-arm64",
+      "sha256": "4b3edcd7be1ffec7184c48fe6bc7d6bce42f2ea67d4709f44d4402e6b48564f2"
     },
     "linux-x64": {
-      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.6.5/mixdog-graph-linux-x64",
-      "sha256": "0d8e8bbdd49b18746ed3f972fc3719731a1143ee03ac9e6d86586788b0b431f8"
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.7.12/mixdog-graph-linux-x64",
+      "sha256": "4394bb7884a8706dd6a4eea55f8755c76ba584cd02248863802d94acc3e1413c"
     },
     "win32-x64": {
-      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.6.5/mixdog-graph-win32-x64.exe",
-      "sha256": "1a671558e5a5f13c7429ff9987a46ad72a71e52241e200d2da820a13d7cbdae7"
+      "url": "https://github.com/trib-plugin/mixdog/releases/download/v0.7.12/mixdog-graph-win32-x64.exe",
+      "sha256": "cbfe189d690085aee1dfd70f5c0b9c26c260d0a080914cbeb504c84510ec3a5a"
     }
   }
 }