@bitkyc08/opencodex 2.66.0-preview.20260925 → 2.67.0-preview.20260926

package/src/web-search/devin-executor.ts

@@ -0,0 +1,192 @@
+import { buildMetadata } from "../adapters/devin/cloud-direct/metadata";
+import { encodeMessage, encodeString, encodeVarintField, iterFields } from "../adapters/devin/cloud-direct/wire";
+import { cancelBodyOnAbort } from "../lib/abort";
+import { readBoundedResponseBytes } from "../lib/bounded-body";
+import { redactSecretString } from "../lib/redact";
+import { sidecarEnter } from "../lib/sidecar-tracker";
+import { getValidAccessTokenSnapshot, publicOAuthAuthenticationErrorMessage, type OAuthAccessSnapshot } from "../oauth";
+import { captureOAuthAccountSelection, commitOAuthAccountSelection } from "../oauth/store";
+import { resolveDevinApiBaseUrl } from "../oauth/devin/api-base";
+import type { SidecarOutcome } from "./executor";
+import { MAX_SIDECAR_RESPONSE_BYTES, type WebSearchSource } from "./parse";
+import { safeWebSearchSources } from "./sources";
+
+const DEVIN_WEB_SEARCH_PATH = "/exa.api_server_pb.ApiServerService/GetWebSearchResults";
+const DEVIN_WEB_SEARCH_RESULTS = 5;
+const DEVIN_WEB_SEARCH_SNIPPET_CHARS = 2_000;
+
+interface DevinSearchResult extends WebSearchSource {
+  snippet?: string;
+}
+
+function assertCompleteProtobuf(buf: Buffer): void {
+  let offset = 0;
+  while (offset < buf.length) {
+    const readVarint = (): bigint => {
+      let value = 0n;
+      for (let shift = 0n; shift < 70n; shift += 7n) {
+        if (offset >= buf.length) throw new Error("truncated varint");
+        const byte = buf[offset++]!;
+        value |= BigInt(byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) return value;
+      }
+      throw new Error("overlong varint");
+    };
+    const tag = readVarint();
+    const wire = Number(tag & 7n);
+    if (tag >> 3n === 0n) throw new Error("invalid field number");
+    if (wire === 0) readVarint();
+    else if (wire === 1) offset += 8;
+    else if (wire === 2) {
+      const length = Number(readVarint());
+      if (!Number.isSafeInteger(length)) throw new Error("invalid field length");
+      offset += length;
+    } else if (wire === 5) offset += 4;
+    else throw new Error("unsupported wire type");
+    if (offset > buf.length) throw new Error("truncated field");
+  }
+}
+
+function fields(buf: Buffer): ReturnType<typeof iterFields> {
+  assertCompleteProtobuf(buf);
+  return iterFields(buf);
+}
+
+function decodeText(value: Buffer): string | undefined {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function chunkText(chunk: Buffer): string | undefined {
+  for (const field of fields(chunk)) {
+    if (field.num === 1 && field.wire === 2 && Buffer.isBuffer(field.value)) return decodeText(field.value);
+    if (field.num === 3 && field.wire === 2 && Buffer.isBuffer(field.value)) {
+      for (const markdownField of fields(field.value)) {
+        if (markdownField.num === 2 && markdownField.wire === 2 && Buffer.isBuffer(markdownField.value)) {
+          return decodeText(markdownField.value);
+        }
+      }
+    }
+  }
+  return undefined;
+}
+
+function parseResult(buf: Buffer): DevinSearchResult | undefined {
+  let url: string | undefined;
+  let title: string | undefined;
+  let text: string | undefined;
+  let summary: string | undefined;
+  const chunks: string[] = [];
+  for (const field of fields(buf)) {
+    if (field.wire !== 2 || !Buffer.isBuffer(field.value)) continue;
+    if (field.num === 2) text = decodeText(field.value);
+    else if (field.num === 3) url = decodeText(field.value);
+    else if (field.num === 4) title = decodeText(field.value);
+    else if (field.num === 6) {
+      const chunk = chunkText(field.value);
+      if (chunk) chunks.push(chunk);
+    } else if (field.num === 7) summary = decodeText(field.value);
+  }
+  if (!url) return undefined;
+  const snippet = (summary || text || chunks.join("\n")).trim().slice(0, DEVIN_WEB_SEARCH_SNIPPET_CHARS);
+  return { url, ...(title ? { title } : {}), ...(snippet ? { snippet } : {}) };
+}
+
+/** Map Cognition's GetWebSearchResults protobuf response to the shared search outcome. */
+export function mapDevinWebSearchResponse(buf: Buffer): SidecarOutcome {
+  const parsed: DevinSearchResult[] = [];
+  let summary = "";
+  for (const field of fields(buf)) {
+    if (field.wire !== 2 || !Buffer.isBuffer(field.value)) continue;
+    if (field.num === 1) {
+      const result = parseResult(field.value);
+      if (result) parsed.push(result);
+    } else if (field.num === 3) {
+      summary = decodeText(field.value)?.trim().slice(0, DEVIN_WEB_SEARCH_SNIPPET_CHARS) ?? "";
+    }
+  }
+  const sources = safeWebSearchSources(parsed);
+  if (sources.length === 0) return { text: "", sources: [], error: "devin web search returned no results" };
+  const byUrl = new Map(parsed.map(result => [result.url, result]));
+  const lines = sources.map(source => {
+    const result = byUrl.get(source.url);
+    return `- ${source.title ?? source.url}: ${result?.snippet || "(no excerpt)"} [${source.url}]`;
+  });
+  return { text: [summary, `Search results:\n${lines.join("\n")}`].filter(Boolean).join("\n\n"), sources };
+}
+
+/** Resolve one account snapshot for an entire alpha/search request. */
+export async function resolveDevinWebSearchSnapshot(
+  providerName: string,
+): Promise<{ snapshot: OAuthAccessSnapshot } | { error: string }> {
+  const credentialProvider = providerName === "devin-cli" ? "devin" : providerName;
+  try {
+    const selection = captureOAuthAccountSelection(credentialProvider);
+    if (!selection) return { error: "devin web search auth failed: no signed-in account" };
+    const snapshot = await getValidAccessTokenSnapshot(credentialProvider);
+    const committed = await commitOAuthAccountSelection(credentialProvider, snapshot.accountId, {
+      expectedSelection: selection,
+      expectedCredentialGeneration: snapshot.generation,
+      requireUsableAccount: true,
+    });
+    return committed ? { snapshot } : { error: "devin web search auth changed; retry the request" };
+  } catch (error) {
+    return { error: `devin web search auth failed: ${publicOAuthAuthenticationErrorMessage(error)}` };
+  }
+}
+
+/** Execute one search through the signed-in Devin/Cognition account. */
+export async function runDevinWebSearch(
+  query: string,
+  snapshot: OAuthAccessSnapshot,
+  abortSignal: AbortSignal,
+): Promise<SidecarOutcome> {
+  const apiServerUrl = resolveDevinApiBaseUrl(snapshot.apiBaseUrl);
+  const metadata = buildMetadata({
+    apiKey: snapshot.accessToken,
+    sessionId: crypto.randomUUID(),
+    requestId: BigInt(Date.now()),
+    triggerId: crypto.randomUUID(),
+  });
+  const body = Buffer.concat([
+    encodeMessage(1, metadata),
+    encodeString(2, query),
+    encodeVarintField(3, DEVIN_WEB_SEARCH_RESULTS),
+  ]);
+  const sidecarExit = sidecarEnter("web-search");
+  try {
+    const response = await fetch(`${apiServerUrl}${DEVIN_WEB_SEARCH_PATH}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/proto", "Connect-Protocol-Version": "1" },
+      body: new Uint8Array(body),
+      signal: abortSignal,
+      redirect: "error",
+    });
+    const detachBodyGuard = cancelBodyOnAbort(response.body, abortSignal);
+    try {
+      const bounded = await readBoundedResponseBytes(response, {
+        maxBytes: MAX_SIDECAR_RESPONSE_BYTES,
+        signal: abortSignal,
+      });
+      if (bounded.oversized) return { text: "", sources: [], error: "devin web search response exceeded byte bound" };
+      if (!response.ok) return { text: "", sources: [], error: `devin web search HTTP ${response.status}` };
+      try {
+        return mapDevinWebSearchResponse(Buffer.from(bounded.bytes));
+      } catch {
+        return { text: "", sources: [], error: "devin web search returned malformed protobuf" };
+      }
+    } finally {
+      detachBodyGuard();
+    }
+  } catch (error) {
+    const kind = abortSignal.reason instanceof Error && abortSignal.reason.name === "TimeoutError"
+      ? "timeout"
+      : "connect_error";
+    return { text: "", sources: [], error: `devin web search ${kind}: ${redactSecretString(error instanceof Error ? error.message : String(error))}` };
+  } finally {
+    sidecarExit();
+  }
+}

package/src/web-search/loop.ts

@@ -337,12 +337,19 @@ export interface WebSearchLoopDeps {
    * `retryParsed` is the exact iteration-local request the retry will be built from. The loop
    * sends a shallow copy of the outer parsed request, so a rotation that rebinds only the outer
    * object never reaches the wire. Optional so existing callers keep compiling.
+   *
+   * A rotation may cross ACCOUNTS, not just keys, and the attempt row is where an operator reads
+   * which one happened. A rotator that knows which kind it performed returns it alongside the
+   * adapter -- the same `{ adapter, recoveryKind }` shape `onCredentialError` already uses below.
    */
   on429?: (
     retryAfterHeader: string | null,
     responseHeaders?: Headers,
     retryParsed?: OcxParsedRequest,
-  ) => ProviderAdapter | null | Promise<ProviderAdapter | null>;
+  ) =>
+    | { adapter: ProviderAdapter; recoveryKind: AttemptRecoveryKind }
+    | null
+    | Promise<{ adapter: ProviderAdapter; recoveryKind: AttemptRecoveryKind } | null>;
   /** Opt-in same-target 429 policy (key-auth providers). When present, 429 replays on the SAME key before on429 rotation. */
   retryOn429Policy?: Required<RateLimitRetryPolicy> | null;
   /** Called only when the final bridged Responses stream reaches completed or incomplete. */
@@ -568,10 +575,10 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
         // Never let a broken body's cancel promise outlive the cumulative header deadline. Observe
         // it, but proceed immediately to the rotated fetch under the SAME deadline signal.
         try { void prepared.response.body?.cancel().catch(() => {}); } catch { /* already closed */ }
-        adapter = rotated;
+        adapter = rotated.adapter;
         // Stall-watchdog seam between bounded retry fetches (audit 011 B3).
         yield { type: "heartbeat" };
-        prepared = await fetchOnce(adapter, "key-429");
+        prepared = await fetchOnce(adapter, rotated.recoveryKind);
       }
 
       // Final headers have arrived. Clear only the deadline timer before ANY body read.