cartethyia 2.7.9 → 2.8.0

package/src/providers/integrations/qoder/claim-qoder-credits.ts

@@ -16,10 +16,14 @@
  */
 import type { CartethyiaDatabase } from "../../../persistence/db-handle";
 import type { ValidatedFetch } from "../../../network/outbound-fetch";
-import { getQoderVersion } from "../../operations/client-versions";
 import { qoderRealmForProvider, QODER_REALMS } from "./qoder-realm";
+import { exchangeQoderPatForHost } from "./qoder-auth";
 import {
+  asNumber,
+  asRecord,
   buildCampaignHeaders,
+  normalizeCampaign,
+  safeParse,
 } from "./qoder-checkin";
 import { qoderMachineHeaders } from "./qoder-umid";
 import {
@@ -38,31 +42,6 @@ export const QODER_CREDIT_PROVIDER_IDS = ["qoder", "qodercn"] as const;
 
 const PAT_PREFIX = "pt-";
 
-function asRecord(value: unknown): Record<string, unknown> | null {
-  if (typeof value !== "object" || value === null) return null;
-  return value as Record<string, unknown>;
-}
-
-function asNumber(value: unknown): number | null {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-
-function normalizeCampaign(raw: Record<string, unknown>): Record<string, unknown> {
-  const benefit = asRecord(raw["benefit"]);
-  return {
-    campaign_id: String(raw["campaignId"] ?? raw["campaign_id"] ?? ""),
-    campaign_key: String(raw["campaignKey"] ?? raw["campaign_key"] ?? ""),
-    action_type: String(raw["actionType"] ?? raw["action_type"] ?? ""),
-    claim_status: String(raw["claimStatus"] ?? raw["claim_status"] ?? ""),
-    ...(benefit !== null ? { benefit } : {}),
-  };
-}
-
 /**
  * Exchanges a PAT (`pt-…`) for a job token (`jt-…`) on the realm's openapi
  * host. Returns the job token, or `null` when the exchange fails.
@@ -70,7 +49,8 @@ function normalizeCampaign(raw: Record<string, unknown>): Record<string, unknown
  * The real client binds the machine identity at exchange time
  * (`getMachineIdentityRequestFields`), so `machine_id` + `machine_token` are
  * sent when available — the job token is then bound to that machine. The
- * User-Agent and Cosy version mirror the real client (`qoder/<version>`).
+ * request is the shared `exchangeQoderPatForHost` (same v1 body and client
+ * identity headers as the auth path), parameterized by this site's own host.
  */
 async function exchangePatToJobToken(
   base: string,
@@ -78,30 +58,17 @@ async function exchangePatToJobToken(
   fetcher: ValidatedFetch,
   machine?: { readonly id?: string; readonly token?: string },
 ): Promise<string | null> {
-  try {
-    const body: Record<string, unknown> = { personal_token: pat };
-    if (machine?.id) body.machine_id = machine.id;
-    if (machine?.token) body.machine_token = machine.token;
-    const version = getQoderVersion();
-    const res = await fetcher(`${base}/api/v1/jobToken/exchange`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "User-Agent": `qoder/${version}`,
-        "Cosy-ClientType": "5",
-        "Cosy-Version": version,
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(25_000),
-    });
-    if (!res.ok) return null;
-    const payload: unknown = await res.json().catch(() => null);
-    const rec = asRecord(payload);
-    const token = String(rec?.["token"] ?? rec?.["device_token"] ?? rec?.["access_token"] ?? "");
-    return token.length > 0 ? token : null;
-  } catch {
-    return null;
-  }
+  const exchanged = await exchangeQoderPatForHost({
+    pat,
+    url: `${base}/api/v1/jobToken/exchange`,
+    ...(machine === undefined ? {} : { machine }),
+    fetcher,
+    signal: AbortSignal.timeout(25_000),
+    tokenKeys: ["token", "device_token", "access_token"],
+  });
+  if (exchanged === null) return null;
+  if (!exchanged.response.ok) return null;
+  return exchanged.result?.token ?? null;
 }
 
 /**
@@ -248,11 +215,3 @@ export async function claimQoderCredits(args: {
     return { state: "error", amount: 0, detail: "Claim request failed." };
   }
 }
-
-function safeParse(raw: string): unknown {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}

package/src/providers/integrations/qoder/qoder-adapter.ts

@@ -30,7 +30,7 @@ import { abortGatewayError, createUpstreamDeadlineLifecycle } from "../../operat
 import { getQoderVersion } from "../../operations/client-versions";
 import { qoderMachineHostname, qoderMachineOs } from "../../operations/cli-platform";
 import { mapUpstreamHttpError } from "../../../transport/failure-policy";
-import { QODER_CN_MODEL_CONFIGS, QODER_INTL_MODEL_CONFIGS, qoderDiscoveredMaxContexts } from "./qoder-catalog";
+import { QODER_CN_MODEL_CONFIGS, QODER_INTL_MODEL_CONFIGS } from "./qoder-catalog";
 import { isQoderVirtualModel, qoderDispatchModelId } from "./qoder-virtual";
 import { isQoderPat, qoderOAuthAuth, qoderSessionId, resolveQoderAuth } from "./qoder-auth";
 import { buildQoderRequest, callQoder } from "./qoder-chat";
@@ -84,16 +84,6 @@ export function resolveQoderTransport(
   return chosen;
 }
 
-/**
- * The widest selectable context window for one model key (from the live list's
- * `context_config`; falls back to the static roster's stated window).
- */
-function qoderMaxContextFor(modelId: string, modelConfig: QoderModelConfig, realm: QoderRealm): number {
-  const discovered = qoderDiscoveredMaxContexts(realm).get(modelId);
-  if (discovered !== undefined) return discovered;
-  return modelConfig.max_input_tokens;
-}
-
 class QoderAdapter implements ProviderAdapter {
   readonly provider_id: ProviderId;
   private readonly realm: QoderRealm;
@@ -256,7 +246,6 @@ class QoderAdapter implements ProviderAdapter {
           modelId,
           request,
           auth.userId,
-          qoderMaxContextFor(modelId, modelConfig, this.realm),
           {
             messages: legacy.messages as Array<Record<string, unknown>>,
             tools: legacy.tools as Array<Record<string, unknown>>,

package/src/providers/integrations/qoder/qoder-auth.ts

@@ -114,6 +114,91 @@ export function qoderSessionId(userId: string, modelId: string): string {
 
 type QoderFetcher = (url: string, init: RequestInit) => Promise<Response>;
 
+/** The fields a PAT→job-token exchange response carries. */
+export interface ExchangeQoderPatResult {
+  readonly token: string;
+  readonly name?: string;
+  readonly userType?: string;
+  readonly refreshToken?: string;
+  readonly expiresAt?: string;
+}
+
+/**
+ * One PAT→job-token exchange against an explicit endpoint URL. Shared by
+ * `exchangeQoderPat` (auth) and the claim flow: both POST the same v1 body
+ * (`{personal_token, machine_id?, machine_token?}`) with the client identity
+ * headers and parse the same response token. Parameterized by URL so each call
+ * site keeps its own verified host (`center.qoder.sh` vs the openapi host);
+ * the header set is the one verified live against both (2026-11-05/05).
+ * Returns the raw `Response` plus the parsed result (or `null` when the body
+ * carried no usable token); `null` itself means the request failed to reach
+ * upstream. Callers decide how to surface each case (throw vs null).
+ */
+export async function exchangeQoderPatForHost(args: {
+  readonly pat: string;
+  readonly url: string;
+  readonly machine?: { readonly id?: string; readonly token?: string };
+  readonly fetcher: QoderFetcher;
+  readonly signal: AbortSignal;
+  readonly version?: string;
+  /** Response keys to read the job token from, tried in order. Defaults to `["token"]`. */
+  readonly tokenKeys?: readonly string[];
+}): Promise<{ readonly response: Response; readonly result: ExchangeQoderPatResult | null } | null> {
+  const body: Record<string, unknown> = { personal_token: args.pat };
+  if (args.machine?.id) body.machine_id = args.machine.id;
+  if (args.machine?.token) body.machine_token = args.machine.token;
+  const version = args.version ?? getQoderVersion();
+  const tokenKeys = args.tokenKeys ?? ["token"];
+  let response: Response;
+  try {
+    response = await args.fetcher(args.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "User-Agent": `qoder/${version}`,
+        "X-Request-ID": randomUUID().toUpperCase(),
+        "Cosy-ClientType": "5",
+        "Cosy-Version": version,
+        "Cosy-MachineOS": qoderMachineOs(),
+      },
+      body: JSON.stringify(body),
+      signal: args.signal,
+    });
+  } catch {
+    return null;
+  }
+  if (!response.ok) return { response, result: null };
+  let responseBody: unknown;
+  try {
+    responseBody = await response.json();
+  } catch {
+    return { response, result: null };
+  }
+  if (typeof responseBody !== "object" || responseBody === null || Array.isArray(responseBody)) {
+    return { response, result: null };
+  }
+  const rec = responseBody as Record<string, unknown>;
+  let token = "";
+  for (const key of tokenKeys) {
+    if (typeof rec[key] === "string" && (rec[key] as string).length > 0) {
+      token = rec[key] as string;
+      break;
+    }
+  }
+  if (token.length === 0) return { response, result: null };
+  return {
+    response,
+    result: {
+      token,
+      ...(typeof rec["name"] === "string" ? { name: rec["name"] as string } : {}),
+      ...(typeof rec["userType"] === "string" ? { userType: rec["userType"] as string } : {}),
+      ...(typeof rec["refresh_token"] === "string" ? { refreshToken: rec["refresh_token"] as string } : {}),
+      ...(typeof rec["expires_at"] === "string" ? { expiresAt: rec["expires_at"] as string } : {}),
+    },
+  };
+}
+
 /**
  * Exchanges a PAT (`pt-…`) for a short-lived job token (`jt-…`) using the
  * modern v1 endpoint. Verified live (2026-11-05): `POST
@@ -135,41 +220,28 @@ async function exchangeQoderPat(
   realm: QoderRealm = "intl",
 ): Promise<QoderAuth> {
   const machineId = qoderMachineIdFromPat(pat);
-  const response = await fetcher(QODER_REALMS[realm].jobTokenUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "application/json",
-      "User-Agent": `qoder/${version}`,
-      "X-Request-ID": randomUUID().toUpperCase(),
-      "Cosy-ClientType": "5",
-      "Cosy-Version": version,
-      "Cosy-MachineOS": qoderMachineOs(),
-    },
-    body: JSON.stringify({ personal_token: pat, machine_id: machineId }),
+  const exchanged = await exchangeQoderPatForHost({
+    pat,
+    url: QODER_REALMS[realm].jobTokenUrl,
+    machine: { id: machineId },
+    fetcher,
     signal,
+    version,
   });
-  if (!response.ok) throw await mapUpstreamHttpError(response, "qoder");
-  let responseBody: unknown;
-  try {
-    responseBody = await response.json();
-  } catch {
-    throw new GatewayError("platform_unavailable", 502, "Qoder PAT exchange returned invalid JSON (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
+  if (exchanged === null) {
+    throw new GatewayError("platform_unavailable", 502, "Qoder PAT exchange failed to reach upstream (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
   }
-  if (typeof responseBody !== "object" || responseBody === null || Array.isArray(responseBody)) {
-    throw new GatewayError("platform_unavailable", 502, "Qoder PAT exchange returned unexpected response (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
-  }
-  const rec = responseBody as Record<string, unknown>;
-  const token = typeof rec["token"] === "string" ? (rec["token"] as string) : "";
-  if (!token) {
-    throw new GatewayError("platform_unavailable", 502, "Qoder PAT exchange returned incomplete credentials (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
+  if (!exchanged.response.ok) throw await mapUpstreamHttpError(exchanged.response, "qoder");
+  const result = exchanged.result;
+  if (result === null) {
+    throw new GatewayError("platform_unavailable", 502, "Qoder PAT exchange returned no usable token (request {requestId}). The upstream came back empty-handed — retry 🌙", {}, "upstream");
   }
   return {
     userId: machineId,
-    userName: typeof rec["name"] === "string" ? (rec["name"] as string) : "",
-    userType: typeof rec["userType"] === "string" ? (rec["userType"] as string) : "personal_standard",
-    securityOauthToken: token,
-    refreshToken: typeof rec["refresh_token"] === "string" ? (rec["refresh_token"] as string) : "",
+    userName: result.name ?? "",
+    userType: result.userType ?? "personal_standard",
+    securityOauthToken: result.token,
+    refreshToken: result.refreshToken ?? "",
     machineId,
   };
 }

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

@@ -322,7 +322,7 @@ export function mapQoderCatalogResponse(raw: unknown): QoderCatalogEntry[] {
  * to a base-catalog/majority vote that can sit below the roster's ceiling
  * (e.g. `qwen3.7-plus` votes 64k while the roster says 131k).
  */
-function qoderRosterMaxOutputFor(providerId: string, key: string): number | undefined {
+export function qoderRosterMaxOutput(providerId: string, key: string): number | undefined {
   const configs = providerId === "qodercn" ? QODER_CN_MODEL_CONFIGS : QODER_INTL_MODEL_CONFIGS;
   return configs[key]?.max_output_tokens;
 }
@@ -332,7 +332,7 @@ export function qoderCatalogModel(
   entry: QoderCatalogEntry,
   providerId: string,
 ): ModelDefinition {
-  const rosterOutput = qoderRosterMaxOutputFor(providerId, entry.key);
+  const rosterOutput = qoderRosterMaxOutput(providerId, entry.key);
   return defineModel({
     id: entry.key,
     providerId,
@@ -350,7 +350,7 @@ export function qoderCatalogModel(
     free: entry.isFree,
     freeTier: entry.isFree,
     // The live row carries no output ceiling, so inherit the static roster's
-    // stated one when it exists (see `qoderRosterMaxOutputFor`).
+    // stated one when it exists (see `qoderRosterMaxOutput`).
     ...(rosterOutput === undefined ? {} : { out: rosterOutput }),
     warnings: QODER_PROVIDER_WARNINGS,
   });
@@ -446,6 +446,21 @@ export function qoderDiscoveredMaxContexts(realm: QoderRealm): ReadonlyMap<strin
   return discoveryMaxContextByKey.get(realm) ?? new Map();
 }
 
+/**
+ * The widest selectable context window for one model key.
+ *
+ * The live list's `context_config` is the authority when discovery has run:
+ * it names every window the account can switch to, and the widest one is what
+ * a dispatch should send (`model_config.max_input_tokens`) so a conversation is
+ * never capped at the *currently active* window (often 180k) when the account
+ * can use 1M. Falls back to the static roster's stated window otherwise.
+ */
+export function qoderMaxContextFor(modelId: string, modelConfig: QoderModelConfig, realm: QoderRealm): number {
+  const discovered = qoderDiscoveredMaxContexts(realm).get(modelId);
+  if (discovered !== undefined) return discovered;
+  return modelConfig.max_input_tokens;
+}
+
 export async function discoverQoderModels(input: {
   readonly realm: QoderRealm;
   /** Account secret the injected signer signs with; blank fails fast. */
@@ -526,7 +541,7 @@ export async function discoverQoderModels(input: {
         // is published.
         const virtuals = QODER_VIRTUAL_MODELS.filter((virtual) => virtual.target === entry.key);
         if (virtuals.length === 0) return [qoderCatalogModel(entry, providerId)];
-        const rosterOutput = qoderRosterMaxOutputFor(providerId, entry.key);
+        const rosterOutput = qoderRosterMaxOutput(providerId, entry.key);
         return virtuals.map((virtual) =>
           defineModel({
             id: virtual.id,
@@ -538,7 +553,7 @@ export async function discoverQoderModels(input: {
             reasoning: entry.isReasoning,
             // A virtual override wins; otherwise inherit the static roster's
             // ceiling for the slot instead of a base-catalog/majority estimate
-            // (see `qoderRosterMaxOutputFor`).
+            // (see `qoderRosterMaxOutput`).
             ...(virtual.outputLimit !== undefined
               ? { out: virtual.outputLimit }
               : rosterOutput === undefined

package/src/providers/integrations/qoder/qoder-chat.ts

@@ -14,9 +14,10 @@ import type {
 } from "../../../protocol/canonical-model";
 import { toolResultParts, toolCallParts } from "../../../protocol/canonical-model";
 import { reasoningEffortFromIntent } from "../../../protocol/reasoning";
+import { reasoningTextForReplay } from "../../../protocol/reasoning-text";
 import { resolveImageSource } from "../../../protocol/codecs";
 import { getQoderVersion } from "../../operations/client-versions";
-import { qoderDiscoveredMaxContexts, QODER_CN_MODEL_CONFIGS, QODER_INTL_MODEL_CONFIGS } from "./qoder-catalog";
+import { qoderMaxContextFor, qoderRosterMaxOutput } from "./qoder-catalog";
 import { transformQoderBody, qoderBuildCosyHeaders } from "./qoder-cosy";
 import { qoderSessionId } from "./qoder-auth";
 import { flattenCanonicalContent, qoderToolChoice, qoderTools } from "./qoder-body";
@@ -69,12 +70,6 @@ function qoderStableRecordId(modelId: string, messages: CanonicalRequest["messag
  * never capped at the *currently active* window (often 180k) when the account
  * can use 1M. Falls back to the static roster's stated window otherwise.
  */
-function qoderMaxContextFor(modelId: string, modelConfig: QoderModelConfig, realm: QoderRealm): number {
-  const discovered = qoderDiscoveredMaxContexts(realm).get(modelId);
-  if (discovered !== undefined) return discovered;
-  return modelConfig.max_input_tokens;
-}
-
 function qoderRequestedMaxTokens(
   request: CanonicalRequest,
   modelConfig: QoderModelConfig,
@@ -91,7 +86,7 @@ function qoderRequestedMaxTokens(
   const configured =
     typeof modelConfig.max_output_tokens === "number"
       ? modelConfig.max_output_tokens
-      : qoderRosterMaxOutput(modelConfig.id, realm) ?? 65_536;
+      : qoderRosterMaxOutput(realm === "cn" ? "qodercn" : "qoder", modelConfig.id) ?? 65_536;
   const controls = request.generation_controls as Record<string, unknown>;
   const requested =
     typeof controls["max_tokens"] === "number"
@@ -102,17 +97,6 @@ function qoderRequestedMaxTokens(
   return typeof requested === "number" && requested > 0 ? Math.min(requested, configured) : configured;
 }
 
-/**
- * The static roster's stated output ceiling for one key, when the roster states
- * one. Dispatch builds a live-discovered model's config without an output limit
- * (upstream's model list reports none); this lookup restores the roster's
- * ceiling so such a model is not capped at the 65_536 last resort.
- */
-function qoderRosterMaxOutput(modelId: string, realm: QoderRealm): number | undefined {
-  const configs = realm === "cn" ? QODER_CN_MODEL_CONFIGS : QODER_INTL_MODEL_CONFIGS;
-  return configs[modelId]?.max_output_tokens;
-}
-
 /**
  * Whether this model needs the prior turn's reasoning echoed back.
  *
@@ -159,7 +143,9 @@ function qoderReasoningEcho(
     return hasReasoningTrace ? { reasoning_content: "" } : {};
   }
   const text = reasoning
-    .map((part) => (part.kind === "reasoning" ? (part.summary ?? part.payload ?? "") : ""))
+    .map((part) =>
+      part.kind === "reasoning" ? (reasoningTextForReplay(part) ?? part.payload ?? "") : "",
+    )
     .join("");
   return { reasoning_content: text };
 }
@@ -448,7 +434,7 @@ export function buildQoderRequest(
       // for every model alike, so the request would declare a cap the catalog
       // does not publish. A discovered model's config carries no output limit,
       // so consult the roster for the key before the 65_536 last resort.
-      max_output_tokens: modelConfig.max_output_tokens ?? qoderRosterMaxOutput(modelId, realm) ?? 65_536,
+      max_output_tokens: modelConfig.max_output_tokens ?? qoderRosterMaxOutput(realm === "cn" ? "qodercn" : "qoder", modelId) ?? 65_536,
       source: modelConfig.source ?? "system",
     },
     messages: qoderMessages,

package/src/providers/integrations/qoder/qoder-checkin.ts

@@ -79,12 +79,12 @@ function campaignHeaders(credential: string): Record<string, string> {
   return buildCampaignHeaders(credential);
 }
 
-function asRecord(value: unknown): Record<string, unknown> | null {
+export function asRecord(value: unknown): Record<string, unknown> | null {
   if (typeof value !== "object" || value === null) return null;
   return value as Record<string, unknown>;
 }
 
-function asNumber(value: unknown): number | null {
+export function asNumber(value: unknown): number | null {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "string" && value.trim() !== "") {
     const parsed = Number(value);
@@ -93,7 +93,7 @@ function asNumber(value: unknown): number | null {
   return null;
 }
 
-function safeParse(raw: string): unknown {
+export function safeParse(raw: string): unknown {
   try {
     return JSON.parse(raw);
   } catch {
@@ -127,7 +127,7 @@ function asState(state: string, today: string, lastClaimedAt: unknown): { active
  * consumes. The API returns camelCase keys (`campaignId`, `actionType`,
  * `claimStatus`); the fixtures and the donor hub use snake_case — accept both.
  */
-function normalizeCampaign(raw: Record<string, unknown>): Record<string, unknown> {
+export function normalizeCampaign(raw: Record<string, unknown>): Record<string, unknown> {
   const benefit = asRecord(raw["benefit"]);
   return {
     campaign_id: String(raw["campaignId"] ?? raw["campaign_id"] ?? ""),

package/src/providers/integrations/qoder/qoder-grpc.ts

@@ -362,7 +362,6 @@ export function buildQoderGrpcRequest(
   modelId: string,
   request: CanonicalRequest,
   userId: string,
-  _contextWindow = 1_000_000,
   legacy?: {
     readonly messages: Array<Record<string, unknown>>;
     readonly tools?: Array<Record<string, unknown>>;

package/src/providers/integrations/qoder/qoder-ide.ts

@@ -479,110 +479,3 @@ export function buildQoderIdeRequest(
   };
 }
 
-/**
- * Qoder upstream streams are flaky: the IDE surface sometimes answers a full
- * normal stop with reasoning only and no output text/tool calls (observed ~1
- * in 4 runs with Sonus). That is not a valid completion — the lab would show a
- * thought with "No text came back". Replay such a stream before committing to
- * it. `sniffQoderStream` below inspects just enough of the body to make that
- * call without buffering the whole (possibly long) stream.
- */
-
-/**
- * Reads the upstream body just far enough to decide whether it carries real
- * output, then returns a replay stream that re-emits the already-read bytes
- * followed by the rest of the original body. If the body ends before any
- * meaningful output is seen, `meaningful` is false and the caller replays the
- * whole request (empty / thought-only recovery) without ever buffering a large
- * response: the original `drainQoderResponse` read the entire stream before
- * forwarding, which made every stream appear to complete in one burst at the
- * end.
- */
-async function sniffQoderStream(
-  response: Response,
-  signal: AbortSignal,
-): Promise<{ meaningful: boolean; response: Response }> {
-  const body = response.body;
-  if (body === null) return { meaningful: true, response };
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  const pending: Uint8Array[] = [];
-  let inspected = "";
-  let meaningful = false;
-  for (let i = 0; i < 32 && !meaningful; i += 1) {
-    const { done, value } = await reader.read();
-    if (signal.aborted) break;
-    if (done) break;
-    pending.push(value);
-    inspected += decoder.decode(value, { stream: true });
-    // Peek at completed SSE frames only: a content delta or a tool-call
-    // fragment means real output is coming. Reasoning-only streams are NOT
-    // meaningful (they are exactly what empty-stream recovery replays), and a
-    // finish reason alone is not output either.
-    if (/data:/.test(inspected)) {
-      for (const frame of inspected.split(/\r?\n\r?\n/)) {
-        if (!frame.includes("data:")) continue;
-        if (frame.includes('"content":"') || frame.includes('"tool_calls"')) {
-          meaningful = true;
-          break;
-        }
-      }
-    }
-    if (inspected.length > 65536) {
-      meaningful = true;
-      break;
-    }
-  }
-  // Replay: previously-read bytes first, then continue the original body.
-  let offset = 0;
-  const replay = new ReadableStream<Uint8Array>({
-    start(controller) {
-      for (; offset < pending.length; offset += 1) controller.enqueue(pending[offset]);
-    },
-    async pull(controller) {
-      if (offset < pending.length) {
-        controller.enqueue(pending[offset]);
-        offset += 1;
-        return;
-      }
-      const { done, value } = await reader.read();
-      if (signal.aborted) {
-        controller.close();
-        return;
-      }
-      if (done) {
-        controller.close();
-        return;
-      }
-      controller.enqueue(value);
-    },
-    cancel(reason) {
-      return reader.cancel(reason);
-    },
-  });
-  return { meaningful, response: new Response(replay, response) };
-}
-
-/**
- * Runs the IDE request up to `1 + maxReplays` times, returning the first
- * response whose stream carried real output (text or tool calls). A 200 with
- * no output (empty or thought-only) is replayed rather than surfaced. The
- * stream is forwarded progressively (not buffered to completion).
- */
-async function fetchQoderIdeWithEmptyRecovery(
-  requestOnce: () => Promise<Response>,
-  signal: AbortSignal,
-  maxReplays = 2,
-): Promise<Response> {
-  let last: Response | undefined;
-  for (let attempt = 0; attempt <= maxReplays; attempt += 1) {
-    const res = await requestOnce();
-    if (!res.ok || !res.body) return res;
-    const sniff = await sniffQoderStream(res, signal);
-    last = sniff.response;
-    if (sniff.meaningful) return last;
-  }
-  return last!;
-}
-
-export { fetchQoderIdeWithEmptyRecovery };

package/src/providers/integrations/qoder/qoder.ts

@@ -42,7 +42,6 @@ export {
   buildQoderIdeRequest,
   qoderBodyToCanonicalEvents,
   qoderEnvelopeToFrames,
-  fetchQoderIdeWithEmptyRecovery,
 } from "./qoder-ide";
 
 // gRPC transport

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

@@ -187,7 +187,7 @@ export function buildTraeChatBody(
     }
     const parts: TraeContentPart[] = [];
     const toolCalls: TraeToolCall[] = [];
-    let toolResult: { callId: string; text: string } | undefined;
+    const toolResults: Array<{ callId: string; text: string }> = [];
     for (const part of message.content) {
       if (part.kind === "toolCall") {
         toolCalls.push({
@@ -198,7 +198,7 @@ export function buildTraeChatBody(
         continue;
       }
       if (part.kind === "toolResult") {
-        toolResult = { callId: part.call_id, text: toolResultText(part.content) };
+        toolResults.push({ callId: part.call_id, text: toolResultText(part.content) });
         continue;
       }
       const mapped = toTraePart(part);
@@ -207,15 +207,19 @@ export function buildTraeChatBody(
 
     // A tool answer becomes its own `tool` turn, which is the only shape
     // upstream accepts for it — leaving it inside the assistant turn is
-    // rejected as a broken tool sequence.
-    if (toolResult !== undefined) {
+    // rejected as a broken tool sequence. One turn per result: a message
+    // whose content carries multiple `toolResult` parts (parallel tool calls)
+    // must emit one `tool` turn per call id, or upstream rejects the missing
+    // ones with `tool call failed: … No tool output found for function call
+    // <id>`.
+    for (const toolResult of toolResults) {
       messages.push({
         role: "tool",
         content: [{ type: "text", text: toolResult.text }],
         tool_call_id: toolResult.callId,
       });
-      continue;
     }
+    if (toolResults.length > 0) continue;
     // Empty turns are skipped: upstream rejects them, and emitting
     // `content: ""` turns leaves a ghost turn in the conversation.
     if (parts.length === 0 && toolCalls.length === 0) continue;