mixdog 1.0.11 → 1.1.0

package/src/tui/session/turn.mjs

@@ -152,6 +152,8 @@ function promptRestoreFor(displayText, options, submittedIds, content = null) {
     onCommitted: typeof options.onCommitted === 'function' ? options.onCommitted : null,
     restorable: options.restorable !== false,
     submittedIds,
+    // Which device submitted the prompt: only that device may get it back.
+    device: typeof options.transcriptMeta?.device === 'string' ? options.transcriptMeta.device : '',
     reclaimed: false,
     committed: false,
     requeueEntries: Array.isArray(options.requeueOnAbort) ? options.requeueOnAbort.slice() : [],
@@ -190,6 +192,9 @@ function steeringItemExtras(steeringMeta) {
     ...(typeof steeringMeta?.transcriptMeta?.sender === 'string' && steeringMeta.transcriptMeta.sender
       ? { sender: steeringMeta.transcriptMeta.sender }
       : {}),
+    ...(typeof steeringMeta?.transcriptMeta?.device === 'string' && steeringMeta.transcriptMeta.device
+      ? { device: steeringMeta.transcriptMeta.device }
+      : {}),
   };
 }
 
@@ -389,7 +394,7 @@ function completeTurn(ctx, result, session) {
   turn.finishedNormally = true;
 }
 
-function failTurn(ctx, error) {
+export function failTurn(ctx, error) {
   const { turn, stream, cards, pushNotice } = ctx;
   flushStreamBatch(stream); // ensure any batched text lands before the error notice
   if (isCancelLikeError(error)) {
@@ -401,12 +406,20 @@ function failTurn(ctx, error) {
   turn.failed = true;
   cards.aggregates.finalizeToolHeaders();
   turn.usageLimited = isUsageLimitError(error);
+  const exhausted = error?.quotaExhausted;
+  if (exhausted && typeof exhausted === 'object') {
+    turn.quota = {
+      provider: String(exhausted.provider || turn.routeMeta?.provider || ''),
+      model: String(exhausted.model || turn.routeMeta?.model || ''),
+      resetAt: Number.isFinite(exhausted.resetAt) ? exhausted.resetAt : null,
+    };
+  }
   turn.failureDetail = toolErrorDisplay(error, 'turn').replace(/^Error:\s*/i, '');
   turn.failureDiagnostic = safeErrorDetails(errText(error));
   pushNotice(turn.failureDetail, 'error', { owner: 'transcript' });
 }
 
-function turnDoneItem({ turn, stream, cards, getState, nextId }) {
+export function turnDoneItem({ turn, stream, cards, getState, nextId }) {
   return {
     kind: 'turndone',
     id: nextId(),
@@ -421,11 +434,11 @@ function turnDoneItem({ turn, stream, cards, getState, nextId }) {
     thinkingElapsedMs: stream.thinkingStartedAt ? stream.accumulatedThinkingMs : 0,
     toolCount: cards.toolCards.length,
     verb: turn.completionVerb,
-    ...(typeof turn.askResult?.autoEffort === 'string' ? { autoEffort: turn.askResult.autoEffort } : {}),
     at: Date.now(),
     ...(turn.failureDetail ? { detail: turn.failureDetail } : {}),
     ...(turn.failureDiagnostic ? { errorDetails: turn.failureDiagnostic } : {}),
     ...turn.routeMeta,
+    ...(turn.failed && turn.quota ? { quota: turn.quota } : {}),
   };
 }
 
@@ -463,6 +476,14 @@ function publishTurnClose(ctx, closingItems) {
     toolMode: runtime.toolMode,
     ...agentStatusState({ force: true }),
   });
+  // Same frame as the failed turndone and busy=false: the resume is queued
+  // (and `quotaResume` published) before anything can observe the idle
+  // session, so a cancel at any later point finds it and wins.
+  if (turn.failed && turn.quota) {
+    try {
+      ctx.bag.beginQuotaSettlement?.();
+    } catch {}
+  }
   ctx.flushDeferredExecutionPendingResumeKick();
 }
 
@@ -503,8 +524,12 @@ async function settleTurn(ctx) {
   try {
     options.onSettled?.(detail);
   } catch {}
+  // A quota failure suspends only a Goal that was running when it struck.
+  const quotaFailed = turn.failed && turn.quota && isCurrentTurn();
+  const goalBefore = quotaFailed ? runtime.goalStatus?.() || null : null;
+  let settledGoal = null;
   try {
-    await bag.onGoalTurnSettled?.({
+    settledGoal = await bag.onGoalTurnSettled?.({
       status: finalStatus,
       error: turn.failureDiagnostic || turn.failureDetail || null,
       usageLimited: turn.usageLimited,
@@ -521,6 +546,17 @@ async function settleTurn(ctx) {
       }),
     });
   } catch {}
+  if (turn.failed && turn.quota) {
+    const suspended =
+      quotaFailed &&
+      !flags.disposed &&
+      goalBefore?.status === 'active' &&
+      settledGoal?.status === 'usage_limited' &&
+      settledGoal.id === goalBefore.id;
+    try {
+      bag.finishQuotaSettlement?.({ suspendedGoalId: suspended ? settledGoal.id : '' });
+    } catch {}
+  }
   if (flags.goalSteeringAbortEpoch === turn.epoch) flags.goalSteeringAbortEpoch = null;
   ctx.tuiDebug(
     `runTurn end turn=${turn.index} status=${finalStatus} elapsedMs=${Date.now() - turn.startedAt} pending=${ctx.pending.length}`

package/src/vendor/statusline/bin/statusline-route.mjs

@@ -17,6 +17,7 @@ import {
 } from '../src/gateway/route-meta.mjs';
 import { getModelMetadataSync } from '../../../runtime/agent/orchestrator/providers/model-catalog.mjs';
 import { resolveRuntimeRoot } from '../../../runtime/shared/runtime-root.mjs';
+import { withDefaultPresets } from '../../../runtime/agent/orchestrator/config-presets.mjs';
 
 function positiveInt(value) {
   const n = parseInt(String(value || ''), 10);
@@ -142,7 +143,7 @@ function resolveConfiguredModelTarget(cfg, rawModel) {
   const lower = stripped.toLowerCase();
   const agent = cfg?.agent && typeof cfg.agent === 'object' ? cfg.agent : {};
   const providers = agent.providers && typeof agent.providers === 'object' ? agent.providers : {};
-  const presets = Array.isArray(agent.presets) ? agent.presets : [];
+  const presets = withDefaultPresets(agent.presets);
   for (const p of presets) {
     if (!p || typeof p !== 'object' || !p.provider || !p.model) continue;
     const providerEntry = providers[p.provider];
@@ -455,7 +456,7 @@ function configuredGatewayStatus(options = {}) {
     model = aliasTarget.model;
   }
   if (!provider || !model) return null;
-  const presets = Array.isArray(cfg?.agent?.presets) ? cfg.agent.presets : [];
+  const presets = withDefaultPresets(cfg?.agent?.presets);
   const preset = presets.find(p =>
     p?.provider === provider &&
     p?.model === model &&

package/src/vendor/statusline/src/gateway/route-meta.mjs

@@ -92,7 +92,7 @@ function cleanBool(value) {
   if (value === false) return false;
   if (typeof value === 'string') {
     const s = value.trim().toLowerCase();
-    if (['1', 'true', 'yes', 'on', 'fast', 'priority'].includes(s)) return true;
+    if (['1', 'true', 'yes', 'on', 'fast', 'priority', 'ultrafast'].includes(s)) return true;
     if (['0', 'false', 'no', 'off', 'none'].includes(s)) return false;
   }
   return null;

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

@@ -1,165 +0,0 @@
-/**
- * openai-ws-warmup.mjs — the Codex generate:false prewarm on a fresh socket.
- *
- * Codex performs generate:false during session startup, then hands the live
- * client session to the first real turn. The prewarm contains stable
- * instructions/tools but no live user/transcript input; its response id
- * becomes the anchor the first real request chains from.
- */
-import { performance } from 'node:perf_hooks';
-import { releaseWebSocket } from './openai-ws-pool.mjs';
-import { _anchorResponseChain, _buildResponseCreateFrame } from './openai-ws-delta.mjs';
-import { _metadataTrace, _withCodexWsClientMetadata } from './openai-codex-metadata.mjs';
-
-/** Only when the session has no prior request state. A reused pooled socket
- *  with a live chain must go straight to the real request. */
-export function startupWarmupApplies({ warmupBody, completedWarmup, attemptIndex, entry }) {
-  return (
-    Boolean(warmupBody) &&
-    typeof warmupBody === 'object' &&
-    !completedWarmup &&
-    attemptIndex === 0 &&
-    !entry.lastResponseId
-  );
-}
-
-/**
- * Sends the prewarm frame and streams its (empty) response. Throws on any
- * failure; the caller's stream-failure path handles it like the real send.
- * Returns the warmup result plus what the caller records about the wire
- * frame it produced.
- */
-export async function runStartupWarmup({
-  entry,
-  warmupBody,
-  attemptIndex,
-  codexMetadataContext,
-  useCodexWsClientMetadata,
-  sendSpan,
-  externalSignal,
-  logSuppressedReasoningDeltas,
-  traceProvider,
-  poolKey,
-  iteration,
-  useModel,
-  midState,
-  streamTimeouts,
-  sendFrame,
-  streamFn,
-  agentTraceFn,
-}) {
-  const warmupBuildStart = performance.now();
-  // Enforce the no-transcript rule at the transport boundary as well as in
-  // the OAuth caller so a future caller cannot accidentally duplicate the
-  // transcript. Keep the same request properties as the real turn; Codex
-  // changes only the input tail and adds generate:false.
-  const parityWarmupBody = {
-    ...warmupBody,
-    input: Array.isArray(warmupBody.input) ? warmupBody.input : [],
-    generate: false,
-  };
-  const warmupFrame = _buildResponseCreateFrame(parityWarmupBody);
-  const warmupMetadataContext = {
-    ...codexMetadataContext,
-    sendOpts: {
-      ...(codexMetadataContext?.sendOpts || {}),
-      requestKind: 'prewarm',
-      codexRequestKind: 'prewarm',
-    },
-  };
-  const wireWarmupFrame = _withCodexWsClientMetadata(
-    warmupFrame,
-    entry,
-    useCodexWsClientMetadata,
-    warmupMetadataContext
-  );
-  const wireFrameHadTurnState = !!wireWarmupFrame?.client_metadata?.['x-codex-turn-state'];
-  const wireFrameMetadataTrace = _metadataTrace(wireWarmupFrame?.client_metadata);
-  sendSpan.requestBuildSerializationMs += performance.now() - warmupBuildStart;
-  await sendFrame(entry, wireWarmupFrame, sendSpan);
-  const warmupStart = Date.now();
-  const warmupState = {
-    attemptIndex,
-    sawResponseCreated: false,
-    sawCompleted: false,
-    sessionId: poolKey,
-    iteration,
-    model: useModel,
-    traceProvider,
-    warmup: true,
-    sendSpan,
-    sendStartedAt: performance.now(),
-  };
-  const warmupResult = await streamFn({
-    entry,
-    externalSignal,
-    onStreamDelta: null,
-    onToolCall: null,
-    state: warmupState,
-    logSuppressedReasoningDeltas,
-    traceProvider,
-    _timeouts: streamTimeouts,
-  });
-  // Surface warmup-time first-event timeout / send-failure flags onto the
-  // shared midState so the outer catch's classifier sees them.
-  // (warmupResult itself only resolves on success; failures throw.)
-  if (warmupState.firstByteTimeout) midState.firstByteTimeout = true;
-  if (warmupState.wsSendFailed) midState.wsSendFailed = true;
-  if (!warmupResult?.responseId) {
-    throw new Error('Responses WS warmup completed without response id');
-  }
-  const completedWarmup = {
-    requestBody: parityWarmupBody,
-    responseId: warmupResult.responseId,
-    usage: warmupResult.usage,
-  };
-  _anchorResponseChain(entry, {
-    responseId: warmupResult.responseId,
-    requestBody: parityWarmupBody,
-    responseItems: warmupResult.responseItems,
-    normalizeWarmupGenerate: useCodexWsClientMetadata,
-  });
-  try {
-    const warmupPayload = {
-      provider: traceProvider,
-      transport: 'websocket',
-      event: 'warmup_completed',
-      response_id: warmupResult.responseId,
-      elapsed_ms: Date.now() - warmupStart,
-      input_tokens: warmupResult.usage?.inputTokens || 0,
-      cached_tokens: warmupResult.usage?.cachedTokens || 0,
-      output_tokens: warmupResult.usage?.outputTokens || 0,
-      prompt_tokens: warmupResult.usage?.promptTokens || 0,
-    };
-    agentTraceFn({
-      sessionId: poolKey,
-      iteration,
-      kind: 'cache_warmup',
-      ...warmupPayload,
-      payload: warmupPayload,
-    });
-  } catch {}
-  return { warmupResult, completedWarmup, wireFrameHadTurnState, wireFrameMetadataTrace };
-}
-
-/** Startup callers stop after the prewarm: the pooled entry retains its
- *  response id, request snapshot and socket for the later real send. */
-export function startupPrewarmResult({ entry, poolKey, cacheKey, warmupResult, startupWarmupResponseId, useModel }) {
-  const responseId = warmupResult?.responseId || startupWarmupResponseId || entry.lastResponseId || null;
-  if (responseId) entry.startupWarmupResponseId = responseId;
-  else releaseWebSocket({ entry, poolKey, keep: false });
-  return {
-    content: '',
-    model: warmupResult?.model || useModel,
-    toolCalls: [],
-    usage: warmupResult?.usage || {
-      inputTokens: 0,
-      outputTokens: 0,
-      cachedTokens: 0,
-      cacheWriteTokens: 0,
-      promptTokens: 0,
-    },
-    startupPrewarm: !!responseId,
-    startupPrewarmHandle: responseId ? { entry, poolKey, cacheKey } : null,
-  };
-}