mixdog 0.9.2 → 0.9.3

package/src/runtime/agent/orchestrator/providers/oauth-usage.mjs

@@ -6,6 +6,7 @@ import { join } from 'path';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { num, round, cleanString } from './lib/usage-primitives.mjs';
 
 const CACHE_FILE = 'gateway-oauth-usage-cache.json';
 const LIVE_CACHE_TTL_MS = 60_000;
@@ -21,24 +22,6 @@ const lastWarnAt = new Map();
 let pendingDiskSnapshots = new Map();
 let pendingDiskFlushTimer = null;
 
-function num(value, fallback = null) {
-  if (value === null || value === undefined || value === '') return fallback;
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function round(value, digits = 4) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return null;
-  const scale = 10 ** digits;
-  return Math.round(n * scale) / scale;
-}
-
-function cleanString(value) {
-  const s = typeof value === 'string' ? value.trim() : '';
-  return s || null;
-}
-
 function providerKey(routeInfo = {}) {
   return String(routeInfo?.provider || '').toLowerCase();
 }
@@ -301,7 +284,7 @@ function balanceFromCredits(credits, source) {
 }
 
 function balanceFromExtraUsage(extra) {
-  if (!extra || typeof extra !== 'object' || extra.is_enabled !== true) return null;
+  if (!extra || typeof extra !== 'object') return null;
   const limit = num(extra.monthly_limit, null);
   const used = num(extra.used_credits, 0);
   if (limit === null) return null;
@@ -315,6 +298,57 @@ function balanceFromExtraUsage(extra) {
   };
 }
 
+function balanceFromAnthropicSpend(spend) {
+  if (!spend || typeof spend !== 'object') return null;
+  const currency = cleanString(spend.used?.currency ?? spend.limit?.currency) || 'USD';
+  // spend.balance may be a plain number or a {amount_minor, exponent} money
+  // object like used/limit; support both shapes.
+  const directBalance = spend.balance && typeof spend.balance === 'object'
+    ? (() => {
+      const minor = num(spend.balance.amount_minor, null);
+      return minor === null ? null : minor / (10 ** num(spend.balance.exponent, 2));
+    })()
+    : num(spend.balance, null);
+  if (directBalance !== null) {
+    return {
+      source: 'anthropic-oauth-spend',
+      remainingUsd: round(directBalance, 4),
+      spentUsd: round(num(spend.used?.amount_minor, 0) / (10 ** num(spend.used?.exponent, 2)), 4),
+      currency,
+    };
+  }
+
+  const usedMinor = num(spend.used?.amount_minor, null);
+  const usedExponent = num(spend.used?.exponent, 2);
+  const usedUsd = usedMinor === null ? null : usedMinor / (10 ** usedExponent);
+
+  const capMinor = num(spend.cap?.credits?.amount_minor, null);
+  if (capMinor !== null && usedUsd !== null) {
+    const capExponent = num(spend.cap?.credits?.exponent, 2);
+    const capUsd = capMinor / (10 ** capExponent);
+    return {
+      source: 'anthropic-oauth-spend',
+      remainingUsd: round(Math.max(0, capUsd - usedUsd), 4),
+      spentUsd: round(usedUsd, 4),
+      currency,
+    };
+  }
+
+  const limitMinor = num(spend.limit?.amount_minor, null);
+  if (limitMinor !== null && limitMinor > 0 && usedUsd !== null) {
+    const limitExponent = num(spend.limit?.exponent, 2);
+    const limitUsd = limitMinor / (10 ** limitExponent);
+    return {
+      source: 'anthropic-oauth-spend',
+      remainingUsd: round(Math.max(0, limitUsd - usedUsd), 4),
+      spentUsd: round(usedUsd, 4),
+      currency,
+    };
+  }
+
+  return null;
+}
+
 function normalizeOpenAIWhamUsage(data) {
   const rate = data?.rate_limit && typeof data.rate_limit === 'object' ? data.rate_limit : null;
   if (!rate) return null;
@@ -388,7 +422,7 @@ function normalizeAnthropicUsage(data, source = 'anthropic-oauth') {
     provider: 'anthropic-oauth',
     source,
     quotaWindows: windows,
-    balance: balanceFromExtraUsage(data.extra_usage),
+    balance: balanceFromAnthropicSpend(data.spend) || balanceFromExtraUsage(data.extra_usage),
     rawKeys: Object.keys(data || {}).sort(),
   };
 }

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

@@ -31,8 +31,7 @@ function truncatedCompatStreamError(label, detail) {
     );
 }
 
-// Invalid-tool-args marker. Native-provider convergence (openai-oauth /
-// opencode): completed-but-malformed tool_call arguments JSON must NOT throw
+// Invalid-tool-args marker: completed-but-malformed tool_call arguments JSON must NOT throw
 // (kills the turn) NOR be silently swallowed to `{}`. Instead the parse
 // failure is carried as data on the tool call's `arguments` slot so the
 // dispatch loop can turn it into an is_error tool_result and let the model
@@ -49,8 +48,7 @@ export function isInvalidToolArgsMarker(value) {
     return !!value && typeof value === 'object' && value.__invalidToolArgs === true;
 }
 /** Model-facing tool_result text for a tool call whose arguments failed to
- * parse. Mirrors opencode `The arguments provided to the tool are invalid` and
- * `failed to parse function arguments` — instructs an in-turn retry. */
+ * parse; instructs the model to retry with valid JSON in the same turn. */
 export function formatInvalidToolArgsResult(call) {
     const name = call?.name || 'tool';
     const detail = call?.arguments?.__parseError || 'arguments were not valid JSON';
@@ -85,9 +83,9 @@ export function parseCompletedToolCallArgumentsJson(raw, label, meta) {
         // Invariant: a completion/finish signal was observed for this tool call
         // (finish_reason present, or a per-call/response "done" event fired), so
         // the arguments are NOT mid-stream-truncated — they are complete but
-        // malformed. Native convergence: return an invalid-args MARKER (not a
-        // throw) so the dispatch loop feeds the parse error back to the model as
-        // a tool_result and the model self-corrects in the same turn. Only an
+        // malformed. Return an invalid-args MARKER (not a throw) so the
+        // dispatch loop feeds the parse error back to the model as a
+        // tool_result and the model self-corrects in the same turn. Only an
         // unfinished stream (no finishReason) stays the retryable truncation
         // case — that transient behavior is deliberately preserved.
         if (meta?.finishReason) {
@@ -406,7 +404,7 @@ export async function consumeCompatChatCompletionStream(stream, { signal, label,
     } catch (err) {
         // Any mid-stream failure after live text was relayed is non-retryable.
         if (emittedText) throw markErrorLiveTextEmitted(err);
-        // Partial-final recovery parity: on a mid-stream stall, attach the
+        // Partial-final recovery: on a mid-stream stall, attach the
         // streamed partial state so the loop can accept a wedged FINAL no-tool
         // summary as partial-final success. pendingToolUse gates out any
         // in-flight/emitted tool call.
@@ -488,12 +486,15 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         if (!item || item.type !== 'tool_search_call') return;
         const callId = item.call_id || item.id || '';
         if (!callId || state.toolCalls.some((call) => call.id === callId)) return;
+        const _tsArgs = item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
+            ? item.arguments
+            : parseCompletedToolCallArgumentsJson(item.arguments || '{}', label, { id: callId, name: 'tool_search', finishReason: 'done' });
         const call = {
             id: callId,
             name: 'tool_search',
-            arguments: item.arguments && typeof item.arguments === 'object'
-                ? item.arguments
-                : parseCompletedToolCallArgumentsJson(item.arguments || '{}', label, { id: callId, name: 'tool_search', finishReason: 'done' }),
+            // Schema is a plain object ({query,select,limit}); an array must
+            // never pass through as args.
+            arguments: (_tsArgs && typeof _tsArgs === 'object' && !Array.isArray(_tsArgs)) ? _tsArgs : {},
             nativeType: 'tool_search_call',
         };
         state.toolCalls.push(call);
@@ -533,6 +534,12 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
                 state.toolInFlight = true;
             } else if (event.item?.type === 'custom_tool_call') {
                 state.toolInFlight = true;
+            } else if (event.item?.type === 'tool_search_call') {
+                // Mark tool_search in-flight at item-added time, same as
+                // function_call/custom_tool_call above, so the stall-recovery
+                // pendingToolUse gate never drops a mid-flight tool_search
+                // before response.output_item.done pushes it.
+                state.toolInFlight = true;
             }
             try { onStreamDelta?.(); } catch {}
             break;
@@ -766,7 +773,7 @@ export async function consumeCompatResponsesStream(stream, {
         }
         flushLeak();
     } catch (err) {
-        // Partial-final recovery parity: attach streamed partial state so a
+        // Partial-final recovery: attach streamed partial state so a
         // wedged FINAL no-tool summary can be accepted as partial-final success.
         if (err?.streamStalled === true) {
             try {

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

@@ -1032,12 +1032,15 @@ export function parseResponsesToolCalls(response, label) {
             const call = customToolCallFromResponseItem(item);
             if (call) out.push(call);
         } else if (item?.type === 'tool_search_call') {
+            const _tsArgs = item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
+                ? item.arguments
+                : parseCompletedToolCallArgumentsJson(item.arguments || '{}', label, { id: item.call_id || item.id, name: 'tool_search', finishReason });
             out.push({
                 id: item.call_id || item.id,
                 name: 'tool_search',
-                arguments: item.arguments && typeof item.arguments === 'object'
-                    ? item.arguments
-                    : parseCompletedToolCallArgumentsJson(item.arguments || '{}', label, { id: item.call_id || item.id, name: 'tool_search', finishReason }),
+                // Schema is a plain object ({query,select,limit}); an array
+                // (parsed JSON or passthrough) must never pass through as args.
+                arguments: (_tsArgs && typeof _tsArgs === 'object' && !Array.isArray(_tsArgs)) ? _tsArgs : {},
                 nativeType: 'tool_search_call',
             });
         }
@@ -1284,8 +1287,7 @@ export class OpenAICompatProvider {
         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.
+        // TLS handshake after an idle gap. Fire-and-forget; never awaited.
         preconnect(this.baseURL);
         if (this.name === 'xai' && useXaiResponsesApi(opts, this.config)) {
             if (useXaiResponsesWebSocket(opts, this.config)) {

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

@@ -9,10 +9,10 @@
  * `input` delta plus `previous_response_id`, skipping the full
  * tools/system/history prefix each turn.
  *
- * References:
- * - pi-mono packages/ai/src/providers/openai-codex-responses.ts
- *   (acquireWebSocket/release, get_incremental_items delta logic).
- * - openai/codex codex-rs/core/src/client.rs (turn-state echo header).
+ * Incremental-input reuse is decided by diffing against the cached request
+ * the socket last sent (see _sansInput below), and requests carry a
+ * turn-state echo header so the backend can correlate WS frames to the
+ * in-flight turn.
  *
  * Exposes:
  *   sendViaWebSocket({ auth, body, sendOpts, onStreamDelta, onToolCall,
@@ -83,9 +83,8 @@ const WS_PRE_RESPONSE_CREATED_MS = (() => {
     if (Number.isFinite(n) && n > 0) return Math.min(Math.max(n, 1_000), 120_000);
     return 10_000;
 })();
-// Single inter-chunk idle timer. Resets on EVERY received frame (matches codex
-// responses_websocket.rs timeout(idle_timeout, ws_stream.next()) and mixdog
-// anthropic-oauth resetIdleTimer on every chunk).
+// Single inter-chunk idle timer. Resets on EVERY received frame — any frame,
+// including metadata/keepalive, proves the socket is live.
 const WS_INTER_CHUNK_MS = PROVIDER_WS_INTER_CHUNK_TIMEOUT_MS;
 // Mid-stream retry budgets + backoff now live in the shared MIDSTREAM_RETRY_POLICY
 // table (retry-classifier.mjs). These aliases keep the local call sites readable
@@ -109,8 +108,8 @@ const WS_MIDSTREAM_POLICY = {
 // decision and just double the user-visible latency.
 // Aligned to the cross-provider default (retry-classifier DEFAULT_MAX_ATTEMPTS=5,
 // anthropic-oauth MAX_ATTEMPTS=5, withRetry-using providers all default to 5).
-// Previously 3 — bumped for parity so every provider exhausts the same number
-// of transient-5xx attempts before surfacing failure to the caller.
+// Bumped from 3 so this provider exhausts the same number of transient-5xx
+// attempts as the others before surfacing failure to the caller.
 const HANDSHAKE_MAX_ATTEMPTS = PROVIDER_RETRY_MAX_ATTEMPTS;
 const HANDSHAKE_BACKOFF_BASE_MS = 500;
 const HANDSHAKE_BACKOFF_CAP_MS = 5000;
@@ -942,9 +941,9 @@ function releaseWebSocket({ entry, poolKey, keep }) {
     _scheduleIdleClose(poolKey, entry);
 }
 
-// Port of pi-mono get_incremental_items: if the cached request (sans input)
-// matches the current one and the current input starts with the cached input,
-// return only the tail. Otherwise return the full input (fresh turn).
+// If the cached request (sans input) matches the current one and the current
+// input starts with the cached input, return only the tail. Otherwise return
+// the full input (fresh turn).
 function _sansInput(body) {
     const { input: _ignored, previous_response_id: _prevIgnored, ...rest } = body;
     return rest;
@@ -1214,19 +1213,23 @@ function _wsErrLabel(p) {
     return 'OpenAI OAuth WS';
 }
 // tool_search_call.arguments parse. Module-scope (exported) for direct test
-// coverage. Native convergence (openai-oauth / anthropic-oauth / opencode): same policy
-// as the function_call_arguments.done path and openai-oauth _parseJsonObject —
+// coverage. Same policy as the function_call_arguments.done path and
+// openai-oauth _parseJsonObject —
 // object passes through; null/non-string/empty/whitespace → {} (no args); a
 // non-empty string that fails JSON.parse is deterministic bad JSON, surfaced
 // as an invalid-args MARKER (not silently swallowed to {}) so the dispatch
 // loop returns an is_error tool_result and the model self-corrects in the same
 // turn.
 export function parseToolSearchArgs(value) {
-    if (value && typeof value === 'object') return value;
+    if (value && typeof value === 'object') {
+        // Reject arrays — the tool_search schema is an object
+        // ({query,select,limit}); an array must never pass through as args.
+        return Array.isArray(value) ? {} : value;
+    }
     if (typeof value !== 'string' || !value.trim()) return {};
     try {
         const parsed = JSON.parse(value);
-        return parsed && typeof parsed === 'object' ? parsed : {};
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
     } catch (err) {
         return makeInvalidToolArgsMarker(value, err instanceof Error ? err.message : String(err));
     }
@@ -1456,7 +1459,7 @@ export async function _streamResponse({
     let messageHandler = null;
     let closeHandler = null;
     let errorHandler = null;
-    // SEMANTIC idle timer (pi per-event parity): distinct from the inter-chunk
+    // SEMANTIC idle timer: distinct from the inter-chunk
     // timer, which resets on EVERY frame (rate_limits/metadata/keepalive keep
     // the socket "alive"). This timer resets ONLY on meaningful output deltas
     // (text/reasoning/tool args — the same events that call onStreamDelta) so a
@@ -1561,7 +1564,7 @@ export async function _streamResponse({
             semanticIdleTimer = setTimeout(() => {
                 traceWsTimeout('semantic_idle_timeout', semanticIdleMs);
                 terminalError = streamStalledError('Responses WS', semanticIdleMs, { emittedToolCall: !!midState?.emittedToolCall });
-                // Partial-final recovery parity: attach streamed partial state so
+                // Partial-final recovery: attach streamed partial state so
                 // a wedged FINAL no-tool summary can be accepted as partial-final
                 // success by the loop. pendingToolUse gates out mid-flight tools.
                 try {
@@ -1633,7 +1636,7 @@ export async function _streamResponse({
         messageHandler = (data) => {
             resetIdle();
             // resetIdle() above resets the SINGLE inter-chunk idle timer on
-            // EVERY received frame (codex parity) — response.created, metadata,
+            // EVERY received frame — response.created, metadata,
             // rate_limits, and all deltas keep the socket alive. Separately, do
             // NOT call onStreamDelta for every frame — metadata/keepalive frames
             // must not reset the agent stall watchdog's lastStreamDeltaAt. Only
@@ -1706,6 +1709,13 @@ export async function _streamResponse({
                         _toolInFlight = true;
                     } else if (event.item?.type === 'custom_tool_call') {
                         _toolInFlight = true;
+                    } else if (event.item?.type === 'tool_search_call') {
+                        // Mark tool_search in-flight at item-added time, same
+                        // as function_call/custom_tool_call above, so the
+                        // semantic-idle stall gate's pendingToolUse never
+                        // drops a mid-flight tool_search before
+                        // response.output_item.done.
+                        _toolInFlight = true;
                     }
                     break;
                 case 'response.function_call_arguments.delta':
@@ -1723,10 +1733,10 @@ export async function _streamResponse({
                     const pending = pendingCalls.get(itemId);
                     // function_call_arguments.done is a completion signal:
                     // empty/whitespace → no args ({}); a non-empty string that
-                    // fails JSON.parse is deterministic bad JSON. Native
-                    // convergence: surface an invalid-args MARKER (not silent
-                    // {}) so the dispatch loop returns an is_error tool_result
-                    // and the model re-issues valid JSON in the same turn.
+                    // fails JSON.parse is deterministic bad JSON. Surface an
+                    // invalid-args MARKER (not silent {}) so the dispatch loop
+                    // returns an is_error tool_result and the model re-issues
+                    // valid JSON in the same turn.
                     let args = {};
                     {
                         const _argText = typeof event.arguments === 'string' ? event.arguments : '';

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

@@ -56,14 +56,13 @@ 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 — the OAuth backend rejects the
-// request without it. Keep close to the latest published @openai/codex CLI because
-// older versions trigger a visibility-filtered catalog (e.g. only rollout
-// models). Bump when the real CLI bumps.
-// OpenAI OAuth backend gates new model exposures (e.g. gpt-5.5 only on >= 0.130.0)
-// on the client_version header. Resolve dynamically from npm so newly-shipped
-// models surface within a day instead of waiting on a hardcoded bump here.
-// Cached 24h in-process; npm failure falls back to the floor below.
+// Version string baked into the models endpoint query — the OAuth backend
+// rejects the request without it, and gates new model exposures (e.g.
+// gpt-5.5 only on >= 0.130.0) on this client_version header; older versions
+// trigger a visibility-filtered catalog (e.g. only rollout models). Resolved
+// dynamically from npm so newly-shipped models surface within a day instead
+// of waiting on a hardcoded bump here. Cached 24h in-process; npm failure
+// falls back to the floor below.
 const CODEX_CLIENT_VERSION_FLOOR = '0.130.0';
 const CODEX_VERSION_CACHE_TTL_MS = 24 * 60 * 60_000;
 let _codexVersionCache = { value: null, fetchedAt: 0 };
@@ -587,7 +586,7 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         providerState: opts.providerState,
         model,
     });
-    // Match the body shape pi-mono and the official OpenAI CLI ship so the
+    // Match the request body shape the OAuth backend expects so the
     // server-side auto-cache routes correctly. text.verbosity / include /
     // tool_choice / parallel_tool_calls are all inert without side effects
     // for most callers but their presence affects how the OAuth backend classifies the
@@ -618,8 +617,8 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     if (opts.fast === true) {
         // 'priority' is the only fast-class value the OpenAI OAuth backend
         // accepts on the wire: 'fast' is hard-rejected ("Unsupported
-        // service_tier: fast", probed 2026-06-11). Match official CLI behavior:
-        // only send the request value when the model catalog advertises it.
+        // service_tier: fast", probed 2026-06-11). Only send the request value
+        // when the model catalog advertises it.
         if (codexModelSupportsServiceTier(model, 'priority')) {
             body.service_tier = 'priority';
         }
@@ -669,8 +668,8 @@ function _envPositiveInt(name, fallback) {
 }
 
 // Completed function_call.arguments parse for the OpenAI Responses stream.
-// Native convergence (openai-oauth / anthropic-oauth / opencode): a function_call item
-// arrives only on a completion/done signal, so a non-empty-but-malformed
+// A function_call item arrives only on a completion/done signal, so a
+// non-empty-but-malformed
 // arguments string is deterministic bad JSON — NOT mid-stream truncation.
 // Empty/whitespace input legitimately means "no arguments" → {}. A non-empty
 // string that fails JSON.parse is surfaced as an invalid-args MARKER (instead
@@ -888,7 +887,7 @@ export async function sendViaHttpSse({
         _clearSemanticIdle();
         _semanticIdleTimer = setTimeout(() => {
             _streamAbortReason = streamStalledError('OpenAI OAuth HTTP fallback', PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS, { emittedToolCall: emittedToolCallIds.size > 0 });
-            // Partial-final recovery parity with anthropic-oauth: attach the
+            // Partial-final recovery: attach the
             // streamed partial state so the agent loop can accept a wedged FINAL
             // no-tool summary as a successful partial-final instead of dropping
             // the result. pendingToolUse gates out any mid-flight tool call.
@@ -1076,6 +1075,22 @@ export async function sendViaHttpSse({
                         name: event.item.name || '',
                         callId: event.item.call_id || '',
                     });
+                } else if (event.item?.type === 'tool_search_call') {
+                    // Mark tool_search as in-flight the moment the item is
+                    // added, mirroring function_call above, so the semantic
+                    // idle watchdog's pendingToolUse gate (pendingCalls.size)
+                    // sees a mid-flight tool_search and never lets stall
+                    // recovery drop it before response.output_item.done.
+                    // kind:'tool_search' tags the entry so the shared
+                    // function_call_arguments.done handler (below) never
+                    // mistakes it for a function call by id collision/empty id.
+                    if (event.item.id) {
+                        pendingCalls.set(event.item.id, {
+                            name: 'tool_search',
+                            callId: event.item.call_id || '',
+                            kind: 'tool_search',
+                        });
+                    }
                 }
                 break;
             case 'response.function_call_arguments.delta':
@@ -1084,6 +1099,7 @@ export async function sendViaHttpSse({
             case 'response.function_call_arguments.done': {
                 const itemId = event.item_id || '';
                 const pending = pendingCalls.get(itemId);
+                if (pending?.kind === 'tool_search') { meaningful(); break; }
                 const call = {
                     id: pending?.callId || event.call_id || '',
                     name: pending?.name || event.name || '',
@@ -1116,6 +1132,7 @@ export async function sendViaHttpSse({
                         }
                     }
                 } else if (item.type === 'tool_search_call') {
+                    pendingCalls.delete(item.id || '');
                     pushToolSearchCall(item);
                 } else if (item.type === 'custom_tool_call') {
                     pushCustomToolCall(item);

package/src/runtime/agent/orchestrator/providers/opencode-go-usage.mjs

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { getOpenCodeGoAuthCookie } from '../../../shared/config.mjs';
+import { round, cleanString as clean } from './lib/usage-primitives.mjs';
 
 const CACHE_FILE = 'opencode-go-usage-cache.json';
 const LIVE_TTL_MS = 5 * 60_000;
@@ -18,23 +19,14 @@ const LIMITS_USD = Object.freeze({
 const DISK_JSON_MEMORY_TTL_MS = 1000;
 let diskJsonCache = { at: 0, file: '', value: null };
 
+// Local unguarded `num`: this module intentionally coerces '' to 0 via
+// Number(''), unlike the guarded shared num() in lib/usage-primitives.mjs.
+// Behavior differs on empty-string input, so it stays local.
 function num(value, fallback = null) {
   const n = Number(value);
   return Number.isFinite(n) ? n : fallback;
 }
 
-function round(value, digits = 4) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return null;
-  const scale = 10 ** digits;
-  return Math.round(n * scale) / scale;
-}
-
-function clean(value) {
-  const text = typeof value === 'string' ? value.trim() : '';
-  return text || null;
-}
-
 function cachePath() {
   return join(resolvePluginData(), CACHE_FILE);
 }
@@ -249,7 +241,41 @@ export function openCodeGoUsageConfigStatus(config = {}) {
   };
 }
 
+// Primary discovery: GET /auth with the auth cookie, follow-manual. The
+// console redirects authenticated sessions straight to /workspace/{id};
+// unauthenticated/invalid cookies redirect to /auth/authorize instead.
+// This avoids depending on the hashed server-fn id used by the /_server
+// probe (WORKSPACES_SERVER_ID), which can change across console deploys.
+async function fetchWorkspaceIdFromAuthRedirect(authCookie, { signal } = {}) {
+  let res;
+  try {
+    res = await fetch(`${BASE_URL}/auth`, {
+      signal,
+      redirect: 'manual',
+      headers: requestHeaders(authCookie),
+    });
+  } catch {
+    return null; // network/redirect-mode quirk: let the _server fallback decide
+  }
+  if (res.status === 401 || res.status === 403) {
+    const err = new Error('OpenCode Go console auth failed');
+    err.code = 'OPENCODE_GO_USAGE_AUTH_FAILED';
+    throw err;
+  }
+  const location = res.headers.get('location') || '';
+  if (!location) return null;
+  if (/(?:^|\/|\.\/)auth\/authorize\b/.test(location)) {
+    const err = new Error('OpenCode Go console auth failed');
+    err.code = 'OPENCODE_GO_USAGE_AUTH_FAILED';
+    throw err;
+  }
+  const workspaceMatch = location.match(/\/workspace\/(wrk_[a-zA-Z0-9]+)/);
+  return normalizeWorkspaceId(workspaceMatch ? workspaceMatch[1] : location);
+}
+
 async function fetchWorkspaceId(authCookie, { signal } = {}) {
+  const fromRedirect = await fetchWorkspaceIdFromAuthRedirect(authCookie, { signal });
+  if (fromRedirect) return fromRedirect;
   const url = new URL(`${BASE_URL}/_server`);
   url.searchParams.set('id', WORKSPACES_SERVER_ID);
   const res = await fetch(url, {

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -232,12 +232,11 @@ export function jitterDelayMs(ms, ratio = PROVIDER_RETRY_JITTER_RATIO, mode = 's
 }
 
 // ── Shared network-resilience interface ──────────────────────────────────────
-// One home for the logic that used to be copied per provider: mid-stream
-// classifier (WS + SSE), transport fallback predicate, stream-safety stamp
-// latches, abort-aware sleep, handshake classifier, and the retry-budget table.
-// Provider differences are passed as ARGUMENTS (policy objects), never branched
-// on a hardcoded provider name. Behavior is preserved EXACTLY — each path below
-// is the relocated original, selected by policy.mode.
+// One home for the logic shared across providers: mid-stream classifier
+// (WS + SSE), transport fallback predicate, stream-safety stamp latches,
+// abort-aware sleep, handshake classifier, and the retry-budget table.
+// Provider differences are passed as ARGUMENTS (policy objects), never
+// branched on a hardcoded provider name.
 
 // F) Retry-budget profiles as DATA. The numbers live ONLY here now.
 //    ws.transientCloseRetries (4) — ws_1006 / ws_1011 connection-loss buckets.
@@ -260,8 +259,8 @@ function _midstreamLimitFor(classifier, policy) {
   return policy.defaultRetries
 }
 
-// WS gates each classifier against its own budget (mirrors the old
-// _allowMidstreamRetry). SSE applies a single top-of-function budget gate and
+// WS gates each classifier against its own budget. SSE applies a single
+// top-of-function budget gate and
 // then returns raw classifier strings, so perClassifierGate:false returns the
 // classifier unconditionally here.
 function _allowMidstream(classifier, attemptIndex, policy) {

package/src/runtime/agent/orchestrator/session/loop/compact-debug.mjs

@@ -0,0 +1,28 @@
+// Compaction debug/diagnostic helpers extracted from loop.mjs.
+import { estimateMessagesTokens } from '../context-utils.mjs';
+
+export function estimateMessagesTokensSafe(messages) {
+    try { return estimateMessagesTokens(messages); }
+    catch { return null; }
+}
+
+export function compactDebugEnabled() {
+    return String(process.env.MIXDOG_COMPACT_DEBUG || '').trim() === '1';
+}
+
+export function compactDiagnosticError(err) {
+    if (!err) return null;
+    const text = String(err?.message || err);
+    return text.length > 500 ? `${text.slice(0, 499)}…` : text;
+}
+
+export function compactByteLength(text) {
+    try { return Buffer.byteLength(String(text || ''), 'utf8'); }
+    catch { return String(text || '').length; }
+}
+
+export function compactDebugLog(scope, details = {}) {
+    if (!compactDebugEnabled()) return;
+    try { process.stderr.write(`[compact] ${scope} ${JSON.stringify(details)}\n`); }
+    catch { /* best-effort diagnostics only */ }
+}