cartethyia 2.5.9 → 2.6.0

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

@@ -159,8 +159,21 @@ export const TRAE_REALMS: Readonly<Record<TraeRealm, TraeRealmConfig>> = {
     modelListSupported: true,
   },
   intl: {
-    core: "https://core-normal.traeapi.us",
-    coreFallbacks: ["https://core-normal.trae.ai", "https://coresg-normal.trae.ai"],
+    // SG is the primary, not a fallback. Region-routing is a property of the
+    // account, not the deployment: an account provisioned into `sg` only
+    // authenticates against the SG host, and sending it to the US core answers
+    // `1001 "we are not able to authenticate you"`. Accounts with a captured
+    // region still resolve to their own host through `TRAE_REGION_CORE_HOSTS`,
+    // so moving the default only changes the answer for accounts whose region
+    // was never recorded — and SG serves the wider international roster, which
+    // makes it the better bet for those than US.
+    // Inlined rather than read from `TRAE_REGION_CORE_HOSTS` below: that map is
+    // declared after this one, and a `const` forward reference throws at module
+    // init. The value must stay identical to `TRAE_REGION_CORE_HOSTS.sg`.
+    core: "https://coresg-normal.trae.ai",
+    // US stays reachable as a fallback: an account that really is US-provisioned
+    // but has no stored region still has to have somewhere to land.
+    coreFallbacks: ["https://core-normal.traeapi.us", "https://core-normal.trae.ai"],
     account: "https://grow-normal.trae.ai",
     accountFallbacks: ["https://grow-normal.traeapi.us"],
     pay: "https://grow-normal.traeapi.us",

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

@@ -1,9 +1,8 @@
 // Trae adapter.
 //
 // Realm-aware: `trae` (intl) and `traecn` (CN) share this code but nothing of
-// the address, the authorization scheme, or the roster. The intl deployment
-// additionally gates on the *current* client version, which is why the version
-// here comes from `getTraeVersion()` (a live resolver) rather than a constant.
+// the address or the roster. Both realms authenticate with
+// `Authorization: Cloud-IDE-JWT <token>` per the Trae 1.107.1 bundle.
 
 import { GatewayError } from "../../../protocol/gateway-error";
 import type { CanonicalEvent, CanonicalRequest, CanonicalStopReason } from "../../../protocol/canonical-model";
@@ -16,7 +15,6 @@ import {
   type ProviderId,
 } from "../../provider-contracts";
 import { mapUpstreamHttpError } from "../../../transport/failure-policy";
-import { getTraeVersion } from "../../operations/client-versions";
 import { abortGatewayError, createUpstreamDeadlineLifecycle } from "../../operations/upstream-deadline";
 import { TRAE_CN_MODELS, TRAE_INTL_MODELS, traeMaxContextWindow } from "./trae-catalog";
 import { buildTraeHeaders } from "./trae-headers";
@@ -92,14 +90,6 @@ class TraeAdapter implements ProviderAdapter {
   readonly provider_id: ProviderId;
   private readonly realm: TraeRealm;
   private readonly fetchFn: typeof fetch;
-  /**
-   * Maps a frame's `index` to the call id seen for it.
-   *
-   * Argument fragments arrive without the id, so the association has to be
-   * remembered between frames rather than read from the fragment itself.
-   */
-  readonly #toolCallIds = new Map<string, string>();
-
   constructor(options: TraeAdapterOptions = {}) {
     this.provider_id = (options.providerId ?? TRAE_PROVIDER_ID) as ProviderId;
     this.realm = options.realm ?? "intl";
@@ -124,9 +114,6 @@ class TraeAdapter implements ProviderAdapter {
     const outboundFetch =
       (context.outbound_fetch as unknown as typeof fetch | undefined) ?? this.fetchFn;
 
-    // intl refuses a stale client version with 4015, so the resolved version is
-    // part of every request rather than a startup detail.
-    const version = getTraeVersion();
     const auth = traeAuth(secret, context.credential.account_id);
     const body = buildTraeChatBody(modelId, request, this.realm);
     /**
@@ -144,7 +131,6 @@ class TraeAdapter implements ProviderAdapter {
       realm: this.realm,
       token: auth.token,
       uid: auth.uid,
-      clientVersion: version,
       stream: true,
     });
 
@@ -192,6 +178,9 @@ class TraeAdapter implements ProviderAdapter {
     yield { type: "response_start", sequence_number: seq++, model: requestModel } as CanonicalEvent;
     let stopReason: CanonicalStopReason = "stop";
     let usage: Record<string, unknown> | undefined;
+    // Tool ids are scoped to one stream. Argument-only frames from a later
+    // request must never inherit an earlier request's id at the same index.
+    const toolCallIds = new Map<string, string>();
     /**
      * Tool calls arrive fragmented across frames and the id is not repeated.
      *
@@ -212,8 +201,12 @@ class TraeAdapter implements ProviderAdapter {
         continue;
       }
       if (frame.event === "error") {
-        const data = frame.data as { message?: unknown };
-        const message = typeof data.message === "string" ? data.message : "Trae stream error";
+        const data = frame.data as { message?: unknown; code?: unknown };
+        const message = typeof data.message === "string" && data.message.length > 0
+          ? data.message
+          : typeof data.code === "number" || typeof data.code === "string"
+            ? `Trae stream error (upstream code ${data.code})`
+            : "Trae stream error";
         throw new GatewayError("platform_unavailable", 502, message, {}, "upstream");
       }
       if (typeof frame.data !== "object" || frame.data === null) continue;
@@ -245,7 +238,7 @@ class TraeAdapter implements ProviderAdapter {
             content: { kind: "reasoning", payload: null, summary: flatReasoning },
           } as CanonicalEvent;
         }
-        yield* this.#toolCallDeltas(record["tool_calls"], announced, () => seq++);
+        yield* this.#toolCallDeltas(record["tool_calls"], announced, toolCallIds, () => seq++);
         if (typeof record["finish_reason"] === "string") {
           stopReason = STOP_REASONS[record["finish_reason"] as string] ?? "stop";
         }
@@ -277,8 +270,9 @@ class TraeAdapter implements ProviderAdapter {
         } as CanonicalEvent;
       }
       if (typeof payload["finish_reason"] === "string") {
-        stopReason = STOP_REASONS[payload["finish_reason"]] ?? "stop";
+        stopReason = STOP_REASONS[payload["finish_reason"] as string] ?? "stop";
       }
+      yield* this.#toolCallDeltas(payload["tool_calls"], announced, toolCallIds, () => seq++);
       if (typeof payload["usage"] === "object" && payload["usage"] !== null) {
         usage = payload["usage"] as Record<string, unknown>;
       }
@@ -311,6 +305,7 @@ class TraeAdapter implements ProviderAdapter {
   async *#toolCallDeltas(
     raw: unknown,
     announced: Set<string>,
+    toolCallIds: Map<string, string>,
     nextSeq: () => number,
   ): AsyncIterable<CanonicalEvent> {
     if (!Array.isArray(raw)) return;
@@ -326,7 +321,7 @@ class TraeAdapter implements ProviderAdapter {
       const slot = `idx:${index}`;
 
       if (declaredId.length > 0) {
-        this.#toolCallIds.set(slot, declaredId);
+        toolCallIds.set(slot, declaredId);
         // The closing frame repeats a known id with no payload; emitting it
         // again would append a duplicate empty call.
         if (announced.has(declaredId)) continue;
@@ -338,11 +333,11 @@ class TraeAdapter implements ProviderAdapter {
           name: name ?? "",
           arguments_delta: "",
         } as CanonicalEvent;
-        continue;
+        if (args.length === 0) continue;
       }
 
       if (args.length === 0) continue;
-      const id = this.#toolCallIds.get(slot);
+      const id = toolCallIds.get(slot);
       if (id === undefined) continue;
       yield {
         type: "tool_call_delta",
@@ -400,7 +395,10 @@ export async function discoverTraeModels(input: {
   readonly providerId?: string;
   /** Account region, so the listing is asked of the host that serves it. */
   readonly region?: string;
-}): Promise<readonly { id: string; ctx: number | undefined }[]> {
+}): Promise<readonly {
+  id: string;
+  ctx: number | undefined;
+}[]> {
   const headers = buildTraeHeaders({
     realm: input.realm,
     token: input.token,

package/src/providers/integrations/xiaomi-mimo/think-stream.ts

@@ -39,15 +39,40 @@ const CLOSE_TAGS = ["</thinking>", "</think>"] as const;
  * Both case variants pass through: `<Think>` and `<THINK>` survived everyone's
  * normalizer long enough for them not to be the leak this closes.
  */
+/**
+ * Removes visible thinking tags, leaving any that sit inside a code span or
+ * fence alone.
+ *
+ * A tag inside backticks is the *subject* of the answer — documentation or a
+ * code sample showing the tag — not markup the upstream leaked, so stripping it
+ * would silently rewrite the answer.
+ */
 export function stripThinkingTags(value: string): string {
   if (!value.includes("<")) return value;
-  // Both the open-close pair and a stray marker on its own: an upstream that
-  // dropped the opening tag before `reasoning_content` was committed still
-  // leaves the closing one behind, and the lone tag reads just as badly to the
-  // client as a paired one.
-  return value
-    .replace(/<think(?:ing)?\b[^>]*>/g, "")
-    .replace(/<\/think(?:ing)?\s*>/g, "");
+  const pattern = /<think(?:ing)?\b[^>]*>|<\/think(?:ing)?\s*>|`+/g;
+  let out = "";
+  let last = 0;
+  let ticks = 0;
+  for (const match of value.matchAll(pattern)) {
+    const text = match[0];
+    const index = match.index ?? 0;
+    if (text.startsWith("`")) {
+      // A fence and an inline span are both just "inside code" here: the
+      // distinguishing case (a newline closing an unterminated span) cannot
+      // affect a tag already indexed in a settled string.
+      if (ticks === 0) {
+        ticks = text.length;
+      } else if (text.length === ticks) {
+        ticks = 0;
+      }
+      continue;
+    }
+    // Inside code: keep the tag verbatim.
+    if (ticks > 0) continue;
+    out += value.slice(last, index);
+    last = index + text.length;
+  }
+  return out + value.slice(last);
 }
 
 /** The longest suffix of `text` that is a proper prefix of any tag. */
@@ -74,6 +99,14 @@ export interface ThinkSplit {
   readonly reasoning: string;
 }
 
+/** A tag match plus the code state at the match, so the caller commits it. */
+interface TagMatch {
+  readonly index: number;
+  readonly length: number;
+  readonly codeTicks: number;
+  readonly codeFenced: boolean;
+}
+
 /**
  * Splits one upstream text chunk into answer text and reasoning text.
  *
@@ -83,6 +116,14 @@ export interface ThinkSplit {
 export class MimoThinkSplitter {
   #buffer = "";
   #inReasoning = false;
+  /** Backtick run that opened the code span/fence we are inside; 0 when not in
+   *  code. A tag inside a code span is the *subject* of the answer — a doc or a
+   *  code sample mentioning `<think>` — not a delimiter, so it must survive
+   *  verbatim instead of splitting the stream. */
+  #codeTicks = 0;
+  /** Whether `#codeTicks` opened a fenced block (closes on its own line) rather
+   *  than an inline span. */
+  #codeFenced = false;
 
   /** Feeds a chunk; returns the text/reasoning split for everything settled. */
   push(chunk: string): ThinkSplit {
@@ -94,14 +135,14 @@ export class MimoThinkSplitter {
       if (!this.#inReasoning) {
         const opened = this.#findOpen();
         if (opened === undefined) break;
-        text += this.#buffer.slice(0, opened.index);
+        text += this.#consumeUpTo(opened);
         this.#buffer = this.#buffer.slice(opened.index + opened.length);
         this.#inReasoning = true;
         continue;
       }
       const closed = this.#findClose();
       if (closed === undefined) break;
-      reasoning += this.#buffer.slice(0, closed.index);
+      reasoning += this.#consumeUpTo(closed);
       this.#buffer = this.#buffer.slice(closed.index + closed.length);
       this.#inReasoning = false;
     }
@@ -125,29 +166,64 @@ export class MimoThinkSplitter {
   flush(): ThinkSplit {
     const rest = this.#buffer;
     this.#buffer = "";
+    this.#codeTicks = 0;
+    this.#codeFenced = false;
     return this.#inReasoning
       ? { text: "", reasoning: rest }
       : { text: stripThinkingTags(rest), reasoning: "" };
   }
 
-  #findOpen(): { index: number; length: number } | undefined {
-    let best: { index: number; length: number } | undefined;
-    for (const tag of OPEN_TAGS) {
-      const index = this.#buffer.indexOf(tag);
-      if (index === -1) continue;
-      if (best === undefined || index < best.index) best = { index, length: tag.length };
-    }
-    return best;
+  /** Returns the text before a tag and commits the code state at it. */
+  #consumeUpTo(match: TagMatch): string {
+    this.#codeTicks = match.codeTicks;
+    this.#codeFenced = match.codeFenced;
+    return this.#buffer.slice(0, match.index);
+  }
+
+  #findOpen(): TagMatch | undefined {
+    return this.#findTag(OPEN_TAGS);
+  }
+
+  #findClose(): TagMatch | undefined {
+    return this.#findTag(CLOSE_TAGS);
   }
 
-  #findClose(): { index: number; length: number } | undefined {
-    let best: { index: number; length: number } | undefined;
-    for (const tag of CLOSE_TAGS) {
-      const index = this.#buffer.indexOf(tag);
-      if (index === -1) continue;
-      if (best === undefined || index < best.index) best = { index, length: tag.length };
+  /**
+   * The earliest occurrence of any of `tags` that is *not* inside a code span
+   * or fence, scanning left to right so code state is tracked exactly once per
+   * position. Returns the match and the code state at it, so `push` can commit
+   * that state when it consumes the tag.
+   */
+  #findTag(tags: readonly string[]): TagMatch | undefined {
+    const buffer = this.#buffer;
+    let ticks = this.#codeTicks;
+    let fenced = this.#codeFenced;
+    for (let i = 0; i < buffer.length; i++) {
+      const char = buffer[i];
+      if (char === "`") {
+        let run = 1;
+        while (buffer[i + run] === "`") run++;
+        if (ticks === 0) {
+          ticks = run;
+          // Three or more backticks open a fence rather than an inline span.
+          fenced = run >= 3;
+        } else if (run === ticks) {
+          ticks = 0;
+          fenced = false;
+        }
+        i += run - 1;
+        continue;
+      }
+      // A newline closes an inline span that never closed on its own line; a
+      // fence runs to a closing line instead.
+      if (char === "\n" && ticks > 0 && !fenced) ticks = 0;
+      if (char !== "<" || ticks > 0) continue;
+      for (const tag of tags) {
+        if (!buffer.startsWith(tag, i)) continue;
+        return { index: i, length: tag.length, codeTicks: ticks, codeFenced: fenced };
+      }
     }
-    return best;
+    return undefined;
   }
 }
 

package/src/providers/integrations/zcode/oauth.ts

@@ -25,8 +25,8 @@
 import {
   nonEmptyTrimmedString,
   readJsonResponse,
-  record,
 } from "../../authentication/oauth-flow-store";
+import { asRecord as record } from "../../../shared/coerce";
 import type {
   OAuthAuthorizeRequest,
   OAuthExchangeResult,