mixdog 1.3.5 → 1.4.1

package/src/runtime/agent/orchestrator/providers/anthropic-sse.mjs

@@ -97,7 +97,7 @@ function _statusForAnthropicSseError(event, payload) {
   return 0;
 }
 
-function _anthropicSseError(event, labels) {
+export function _anthropicSseError(event, labels) {
   const payload = event?.error && typeof event.error === 'object' ? event.error : event;
   const type = payload?.type || event?.type || 'error';
   const message = payload?.message || 'Anthropic SSE error';
@@ -161,6 +161,12 @@ function applyAnthropicSseEvent(framedEvent, { turn, watchdogs, state, progress,
         return false;
       case 'message_delta':
         return turn.onMessageDelta(event);
+      case 'ping':
+        // Anthropic bridges long generation gaps (adaptive thinking, a buffered
+        // tool input) with `ping` events. A distinct kind, not 'semantic': the
+        // agent watchdog decides how far a keepalive may extend liveness.
+        progress('keepalive');
+        return false;
       case 'message_stop':
         turn.onMessageStop();
         // Anthropic streams can keep emitting `:ping` keepalive frames after
@@ -198,7 +204,9 @@ export async function parseSSEStream(
   const progress = (kind) => {
     try {
       onStreamDelta?.(kind);
-    } catch {}
+    } catch {
+      // the stream-delta observer is advisory
+    }
   };
   const turn = createAnthropicSseTurn({
     state,
@@ -222,12 +230,7 @@ export async function parseSSEStream(
     _captureMidstreamAbort(state, signal.reason);
     return signal.reason instanceof Error ? signal.reason : new Error(`${labels.display} SSE stream aborted`);
   };
-  const onAbort = () => {
-    try {
-      const _c = reader.cancel('SSE aborted');
-      if (_c && typeof _c.catch === 'function') _c.catch(() => {});
-    } catch {}
-  };
+  const onAbort = () => cancelReaderOnAbort(reader);
   let buffer = '';
   let currentEvent = '';
   retainProviderSseStream(streamKey);
@@ -239,24 +242,12 @@ export async function parseSSEStream(
       signal.addEventListener('abort', onAbort, { once: true });
     }
     watchdogs.armFirstMessageTimer();
-    streamLoop: while (true) {
+    while (true) {
       let chunk;
       try {
         chunk = await watchdogs.read();
       } catch (err) {
-        const stopped = watchdogs.readFailure() ?? (signal?.aborted ? abortedError() : null);
-        if (stopped) {
-          // The caller's cancellation reason may be shared: never stamp this
-          // request's usage on it; the usage reported so far goes to this send.
-          if (signal?.aborted && state?.sawMessageStart) {
-            const reported = turn.reportedUsage();
-            noteAbandonedUsage(reported.usage, reported.model);
-          }
-          throw stopped;
-        }
-        // The connection dropped mid-body: carry what this turn completed so
-        // the loop can continue from finished tool calls instead of failing.
-        throw state?.sawMessageStart ? turn.attachTransportPartial(err) : err;
+        throw readFailureError(err, { watchdogs, signal, state, turn, abortedError });
       }
       const { done, value } = chunk;
       if (done) break;
@@ -277,10 +268,7 @@ export async function parseSSEStream(
       const framed = frameProviderSseChunk(region, { currentEvent, streamKey });
       const framedChunk = typeof framed?.then === 'function' ? await framed : framed;
       currentEvent = framedChunk.currentEvent;
-      for (const framedEvent of framedChunk.events) {
-        if (framedEvent.error) continue;
-        if (applyAnthropicSseEvent(framedEvent, { turn, watchdogs, state, progress, labels })) break streamLoop;
-      }
+      if (applyAnthropicSseChunk(framedChunk.events, { turn, watchdogs, state, progress, labels })) break;
     }
     turn.flushLeak();
     if (state?.sawMessageStart && !state?.sawCompleted) throw turn.truncatedError();
@@ -289,20 +277,69 @@ export async function parseSSEStream(
     watchdogs.dispose();
     try {
       releaseProviderSseStream(streamKey);
-    } catch {}
+    } catch {
+      // releasing the stream registration is bookkeeping only
+    }
     if (signal) signal.removeEventListener('abort', onAbort);
     // message_stop deliberately exits before EOF because Anthropic may keep
     // sending pings. Cancel the reader so the successful response body and
     // underlying keep-alive connection are not stranded.
     try {
       await reader.cancel('Anthropic SSE complete');
-    } catch {}
+    } catch {
+      // the reader may already be closed after the stream ended
+    }
+    releaseReaderLock(reader, labels);
+  }
+}
+
+// Caller cancellation of a live stream: cancel the reader without awaiting it.
+function cancelReaderOnAbort(reader) {
+  try {
+    const _c = reader.cancel('SSE aborted');
+    if (_c && typeof _c.catch === 'function') _c.catch(() => {});
+  } catch {
+    // the reader may already be closed or released
+  }
+}
+
+// The error a failed reader.read() ends the stream with: a watchdog stop or the
+// caller's abort as-is, otherwise the transport failure carrying the partial
+// turn once the message started.
+function readFailureError(err, { watchdogs, signal, state, turn, abortedError }) {
+  const stopped = watchdogs.readFailure() ?? (signal?.aborted ? abortedError() : null);
+  if (stopped) {
+    // The caller's cancellation reason may be shared: never stamp this
+    // request's usage on it; the usage reported so far goes to this send.
+    if (signal?.aborted && state?.sawMessageStart) {
+      const reported = turn.reportedUsage();
+      noteAbandonedUsage(reported.usage, reported.model);
+    }
+    return stopped;
+  }
+  // The connection dropped mid-body: carry what this turn completed so
+  // the loop can continue from finished tool calls instead of failing.
+  return state?.sawMessageStart ? turn.attachTransportPartial(err) : err;
+}
+
+// Fold one network chunk's framed records into the turn, in order. Returns true
+// once a terminal record ends the stream; a framing error skips its record.
+function applyAnthropicSseChunk(events, context) {
+  for (const framedEvent of events) {
+    if (framedEvent.error) continue;
+    if (applyAnthropicSseEvent(framedEvent, context)) return true;
+  }
+  return false;
+}
+
+function releaseReaderLock(reader, labels) {
+  try {
+    reader.releaseLock();
+  } catch (err) {
     try {
-      reader.releaseLock();
-    } catch (err) {
-      try {
-        process.stderr.write(`[${labels.tag}] reader releaseLock failed: ${err?.message ?? String(err)}\n`);
-      } catch {}
+      process.stderr.write(`[${labels.tag}] reader releaseLock failed: ${err?.message ?? String(err)}\n`);
+    } catch {
+      // stderr may be closed; the releaseLock failure is only reported
     }
   }
 }

package/src/runtime/agent/orchestrator/providers/anthropic-turn-result.mjs

@@ -11,7 +11,7 @@
  */
 import { traceAgentUsage } from '../agent-trace.mjs';
 import { reportedCostUsd } from './lib/usage-primitives.mjs';
-import { latestAnthropicPrefix } from './lib/anthropic-prefix-trace.mjs';
+import { anthropicPrefixSessionId, latestAnthropicPrefix } from './lib/anthropic-prefix-trace.mjs';
 
 /**
  * @param {object} parseResult  the assembled turn (streaming or normalized non-streaming)
@@ -48,7 +48,7 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
       // Anthropic usage is additive at this inner transport
       // boundary, even when OpenCode Go supplies the provider id.
       inputTokensInclusive: false,
-      prefixBlocks: latestAnthropicPrefix(opts.sessionId || opts.session?.id || null),
+      prefixBlocks: latestAnthropicPrefix(anthropicPrefixSessionId(opts)),
     });
   }
 

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

@@ -2,10 +2,11 @@ import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/pro
 import { sanitizeToolPairs } from '../session/context-utils.mjs';
 import { AnthropicFallbackTriggeredError } from './retry-classifier.mjs';
 import {
-  announceAnthropicModelFallback,
   createAnthropicOverloadTracker,
   isTerminalOverloadModel,
+  takeAnthropicModelFallback,
 } from './anthropic-overload-fallback.mjs';
+import { removeAbortListener } from './anthropic-oauth-request/abort-wiring.mjs';
 import { readStreamOutcome } from './lib/stream-outcome.mjs';
 import { createPassthroughSignal } from '../stall-policy.mjs';
 import { createAbortController } from '../../../shared/abort-controller.mjs';
@@ -18,6 +19,7 @@ import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-r
 import { armFirstByteWatchdog, createAnthropicApiTransport } from './anthropic-api-transport.mjs';
 import { createAnthropicApiRecovery } from './anthropic-api-recovery.mjs';
 import { buildAnthropicTurnResult } from './anthropic-turn-result.mjs';
+import { sendAnthropicCacheWarm } from './anthropic-cache-warm.mjs';
 import {
   assertAnthropicStreamNotEmpty,
   createAnthropicMidState,
@@ -38,6 +40,29 @@ import { streamCallbacks } from './lib/send-callbacks.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
 export { _test, _toAnthropicMessagesForTest } from './anthropic-messages.mjs';
 
+// One stream attempt's controller, aborted with the caller's reason when the
+// send's signal aborts. An already-aborted send fails before the attempt.
+function linkAttemptAbort(totalSignal) {
+  const streamController = createAbortController();
+  let cancelHandler = null;
+
+  if (totalSignal) {
+    if (totalSignal.aborted) {
+      const reason = totalSignal.reason;
+      throw reason instanceof Error ? reason : new Error('Anthropic request aborted');
+    }
+    cancelHandler = () => {
+      try {
+        streamController.abort(totalSignal.reason);
+      } catch {
+        // best-effort propagation of caller cancellation
+      }
+    };
+    totalSignal.addEventListener('abort', cancelHandler, { once: true });
+  }
+  return { streamController, cancelHandler };
+}
+
 export class AnthropicProvider {
   // Takes a PDF as a native document block (decided by this adapter's wire protocol).
   nativePdf = true;
@@ -143,6 +168,38 @@ export class AnthropicProvider {
       throw err;
     }
   }
+  /**
+   * Cache-warm mode (anthropic-cache-warm.mjs): the request `send` would
+   * build for these arguments, sent once on the retry-free client — no
+   * key reload, fallback model or re-send — and cut at the first content
+   * block. `onUsage` receives the reported usage as it arrives.
+   */
+  async sendCacheWarm(messages, model, tools, opts = {}, { onUsage, accountId = '' } = {}) {
+    const prepared = await preparePdfTextForProvider(sanitizeToolPairs(messages), this);
+    const { params, requestHeaders } = await buildAnthropicApiRequest({
+      name: this.name,
+      config: this.config,
+      messages: prepared,
+      useModel: model,
+      tools,
+      opts,
+      fastModeLatched: this.fastModeBetaHeaderLatched,
+      modelInfo: isCustomProviderName(this.name) ? this.getCachedModelInfo?.(model) || null : null,
+      capabilityModel: this._capabilityModel(model),
+    });
+    return sendAnthropicCacheWarm({
+      providerName: this.name,
+      instance: this,
+      accountId,
+      model,
+      opts,
+      onUsage,
+      post: (signal) =>
+        this._currentClient()
+          .messages.create(params, { signal, ...(requestHeaders ? { headers: requestHeaders } : {}) })
+          .asResponse(),
+    });
+  }
   // The `anthropic` API-key provider and every custom `anthropic`-protocol
   // provider (a subclass of this one) share this send path.
   async _doSend(messages, model, tools, sendOpts) {
@@ -188,89 +245,20 @@ export class AnthropicProvider {
     const totalTimeout = createPassthroughSignal(externalSignal);
     const totalSignal = totalTimeout.signal;
 
-    const cleanupCancelHandler = (handler) => {
-      if (!handler) return;
-      try {
-        totalSignal.removeEventListener('abort', handler);
-      } catch {}
-    };
-
-    // Request-loop 529s and SSE overload events share one counter; at the
-    // limit the configured fallback model takes over the whole send.
-    const overload = createAnthropicOverloadTracker({
-      model: useModel,
-      fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
-      terminalAtLimit: !isCustomProviderName(this.name) && isTerminalOverloadModel(useModel),
-    });
-    // The SDK calls and their initial-response retry policy
-    // (anthropic-api-transport.mjs).
-    const transport = createAnthropicApiTransport({
-      client: this._currentClient(),
-      label: this.name,
+    const { transport, buildTurnResult, recovery, midstream } = this._createSendRecovery({
       opts,
       useModel,
       params,
       requestHeaders,
       totalSignal,
-      overload,
-    });
-    // Usage accounting + caller-visible projection, shared by the streaming
-    // success path and the non-streaming fallback (anthropic-turn-result.mjs).
-    const buildTurnResult = (parseResult) =>
-      buildAnthropicTurnResult(parseResult, { provider: this.name, useModel, opts });
-    // Non-streaming re-issue of a dead stream, behind the transport-recovery
-    // budget and the exposed-output retraction handshake
-    // (anthropic-api-recovery.mjs).
-    const recovery = createAnthropicApiRecovery({
-      label: this.name,
-      opts,
-      useModel,
-      params,
-      totalSignal,
-      transport,
-      buildTurnResult,
       onStageChange,
       onTextReset,
     });
-    // Bounded mid-stream retries for transient stream loss; jittered backoff
-    // between attempts (anthropic-midstream-recovery.mjs, shared with
-    // anthropic-oauth).
-    const midstream = createAnthropicMidstreamRecovery({
-      label: this.name,
-      displayName: 'Anthropic',
-      outcomeProvider: 'anthropic',
-      midstreamOwner: `${this.name}-midstream`,
-      unreachableMessage: 'Anthropic mid-stream retry: unreachable',
-      // The transport's withRetry already exhausted the full request-level
-      // budget for a non-OK initial response, so it must not earn an
-      // additional SSE retry budget here.
-      initialResponseErrorTerminal: true,
-      maxRetries: ANTHROPIC_MAX_MIDSTREAM_RETRIES,
-      totalSignal,
-      recovery,
-      onStageChange,
-      retry529: opts.retry529 !== false,
-      overload,
-    });
 
     let streamingFallbackTried = false;
     try {
       for (let attemptIndex = 0; attemptIndex <= ANTHROPIC_MAX_MIDSTREAM_RETRIES; attemptIndex++) {
-        const streamController = createAbortController();
-        let cancelHandler = null;
-
-        if (totalSignal) {
-          if (totalSignal.aborted) {
-            const reason = totalSignal.reason;
-            throw reason instanceof Error ? reason : new Error('Anthropic request aborted');
-          }
-          cancelHandler = () => {
-            try {
-              streamController.abort(totalSignal.reason);
-            } catch {}
-          };
-          totalSignal.addEventListener('abort', cancelHandler, { once: true });
-        }
+        const { streamController, cancelHandler } = linkAttemptAbort(totalSignal);
 
         const midState = createAnthropicMidState(attemptIndex);
 
@@ -280,13 +268,17 @@ export class AnthropicProvider {
         try {
           try {
             onStageChange?.('requesting');
-          } catch {}
+          } catch {
+            // the stage observer is advisory
+          }
 
           response = await transport.requestStreamingResponse();
 
           try {
             onStageChange?.('streaming');
-          } catch {}
+          } catch {
+            // the stage observer is advisory
+          }
 
           firstByte = armFirstByteWatchdog(streamController, midState);
 
@@ -307,7 +299,9 @@ export class AnthropicProvider {
           );
           try {
             streamController.abort?.('Anthropic SSE complete');
-          } catch {}
+          } catch {
+            // the stream is complete; the controller may already be aborted
+          }
 
           firstByte.cleanup();
           assertAnthropicStreamNotEmpty(midState, parseResult, 'Anthropic');
@@ -336,26 +330,80 @@ export class AnthropicProvider {
           return decision.value;
         } finally {
           firstByte?.cleanup();
-          cleanupCancelHandler(cancelHandler);
+          removeAbortListener(totalSignal, cancelHandler);
         }
       }
       throw midstream.exhaustedError();
     } catch (err) {
-      // The fallback trigger can surface from the request loop, a mid-stream
-      // overload, or the non-streaming recovery: handle it around the whole
-      // operation, not just the first request.
-      if (!(err instanceof AnthropicFallbackTriggeredError)) throw err;
-      process.stderr.write(`[${this.name}] ${err.message}\n`);
-      announceAnthropicModelFallback(onStageChange, useModel, err.fallbackModel);
-      return await this._doSend(messages, err.fallbackModel, tools, {
-        ...opts,
-        fallbackModel: undefined,
-        _fallbackTriggered: true,
-      });
+      const fallbackOpts = takeAnthropicModelFallback(err, { tag: this.name, model: useModel, opts, onStageChange });
+      return await this._doSend(messages, err.fallbackModel, tools, fallbackOpts);
     } finally {
       totalTimeout.cleanup();
     }
   }
+  // The recovery pipeline of one send over its fixed request: the shared
+  // overload counter, the transport, the turn-result projection, the
+  // non-streaming recovery and the bounded mid-stream retries.
+  _createSendRecovery({ opts, useModel, params, requestHeaders, totalSignal, onStageChange, onTextReset }) {
+    // Request-loop 529s and SSE overload events share one counter; at the
+    // limit the configured fallback model takes over the whole send.
+    const overload = createAnthropicOverloadTracker({
+      model: useModel,
+      fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
+      terminalAtLimit: !isCustomProviderName(this.name) && isTerminalOverloadModel(useModel),
+    });
+    // The SDK calls and their initial-response retry policy
+    // (anthropic-api-transport.mjs).
+    const transport = createAnthropicApiTransport({
+      client: this._currentClient(),
+      label: this.name,
+      opts,
+      useModel,
+      params,
+      requestHeaders,
+      totalSignal,
+      overload,
+    });
+    // Usage accounting + caller-visible projection, shared by the streaming
+    // success path and the non-streaming fallback (anthropic-turn-result.mjs).
+    const buildTurnResult = (parseResult) =>
+      buildAnthropicTurnResult(parseResult, { provider: this.name, useModel, opts });
+    // Non-streaming re-issue of a dead stream, behind the transport-recovery
+    // budget and the exposed-output retraction handshake
+    // (anthropic-api-recovery.mjs).
+    const recovery = createAnthropicApiRecovery({
+      label: this.name,
+      opts,
+      useModel,
+      params,
+      totalSignal,
+      transport,
+      buildTurnResult,
+      onStageChange,
+      onTextReset,
+    });
+    // Bounded mid-stream retries for transient stream loss; jittered backoff
+    // between attempts (anthropic-midstream-recovery.mjs, shared with
+    // anthropic-oauth).
+    const midstream = createAnthropicMidstreamRecovery({
+      label: this.name,
+      displayName: 'Anthropic',
+      outcomeProvider: 'anthropic',
+      midstreamOwner: `${this.name}-midstream`,
+      unreachableMessage: 'Anthropic mid-stream retry: unreachable',
+      // The transport's withRetry already exhausted the full request-level
+      // budget for a non-OK initial response, so it must not earn an
+      // additional SSE retry budget here.
+      initialResponseErrorTerminal: true,
+      maxRetries: ANTHROPIC_MAX_MIDSTREAM_RETRIES,
+      totalSignal,
+      recovery,
+      onStageChange,
+      retry529: opts.retry529 !== false,
+      overload,
+    });
+    return { transport, buildTurnResult, recovery, midstream };
+  }
   async listModels() {
     const apiKey = resolveProviderApiKey(this.name, this.config);
     if (!apiKey) return MODELS;