mixdog 1.3.4 → 1.3.5

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

@@ -36,8 +36,18 @@ function retiredModelError(err, streamedText, model) {
  * @param {Function|null} deps.onToolCall
  * @param {Function|null} deps.onTextDelta
  * @param {Function|null} deps.onStreamDelta
+ * @param {Function|null} [deps.onReasoningDelta]  receives thought-summary text
+ * @param {Function|null} [deps.retractReasoning]  drops thinking a dead attempt already showed
  */
-export function createAntigravityStreamCollector({ tools, useModel, onToolCall, onTextDelta, onStreamDelta }) {
+export function createAntigravityStreamCollector({
+  tools,
+  useModel,
+  onToolCall,
+  onTextDelta,
+  onStreamDelta,
+  onReasoningDelta = null,
+  retractReasoning = null,
+}) {
   let textLeakGuard = null;
   let terminalFailure = null;
   // Streamed text is kept so a retirement notice can be told apart from
@@ -66,6 +76,7 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
   // Each attempt starts from an empty record: a replayed request must not
   // inherit the dead attempt's text or failure.
   const beginAttempt = () => {
+    retractReasoning?.();
     textLeakGuard = createGeminiTextLeakGuard({
       knownToolNames: tools?.map((t) => t.name).filter(Boolean) ?? [],
       onTextDelta: relayText,
@@ -80,6 +91,8 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
     textLeakGuard = null;
   };
 
+  const failureUsage = { model: useModel, normalize: normalizeAntigravityUsage };
+
   const consume = async (res, attemptSignal, { firstByteTimeoutMs } = {}) => {
     try {
       return await consumeGeminiRestStreamResponse(res, {
@@ -87,10 +100,11 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
         firstByteTimeoutMs,
         onStreamDelta,
         onTextDelta: relayText,
+        onReasoningDelta,
         onChunk,
         textLeakGuard,
         label: 'Antigravity streamGenerateContent',
-        failureUsage: { model: useModel, normalize: normalizeAntigravityUsage },
+        failureUsage,
         // Cloud Code Assist nests the Gemini payload under
         // `response`; in-band error events stay top level.
         unwrapChunk: (chunk) => (chunk && typeof chunk === 'object' && chunk.response ? chunk.response : chunk),
@@ -105,6 +119,7 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
     beginAttempt,
     releaseGuard,
     consume,
+    failureUsage,
     get leakGuard() {
       return textLeakGuard;
     },

package/src/runtime/agent/orchestrator/providers/antigravity-transport.mjs

@@ -24,6 +24,7 @@ import { TIMEOUT_PHASE, isFirstByteTimeout } from '../../../shared/provider-time
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { _scrubTokens } from './antigravity-oauth-tokens.mjs';
 import { applyGeminiErrorContract } from './gemini-error-contract.mjs';
+import { geminiInvalidStreamReask } from './gemini-retry-policy.mjs';
 import { DETERMINISTIC_KINDS, providerErrorKind } from './provider-error-kind.mjs';
 
 // Rate-limit reason: 503/529 are capacity by status; a
@@ -113,9 +114,10 @@ export function antigravityError(res, text, endpoint) {
  * @param {string} deps.body  serialized request
  * @param {object} deps.opts  send options (stage heartbeat)
  * @param {AbortSignal|null} deps.signal  retry-loop signal (session pass-through)
- * @param {{ beginAttempt: Function, consume: Function }} deps.collector
+ * @param {{ beginAttempt: Function, consume: Function, failureUsage?: { model: string, normalize: Function } }} deps.collector
  * @param {{ timeoutMs: number, maxMs: number, retries: number|null }} [deps.firstByte]
  *   first-byte window per attempt (antigravityFirstBytePolicy)
+ * @param {boolean} [deps.afterToolResult]  the request ends with a tool result (an empty STOP is then a valid answer)
  * @returns {() => Promise<object>} one retried request that resolves the final payload
  */
 export function createAntigravityRequest({
@@ -128,6 +130,7 @@ export function createAntigravityRequest({
   collector,
   sleepFn,
   firstByte = ANTIGRAVITY_UNCLASSED_FIRST_BYTE,
+  afterToolResult = false,
 }) {
   const log = (attempt, lastErr, delayMs) => {
     // A first-byte timeout runs on its own, shorter retry budget.
@@ -240,9 +243,23 @@ export function createAntigravityRequest({
   return async () => {
     const state = { capacityRetries: 0, quickRetried: false };
     const send = { attempts: 0, firstByteTimeouts: 0, firstByteWaitedMs: 0 };
+    let streamAttempt = 0;
     for (let tried = 1; ; tried++) {
       try {
-        return await attemptOnce(send);
+        const response = await attemptOnce(send);
+        // A finished but unusable answer (empty STOP, malformed call) gets
+        // the same bounded re-ask as the API-key transport. The dead
+        // attempt's thinking is retracted when the next attempt begins.
+        if (signal?.aborted) return response;
+        const reask = geminiInvalidStreamReask(response, collector.leakGuard, {
+          afterToolResult,
+          streamAttempt,
+          failureUsage: collector.failureUsage,
+        });
+        if (!reask) return response;
+        log(streamAttempt + 1, reask.unusable, reask.waitMs);
+        streamAttempt += 1;
+        await sleepWithAbort(reask.waitMs, signal, sleepFn, 'Antigravity retry wait aborted');
       } catch (err) {
         const waitMs = antigravity429WaitMs(err, state);
         if (waitMs == null) {

package/src/runtime/agent/orchestrator/providers/codex-client-meta.mjs

@@ -20,7 +20,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // version (gpt-6.1-sol requires >= 0.159.0, measured 2026-10-09), so the
 // release workflow raises this to the published CLI version on every release
 // (scripts/sync-client-version-floors.mjs).
-export const CODEX_CLIENT_VERSION_FLOOR = '0.163.0';
+export const CODEX_CLIENT_VERSION_FLOOR = '0.164.0';
 export const CODEX_CLI_NPM_PACKAGE = '@openai/codex';
 const live = createNpmVersionSource(CODEX_CLI_NPM_PACKAGE, { persistKey: 'codex-cli' });
 

package/src/runtime/agent/orchestrator/providers/cursor-wire-normalization.mjs

@@ -197,19 +197,25 @@ function usagePercent(value) {
   return Math.round(normalized * 10_000) / 10_000;
 }
 
+// The models the Auto pool (`autoPercentUsed`) meters: Auto under both of its
+// ids and the Composer family. Every other model draws on the API pool.
+const AUTO_POOL_MODELS = Object.freeze(['auto', 'default', 'composer']);
+
 // The included-plan windows: per-lane progress percentages when the dashboard
-// reports them, else one dollar window over the included balance.
+// reports them, else one dollar window over the included balance. Each lane
+// gates only the models it meters.
 function includedUsageWindows(included, plan, includedBalance, resetAt) {
   const progressWindows = [
-    ['Basic', included.autoPercentUsed],
-    ['API', included.apiPercentUsed],
+    ['Basic', included.autoPercentUsed, { models: [...AUTO_POOL_MODELS] }],
+    ['API', included.apiPercentUsed, { except: [...AUTO_POOL_MODELS] }],
   ].filter(([, value]) => Number.isFinite(Number(value)));
   if (progressWindows.length) {
-    return progressWindows.map(([label, value]) => ({
+    return progressWindows.map(([label, value, scope]) => ({
       label,
       source: 'cursor-dashboard',
       usedPct: usagePercent(value),
       ...(resetAt ? { resetAt } : {}),
+      ...scope,
     }));
   }
   if (!includedBalance) return [];

package/src/runtime/agent/orchestrator/providers/cursor-wire-protobuf.mjs

@@ -1,9 +1,10 @@
-function fields(entries) {
-  return Object.fromEntries(entries.map(([name, no, type, options = {}]) => [no, { name, no, type, ...options }]));
-}
-
-const map = (key, value) => ({ map: [key, value] });
-const repeated = { repeated: true };
+import {
+  concatBytes,
+  createProtobufCodec,
+  protobufFields as fields,
+  mapOf as map,
+  repeated,
+} from './wire-protobuf-codec.mjs';
 
 // Only the fields read or written by the provider are described here.
 const SCHEMAS = {
@@ -639,149 +640,10 @@ const SCHEMAS = {
   JsonList: fields([['values', 1, 'JsonValue', repeated]]),
 };
 
-const textEncoder = new TextEncoder();
-// A protobuf string is data, not a text document with a disposable BOM.
-const textDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
-
-function concatBytes(parts) {
-  const length = parts.reduce((sum, part) => sum + part.length, 0);
-  const output = new Uint8Array(length);
-  let offset = 0;
-  for (const part of parts) {
-    output.set(part, offset);
-    offset += part.length;
-  }
-  return output;
-}
-
-function encodeVarint(value) {
-  let current = BigInt(value ?? 0);
-  if (current < 0) current = BigInt.asUintN(64, current);
-  const bytes = [];
-  do {
-    let byte = Number(current & 0x7fn);
-    current >>= 7n;
-    if (current) byte |= 0x80;
-    bytes.push(byte);
-  } while (current);
-  return Uint8Array.from(bytes);
-}
-
-function encodeTag(no, wireType) {
-  return encodeVarint((BigInt(no) << 3n) | BigInt(wireType));
-}
-
-function isMessageType(type) {
-  return Object.hasOwn(SCHEMAS, type);
-}
-
-function wireTypeFor(type) {
-  if (type === 'double') return 1;
-  if (['string', 'bytes', 'raw'].includes(type) || isMessageType(type)) return 2;
-  return 0;
-}
-
-function scalarBytes(type, value) {
-  if (type === 'string') return textEncoder.encode(String(value));
-  if (type === 'bytes' || type === 'raw') return value instanceof Uint8Array ? value : new Uint8Array(value);
-  if (type === 'double') {
-    const buffer = new ArrayBuffer(8);
-    new DataView(buffer).setFloat64(0, Number(value), true);
-    return new Uint8Array(buffer);
-  }
-  if (type === 'bool') return encodeVarint(value ? 1 : 0);
-  if (type === 'int' || type === 'uint') return encodeVarint(value);
-  if (isMessageType(type)) return encodeMessage(type, value);
-  throw new Error(`Unknown Cursor protobuf type: ${type}`);
-}
-
-function shouldWrite(type, value) {
-  if (value == null) return false;
-  if (type === 'string') return value !== '';
-  return true;
-}
-
-function encodeField(no, type, value) {
-  const wireType = wireTypeFor(type);
-  const payload = scalarBytes(type, value);
-  if (wireType === 2) return concatBytes([encodeTag(no, wireType), encodeVarint(payload.length), payload]);
-  return concatBytes([encodeTag(no, wireType), payload]);
-}
-
-function encodeMapField(no, [keyType, valueType], value) {
-  const parts = [];
-  for (const [key, entryValue] of Object.entries(value || {})) {
-    const entry = concatBytes([encodeField(1, keyType, key), encodeField(2, valueType, entryValue)]);
-    parts.push(concatBytes([encodeTag(no, 2), encodeVarint(entry.length), entry]));
-  }
-  return parts;
-}
-
-export function encodeMessage(type, value = {}) {
-  const schema = SCHEMAS[type];
-  if (!schema) throw new Error(`Unknown Cursor protobuf message: ${type}`);
-  const parts = [];
-  for (const descriptor of Object.values(schema)) {
-    const fieldValue = value[descriptor.name];
-    if (descriptor.type?.map) {
-      parts.push(...encodeMapField(descriptor.no, descriptor.type.map, fieldValue));
-      continue;
-    }
-    let values = [fieldValue];
-    if (descriptor.repeated) values = Array.isArray(fieldValue) ? fieldValue : [];
-    for (const item of values) {
-      // A oneof's explicit empty string is a value, not an absent field.
-      if ((descriptor.presence && item != null) || shouldWrite(descriptor.type, item)) {
-        parts.push(encodeField(descriptor.no, descriptor.type, item));
-      }
-    }
-  }
-  return concatBytes(parts);
-}
-
-class ProtoReader {
-  constructor(bytes) {
-    this.bytes = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
-    this.offset = 0;
-  }
-
-  get done() {
-    return this.offset >= this.bytes.length;
-  }
-
-  varint() {
-    let value = 0n;
-    let shift = 0n;
-    while (!this.done) {
-      const byte = this.bytes[this.offset++];
-      value |= BigInt(byte & 0x7f) << shift;
-      if ((byte & 0x80) === 0) return value;
-      shift += 7n;
-      if (shift > 70n) throw new Error('Invalid Cursor protobuf varint');
-    }
-    throw new Error('Truncated Cursor protobuf varint');
-  }
-
-  take(length) {
-    const end = this.offset + length;
-    if (end > this.bytes.length) throw new Error('Truncated Cursor protobuf field');
-    const value = this.bytes.subarray(this.offset, end);
-    this.offset = end;
-    return value;
-  }
+const codec = createProtobufCodec(SCHEMAS, { label: 'Cursor protobuf' });
+const { encodeField, ProtoReader } = codec;
 
-  bytesValue() {
-    return this.take(Number(this.varint()));
-  }
-
-  skip(wireType) {
-    if (wireType === 0) this.varint();
-    else if (wireType === 1) this.take(8);
-    else if (wireType === 2) this.bytesValue();
-    else if (wireType === 5) this.take(4);
-    else throw new Error(`Unsupported Cursor protobuf wire type: ${wireType}`);
-  }
-}
+export const { encodeMessage, decodeMessage } = codec;
 
 export function rewriteConversationState(checkpoint, rootPromptMessagesJson, turns = []) {
   const preserved = [];
@@ -808,75 +670,6 @@ export function rewriteConversationState(checkpoint, rootPromptMessagesJson, tur
   return concatBytes([...preserved, ...replacement]);
 }
 
-function decodeScalar(reader, type, wireType) {
-  if (type === 'string') return textDecoder.decode(reader.bytesValue());
-  if (type === 'bytes' || type === 'raw') return new Uint8Array(reader.bytesValue());
-  if (type === 'double') {
-    if (wireType !== 1) throw new Error('Invalid Cursor protobuf double');
-    const value = new DataView(reader.bytes.buffer, reader.bytes.byteOffset + reader.offset, 8).getFloat64(0, true);
-    reader.offset += 8;
-    return value;
-  }
-  if (type === 'bool') return reader.varint() !== 0n;
-  if (type === 'int') return Number(BigInt.asIntN(64, reader.varint()));
-  if (type === 'uint') return Number(reader.varint());
-  if (isMessageType(type)) return decodeMessage(type, reader.bytesValue());
-  throw new Error(`Unknown Cursor protobuf type: ${type}`);
-}
-
-function decodeMapEntry(bytes, [keyType, valueType]) {
-  const reader = new ProtoReader(bytes);
-  let key = '';
-  let value = valueType === 'string' ? '' : undefined;
-  while (!reader.done) {
-    const tag = reader.varint();
-    const no = Number(tag >> 3n);
-    const wireType = Number(tag & 7n);
-    if (no === 1) key = decodeScalar(reader, keyType, wireType);
-    else if (no === 2) value = decodeScalar(reader, valueType, wireType);
-    else reader.skip(wireType);
-  }
-  return [String(key), value];
-}
-
-export function decodeMessage(type, bytes) {
-  const schema = SCHEMAS[type];
-  if (!schema) throw new Error(`Unknown Cursor protobuf message: ${type}`);
-  const reader = new ProtoReader(bytes);
-  const output = {};
-  while (!reader.done) {
-    const tag = reader.varint();
-    const no = Number(tag >> 3n);
-    const wireType = Number(tag & 7n);
-    const descriptor = schema[no];
-    if (!descriptor) {
-      const start = reader.offset;
-      reader.skip(wireType);
-      output.$unknown ||= [];
-      output.$unknown.push({
-        no,
-        wireType,
-        data: new Uint8Array(reader.bytes.subarray(start, reader.offset)),
-      });
-      continue;
-    }
-    if (descriptor.type?.map) {
-      const [key, value] = decodeMapEntry(reader.bytesValue(), descriptor.type.map);
-      output[descriptor.name] ||= {};
-      output[descriptor.name][key] = value;
-      continue;
-    }
-    const value = decodeScalar(reader, descriptor.type, wireType);
-    if (descriptor.repeated) {
-      output[descriptor.name] ||= [];
-      output[descriptor.name].push(value);
-    } else {
-      output[descriptor.name] = value;
-    }
-  }
-  return output;
-}
-
 function jsonToProtoValue(value) {
   if (value === null) return { nullValue: 0 };
   if (Array.isArray(value)) return { listValue: { values: value.map(jsonToProtoValue) } };

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

@@ -482,7 +482,14 @@ function selectParameterizedCursorVariant(group, requested, sendOpts = {}) {
   const parameters = { ...(defaultVariant?.parameters || {}), ...aliasParameters };
   const routeParameters =
     sendOpts.modelParameters && typeof sendOpts.modelParameters === 'object' ? sendOpts.modelParameters : {};
+  // The window picked the mode above: a stored `context` no variant of that
+  // mode offers (a 256k left beside a raised 500K window) is a stale value and
+  // yields to the mode's own; one the mode offers stays the user's choice.
+  const staleContext =
+    Object.hasOwn(routeParameters, 'context') &&
+    !availableVariants.some((variant) => String(variant.parameters?.context ?? '') === String(routeParameters.context));
   for (const definition of group.definitions) {
+    if (staleContext && definition.id === 'context') continue;
     if (Object.hasOwn(routeParameters, definition.id)) {
       parameters[definition.id] = String(routeParameters[definition.id]);
     }