mixdog 1.3.4 → 1.4.0

package/src/runtime/agent/orchestrator/providers/gemini-retry-policy.mjs

@@ -23,6 +23,7 @@
  * Replay stays gated by the stream-outcome contract: a stream that exposed
  * text or dispatched a tool is never re-issued.
  */
+import { noteAbandonedUsage } from '../../../shared/llm/usage-context.mjs';
 import { readStreamOutcome } from './lib/stream-outcome.mjs';
 import { DETERMINISTIC_KINDS, providerErrorKind, typedCodeKind } from './provider-error-kind.mjs';
 import { midstreamRetryDelayMs } from './retry-backoff.mjs';
@@ -42,7 +43,7 @@ export const GEMINI_REQUEST_RETRY = Object.freeze({
 });
 
 // A server wait longer than this is a lock-out, not a retry.
-export const GEMINI_MAX_RETRYABLE_ADVICE_MS = 300_000;
+const GEMINI_MAX_RETRYABLE_ADVICE_MS = 300_000;
 
 function hasLongAdvice(err) {
   const { kind, retryAfterMs } = providerErrorKind(err);
@@ -56,7 +57,7 @@ export function geminiEndsWithFunctionResponse(contents) {
 }
 
 export const GEMINI_MIDSTREAM_MAX_ATTEMPTS = 4;
-export const GEMINI_MIDSTREAM_INITIAL_DELAY_MS = 1000;
+const GEMINI_MIDSTREAM_INITIAL_DELAY_MS = 1000;
 
 const midstreamStepMs = (streamAttempt) => GEMINI_MIDSTREAM_INITIAL_DELAY_MS * 2 ** streamAttempt;
 
@@ -116,7 +117,14 @@ export function geminiInvalidStreamReason(response, textLeakGuard = null, { afte
  * open + consume and calls `connected()` once the response opened; it resolves
  * `{ response, textLeakGuard }`.
  */
-export async function runGeminiStreamAttempts({ run, signal, onRetry, sleepFn, afterToolResult = false }) {
+export async function runGeminiStreamAttempts({
+  run,
+  signal,
+  onRetry,
+  sleepFn,
+  afterToolResult = false,
+  failureUsage = null,
+}) {
   for (let streamAttempt = 0; ; streamAttempt++) {
     let connected = false;
     let result;
@@ -157,29 +165,60 @@ export async function runGeminiStreamAttempts({ run, signal, onRetry, sleepFn, a
       await sleepWithAbort(waitMs, signal, sleepFn, 'Gemini stream retry wait aborted');
       continue;
     }
-    const invalid = geminiInvalidStreamReason(result.response, result.textLeakGuard, { afterToolResult });
-    if (!invalid || signal?.aborted) return result;
-    const unusable = Object.assign(new Error(`Gemini stream unusable: ${invalid}`), {
-      name: 'InvalidStreamError',
-      code: invalid.toLowerCase(),
+    if (signal?.aborted) return result;
+    const reask = geminiInvalidStreamReask(result.response, result.textLeakGuard, {
+      afterToolResult,
+      streamAttempt,
+      failureUsage,
     });
-    if (streamAttempt + 1 >= GEMINI_MIDSTREAM_MAX_ATTEMPTS) {
-      // A spent ladder on an empty answer is a failure, not an answer; a
-      // malformed / unexpected tool call keeps its finish-reason error.
-      if (invalid !== 'NO_RESPONSE_TEXT') return result;
-      throw markProviderRecoveryExhausted(unusable, {
-        owner: 'gemini-stream',
-        attempts: GEMINI_MIDSTREAM_MAX_ATTEMPTS,
-        terminal: true,
-      });
-    }
-    const waitMs = midstreamStepMs(streamAttempt);
+    if (!reask) return result;
     onRetry?.({
       attempt: streamAttempt + 1,
       maxAttempts: GEMINI_MIDSTREAM_MAX_ATTEMPTS,
-      lastErr: unusable,
-      delayMs: waitMs,
+      lastErr: reask.unusable,
+      delayMs: reask.waitMs,
+    });
+    await sleepWithAbort(reask.waitMs, signal, sleepFn, 'Gemini stream retry wait aborted');
+  }
+}
+
+/**
+ * The bounded re-ask for a finished but unusable response (empty STOP,
+ * malformed / unexpected tool call), shared by every Gemini-shaped transport:
+ * `{ unusable, waitMs }` when the request should be re-issued after `waitMs`,
+ * null when the response stands (usable, or a spent ladder on a malformed
+ * call, which keeps its finish-reason error). A spent ladder on an empty
+ * answer throws: it is a failure, not an answer.
+ *
+ * The discarded response was still billed. `failureUsage` ({ model,
+ * normalize(usageMetadata) }) records it: a scheduled re-ask notes it as
+ * abandoned usage; a spent ladder that throws carries it as
+ * partialUsage/partialModel (the send's error accounting records it once).
+ */
+export function geminiInvalidStreamReask(
+  response,
+  textLeakGuard,
+  { afterToolResult = false, streamAttempt = 0, failureUsage = null } = {}
+) {
+  const invalid = geminiInvalidStreamReason(response, textLeakGuard, { afterToolResult });
+  if (!invalid) return null;
+  const unusable = Object.assign(new Error(`Gemini stream unusable: ${invalid}`), {
+    name: 'InvalidStreamError',
+    code: invalid.toLowerCase(),
+  });
+  const usage = response?.usageMetadata && failureUsage ? failureUsage.normalize(response.usageMetadata) : null;
+  if (streamAttempt + 1 >= GEMINI_MIDSTREAM_MAX_ATTEMPTS) {
+    if (invalid !== 'NO_RESPONSE_TEXT') return null;
+    if (usage) {
+      unusable.partialUsage = usage;
+      unusable.partialModel = failureUsage.model;
+    }
+    throw markProviderRecoveryExhausted(unusable, {
+      owner: 'gemini-stream',
+      attempts: GEMINI_MIDSTREAM_MAX_ATTEMPTS,
+      terminal: true,
     });
-    await sleepWithAbort(waitMs, signal, sleepFn, 'Gemini stream retry wait aborted');
   }
+  if (usage) noteAbandonedUsage(usage, failureUsage.model);
+  return { unusable, waitMs: midstreamStepMs(streamAttempt) };
 }

package/src/runtime/agent/orchestrator/providers/gemini-sdk-request.mjs

@@ -96,6 +96,7 @@ export async function streamGeminiSdkAttempt(genModel, stream, attemptSignal, on
       signal: attemptSignal,
       onStreamDelta: callbacks.onStreamDelta,
       onTextDelta: callbacks.onTextDelta,
+      onReasoningDelta: callbacks.onReasoningDelta,
       textLeakGuard,
       label: 'Gemini SDK streamGenerateContent',
       failureUsage: geminiFailureUsage(stream.opts, stream.cachedContent, stream.useModel),

package/src/runtime/agent/orchestrator/providers/gemini-stream.mjs

@@ -51,7 +51,7 @@ const GEMINI_RPC_CODES = new Set(['UNAVAILABLE', 'DEADLINE_EXCEEDED', 'ABORTED',
  * Copy a typed Gemini/gRPC status onto the error so classifyError can retry
  * UNAVAILABLE/DEADLINE_EXCEEDED/ABORTED/INTERNAL without an HTTP status.
  */
-export function stampGeminiRpcError(err) {
+function stampGeminiRpcError(err) {
   if (!err || typeof err !== 'object') return err;
   if (typeof err.geminiStatus === 'string' && err.geminiStatus) return err;
   for (const field of [err.status, err.error?.status, err.cause?.status, err.cause?.geminiStatus]) {
@@ -326,16 +326,43 @@ function mergeStreamMetadata(previous, next) {
 
 // A stream that ends with no finishReason is unfinished, whatever it carried
 // (thoughts only, an empty body, even right after a tool result); only a
-// STOP that carries no text is a completed, empty answer.
-function assertGeminiStreamCompleted({ sawStreamChunk, finishReason, promptBlockReason, label }) {
+// STOP that carries no text is a completed, empty answer. The one exception
+// is a stream that delivered at least one whole functionCall part and no
+// explicitly unfinished one: the gateway ends such a tool-use turn without a
+// finishReason, and every call is intact.
+function assertGeminiStreamCompleted({ sawStreamChunk, finishReason, promptBlockReason, parts, label }) {
   if (!sawStreamChunk) {
     throw geminiTruncatedStreamError(`${label} truncated: empty stream`);
   }
   if (geminiFinishReasonKind(finishReason) === 'none' && geminiFinishReasonKind(promptBlockReason) === 'none') {
+    if (Array.isArray(parts)) {
+      const calls = parts.filter((part) => part?.functionCall);
+      if (calls.length > 0 && calls.every(isCompleteFunctionCallPart)) return;
+    }
     throw geminiTruncatedStreamError(`${label} truncated: no finishReason`);
   }
 }
 
+// A functionCall part is whole when it names the function and its arguments
+// are not still streaming in pieces.
+function isIncompleteFunctionCallPart(part) {
+  const call = part?.functionCall;
+  if (!call) return false;
+  return (
+    call.willContinue === true ||
+    call.will_continue === true ||
+    call.partialArgs !== undefined ||
+    call.partial_args !== undefined
+  );
+}
+
+function isCompleteFunctionCallPart(part) {
+  const call = part?.functionCall;
+  if (!call || typeof call.name !== 'string' || call.name === '') return false;
+  if (isIncompleteFunctionCallPart(part)) return false;
+  return call.args === undefined || (call.args !== null && typeof call.args === 'object' && !Array.isArray(call.args));
+}
+
 // Concatenate the text parts of a single streamed Gemini chunk. Used to feed
 // the gateway live-text relay (onTextDelta) with the incremental text payload
 // as each SSE/SDK chunk arrives. Returns '' for tool-call / thought-only /
@@ -351,6 +378,27 @@ function geminiChunkText(chunk) {
   return text;
 }
 
+// The thought-summary text of a streamed chunk, relayed as reasoning and never
+// mixed into the answer text.
+function geminiChunkThoughtText(chunk) {
+  const parts = chunk?.candidates?.[0]?.content?.parts;
+  if (!Array.isArray(parts)) return '';
+  let text = '';
+  for (const p of parts) {
+    if (p && p.thought === true && typeof p.text === 'string') text += p.text;
+  }
+  return text;
+}
+
+function relayGeminiReasoning(chunk, onReasoningDelta) {
+  if (!onReasoningDelta) return;
+  const thought = geminiChunkThoughtText(chunk);
+  if (!thought) return;
+  try {
+    onReasoningDelta(thought);
+  } catch {}
+}
+
 // Returns the text actually RELAYED to the live sink (''  when it was only
 // buffered), so callers can track visible output rather than raw stream text.
 function relayGeminiStreamText(t, { onTextDelta, textLeakGuard }) {
@@ -384,6 +432,9 @@ export function createGeminiTextLeakGuard({
   const _enabled = _knownTools.size > 0;
   const _isKnownTool = (name) => _knownTools.has(name);
   let leakBuffer = '';
+  // Markdown fence / inline-code state carried across chunks: a tag inside a
+  // code fence opened in an earlier chunk is an example, not a call.
+  let fenceState = null;
   let relayedText = '';
   const leakedCalls = [];
   // With `deferToolCalls`, recovered calls wait here until the caller has seen
@@ -425,8 +476,18 @@ export function createGeminiTextLeakGuard({
   const pumpLeakBuffer = (final) => {
     if (!_enabled) return;
     if (!leakBuffer && !final) return;
-    const { emit, calls, rest } = scanLeakedToolCalls(leakBuffer, { isKnownTool: _isKnownTool, final });
+    const {
+      emit,
+      calls,
+      rest,
+      fenceState: nextFence,
+    } = scanLeakedToolCalls(leakBuffer, {
+      isKnownTool: _isKnownTool,
+      final,
+      fenceState,
+    });
     leakBuffer = rest;
+    fenceState = nextFence;
     // Only text handed to the live sink counts as relayed/visible. Without
     // an onTextDelta sink the scrubbed text is buffered for the final
     // result and never shown, so it must not deny a replay.
@@ -521,6 +582,7 @@ export async function consumeGeminiRestStreamResponse(
     signal,
     onStreamDelta,
     onTextDelta,
+    onReasoningDelta = null,
     textLeakGuard,
     label,
     unwrapChunk = null,
@@ -568,6 +630,7 @@ export async function consumeGeminiRestStreamResponse(
     try {
       onStreamDelta?.(geminiChunkProgressKind(parsed));
     } catch {}
+    relayGeminiReasoning(parsed, onReasoningDelta);
     if (onTextDelta || textLeakGuard) {
       relayedText += relayGeminiStreamText(geminiChunkText(parsed), { onTextDelta, textLeakGuard });
     }
@@ -665,6 +728,7 @@ export async function consumeGeminiRestStreamResponse(
       sawStreamChunk,
       finishReason,
       promptBlockReason,
+      parts: aggregated.candidates?.[0]?.content?.parts,
       label,
     });
   } catch (err) {
@@ -679,6 +743,7 @@ export async function consumeGeminiSdkStream(
     signal,
     onStreamDelta,
     onTextDelta,
+    onReasoningDelta = null,
     textLeakGuard,
     label,
     cancelGeneration,
@@ -741,6 +806,7 @@ export async function consumeGeminiSdkStream(
       try {
         onStreamDelta?.(geminiChunkProgressKind(step.value));
       } catch {}
+      relayGeminiReasoning(step.value, onReasoningDelta);
       if (onTextDelta || textLeakGuard) {
         const t = geminiChunkText(step.value);
         relayedText += relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
@@ -770,6 +836,7 @@ export async function consumeGeminiSdkStream(
       sawStreamChunk: reader.sawStreamChunk,
       finishReason,
       promptBlockReason,
+      parts: raw?.candidates?.[0]?.content?.parts,
       label,
     });
     return raw;

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

@@ -31,6 +31,7 @@ import {
 } from './gemini-retry-policy.mjs';
 import { geminiTextLeakGuardFor, streamGeminiSdkAttempt } from './gemini-sdk-request.mjs';
 import { emitGeminiToolCalls } from './gemini-schema.mjs';
+import { createGeminiReasoningRelay } from './gemini-reasoning-relay.mjs';
 import { buildGeminiRequest, geminiCachedRestBody } from './gemini-request-body.mjs';
 import {
   geminiIncompleteError,
@@ -134,10 +135,14 @@ function geminiRetryLogger(opts, tag) {
 }
 
 function geminiSendCallbacks(opts) {
+  const reasoning = createGeminiReasoningRelay(opts);
   return {
     onStreamDelta: typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null,
     onToolCall: typeof opts.onToolCall === 'function' ? opts.onToolCall : null,
     onTextDelta: typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null,
+    onReasoningDelta: reasoning.onReasoningDelta,
+    // Thinking already shown by a dead or discarded attempt.
+    retractReasoning: reasoning.retract,
   };
 }
 
@@ -220,11 +225,12 @@ export class GeminiProvider {
    * dispatched tool can never run twice. Returns the aggregated response, or
    * null when the failure is ineligible or the fallback itself fails.
    */
-  async _recoverGeminiNonStreaming({ streamErr, signal, opts, model, generate }) {
+  async _recoverGeminiNonStreaming({ streamErr, signal, opts, model, generate, retractReasoning }) {
     if (!canFallbackNonStreaming(streamErr, { signal })) return null;
     noteErrorUsage(streamErr);
     let aggregated;
     try {
+      retractReasoning?.();
       signalRequesting(opts);
       aggregated = await generate(signal || undefined);
     } catch {
@@ -549,6 +555,16 @@ export class GeminiProvider {
     }
   }
 
+  // The output limit the live model roster declared for this model, or null.
+  _rosterOutputLimit(model) {
+    try {
+      const id = geminiBareModelId(model);
+      return this._modelCache.loadSync()?.find?.((entry) => entry?.id === id)?.outputTokens ?? null;
+    } catch {
+      return null;
+    }
+  }
+
   async _doSend(messages, model, tools, sendOpts, internal = {}) {
     const opts = sendOpts || {};
     const signal = opts.signal || null;
@@ -556,7 +572,7 @@ export class GeminiProvider {
     throwIfGeminiAborted(signal);
 
     const useModel = model || (await ensureLatestGeminiModel(this));
-    const request = buildGeminiRequest(messages, useModel, tools, opts);
+    const request = buildGeminiRequest(messages, useModel, tools, opts, this._rosterOutputLimit(useModel));
     signalRequesting(opts);
 
     // Explicit cachedContents (system + tools + prior-turn transcript).
@@ -690,7 +706,9 @@ export class GeminiProvider {
         sleepFn: this.config?.sleepFn,
         onRetry: geminiRetryLogger(opts, '[gemini-rest]'),
         afterToolResult,
+        failureUsage: geminiFailureUsage(opts, cachedContent, useModel),
         run: async ({ signal: attemptSignal, connected }) => {
+          callbacks.retractReasoning();
           signalRequesting(opts);
           const res = await this._openRestStream(genUrl, body, attemptSignal);
           connected();
@@ -699,6 +717,7 @@ export class GeminiProvider {
             signal: attemptSignal,
             onStreamDelta: callbacks.onStreamDelta,
             onTextDelta: callbacks.onTextDelta,
+            onReasoningDelta: callbacks.onReasoningDelta,
             textLeakGuard,
             label: 'Gemini REST streamGenerateContent',
             failureUsage: geminiFailureUsage(opts, cachedContent, useModel),
@@ -722,6 +741,7 @@ export class GeminiProvider {
         opts,
         model: useModel,
         generate: (fallbackSignal) => this._restGenerateContent(useModel, apiKey, body, fallbackSignal),
+        retractReasoning: callbacks.retractReasoning,
       });
       if (!recovered) throw err;
       return { response: recovered, textLeakGuard: null };
@@ -760,7 +780,9 @@ export class GeminiProvider {
         sleepFn: this.config?.sleepFn,
         onRetry: geminiRetryLogger(opts, '[gemini]'),
         afterToolResult: geminiEndsWithFunctionResponse(contents),
+        failureUsage: geminiFailureUsage(opts, stream.cachedContent, useModel),
         run: async ({ signal: attemptSignal, connected }) => {
+          stream.callbacks.retractReasoning();
           signalRequesting(opts);
           return await streamGeminiSdkAttempt(genModel, stream, attemptSignal, connected);
         },
@@ -775,6 +797,7 @@ export class GeminiProvider {
           const result = await genModel.generateContent({ contents }, { signal: fallbackSignal });
           return result?.response ?? null;
         },
+        retractReasoning: stream.callbacks.retractReasoning,
       });
       if (!recovered) throw err;
       return { response: recovered, textLeakGuard: null };

package/src/runtime/agent/orchestrator/providers/grok-client-version.mjs

@@ -3,7 +3,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // Grok CLI client version for the cli-chat-proxy version gate (HTTP 426).
 // Effective = env override, else max(floor, learned-from-426, live npm latest
 // of the official @xai-official/grok CLI).
-export const GROK_CLI_VERSION_FLOOR = '1.0.67';
+export const GROK_CLI_VERSION_FLOOR = '1.0.70';
 export const GROK_CLI_NPM_PACKAGE = '@xai-official/grok';
 
 const live = createNpmVersionSource(GROK_CLI_NPM_PACKAGE, { persistKey: 'grok-cli' });

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -11,12 +11,13 @@ import { reportedCostUsd } from './usage-primitives.mjs';
 import { reportInvalidTool, wireInputSchema } from './claude-bridge-schema.mjs';
 import { normalizeServerToolUse } from './anthropic-server-tool-usage.mjs';
 import { ANTHROPIC_TOOL_CALL_IDS, withWireToolCallIds } from './tool-call-wire-ids.mjs';
+import { supportsAnthropicTurnScopedSystemMessages } from '../../../../shared/llm/anthropic-thinking-contract.mjs';
 export const ANTHROPIC_CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
 const ANTHROPIC_CACHE_TTL_VOLATILE = { type: 'ephemeral' };
 
 // Anthropic allows at most 4 cache_control breakpoints across the whole
 // serialized request (tools + system + messages).
-export const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
+const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
 
 // A block can carry a breakpoint unless it is thinking/redacted_thinking or an
 // empty text block (both are rejected by the API).
@@ -98,6 +99,84 @@ export function appendAnthropicTailReminder(anthropicMessages, reminder) {
   return anthropicMessages;
 }
 
+// Turn-scoped tail reminders (see tail-reminder-split.mjs). The capability:
+// the first-party Messages routes (no gateway base URL, beta headers allowed)
+// on a model that takes clear_at system messages. Everything else keeps the
+// legacy appendAnthropicTailReminder layout.
+// Server-side fallback needs no exclusion: live-checked on the OAuth route,
+// a trailing clear_at message is accepted with `fallbacks: "default"` (Opus
+// 5.5, Sonnet 5.5) and with explicit lists naming Sonnet 5 or Opus 4.8, and
+// fallback runs only on a safety-classifier refusal.
+export function anthropicTurnScopedReminders(provider, model, config = {}) {
+  return (
+    ANTHROPIC_NATIVE_PROVIDERS.has(provider) &&
+    config?.disableBetaHeaders !== true &&
+    (!config?.baseURL || /^https:\/\/api\.anthropic\.com(?:\/|$)/.test(config.baseURL)) &&
+    supportsAnthropicTurnScopedSystemMessages(model)
+  );
+}
+
+// The stored reminder of a lowered assistant turn (toAnthropicMessages). A
+// symbol key: JSON serialization never puts it on the wire.
+const TURN_REMINDER = Symbol('turnReminder');
+
+function assistantWireMessage(message, content) {
+  const wire = { role: 'assistant', content };
+  if (typeof message.turnReminder === 'string' && message.turnReminder) wire[TURN_REMINDER] = message.turnReminder;
+  return wire;
+}
+
+// Derived only from the stored text, so a replay is byte-identical to the
+// request that first sent it. Text only, never a cache_control (both 400).
+function turnReminderMessage(text) {
+  return { role: 'system', clear_at: 'next_user_message', content: [{ type: 'text', text }] };
+}
+
+export function hasAnthropicTurnScopedMessages(messages) {
+  return Array.isArray(messages) && messages.some((m) => m?.role === 'system' && m.clear_at);
+}
+
+// A turn-scoped message must follow a user turn; an effort control (empty
+// system message, lowerAnthropicEffortHistory) may sit between them. Creation
+// (appendAnthropicTurnReminder) and replay (withAnthropicTurnReminders) both
+// decide by this one rule on the lowered array, so a turn whose request carried
+// no reminder never gets one on replay.
+function followsUserTurn(messages) {
+  let index = messages.length - 1;
+  const last = messages[index];
+  if (last?.role === 'system' && Array.isArray(last.content) && last.content.length === 0) index--;
+  return messages[index]?.role === 'user';
+}
+
+/** The lowered history with each stored reminder re-sent right before the
+ *  assistant turn generated under it (after any effort control), exactly where
+ *  that turn's own request carried it as its last message. String contents
+ *  become one text block, so a cache marker (which turns a string into a block
+ *  list on the turn it lands) never changes a message's shape between
+ *  requests: the wire stays append-only. */
+export function withAnthropicTurnReminders(anthropicMessages) {
+  const out = [];
+  for (const message of anthropicMessages) {
+    const text = message?.role === 'assistant' ? message[TURN_REMINDER] : '';
+    if (text && followsUserTurn(out)) out.push(turnReminderMessage(text));
+    out.push(
+      typeof message?.content === 'string' && message.content.trim()
+        ? { ...message, content: [{ type: 'text', text: message.content }] }
+        : message
+    );
+  }
+  return out;
+}
+
+/** The current reminder as a turn-scoped system message ending the request.
+ *  A tail that is not a user turn (an assistant continuation) cannot take one
+ *  and gets no reminder at all: anything else would be missing from the next
+ *  request, which replays that turn without one. */
+export function appendAnthropicTurnReminder(anthropicMessages, reminder) {
+  if (reminder && followsUserTurn(anthropicMessages)) anthropicMessages.push(turnReminderMessage(reminder));
+  return anthropicMessages;
+}
+
 export function resolveAnthropicCacheTtls(opts) {
   const strategy = opts?.cacheStrategy || {};
   const pick = (layer, fallback) => {
@@ -278,7 +357,8 @@ export function toAnthropicMessages(transcript, availableTools, provider = '') {
             if (tb && typeof tb === 'object') content.push(tb);
           }
         }
-        if (m.content) content.push({ type: 'text', text: m.content });
+        // A blank text block is a hard 400 on every request that replays it.
+        if (!isBlankText(m.content)) content.push({ type: 'text', text: m.content });
         for (const tc of m.toolCalls || []) {
           content.push({
             type: 'tool_use',
@@ -288,7 +368,7 @@ export function toAnthropicMessages(transcript, availableTools, provider = '') {
           });
         }
       }
-      result.push({ role: 'assistant', content });
+      result.push(assistantWireMessage(m, content));
       continue;
     }
     if (m.role === 'tool') {
@@ -346,11 +426,20 @@ export function toAnthropicMessages(transcript, availableTools, provider = '') {
     ) {
       continue;
     }
-    result.push({ role: m.role, content: normalizeContentForAnthropic(m.content) });
+    // An assistant turn with no text and no blocks (a refused or empty final
+    // kept in the transcript for diagnosis) has nothing to replay; sending it
+    // would be a blank text block the API rejects on every later request.
+    if (m.role === 'assistant' && isBlankText(m.content)) continue;
+    const content = normalizeContentForAnthropic(m.content);
+    result.push(m.role === 'assistant' ? assistantWireMessage(m, content) : { role: m.role, content });
   }
   return sanitizeAnthropicContentPairs(result);
 }
 
+function isBlankText(content) {
+  return content == null || (typeof content === 'string' && !content.trim());
+}
+
 export function clampAnthropicThinkingBudget(value, maxTokens) {
   const desired = Math.floor(Number(value));
   const max = Math.floor(Number(maxTokens));
@@ -702,9 +791,11 @@ export function applyAnthropicCacheMarkers(
 
 // The breakpoint goes on the last message that has an eligible block: a
 // trailing effort control (empty system message) or a thinking-only tail has
-// nothing to mark. -1 when no message does.
+// nothing to mark, and a turn-scoped system message rejects cache_control.
+// -1 when no message does.
 function lastMarkableMessageIndex(messages) {
   for (let index = messages.length - 1; index >= 0; index--) {
+    if (messages[index].role === 'system') continue;
     if (lastEligibleBlockIndex(messages[index].content) >= 0) return index;
   }
   return -1;

package/src/runtime/agent/orchestrator/providers/lib/oauth-token-utils.mjs

@@ -67,10 +67,10 @@ export function sameAccountIdentity(a, b) {
   return Boolean(left.email && right.email && left.email.toLowerCase() === right.email.toLowerCase());
 }
 
-// expires_at may arrive as a unix number (seconds or milliseconds) or an
-// ISO-8601 string. Normalize to epoch milliseconds; 0 means unknown.
+// expires_at may arrive as a unix number (seconds or milliseconds), a numeric
+// string, or an ISO-8601 string. Normalize to epoch milliseconds; 0 means unknown.
 export function normalizeExpiresAtMs(value) {
-  if (typeof value === 'string') {
+  if (typeof value === 'string' && !Number.isFinite(Number(value.trim() || NaN))) {
     const ms = Date.parse(value);
     return Number.isFinite(ms) ? ms : 0;
   }
@@ -79,6 +79,20 @@ export function normalizeExpiresAtMs(value) {
   return n < 1e12 ? n * 1000 : n;
 }
 
+/**
+ * Whether a stored `{ access_token, refresh_token?, expires_at }` document is a
+ * sign-in: it can refresh, or its access token is known to be unexpired. A copy
+ * made without a refresh token (an isolated dev instance, so it cannot rotate
+ * the original's) coasts on the access token until then; one with no known
+ * expiry and no refresh token is incomplete, not a sign-in.
+ */
+export function isSignedInTokenDocument(raw) {
+  if (!raw?.access_token) return false;
+  if (raw.refresh_token) return true;
+  const expiresAt = normalizeExpiresAtMs(raw.expires_at ?? raw.expiresAt) || expiryFromAccessToken(raw.access_token);
+  return expiresAt > Date.now();
+}
+
 /**
  * Status record for a stored OAuth credential that has an access token.
  * `expiresAt` is epoch ms (0 = unknown); `detail` labels the credential source.

package/src/runtime/agent/orchestrator/providers/lib/tail-reminder-split.mjs

@@ -1,9 +1,27 @@
 // The tail reminder (session/tail-reminder-rules.mjs) rides the outgoing request
-// as its last message, marked meta.source 'tail-reminder'. It is ephemeral: a
-// provider builder that keeps per-message state (cache breakpoints, message
-// counts, continuation indexes, tool-loop closure) lifts it off first with
-// splitTailReminder, builds from the real history, and appends the reminder as
-// the final wire element, so the history-derived prefix never contains it.
+// as its last message, marked meta.source 'tail-reminder'. A provider builder
+// that keeps per-message state (cache breakpoints, message counts, continuation
+// indexes, tool-loop closure) lifts it off first with splitTailReminder, builds
+// from the real history, and then places it in one of two modes:
+//
+// - Legacy (default, every provider): the reminder is the final wire element
+//   (Anthropic: a text block on the last user message) and is never sent again,
+//   so the next request's history no longer holds it. That rewrites what came
+//   before the assistant turn it produced; Anthropic then drops that turn's
+//   thinking (prefix_binding_mismatch).
+// - Turn-scoped (append-only): the request ends with a turn-scoped system
+//   message ({role:'system', clear_at:'next_user_message'}), and every later
+//   request re-sends it byte-identically right before the assistant turn it
+//   produced. send-with-recovery stores the reminder on that assistant message
+//   (`turnReminder`, all providers), so the wire only ever grows.
+//
+// Opting in is per provider builder: decide with a capability predicate
+// (Anthropic: anthropicTurnScopedReminders in anthropic-request-utils.mjs —
+// first-party Messages routes on a supported model),
+// re-emit stored `turnReminder`s from the lowered history and append the
+// current one in the same shape, both by one placement rule: a request whose
+// tail cannot take the message gets no reminder, and replay skips that turn. Builders that have not opted in ignore `turnReminder` and keep
+// the legacy layout; a stored reminder never reaches their wire.
 export const TAIL_REMINDER_META = 'tail-reminder';
 
 export function splitTailReminder(messages) {