cartethyia 2.5.2 → 2.5.4

package/src/providers/integrations/cline/cline-quota.ts

@@ -1,128 +1,132 @@
-import type { FetchLike, ProviderQuotaResult, ProviderQuotaWindow } from "../../quota/quota-contracts";
-import { authCredential, getJson, record, text } from "../../quota/quota-contracts";
-import { parseLimitWindows } from "../../quota/quota-limit-windows";
-import { probeApiKeyConnectivity } from "../../quota/quota-support";
-import { getClineCliVersion, getClineSdkVersion } from "../../operations/client-versions";
-import { clinePlatform, clinePlatformVersion } from "../../operations/cli-platform";
-
-/**
- * Quota headers always carry the currently resolved CLI version.
- *
- * The two version headers are two different versions and must stay that way.
- * `x-client-version` is the Cline CLI the operator is running (`cline` on npm),
- * from the shared pooler. `x-core-version` is the `@cline/sdk` version — a
- * separate npm package with its own release line, though one the CLI pins as a
- * dependency. This used to send the *client* version in both slots, so the
- * billing surface was told our core was `4.1.23`, a vscode extension version
- * that `@cline/sdk` never published.
- *
- * Both surfaces now send the same pairing (`cliVersion` / `sdkVersion`) and the
- * same `cline-cli` client type. A header the upstream can validate is not
- * cosmetic: an implausible core version is exactly what a "please update and
- * re-authenticate" refusal is shaped like, and it is indistinguishable from a
- * dead credential from the response alone.
- *
- * Header identity is not what gates these endpoints: probing `/users/me`,
- * `/users/me/plan` and `/users/me/plan/usage-limits` with no identity headers,
- * the SDK identity and the CLI identity all returned identical responses. The
- * 404 from the plan routes is "no plan history found for user", i.e. account
- * state, not a rejected client.
- */
-function clineQuotaHeaders(): Record<string, string> {
-  const version = getClineCliVersion();
-  return {
-    accept: "application/json",
-    "content-type": "application/json",
-    "user-agent": `Cline/${version}`,
-    "x-platform": clinePlatform(),
-    "x-platform-version": clinePlatformVersion(),
-    "x-client-type": "cline-cli",
-    "x-client-version": version,
-    "x-core-version": getClineSdkVersion(),
-    "x-is-multiroot": "false",
-  };
-}
-
-const CLINE_WINDOW_LABELS: Readonly<Record<string, string>> = {
-  five_hour: "5 Hour",
-  weekly: "7 Day",
-  monthly: "30 Day",
-};
-
-/** Reads Cline's `limits[]` array — one entry per billing window. */
-function usageWindows(value: unknown): readonly ProviderQuotaWindow[] {
-  return [
-    ...parseLimitWindows(value, {
-      kindPaths: ["type"],
-      percentPaths: ["percentUsed"],
-      resetPaths: ["resetsAt"],
-      limitPaths: ["limit", "entitlement", "total"],
-      usedPaths: ["used", "usedCredits"],
-      // Cline reports a percentage and a ceiling but no absolute used value,
-      // so the absolute is derived rather than left null.
-      deriveUsed: (_entry, usedPercent, limit) =>
-        usedPercent !== null && limit !== null ? (limit * usedPercent) / 100 : null,
-      labelFor: (kind) => CLINE_WINDOW_LABELS[kind] ?? null,
-      fallbackLabel: (kind) => kind,
-    }),
-  ];
-}
-
-function isMissingPlanHistory(reason: unknown): boolean {
-  const message =
-    reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "";
-  return /\b404\b|\bno plan history\b/i.test(message);
-}
-
-const CLINE_PROVIDER_ID = "cline" as const;
-/** Envelope marking a resolved secret as an api key rather than an OAuth grant. */
-export const CLINE_API_KEY_PREFIX = "cline-api-key:" as const;
-
-/** Wraps a resolved api_key secret so the collector can route it to /models. */
-export function markClineApiKeyCredential(credential: string): string {
-  return credential.startsWith(CLINE_API_KEY_PREFIX) ? credential : `${CLINE_API_KEY_PREFIX}${credential}`;
-}
-
-export async function fetchClineQuota(
-  credential: string,
-  fetcher: FetchLike,
-): Promise<ProviderQuotaResult> {
-  // API-key accounts carry no OAuth envelope and upstream exposes no quota
-  // surface for them, so an api key must never reach the OAuth-only
-  // users/me endpoint (a 401 there is not dispatchable either). The account
-  // test for keys is plain validity via /models.
-  if (credential.startsWith(CLINE_API_KEY_PREFIX)) {
-    return probeApiKeyConnectivity(
-      CLINE_PROVIDER_ID,
-      credential.slice(CLINE_API_KEY_PREFIX.length),
-      fetcher,
-    );
-  }
-  const fields = authCredential(credential);
-  const access = text(fields.accessToken);
-  if (!access) throw new Error("Cline credential has no access token.");
-  const headers = {
-    ...clineQuotaHeaders(),
-    authorization: `Bearer ${access.startsWith("workos:") ? access : `workos:${access}`}`,
-  };
-  const me = record(await getJson("https://api.cline.bot/api/v1/users/me", headers, fetcher));
-  const userId = text(me?.id);
-  if (!userId) throw new Error("Cline account response has no user id.");
-  const [planRaw, limitsRaw] = await Promise.allSettled([
-    getJson("https://api.cline.bot/api/v1/users/me/plan", headers, fetcher),
-    getJson("https://api.cline.bot/api/v1/users/me/plan/usage-limits", headers, fetcher),
-  ]);
-  const plan = record(planRaw.status === "fulfilled" ? planRaw.value : null);
-  const limitsFailed = limitsRaw.status === "rejected";
-  const windows = usageWindows(limitsRaw.status === "fulfilled" ? limitsRaw.value : null);
-  const error =
-    limitsFailed && !isMissingPlanHistory(limitsRaw.reason)
-      ? "Failed to fetch quota limits."
-      : null;
-  return {
-    source: "cline",
-    plan: text(record(plan?.plan)?.displayName) ?? text(plan?.displayName) ?? "Cline",
-    windows,
-    error,
-  };
-}
+import type { FetchLike, ProviderQuotaResult, ProviderQuotaWindow } from "../../quota/quota-contracts";
+import { authCredential, getJson, record, text } from "../../quota/quota-contracts";
+import { parseLimitWindows } from "../../quota/quota-limit-windows";
+import { getClineCliVersion, getClineSdkVersion } from "../../operations/client-versions";
+import { clinePlatform, clinePlatformVersion } from "../../operations/cli-platform";
+
+/**
+ * Quota headers always carry the currently resolved CLI version.
+ *
+ * The two version headers are two different versions and must stay that way.
+ * `x-client-version` is the Cline CLI the operator is running (`cline` on npm),
+ * from the shared pooler. `x-core-version` is the `@cline/sdk` version — a
+ * separate npm package with its own release line, though one the CLI pins as a
+ * dependency. This used to send the *client* version in both slots, so the
+ * billing surface was told our core was `4.1.23`, a vscode extension version
+ * that `@cline/sdk` never published.
+ *
+ * Both surfaces now send the same pairing (`cliVersion` / `sdkVersion`) and the
+ * same `cline-cli` client type. A header the upstream can validate is not
+ * cosmetic: an implausible core version is exactly what a "please update and
+ * re-authenticate" refusal is shaped like, and it is indistinguishable from a
+ * dead credential from the response alone.
+ *
+ * Header identity is not what gates these endpoints: probing `/users/me`,
+ * `/users/me/plan` and `/users/me/plan/usage-limits` with no identity headers,
+ * the SDK identity and the CLI identity all returned identical responses. The
+ * 404 from the plan routes is "no plan history found for user", i.e. account
+ * state, not a rejected client.
+ */
+function clineQuotaHeaders(): Record<string, string> {
+  const version = getClineCliVersion();
+  return {
+    accept: "application/json",
+    "content-type": "application/json",
+    "user-agent": `Cline/${version}`,
+    "x-platform": clinePlatform(),
+    "x-platform-version": clinePlatformVersion(),
+    "x-client-type": "cline-cli",
+    "x-client-version": version,
+    "x-core-version": getClineSdkVersion(),
+    "x-is-multiroot": "false",
+  };
+}
+
+const CLINE_WINDOW_LABELS: Readonly<Record<string, string>> = {
+  five_hour: "5 Hour",
+  weekly: "7 Day",
+  monthly: "30 Day",
+};
+
+/** Reads Cline's `limits[]` array — one entry per billing window. */
+function usageWindows(value: unknown): readonly ProviderQuotaWindow[] {
+  return [
+    ...parseLimitWindows(value, {
+      kindPaths: ["type"],
+      percentPaths: ["percentUsed"],
+      resetPaths: ["resetsAt"],
+      limitPaths: ["limit", "entitlement", "total"],
+      usedPaths: ["used", "usedCredits"],
+      // Cline reports a percentage and a ceiling but no absolute used value,
+      // so the absolute is derived rather than left null.
+      deriveUsed: (_entry, usedPercent, limit) =>
+        usedPercent !== null && limit !== null ? (limit * usedPercent) / 100 : null,
+      labelFor: (kind) => CLINE_WINDOW_LABELS[kind] ?? null,
+      fallbackLabel: (kind) => kind,
+    }),
+  ];
+}
+
+function isMissingPlanHistory(reason: unknown): boolean {
+  const message =
+    reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "";
+  return /\b404\b|\bno plan history\b/i.test(message);
+}
+
+/** Envelope marking a resolved secret as an api key rather than an OAuth grant. */
+export const CLINE_API_KEY_PREFIX = "cline-api-key:" as const;
+
+/** Wraps a resolved api_key secret so the collector can route it to /models. */
+export function markClineApiKeyCredential(credential: string): string {
+  return credential.startsWith(CLINE_API_KEY_PREFIX) ? credential : `${CLINE_API_KEY_PREFIX}${credential}`;
+}
+
+export async function fetchClineQuota(
+  credential: string,
+  fetcher: FetchLike,
+): Promise<ProviderQuotaResult> {
+  const isApiKey = credential.startsWith(CLINE_API_KEY_PREFIX);
+  const bearer = isApiKey ? credential.slice(CLINE_API_KEY_PREFIX.length) : null;
+
+  let headers: Record<string, string>;
+  if (isApiKey && bearer) {
+    // An api key is its own bearer token: `Authorization: Bearer sk_...`, with
+    // no `workos:` prefix.
+    //
+    // Prefixing it is what produced "Unauthorized: please make sure you're
+    // using the latest version of Cline and re-authenticate" — verified against
+    // a live key, where the same key returned 200 on `/users/me` bare and 401
+    // once `workos:` was prepended. The message names a version problem, so it
+    // reads as a client the upstream refuses rather than a malformed header,
+    // which is why it went unrecognised for so long.
+    headers = { ...clineQuotaHeaders(), authorization: `Bearer ${bearer}` };
+  } else {
+    const fields = authCredential(credential);
+    const access = text(fields.accessToken);
+    if (!access) throw new Error("Cline credential has no access token.");
+    headers = {
+      ...clineQuotaHeaders(),
+      authorization: `Bearer ${access.startsWith("workos:") ? access : `workos:${access}`}`,
+    };
+  }
+  const me = record(await getJson("https://api.cline.bot/api/v1/users/me", headers, fetcher));
+  const userId = text(me?.id);
+  if (!userId) throw new Error("Cline account response has no user id.");
+  const [planRaw, limitsRaw] = await Promise.allSettled([
+    getJson("https://api.cline.bot/api/v1/users/me/plan", headers, fetcher),
+    getJson("https://api.cline.bot/api/v1/users/me/plan/usage-limits", headers, fetcher),
+  ]);
+  const plan = record(planRaw.status === "fulfilled" ? planRaw.value : null);
+  const limitsFailed = limitsRaw.status === "rejected";
+  const windows = usageWindows(limitsRaw.status === "fulfilled" ? limitsRaw.value : null);
+  const error =
+    limitsFailed && !isMissingPlanHistory(limitsRaw.reason)
+      ? "Failed to fetch quota limits."
+      : null;
+  return {
+    source: "cline",
+    plan: text(record(plan?.plan)?.displayName) ?? text(plan?.displayName) ?? "Cline",
+    windows,
+    error,
+  };
+}

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

@@ -16,31 +16,38 @@ interface CodexIdentityHeadersOptions {
   readonly sessionId?: string | undefined;
   readonly threadId?: string | undefined;
   readonly windowId?: string | undefined;
-  readonly turnId?: string | undefined;
-  readonly parentTurnId?: string | undefined;
-  readonly conversationId?: string | undefined;
-  readonly installationId?: string | undefined;
   readonly turnMetadataJson?: string | undefined;
   readonly betaFeatures?: string | undefined;
   readonly subAgent?: string | undefined;
   readonly responsesLite?: boolean | undefined;
   readonly turnState?: string | undefined;
-  readonly modelsEtag?: string | undefined;
-  /**
-   * `x-codex-routing-hint: model=<slug>[;tier=<service_tier>]` — codex-rs
-   * sends this on every ChatGPT-OAuth Responses/compaction/WebSocket
-   * request. Callers compute the value; absent/empty omits the header.
-   */
-  readonly routingHint?: string | undefined;
 }
 
+/**
+ * Assembles the request headers the reference ChatGPT-OAuth Responses
+ * dispatch sends (`codex-rs` rust-v0.160.0):
+ *
+ * - default client headers (`default_headers`): `originator`, `user-agent`
+ *   (no `version` header at this tag);
+ * - auth (`add_auth_headers`): `authorization`, `chatgpt-account-id`;
+ * - per-request extras (`build_responses_options`): `x-codex-beta-features`?,
+ *   `x-codex-turn-state`?, `x-oai-attestation`?, lite header when Responses
+ *   Lite, the compatibility projection (`x-codex-window-id`,
+ *   `x-codex-turn-metadata`, `x-codex-parent-thread-id`?, `x-openai-subagent`?);
+ * - transport options (`ApiResponsesOptions` + stream wrapper):
+ *   `x-client-request-id` / `session-id` / `thread-id` / `x-openai-subagent`?.
+ *
+ * Identity values that moved into the body (`client_metadata` — installation,
+ * turn id, parent turn id) are absent here by design. `conversation-id`,
+ * `turn-id`, `parent-turn-id` direct headers and `x-codex-routing-hint`
+ * (WebSocket-only at this tag) are not emitted.
+ */
 export function buildCodexIdentityHeaders(
   options: CodexIdentityHeadersOptions,
 ): Record<string, string> {
   const headers: Record<string, string> = {};
   headers["user-agent"] = buildCodexUserAgent(options.version);
   headers["originator"] = "codex_cli_rs";
-  headers["version"] = options.version;
   const token =
     options.credential.secret === undefined
       ? undefined
@@ -50,37 +57,19 @@ export function buildCodexIdentityHeaders(
     (token === undefined ? undefined : getCodexAccountId(token));
   if (accountId !== undefined && accountId.length > 0)
     headers["chatgpt-account-id"] = accountId;
-  headers["OpenAI-Beta"] = "responses=experimental";
   if (options.attestation !== undefined && options.attestation.length > 0)
     headers["x-oai-attestation"] = options.attestation;
   if (options.residency !== undefined && options.residency.length > 0)
     headers["x-openai-internal-codex-residency"] = options.residency;
   if (options.sessionId !== undefined && options.sessionId.length > 0) {
     headers["session-id"] = options.sessionId;
-    headers["x-client-request-id"] = options.sessionId;
-    if (
-      options.conversationId === undefined ||
-      options.conversationId.length === 0
-    ) {
-      headers["conversation-id"] = options.sessionId;
-    }
   }
-  if (options.threadId !== undefined && options.threadId.length > 0)
+  if (options.threadId !== undefined && options.threadId.length > 0) {
     headers["thread-id"] = options.threadId;
+    headers["x-client-request-id"] = options.threadId;
+  }
   if (options.windowId !== undefined && options.windowId.length > 0)
     headers["x-codex-window-id"] = options.windowId;
-  if (options.turnId !== undefined && options.turnId.length > 0)
-    headers["turn-id"] = options.turnId;
-  if (options.parentTurnId !== undefined && options.parentTurnId.length > 0)
-    headers["parent-turn-id"] = options.parentTurnId;
-  if (options.conversationId !== undefined && options.conversationId.length > 0)
-    headers["conversation-id"] = options.conversationId;
-  if (
-    options.installationId !== undefined &&
-    options.installationId.length > 0
-  ) {
-    headers["x-codex-installation-id"] = options.installationId;
-  }
   if (
     options.turnMetadataJson !== undefined &&
     options.turnMetadataJson.length > 0
@@ -99,12 +88,6 @@ export function buildCodexIdentityHeaders(
   if (options.turnState !== undefined && options.turnState.length > 0) {
     headers["x-codex-turn-state"] = options.turnState;
   }
-  if (options.modelsEtag !== undefined && options.modelsEtag.length > 0) {
-    headers["x-models-etag"] = options.modelsEtag;
-  }
-  if (options.routingHint !== undefined && options.routingHint.length > 0) {
-    headers["x-codex-routing-hint"] = options.routingHint;
-  }
   return headers;
 }
 
@@ -118,6 +101,7 @@ export function createCodexRequestMetadata(args: {
   windowId: string;
   turnId: string;
   parentTurnId?: string;
+  subAgent?: string;
   requestKind?: string;
   turnStartedAtUnixMs?: number;
   compaction?: Record<string, unknown>;
@@ -150,6 +134,8 @@ export function createCodexRequestMetadata(args: {
   };
   if (args.parentTurnId !== undefined && args.parentTurnId.length > 0)
     clientMetadata["parent_turn_id"] = args.parentTurnId;
+  if (args.subAgent !== undefined && args.subAgent.length > 0)
+    clientMetadata["x-openai-subagent"] = args.subAgent;
   clientMetadata["x-codex-turn-metadata"] = turnMetadataJson;
   return { clientMetadata, turnMetadataJson };
 }

package/src/providers/integrations/codex/codex.ts

@@ -551,8 +551,8 @@ export function createCodexAdapter(
   const subAgent = config.subagent;
   const installationOverride = config.installation_id_override;
 
-  // Per-session state for sticky routing (x-codex-turn-state / x-models-etag)
-  // and identity reuse. Bounded LRU + TTL: an unbounded map would leak
+  // Per-session state for sticky routing (x-codex-turn-state) and identity
+  // reuse. Bounded LRU + TTL: an unbounded map would leak
   // memory forever under a long-running process serving many distinct
   // Codex sessions.
   const sessionStates = new Map<
@@ -639,16 +639,13 @@ export function createCodexAdapter(
     const state = getSessionState(sessionId);
     if (state === undefined) return;
     let turnState: string | null = null;
-    let modelsEtag: string | null = null;
     if (headers instanceof Headers) {
       turnState = headers.get("x-codex-turn-state");
-      modelsEtag = headers.get("x-models-etag");
     } else if (typeof headers === "object") {
       const rec = headers as Record<string, string>;
       for (const [k, v] of Object.entries(rec)) {
         const lower = k.toLowerCase();
         if (lower === "x-codex-turn-state") turnState = v;
-        if (lower === "x-models-etag") modelsEtag = v;
       }
     }
     if (
@@ -658,9 +655,6 @@ export function createCodexAdapter(
     ) {
       state.turnState = turnState;
     }
-    if (modelsEtag !== null && modelsEtag.length > 0) {
-      state.modelsEtag = modelsEtag;
-    }
   }
 
   return {
@@ -700,13 +694,10 @@ export function createCodexAdapter(
           sessionId: identity.session_id,
           threadId: identity.thread_id,
           windowId: identity.window_id,
-          turnId: identity.turn_id,
-          installationId,
           turnMetadataJson,
           betaFeatures: betaRemoteCompaction
             ? "remote_compaction_v2"
             : undefined,
-          routingHint: `model=${body["model"] as string}`,
         }),
       };
       const { res, release } = await postUpstreamJson(
@@ -919,7 +910,6 @@ export function createCodexAdapter(
       let rawWindowId = nonEmpty(request.window_id);
       let rawTurnId = nonEmpty(request.turn_id);
       const rawParentTurnId = nonEmpty(request.parent_turn_id);
-      const rawConversationId = nonEmpty(request.conversation_id);
 
       const installationId = await getInstallationIdCached();
 
@@ -970,9 +960,6 @@ export function createCodexAdapter(
       const turnStartedAtUnixMs = Date.now();
       sessionState.turnStartedAtUnixMs = turnStartedAtUnixMs;
 
-      // If conversation_id not supplied, mirror session_id (reference behavior).
-      const conversationId = rawConversationId ?? effectiveSessionId;
-
       const token =
         context.credential.secret === undefined
           ? undefined
@@ -998,12 +985,6 @@ export function createCodexAdapter(
       const betaFeatures = betaRemoteCompaction
         ? "remote_compaction_v2"
         : undefined;
-      // `x-codex-routing-hint` mirrors codex-rs (`codexRoutingHint`): the
-      // Codex adapter is OAuth-family only, so the hint is always emitted.
-      const serviceTier = request.generation_controls.service_tier;
-      const routingHint = serviceTier
-        ? `model=${request.model};tier=${serviceTier}`
-        : `model=${request.model}`;
 
       const headers: Record<string, string> = {
         "content-type": "application/json",
@@ -1020,19 +1001,11 @@ export function createCodexAdapter(
           sessionId: effectiveSessionId,
           threadId,
           windowId,
-          turnId,
-          ...(rawParentTurnId === undefined
-            ? {}
-            : { parentTurnId: rawParentTurnId }),
-          conversationId,
-          installationId,
           turnMetadataJson,
           betaFeatures,
           subAgent,
           responsesLite,
           turnState: sessionState.turnState,
-          modelsEtag: sessionState.modelsEtag,
-          routingHint,
         }),
       );
       const outboundFetch = context.outbound_fetch ?? fetchFn;