@bitkyc08/opencodex 2.69.0 → 2.70.0

package/src/adapters/command-code-tool-text.ts

@@ -22,9 +22,10 @@ import { validatesRestoredValue } from "./command-code-restored-schema";
  * A text block that opens with `<tool_call>` is therefore held instead of streamed. It is dropped
  * when a native call proves it is a duplicate, or restored on an eligible clean MiMo finish when
  * it names a declared tool with arguments that fit its schema. Other markup is released unchanged.
- * MiMo can also append the markup after ordinary prose inside one text block; the stream filter
- * splits such a delta at the marker and holds the markup part the same way (#5698; a marker split
- * across deltas after prose is still released as text).
+ * MiMo can also append the markup after ordinary prose inside one text block. A marker that
+ * follows prose can never become a call: its envelope is still held — a matching native call
+ * strips it as an echo — and otherwise it is released as the presentation text it is.
+ * A leading bare envelope remains eligible under the declared-tool rules.
  * A malformed envelope that still opens and closes around a declared function name, but that the
  * strict parser rejects, is dropped instead of released when the native call for that same function
  * arrives, and on the clean-finish path, so the echo never reaches the client.
@@ -236,8 +237,14 @@ interface TextBlock {
   state: "probing" | "held" | "queued" | "dropped" | "streaming";
   ended: boolean;
   interrupted: boolean;
-  /** Tool inputs open when the block started; the native call that duplicates it is one of them. */
+  /**
+   * Tool inputs the block could echo: those open when it started, plus, for a post-prose tail,
+   * at most one later input of the envelope's own tool. The block waits only while one of them
+   * is still open.
+   */
   candidates: Set<string>;
+  /** The one later input a post-prose tail admitted as a candidate, if any. */
+  lateCandidate?: string;
 }
 
 interface TextChunk {
@@ -296,7 +303,19 @@ export class CommandCodeToolTextFilter {
 
   toolInputStart(id: unknown, name: unknown): AdapterEvent[] {
     const events = this.breakOpenBlocks();
-    if (typeof id === "string" && typeof name === "string") this.openInputs.set(id, name);
+    if (typeof id === "string" && typeof name === "string") {
+      this.openInputs.set(id, name);
+      // A post-prose echo can precede the start of the native input it duplicates. An echo
+      // duplicates one call, so a complete tail admits one later input of its own tool and no
+      // other: unrelated or repeated starts cannot keep extending the wait. Once every candidate
+      // closes without a match, matchNative releases the tail as text.
+      for (const block of this.held) {
+        if (!block.interrupted || block.candidates.size === 0 || block.lateCandidate !== undefined) continue;
+        if (looseEnvelopeName(block.markupParts.join(""), this.declared) !== name) continue;
+        block.lateCandidate = id;
+        block.candidates.add(id);
+      }
+    }
     return events;
   }
 
@@ -341,54 +360,60 @@ export class CommandCodeToolTextFilter {
       block = { id: key, markupParts: [], probe: "", bytes: 0, state: "probing", ended: false, interrupted: false, candidates: new Set(this.openInputs.keys()) };
       this.blocks.set(key, block);
     }
-    // MiMo can append tool-call markup after ordinary prose inside one text block. The probe below
-    // only recognizes a block that opens with the marker, so a marker arriving after prose would
-    // reach the client (captured 2026-09-23 from xiaomi/mimo-v2.6-pro: prose, then
-    // "<tool_call><function=exec>..." echoed by the gateway as one text delta). Split the delta at
-    // the marker: prose keeps its queued or streamed path, the markup starts a fresh probe block
-    // and follows the normal hold-and-restore route. A probing block that has consumed nothing but
-    // whitespace keeps its probe instead, because that probe already holds the marker.
-    if (block.state !== "held") {
-      const markerIndex = text.indexOf(TOOL_CALL_MARKER);
-      const whitespaceLead = markerIndex > 0 && block.state === "probing" && block.probe === ""
-        && text.slice(0, markerIndex).trim() === "";
-      // markerIndex === 0 on a probing block is the ordinary hold path; on any other state the
-      // block is ordinary text and the marker must still start a fresh probe block.
-      if (!whitespaceLead && (markerIndex > 0 || (markerIndex === 0 && block.state !== "probing"))) {
-        const prose = markerIndex > 0 ? text.slice(0, markerIndex) : "";
-        const marked = markerIndex > 0 ? text.slice(markerIndex) : text;
-        let proseEvents: AdapterEvent[] = [];
-        if (prose) {
-          if (block.state === "streaming" && this.head === this.pending.length) {
-            proseEvents = [{ type: "text_delta", text: prose }];
-          } else {
-            if (block.state === "dropped" || block.state === "streaming") {
-              block = { id: key, markupParts: [], probe: "", bytes: 0, state: "queued", ended: false, interrupted: true, candidates: new Set() };
-              this.blocks.set(key, block);
-            }
-            proseEvents = this.queueProseDelta(block, prose);
-            this.probeBlockText(block, prose);
-          }
-        }
-        if (block.state === "queued") block.state = "streaming";
-        this.activeProbes.delete(key);
-        const probeBlock: TextBlock = { id: key, markupParts: [], probe: "", bytes: 0, state: "probing", ended: false, interrupted: false, candidates: new Set(this.openInputs.keys()) };
-        this.blocks.set(key, probeBlock);
-        return [...boundaryEvents, ...proseEvents, ...this.textDelta(id, marked)];
-      }
-      if (markerIndex === -1 && block.state === "streaming" && this.head === this.pending.length) {
-        return [...boundaryEvents, { type: "text_delta", text }];
+    // Probe before retaining so the state transition precedes the marker scan: a delta that
+    // carries prose AND a marker must split this visit, not a later one.
+    if (block.state === "probing") {
+      this.probeBlockText(block, text);
+      if (block.state === "probing") this.activeProbes.set(key, block);
+      else this.activeProbes.delete(key);
+    }
+    // Only a bare text block can open protocol markup. Once prose has committed the block, a
+    // marker inside the delta starts a held tail instead: it never restores a call, but a
+    // matching native call still strips the echo and an unmatched one releases as text.
+    if (block.state === "streaming" || block.state === "queued") {
+      const markerStart = this.findFreshMarker(text);
+      if (markerStart !== undefined) {
+        return [
+          ...boundaryEvents,
+          ...this.enqueueTailProse(block, text.slice(0, markerStart)),
+          ...this.openHeldTail(key, text.slice(markerStart)),
+        ];
       }
     }
+    if (block.state === "streaming" && this.head === this.pending.length) {
+      return [...boundaryEvents, { type: "text_delta", text }];
+    }
     // Once a duplicate is dropped, later text is a new chunk at its own wire position.
     if (block.state === "dropped" || block.state === "streaming") {
       block = { id: key, markupParts: [], probe: "", bytes: 0, state: "queued", ended: false, interrupted: true, candidates: new Set() };
       this.blocks.set(key, block);
     }
-    const preceding = this.makeRoom(encoder.encode(text).byteLength);
-    this.retain(block, text);
-    if (block.state === "probing") this.activeProbes.set(key, block);
+    const events = this.retainChunk(block, text);
+    return [...boundaryEvents, ...events, ...this.limitPending()];
+  }
+
+  /** Find a complete marker or its trailing prefix before either can reach presentation text. */
+  private findFreshMarker(text: string): number | undefined {
+    const index = text.indexOf(TOOL_CALL_MARKER);
+    if (index >= 0) return index;
+    for (let length = Math.min(text.length, TOOL_CALL_MARKER.length - 1); length > 0; length--) {
+      if (text.endsWith(TOOL_CALL_MARKER.slice(0, length))) return text.length - length;
+    }
+    return undefined;
+  }
+
+  /** Retain a text fragment on a block and append its pending chunk. Never drains. */
+  private retainChunk(block: TextBlock, text: string): AdapterEvent[] {
     const bytes = encoder.encode(text).byteLength;
+    const flushing = this.queuedBytes + bytes > MAX_HELD_TOOL_TEXT_BYTES;
+    const preceding = this.makeRoom(bytes);
+    // The new block has no pending chunk during the flush, so demote it here too.
+    if (flushing && (block.state === "held" || block.state === "probing")) {
+      block.state = "queued";
+      block.markupParts = [];
+      this.activeProbes.delete(block.id);
+    }
+    this.retain(block, text);
     const tail = this.pending.at(-1);
     if (tail?.kind === "chunk" && tail.block === block && this.head < this.pending.length) {
       tail.parts.push(text);
@@ -399,9 +424,32 @@ export class CommandCodeToolTextFilter {
       this.queueOperations++;
     }
     this.queuedBytes += bytes;
-    this.probeBlockText(block, text);
-    if (block.state !== "probing") this.activeProbes.delete(key);
-    return [...boundaryEvents, ...preceding, ...this.limitPending()];
+    return preceding;
+  }
+
+  /**
+   * Emit or retain the prose that precedes a mid-prose marker. Streamed text takes the same
+   * immediate path it would have without a marker; anything queued stays on the wire order.
+   */
+  private enqueueTailProse(block: TextBlock, text: string): AdapterEvent[] {
+    if (text === "") return [];
+    if (block.state === "streaming" && this.head === this.pending.length) {
+      return [{ type: "text_delta", text }];
+    }
+    return this.retainChunk(block, text);
+  }
+
+  /**
+   * Open a budgeted probing/held tail for markup or a marker prefix that followed prose. The tail shares the native-call matching of
+   * an ordinary held block — a same-content call drops it as an echo — but `interrupted` bars
+   * restoration forever: prose-prefixed markup can never mint a call, only disappear or be text.
+   */
+  private openHeldTail(key: string, text: string): AdapterEvent[] {
+    const tail: TextBlock = { id: key, markupParts: [], probe: "", bytes: 0, state: "probing", ended: false, interrupted: true, candidates: new Set(this.openInputs.keys()) };
+    this.blocks.set(key, tail);
+    this.probeBlockText(tail, text);
+    if (tail.state === "probing") this.activeProbes.set(key, tail);
+    return [...this.retainChunk(tail, text), ...this.limitPending()];
   }
 
   textEnd(id: unknown): AdapterEvent[] {
@@ -476,7 +524,9 @@ export class CommandCodeToolTextFilter {
         // native call is for the function it declares, that call carries the execution, so drop the
         // echo rather than releasing it as text. A native call for any other tool proves nothing
         // about this envelope, so it keeps the release-as-text path below.
-        if (markup === undefined && looseEnvelopeName(text, this.declared) === name) {
+        // A held tail (markup after prose) never drops on name alone — its context is ordinary
+        // prose the model wrote, so only an exact input match can prove it is an echo.
+        if (!block.interrupted && markup === undefined && looseEnvelopeName(text, this.declared) === name) {
           this.drop(block);
           block.state = "dropped";
           this.activeProbes.delete(block.id);
@@ -593,24 +643,6 @@ export class CommandCodeToolTextFilter {
     }
   }
 
-  /** Route ordinary prose through the queued wire path (shared by the mid-stream marker split). */
-  private queueProseDelta(block: TextBlock, prose: string): AdapterEvent[] {
-    const preceding = this.makeRoom(encoder.encode(prose).byteLength);
-    this.retain(block, prose);
-    const bytes = encoder.encode(prose).byteLength;
-    const tail = this.pending.at(-1);
-    if (tail?.kind === "chunk" && tail.block === block && this.head < this.pending.length) {
-      tail.parts.push(prose);
-      tail.bytes += bytes;
-      this.queueOperations++;
-    } else {
-      this.pending.push({ kind: "chunk", block, parts: [prose], bytes });
-      this.queueOperations++;
-    }
-    this.queuedBytes += bytes;
-    return preceding;
-  }
-
   private drop(block: TextBlock): void {
     this.budget.releaseRetained(block.bytes, { kind: "live_transient" });
     this.queuedBytes = Math.max(0, this.queuedBytes - block.bytes);

package/src/adapters/command-code.ts

@@ -16,6 +16,7 @@ import { parseDataUrl } from "./image";
 import { createAdapterPhysicalSend } from "./physical-send";
 import { SendBudgetExhaustedError } from "../lib/upstream-retry";
 import { CommandCodeToolTextFilter, type CommandCodeDeclaredTools } from "./command-code-tool-text";
+import { EMPTY_COMMAND_CODE_PROJECT_CONTEXT, loadCommandCodeProjectContext } from "./command-code-project-context";
 
 function declaredTools(tools: OcxTool[]): CommandCodeDeclaredTools {
   return new Map(tools.map(tool => [
@@ -610,8 +611,11 @@ export function createCommandCodeAdapter(provider: OcxProviderConfig): ProviderA
         ...(choiceInstruction ? [choiceInstruction] : []),
       ].join("\n\n"), parsed.modelId);
       const reasoningEffort = supportedCommandCodeEffort(provider, parsed.modelId, parsed.options.reasoning);
+      const projectContext = provider.projectContext === "on"
+        ? await loadCommandCodeProjectContext(cwd)
+        : EMPTY_COMMAND_CODE_PROJECT_CONTEXT;
       const body = {
-        config: await commandCodeConfig(cwd), memory: "", taste: null, skills: null,
+        config: await commandCodeConfig(cwd), ...projectContext,
         permissionMode: "standard", mode: "agent",
         params: {
           model: canonicalCommandCodeModelId(parsed.modelId),

package/src/adapters/cursor/catalog.ts

@@ -140,6 +140,17 @@ export const CURSOR_CAPABILITIES: Record<string, CursorCapability> = {
       thinking: { levels: FULL, order: T },
     },
   },
+  // 260929 Claude Sonnet 5.5: cursor.com/docs/models/claude-sonnet-5-5 lists it (1M max context),
+  // but the live GetUsableModels roster does not yet. Shaped like Opus 5.5 (flat effort ids, no
+  // thinking variant); re-shape from the roster once it appears.
+  "claude-sonnet-5-5": {
+    displayName: "Claude Sonnet 5.5",
+    window: CONTEXT_1M,
+    defaultVariant: "regular",
+    variants: {
+      regular: { levels: FULL },
+    },
+  },
   "claude-sonnet-5": {
     displayName: "Claude Sonnet 5",
     window: CONTEXT_1M,

package/src/adapters/cursor/effort-map.ts

@@ -39,6 +39,9 @@ const CURSOR_MODEL_EFFORT_TIERS: Record<string, readonly string[]> = {
   // 260923 Opus 5.5: live GetUsableModels roster advertises low..max in both regular and fast forms.
   "claude-opus-5-5": ["low", "medium", "high", "xhigh", "max"],
   "claude-opus-5-5-fast": ["low", "medium", "high", "xhigh", "max"],
+  // 260929 preemptive Sonnet 5.5: Anthropic documents low..max; flat ids like Opus 5.5 until the
+  // live GetUsableModels roster lists the model.
+  "claude-sonnet-5-5": ["low", "medium", "high", "xhigh", "max"],
   "claude-sonnet-5": ["low", "medium", "high", "xhigh", "max"],
   "glm-5.2": ["high", "max"],
   // 260825 live GetUsableModels. gemini-3.6-flash was the first Cursor model exposing

package/src/adapters/devin/cloud-direct/catalog.ts

@@ -35,8 +35,18 @@
  *     #5  supports_images      bool   ← tri-state: absent stays unknown
  *     #18 max_input_tokens     varint ← per-account context window
  *     #22 model_uid            string ← what `GetChatMessage` accepts
+ *     #23 model_info           ModelInfo { #6 features { #15 supports_thinking },
+ *                                          #13 max_output_tokens, #23 model_family_uid }
+ *     #30 family_metadata      ModelFamilyMetadata { #1 family_label,
+ *                                          #2 repeated Entry { #1 axis key, #2 { #1 order, #2 name } },
+ *                                          #3 is_default_model_in_family }
+ *     #31 is_default_model_in_family bool
  *   }
  *
+ *   #23/#30/#31 were read back from a live 267-row catalog (2026-09-27): every
+ *   current row names its family, and each family marks one default member.
+ *   Legacy `MODEL_*` rows carry no #30.
+ *
  *   Disabled semantics: TRUE means "this UID exists in the catalog but the
  *   caller's account/tier cannot run inference against it." BYOK models
  *   surface as `disabled: false` so users with their own provider keys still
@@ -91,6 +101,73 @@ export interface ModelCatalogEntry {
    * (see src/providers/antigravity-models.ts).
    */
   supportsImages?: boolean;
+  /** ModelInfo #13: the model's own output-token ceiling. */
+  maxOutputTokens?: number;
+  /** ModelInfo #6.15. */
+  supportsThinking?: boolean;
+  /** ModelInfo #23, e.g. `swe-1.7` for both `swe-1-7` and `swe-1-7-medium`. */
+  familyUid?: string;
+  /** ModelFamilyMetadata #1, e.g. `SWE-1.7`. */
+  familyLabel?: string;
+  /**
+   * ModelFamilyMetadata #2: this row's position on each of its family's axes,
+   * keyed by axis name (`Effort`, `Reasoning Effort`, `Fast Mode`, `1M Context`,
+   * `Thinking`, ...). Toggle axes such as `Fast Mode` carry only an order.
+   */
+  familyAxes?: Record<string, DevinFamilyAxisValue>;
+  /** #31 (or #30.3): the member the family selects when nothing is asked for. */
+  isFamilyDefault?: boolean;
+}
+
+export interface DevinFamilyAxisValue {
+  order: number;
+  name?: string;
+}
+
+/**
+ * Rows whose catalog entry claims image support that the model does not have.
+ * Live 2026-09-27: `swe-1-6` answered "NOIMAGE" to a solid red PNG while
+ * `swe-1-6-fast` and `swe-2-medium` named the colour, so the image is dropped
+ * server-side without an error. Marking it text-only lets the vision fallback
+ * describe the image instead of the model silently never seeing it.
+ */
+const IMAGE_BLIND_UIDS = new Set(['swe-1-6']);
+
+function parseFamilyMetadata(buf: Buffer): { label?: string; axes: Record<string, DevinFamilyAxisValue>; isDefault: boolean } {
+  let label: string | undefined;
+  let isDefault = false;
+  const axes: Record<string, DevinFamilyAxisValue> = {};
+  for (const f of iterFields(buf)) {
+    if (f.num === 1 && f.wire === 2 && Buffer.isBuffer(f.value)) label = f.value.toString('utf8');
+    else if (f.num === 3 && f.wire === 0) isDefault = f.value === 1n;
+    else if (f.num === 2 && f.wire === 2 && Buffer.isBuffer(f.value)) {
+      let key = '';
+      const value: DevinFamilyAxisValue = { order: 0 };
+      for (const e of iterFields(f.value)) {
+        if (e.num === 1 && e.wire === 2 && Buffer.isBuffer(e.value)) key = e.value.toString('utf8');
+        else if (e.num === 2 && e.wire === 2 && Buffer.isBuffer(e.value)) {
+          for (const v of iterFields(e.value)) {
+            if (v.num === 1 && v.wire === 0) value.order = Number(v.value);
+            else if (v.num === 2 && v.wire === 2 && Buffer.isBuffer(v.value)) value.name = v.value.toString('utf8');
+          }
+        }
+      }
+      if (key) axes[key] = value;
+    }
+  }
+  return { ...(label ? { label } : {}), axes, isDefault };
+}
+
+function parseModelInfo(buf: Buffer): { maxOutputTokens?: number; familyUid?: string; supportsThinking?: boolean } {
+  const out: { maxOutputTokens?: number; familyUid?: string; supportsThinking?: boolean } = {};
+  for (const f of iterFields(buf)) {
+    if (f.num === 13 && typeof f.value === 'bigint' && f.value > 0n) out.maxOutputTokens = Number(f.value);
+    else if (f.num === 23 && f.wire === 2 && Buffer.isBuffer(f.value) && f.value.length > 0) out.familyUid = f.value.toString('utf8');
+    else if (f.num === 6 && f.wire === 2 && Buffer.isBuffer(f.value)) {
+      for (const g of iterFields(f.value)) if (g.num === 15 && g.wire === 0) out.supportsThinking = g.value === 1n;
+    }
+  }
+  return out;
 }
 
 export interface CacheEntry {
@@ -127,6 +204,9 @@ export function parseCatalogBuffer(buf: Buffer, apiKey: string, host: string): C
     let disabled = false;
     let contextWindow = 0;
     let supportsImages: boolean | undefined;
+    let info: ReturnType<typeof parseModelInfo> = {};
+    let family: ReturnType<typeof parseFamilyMetadata> | undefined;
+    let isFamilyDefault = false;
     for (const sf of iterFields(f.value as Buffer)) {
       if (sf.num === 1 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
         label = (sf.value as Buffer).toString('utf8');
@@ -145,8 +225,15 @@ export function parseCatalogBuffer(buf: Buffer, apiKey: string, host: string): C
         contextWindow = Number(sf.value);
       } else if (sf.num === 22 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
         modelUid = (sf.value as Buffer).toString('utf8');
+      } else if (sf.num === 23 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
+        info = parseModelInfo(sf.value);
+      } else if (sf.num === 30 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
+        family = parseFamilyMetadata(sf.value);
+      } else if (sf.num === 31 && sf.wire === 0) {
+        isFamilyDefault = sf.value === 1n;
       }
     }
+    if (IMAGE_BLIND_UIDS.has(modelUid)) supportsImages = false;
     if (modelUid.length > 0) {
       byUid.set(modelUid, {
         modelUid,
@@ -154,6 +241,10 @@ export function parseCatalogBuffer(buf: Buffer, apiKey: string, host: string): C
         disabled,
         ...(contextWindow > 0 ? { contextWindow } : {}),
         ...(supportsImages !== undefined ? { supportsImages } : {}),
+        ...info,
+        ...(family?.label ? { familyLabel: family.label } : {}),
+        ...(family ? { familyAxes: family.axes } : {}),
+        ...(isFamilyDefault || family?.isDefault ? { isFamilyDefault: true } : {}),
       });
     }
   }