@bitkyc08/opencodex 2.69.0 → 2.70.0

package/src/adapters/devin/live-models.ts

@@ -2,12 +2,12 @@
  * Live Devin / Cognition model discovery via GetCascadeModelConfigs.
  *
  * The live catalog is the source of truth for the model roster. The endpoint
- * returns effort-suffixed variants (e.g. `gpt-5-6-sol-high`); we collapse those
- * to base ids so the picker stays clean and the adapter appends the effort
- * suffix at request time. `DEVIN_STATIC_MODELS` is only a degraded-mode
+ * returns one row per variant (e.g. `gpt-5-6-sol-high`), grouped into families;
+ * the picker shows one id per family and the adapter picks the family member
+ * for the requested effort at request time. `DEVIN_STATIC_MODELS` is only a degraded-mode
  * fallback for when there is no API key or discovery fails.
  */
-import { getCachedCatalog, type ModelCatalogEntry } from "./cloud-direct";
+import { getCachedCatalog, type CacheEntry, type ModelCatalogEntry } from "./cloud-direct";
 
 const DEFAULT_HOST = "https://server.codeium.com";
 
@@ -66,6 +66,8 @@ export const DEVIN_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
   "claude-opus-5-5": 1_000_000,
   "claude-opus-5": 1_000_000,
   "claude-fable-5-1": 1_000_000,
+  // 260929 preemptive: Claude Sonnet 5.5 (1M per Anthropic) seeded before Devin's live catalog lists it.
+  "claude-sonnet-5-5": 1_000_000,
   "claude-sonnet-5": 1_000_000,
   "glm-5-2": 200_000,
   "glm-5-3": 1_048_576,
@@ -103,7 +105,7 @@ export function collapseDevinModelUid(uid: string): string {
  * Offering them on a reasoning control would name a setting that does something
  * else, so the collapse keeps stripping them while the ladder ignores them.
  */
-const REASONING_RUNG_TOKENS = new Set(["none", "low", "medium", "high", "xhigh", "max"]);
+const REASONING_RUNG_TOKENS = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
 /**
  * The reasoning rungs a catalog UID carries, in ladder order.
@@ -124,11 +126,154 @@ export function devinReasoningRungsOf(uid: string): string[] {
 }
 
 /** Ladder order for display, matching the Codex rung order. */
-const RUNG_ORDER = ["none", "low", "medium", "high", "xhigh", "max"];
+const RUNG_ORDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export function sortDevinRungs(rungs: Iterable<string>): string[] {
   return [...new Set(rungs)].sort((a, b) => RUNG_ORDER.indexOf(a) - RUNG_ORDER.indexOf(b));
 }
 
+/**
+ * Effort rungs a catalog family axis can name, in ladder order.
+ * The catalog spells `Minimal` (Gemini Flash) and `No Thinking` (GLM), which
+ * resolution and the picker place alongside the usual Codex rungs.
+ */
+const FAMILY_EFFORT_LADDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+const EFFORT_AXES = ["Effort", "Reasoning Effort"];
+const FAST_AXIS = "Fast Mode";
+const LONG_CONTEXT_AXIS = "1M Context";
+const THINKING_AXIS = "Thinking";
+
+/** The picker id of a catalog family: its uid with dotted versions hyphenated, as the row uids spell it. */
+export function devinFamilyBaseId(familyUid: string): string {
+  return familyUid.replace(/\./g, "-");
+}
+
+function isEffortAxis(axis: string): boolean {
+  return EFFORT_AXES.includes(axis);
+}
+
+/** The effort rung a family member sits on, read from its axis value name rather than its uid. */
+export function devinFamilyEffortOf(entry: ModelCatalogEntry): string | undefined {
+  const axes = entry.familyAxes;
+  if (!axes) return undefined;
+  for (const axis of EFFORT_AXES) {
+    const name = axes[axis]?.name?.toLowerCase();
+    if (!name) continue;
+    const rung = name === "no thinking" ? "none" : name;
+    if (FAMILY_EFFORT_LADDER.includes(rung)) return rung;
+  }
+  return undefined;
+}
+
+const familyCache = new WeakMap<CacheEntry, Map<string, ModelCatalogEntry[]>>();
+
+/**
+ * Group catalog rows by family, keyed by the family's picker id. Only rows
+ * that carry family metadata take part; legacy `MODEL_*` rows are internal
+ * enum names and never form a picker family.
+ */
+export function devinFamiliesOf(catalog: CacheEntry): Map<string, ModelCatalogEntry[]> {
+  let families = familyCache.get(catalog);
+  if (families) return families;
+  families = new Map();
+  for (const entry of catalog.byUid.values()) {
+    if (!entry.familyUid || !entry.familyAxes || entry.modelUid.startsWith("MODEL_")) continue;
+    const base = devinFamilyBaseId(entry.familyUid);
+    const members = families.get(base);
+    if (members) members.push(entry);
+    else families.set(base, [entry]);
+  }
+  familyCache.set(catalog, families);
+  return families;
+}
+
+/** What a caller asked for, independent of how the catalog spells it. */
+export interface DevinVariantRequest {
+  effort?: string;
+  fast?: boolean;
+  longContext?: boolean;
+}
+
+function lexicallyLess(a: number[], b: number[]): boolean {
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return a[i]! < b[i]!;
+  return false;
+}
+
+function effortIndex(rung: string | undefined): number {
+  return rung === undefined ? -1 : FAMILY_EFFORT_LADDER.indexOf(rung);
+}
+
+/**
+ * The member closest to `targets` on the non-effort axes, then the lowest rung
+ * at or above `effort`, falling back to the highest rung below it. A missing
+ * rung never quietly turns reasoning down: `high` on SWE-1.7 (Medium, Max)
+ * selects Max, `xhigh` on SWE-2 selects Max, and `medium` on Kimi K3 (Low,
+ * High, Max) selects High.
+ *
+ * Not lowering a requested effort outranks the non-effort axes: in a family
+ * whose Fast rows stop at Medium, `high` plus Fast selects the regular High row
+ * rather than dropping to Medium to keep Fast. A member with no effort rung
+ * cannot prove it is not lower, so it ranks behind any rung at or above the
+ * request. `none` (the bottom of the ladder) is never "lowered", which leaves
+ * the Thinking-off target in charge of that request.
+ */
+function closestMember(
+  members: ModelCatalogEntry[],
+  targets: Record<string, number>,
+  effort: string | undefined,
+): ModelCatalogEntry | undefined {
+  const want = effortIndex(effort);
+  let best: ModelCatalogEntry | undefined;
+  let bestScore: number[] | undefined;
+  for (const member of members) {
+    const axes = member.familyAxes ?? {};
+    const mismatches = Object.entries(targets).filter(([axis, order]) => (axes[axis]?.order ?? 0) !== order).length;
+    const have = effortIndex(devinFamilyEffortOf(member));
+    const lowered = want > 0 && have < want ? 1 : 0;
+    const distance = want < 0 ? 0
+      : have < 0 ? 2 * FAMILY_EFFORT_LADDER.length
+      : have >= want ? have - want : FAMILY_EFFORT_LADDER.length + (want - have);
+    const score = [lowered, mismatches, distance, -have];
+    if (!bestScore || lexicallyLess(score, bestScore)) {
+      best = member;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+/**
+ * Pick the family member for a request. Axes the caller did not ask about
+ * (`Fast Mode`, `1M Context`, `Thinking`, `Prompt Cache Retention`, ...) stay
+ * where the anchor has them; the anchor is the member the caller named, else
+ * the family's catalog default, else the neutral member (every toggle off,
+ * effort nearest Medium) for the few families that mark no default. Disabled
+ * members are passed over while any enabled one remains, so the pre-flight
+ * only reports a tier refusal when the whole family is refused. `includeDisabled`
+ * ranks every member, which tells a caller whether a disabled row is itself the
+ * best match for the request.
+ */
+export function selectDevinFamilyMember(
+  members: ModelCatalogEntry[],
+  request: DevinVariantRequest,
+  anchor?: ModelCatalogEntry,
+  options: { includeDisabled?: boolean } = {},
+): ModelCatalogEntry | undefined {
+  const axisNames = new Set(members.flatMap((m) => Object.keys(m.familyAxes ?? {})).filter((a) => !isEffortAxis(a)));
+  const base = anchor
+    ?? members.find((m) => m.isFamilyDefault)
+    ?? closestMember(members, Object.fromEntries([...axisNames].map((a) => [a, 0])), "medium");
+  if (!base) return undefined;
+  const targets: Record<string, number> = {};
+  for (const axis of axisNames) targets[axis] = base.familyAxes?.[axis]?.order ?? 0;
+  if (request.fast && axisNames.has(FAST_AXIS)) targets[FAST_AXIS] = 1;
+  if (request.longContext && axisNames.has(LONG_CONTEXT_AXIS)) targets[LONG_CONTEXT_AXIS] = 1;
+  // `none` means no reasoning. Families like Claude Sonnet 4.6 express that as
+  // Thinking off rather than as an effort rung.
+  if (request.effort === "none" && axisNames.has(THINKING_AXIS)) targets[THINKING_AXIS] = 0;
+  const enabled = options.includeDisabled ? members : members.filter((m) => !m.disabled);
+  return closestMember(enabled.length > 0 ? enabled : members, targets, request.effort ?? devinFamilyEffortOf(base));
+}
+
 /**
  * Degraded-mode ladders, used only before the account catalog is readable.
  *
@@ -158,14 +303,18 @@ export type DevinUsableModelsResult =
       models: string[];
       contextWindows: Record<string, number>;
       efforts: Record<string, string[]>;
+      /** Per base, the effort of the family's catalog default member, when it is on the ladder. */
+      defaultEfforts: Record<string, string>;
       inputModalities: Record<string, string[]>;
     }
   | { ok: false; error: "auth" | "http" | "empty" | "unknown"; detail?: string };
 
 /**
  * Fetch the live model roster from Cognition's `GetCascadeModelConfigs` and
- * collapse effort-suffixed variants to base ids. The returned list is the
- * authoritative model roster for the signed-in account.
+ * collapse variants to base ids. Rows that carry family metadata collapse to
+ * their family and read their effort from the family's effort axis; only rows
+ * without it (older catalogs) fall back to reading suffixes off the uid. The
+ * returned list is the authoritative model roster for the signed-in account.
  */
 export async function fetchDevinUsableModels(opts: {
   apiKey: string;
@@ -187,9 +336,13 @@ export async function fetchDevinUsableModels(opts: {
       // Skip internal enum constants (e.g. MODEL_GPT_5_2_LOW, MODEL_PRIVATE_*).
       // Real chat model UIDs are lowercase dashed strings (swe-1-7, gpt-5-6-sol).
       if (entry.modelUid.startsWith("MODEL_")) continue;
-      const base = collapseDevinModelUid(entry.modelUid);
+      const family = entry.familyUid && entry.familyAxes ? devinFamilyBaseId(entry.familyUid) : undefined;
+      const base = family ?? collapseDevinModelUid(entry.modelUid);
       bases.add(base);
-      const found = devinReasoningRungsOf(entry.modelUid);
+      const familyRung = family ? devinFamilyEffortOf(entry) : undefined;
+      const found = family
+        ? (familyRung && REASONING_RUNG_TOKENS.has(familyRung) ? [familyRung] : [])
+        : devinReasoningRungsOf(entry.modelUid);
       if (found.length > 0) {
         let set = rungs.get(base);
         if (!set) { set = new Set(); rungs.set(base, set); }
@@ -222,13 +375,21 @@ export async function fetchDevinUsableModels(opts: {
       // would draw a picker whose only option is the value already in effect.
       if (set.size > 1) efforts[base] = sortDevinRungs(set);
     }
+    const defaultEfforts: Record<string, string> = {};
+    for (const [base, members] of devinFamiliesOf(catalog)) {
+      if (!members.some((member) => member.isFamilyDefault)) continue;
+      const selected = selectDevinFamilyMember(members, {});
+      const rung = selected && devinFamilyEffortOf(selected);
+      if (rung && efforts[base]?.includes(rung)) defaultEfforts[base] = rung;
+    }
     // supportsImages arrives tri-state per catalog row, so the collapse votes:
     // a row that never asserted field #5 abstains, which keeps an unsuffixed
     // unknown row from poisoning a base whose effort variants were measured
     // image-capable. Unanimous measured rows advertise; measured disagreement
     // advertises nothing, because a single measured false is not outvoted by
-    // its siblings. One accepted mismatch: resolveWireModelUid prefers the
-    // plain UID when the catalog lists it, so a base advertised
+    // its siblings. One accepted mismatch, only for rows without family
+    // metadata: resolveWireModelUid prefers the plain UID when the catalog
+    // lists it, so a base advertised
     // ["text","image"] on variant evidence can still route a no-effort request
     // to a plain row that never asserted the field.
     const inputModalities: Record<string, string[]> = {};
@@ -236,7 +397,7 @@ export async function fetchDevinUsableModels(opts: {
       if (votes.sawTrue && votes.sawFalse) continue;
       inputModalities[base] = votes.sawTrue ? ["text", "image"] : ["text"];
     }
-    return { ok: true, models: [...bases].sort(), contextWindows, efforts, inputModalities };
+    return { ok: true, models: [...bases].sort(), contextWindows, efforts, defaultEfforts, inputModalities };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (/unauth|401|invalid token|login/i.test(message)) return { ok: false, error: "auth", detail: message };

package/src/adapters/devin/reasoning-signature.ts

@@ -0,0 +1,100 @@
+/**
+ * Devin reasoning signatures across turns.
+ *
+ * GetChatMessage returns the turn's reasoning attestation as `delta_signature`
+ * (#10) together with `delta_signature_type` (#21) in the same frame, and the
+ * native client replays both on the assistant prompt as #12 and #18. Measured
+ * live on swe-2-high the pair arrives AFTER the visible answer (reasoning, text,
+ * then signature), so the Responses layer stores it as its own signature-only
+ * reasoning item behind the thinking-text item. GPT and Gemini rows stream no
+ * thinking text at all, only the signature.
+ *
+ * The type is carried inside the stored signature because the reasoning
+ * envelope that round-trips through the client keeps a single signature string.
+ * A signature stored before this prefix existed replays without a type.
+ */
+import type { OcxAssistantMessage } from "../../types";
+import { isProviderIssuedThinkingSignature } from "../../responses/reasoning-envelope";
+
+const TYPED_SIGNATURE_PREFIX = "devin-sig1:";
+
+export function encodeDevinSignature(signature: string, signatureType: string | undefined): string {
+  return signatureType && !signatureType.includes(":")
+    ? `${TYPED_SIGNATURE_PREFIX}${signatureType}:${signature}`
+    : signature;
+}
+
+export function decodeDevinSignature(stored: string): { signature: string; signatureType?: string } {
+  if (!stored.startsWith(TYPED_SIGNATURE_PREFIX)) return { signature: stored };
+  const rest = stored.slice(TYPED_SIGNATURE_PREFIX.length);
+  const colon = rest.indexOf(":");
+  if (colon <= 0) return { signature: stored };
+  return { signature: rest.slice(colon + 1), signatureType: rest.slice(0, colon) };
+}
+
+/**
+ * The assistant turn's reasoning for ChatMessagePrompt #11/#12/#18.
+ *
+ * All of the turn's thinking text is replayed. A signature rides along only
+ * when it covers exactly that text:
+ * - one thinking block carrying its own issued signature (a stray
+ *   signature-only block does not displace it);
+ * - at most one unsigned thinking block plus exactly one signature-only block,
+ *   which is how a single Devin turn arrives once its late #10 frame has been
+ *   split into its own reasoning item. With no thinking block at all this is a
+ *   GPT or Gemini row, where the signature is the only reasoning there is.
+ * Any other mix (two signed blocks, a signed block beside unsigned text) has no
+ * single attestation for the joined text, so the turn is replayed unsigned.
+ *
+ * `withholdAnthropic` drops an Anthropic signature and keeps the text: the
+ * fallback for a Claude turn Cognition refused (see hasAnthropicSignature).
+ */
+export function devinAssistantReasoning(
+  message: OcxAssistantMessage,
+  modelId = "",
+  withholdAnthropic = false,
+): { thinking?: string; signature?: string; signature_type?: string } {
+  const blocks = message.content.filter(
+    (part): part is Extract<typeof part, { type: "thinking" }> => part.type === "thinking",
+  );
+  const textBlocks = blocks.filter(part => Boolean(part.thinking));
+  const signatureOnly = blocks.filter(part => !part.thinking && isProviderIssuedThinkingSignature(part.signature));
+  const text = textBlocks.map(part => part.thinking).join("\n");
+  let stored: string | undefined;
+  if (textBlocks.length === 1 && isProviderIssuedThinkingSignature(textBlocks[0]!.signature)) {
+    stored = textBlocks[0]!.signature;
+  } else if (textBlocks.length === 0 && signatureOnly.length === 1) {
+    stored = signatureOnly[0]!.signature;
+  } else if (textBlocks.length === 1 && signatureOnly.length === 1) {
+    // Only the late trailer shape attests this text. The Responses parser can
+    // fold reasoning around a call into one assistant message, so counting
+    // blocks without checking their position can attach an unrelated signature.
+    const textIndex = message.content.indexOf(textBlocks[0]!);
+    if (message.content[textIndex + 1] === signatureOnly[0]) stored = signatureOnly[0]!.signature;
+  }
+  let decoded = stored ? decodeDevinSignature(stored) : undefined;
+  if (decoded && withholdAnthropic && signatureTypeFor(decoded, modelId) === "anthropic") decoded = undefined;
+  return {
+    ...(text ? { thinking: text } : {}),
+    ...(decoded ? { signature: decoded.signature } : {}),
+    ...(decoded?.signatureType ? { signature_type: decoded.signatureType } : {}),
+  };
+}
+
+/** A stored signature from before its type was recorded falls back to the model being called. */
+function signatureTypeFor(decoded: { signatureType?: string }, modelId: string): string | undefined {
+  return decoded.signatureType ?? (/claude/i.test(modelId) ? "anthropic" : undefined);
+}
+
+/**
+ * True when the mapped history replays a Claude signature. Cognition streams
+ * Claude's thinking as a summary while the signature covers the original, so
+ * the pair can fail validation: live on claude-opus-5-5 a signed replay of a
+ * visible-thinking turn was refused with `invalid_argument` in 5 of 6 tries and
+ * a text-only one in none, while a signed replay that is accepted is what lets
+ * the model recall its earlier reasoning. The adapter therefore sends the
+ * signature and retries a refusal once without it.
+ */
+export function hasAnthropicSignature(items: ReadonlyArray<{ signature?: string; signature_type?: string }>, modelId: string): boolean {
+  return items.some(item => Boolean(item.signature) && signatureTypeFor({ signatureType: item.signature_type }, modelId) === "anthropic");
+}