decorated-pi 0.3.0 → 0.4.0

package/extensions/patch.ts

@@ -11,7 +11,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as os from "node:os";
+import * as fsPromises from "node:fs/promises";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Types
@@ -45,6 +45,8 @@ export interface PatchResult {
   replacements: Map<string, ReplacementInfo[]>;
   /** Original file lines per file, for diff context generation */
   originalLines: Map<string, string[]>;
+  /** Pre-generated diff string (set by applyEdits to avoid re-reading files) */
+  diff: string;
 }
 
 /** Records a single old_str→new_str replacement within a file */
@@ -63,6 +65,8 @@ export interface ReplacementInfo {
   newLines: string[];
   /** Optional anchor text (first line only, for hunk display) */
   anchor?: string;
+  /** Anchor was provided but not found, and patch fell back to global old_str search */
+  anchorMissing?: boolean;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -90,6 +94,7 @@ export async function applyPatch(patch: FilePatch, cwd: string): Promise<PatchRe
     warnings: [],
     replacements: new Map(),
     originalLines: new Map(),
+    diff: "",
   };
 
   const absPath = resolveAbsPath(cwd, patch.path);
@@ -119,6 +124,7 @@ export async function applyPatches(patches: FilePatch[], cwd: string): Promise<P
     warnings: [],
     replacements: new Map(),
     originalLines: new Map(),
+    diff: "",
   };
 
   for (const p of patches) {
@@ -185,21 +191,17 @@ async function applyEdits(
   }
 
   const rawContent = fs.readFileSync(absPath, "utf8");
-  // Store original lines for diff context generation later
-  const origLines = rawContent.split("\n");
-  // Remove trailing empty line from split (trailing newline), but keep lines for content-less files
-  if (origLines.length > 1 && origLines[origLines.length - 1] === "") origLines.pop();
-  result.originalLines.set(displayPath, origLines);
-
   const lineEnding = detectLineEnding(rawContent);
   let content = normalizeLineEndings(rawContent);
 
   // Precompute line offsets for O(log n) line number lookups
-  const rawLineOffsets = buildLineOffsets(rawContent);
+  const lineOffsets = buildLineOffsets(rawContent);
+  const totalLines = lineOffsets.length - 1;
 
   // Track cumulative offset for mapping current positions back to original
   let cumulativeOffset = 0;
   const replacements: ReplacementInfo[] = [];
+  const neededRanges: LineRange[] = [];
 
   for (const edit of edits) {
     if (!edit.old_str) {
@@ -211,56 +213,80 @@ async function applyEdits(
 
     // Determine search range
     let searchFrom = 0;
+    let displayAnchor: string | undefined;
+    let anchorMissing = false;
+    let anchorNotFoundMessage: string | undefined;
 
     if (edit.anchor) {
       const anchorNorm = normalizeLineEndings(edit.anchor);
 
-      // Find anchor — must be unique
+      // Find anchor — must be unique when present
       const anchorIdx = content.indexOf(anchorNorm);
       if (anchorIdx === -1) {
-        throw new ApplyError(
-          `Anchor not found in ${displayPath}: "${truncate(edit.anchor)}".`
-        );
-      }
-      // Check uniqueness
-      const secondAnchor = content.indexOf(anchorNorm, anchorIdx + 1);
-      if (secondAnchor !== -1) {
-        throw new ApplyError(
-          `Anchor is not unique in ${displayPath}: "${truncate(edit.anchor)}" ` +
-          `found at multiple locations. Choose a more specific anchor.`
-        );
+        anchorNotFoundMessage = `Anchor not found in ${displayPath}: "${truncate(edit.anchor)}".`;
+      } else {
+        const secondAnchor = content.indexOf(anchorNorm, anchorIdx + 1);
+        if (secondAnchor !== -1) {
+          throw new ApplyError(
+            `Anchor is not unique in ${displayPath}: "${truncate(edit.anchor)}" ` +
+            `found at multiple locations. Choose a more specific anchor.`
+          );
+        }
+        // Search from anchor start position onward (anchor narrows search range)
+        // old_str may start at anchor position (anchor is a prefix of old_str)
+        searchFrom = anchorIdx;
+        displayAnchor = edit.anchor;
+        anchorMissing = false;
       }
-
-      // Search from anchor start position onward (anchor narrows search range)
-      // old_str may start at anchor position (anchor is a prefix of old_str)
-      searchFrom = anchorIdx;
     }
 
     // Find old_str in range — must be unique
-    const matchIdx = content.indexOf(oldNorm, searchFrom);
+    let matchIdx = anchorNotFoundMessage ? -1 : content.indexOf(oldNorm, searchFrom);
     if (matchIdx === -1) {
-      throw new ApplyError(
-        `old_str not found in ${displayPath}` +
-        (edit.anchor ? ` after anchor "${truncate(edit.anchor)}"` : "") +
-        `: "${truncate(edit.old_str)}". ` +
-        `The file may have changed — re-read it and try again.`
-      );
+      if (anchorNotFoundMessage) {
+        displayAnchor = edit.anchor;
+        anchorMissing = true;
+        const globalMatchIdx = content.indexOf(oldNorm, 0);
+        if (globalMatchIdx === -1) {
+          throw new ApplyError(
+            `${anchorNotFoundMessage} old_str not found in ${displayPath}: "${truncate(edit.old_str)}". ` +
+            `The file may have changed — re-read it and try again.`
+          );
+        }
+        const secondGlobalMatch = content.indexOf(oldNorm, globalMatchIdx + 1);
+        if (secondGlobalMatch !== -1) {
+          throw new ApplyError(
+            `${anchorNotFoundMessage} old_str is not unique in ${displayPath}: "${truncate(edit.old_str)}". ` +
+            `Add more context to old_str or use a more specific anchor.`
+          );
+        }
+        matchIdx = globalMatchIdx;
+      } else {
+        throw new ApplyError(
+          `old_str not found in ${displayPath}` +
+          (edit.anchor ? ` after anchor "${truncate(edit.anchor)}"` : "") +
+          `: "${truncate(edit.old_str)}". ` +
+          `The file may have changed — re-read it and try again.`
+        );
+      }
     }
 
-    // Check uniqueness
-    const secondMatch = content.indexOf(oldNorm, matchIdx + 1);
-    if (secondMatch !== -1) {
-      throw new ApplyError(
-        `old_str is not unique in ${displayPath}: "${truncate(edit.old_str)}". ` +
-        `Add more context to old_str or use an anchor to narrow the search.`
-      );
+    // Check uniqueness in anchor-narrowed / plain search path only when anchor was used normally
+    if (!anchorNotFoundMessage) {
+      const secondMatch = content.indexOf(oldNorm, matchIdx + 1);
+      if (secondMatch !== -1) {
+        throw new ApplyError(
+          `old_str is not unique in ${displayPath}: "${truncate(edit.old_str)}". ` +
+          `Add more context to old_str or use an anchor to narrow the search.`
+        );
+      }
     }
 
     // Compute line numbers in the original file for diff generation (O(log n) via binary search)
     // matchIdx is in the modified content; subtract cumulative offset to map back to original
     const origMatchIdx = matchIdx - cumulativeOffset;
-    const oldStartLine = lineAtOffset(rawLineOffsets, origMatchIdx);
-    const oldEndLine = lineAtOffset(rawLineOffsets, origMatchIdx + oldNorm.length - 1);
+    const oldStartLine = lineAtOffset(lineOffsets, origMatchIdx);
+    const oldEndLine = lineAtOffset(lineOffsets, origMatchIdx + oldNorm.length - 1);
 
     // Apply replacement
     content =
@@ -283,10 +309,35 @@ async function applyEdits(
       newEndLine,
       oldLines: oldNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
       newLines: newNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
-      anchor: edit.anchor ? edit.anchor.split("\n")[0] : undefined,
+      anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined,
+      anchorMissing,
+    });
+
+    // Collect context range for this edit
+    neededRanges.push({
+      startLine: Math.max(1, oldStartLine - CONTEXT_LINES),
+      endLine: Math.min(totalLines, oldEndLine + CONTEXT_LINES),
     });
   }
 
+  // Generate diff using only needed context lines (no full-file split)
+  const mergedRanges = mergeRanges(neededRanges);
+  const neededLines: Map<number, string> = new Map();
+  for (const range of mergedRanges) {
+    const lines = extractLineRange(content, lineOffsets, range.startLine, range.endLine);
+    for (let i = 0; i < lines.length; i++) {
+      neededLines.set(range.startLine + i, lines[i]);
+    }
+  }
+
+  // Build diff for this file and append to result
+  const fileDiff = generateLocalDiff(displayPath, replacements, neededLines, totalLines);
+  if (result.diff) {
+    result.diff += "\n" + fileDiff;
+  } else {
+    result.diff = fileDiff;
+  }
+
   // Restore line endings
   const finalContent = restoreLineEndings(content, lineEnding);
 
@@ -334,13 +385,13 @@ export async function computePatchPreview(
         return { error: "File not found" };
       }
 
-      const rawContent = fs.readFileSync(absPath, "utf8");
-      const origLines = rawContent.split("\n");
-      if (origLines.length > 1 && origLines[origLines.length - 1] === "") origLines.pop();
-      let content = normalizeLineEndings(rawContent);
-      const rawLineOffsets = buildLineOffsets(rawContent);
-      const allReplacements: ReplacementInfo[] = [];
-      let cumulativeOffset = 0;
+      const rawContent = await fsPromises.readFile(absPath, "utf8");
+    const lineOffsets = buildLineOffsets(rawContent);
+    const totalLines = lineOffsets.length - 1;
+    let content = normalizeLineEndings(rawContent);
+    const allReplacements: ReplacementInfo[] = [];
+    const neededRanges: LineRange[] = [];
+    let cumulativeOffset = 0;
 
       for (const edit of patch.edits) {
         if (!edit.old_str) continue;
@@ -348,33 +399,72 @@ export async function computePatchPreview(
         const newNorm = normalizeLineEndings(edit.new_str);
 
         let searchFrom = 0;
+        let displayAnchor: string | undefined;
+        let anchorMissing = false;
+        let anchorNotFoundMessage: string | undefined;
         if (edit.anchor) {
           const anchorNorm = normalizeLineEndings(edit.anchor);
           const idx = content.indexOf(anchorNorm);
           if (idx === -1) {
-            return { error: `Anchor not found: "${truncate(edit.anchor)}"` };
+            anchorNotFoundMessage = `Anchor not found: "${truncate(edit.anchor)}"`;
+          } else {
+            const secondAnchor = content.indexOf(anchorNorm, idx + 1);
+            if (secondAnchor !== -1) {
+              return { error: `Anchor is not unique: "${truncate(edit.anchor)}"` };
+            }
+            searchFrom = idx;
+            displayAnchor = edit.anchor;
+            anchorMissing = false;
           }
-          searchFrom = idx;
         }
 
-        const matchIdx = content.indexOf(oldNorm, searchFrom);
+        let matchIdx = anchorNotFoundMessage ? -1 : content.indexOf(oldNorm, searchFrom);
         if (matchIdx === -1) {
-          return { error: `old_str not found: "${truncate(edit.old_str)}"` };
+          if (anchorNotFoundMessage) {
+            displayAnchor = edit.anchor;
+            anchorMissing = true;
+            const globalMatchIdx = content.indexOf(oldNorm, 0);
+            if (globalMatchIdx === -1) {
+              return { error: `${anchorNotFoundMessage}; old_str not found: "${truncate(edit.old_str)}"` };
+            }
+            const secondGlobalMatch = content.indexOf(oldNorm, globalMatchIdx + 1);
+            if (secondGlobalMatch !== -1) {
+              return { error: `${anchorNotFoundMessage}; old_str is not unique: "${truncate(edit.old_str)}"` };
+            }
+            matchIdx = globalMatchIdx;
+          } else {
+            return { error: `old_str not found: "${truncate(edit.old_str)}"` };
+          }
         }
 
         const origMatchIdx = matchIdx - cumulativeOffset;
-        const oldStartLine = lineAtOffset(rawLineOffsets, origMatchIdx);
-        const oldEndLine = lineAtOffset(rawLineOffsets, origMatchIdx + oldNorm.length - 1);
+        const oldStartLine = lineAtOffset(lineOffsets, origMatchIdx);
+        const oldEndLine = lineAtOffset(lineOffsets, origMatchIdx + oldNorm.length - 1);
         const oldLines = oldNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === ""));
         const newLines = newNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === ""));
         content = content.substring(0, matchIdx) + newNorm + content.substring(matchIdx + oldNorm.length);
         const newStartLine = charOffsetToLine(content, matchIdx);
         const newEndLine = charOffsetToLine(content, matchIdx + newNorm.length - 1);
-        allReplacements.push({ oldStartLine, oldEndLine, newStartLine, newEndLine, oldLines, newLines, anchor: edit.anchor ? edit.anchor.split("\n")[0] : undefined });
+        // Record needed context range around this edit
+        neededRanges.push({
+          startLine: Math.max(1, oldStartLine - CONTEXT_LINES),
+          endLine: Math.min(totalLines, oldEndLine + CONTEXT_LINES),
+        });
+        allReplacements.push({ oldStartLine, oldEndLine, newStartLine, newEndLine, oldLines, newLines, anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined, anchorMissing });
         cumulativeOffset += newNorm.length - oldNorm.length;
       }
 
-      const diff = generateReplacementDiff(patch.path, allReplacements, origLines);
+      // Merge needed ranges and extract only those lines
+      const mergedRanges = mergeRanges(neededRanges);
+      const neededLines: Map<number, string> = new Map();
+      for (const range of mergedRanges) {
+        const lines = extractLineRange(content, lineOffsets, range.startLine, range.endLine);
+        for (let i = 0; i < lines.length; i++) {
+          neededLines.set(range.startLine + i, lines[i]);
+        }
+      }
+
+      const diff = generateLocalDiff(patch.path, allReplacements, neededLines, totalLines);
       return { diff };
     } else {
       return { error: "Must provide edits[] or overwrite:true" };
@@ -400,6 +490,12 @@ export async function computePatchPreviewMulti(
 
 
 export function generatePatchDiff(result: PatchResult): string {
+  // If applyEdits pre-generated the diff, use it directly (avoids re-reading files)
+  if (result.diff) {
+    return result.diff;
+  }
+
+  // Fallback: reconstruct diff from stored originalLines (legacy path)
   const parts: string[] = [];
   for (const [filePath, reps] of result.replacements) {
     const origLines = result.originalLines.get(filePath) ?? [];
@@ -438,14 +534,29 @@ function buildReplacementChunks(
   return chunks;
 }
 
-function getChunkAnchors(chunk: ReplacementChunk): string[] {
-  return [
-    ...new Set(
-      chunk.reps
-        .map((rep) => rep.anchor?.trim())
-        .filter((anchor): anchor is string => Boolean(anchor)),
-    ),
-  ];
+interface ChunkAnchor {
+  text: string;
+  missing: boolean;
+}
+
+function getChunkAnchors(chunk: ReplacementChunk): ChunkAnchor[] {
+  const byText = new Map<string, ChunkAnchor>();
+  for (const rep of chunk.reps) {
+    const text = rep.anchor?.trim();
+    if (!text) continue;
+    const existing = byText.get(text);
+    if (!existing) {
+      byText.set(text, { text, missing: Boolean(rep.anchorMissing) });
+    } else if (!rep.anchorMissing) {
+      // If any replacement successfully used this anchor, do not mark it missing.
+      existing.missing = false;
+    }
+  }
+  return [...byText.values()];
+}
+
+function formatAnchorLabel(anchor: ChunkAnchor): string {
+  return anchor.text + (anchor.missing ? " (missing)" : "");
 }
 
 function formatChunkHeader(chunk: ReplacementChunk): string {
@@ -459,7 +570,7 @@ function formatChunkHeader(chunk: ReplacementChunk): string {
   }
 
   if (anchors.length === 1) {
-    return `@@ lines ${range} @@ anchor: ${anchors[0]}`;
+    return `@@ lines ${range} @@ anchor: ${formatAnchorLabel(anchors[0]!)}`;
   }
 
   return `@@ lines ${range} @@`;
@@ -471,7 +582,7 @@ function formatChunkMetadataLines(chunk: ReplacementChunk): string[] {
 
   const shown = anchors.slice(0, 2);
   const remaining = anchors.length - shown.length;
-  const lines = ["anchors:", ...shown.map((anchor) => `  - ${anchor}`)];
+  const lines = ["anchors:", ...shown.map((anchor) => `  - ${formatAnchorLabel(anchor)}`)];
   if (remaining > 0) {
     lines.push(`  - +${remaining} more`);
   }
@@ -581,7 +692,18 @@ function restoreLineEndings(text: string, ending: string): string {
   return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
 }
 
-/** Precompute character offsets for each line start. offsets[i] = char offset of line i+1 (1-based). */
+// ═══════════════════════════════════════════════════════════════════════════
+// Line range utilities (for partial file reading)
+// ═══════════════════════════════════════════════════════════════════════════
+
+const CONTEXT_LINES = 3;
+
+interface LineRange {
+  startLine: number;
+  endLine: number;
+}
+
+/** Build line offset table: offsets[i] = character offset of line i+1 (1-based) */
 function buildLineOffsets(content: string): number[] {
   const offsets = [0];
   for (let i = 0; i < content.length; i++) {
@@ -590,8 +712,8 @@ function buildLineOffsets(content: string): number[] {
   return offsets;
 }
 
-/** Binary search: find 1-based line number containing the given char offset.
- *  Uses precomputed line offsets instead of scanning from the beginning. */
+
+/** Binary search: find 1-based line number containing charOffset */
 function lineAtOffset(lineOffsets: number[], charOffset: number): number {
   let lo = 0, hi = lineOffsets.length - 1;
   while (lo < hi) {
@@ -599,10 +721,51 @@ function lineAtOffset(lineOffsets: number[], charOffset: number): number {
     if (lineOffsets[mid] <= charOffset) lo = mid;
     else hi = mid - 1;
   }
-  return lo + 1; // 1-based
+  return lo + 1;
+}
+
+/** Binary search: find line start offset given 1-based line number */
+function offsetAtLine(lineOffsets: number[], lineNum: number): number {
+  if (lineNum <= 1) return 0;
+  if (lineNum > lineOffsets.length) return lineOffsets[lineOffsets.length - 1];
+  return lineOffsets[lineNum - 1];
 }
 
-/** Convert a character offset to a 1-based line number. O(n) — prefer lineAtOffset for repeated calls on same content. */
+/** Extract a range of lines from content (1-based, inclusive) */
+function extractLineRange(content: string, lineOffsets: number[], startLine: number, endLine: number): string[] {
+  const lines: string[] = [];
+  for (let i = startLine; i <= endLine; i++) {
+    const start = offsetAtLine(lineOffsets, i);
+    const end = offsetAtLine(lineOffsets, i + 1);
+    // Remove trailing \n from last line if present
+    const lineText = content.slice(start, end).replace(/\n$/, "");
+    lines.push(lineText);
+  }
+  return lines;
+}
+
+
+/** Merge overlapping/adjacent line ranges */
+function mergeRanges(ranges: LineRange[]): LineRange[] {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.startLine - b.startLine);
+  const merged: LineRange[] = [];
+  for (const r of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && r.startLine <= last.endLine + 1) {
+      last.endLine = Math.max(last.endLine, r.endLine);
+    } else {
+      merged.push({ ...r });
+    }
+  }
+  return merged;
+}
+
+function randomId(): string {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+/** Convert a character offset to a 1-based line number. */
 function charOffsetToLine(content: string, offset: number): number {
   let line = 1;
   for (let i = 0; i < offset && i < content.length; i++) {
@@ -611,8 +774,63 @@ function charOffsetToLine(content: string, offset: number): number {
   return line;
 }
 
-function randomId(): string {
-  return Math.random().toString(36).slice(2, 10);
+/**
+ * Generate diff using only the needed lines (partial file context).
+ */
+function generateLocalDiff(
+  filePath: string,
+  reps: ReplacementInfo[],
+  neededLines: Map<number, string>,
+  totalLines: number,
+): string {
+  if (reps.length === 0) return "";
+
+  const parts: string[] = [];
+  parts.push(`--- ${filePath}`);
+  parts.push(`+++ ${filePath}`);
+
+  // Calculate dynamic width based on max line number
+  const maxLineNum = Math.max(totalLines, ...reps.map(r => r.oldEndLine));
+  const numWidth = String(maxLineNum).length;
+
+  // Merge replacement chunks
+  const chunks = buildReplacementChunks(reps, totalLines, CONTEXT_LINES);
+  for (let c = 0; c < chunks.length; c++) {
+    if (c > 0) parts.push("");
+    const chunk = chunks[c]!;
+    parts.push(formatChunkHeader(chunk));
+    parts.push(...formatChunkMetadataLines(chunk));
+
+    // Output context + removed + added
+    let cursor = chunk.startLine;
+    for (const rep of chunk.reps) {
+      // Context before this replacement
+      for (let i = cursor; i < rep.oldStartLine; i++) {
+        const lineText = neededLines.get(i);
+        if (lineText !== undefined) {
+          parts.push(` ${String(i).padStart(numWidth, " ")} ${lineText}`);
+        }
+      }
+      // Removed lines
+      for (let i = 0; i < rep.oldLines.length; i++) {
+        parts.push(`-${String(rep.oldStartLine + i).padStart(numWidth, " ")} ${rep.oldLines[i]}`);
+      }
+      // Added lines
+      for (let i = 0; i < rep.newLines.length; i++) {
+        parts.push(`+${String(rep.oldStartLine + i).padStart(numWidth, " ")} ${rep.newLines[i]}`);
+      }
+      cursor = rep.oldEndLine + 1;
+    }
+    // Trailing context
+    for (let i = cursor; i <= chunk.endLine; i++) {
+      const lineText = neededLines.get(i);
+      if (lineText !== undefined) {
+        parts.push(` ${String(i).padStart(numWidth, " ")} ${lineText}`);
+      }
+    }
+  }
+
+  return parts.join("\n");
 }
 
 function truncate(s: string, maxLen = 60): string {

package/extensions/providers/ark-coding.ts

@@ -22,6 +22,8 @@ const BASE_URL = "https://ark.cn-beijing.volces.com/api/coding/v3";
 
 const MODELS: ProviderModelConfig[] = [
   { id: "deepseek-v3.2", name: "DeepSeek V3.2", reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 163_840, maxTokens: 65_536, compat: { supportsDeveloperRole: false, supportsReasoningEffort: true } as any },
+  { id: "deepseek-v4-flash", name: "DeepSeek V4 Flash", reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1_048_576, maxTokens: 1_048_576, compat: { supportsDeveloperRole: false, supportsReasoningEffort: true } as any },
+  { id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1_048_576, maxTokens: 1_048_576, compat: { supportsDeveloperRole: false, supportsReasoningEffort: true } as any },
   { id: "glm-4.7", name: "GLM 4.7", reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 202_752, maxTokens: 131_072, compat: { supportsDeveloperRole: false, supportsReasoningEffort: true } as any },
   { id: "glm-5.1", name: "GLM 5.1", reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 202_752, maxTokens: 131_072, compat: { supportsDeveloperRole: false, supportsReasoningEffort: true } as any },
   { id: "kimi-k2.5", name: "Kimi K2.5", reasoning: true, input: ["text", "image"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 262_144, maxTokens: 262_144, compat: { supportsDeveloperRole: false, supportsReasoningEffort: true } as any },