@koreanhole/opencodex 2.97.0 → 2.99.0

package/src/adapters/cli-agent/gemini/model-metadata.ts

@@ -26,6 +26,9 @@ export interface GeminiMetadataResult {
   packageRoot?: string;
   settingsPath?: string;
   capabilities: Record<string, GeminiModelCapability>;
+  tokenLimits: Record<string, number>;
+  defaultTokenLimit?: number;
+  compressionThreshold?: number;
   warning?: string;
 }
 
@@ -123,6 +126,85 @@ async function readThinkingLevels(packageRoot: string): Promise<Array<{ effort:
   return [];
 }
 
+interface RuntimeLimits {
+  tokenLimits: Record<string, number>;
+  defaultTokenLimit?: number;
+  compressionThreshold?: number;
+}
+
+function numericLiteral(value: string): number | undefined {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : undefined;
+}
+
+function functionBody(text: string, name: string): string | undefined {
+  const start = text.indexOf(`function ${name}(`);
+  if (start < 0) return undefined;
+  const open = text.indexOf("{", start);
+  if (open < 0) return undefined;
+  let depth = 0;
+  for (let index = open; index < text.length; index++) {
+    if (text[index] === "{") depth++;
+    else if (text[index] === "}" && --depth === 0) return text.slice(open + 1, index);
+  }
+  return undefined;
+}
+
+async function readRuntimeLimits(packageRoot: string): Promise<RuntimeLimits> {
+  let files: string[];
+  try {
+    files = (await readdir(join(packageRoot, "bundle"))).filter(name => name.endsWith(".js"));
+  } catch {
+    return { tokenLimits: {} };
+  }
+  const candidates = await Promise.all(files.map(async name => {
+    const path = join(packageRoot, "bundle", name);
+    const info = await stat(path).catch(() => undefined);
+    return info ? { path, size: info.size } : undefined;
+  }));
+  candidates.sort((left, right) => (left?.size ?? Infinity) - (right?.size ?? Infinity));
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const text = await readFile(candidate.path, "utf8").catch(() => "");
+    if (!text.includes("DEFAULT_TOKEN_LIMIT")) continue;
+    const defaultMatch = text.match(/var DEFAULT_TOKEN_LIMIT = ([0-9.e+]+);/);
+    const defaultTokenLimit = defaultMatch ? numericLiteral(defaultMatch[1]!) : undefined;
+    if (!defaultTokenLimit) continue;
+    const gemmaMatch = text.match(/var GEMMA_4_TOKEN_LIMIT = ([0-9.e+]+);/);
+    const gemmaLimit = gemmaMatch ? numericLiteral(gemmaMatch[1]!) : undefined;
+    const thresholdMatch = text.match(/var DEFAULT_COMPRESSION_TOKEN_THRESHOLD = ([0-9.]+);/);
+    const compressionThreshold = thresholdMatch ? Number(thresholdMatch[1]) : undefined;
+    const constants = new Map<string, string>();
+    for (const match of text.matchAll(/var ([A-Z][A-Z0-9_]*) = "([^"]+)";/g)) {
+      constants.set(match[1]!, match[2]!);
+    }
+    const body = functionBody(text, "tokenLimit");
+    const tokenLimits: Record<string, number> = {};
+    if (body) {
+      const groups = [...body.matchAll(/case ([A-Z][A-Z0-9_]*):([\s\S]*?)(?=case |default:|$)/g)];
+      for (const group of groups) {
+        const modelId = constants.get(group[1]!);
+        const returned = group[2]!.match(/return ([A-Z][A-Z0-9_]*|[0-9.e+]+);/)?.[1];
+        if (!modelId || !returned) continue;
+        const limit = returned === "DEFAULT_TOKEN_LIMIT"
+          ? defaultTokenLimit
+          : returned === "GEMMA_4_TOKEN_LIMIT"
+            ? gemmaLimit
+            : numericLiteral(returned);
+        if (limit) tokenLimits[modelId] = limit;
+      }
+    }
+    return {
+      tokenLimits,
+      defaultTokenLimit,
+      ...(compressionThreshold !== undefined && compressionThreshold > 0 && compressionThreshold <= 1
+        ? { compressionThreshold }
+        : {}),
+    };
+  }
+  return { tokenLimits: {} };
+}
+
 function mergeConfig(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown> {
   const out = { ...target };
   for (const [key, value] of Object.entries(source)) {
@@ -195,19 +277,20 @@ function capabilitiesFromMetadata(
 async function loadMetadata(options: GeminiMetadataOptions): Promise<GeminiMetadataResult> {
   const env = options.env ?? process.env;
   const packageRoot = options.packageRoot ?? await findPackageRoot(options.binary);
-  if (!packageRoot) return { capabilities: {}, warning: "Gemini CLI package metadata was not found." };
+  if (!packageRoot) return { capabilities: {}, tokenLimits: {}, warning: "Gemini CLI package metadata was not found." };
+  const runtimeLimits = await readRuntimeLimits(packageRoot);
   const docsPath = join(packageRoot, "bundle", "docs", "reference", "configuration.md");
   let markdown: string;
   try {
     markdown = await readFile(docsPath, "utf8");
   } catch {
-    return { packageRoot, capabilities: {}, warning: "Gemini CLI model configuration documentation was not found." };
+    return { packageRoot, capabilities: {}, ...runtimeLimits, warning: "Gemini CLI model configuration documentation was not found." };
   }
   const defaultAliases = extractDefaultJson(markdown, "aliases");
   const defaultDefinitions = extractDefaultJson(markdown, "modelDefinitions");
   const defaultOverrides = extractDefaultJsonValue(markdown, "overrides");
   if (!defaultAliases || !defaultDefinitions) {
-    return { packageRoot, capabilities: {}, warning: "Gemini CLI model configuration metadata could not be parsed." };
+    return { packageRoot, capabilities: {}, ...runtimeLimits, warning: "Gemini CLI model configuration metadata could not be parsed." };
   }
 
   const home = stringValue(env.GEMINI_CLI_HOME) ?? stringValue(env.HOME) ?? stringValue(env.USERPROFILE) ?? homedir();
@@ -231,12 +314,13 @@ async function loadMetadata(options: GeminiMetadataOptions): Promise<GeminiMetad
   ];
   const levels = await readThinkingLevels(packageRoot);
   if (levels.length === 0) {
-    return { packageRoot, settingsPath, capabilities: {}, warning: "Gemini CLI thinking-level metadata was not found." };
+    return { packageRoot, settingsPath, capabilities: {}, ...runtimeLimits, warning: "Gemini CLI thinking-level metadata was not found." };
   }
   return {
     packageRoot,
     settingsPath,
     capabilities: capabilitiesFromMetadata(definitions, aliases, levels, overrides),
+    ...runtimeLimits,
   };
 }
 
@@ -273,6 +357,18 @@ export function mergeGeminiModelDescriptors(
       ...(model.description ? { description: model.description } : {}),
       supportedReasoningLevels: reasoningLevels,
       ...(capability?.defaultReasoningLevel ? { defaultReasoningLevel: capability.defaultReasoningLevel } : {}),
+      ...(metadata.tokenLimits[model.modelId] !== undefined
+        ? {
+            contextWindowTokens: metadata.tokenLimits[model.modelId],
+            maxContextWindowTokens: metadata.tokenLimits[model.modelId],
+          }
+        : metadata.defaultTokenLimit !== undefined
+          ? {
+              contextWindowTokens: metadata.defaultTokenLimit,
+              maxContextWindowTokens: metadata.defaultTokenLimit,
+            }
+          : {}),
+      ...(metadata.compressionThreshold !== undefined ? { compressionThreshold: metadata.compressionThreshold } : {}),
     };
   });
 }

package/src/adapters/cli-agent/gemini/runtime.ts

@@ -0,0 +1,183 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getConfigDir } from "../../../config";
+import type { AcpInitialize } from "../acp-client";
+
+export interface GeminiModelRuntime {
+  contextSize?: number;
+  usedTokens?: number;
+  promptChars?: number;
+  charsPerToken?: number;
+  observedAt: number;
+}
+
+export interface GeminiRuntime {
+  loadSession: boolean;
+  prompt: {
+    image: boolean;
+    audio: boolean;
+    embeddedContext: boolean;
+  };
+  compressionThreshold?: number;
+  models: Record<string, GeminiModelRuntime>;
+}
+
+const runtimeCache = new Map<string, GeminiRuntime>();
+let loadedFromDisk = false;
+
+function positive(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+function nonNegative(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function runtimePath(env: NodeJS.ProcessEnv): string {
+  return join(getConfigDir(env), "gemini", "capabilities.json");
+}
+
+function emptyRuntime(): GeminiRuntime {
+  return {
+    loadSession: false,
+    prompt: { image: false, audio: false, embeddedContext: false },
+    models: {},
+  };
+}
+
+function parseRuntime(value: unknown): GeminiRuntime | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const row = value as Record<string, unknown>;
+  const prompt = row.prompt && typeof row.prompt === "object" && !Array.isArray(row.prompt)
+    ? row.prompt as Record<string, unknown>
+    : {};
+  const models: Record<string, GeminiModelRuntime> = {};
+  if (row.models && typeof row.models === "object" && !Array.isArray(row.models)) {
+    for (const [modelId, raw] of Object.entries(row.models as Record<string, unknown>)) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+      const item = raw as Record<string, unknown>;
+      models[modelId] = {
+        ...(positive(item.contextSize) !== undefined ? { contextSize: positive(item.contextSize) } : {}),
+        ...(nonNegative(item.usedTokens) !== undefined ? { usedTokens: nonNegative(item.usedTokens) } : {}),
+        ...(nonNegative(item.promptChars) !== undefined ? { promptChars: nonNegative(item.promptChars) } : {}),
+        ...(positive(item.charsPerToken) !== undefined ? { charsPerToken: positive(item.charsPerToken) } : {}),
+        observedAt: nonNegative(item.observedAt) ?? 0,
+      };
+    }
+  }
+  const threshold = positive(row.compressionThreshold);
+  return {
+    loadSession: row.loadSession === true,
+    prompt: {
+      image: prompt.image === true,
+      audio: prompt.audio === true,
+      embeddedContext: prompt.embeddedContext === true,
+    },
+    ...(threshold !== undefined && threshold <= 1 ? { compressionThreshold: threshold } : {}),
+    models,
+  };
+}
+
+async function readDisk(env: NodeJS.ProcessEnv): Promise<void> {
+  if (loadedFromDisk) return;
+  loadedFromDisk = true;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await readFile(runtimePath(env), "utf8"));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+  for (const [fingerprint, value] of Object.entries(parsed as Record<string, unknown>)) {
+    const runtime = parseRuntime(value);
+    if (runtime) runtimeCache.set(fingerprint, runtime);
+  }
+}
+
+async function persist(env: NodeJS.ProcessEnv): Promise<void> {
+  const path = runtimePath(env);
+  await mkdir(join(getConfigDir(env), "gemini"), { recursive: true, mode: 0o700 });
+  const limit = Number(env.OPENCODEX_GEMINI_CAPABILITY_MAX ?? "") || 8;
+  if (runtimeCache.size > limit) {
+    const oldest = [...runtimeCache.entries()]
+      .sort((left, right) => {
+        const leftAt = Math.max(0, ...Object.values(left[1].models).map(model => model.observedAt));
+        const rightAt = Math.max(0, ...Object.values(right[1].models).map(model => model.observedAt));
+        return leftAt - rightAt;
+      });
+    for (const [fingerprint] of oldest.slice(0, Math.max(0, runtimeCache.size - limit))) {
+      runtimeCache.delete(fingerprint);
+    }
+  }
+  const payload = Object.fromEntries(runtimeCache);
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify(payload, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  await rename(temporary, path);
+}
+
+export async function getGeminiRuntime(
+  fingerprint: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<GeminiRuntime> {
+  await readDisk(env);
+  return runtimeCache.get(fingerprint) ?? emptyRuntime();
+}
+
+export async function recordGeminiInitialize(
+  fingerprint: string,
+  initialize: AcpInitialize,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  await readDisk(env);
+  const current = runtimeCache.get(fingerprint) ?? emptyRuntime();
+  runtimeCache.set(fingerprint, {
+    ...current,
+    loadSession: initialize.capabilities.loadSession,
+    prompt: { ...initialize.capabilities.prompt },
+  });
+  await persist(env).catch(() => undefined);
+}
+
+export async function recordGeminiUsage(
+  fingerprint: string,
+  modelId: string,
+  usedTokens: number,
+  contextSize: number,
+  promptChars: number,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  if (!positive(contextSize) || !nonNegative(usedTokens) || !nonNegative(promptChars)) return;
+  await readDisk(env);
+  const current = runtimeCache.get(fingerprint) ?? emptyRuntime();
+  const previous = current.models[modelId];
+  const charsPerToken = usedTokens > 0 && promptChars > 0
+    ? promptChars / usedTokens
+    : previous?.charsPerToken;
+  current.models[modelId] = {
+    contextSize,
+    usedTokens,
+    promptChars,
+    ...(charsPerToken !== undefined ? { charsPerToken } : {}),
+    observedAt: Date.now(),
+  };
+  runtimeCache.set(fingerprint, current);
+  await persist(env).catch(() => undefined);
+}
+
+export async function recordGeminiCompressionThreshold(
+  fingerprint: string,
+  threshold: number | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  if (threshold === undefined || !positive(threshold) || threshold > 1) return;
+  await readDisk(env);
+  const current = runtimeCache.get(fingerprint) ?? emptyRuntime();
+  current.compressionThreshold = threshold;
+  runtimeCache.set(fingerprint, current);
+  await persist(env).catch(() => undefined);
+}
+
+export function resetGeminiRuntimeCacheForTests(): void {
+  runtimeCache.clear();
+  loadedFromDisk = false;
+}

package/src/adapters/cli-agent/gemini/session-store.ts

@@ -0,0 +1,202 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getConfigDir } from "../../../config";
+import type { OcxMessage } from "../../../types";
+
+export interface GeminiSessionRecord {
+  keyHash: string;
+  vendorSessionId: string;
+  fingerprint: string;
+  modelId: string;
+  workspace: string;
+  historyCount: number;
+  historyHash: string;
+  lastUsed: number;
+  turnCount: number;
+}
+
+interface SessionDocument {
+  version: 1;
+  sessions: Record<string, GeminiSessionRecord>;
+  responses: Record<string, string>;
+}
+
+const sessions = new Map<string, GeminiSessionRecord>();
+const responses = new Map<string, string>();
+let loaded = false;
+
+function sessionPath(env: NodeJS.ProcessEnv): string {
+  return join(getConfigDir(env), "gemini", "sessions.json");
+}
+
+function positiveInt(value: unknown, fallback: number): number {
+  const parsed = typeof value === "string" ? Number(value) : value;
+  return typeof parsed === "number" && Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+
+function ttlMs(env: NodeJS.ProcessEnv): number {
+  return positiveInt(env.OPENCODEX_GEMINI_SESSION_TTL_MS, 60 * 60 * 1000);
+}
+
+function maxSessions(env: NodeJS.ProcessEnv): number {
+  return positiveInt(env.OPENCODEX_GEMINI_SESSION_MAX, 32);
+}
+
+function parseRecord(value: unknown): GeminiSessionRecord | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const row = value as Record<string, unknown>;
+  const keyHash = typeof row.keyHash === "string" ? row.keyHash : undefined;
+  const vendorSessionId = typeof row.vendorSessionId === "string" ? row.vendorSessionId : undefined;
+  const fingerprint = typeof row.fingerprint === "string" ? row.fingerprint : undefined;
+  const modelId = typeof row.modelId === "string" ? row.modelId : undefined;
+  const workspace = typeof row.workspace === "string" ? row.workspace : undefined;
+  const historyHash = typeof row.historyHash === "string" ? row.historyHash : undefined;
+  const historyCount = typeof row.historyCount === "number" && Number.isInteger(row.historyCount) && row.historyCount >= 0 ? row.historyCount : undefined;
+  const lastUsed = typeof row.lastUsed === "number" && Number.isFinite(row.lastUsed) && row.lastUsed >= 0 ? row.lastUsed : undefined;
+  const turnCount = typeof row.turnCount === "number" && Number.isInteger(row.turnCount) && row.turnCount >= 0 ? row.turnCount : undefined;
+  if (!keyHash || !vendorSessionId || !fingerprint || !modelId || !workspace || !historyHash || historyCount === undefined || lastUsed === undefined || turnCount === undefined) return undefined;
+  return { keyHash, vendorSessionId, fingerprint, modelId, workspace, historyCount, historyHash, lastUsed, turnCount };
+}
+
+async function load(env: NodeJS.ProcessEnv): Promise<void> {
+  if (loaded) return;
+  loaded = true;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await readFile(sessionPath(env), "utf8"));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+  const document = parsed as Partial<SessionDocument>;
+  if (document.version !== 1) return;
+  if (document.sessions && typeof document.sessions === "object") {
+    for (const [key, value] of Object.entries(document.sessions)) {
+      const record = parseRecord(value);
+      if (record) sessions.set(key, record);
+    }
+  }
+  if (document.responses && typeof document.responses === "object") {
+    for (const [responseId, keyHash] of Object.entries(document.responses)) {
+      if (typeof keyHash === "string") responses.set(responseId, keyHash);
+    }
+  }
+}
+
+async function persist(env: NodeJS.ProcessEnv): Promise<void> {
+  const path = sessionPath(env);
+  await mkdir(join(getConfigDir(env), "gemini"), { recursive: true, mode: 0o700 });
+  const document: SessionDocument = {
+    version: 1,
+    sessions: Object.fromEntries(sessions),
+    responses: Object.fromEntries(responses),
+  };
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify(document, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  await rename(temporary, path);
+}
+
+function safeWorkspace(workspace: string, env: NodeJS.ProcessEnv): boolean {
+  const root = join(getConfigDir(env), "gemini", "sessions");
+  return workspace.startsWith(`${root}/`);
+}
+
+async function removeWorkspace(record: GeminiSessionRecord, env: NodeJS.ProcessEnv): Promise<void> {
+  if (!safeWorkspace(record.workspace, env)) return;
+  await rm(record.workspace, { recursive: true, force: true }).catch(() => undefined);
+}
+
+export function hashConversationKey(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export function hashMessages(messages: readonly OcxMessage[]): string {
+  return createHash("sha256")
+    .update(JSON.stringify(messages, (key, value) => key === "timestamp" ? undefined : value))
+    .digest("hex");
+}
+
+export function geminiSessionWorkspace(keyHash: string, env: NodeJS.ProcessEnv = process.env): string {
+  return join(getConfigDir(env), "gemini", "sessions", keyHash);
+}
+
+export async function findGeminiSessionByResponseId(
+  responseId: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<GeminiSessionRecord | undefined> {
+  await load(env);
+  const keyHash = responses.get(responseId);
+  return keyHash ? sessions.get(keyHash) : undefined;
+}
+
+export async function findGeminiSessionByKeyHash(
+  keyHash: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<GeminiSessionRecord | undefined> {
+  await load(env);
+  return sessions.get(keyHash);
+}
+
+export async function saveGeminiSession(
+  record: GeminiSessionRecord,
+  responseId: string | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  await load(env);
+  sessions.set(record.keyHash, record);
+  const previousResponses = [...responses].filter(([, key]) => key === record.keyHash);
+  for (const [id] of previousResponses.slice(0, Math.max(0, previousResponses.length - 1))) {
+    responses.delete(id);
+  }
+  if (responseId) responses.set(responseId, record.keyHash);
+  const cutoff = Date.now() - ttlMs(env);
+  for (const [key, value] of sessions) {
+    if (value.lastUsed < cutoff) {
+      sessions.delete(key);
+      for (const [id, mapped] of responses) if (mapped === key) responses.delete(id);
+      await removeWorkspace(value, env);
+    }
+  }
+  const limit = maxSessions(env);
+  while (sessions.size > limit) {
+    const oldest = [...sessions.values()].sort((left, right) => left.lastUsed - right.lastUsed)[0];
+    if (!oldest) break;
+    sessions.delete(oldest.keyHash);
+    for (const [id, mapped] of responses) if (mapped === oldest.keyHash) responses.delete(id);
+    await removeWorkspace(oldest, env);
+  }
+  await persist(env);
+}
+
+export async function deleteGeminiSession(
+  keyHash: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  await load(env);
+  const record = sessions.get(keyHash);
+  sessions.delete(keyHash);
+  for (const [id, mapped] of responses) if (mapped === keyHash) responses.delete(id);
+  if (record) await removeWorkspace(record, env);
+  await persist(env);
+}
+
+export async function reclaimGeminiSessions(env: NodeJS.ProcessEnv = process.env): Promise<void> {
+  await load(env);
+  const cutoff = Date.now() - ttlMs(env);
+  let changed = false;
+  for (const [key, record] of sessions) {
+    if (record.lastUsed >= cutoff) continue;
+    sessions.delete(key);
+    for (const [id, mapped] of responses) if (mapped === key) responses.delete(id);
+    await removeWorkspace(record, env);
+    changed = true;
+  }
+  if (changed) await persist(env);
+}
+
+export function resetGeminiSessionStoreForTests(): void {
+  sessions.clear();
+  responses.clear();
+  loaded = false;
+}

package/src/adapters/cli-agent/protocol.ts

@@ -108,7 +108,7 @@ export function buildSystemPrompt(parsed: OcxParsedRequest): string | undefined
 
 export function buildConversationInput(
   parsed: OcxParsedRequest,
-  options: { maxHistoryChars?: number; vendorNameByWire?: ReadonlyMap<string, string> } = {},
+  options: { maxHistoryChars?: number; maxChars?: number; vendorNameByWire?: ReadonlyMap<string, string> } = {},
 ): string[] {
   const messages = parsed.context.messages.filter(message => message.role !== "developer");
   if (messages.length === 0) {
@@ -117,14 +117,8 @@ export function buildConversationInput(
   if (messages.length === 1 && messages[0]!.role === "user") {
     return [JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: textOf(messages[0]!.content) }] } })];
   }
-  const history = messages.slice(0, -1)
-    .map(message => formatMessage(message, options.vendorNameByWire))
-    .filter(Boolean)
-    .join("\n\n");
-  const limit = options.maxHistoryChars ?? MAX_PROJECTED_HISTORY_CHARS;
-  const boundedHistory = history.length > limit
-    ? `[Earlier conversation history truncated for length...]\n\n${history.slice(-limit)}`
-    : history;
+  const limit = options.maxChars ?? options.maxHistoryChars ?? MAX_PROJECTED_HISTORY_CHARS;
+  const boundedHistory = projectHistory(messages.slice(0, -1), limit, options.vendorNameByWire);
   const current = messages.at(-1)!;
   const currentText = current.role === "toolResult"
     ? `${formatMessage(current)}\n\nPlease proceed based on the above tool result.`
@@ -138,4 +132,61 @@ export function buildConversationInput(
   })];
 }
 
+function projectHistory(
+  messages: readonly OcxMessage[],
+  limit: number,
+  vendorNameByWire?: ReadonlyMap<string, string>,
+): string {
+  const entries = messages.map((message, index) => {
+    const age = messages.length - index;
+    const priority = message.role === "toolResult"
+      ? age <= 2 ? 10 : 2
+      : message.role === "user"
+        ? 9
+        : message.role === "assistant" && message.content.every(part => part.type === "thinking")
+          ? 1
+          : message.role === "assistant" && age <= 2
+            ? 8
+            : 4;
+    return {
+      index,
+      age,
+      priority,
+      text: formatMessage(message, vendorNameByWire),
+    };
+  }).filter(entry => entry.text.length > 0);
+  let total = entries.reduce((sum, entry) => sum + entry.text.length + 2, 0);
+  if (total <= limit) return entries.map(entry => entry.text).join("\n\n");
+  const removed = new Set<number>();
+  const candidates = entries
+    .filter(entry => entry.priority < 10)
+    .sort((left, right) => left.priority - right.priority || right.age - left.age);
+  for (const entry of candidates) {
+    if (total <= limit) break;
+    removed.add(entry.index);
+    total -= entry.text.length + 2;
+  }
+  for (const entry of entries.filter(entry => !removed.has(entry.index)).sort((left, right) => right.age - left.age)) {
+    if (total <= limit) break;
+    removed.add(entry.index);
+    total -= entry.text.length + 2;
+  }
+  const kept = entries.filter(entry => !removed.has(entry.index)).map(entry => entry.text);
+  return [`[Earlier conversation history omitted: ${removed.size} messages]`, ...kept].filter(Boolean).join("\n\n");
+}
+
+export function buildConversationDelta(
+  parsed: OcxParsedRequest,
+  startIndex: number,
+  options: { vendorNameByWire?: ReadonlyMap<string, string> } = {},
+): string {
+  const messages = parsed.context.messages.filter(message => message.role !== "developer");
+  const delta = messages.slice(startIndex).map(message => formatMessage(message, options.vendorNameByWire)).filter(Boolean);
+  if (delta.length === 0) return "";
+  const text = delta.join("\n\n");
+  return messages.at(-1)?.role === "toolResult"
+    ? `${text}\n\nPlease proceed based on the above tool result.`
+    : text;
+}
+
 export type { AdapterEvent };

package/src/adapters/cli-agent/types.ts

@@ -1,5 +1,5 @@
 import type { ChildProcess, SpawnOptions } from "node:child_process";
-import type { AdapterEvent, OcxUsage } from "../../types";
+import type { OcxUsage } from "../../types";
 
 export type CliAgentSpawnFn = (
   command: string,
@@ -17,27 +17,6 @@ export interface CliAgentStreamState {
   lastError?: string;
 }
 
-export interface CliAgentFailure {
-  exitCode: number;
-  stderr: string;
-}
-
-export interface CliAgentTurnPlan {
-  label: string;
-  binary: string;
-  args: readonly string[];
-  env: Record<string, string>;
-  cwd: string;
-  stdin: string;
-  stdinFile?: string;
-  state: CliAgentStreamState;
-  parseLine: (message: Record<string, unknown>, state: CliAgentStreamState) => AdapterEvent[];
-  classifyFailure?: (failure: CliAgentFailure) => Extract<AdapterEvent, { type: "error" }>;
-  requireToolCall?: boolean;
-  toolBatchIdleMs?: number;
-  cleanup: () => Promise<void>;
-}
-
 export interface CliAgentTurnDeps {
   spawn?: CliAgentSpawnFn;
   platform?: NodeJS.Platform;