@bitkyc08/opencodex 2.52.0-preview.20260911 → 2.52.0

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

@@ -0,0 +1,65 @@
+/*
+ * Derived from rsvedant/opencode-windsurf-auth (src/cloud-direct/), MIT licensed.
+ *
+ * MIT License
+ * Copyright (c) 2026 Vedant
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Public surface of the cloud-direct module.
+ *
+ * Usage:
+ *   import { streamChat } from './cloud-direct/index.js';
+ *
+ *   for await (const delta of streamChat({
+ *     apiKey: creds.apiKey,
+ *     apiServerUrl: creds.apiServerUrl,
+ *     modelUid: 'swe-1-6',
+ *     messages: [{ role: 'user', content: 'hi' }],
+ *   })) {
+ *     process.stdout.write(delta);
+ *   }
+ */
+
+export {
+  streamChat,
+  streamChatEvents,
+  allocateCascadeId,
+  CloudChatError,
+  type CloudChatRequest,
+  type ChatHistoryItem,
+  type CloudChatEvent,
+  type ToolDef,
+} from './chat.js';
+
+export {
+  mintUserJwt,
+  getCachedUserJwt,
+  clearCachedUserJwt,
+  CloudAuthError,
+} from './auth.js';
+
+export {
+  getCachedCatalog,
+  clearCachedCatalog,
+  ModelNotAvailableError,
+  type ModelCatalogEntry,
+  type CacheEntry,
+} from './catalog.js';

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

@@ -0,0 +1,134 @@
+/*
+ * Derived from rsvedant/opencode-windsurf-auth (src/cloud-direct/), MIT licensed,
+ * Copyright (c) 2026 Vedant. The full notice is in ./index.ts.
+ */
+/**
+ * `exa.codeium_common_pb.Metadata` proto builder.
+ *
+ * Field numbers come from src/plugin/discovery.ts (which reads the bundled
+ * extension.js for live numbers). For cloud-direct we hard-code the canonical
+ * set of fields the LS always populates — the IDE-extracted dynamic numbers
+ * would help if Windsurf renumbers, but we don't have a way to refresh those
+ * without the bundled extension.js path being present.
+ *
+ * Captured from real LS upstream traffic via mitm reverse-proxy. See
+ * docs/CLOUD_DIRECT.md → "The exact captured request body (annotated)".
+ */
+
+import {
+  encodeMessage,
+  encodeString,
+  encodeTimestampBody,
+  encodeVarintField,
+} from './wire.js';
+import { randomBytes } from 'node:crypto';
+
+/**
+ * extension_version + ide_version sent to the cloud. It MUST be a string the
+ * cloud recognizes as a real client release: an unknown version comes back as
+ * an opaque "an internal error occurred", with no hint that the version is what
+ * it objected to.
+ *
+ * Pinned to the version the shipped desktop client reports
+ * (`product.json` -> `windsurfVersion`) rather than to anything of ours. The
+ * previous pin of "2.0.0" predates the Devin rebrand and no longer chats.
+ * `OPENCODEX_DEVIN_CLIENT_VERSION` overrides it, which is the escape hatch when
+ * Cognition retires a version before this constant is updated.
+ */
+const WINDSURF_VERSION_STRING = process.env.OPENCODEX_DEVIN_CLIENT_VERSION?.trim() || '3.9.19';
+
+/**
+ * Identity the hosted chat RPC expects, which is not the desktop client's.
+ * GetChatMessage is calibrated against a different client name and version, and
+ * sending the IDE's own strings is one of the ways the request comes back as an
+ * opaque "an internal error occurred".
+ */
+const CLOUD_CHAT_CLIENT_NAME = 'chisel';
+const CLOUD_CHAT_CLIENT_VERSION = process.env.OPENCODEX_DEVIN_CHAT_CLIENT_VERSION?.trim() || '2026.8.18';
+const CLOUD_CHAT_OS = 'windows';
+
+/**
+ * Metadata #31 is a device fingerprint, and the server checks its shape rather
+ * than its value: 732 hex characters (366 bytes). Anything shorter — including
+ * absent — is rejected with the same opaque internal error, and a fresh random
+ * value per request is accepted, so nothing here identifies the machine.
+ */
+const DEVICE_FINGERPRINT_BYTES = 366;
+
+export interface MetadataInput {
+  /** Persistent api_key from OAuth (`devin-session-token$<JWT>`). */
+  apiKey: string;
+  /**
+   * Fresh user_jwt from GetUserJwt. The catalog RPC uses it; the hosted chat
+   * path does not need it and only sends it when an operator opts in.
+   */
+  userJwt?: string;
+  /** UUID — one per opencode session is fine. */
+  sessionId: string;
+  /** Monotonic, milliseconds since epoch. */
+  requestId: bigint;
+  /** UUID — one per RPC call. */
+  triggerId: string;
+  /** Optional override for the version string. Cosmetic. */
+  windsurfVersion?: string;
+  /** Optional override for the host OS string. */
+  osName?: string;
+  /**
+   * Emit the exact field set the hosted chat RPC accepts.
+   *
+   * GetChatMessage validates this message far more strictly than
+   * GetCascadeModelConfigs does, which is why the catalog has always worked
+   * while chat did not. The shape is seven identity fields, the optional
+   * user_jwt, and the fingerprint — the telemetry fields this module otherwise
+   * sends (request_id, session_id, ls_timestamp, trigger_id, plan_name,
+   * ide_type) are not part of it.
+   */
+  cloudChatShape?: boolean;
+  /** Override for Metadata #31; a random fingerprint is generated when absent. */
+  deviceHex?: string;
+}
+
+function osString(): string {
+  switch (process.platform) {
+    case 'darwin': return 'darwin';
+    case 'linux': return 'linux';
+    case 'win32': return 'windows';
+    default: return String(process.platform);
+  }
+}
+
+export function buildMetadata(input: MetadataInput): Buffer {
+  const version = input.windsurfVersion ?? WINDSURF_VERSION_STRING;
+  const os = input.osName ?? osString();
+  if (input.cloudChatShape) {
+    const clientVersion = input.windsurfVersion ?? CLOUD_CHAT_CLIENT_VERSION;
+    return Buffer.concat([
+      encodeString(1, CLOUD_CHAT_CLIENT_NAME),
+      encodeString(2, clientVersion),
+      encodeString(3, input.apiKey),
+      encodeString(4, 'en'),
+      encodeString(5, input.osName ?? CLOUD_CHAT_OS),
+      encodeString(7, clientVersion),
+      encodeString(12, CLOUD_CHAT_CLIENT_NAME),
+      ...(input.userJwt ? [encodeString(21, input.userJwt)] : []),
+      encodeString(31, input.deviceHex ?? randomBytes(DEVICE_FINGERPRINT_BYTES).toString('hex')),
+    ]);
+  }
+  const parts: Buffer[] = [
+    encodeString(1, 'windsurf'),                     // ide_name
+    encodeString(2, version),                         // extension_version
+    encodeString(3, input.apiKey),                    // api_key
+    encodeString(4, 'en'),                            // locale
+    encodeString(5, os),                              // os
+    encodeString(7, version),                         // ide_version
+    encodeVarintField(9, input.requestId),            // request_id (uint64 monotonic)
+    encodeString(10, input.sessionId),                // session_id
+    encodeString(12, 'windsurf'),                     // extension_name
+    encodeMessage(16, encodeTimestampBody()),         // ls_timestamp (google.protobuf.Timestamp)
+    encodeString(25, input.triggerId),                // trigger_id
+    encodeString(26, 'Unset'),                        // plan_name
+    encodeString(28, 'windsurf'),                     // ide_type
+  ];
+  if (input.userJwt) parts.push(encodeString(21, input.userJwt));   // user_jwt
+  return Buffer.concat(parts);
+}

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

@@ -0,0 +1,206 @@
+/*
+ * Derived from rsvedant/opencode-windsurf-auth (src/cloud-direct/), MIT licensed,
+ * Copyright (c) 2026 Vedant. The full notice is in ./index.ts.
+ */
+/**
+ * Manual protobuf + Connect-RPC streaming envelope helpers.
+ *
+ * Connect-RPC streaming wire format (HTTPS POST body):
+ *   ┌─────────────┬────────────────┬──────────────┐
+ *   │ flags 1byte │ length 4B BE   │   payload    │
+ *   └─────────────┴────────────────┴──────────────┘
+ *   flags bit 0x01 = payload is gzip-compressed
+ *   flags bit 0x02 = end-of-stream (trailer frame — JSON {error} or empty {})
+ *
+ * All `Get*` methods on `exa.api_server_pb.ApiServerService` that the
+ * language_server calls upstream use this format, content-type
+ * `application/connect+proto`, with `Connect-Protocol-Version: 1`.
+ *
+ * Kept tiny and dependency-free — same philosophy as src/plugin/protobuf.ts.
+ */
+
+import * as zlib from 'zlib';
+
+// ----------------------------------------------------------------------------
+// Proto wire encode
+// ----------------------------------------------------------------------------
+
+export function encodeVarint(value: number | bigint): Buffer {
+  const v0 = BigInt(value);
+  // Reject negatives at the boundary. Proto3 spec encodes signed types as
+  // 10-byte sign-extended varints; we don't support that here and the
+  // current call sites never need it (tags, lengths, request ids — all
+  // strictly positive). The old loop body would have terminated with
+  // `Number(-1n)` = -1, producing a malformed single 0xFF byte that the
+  // server would misparse silently. Throw instead so future regressions
+  // surface immediately.
+  if (v0 < 0n) {
+    throw new RangeError(`encodeVarint: negative input not supported (got ${value})`);
+  }
+  const bytes: number[] = [];
+  let v = v0;
+  while (v > 127n) {
+    bytes.push(Number(v & 0x7fn) | 0x80);
+    v >>= 7n;
+  }
+  bytes.push(Number(v));
+  return Buffer.from(bytes);
+}
+
+export function encodeTag(fieldNum: number, wire: number): Buffer {
+  return encodeVarint((fieldNum << 3) | wire);
+}
+
+export function encodeString(fieldNum: number, s: string): Buffer {
+  const buf = Buffer.from(s, 'utf8');
+  return Buffer.concat([encodeTag(fieldNum, 2), encodeVarint(buf.length), buf]);
+}
+
+export function encodeMessage(fieldNum: number, body: Buffer): Buffer {
+  return Buffer.concat([encodeTag(fieldNum, 2), encodeVarint(body.length), body]);
+}
+
+export function encodeVarintField(fieldNum: number, v: number | bigint): Buffer {
+  return Buffer.concat([encodeTag(fieldNum, 0), encodeVarint(v)]);
+}
+
+export function encodeFixed64Field(fieldNum: number, v: number): Buffer {
+  const b = Buffer.alloc(8);
+  b.writeDoubleLE(v, 0);
+  return Buffer.concat([encodeTag(fieldNum, 1), b]);
+}
+
+export function encodeTimestampBody(): Buffer {
+  const now = Date.now();
+  const seconds = Math.floor(now / 1000);
+  const nanos = (now % 1000) * 1_000_000;
+  return Buffer.concat([
+    encodeVarintField(1, seconds),
+    nanos > 0 ? encodeVarintField(2, nanos) : Buffer.alloc(0),
+  ]);
+}
+
+// ----------------------------------------------------------------------------
+// Proto wire decode
+// ----------------------------------------------------------------------------
+
+export function decodeVarint(buf: Buffer, offset: number): [bigint, number] {
+  let res = 0n;
+  let shift = 0n;
+  let i = offset;
+  while (i < buf.length) {
+    const b = buf[i++];
+    res |= BigInt(b & 0x7f) << shift;
+    if (!(b & 0x80)) return [res, i];
+    shift += 7n;
+  }
+  throw new Error('truncated varint');
+}
+
+export interface ProtoField {
+  num: number;
+  wire: number;
+  /** varint → bigint, fixed → 8/4 byte Buffer, length-delim → payload Buffer. */
+  value: bigint | Buffer;
+}
+
+export function* iterFields(buf: Buffer): Generator<ProtoField> {
+  let i = 0;
+  while (i < buf.length) {
+    const [tagBig, ai] = decodeVarint(buf, i);
+    i = ai;
+    const tag = Number(tagBig);
+    const num = tag >> 3;
+    const wire = tag & 0x7;
+    if (wire === 0) {
+      const [v, bi] = decodeVarint(buf, i);
+      i = bi;
+      yield { num, wire, value: v };
+    } else if (wire === 1) {
+      // Bounds-check: a truncated frame mustn't yield a short fixed64 slice
+      // that downstream readers treat as a full 8-byte value. Stop iterating
+      // cleanly instead.
+      if (i + 8 > buf.length) return;
+      yield { num, wire, value: buf.slice(i, i + 8) };
+      i += 8;
+    } else if (wire === 2) {
+      const [n, ci] = decodeVarint(buf, i);
+      i = ci;
+      const len = Number(n);
+      // Bounds-check: when the declared length runs past the buffer, the
+      // frame is corrupt or truncated. Returning short-buffered slices to
+      // downstream parsers used to misparse silently (M12).
+      if (len < 0 || i + len > buf.length) return;
+      yield { num, wire, value: buf.slice(i, i + len) };
+      i += len;
+    } else if (wire === 5) {
+      if (i + 4 > buf.length) return;
+      yield { num, wire, value: buf.slice(i, i + 4) };
+      i += 4;
+    } else if (wire === 3 || wire === 4) {
+      // Wire types 3 (start group) and 4 (end group) are deprecated in
+      // proto3 but show up in some Codeium server-generated messages. They
+      // carry no length info; the safe behavior is to stop iterating
+      // gracefully rather than tear down the whole frame parse.
+      return;
+    } else {
+      // Unknown wire type — bail rather than misalign.
+      return;
+    }
+  }
+}
+
+// ----------------------------------------------------------------------------
+// Connect-streaming envelope
+// ----------------------------------------------------------------------------
+
+/**
+ * Wrap `body` (a serialized proto message) in a Connect-streaming envelope.
+ * If `compress` is true, gzip the payload and set the 0x01 flag.
+ */
+export function frameConnectStream(body: Buffer, compress = true): Buffer {
+  let payload = body;
+  let flags = 0;
+  if (compress) {
+    payload = zlib.gzipSync(body);
+    flags |= 0x01;
+  }
+  const header = Buffer.alloc(5);
+  header[0] = flags;
+  header.writeUInt32BE(payload.length, 1);
+  return Buffer.concat([header, payload]);
+}
+
+export interface ConnectFrame {
+  flags: number;
+  /** Decompressed payload (gzip handled here if flags & 0x01). */
+  payload: Buffer;
+  /** Frame is the trailer (end-of-stream). */
+  eos: boolean;
+}
+
+/**
+ * Parse all Connect-streaming frames out of a response body.
+ *
+ * Returns array of decoded frames. Each frame's payload is already gzip-decoded
+ * if the compression flag was set.
+ */
+export function parseConnectFrames(buf: Buffer): ConnectFrame[] {
+  const out: ConnectFrame[] = [];
+  let i = 0;
+  while (i + 5 <= buf.length) {
+    const flags = buf[i];
+    const len = buf.readUInt32BE(i + 1);
+    if (i + 5 + len > buf.length) break;
+    let payload = buf.slice(i + 5, i + 5 + len);
+    if (flags & 0x01) {
+      // Compressed frame. If gunzip fails the frame is genuinely corrupt
+      // — surfacing as a thrown error beats parsing raw gzip bytes as proto
+      // (which previously produced misleading "yielded bad wire type" downstream).
+      payload = zlib.gunzipSync(payload);
+    }
+    out.push({ flags, payload, eos: (flags & 0x02) !== 0 });
+    i += 5 + len;
+  }
+  return out;
+}

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

@@ -0,0 +1,133 @@
+/**
+ * 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
+ * fallback for when there is no API key or discovery fails.
+ */
+import { getCachedCatalog, type ModelCatalogEntry } from "./cloud-direct";
+
+const DEFAULT_HOST = "https://server.codeium.com";
+
+/**
+ * Degraded-mode fallback shown when there is no API key or live discovery
+ * fails. The live catalog overrides this whenever discovery succeeds.
+ */
+export const DEVIN_STATIC_MODELS = [
+  "swe-1-7",
+  "swe-1-7-lightning",
+  "gpt-5-6-sol",
+  "gpt-5-6-luna",
+  "gpt-5-6-terra",
+  "claude-opus-4-8",
+  "claude-fable-5-1",
+  "claude-sonnet-5",
+  "glm-5-2",
+  "kimi-k2-7",
+  "grok-4-5",
+] as const;
+
+/**
+ * Degraded-mode context windows, used only when live discovery cannot run.
+ *
+ * Every number here was read from a live `GetCascadeModelConfigs` response
+ * (`ClientModelConfig` field #18) rather than from documentation, because
+ * Cognition publishes none: the Devin CLI and Desktop model pages, the SWE-2
+ * and SWE-1.7 announcements, and the Windsurf model reference all state model
+ * names without a context window. The only published numbers are long-context
+ * pricing thresholds, which are a different quantity and were not used.
+ *
+ * The previous copy of this table was wrong for nine of its eleven rows — the
+ * three Claude models were listed at 200k against an actual 1M, `grok-4-5` at
+ * 256k against 500k, and the GPT rows at 1.05M against 1M — because it was
+ * assembled from each model's upstream vendor window instead of what Cognition
+ * actually serves. Measure the catalog when updating this; do not carry a
+ * number over from the model's original vendor.
+ */
+export const DEVIN_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
+  "swe-2": 262_000,
+  "swe-1-7": 262_000,
+  "swe-1-7-lightning": 202_752,
+  "swe-1-6": 200_000,
+  "gpt-5-6-sol": 1_000_000,
+  "gpt-5-6-luna": 1_000_000,
+  "gpt-5-6-terra": 1_000_000,
+  "gpt-6-astra": 1_000_000,
+  "claude-opus-4-8": 1_000_000,
+  "claude-opus-5": 1_000_000,
+  "claude-fable-5-1": 1_000_000,
+  "claude-sonnet-5": 1_000_000,
+  "glm-5-2": 200_000,
+  "glm-5-3": 1_048_576,
+  "kimi-k2-7": 262_144,
+  "kimi-k3": 1_048_576,
+  "gemini-3-8-flash": 1_048_576,
+  "grok-4-5": 500_000,
+  "grok-4-6": 500_000,
+};
+
+/**
+ * Trailing tokens that the Cognition catalog appends as effort/variant
+ * suffixes. Stripped to collapse suffixed UIDs to their base id.
+ */
+const EFFORT_TOKENS = new Set([
+  "low", "medium", "high", "xhigh", "max", "none", "fast", "priority", "1m",
+]);
+
+/** Collapse an effort-suffixed UID to its base id (e.g. `gpt-5-6-sol-high` → `gpt-5-6-sol`). */
+export function collapseDevinModelUid(uid: string): string {
+  const parts = uid.split("-");
+  while (parts.length > 1 && EFFORT_TOKENS.has(parts[parts.length - 1]!)) {
+    parts.pop();
+  }
+  return parts.join("-");
+}
+
+export type DevinUsableModelsResult =
+  | { ok: true; models: string[]; contextWindows: Record<string, number> }
+  | { 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.
+ */
+export async function fetchDevinUsableModels(opts: {
+  apiKey: string;
+  baseUrl?: string;
+  signal?: AbortSignal;
+}): Promise<DevinUsableModelsResult> {
+  try {
+    const host = (opts.baseUrl || DEFAULT_HOST).replace(/\/$/, "");
+    const catalog = await getCachedCatalog(opts.apiKey, host, opts.signal);
+    if (!catalog) return { ok: false, error: "empty" };
+    const bases = new Set<string>();
+    const contextWindows: Record<string, number> = {};
+    for (const entry of catalog.byUid.values()) {
+      if (entry.disabled) continue;
+      // 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);
+      bases.add(base);
+      if (entry.contextWindow && entry.contextWindow > 0) {
+        // Variants of one base can disagree: the opt-in `-1m` rows report a
+        // larger window than the plain row of the same base, and both collapse
+        // here because `1m` is an effort token. Keep the smallest, because the
+        // base id routes to the plain variant — advertising the long-context
+        // number would promise a window the request the picker actually sends
+        // cannot use.
+        const seen = contextWindows[base];
+        contextWindows[base] = seen === undefined ? entry.contextWindow : Math.min(seen, entry.contextWindow);
+      }
+    }
+    if (bases.size === 0) return { ok: false, error: "empty" };
+    return { ok: true, models: [...bases].sort(), contextWindows };
+  } 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 };
+    return { ok: false, error: "unknown", detail: message };
+  }
+}