cartethyia 2.4.6 → 2.5.0

package/src/providers/integrations/trae/trae-catalog.ts

@@ -0,0 +1,190 @@
+// Trae model rosters.
+//
+// Each realm has its own roster because upstream really does serve different
+// models per deployment — CN is domestic (Doubao/DeepSeek/GLM/Kimi/Qwen),
+// intl is frontier (Gemini/Claude/GPT/Grok). Merging them would offer a CN
+// account models its realm refuses, which is a runtime failure rather than a
+// cosmetic one.
+//
+// The static rosters are the fallback, not the truth: `discoverTraeModels`
+// replaces them with the live `/api/ide/v1/model_list` answer when that
+// endpoint works. It works on CN only — intl answers `403 no schema found`, so
+// intl stays on its static roster and says so via `modelListSupported`.
+
+import { defineModel, type ModelDefinition } from "../../provider-model-definition";
+import { TRAE_AGENT_CHAT_PATH, TRAE_CHAT_PATH, type TraeRealm } from "./trae-realm";
+
+/** One roster row, as upstream describes it. */
+export interface TraeModelRow {
+  /** Upstream key, sent as `model_name`. */
+  readonly id: string;
+  readonly displayName: string;
+  /** Context window, preferring the selectable maximum. */
+  readonly ctx: number;
+  readonly out: number;
+  readonly vision: boolean;
+  readonly reasoning: boolean;
+  /**
+   * Surface this row belongs to.
+   *
+   * Defaults to `"chat"`. The picker's models must be `"agent"`: they are
+   * absent from `model_list` and answer `4023 model is unknown` on the chat
+   * path no matter which host is tried.
+   */
+  readonly surface?: TraeSurface;
+}
+
+/** Which upstream endpoint serves a row. */
+export type TraeSurface = "chat" | "agent";
+
+/** CN roster: 20 chat-face models from the donor's client-state snapshot. */
+const TRAE_CN_ROWS: readonly TraeModelRow[] = [
+  { id: "Doubao-Seed-Code", displayName: "Seed-Code", ctx: 256000, out: 224000, vision: true, reasoning: true },
+  { id: "DeepSeek-V4-Flash-Official", displayName: "DeepSeek-V4-Flash", ctx: 1000000, out: 936000, vision: false, reasoning: true },
+  { id: "DeepSeek-V4-Pro-Official", displayName: "DeepSeek-V4-Pro", ctx: 1000000, out: 936000, vision: false, reasoning: true },
+  { id: "deepseek-v4.1-flash", displayName: "DeepSeek-V4.1-Flash", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+  { id: "glm-5.2", displayName: "GLM-5.2", ctx: 1000000, out: 936000, vision: false, reasoning: true },
+  { id: "glm-5.3", displayName: "GLM-5.3", ctx: 1000000, out: 936000, vision: false, reasoning: true },
+  { id: "glm-5.3-flash", displayName: "GLM-5.3-Flash", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+  { id: "glm-5.3-flashx", displayName: "GLM-5.3-FlashX", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+  { id: "kimi-k2.8-preview", displayName: "Kimi-K2.8-Preview", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+  { id: "kimi-k3", displayName: "Kimi-K3", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+  { id: "mimo-v2.6-flash", displayName: "MiMo-V2.6-Flash", ctx: 981504, out: 917504, vision: true, reasoning: false },
+  { id: "mimo-v2.6-pro", displayName: "MiMo-V2.6-Pro", ctx: 981504, out: 917504, vision: true, reasoning: false },
+  { id: "minimax-m3", displayName: "MiniMax-M3", ctx: 1000000, out: 936000, vision: true, reasoning: false },
+  { id: "qwen-3.7-plus", displayName: "Qwen3.7-Plus", ctx: 1000000, out: 936000, vision: true, reasoning: false },
+  { id: "qwen3.8-flash", displayName: "Qwen3.8-Flash", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+  { id: "qwen3.8-max", displayName: "Qwen3.8-Max", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+  { id: "Doubao-Seed-2.1-Pro", displayName: "Seed-2.1-Pro-0915", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+  { id: "Doubao-Seed-2.1-Turbo", displayName: "Seed-2.1-Turbo", ctx: 256000, out: 224000, vision: true, reasoning: true },
+  { id: "Doubao-Seed-Evolving", displayName: "Seed-Evolving", ctx: 1000000, out: 936000, vision: true, reasoning: false },
+  { id: "step-5-preview", displayName: "Step-5-Preview", ctx: 1000000, out: 936000, vision: true, reasoning: true },
+];
+
+/**
+ * Intl roster: the IDE picker's models, every row confirmed by a real
+ * completion on a live SG account.
+ *
+ * Agent-only, and that is a deliberate narrowing rather than an oversight.
+ * Trae serves two disjoint surfaces and the legacy chat roster (`gpt-4o`,
+ * `gemini_2.5_flash`, `deepseek-V3`, …) belongs to the other one: those ids
+ * are rejected here with `4001 param is invalid`, and the agent ids are
+ * rejected there with `4023 model is unknown`. There is no call that serves
+ * both, so a single-surface catalog is the only honest one; offering the chat
+ * ids would advertise models this provider's dispatch cannot reach. See
+ * `documentation/research/trae-agent-vs-chat-surface.md`.
+ *
+ * `ctx` is the **selectable maximum** (`context_window_tokens.max`), not the
+ * active `dev` window. Upstream advertises both and they differ by up to 5x
+ * (DeepSeek-V4 rows: 200k active, 1M selectable), so reading `dev` makes a
+ * client under-request the window it is entitled to. The maximum is per model
+ * and is **not** uniform: the GPT rows cap at 272k and Kimi-K2.5 / MiniMax-M2.7
+ * offer no selectable upgrade at all, staying at 200k.
+ *
+ * `out` is what the same model is filed at in the CodeBuddy roster where that
+ * roster carries it (DeepSeek-V4 384k, MiniMax-M3 512k, Kimi-K2.5 262k,
+ * Kimi-K3 131k, Gemini-3.1-Pro and Kimi-K2.7 65k, the GPT rows 128k), and 131k
+ * for models absent there. It is deliberately **not** Trae's
+ * `model_detail_list[0].max_tokens`: upstream states that as the cap it applies
+ * to its own output, which collapsed the whole roster onto 32k/64k and is far
+ * below what these models actually return elsewhere.
+ *
+ * `glm-5.2` is absent: it is in the harness's id map but not in any account
+ * config list, and answers `4001` identically to a bogus id.
+ *
+ * Rows report their real upstream in `timing_cost.provider_model_name`, which
+ * is usually not the id sent (DeepSeek-V4.1-Flash resolves to
+ * `ep-2026…-69njn`), so the id is always the config name, never the resolved
+ * one.
+ */
+const TRAE_INTL_ROWS: readonly TraeModelRow[] = [
+  { id: "gpt-5.4", displayName: "GPT-5.4", ctx: 272000, out: 128_000, vision: true, reasoning: true, surface: "agent" },
+  { id: "gpt-5.2", displayName: "GPT-5.2", ctx: 272000, out: 128_000, vision: true, reasoning: true, surface: "agent" },
+  { id: "gpt-5.2-codex-paygo", displayName: "GPT-5.2-Codex", ctx: 272000, out: 128_000, vision: true, reasoning: true, surface: "agent" },
+  { id: "gpt-5.1-paygo", displayName: "GPT-5.1", ctx: 272000, out: 128_000, vision: true, reasoning: true, surface: "agent" },
+  { id: "gpt-5-paygo", displayName: "GPT-5", ctx: 272000, out: 128_000, vision: true, reasoning: true, surface: "agent" },
+  { id: "Dola-Seed-2.0-Code", displayName: "Seed-2.1-Turbo", ctx: 1000000, out: 131_072, vision: true, reasoning: true, surface: "agent" },
+  { id: "deepseek-v4.1-flash", displayName: "DeepSeek-V4.1-Flash", ctx: 1000000, out: 384_000, vision: false, reasoning: true, surface: "agent" },
+  { id: "deepseek-v4-flash-0731", displayName: "DeepSeek-V4-Flash", ctx: 1000000, out: 384_000, vision: false, reasoning: true, surface: "agent" },
+  { id: "deepseek-v4-pro-0813", displayName: "DeepSeek-V4-Pro", ctx: 1000000, out: 384_000, vision: false, reasoning: true, surface: "agent" },
+  { id: "kimi-k3", displayName: "Kimi-K3", ctx: 1000000, out: 131_072, vision: true, reasoning: true, surface: "agent" },
+  { id: "kimi-k2.7-code", displayName: "Kimi-K2.7-Code", ctx: 1000000, out: 65_536, vision: true, reasoning: true, surface: "agent" },
+  { id: "kimi-k2.5", displayName: "Kimi-K2.5", ctx: 200000, out: 262_144, vision: false, reasoning: true, surface: "agent" },
+  { id: "gemini-3.1-pro", displayName: "Gemini-3.1-Pro-Preview", ctx: 1000000, out: 65_536, vision: true, reasoning: true, surface: "agent" },
+  { id: "gemini-3-flash-solo", displayName: "Gemini-3-Flash-Preview", ctx: 1000000, out: 65_536, vision: true, reasoning: true, surface: "agent" },
+  { id: "minimax-m3", displayName: "MiniMax-M3", ctx: 1000000, out: 512_000, vision: true, reasoning: true, surface: "agent" },
+  { id: "minimax-m2.7", displayName: "MiniMax-M2.7", ctx: 200000, out: 131_072, vision: false, reasoning: true, surface: "agent" },
+];
+
+function traeModels(rows: readonly TraeModelRow[], providerId: string): readonly ModelDefinition[] {
+  return rows.map((row) =>
+    defineModel({
+      id: row.id,
+      providerId,
+      wireFamily: "chat",
+      endpoint: row.surface === "agent" ? TRAE_AGENT_CHAT_PATH : TRAE_CHAT_PATH,
+      ctx: row.ctx,
+      out: row.out,
+      vision: row.vision,
+      reasoning: row.reasoning,
+    }),
+  );
+}
+
+export const TRAE_CN_MODELS: readonly ModelDefinition[] = traeModels(TRAE_CN_ROWS, "traecn");
+export const TRAE_INTL_MODELS: readonly ModelDefinition[] = traeModels(TRAE_INTL_ROWS, "trae");
+
+/** Roster for a realm. */
+export function traeStaticModels(realm: TraeRealm): readonly ModelDefinition[] {
+  return realm === "cn" ? TRAE_CN_MODELS : TRAE_INTL_MODELS;
+}
+
+/**
+ * Reads the largest context window out of one upstream model object.
+ *
+ * Upstream reports two independent numbers and they are not the same thing:
+ * `context_window_size.default` is the window that is active, while
+ * `context_window_size.max` is a *list* of selectable windows. Reading only
+ * the default is what made the fetcher always pick the smaller number — CN
+ * DeepSeek advertises 116k active but 1M selectable, so a client told 116k
+ * never asks for the window the account is entitled to.
+ *
+ * `context_window_tokens` is the older sibling spelling; `dev` pairs with
+ * `default` and `max` pairs with `max`.
+ */
+export function traeMaxContextWindow(raw: unknown): number | undefined {
+  if (typeof raw !== "object" || raw === null) return undefined;
+  const record = raw as Record<string, unknown>;
+  const candidates: number[] = [];
+  const collect = (value: unknown): void => {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+      candidates.push(value);
+      return;
+    }
+    if (Array.isArray(value)) value.forEach(collect);
+  };
+
+  const size = record["context_window_size"];
+  if (typeof size === "object" && size !== null) {
+    const sized = size as Record<string, unknown>;
+    collect(sized["max"]);
+  }
+  const tokens = record["context_window_tokens"];
+  if (typeof tokens === "object" && tokens !== null) {
+    collect((tokens as Record<string, unknown>)["max"]);
+  }
+  if (candidates.length > 0) return Math.max(...candidates);
+
+  // No selectable maximum: the active window is all we honestly know.
+  if (typeof size === "object" && size !== null) {
+    const fallback = (size as Record<string, unknown>)["default"];
+    if (typeof fallback === "number" && Number.isFinite(fallback) && fallback > 0) return fallback;
+  }
+  if (typeof tokens === "object" && tokens !== null) {
+    const fallback = (tokens as Record<string, unknown>)["dev"];
+    if (typeof fallback === "number" && Number.isFinite(fallback) && fallback > 0) return fallback;
+  }
+  const prompt = record["prompt_max_tokens"];
+  if (typeof prompt === "number" && Number.isFinite(prompt) && prompt > 0) return prompt;
+  return undefined;
+}

package/src/providers/integrations/trae/trae-headers.ts

@@ -0,0 +1,149 @@
+// Trae request headers: auth + device fingerprint.
+//
+// The two realms do not authenticate the same way. CN sends
+// `Authorization: Cloud-IDE-JWT <token>`; intl overrides it to `Bearer <token>`
+// and additionally sends the *current* client version, because intl
+// `llm_raw_chat` answers `4015` (risk control) when the version is stale. That
+// is why the version here is resolved rather than pinned.
+//
+// Sourced from the donor hub `Public/trae2api-hub` (`auth_headers` in
+// `trae_client.py`, `trae_device_headers` in `trae_fingerprint.py`).
+
+import { createHash, randomUUID } from "node:crypto";
+import {
+  TRAE_APP_ID,
+  TRAE_PLUGIN_CHANNEL,
+  TRAE_REALMS,
+  type TraeRealm,
+} from "./trae-realm";
+
+/** Device fingerprint derived from an account identity. */
+export interface TraeDeviceIdentity {
+  /** Stable per account: sha256 of a seeded string, 64 hex chars. */
+  readonly machineId: string;
+  /** Numeric, 19 digits: the upstream client reuses the account's numeric id. */
+  readonly deviceId: string;
+}
+
+/**
+ * Derives the device pair the upstream client sends.
+ *
+ * Both are pure one-way derivations from the account id, so one account always
+ * presents one device and two accounts never share one — the donor notes this
+ * is the risk-control correlation surface, so a per-process random id would
+ * look like many devices behind one account and a shared id would link them.
+ */
+export function traeDeviceIdentity(uid: string): TraeDeviceIdentity {
+  const seed = String(uid ?? "").trim() || "anonymous";
+  const machineId = createHash("sha256").update(`trae-machine:${seed}`).digest("hex");
+  const raw = String(uid ?? "").trim();
+  if (/^\d+$/.test(raw)) {
+    // The official client reuses the 19-digit userId verbatim.
+    return { machineId, deviceId: raw };
+  }
+  const digest = createHash("sha256").update(`trae-device:${raw || "anonymous"}`).digest("hex");
+  const numeric = BigInt(`0x${digest.slice(0, 16)}`);
+  return { machineId, deviceId: String(10n ** 18n + (numeric % (9n * 10n ** 18n))) };
+}
+
+/**
+ * OS string reported as `X-Os-Version`.
+ *
+ * The donor reads this from the host registry, which leaks the operator's real
+ * Windows build to upstream. This gateway is not the operator's desktop, so a
+ * fixed value of the same shape is both more private and more stable.
+ */
+export const TRAE_OS_VERSION = "Windows 11 Pro";
+
+/** Reported hardware brand, same reasoning as the OS string. */
+export const TRAE_DEVICE_BRAND = "Default string";
+
+/** Per-request correlation id. Random, not derived — decoupled from the device. */
+export function traeRequestId(): string {
+  return randomUUID();
+}
+
+/** Inputs for {@link buildTraeHeaders}. */
+export interface TraeHeaderInput {
+  readonly realm: TraeRealm;
+  /** Access token, sent as both `x-ide-token` and the Authorization bearer. */
+  readonly token: string;
+  /** Account id the device fingerprint is derived from. */
+  readonly uid: string;
+  /**
+   * Current client version, e.g. `3.6.2`. Sent by intl as `x-ide-version` and
+   * `x-app-version`; a stale value is refused with 4015.
+   */
+  readonly clientVersion?: string;
+  /** Version code sent as `x-ide-version-code`. */
+  readonly versionCode?: string;
+  /** True for the streaming chat call, which overrides `Accept`. */
+  readonly stream?: boolean;
+  /** Extra/replacement headers, applied case-insensitively. */
+  readonly extra?: Readonly<Record<string, string | null>>;
+}
+
+/**
+ * Builds the header set for one Trae request.
+ *
+ * `null` in `extra` deletes the header, matching the donor's override rule.
+ */
+export function buildTraeHeaders(input: TraeHeaderInput): Record<string, string> {
+  const config = TRAE_REALMS[input.realm];
+  const device = traeDeviceIdentity(input.uid);
+  const headers: Record<string, string> = {
+    "X-App-Id": TRAE_APP_ID,
+    "x-plugin-channel": TRAE_PLUGIN_CHANNEL,
+    "x-ide-version-code": input.versionCode ?? config.versionCode,
+    "x-ide-token": input.token,
+    Authorization: `Cloud-IDE-JWT ${input.token}`,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "User-Agent": config.userAgent,
+    "X-Device-Cpu": "Intel",
+    "X-Device-Id": device.deviceId,
+    "X-Machine-Id": device.machineId,
+    "X-Device-Brand": encodeURIComponent(TRAE_DEVICE_BRAND),
+    "X-Device-Type": "windows",
+    "X-Os-Version": encodeURIComponent(TRAE_OS_VERSION),
+    "X-Request-Id": traeRequestId(),
+  };
+
+  if (input.realm === "intl") {
+    // intl raw_chat requires Bearer (not Cloud-IDE-JWT) *and* the current
+    // client version on four headers; a stale version is answered 4015.
+    const version = input.clientVersion ?? intlVersionFallback(config.userAgent);
+    headers["Authorization"] = `Bearer ${input.token}`;
+    headers["x-ide-token"] = input.token;
+    headers["x-ide-version"] = version;
+    headers["x-app-version"] = version;
+    headers["User-Agent"] = "TraeClient/TTNet";
+    headers["store-country-code"] = "us";
+  }
+
+  if (input.stream === true) {
+    headers["Accept"] = "text/event-stream";
+    headers["Cache-Control"] = "no-cache";
+  }
+
+  for (const [key, value] of Object.entries(input.extra ?? {})) {
+    const lower = key.toLowerCase();
+    for (const existing of Object.keys(headers)) {
+      if (existing.toLowerCase() === lower) delete headers[existing];
+    }
+    if (value !== null) headers[key] = value;
+  }
+  return headers;
+}
+
+/**
+ * Last-resort intl version: the one baked into the realm's own User-Agent.
+ *
+ * Only reached when the version resolver has not answered yet. It is the
+ * donor's last observed version rather than an invented number, so a cold
+ * process sends something upstream has accepted before.
+ */
+function intlVersionFallback(userAgent: string): string {
+  const match = userAgent.match(/(\d+\.\d+\.\d+)/);
+  return match?.[1] ?? "3.6.2";
+}