mixdog 1.3.5 → 1.4.1

package/src/runtime/agent/orchestrator/providers/media-normalization.mjs

@@ -274,7 +274,7 @@ function* walkContentParts(content) {
  * beforehand by preparePdfTextForProvider, so one reaching here is a bug.
  * Null when the part is not a file at all.
  */
-export function textFormOfFilePart(part) {
+function textFormOfFilePart(part) {
   if (part?.type !== 'file' && part?.type !== 'document') return null;
   try {
     const file = fileInfo(part);
@@ -840,6 +840,56 @@ function partCarriesLiveMedia(part) {
   return Array.isArray(part.content) && contentCarriesLiveMedia(part.content);
 }
 
+/** An image part in any spelling the providers use: inline, URL, file id or
+ *  URI, Gemini inline data. */
+function isImagePart(part) {
+  return Boolean(
+    part.type === 'image' ||
+      part.type === 'image_url' ||
+      part.type === 'input_image' ||
+      imageUrlFromPart(part) ||
+      imageFileIdFromPart(part) ||
+      imageFileUriFromPart(part) ||
+      geminiInlineInfo(part)
+  );
+}
+
+function mapPartText(part, mapText) {
+  if (typeof part === 'string') return mapText(part);
+  if (!part || typeof part !== 'object') return part;
+  // Media and attachment references are encodings, never text.
+  if (isAttachmentReference(part) || isImagePart(part) || fileInfo(part)) return part;
+  for (const key of ['text', 'content']) {
+    if (typeof part[key] === 'string') {
+      const next = mapText(part[key]);
+      return next === part[key] ? part : { ...part, [key]: next };
+    }
+  }
+  if (Array.isArray(part.content)) {
+    const nextContent = mapContentText(part.content, mapText);
+    if (nextContent !== part.content) return { ...part, content: nextContent };
+  }
+  return part;
+}
+
+/** `content` with `mapText` applied to its text and nothing else: a string,
+ *  the text a text part or a part's string content carries (textFromPart),
+ *  and nested part content; media parts and attachment references stay as
+ *  they are. The same value when nothing changed. */
+export function mapContentText(content, mapText) {
+  if (typeof content === 'string') return mapText(content);
+  const parts = contentParts(content);
+  if (!parts) return content;
+  let changed = false;
+  const out = parts.map((part) => {
+    const next = mapPartText(part, mapText);
+    if (next !== part) changed = true;
+    return next;
+  });
+  if (!changed) return content;
+  return Array.isArray(content) ? out : { ...content, content: out };
+}
+
 function sanitizePartForStoredHistory(part) {
   if (typeof part === 'string') return part;
   if (!part || typeof part !== 'object') return part;
@@ -849,15 +899,7 @@ function sanitizePartForStoredHistory(part) {
   // reloading the session keeps the provider prompt cache intact.
   const storedImage = part.type === 'image' ? storedImagePart(part) : null;
   if (storedImage) return storedImage;
-  if (
-    part.type === 'image' ||
-    part.type === 'image_url' ||
-    part.type === 'input_image' ||
-    imageUrlFromPart(part) ||
-    imageFileIdFromPart(part) ||
-    imageFileUriFromPart(part) ||
-    geminiInlineInfo(part)
-  ) {
+  if (isImagePart(part)) {
     return { type: 'text', text: storedHistoryImagePlaceholder(part) };
   }
   const file = fileInfo(part);

package/src/runtime/agent/orchestrator/providers/mimo-oauth-login.mjs

@@ -2,6 +2,7 @@
 // X25519 public key we send in the authorize URL; the reply (loopback redirect
 // or a pasted code) carries `u` = ephemeralPub(32) | nonce(12) | ciphertext | tag(16).
 import { createServer } from 'node:http';
+import { listenOn } from './lib/listen-on.mjs';
 import { lookup } from 'node:dns/promises';
 import { createDecipheriv, createHash, createPublicKey, diffieHellman, generateKeyPairSync } from 'node:crypto';
 import { openLoginUrl } from './lib/open-login-url.mjs';
@@ -112,16 +113,6 @@ async function loopbackAddresses() {
   return ['127.0.0.1'];
 }
 
-function listenOn(server, port, host) {
-  return new Promise((resolve, reject) => {
-    server.once('error', reject);
-    server.listen(port, host, () => {
-      server.off('error', reject);
-      resolve();
-    });
-  });
-}
-
 export async function beginOAuthLogin({
   openBrowser = true,
   timeoutMs = LOGIN_TIMEOUT_MS,

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.d.mts

@@ -5,7 +5,14 @@ export const MODEL_PROXY_OPERATIONS: Readonly<{
   resolve: 'modelProxyResolve';
   heartbeat: 'modelProxyHeartbeat';
 }>;
-export type ModelProxyMethod = 'send' | 'listModels' | 'refreshModels' | 'isAvailable' | 'resolveWireRoute' | 'providerConfig';
+export type ModelProxyMethod =
+  | 'send'
+  | 'listModels'
+  | 'refreshModels'
+  | 'isAvailable'
+  | 'quotaUsable'
+  | 'resolveWireRoute'
+  | 'providerConfig';
 export const MODEL_PROXY_METHODS: ReadonlyArray<ModelProxyMethod>;
 export const MODEL_PROXY_HEARTBEAT_MS: number;
 export const MODEL_PROXY_LEASE_MS: number;

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.mjs

@@ -34,6 +34,7 @@ export const MODEL_PROXY_METHODS = Object.freeze([
   'listModels',
   'refreshModels',
   'isAvailable',
+  'quotaUsable',
   'resolveWireRoute',
   'providerConfig',
 ]);

package/src/runtime/agent/orchestrator/providers/npm-cli-version.mjs

@@ -8,6 +8,7 @@
 // so a new process (or an offline one) starts from the newest version this
 // machine has seen rather than from a floor that only moves with a release.
 
+import { runAbortable } from '../../../shared/abort-race.mjs';
 import { readLastKnownVersion, rememberLastKnownVersion } from './client-version-store.mjs';
 
 const SEMVER = /^\d+\.\d+\.\d+$/;
@@ -41,11 +42,18 @@ export async function parseNpmLatest(res) {
   return SEMVER.test(v) ? v : null;
 }
 
-/** One GET of `url` parsed to a version; null when offline, slow, or unrecognised. */
+/** One GET of `url` parsed to a version; null when offline, slow, or unrecognised.
+ *  The deadline settles the lookup itself instead of relying on the request
+ *  and its body read to honour the abort: a send awaits this lookup, and its
+ *  timer is unref'd, so once the abort tears the socket down nothing else is
+ *  left to wake a read that missed it. */
 export async function fetchRemoteVersion(url, parse, timeoutMs = TIMEOUT_MS) {
+  const signal = AbortSignal.timeout(timeoutMs);
   try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
-    return res.ok ? (await parse(res)) || null : null;
+    return await runAbortable(signal, async () => {
+      const res = await fetch(url, { signal });
+      return res.ok ? (await parse(res)) || null : null;
+    });
   } catch {
     return null;
   }

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -5,6 +5,7 @@ import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { cursorTokenExpiry } from './cursor-auth.mjs';
 import { describeDevinOAuthCredentials } from './devin-auth.mjs';
+import { isSignedInTokenDocument } from './lib/oauth-token-utils.mjs';
 import { isValidMuseCredentialDocument } from './muse-code-oauth-tokens.mjs';
 import { isValidOpenCodeGoCredentialDocument } from './opencode-go-oauth-tokens.mjs';
 import { developerOptionEnabled, developerOptionForProvider } from '../../../shared/developer-options.mjs';
@@ -152,7 +153,7 @@ function openAIOAuthState() {
       join(resolvePluginData(), 'openai-oauth.json'),
   ];
   return memoProbe('openai-oauth', paths, () =>
-    resolveProbeState(paths, (docs) => docs.some((raw) => !!(raw?.access_token && raw?.refresh_token)))
+    resolveProbeState(paths, (docs) => docs.some((raw) => isSignedInTokenDocument(raw)))
   );
 }
 

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

@@ -184,6 +184,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
                 signal: attemptSignal,
                 label: provider.name,
                 providerName: provider.name,
+                sessionId: opts.sessionId,
                 onStreamDelta: opts.onStreamDelta,
                 onToolCall: opts.onToolCall,
                 onTextDelta: opts.onTextDelta,

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

@@ -5,7 +5,14 @@
  */
 import { mergeToolCallDelta } from './tool-call-acc.mjs';
 import { reportStreamItemStart } from '../lib/send-callbacks.mjs';
-import { appendText, drainLeakedCalls, relayText, reportProgress, reportTransport } from './stream-state.mjs';
+import {
+  appendText,
+  drainLeakedCalls,
+  relayText,
+  reportLifecycle,
+  reportProgress,
+  reportTransport,
+} from './stream-state.mjs';
 import { chatContentParts } from '../openai-compat-reasoning-field.mjs';
 
 function appendReasoning(state, text, source) {
@@ -50,7 +57,7 @@ export function applyCompatChunk(state, chunk) {
   const choice = chunk?.choices?.[0];
   const delta = choice?.delta;
   if (typeof delta?.role === 'string' && delta.role) {
-    reportProgress(state, 'semantic');
+    reportLifecycle(state, 'semantic');
   }
   const contentParts = chatContentParts(delta?.content);
   if (contentParts) applyContentParts(state, contentParts);

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

@@ -70,6 +70,13 @@ export function reportProgress(state, kind) {
   } catch {}
 }
 
+/** Chunk metadata without output (a role-only delta): progress once the
+ *  model has produced output; before that it neither ends the first-output
+ *  phase nor starts the semantic idle (the chunk already reported transport). */
+export function reportLifecycle(state, kind) {
+  if (state.semanticIdleDeadlineAt > 0) reportProgress(state, kind);
+}
+
 /** Text the model exposed: accumulate, refresh the idle deadline, relay live. */
 export function appendText(state, text) {
   state.content += text;

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

@@ -10,6 +10,7 @@ import {
   PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
   PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
   createTimeoutSignal,
+  providerFirstOutputTimeoutMs,
 } from '../stall-policy.mjs';
 import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import {
@@ -28,6 +29,7 @@ import {
   toolWorkStarted,
 } from './openai-compat-chat-stream/stream-state.mjs';
 import { applyCompatChunk } from './openai-compat-chat-stream/chunk-events.mjs';
+import { streamFirstOutputWindow } from './lib/first-output-window.mjs';
 import { incompleteStreamError, settleCompatStream } from './openai-compat-chat-stream/stream-result.mjs';
 
 export async function consumeCompatChatCompletionStream(
@@ -45,11 +47,20 @@ export async function consumeCompatChatCompletionStream(
     semanticIdleTimeoutMs,
     firstByteTimeoutMs,
     leakedToolCallRecovery = true,
+    sessionId = null,
   } = {}
 ) {
   const idleOverrideEnabled = Number.isFinite(Number(semanticIdleTimeoutMs)) && Number(semanticIdleTimeoutMs) > 0;
   const idleEnabled = idleOverrideEnabled || PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
   const idleMs = idleOverrideEnabled ? Number(semanticIdleTimeoutMs) : PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS;
+  // Until the first semantic output the logical request's first-output window
+  // bounds the stream; a request that already had output runs under the
+  // semantic idle from the stream's opening.
+  const firstOutput = streamFirstOutputWindow({
+    sessionId,
+    onStreamDelta,
+    timeoutMs: providerFirstOutputTimeoutMs(idleMs),
+  });
   const state = createCompatStreamState({
     providerName,
     knownToolNames,
@@ -60,6 +71,7 @@ export async function consumeCompatChatCompletionStream(
     onStreamItemStart,
     leakedToolCallRecovery,
   });
+  if (firstOutput.outputSeen) state.semanticIdleDeadlineAt = Date.now() + idleMs;
   reportTransport(state);
   const iterator = stream[Symbol.asyncIterator]();
   let iteratorDone = false;
@@ -72,9 +84,8 @@ export async function consumeCompatChatCompletionStream(
     while (true) {
       const { value: chunk, done } = await nextAsyncWithWatchdog(iterator, {
         signal: state.sawFirstEvent ? signal : firstByteTimeout.signal,
-        idleMs,
-        idleDeadlineAt: state.semanticIdleDeadlineAt,
-        idleEnabled: state.sawFirstEvent && idleEnabled && state.semanticIdleDeadlineAt > 0,
+        ...firstOutput.idleWatch(state.semanticIdleDeadlineAt, idleMs),
+        idleEnabled: state.sawFirstEvent && idleEnabled,
         idleLabel: `${label} SSE idle`,
         streamLabel: label,
         emittedToolCall: () => toolWorkStarted(state),

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

@@ -147,7 +147,8 @@ function settleMaxOutputIncomplete(event, state, ctx, reason) {
 function onCreated(event, state, ctx) {
   if (event.response?.model) state.model = event.response.model;
   if (event.response?.id) state.responseId = event.response.id;
-  signal(ctx, 'semantic');
+  // Metadata, not output: progress only once the stream has seen output.
+  ctx.onLifecycle?.('semantic');
 }
 
 function onOutputTextDelta(event, state, ctx) {
@@ -196,7 +197,8 @@ function onOutputItemAdded(event, state, ctx) {
     state.toolInFlight = true;
   }
   reportStreamItemStart(ctx.onStreamItemStart, responsesItemStart(event.item));
-  signal(ctx, state.toolInFlight ? 'tool' : 'semantic');
+  if (state.toolInFlight) signal(ctx, 'tool');
+  else ctx.onLifecycle?.('semantic');
 }
 
 // A tool call's args (or custom-tool input) are streaming — mark tool work

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

@@ -241,6 +241,7 @@ async function streamCompatResponses({ provider, params, label, signal, opts, he
           return await consumeCompatResponsesStream(stream, {
             signal: attemptSignal,
             label,
+            sessionId: opts.sessionId,
             onStreamDelta: opts.onStreamDelta,
             onToolCall: opts.onToolCall,
             onTextDelta: opts.onTextDelta,

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

@@ -168,9 +168,11 @@ export async function nextAsyncWithWatchdog(
       }
       // The SDK JSON-decodes each frame inside next(): a SyntaxError here is a
       // malformed wire frame, typed at this boundary and nowhere else.
-      iterator.next().then(resolve, (error) =>
-        reject(error instanceof SyntaxError ? malformedCompatStreamError(streamLabel || idleLabel, error) : error)
-      );
+      iterator
+        .next()
+        .then(resolve, (error) =>
+          reject(error instanceof SyntaxError ? malformedCompatStreamError(streamLabel || idleLabel, error) : error)
+        );
     });
   } catch (err) {
     if (idleTimedOut)

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

@@ -7,6 +7,7 @@ import {
   PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
   PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
   createTimeoutSignal,
+  providerFirstOutputTimeoutMs,
 } from '../stall-policy.mjs';
 import {
   closeCompatStream,
@@ -23,6 +24,7 @@ import {
   parseCompletedToolCallArgumentsJson,
 } from './lib/openai-tool-args.mjs';
 import { handleCompatResponsesStreamEvent } from './openai-compat-responses-events.mjs';
+import { streamFirstOutputWindow } from './lib/first-output-window.mjs';
 import {
   attachPartialState,
   createResponsesLeakRelay,
@@ -56,6 +58,7 @@ export async function consumeCompatResponsesStream(
     responseOutputText,
     knownToolNames,
     semanticIdleTimeoutMs,
+    sessionId = null,
   } = {}
 ) {
   try {
@@ -68,13 +71,23 @@ export async function consumeCompatResponsesStream(
   const idleEnabled = idleOverrideEnabled || PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
   // Per-event (last-event-relative) SEMANTIC idle — see the Chat path note.
   const idleMs = idleOverrideEnabled ? Number(semanticIdleTimeoutMs) : PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS;
+  // Until the first semantic output the logical request's first-output window
+  // bounds the stream; a request that already had output runs under the
+  // semantic idle from the stream's opening.
+  const firstOutput = streamFirstOutputWindow({
+    sessionId,
+    onStreamDelta,
+    timeoutMs: providerFirstOutputTimeoutMs(idleMs),
+  });
   const state = createResponsesStreamState();
+  if (firstOutput.outputSeen) state.semanticIdleDeadlineAt = Date.now() + idleMs;
   const reportProgress = (kind) => {
     if (kind !== 'transport') state.semanticIdleDeadlineAt = Date.now() + idleMs;
     try {
       onStreamDelta?.(kind);
     } catch {}
   };
+  const reportLifecycle = (kind) => reportProgress(state.semanticIdleDeadlineAt > 0 ? kind : 'transport');
   let sawFirstEvent = false;
   const { relayLeakText, flushLeak, leakedCalls } = createResponsesLeakRelay({
     state,
@@ -88,6 +101,7 @@ export async function consumeCompatResponsesStream(
     parseResponsesToolCalls,
     responseOutputText,
     onStreamDelta: reportProgress,
+    onLifecycle: reportLifecycle,
     onToolCall,
     onTextDelta,
     onStreamItemStart,
@@ -98,9 +112,8 @@ export async function consumeCompatResponsesStream(
     while (true) {
       const { value: event, done } = await nextAsyncWithWatchdog(iterator, {
         signal: sawFirstEvent ? signal : firstByteTimeout.signal,
-        idleMs,
-        idleDeadlineAt: state.semanticIdleDeadlineAt,
-        idleEnabled: sawFirstEvent && idleEnabled && state.semanticIdleDeadlineAt > 0,
+        ...firstOutput.idleWatch(state.semanticIdleDeadlineAt, idleMs),
+        idleEnabled: sawFirstEvent && idleEnabled,
         idleLabel: `${label} SSE idle`,
         streamLabel: label,
         // Unsafe-to-retry once any tool call (native or recovered-leaked)

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

@@ -131,6 +131,7 @@ export async function sendXaiResponses(provider, messages, useModel, tools, opts
           return await consumeCompatResponsesStream(stream, {
             signal: attemptSignal,
             label: 'xai:responses',
+            sessionId: opts.sessionId,
             onStreamDelta: opts.onStreamDelta,
             onToolCall: opts.onToolCall,
             onTextDelta: opts.onTextDelta,

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-events/output-items.mjs

@@ -15,7 +15,7 @@ function outputItemKind(item) {
   return 'semantic';
 }
 
-export function createOutputItemEvents({ state, items, meaningful }) {
+export function createOutputItemEvents({ state, items, meaningful, lifecycle }) {
   const { toolTracker } = state;
 
   const onOutputItemAdded = (item) => {
@@ -52,7 +52,10 @@ export function createOutputItemEvents({ state, items, meaningful }) {
       toolTracker.mark(item);
       state.toolInFlight = true;
     }
-    meaningful(state.toolInFlight ? 'tool' : 'semantic');
+    // A tool call starting is model output; an empty reasoning or message
+    // item is lifecycle (the silent thinking follows it).
+    if (state.toolInFlight) meaningful('tool');
+    else lifecycle('semantic');
   };
 
   const onToolInputDelta = (itemId) => {

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-events.mjs

@@ -7,18 +7,28 @@ import { createOutputItemEvents } from './response-events/output-items.mjs';
 import { createTerminalFrameEvents } from './response-events/terminal-frames.mjs';
 import { reportStreamItemStart, responsesItemStart } from '../lib/send-callbacks.mjs';
 
-export function createResponseEvents({ state, items, text, outcome, meaningful, onServerEvent, onStreamItemStart }) {
-  const output = createOutputItemEvents({ state, items, meaningful });
+export function createResponseEvents({
+  state,
+  items,
+  text,
+  outcome,
+  meaningful,
+  lifecycle,
+  onServerEvent,
+  onStreamItemStart,
+}) {
+  const output = createOutputItemEvents({ state, items, meaningful, lifecycle });
   const terminal = createTerminalFrameEvents({ state, items, text, outcome, meaningful });
 
   const handleEvent = (event) => {
     if (!event || typeof event.type !== 'string') return;
     onServerEvent();
     switch (event.type) {
+      // The server's ack is metadata, not model output: it satisfies only the
+      // first-server-event deadline (onServerEvent above).
       case 'response.created':
         if (event.response?.model) state.model = event.response.model;
         if (event.response?.id) state.responseId = event.response.id;
-        meaningful('semantic');
         break;
       case 'response.output_text.delta':
         text.relayLeakText(event.delta || '');

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

@@ -24,7 +24,8 @@ import { createResponseEvents } from './openai-http-sse-response-state/response-
  * @param {(call: object) => void} [deps.onToolCall]
  * @param {(text: string) => void} [deps.onTextDelta]
  * @param {(kind: string) => void} deps.meaningful  semantic progress (re-arms the idle watchdog)
- * @param {() => void} deps.onServerEvent  first-event → semantic-idle handover
+ * @param {(kind: string) => void} [deps.lifecycle]  item lifecycle without output: progress only after semantic output
+ * @param {() => void} deps.onServerEvent  any parsed server event (satisfies the first-server-event deadline)
  * @param {(detail: object) => void} [deps.onStreamItemStart]  a tool call or phased message started
  */
 export function createHttpSseResponseState({
@@ -33,6 +34,7 @@ export function createHttpSseResponseState({
   onTextDelta,
   onStreamItemStart = null,
   meaningful,
+  lifecycle = () => {},
   onServerEvent,
   label,
 }) {
@@ -40,7 +42,16 @@ export function createHttpSseResponseState({
   const outcome = createResponseOutcome({ state });
   const items = createResponseItems({ state, onToolCall });
   const text = createTextRelay({ state, body, onTextDelta, meaningful, emitToolCall: items.emitToolCall });
-  const events = createResponseEvents({ state, items, text, outcome, meaningful, onServerEvent, onStreamItemStart });
+  const events = createResponseEvents({
+    state,
+    items,
+    text,
+    outcome,
+    meaningful,
+    lifecycle,
+    onServerEvent,
+    onStreamItemStart,
+  });
 
   return {
     handleEvent: events.handleEvent,