@bitkyc08/opencodex 2.69.0 → 2.70.0

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

@@ -39,6 +39,7 @@ import { getCachedCatalog, ModelNotAvailableError, type CacheEntry } from './cat
 import { anySignal, cancelBodyOnAbort } from '../../../lib/abort.js';
 import { parseRetryAfterFromMessage } from '../../../lib/retry-delay.js';
 import { resolveDevinApiBaseUrl } from '../../../oauth/devin/api-base.js';
+import { normalizeDevinToolParameters } from './tool-schema.js';
 
 /**
  * Connect-RPC streaming inactivity timeout. If the cloud sends zero bytes
@@ -175,6 +176,7 @@ export function allocateCascadeId(): string {
  *   #3 prompt: string                          (text content)
  *   #4 num_tokens: int                          (rough estimate)
  *   #5 safe_for_code_telemetry: bool            (1 = ok to log)
+ *   #9 tool_result_is_error: bool               (tool prompts only)
  *   #10 images: repeated ImageData              (multimodal)
  *   #11 thinking: string                        (assistant reasoning, replayed)
  *   #12 signature: string                       (opaque attestation for #11)
@@ -218,6 +220,7 @@ function encodeChatMessagePrompt(
     thinking?: string;
     signature?: string;
     signatureType?: string;
+    isError?: boolean;
   },
 ): Buffer {
   const textParts = content.filter((p): p is { type: 'text'; text: string } => p.type === 'text');
@@ -234,6 +237,9 @@ function encodeChatMessagePrompt(
   if (opts?.toolCallId) {
     parts.push(encodeString(7, opts.toolCallId));
   }
+  // Accepted live on a tool prompt. Only some models act on it, so the adapter
+  // also keeps an in-band marker in the text.
+  if (opts?.isError) parts.push(encodeVarintField(9, 1));
   // Assistant message with tool_calls: encode each as a ChatToolCall.
   if (opts?.toolCalls && opts.toolCalls.length > 0) {
     for (const tc of opts.toolCalls) {
@@ -257,30 +263,26 @@ function encodeChatMessagePrompt(
 const SOURCE_BY_ROLE: Record<string, number> = {
   user: 1,
   assistant: 2,
-  // NOTE: do not send source=3 (SYSTEM) directly — the Codeium chat backend
-  // returns "third-party model provider is experiencing issues" when any
-  // ChatMessagePrompt has source=SYSTEM. The captured LS upstream traffic
-  // shows the IDE inlines system context into the *user* prompt (source=1)
-  // wrapped in <additional_metadata>...</additional_metadata>. We collapse
-  // role:'system' messages into the next user turn before building the
-  // proto — see `collapseSystemIntoUser` below.
+  // Never sent as a prompt source: the leading system text goes in request #2,
+  // and a later system message is collapsed into the next user turn below.
   system: 1,
   tool: 4,
 };
 
 /**
- * Collapse OpenAI-style messages so all `role:'system'` entries are inlined
- * into the immediately-following user message, matching the wire format the
- * IDE uses. Cognition's chat backend rejects raw role=system entries.
+ * Collapse `role:'system'` entries that follow the conversation start into the
+ * immediately-following user message. The leading run of system messages never
+ * reaches here; it is the request's #2 system prompt. With S0 already sent as #2:
  *
- *   [{system: "S1"}, {system: "S2"}, {user: "U1"}, {assistant: "A1"}, {user: "U2"}]
+ *   [{user: "U1"}, {assistant: "A1"}, {system: "S1"}, {system: "S2"}, {user: "U2"}]
  *
  * becomes
  *
- *   [{user: "<system>\nS1\nS2\n</system>\nU1"}, {assistant: "A1"}, {user: "U2"}]
+ *   [{user: "U1"}, {assistant: "A1"}, {user: "<system>\nS1\n\nS2\n</system>\nU2"}]
  *
  * If there's no following user message, the trailing system messages get
- * appended as a synthesized user turn.
+ * appended as a synthesized user turn. A request made only of system messages
+ * keeps no #2 and comes through here whole, so its prompt list is never empty.
  */
 function collapseSystemIntoUser(messages: ChatHistoryItem[]): ChatHistoryItem[] {
   const out: ChatHistoryItem[] = [];
@@ -332,10 +334,15 @@ function collapseSystemIntoUser(messages: ChatHistoryItem[]): ChatHistoryItem[]
  * CompletionConfiguration — mirrors the LS-shipped defaults, lets the caller
  * override the obvious knobs.
  */
-/** Output cap when the caller named none. */
+/** Output cap when neither the caller nor the catalog named one. */
 const DEFAULT_MAX_OUTPUT_TOKENS = 8192;
-/** Context window when the caller named none. */
-const DEFAULT_CONTEXT_WINDOW = 128_000;
+/**
+ * CompletionConfiguration #3 is `max_newlines`, not a token count and not an
+ * input ceiling: live, a value of 5 did not truncate a 25-line answer. It is
+ * still sent, at the value every turn has carried, so the request shape the
+ * service accepts does not change.
+ */
+const MAX_NEWLINES = 128_000;
 
 /**
  * Cognition rejects a temperature of exactly 0 with the same opaque internal
@@ -353,7 +360,6 @@ function safeTemperature(value: number | undefined): number {
 
 function encodeCompletionConfiguration(opts: {
   maxOutputTokens?: number;
-  maxInputTokens?: number;
   temperature?: number;
   topK?: number;
   topP?: number;
@@ -365,15 +371,15 @@ function encodeCompletionConfiguration(opts: {
   };
   // Tag map, verified by building the same turn with a working client and
   // diffing the encoded messages field by field: #2 is the OUTPUT cap and #3 is
-  // the context window. This layout had those two swapped, so a caller asking
-  // for 32 output tokens put 32 into the context-window field and the request
-  // came back as an opaque "an internal error occurred" — for every turn, on
-  // every account, which is why free and paid failed identically. #6 and #11
-  // are not part of the message the service accepts.
+  // max_newlines. This layout once had those two swapped, so a caller's output
+  // cap landed in #3 and a large value in #2, and the request came back as an
+  // opaque "an internal error occurred" — for every turn, on every account,
+  // which is why free and paid failed identically. #6 and #11 are not part of
+  // the message the service accepts.
   return Buffer.concat([
     encodeVarintField(1, 1),
     encodeVarintField(2, opts.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS),
-    encodeVarintField(3, opts.maxInputTokens ?? DEFAULT_CONTEXT_WINDOW),
+    encodeVarintField(3, MAX_NEWLINES),
     enc64(5, safeTemperature(opts.temperature)),
     encodeVarintField(7, opts.topK ?? 40),
     enc64(8, opts.topP ?? 1.0),
@@ -424,6 +430,8 @@ export interface ChatHistoryItem {
   thinking?: string;
   signature?: string;
   signature_type?: string;
+  /** For `role: 'tool'` only — the tool failed. Encoded as ChatMessagePrompt #9. */
+  is_error?: boolean;
 }
 
 /**
@@ -486,7 +494,7 @@ export type CloudChatEvent =
    * turn produced. Without decoding it there is nothing to put in the prompt's
    * #12 on the next turn, so the replay would always be unsigned.
    */
-  | { kind: 'reasoning_signature'; signature: string }
+  | { kind: 'reasoning_signature'; signature: string; signatureType?: string }
   | { kind: 'tool_call_start'; id: string; name: string }
   | {
       kind: 'tool_call_args';
@@ -531,8 +539,8 @@ interface BuildArgs {
   messages: ChatHistoryItem[];
   cascadeId: string;
   /**
-   * GetChatMessageRequest #22. Optional because it is omitted on a first turn;
-   * the working client only reuses one across a later tool loop.
+   * GetChatMessageRequest #17 prompt_id. Optional because it is omitted on a
+   * first turn; the working client only reuses one across a later tool loop.
    */
   promptId?: string;
   sessionId: string;
@@ -543,7 +551,6 @@ interface BuildArgs {
   requestType?: number;
   completionOpts?: {
     maxOutputTokens?: number;
-    maxInputTokens?: number;
     temperature?: number;
     topK?: number;
     topP?: number;
@@ -636,16 +643,20 @@ export function sanitizeToolDescriptionForCognitionForTests(description: string)
   return sanitizeToolDescriptionForCognition(description);
 }
 
-function encodeToolDef(tool: ToolDef): Buffer {
-  const rawDesc = sanitizeToolDescriptionForCognition(tool.description ?? '');
-  const desc =
-    rawDesc.length > MAX_TOOL_DESC_LEN
-      ? rawDesc.slice(0, MAX_TOOL_DESC_LEN - 24) + '\n…(truncated for cloud)'
-      : rawDesc;
+/** Description as transmitted on the Cognition wire, also used by overflow estimation. */
+export function prepareToolDescriptionForCognition(description: string): string {
+  const rawDesc = sanitizeToolDescriptionForCognition(description);
+  return rawDesc.length > MAX_TOOL_DESC_LEN
+    ? rawDesc.slice(0, MAX_TOOL_DESC_LEN - 24) + '\n…(truncated for cloud)'
+    : rawDesc;
+}
+
+function encodeToolDef(tool: ToolDef, modelUid: string): Buffer {
+  const desc = prepareToolDescriptionForCognition(tool.description ?? '');
   return Buffer.concat([
     encodeString(1, tool.name),
     encodeString(2, desc),
-    encodeString(3, JSON.stringify(tool.parameters ?? {})),
+    encodeString(3, JSON.stringify(normalizeDevinToolParameters(modelUid, tool.parameters ?? {}))),
   ]);
 }
 
@@ -664,9 +675,22 @@ function buildGetChatMessageRequest(args: BuildArgs): Buffer {
     cloudChatShape: true,
   });
 
-  // System messages must be inlined into the user turn (Cognition cloud
-  // rejects source=3). See `collapseSystemIntoUser` for the format.
-  const collapsed = collapseSystemIntoUser(args.messages);
+  // The leading system messages become request #2. Measured live on swe-1-6
+  // with a ~6.7k-token system prompt: turn 2 read 6688 of 6715 prompt tokens
+  // from cache in #2, against 7072 of 7097 when the same text was collapsed
+  // into the first user prompt, so the cache ratio is unchanged and the prompt
+  // is smaller. The model obeyed an instruction given only in #2.
+  // A request with only system text keeps it as a user prompt: #2 alone would
+  // leave the request with no prompt at all.
+  const firstNonSystem = args.messages.findIndex((m) => m.role !== 'system');
+  const leadingSystem = firstNonSystem === -1 ? [] : args.messages.slice(0, firstNonSystem);
+  const systemPrompt = leadingSystem
+    .map((m) => normalizeContent(m.content)
+      .filter((p): p is { type: 'text'; text: string } => p.type === 'text')
+      .map((p) => p.text).join('\n'))
+    .filter(Boolean)
+    .join('\n\n');
+  const collapsed = collapseSystemIntoUser(args.messages.slice(leadingSystem.length));
   const promptParts = collapsed.map((m) =>
     encodeMessage(
       3,
@@ -683,6 +707,7 @@ function buildGetChatMessageRequest(args: BuildArgs): Buffer {
           thinking: m.role === 'assistant' ? m.thinking : undefined,
           signature: m.role === 'assistant' ? m.signature : undefined,
           signatureType: m.role === 'assistant' ? m.signature_type : undefined,
+          isError: m.role === 'tool' ? m.is_error : undefined,
         },
       ),
     ),
@@ -691,7 +716,7 @@ function buildGetChatMessageRequest(args: BuildArgs): Buffer {
   const completion = encodeCompletionConfiguration(args.completionOpts ?? {});
 
   const toolParts: Buffer[] = (args.tools ?? []).map((t) =>
-    encodeMessage(10, encodeToolDef(t)),
+    encodeMessage(10, encodeToolDef(t, args.modelUid)),
   );
 
   // Field layout from mitm capture of the LS:
@@ -701,15 +726,15 @@ function buildGetChatMessageRequest(args: BuildArgs): Buffer {
   //   #8  completion_configuration
   //   #10 tools (repeated ChatToolDefinition)
   //   #13 prompt_cache_options
+  //   #15 CortexTrajectoryReference
   //   #16 cascade_id (string)
+  //   #17 prompt_id (string)
   //   #21 chat_model_uid (string)
-  //   #22 prompt_id (string)
+  //   #22 execution_id (string)
   return Buffer.concat([
     encodeMessage(1, metadata),
-    // #2 system_prompt is always written, empty when the caller had none. The
-    // system turn is separately collapsed into the first user message because
-    // source=SYSTEM is refused; this field is the one the wire expects here.
-    encodeString(2, ''),
+    // #2 system_prompt is always written, empty when the caller had none.
+    encodeString(2, systemPrompt),
     ...promptParts,
     encodeVarintField(7, args.requestType ?? 5),
     encodeMessage(8, completion),
@@ -721,7 +746,7 @@ function buildGetChatMessageRequest(args: BuildArgs): Buffer {
     // it and records real savings; sending it unconditionally matches both the
     // native client and CLIProxyAPIPlus, which places it outside its tools gate.
     encodeMessage(13, encodeVarintField(1, PROMPT_CACHE_EPHEMERAL)),
-    // #15 session model config: { id, turn, 4 }. Present on every verified
+    // #15 CortexTrajectoryReference: { id, 1, 4 }. Present on every verified
     // request.
     encodeMessage(15, Buffer.concat([
       encodeString(1, crypto.randomUUID()),
@@ -731,9 +756,9 @@ function buildGetChatMessageRequest(args: BuildArgs): Buffer {
     encodeString(16, args.cascadeId),
     encodeVarintField(20, 1),
     encodeString(21, args.modelUid),
-    // #22 is deliberately omitted. It is a user-exchange id that only appears
-    // from the second turn onward and is reused across that turn's tool loop; a
-    // fresh per-request uuid matches neither shape.
+    // #17 prompt_id is deliberately omitted. It is a user-exchange id that only
+    // appears from the second turn onward and is reused across that turn's tool
+    // loop; a fresh per-request uuid matches neither shape.
   ]);
 }
 
@@ -792,6 +817,10 @@ export function* decodeChatFrame(proto: Buffer): Generator<CloudChatEvent> {
     }
   }
   if (authoritativeUsage) yield authoritativeUsage;
+  let signatureType: string | undefined;
+  for (const f of iterFields(proto)) {
+    if (f.num === 21 && f.wire === 2 && Buffer.isBuffer(f.value)) signatureType = (f.value as Buffer).toString('utf8') || undefined;
+  }
   for (const f of iterFields(proto)) {
     if (f.num === 3 && f.wire === 2 && Buffer.isBuffer(f.value)) {
       // Visible delta_text — what the user should SEE in the chat.
@@ -817,7 +846,8 @@ export function* decodeChatFrame(proto: Buffer): Generator<CloudChatEvent> {
       if (s) yield { kind: 'reasoning', text: s };
     } else if (f.num === 10 && f.wire === 2 && Buffer.isBuffer(f.value)) {
       const s = (f.value as Buffer).toString('utf8');
-      if (s) yield { kind: 'reasoning_signature', signature: s };
+      // #21 delta_signature_type arrives in the same frame; the prompt replays it as #18.
+      if (s) yield { kind: 'reasoning_signature', signature: s, ...(signatureType ? { signatureType } : {}) };
     } else if (f.num === 6 && f.wire === 2 && Buffer.isBuffer(f.value)) {
       let id: string | undefined;
       let name: string | undefined;

package/src/adapters/devin/cloud-direct/tool-schema.ts

@@ -0,0 +1,121 @@
+/**
+ * Tool-schema compatibility for Gemini models behind GetChatMessage.
+ *
+ * Measured live on gemini-3-8-flash-medium: any schema node whose `type` is a
+ * JSON-Schema type array (`["string", "null"]`) is refused with an opaque
+ * `invalid_argument` on every turn, while the same union spelled as
+ * `anyOf: [{type: "string"}, {type: "null"}]` is accepted, as are `$schema`,
+ * `additionalProperties: false`, `const`, and `$ref`/`$defs`. Claude models
+ * accept type arrays, so only the Gemini family is rewritten, and only that one
+ * keyword: the full Google subset sanitizer would strip keywords this backend
+ * accepts.
+ */
+
+export function isDevinGeminiModelUid(modelUid: string): boolean {
+  return /^gemini-/i.test(modelUid) || /^MODEL_GOOGLE_GEMINI_/i.test(modelUid);
+}
+
+/** Keys whose values are instance data, not subschemas. */
+const DATA_KEYS = new Set(['enum', 'const', 'default', 'examples', 'example']);
+/** Keys whose values map arbitrary names (which may be "enum" or "default") to subschemas. */
+const SCHEMA_MAP_KEYS = new Set(['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas', 'dependencies']);
+/** Keys that describe the whole node and stay on it rather than moving into each branch. */
+const ANNOTATION_KEYS = new Set(['description', 'title', 'default', 'examples', 'example', '$comment', 'deprecated']);
+
+function rewriteMap(map: unknown): unknown {
+  if (!map || typeof map !== 'object' || Array.isArray(map)) return map;
+  // A draft-7 `dependencies` entry may be a list of property names, which is data.
+  return Object.fromEntries(Object.entries(map).map(([name, schema]) => [name, Array.isArray(schema) ? schema : rewrite(schema)]));
+}
+
+type Schema = Record<string, unknown>;
+const isSchema = (value: unknown): value is Schema => !!value && typeof value === 'object' && !Array.isArray(value);
+
+/**
+ * `{type: [T, "null"], ...rest}` becomes `{anyOf: [{...rest, type: T}, {type: "null"}]}`,
+ * so type-specific keywords (items, properties, ...) stay attached to their type.
+ * An existing anyOf is folded in branch by branch when no branch contradicts an
+ * outer keyword, and kept beside the split under allOf when one does.
+ */
+function splitTypeArray(node: Schema, types: unknown[]): Schema {
+  const annotations: Schema = {};
+  const rest: Schema = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === 'type' || key === 'anyOf') continue;
+    Object.defineProperty(ANNOTATION_KEYS.has(key) ? annotations : rest, key, { value, enumerable: true, writable: true, configurable: true });
+  }
+  const concrete = types.filter((type) => type !== 'null');
+  // An outer enum/const is still binding after the type array is split.
+  const allowsNull = concrete.length < types.length
+    && (!Array.isArray(rest.enum) || rest.enum.includes(null))
+    && (!Object.hasOwn(rest, 'const') || rest.const === null);
+  const existing = Array.isArray(node.anyOf) ? node.anyOf : undefined;
+  // Boolean constraints apply to every type, including null. A bare null branch
+  // would bypass them, so keep the type split and the outer schema conjunctive.
+  if (allowsNull && ['not', 'allOf', 'oneOf', 'if', 'then', 'else'].some((key) => key in rest)) {
+    return {
+      ...annotations,
+      allOf: [splitTypeArray({ type: types }, types), existing ? { ...rest, anyOf: existing } : rest],
+    };
+  }
+  // Folding merges each branch into the outer keywords, which is only exact when
+  // they never disagree: `{maxLength: 5, anyOf: [{maxLength: 50}]}` folded would
+  // loosen the outer limit. On a disagreement keep both constraints under allOf,
+  // which this backend accepts (live: gemini-3-8-flash-medium).
+  if (existing?.some((branch) => isSchema(branch) && (
+    Object.keys(branch).some((key) => key !== 'type' && key in rest && JSON.stringify(branch[key]) !== JSON.stringify(rest[key]))
+    // Keep an existing null branch's own constraints; folding it to {type:"null"}
+    // would admit values that its enum, const, or nested schema rejects.
+    || (allowsNull && branch.type === 'null' && Object.keys(branch).some((key) => key !== 'type'))
+    || (allowsNull && branch.type === undefined && ['enum', 'const', 'not', 'allOf', 'oneOf'].some((key) => key in branch))
+  ))) {
+    return { ...annotations, allOf: [splitTypeArray({ ...rest, type: types }, types), { anyOf: existing }] };
+  }
+  const branches: unknown[] = [];
+  let nullReachable = allowsNull && !existing;
+  if (!existing) {
+    for (const type of concrete) branches.push({ ...rest, type });
+  } else {
+    for (const branch of existing) {
+      if (!isSchema(branch)) continue;
+      if (branch.type === undefined) {
+        for (const type of concrete) branches.push({ ...rest, ...branch, type });
+        if (allowsNull) nullReachable = true;
+      } else if (branch.type === 'null') {
+        if (allowsNull) nullReachable = true;
+      } else if (concrete.includes(branch.type)) {
+        branches.push({ ...rest, ...branch });
+      }
+    }
+  }
+  if (nullReachable) branches.push({ type: 'null' });
+  // The two unions are disjoint. Keep both constraints rather than drop the type union,
+  // which would let the anyOf branches admit types the node never allowed.
+  if (branches.length === 0) return { ...annotations, allOf: [splitTypeArray({ ...rest, type: types }, types), { anyOf: existing }] };
+  if (branches.length === 1 && isSchema(branches[0])) return { ...annotations, ...branches[0] };
+  return { ...annotations, anyOf: branches };
+}
+
+function rewrite(node: unknown): unknown {
+  if (Array.isArray(node)) return node.map(rewrite);
+  if (!isSchema(node)) return node;
+  // fromEntries defines own properties, so a "__proto__" key stays data.
+  const out: Schema = Object.fromEntries(
+    Object.entries(node).map(([key, value]) => [
+      key,
+      DATA_KEYS.has(key) ? value : SCHEMA_MAP_KEYS.has(key) ? rewriteMap(value) : rewrite(value),
+    ]),
+  );
+  if (!Array.isArray(out.type)) return out;
+  const types = out.type as unknown[];
+  if (types.length === 0) {
+    delete out.type;
+    return out;
+  }
+  return splitTypeArray(out, types);
+}
+
+/** Rewrite type arrays for Gemini uids; every other model gets the schema unchanged. */
+export function normalizeDevinToolParameters(modelUid: string, parameters: unknown): unknown {
+  return isDevinGeminiModelUid(modelUid) ? rewrite(parameters) : parameters;
+}

package/src/adapters/devin/context-overflow.ts

@@ -0,0 +1,75 @@
+/**
+ * Recognise an oversized Devin history behind Cognition's opaque refusal.
+ *
+ * Measured live on swe-1-6 (200k context): a 1.2 MB or 3 MB history is refused
+ * after ~11s with `invalid_argument` and no output, the same code a bad tool
+ * schema gets. Passed through as a plain 400, Codex never learns its context is
+ * full and never compacts, so every later turn dead-ends the same way. Only a
+ * request large against the model's window is reclassified; a small request
+ * with the same code stays an ordinary 400.
+ *
+ * Boundary, binary-searched live on swe-1-6 (200k catalog window, 8192 output):
+ * accepted at 199,186 prompt tokens of prose and 200,345 of JSON, refused at
+ * ~203k of either. Raising the output cap to 32000 did not move it (195,571
+ * input tokens still accepted), so the window is not reduced by the output
+ * reservation and the threshold is the window itself.
+ */
+import type { AdapterEvent } from "../../types";
+import type { ChatHistoryItem, ToolDef } from "./cloud-direct";
+import { prepareToolDescriptionForCognition } from "./cloud-direct/chat";
+
+/**
+ * Share of the window the estimate must reach. Characters per real token ran
+ * from 1.33 (Korean) through 2.31 (JSON) and 4.23 (source code) to 5.53
+ * (prose), so no character ratio separates "over the window" from "60% of it".
+ * The word-piece count below read 1.00x to 1.54x of the real count on those
+ * samples: at 0.95 every sample at the window is caught and none at 60% is.
+ */
+const WINDOW_SHARE = 0.95;
+/** One token per short letter run, 1-3 digit group, or other visible character. */
+const WORD_PIECE = /[A-Z]?[a-z]{1,8}|[A-Z]{1,8}(?![a-z])|\d{1,3}|\S/g;
+/** Text size that counts as oversized when the model's window is unknown. */
+const UNKNOWN_WINDOW_CHARS = 512 * 1024;
+
+export const DEVIN_CONTEXT_OVERFLOW_MESSAGE =
+  "Devin rejected this turn and its history is at or past the model's context window. Compact the conversation or start a new session.";
+
+/** Text the model would tokenize; image bytes are excluded so a screenshot cannot look like a long history. */
+function requestText(messages: ChatHistoryItem[], tools: ToolDef[] | undefined): string {
+  const parts: string[] = [];
+  for (const m of messages) {
+    if (typeof m.content === "string") parts.push(m.content);
+    else for (const p of m.content) if (p.type === "text") parts.push(p.text);
+    for (const call of m.tool_calls ?? []) parts.push(call.arguments);
+    if (m.thinking) parts.push(m.thinking);
+  }
+  for (const tool of tools ?? []) parts.push(prepareToolDescriptionForCognition(tool.description ?? ""), JSON.stringify(tool.parameters ?? {}));
+  return parts.join("\n");
+}
+
+export function isDevinHistoryOverflow(input: {
+  code: string | undefined;
+  producedOutput: boolean;
+  contextWindow: number | undefined;
+  messages: ChatHistoryItem[];
+  tools: ToolDef[] | undefined;
+}): boolean {
+  if (input.code !== "invalid_argument" || input.producedOutput) return false;
+  const text = requestText(input.messages, input.tools);
+  if (!input.contextWindow) return text.length >= UNKNOWN_WINDOW_CHARS;
+  let pieces = 0;
+  for (const _ of text.matchAll(WORD_PIECE)) pieces++;
+  return pieces >= input.contextWindow * WINDOW_SHARE;
+}
+
+/** Same terminal shape the Kiro adapter uses, which Codex reads as "context full, compact". */
+export function devinContextOverflowEvent(): Extract<AdapterEvent, { type: "error" }> {
+  return {
+    type: "error",
+    message: DEVIN_CONTEXT_OVERFLOW_MESSAGE,
+    status: 400,
+    errorType: "invalid_request_error",
+    code: "context_length_exceeded",
+    retryable: false,
+  };
+}