mixdog 1.4.0 → 1.4.2

package/src/runtime/agent/orchestrator/providers/openai-ws-stream/event-switch.mjs

@@ -27,11 +27,24 @@ export function createWsEventSwitch({
     // already cleared the pre-stream watchdog and armed the single idle timer.
     // response.created is a MEANINGFUL frame, so it also satisfies the
     // first-meaningful watchdog (keepalive/metadata frames never reach here,
-    // so they never clear it). Semantic idle is not armed until actual model
-    // progress; transport-only reasoning heartbeats are bounded by the outer
-    // first-visible ceiling instead.
+    // so they never clear it). It is still metadata, not model output: it
+    // neither ends the first-output phase nor arms the semantic idle, and the
+    // agent sees it as transport.
     watchdogs.clearFirstMeaningful();
-    progress('semantic');
+    progress('transport');
+  }
+
+  // A tool item starting is model output: it resets the semantic-idle timer so
+  // long server-side tool latency after item-added (before any arg delta) is
+  // not mistaken for a silent stall. An empty reasoning or message item is
+  // progress only once the model has produced output; before that the silent
+  // thinking follows it.
+  function onItemAdded() {
+    let kind = null;
+    if (response.toolInFlight) kind = 'tool';
+    else if (watchdogs.semanticSeen()) kind = 'semantic';
+    if (kind) watchdogs.bumpSemantic();
+    progress(kind ?? 'transport');
   }
 
   function onOutputTextDelta(delta) {
@@ -84,11 +97,7 @@ export function createWsEventSwitch({
       case 'response.output_item.added':
         response.noteItemAdded(event.item);
         reportStreamItemStart(onStreamItemStart, responsesItemStart(event.item));
-        // Item lifecycle is genuine progress: reset the semantic-idle timer so
-        // long server-side tool latency after item-added (before any arg
-        // delta) is not mistaken for a silent stall.
-        watchdogs.resetSemantic();
-        progress(response.toolInFlight ? 'tool' : 'semantic');
+        onItemAdded();
         break;
       case 'response.function_call_arguments.delta':
       case 'response.custom_tool_call_input.delta':
@@ -115,9 +124,10 @@ export function createWsEventSwitch({
         const kind = response.completeOutputItem(event.item);
         // A stream that names the phase only on the finished message.
         if (event.item?.type === 'message') reportStreamItemStart(onStreamItemStart, responsesItemStart(event.item));
-        // Item-done is genuine lifecycle progress — reset semantic idle so
-        // latency before the next item/args does not stall.
-        watchdogs.resetSemantic();
+        // A completed item (reasoning, message, tool call) is model output —
+        // it ends the first-output phase and resets semantic idle so latency
+        // before the next item/args does not stall.
+        watchdogs.bumpSemantic();
         progress(kind);
         break;
       }

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

@@ -24,11 +24,13 @@ import {
   PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
   PROVIDER_WS_FIRST_MEANINGFUL_TIMEOUT_MS,
   PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS,
+  providerFirstOutputTimeoutMs,
 } from '../stall-policy.mjs';
 import { _wsErrLabel, WS_MAX_INCOMING_FRAME_BYTES } from './openai-ws-pool.mjs';
 import { createWsResponseState } from './openai-ws-response-state.mjs';
 import { createWsTextRelay } from './openai-ws-text-relay.mjs';
 import { createWsStreamWatchdogs } from './openai-ws-watchdogs.mjs';
+import { streamFirstOutputWindow } from './lib/first-output-window.mjs';
 import {
   enableSessionTransportTracking,
   disableSessionTransportTracking,
@@ -85,6 +87,7 @@ function resolveStreamTimeouts(_timeouts) {
     interChunkMs: _positiveInt(_timeouts?.interChunkMs, WS_INTER_CHUNK_MS),
     maxIncomingFrameBytes: _positiveInt(_timeouts?.maxIncomingFrameBytes, WS_MAX_INCOMING_FRAME_BYTES),
     firstMeaningfulMs: _positiveInt(_timeouts?.firstMeaningfulMs, PROVIDER_WS_FIRST_MEANINGFUL_TIMEOUT_MS),
+    firstOutputMs: _positiveInt(_timeouts?.firstOutputMs, providerFirstOutputTimeoutMs(semanticIdleMs)),
     semanticIdleMs,
     semanticIdleEnabled: PROVIDER_SSE_IDLE_WATCHDOG_ENABLED && semanticIdleMs > 0,
   };
@@ -112,7 +115,8 @@ export async function _streamResponse({
   if (socket?.readyState === WebSocket.OPEN) {
     markSessionTransportActivity(state?.sessionId);
   }
-  const { maxIncomingFrameBytes, ...timeouts } = resolveStreamTimeouts(_timeouts);
+  const { maxIncomingFrameBytes, firstOutputMs, ...timeouts } = resolveStreamTimeouts(_timeouts);
+  const firstOutput = streamFirstOutputWindow({ sessionId: state?.sessionId, onStreamDelta, timeoutMs: firstOutputMs });
   const streamingStart = Date.now();
   // Mid-stream retry classifier needs to distinguish "stream died before we
   // even saw response.created" from "stream died after we had a partial
@@ -182,6 +186,7 @@ export async function _streamResponse({
       streamingStart,
       currentModel: () => response.model,
       timeouts,
+      firstOutput,
       attachPartialState,
       fail,
     });
@@ -256,6 +261,7 @@ export async function _streamResponse({
     if (!handlers.attach()) return;
     watchdogs.armPreStream();
     watchdogs.armFirstMeaningful();
+    watchdogs.armFirstOutput();
     // No proactive client ping: Codex's Responses WebSocket uses the library
     // default (automatic pong replies, no periodic client ping). Incoming
     // frames remain bounded by the 300s stream idle timeout.

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

@@ -1,14 +1,18 @@
 /**
- * openai-ws-watchdogs.mjs — the four timers that bound one Responses WS
+ * openai-ws-watchdogs.mjs — the five timers that bound one Responses WS
  * stream, and what each one proves when it fires:
  *
  *   pre-stream      — no server event at all after response.create (a wedged
  *                     post-upgrade socket); cleared by ANY frame.
  *   first-meaningful — no response.created / content / tool-arg delta, even
  *                     while keepalive frames keep arriving; cleared once.
+ *   first-output    — no semantic output (reasoning, text, tool call) within
+ *                     the first-output window; metadata, empty items and
+ *                     keepalives never clear or extend it; cleared once.
  *   inter-chunk     — byte silence mid-stream; reset by EVERY frame.
- *   semantic idle   — deltas then silence (keepalives only); reset only by
- *                     meaningful output and item lifecycle.
+ *   semantic idle   — deltas then silence (keepalives only); armed by the
+ *                     first semantic output, then reset by meaningful output
+ *                     and item lifecycle.
  *
  * Every expiry hands a tagged error to `fail`, which owns terminalError, the
  * socket close and the settle; the timers never touch the Promise.
@@ -23,6 +27,8 @@ import { streamStalledError } from '../stall-policy.mjs';
  * @param {number} deps.streamingStart
  * @param {() => string} deps.currentModel
  * @param {{ preResponseCreatedMs: number, firstMeaningfulMs: number, interChunkMs: number, semanticIdleMs: number, semanticIdleEnabled: boolean }} deps.timeouts
+ * @param {ReturnType<typeof import('./lib/first-output-window.mjs').streamFirstOutputWindow>} deps.firstOutput
+ *   the logical request's first-output window
  * @param {(err: Error) => Error} deps.attachPartialState
  * @param {(err: Error, closeReason: string) => void} deps.fail
  */
@@ -32,6 +38,7 @@ export function createWsStreamWatchdogs({
   streamingStart,
   currentModel,
   timeouts,
+  firstOutput,
   attachPartialState,
   fail,
 }) {
@@ -86,27 +93,30 @@ export function createWsStreamWatchdogs({
       // synthesized completion. Attach the streamed partial state so
       // the loop's partial/tool recovery can finalize it explicitly.
       err.streamStalled = true;
+      err.code = 'ESTREAMSTALL';
       attachPartialState(err);
       fail(err, 'inter_chunk_timeout');
     }, interChunkMs);
   };
+  // A semantic stall (first-output or idle window): partial-final recovery
+  // attaches the 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.
+  const failStalled = (event, timeoutMs) => {
+    traceWsTimeout(event, timeoutMs);
+    const err = streamStalledError('Responses WS', timeoutMs, {
+      emittedToolCall: !!midState?.emittedToolCall,
+    });
+    attachPartialState(err);
+    try {
+      err.wsCloseCode = 4000;
+    } catch {}
+    fail(err, event);
+  };
   const resetSemanticIdle = () => {
     if (!semanticIdleEnabled) return;
     if (semanticIdleTimer) clearTimeout(semanticIdleTimer);
-    semanticIdleTimer = setTimeout(() => {
-      traceWsTimeout('semantic_idle_timeout', semanticIdleMs);
-      const err = streamStalledError('Responses WS', semanticIdleMs, {
-        emittedToolCall: !!midState?.emittedToolCall,
-      });
-      // 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.
-      attachPartialState(err);
-      try {
-        err.wsCloseCode = 4000;
-      } catch {}
-      fail(err, 'semantic_idle_timeout');
-    }, semanticIdleMs);
+    semanticIdleTimer = setTimeout(() => failStalled('semantic_idle_timeout', semanticIdleMs), semanticIdleMs);
     try {
       semanticIdleTimer.unref?.();
     } catch {}
@@ -164,24 +174,41 @@ export function createWsStreamWatchdogs({
         firstMeaningfulTimer.unref?.();
       } catch {}
     },
+    /** Fires if the logical request produces no semantic output by its
+     *  first-output deadline. Metadata (response.created / in_progress), empty
+     *  item lifecycle and keepalive frames never clear or extend it, and the
+     *  shorter semantic idle does not run before the first output, so a model
+     *  may think silently past the idle window. A request that already had
+     *  output has none: its stream runs under the semantic idle from its
+     *  first frame (resetIdle). */
+    armFirstOutput() {
+      if (!firstOutput.outputSeen && semanticIdleEnabled && firstOutput.timeoutMs > 0) {
+        firstOutput.arm(() => failStalled('first_output_timeout', firstOutput.timeoutMs));
+      }
+    },
     /** Called on EVERY parsed server event: any frame proves the socket is
      *  live. Also clears the pre-stream watchdog in case the first event is
-     *  not response.created. */
+     *  not response.created, and starts the semantic idle (once) for a
+     *  request that already had output. */
     resetIdle() {
       clearPreStream();
       resetInterChunk();
+      if (firstOutput.outputSeen && !semanticIdleTimer) resetSemanticIdle();
     },
-    /** Meaningful-output progress: text/reasoning/tool-arg deltas. The
-     *  first one also satisfies the first-meaningful watchdog. */
+    /** Meaningful-output progress: text/reasoning/tool output. The first one
+     *  also satisfies the first-meaningful watchdog and ends the first-output
+     *  phase. */
     bumpSemantic() {
       clearFirstMeaningful();
+      firstOutput.noteOutput();
       resetSemanticIdle();
     },
-    /** Item lifecycle progress (added/done) without a delta. */
-    resetSemantic: resetSemanticIdle,
+    /** Whether the model has produced semantic output on this stream. */
+    semanticSeen: () => firstOutput.outputSeen,
     /** response.created is meaningful on its own. */
     clearFirstMeaningful,
     clearAll() {
+      firstOutput.clear();
       if (idleTimer) clearTimeout(idleTimer);
       if (interChunkTimer) {
         clearTimeout(interChunkTimer);

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

@@ -228,7 +228,7 @@ export class OpenCodeGoOAuthProvider {
     });
     const response = await consoleGetJson(CONFIG_URL, tokens, { fetchFn: this.config.fetchImpl, refresh: true });
     const remote = goConfigFromResponse(response, listsGoModels(response) ? null : await loadModelsDevGoModels());
-    publish(remote.models, {
+    await publish(remote.models, {
       baseURL: remote.baseURL,
       headers: remote.headers,
       accountId: tokens.account_id,

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

@@ -170,7 +170,9 @@ export class OpenCodeGoProvider {
       const { OpenCodeGoGeminiEngine } = await import('./opencode-go-gemini.mjs');
       this.gemini = new OpenCodeGoGeminiEngine({
         ...this.config,
-        baseURL: this.openai.baseURL,
+        // The OAuth org config names the chat base `.../go/openai/v1`; the
+        // generateContent routes live under `.../go/v1` and 404 on it.
+        baseURL: String(this.openai.baseURL).replace(/\/openai\/v1$/i, '/v1'),
         extraHeaders: {
           ...GO_GATEWAY_PRESET.extraHeaders,
           ...(this.config.extraHeaders || {}),

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -3,7 +3,9 @@ import { oauthCredentialProbeState } from './oauth-credential-probes.mjs';
 import { providerAvailable } from './provider-availability.mjs';
 import { refreshCatalog as refreshMetadataCatalog } from './model-catalog.mjs';
 import { wrapProviderAdmission } from './admission-scheduler.mjs';
-import { createAccountPoolProvider } from './account-pool.mjs';
+import { createAccountPoolProvider, createCustomKeyPoolProvider } from './account-pool.mjs';
+import { customKeyEngine } from './custom-provider-keys.mjs';
+import { customProviderKeyIds } from '../../../shared/provider-accounts.mjs';
 import { isInclusiveProvider } from '../../../shared/llm/cost.mjs';
 import { noEnabledProvidersError } from './registry-errors.mjs';
 import { providerTakesNativePdf } from '../../../attachments/store.mjs';
@@ -182,6 +184,7 @@ async function loadProviderExport(cacheKey, spec, exportName, signal = null) {
 const PROVIDER_MODULES = {
   anthropic: ['./anthropic.mjs', 'AnthropicProvider'],
   gemini: ['./gemini.mjs', 'GeminiProvider'],
+  'vertex-ai': ['./vertex-ai.mjs', 'VertexAIProvider'],
   'openai-oauth': ['./openai-oauth.mjs', 'OpenAIOAuthProvider'],
   'anthropic-oauth': ['./anthropic-oauth.mjs', 'AnthropicOAuthProvider'],
   'grok-oauth': ['./grok-oauth.mjs', 'GrokOAuthProvider'],
@@ -227,13 +230,39 @@ async function instantiateProvider(name, Ctor, cfg, proxyChannel = null) {
     const { createModelProxyProvider } = await import('./model-proxy-provider.mjs');
     return wrapProviderAdmission(createModelProxyProvider(name, cfg, proxyChannel ?? getModelProxyChannel()), name);
   }
-  if (isCustomProviderConfig(name, cfg)) return wrapProviderAdmission(await Ctor(name, cfg), name);
+  if (isCustomProviderConfig(name, cfg)) {
+    const { [CUSTOM_KEY_IDS]: keyIds, ...settings } = cfg;
+    const primary = wrapProviderAdmission(await Ctor(name, settings), name);
+    // Only a provider with additional keys sends through the key roster.
+    if (!keyIds?.length) return primary;
+    return createCustomKeyPoolProvider(name, primary, (id) => customKeyEngine(primary, name, id));
+  }
   if (Object.hasOwn(OPENAI_COMPAT_PRESETS, name) && !Object.hasOwn(PROVIDER_MODULES, name)) {
     return wrapProviderAdmission(new Ctor(name, cfg), name);
   }
   return createAccountPoolProvider(name, () => wrapProviderAdmission(new Ctor(cfg), name));
 }
 
+// A custom provider's additional keys live in its key roster, not the config.
+// Their ids are read once per init and join its entry (and so its reuse
+// signature): a save that changes them rebuilds the provider, which is wrapped
+// in the key pool only while it has some. A single-key provider's entry and
+// sends stay as they were, with no roster read per send.
+const CUSTOM_KEY_IDS = 'customKeyIds';
+
+function withCustomKeyIds(config) {
+  if (!config || typeof config !== 'object') return config;
+  let out = config;
+  for (const [name, cfg] of Object.entries(config)) {
+    if (!isCustomProviderConfig(name, cfg) || cfg.auth === 'none') continue;
+    const ids = customProviderKeyIds(name);
+    if (!ids.length) continue;
+    if (out === config) out = { ...config };
+    out[name] = { ...cfg, [CUSTOM_KEY_IDS]: ids };
+  }
+  return out;
+}
+
 let _initProvidersCalls = 0;
 /** Test seam: how many times initProviders was called in this process. */
 export function _initProvidersCallCountForTest() {
@@ -249,6 +278,8 @@ export async function initProviders(config, { signal = null } = {}) {
   if (proxyChannel) {
     const { loadModelProxyProviderConfig } = await import('./model-proxy-provider.mjs');
     config = await awaitWithAbort(loadModelProxyProviderConfig({ channel: proxyChannel }), signal);
+  } else {
+    config = withCustomKeyIds(config);
   }
   const sig = reuseSignature(config, proxyChannel);
   // Coalesce: an identical config is already mid-init — attach to it.
@@ -684,6 +715,18 @@ export function refreshProviderCatalogsOnStartup() {
   return _startupCatalogRefreshPromise;
 }
 
+// Force-refresh only the named providers' catalogs, each bounded like the full
+// refresh. It leaves the 24h window, the catalog revision and every other
+// provider's cache alone.
+export function refreshProviderCatalogsFor(names) {
+  const pending = [];
+  for (const [name, provider] of availableProviderEntries()) {
+    const refreshFn = names.includes(name) ? providerCatalogRefreshFn(provider) : null;
+    if (refreshFn) pending.push(boundedCatalogRefresh(name, provider, refreshFn, 'catalog refresh'));
+  }
+  return Promise.allSettled(pending);
+}
+
 // Refresh the complete catalog at most once per 24h process window. The timer
 // above calls this automatically when the window expires; callers may bypass
 // that window after an explicit auth/config/model-refresh action.