cartethyia 2.7.3 → 2.7.4

package/src/providers/integrations/inferhub.ts

@@ -1,6 +1,7 @@
 // Hybrid: the Messages-wire leg (`InferhubMessagesAdapter`, Claude Messages
 // envelope + Bearer auth + breakpoint cache stamping) is a non-OpenAI wire and
 // stays bespoke; the chat leg is a declarative spec row.
+import { assertCredentialKind, assertWireFamily } from "../provider-contracts";
 import type { ProviderDispatchTarget, ProviderAdapter, ProviderDispatchContext } from "../provider-contracts";
 import type { ModelDefinition } from "../provider-model-definition";
 import type { ProviderModelDiscovery } from "../discovery/discovery-types";
@@ -326,21 +327,13 @@ export class InferhubMessagesAdapter implements ProviderAdapter {
     context: ProviderDispatchContext,
   ): AsyncIterable<CanonicalEvent> {
     if (candidate.wire_family !== "messages") {
-      throw new GatewayError(
-        "capability_unsupported",
-        400,
-        `inferhub messages leg supports messages only, got ${candidate.wire_family}`,
-      );
+      assertWireFamily(candidate, "messages", "inferhub messages leg");
     }
     if (context.credential.credential_kind !== "api_key") {
-      throw new GatewayError(
-        "invalid_request",
-        400,
-        `inferhub: api_key credential required (got credential_kind=${context.credential.credential_kind})`,
-      );
+      assertCredentialKind(context.credential, "api_key", "inferhub");
     }
     if (context.credential.secret === undefined || context.credential.secret.length === 0) {
-      throw new GatewayError("invalid_request", 400, "inferhub: API key is missing a secret value");
+      throw new GatewayError("invalid_request", 400, "inferhub: API key is missing a secret value (request {requestId}). Wrong key, right door — check the key 🔑");
     }
     const apiKey = new TextDecoder().decode(context.credential.secret);
     const customHeaders = filterClaudeCustomHeaders({

package/src/providers/integrations/kimi/kimi.ts

@@ -26,6 +26,7 @@ import {
 } from "../../../protocol/request/messages";
 import { sendClaudeMessagesRequest } from "../../../protocol/upstream/send-claude-messages";
 import { endpointUrl } from "../../../protocol/codecs";
+import { assertCredentialKind, assertWireFamily } from "../../provider-contracts";
 import type { ProviderDispatchTarget, ProviderAdapter, ProviderDispatchContext } from "../../provider-contracts";
 import {
   getKimiCommonHeaders,
@@ -141,24 +142,16 @@ class KimiCodeAdapter implements ProviderAdapter {
     context: ProviderDispatchContext,
   ): AsyncIterable<CanonicalEvent> {
     if (candidate.wire_family !== "messages") {
-      throw new GatewayError(
-        "capability_unsupported",
-        400,
-        `kimi supports messages only, got ${candidate.wire_family}`,
-      );
+      assertWireFamily(candidate, "messages", "kimi");
     }
     if (context.credential.credential_kind !== "oauth") {
-      throw new GatewayError(
-        "invalid_request",
-        400,
-        `kimi: OAuth credential required (got credential_kind=${context.credential.credential_kind})`,
-      );
+      assertCredentialKind(context.credential, "oauth", "kimi");
     }
     if (!context.credential.secret) {
       throw new GatewayError(
         "authentication_failed",
         401,
-        "kimi: OAuth credential secret is required",
+        "kimi: OAuth credential secret is required (request {requestId}). Wrong key, right door — check the credential 🔑",
       );
     }
     const credential = parseKimiCredential(

package/src/providers/integrations/kiro/kiro.ts

@@ -344,7 +344,7 @@ class KiroAdapter implements ProviderAdapter {
       ? new TextDecoder().decode(context.credential.secret).trim()
       : "";
     if (secret.length === 0) {
-      throw new GatewayError("authentication_failed", 401, "Missing Kiro credential", {
+      throw new GatewayError("authentication_failed", 401, "Missing Kiro credential (request {requestId}). Wrong key, right door — check the credential 🔑", {
         providerId: KIRO_PROVIDER_ID,
       });
     }
@@ -381,7 +381,7 @@ class KiroAdapter implements ProviderAdapter {
       throw new GatewayError(
         "invalid_request",
         400,
-        "Kiro cannot accept this conversation",
+        "Kiro cannot accept this conversation (request {requestId}). Check the shape of what you sent — then resend 🪞",
         { providerId: KIRO_PROVIDER_ID, problems: built.error.problems },
       );
     }
@@ -398,7 +398,7 @@ class KiroAdapter implements ProviderAdapter {
       machineId,
     );
     if (!response.body) {
-      throw new GatewayError("platform_unavailable", 502, "Kiro returned an empty body", {
+      throw new GatewayError("platform_unavailable", 502, "Kiro returned an empty body (request {requestId}). The upstream came back empty-handed — retry 🌙", {
         providerId: KIRO_PROVIDER_ID,
       }, "upstream");
     }
@@ -433,14 +433,14 @@ class KiroAdapter implements ProviderAdapter {
       });
     } catch (error) {
       if (error instanceof Error && error.name === "AbortError") {
-        throw new GatewayError("transport_closed", 499, "request was cancelled", {
+        throw new GatewayError("transport_closed", 499, "The request was cancelled (request {requestId}). Send it again whenever ready 🙃", {
           providerId: KIRO_PROVIDER_ID,
         });
       }
       throw new GatewayError(
         "transport_unavailable",
         502,
-        `Kiro transport failed: ${error instanceof Error ? error.message : String(error)}`,
+        `Kiro transport failed (request {requestId}): ${error instanceof Error ? error.message : String(error)}. The connection ghosted us — come back in a moment 👻`,
         { providerId: KIRO_PROVIDER_ID },
         "network",
       );
@@ -484,7 +484,7 @@ class KiroAdapter implements ProviderAdapter {
             throw new GatewayError(
               "platform_unavailable",
               502,
-              "Kiro EventStream exceeded the buffer bound",
+              "Kiro EventStream exceeded the buffer bound (request {requestId}). The upstream sent more than we can hold — retry 🌙",
               { providerId: KIRO_PROVIDER_ID },
               "upstream",
             );
@@ -497,7 +497,7 @@ class KiroAdapter implements ProviderAdapter {
           throw new GatewayError(
             "platform_unavailable",
             502,
-            `Kiro EventStream is corrupt: ${decoded.failure.detail}`,
+            `Kiro EventStream is corrupt: ${decoded.failure.detail} (request {requestId}). The upstream sent something we can't read — retry 🌙`,
             { providerId: KIRO_PROVIDER_ID, reason: decoded.failure.reason },
             "upstream",
           );
@@ -506,7 +506,7 @@ class KiroAdapter implements ProviderAdapter {
         for (const message of decoded.messages) {
           const outcome = decoder.decode(message);
           if (outcome.failure !== undefined) {
-            throw new GatewayError("platform_unavailable", 502, outcome.failure.message, {
+            throw new GatewayError("platform_unavailable", 502, `${outcome.failure.message} (request {requestId}). The upstream came back empty-handed — retry 🌙`, {
               providerId: KIRO_PROVIDER_ID,
             }, "upstream");
           }
@@ -578,14 +578,14 @@ class KiroAdapter implements ProviderAdapter {
       await reader.cancel().catch(() => undefined);
       if (error instanceof GatewayError) throw error;
       if (error instanceof Error && error.name === "AbortError") {
-        throw new GatewayError("transport_closed", 499, "request was cancelled", {
+        throw new GatewayError("transport_closed", 499, "The request was cancelled (request {requestId}). Send it again whenever ready 🙃", {
           providerId: KIRO_PROVIDER_ID,
         });
       }
       throw new GatewayError(
         "platform_unavailable",
         502,
-        `Kiro stream failed: ${error instanceof Error ? error.message : String(error)}`,
+        `Kiro stream failed (request {requestId}): ${error instanceof Error ? error.message : String(error)}. The upstream came back empty-handed — retry 🌙`,
         { providerId: KIRO_PROVIDER_ID },
         "upstream",
       );

package/src/providers/integrations/muse/muse.ts

@@ -22,6 +22,7 @@ import type { CanonicalRequest } from "../../../protocol/canonical-model";
 import { GatewayError } from "../../../protocol/gateway-error";
 import { decodeMuseCredential } from "../../../security/credential-codec";
 import { OpenAICompatibleAdapter, withBearerAuthentication } from "../../adapters/compatible-adapter";
+import { assertCredentialKind } from "../../provider-contracts";
 import type { ProviderDispatchTarget, ProviderDispatchContext, ResolvedCredential } from "../../provider-contracts";
 import { providerBaseUrl } from "../../provider-metadata";
 
@@ -85,19 +86,19 @@ export function parseMuseCodeCredential(
     // as before the extraction.
     const message = error instanceof Error ? error.message : "";
     if (message.endsWith("must be a JSON object")) {
-      throw new GatewayError("invalid_request", 400, "muse: credential must be a JSON object");
+      throw new GatewayError("invalid_request", 400, "muse: credential must be a JSON object (request {requestId}). Wrong key, right door — check the credential 🔑");
     }
     if (message.endsWith("is not a valid JSON blob")) {
       throw new GatewayError(
         "invalid_request",
         400,
-        "muse: credential is not a valid JSON blob; sign in again",
+        "muse: credential is not a valid JSON blob (request {requestId}); sign in again. Wrong key, right door — check the credential 🔑",
       );
     }
     throw new GatewayError(
       "authentication_failed",
       401,
-      "muse: credential is missing oauthAccessToken or apiKey; sign in again",
+      "muse: credential is missing oauthAccessToken or apiKey (request {requestId}); sign in again. Wrong key, right door — check the credential 🔑",
     );
   }
 }
@@ -137,17 +138,13 @@ class MuseCodeAdapter extends OpenAICompatibleAdapter {
     candidate: ProviderDispatchTarget,
   ): Promise<Record<string, string>> {
     if (context.credential.credential_kind !== "oauth") {
-      throw new GatewayError(
-        "invalid_request",
-        400,
-        `muse: OAuth credential required (got credential_kind=${context.credential.credential_kind})`,
-      );
+      assertCredentialKind(context.credential, "oauth", "muse");
     }
     if (!context.credential.secret) {
       throw new GatewayError(
         "authentication_failed",
         401,
-        "muse: OAuth credential secret is required",
+        "muse: OAuth credential secret is required (request {requestId}). Wrong key, right door — check the credential 🔑",
       );
     }
     const { apiKey } = decodeMuseCredential(context.credential.secret);

package/src/providers/integrations/perplexity.ts

@@ -69,11 +69,11 @@ export function createPerplexityAdapter(fetchImpl?: typeof fetch): ProviderAdapt
       void _candidate;
       const query = extractSearchQuery(request);
       if (!query) {
-        throw new GatewayError("invalid_request", 400, "Search query is required.");
+        throw new GatewayError("invalid_request", 400, "Search query is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
       }
       const token = tokenFromContext(context);
       if (!token) {
-        throw new GatewayError("authentication_failed", 401, "Missing Perplexity API key");
+        throw new GatewayError("authentication_failed", 401, "Missing Perplexity API key (request {requestId}). Wrong key, right door — check the key 🔑");
       }
 
       const fetchFn = (context.outbound_fetch as unknown as typeof fetch | undefined) ?? fetchImpl ?? globalThis.fetch;

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

@@ -133,13 +133,15 @@ export const QODER_INTL_MODEL_CONFIGS: Readonly<Record<string, QoderModelConfig>
   qfmodel: { id: "qfmodel", display_name: "Qwen3.8-Flash", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_free: true, is_reasoning: true },
   qmodel_latest: { id: "qmodel_latest", display_name: "Qwen3.7-Max", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_reasoning: false },
   qmodel: { id: "qmodel", display_name: "Qwen3.7-Plus", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_reasoning: false },
-  kmodel_latest: { id: "kmodel_latest", display_name: "Kimi-K3", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_free: false, is_reasoning: false },
+  kmodel_latest: { id: "kmodel_latest", display_name: "Kimi-K3.1-Pro", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_free: false, is_reasoning: false },
   kmodel: { id: "kmodel", display_name: "Kimi-K2.8-Preview", max_input_tokens: 1000000, max_output_tokens: 65_536, is_vl: true, is_free: false, is_reasoning: false },
   gmodel: { id: "gmodel", display_name: "GLM-5.3", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_free: false, is_reasoning: true },
   gfmodel: { id: "gfmodel", display_name: "GLM-5.3-Flash", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_reasoning: true },
   dmodel: { id: "dmodel", display_name: "DeepSeek-V4-Pro", max_input_tokens: 1000000, max_output_tokens: 384_000, is_vl: true, is_free: false, is_reasoning: true },
-  dfmodel: { id: "dfmodel", display_name: "DeepSeek-Flash", max_input_tokens: 1000000, max_output_tokens: 384_000, is_vl: true, is_free: true, is_reasoning: true },
-  mmodel: { id: "mmodel", display_name: "MiniMax-M3", max_input_tokens: 1000000, max_output_tokens: 512_000, is_vl: true, is_free: false, is_reasoning: false },
+  // Live roster (2026-11-01) reports dfmodel as billed (is_free false); it was
+  // previously marked free. Display names are corrected from the same capture.
+  dfmodel: { id: "dfmodel", display_name: "DeepSeek-Flash", max_input_tokens: 1000000, max_output_tokens: 384_000, is_vl: true, is_free: false, is_reasoning: true },
+  mmodel: { id: "mmodel", display_name: "MiniMax-M3.1-Flash", max_input_tokens: 1000000, max_output_tokens: 512_000, is_vl: true, is_free: false, is_reasoning: false },
 };
 
 /**
@@ -353,6 +355,14 @@ interface CachedRoster {
 /** Per-realm live-list cache; keyed by realm, not by account. */
 const discoveryCache = new Map<QoderRealm, CachedRoster>();
 
+/**
+ * Per-realm max-context window per roster key, taken from the live list's
+ * `context_config` (the widest selectable window). This is what dispatch reads
+ * to send `model_config.max_input_tokens`; without it the request would use the
+ * static roster's *currently active* window (often 180k) instead of the max.
+ */
+const discoveryMaxContextByKey = new Map<QoderRealm, Map<string, number>>();
+
 /**
  * Drops one realm's cached list.
  *
@@ -361,8 +371,21 @@ const discoveryCache = new Map<QoderRealm, CachedRoster>();
  * previous assertion left behind.
  */
 export function resetQoderDiscoveryCache(realm?: QoderRealm): void {
-  if (realm === undefined) discoveryCache.clear();
-  else discoveryCache.delete(realm);
+  if (realm === undefined) {
+    discoveryCache.clear();
+    discoveryMaxContextByKey.clear();
+  } else {
+    discoveryCache.delete(realm);
+    discoveryMaxContextByKey.delete(realm);
+  }
+}
+
+/**
+ * The widest selectable context window per roster key for one realm, from the
+ * live model list. Empty when discovery has not succeeded for that realm yet.
+ */
+export function qoderDiscoveredMaxContexts(realm: QoderRealm): ReadonlyMap<string, number> {
+  return discoveryMaxContextByKey.get(realm) ?? new Map();
 }
 
 export async function discoverQoderModels(input: {
@@ -389,7 +412,7 @@ export async function discoverQoderModels(input: {
     throw new GatewayError(
       "authentication_failed",
       401,
-      "Qoder model discovery requires an account credential.",
+      "Qoder model discovery requires an account credential (request {requestId}). Wrong key, right door — check the credential 🔑",
       { providerId, realm: input.realm },
     );
   }
@@ -398,7 +421,7 @@ export async function discoverQoderModels(input: {
     throw new GatewayError(
       "invalid_request",
       400,
-      "Qoder model discovery requires a validated outbound fetch",
+      "Qoder model discovery requires a validated outbound fetch (request {requestId}). No bridge to cross — configure a pool first 🏗️",
       { providerId, realm: input.realm },
     );
   }
@@ -409,6 +432,11 @@ export async function discoverQoderModels(input: {
     const url = `${host}${QODER_MODELS_PATH}`;
     try {
       const headers = await input.headers(url, signedBody);
+      // GET, not POST: upstream refuses POST on the model-list surface (400
+      // "Request method 'POST' not supported"). The signature covers the body,
+      // so the body must accompany the GET. The gateway's validated egress
+      // dials GET+body through the Node http(s) client (the runtime fetch
+      // rejects GET bodies), which is exactly the shape the donor client sends.
       const response = await fetcher(url, {
         method: "GET",
         headers: headers as unknown as HeadersInit,
@@ -430,9 +458,19 @@ export async function discoverQoderModels(input: {
         continue;
       }
       const models = enabled.map((entry) => qoderCatalogModel(entry, providerId));
+      // Index the widest selectable window per key (from `context_config`,
+      // already computed into `maxInputTokens` by `mapQoderCatalogResponse`) so
+      // dispatch can send the maximum rather than the currently active one.
+      const maxCtx = new Map<string, number>();
+      for (const entry of enabled) {
+        if (entry.maxInputTokens !== undefined && entry.key.length > 0) {
+          maxCtx.set(entry.key, entry.maxInputTokens);
+        }
+      }
       // Cached only after a host actually answered: a failure must stay
       // retryable on the next call rather than being frozen for five minutes.
       discoveryCache.set(input.realm, { at: Date.now(), models });
+      discoveryMaxContextByKey.set(input.realm, maxCtx);
       return models;
     } catch (error) {
       lastError = error;
@@ -441,9 +479,9 @@ export async function discoverQoderModels(input: {
   throw new GatewayError(
     "transport_unavailable",
     502,
-    `Qoder model discovery failed for ${input.realm}: ${
+    `Qoder model discovery failed for ${input.realm} (request {requestId}): ${
       lastError instanceof Error ? lastError.message : "unknown error"
-    }`,
+    }. The connection ghosted us — come back in a moment 👻`,
     { providerId, realm: input.realm },
     "upstream",
   );

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

@@ -175,15 +175,18 @@ async function tryClaimDaily(
   if (campaigns === null) {
     return { state: "error", amount: 0, error: "Campaign list unavailable." };
   }
-  for (const campaign of campaigns) {
+  // Claim a `CLAIMABLE` CREDITS-kind campaign. Promo rows (`VIEW_DETAILS`,
+  // no benefit) are not credit grants and must not be claimed — claiming one
+  // spends the account's daily slot for nothing and makes the sweep report a
+  // misleading `claimed` with 0 credits.
+  const claimable = campaigns.filter((c) => {
+    if (String(c["claim_status"] ?? "").toUpperCase() !== "CLAIMABLE") return false;
+    const kind = String(asRecord(c["benefit"])?.["kind"] ?? "").toUpperCase();
+    const action = String(c["action_type"] ?? "").toUpperCase();
+    return kind === "CREDITS" || action === "CLAIM_BENEFIT";
+  });
+  for (const campaign of claimable) {
     const benefit = asRecord(campaign["benefit"]);
-    const kind = String(benefit?.["kind"] ?? "").toUpperCase();
-    if (kind !== "CREDITS" && kind !== "") continue;
-    const actionType = String(campaign["action_type"] ?? "");
-    if (actionType !== "" && actionType !== "CLAIM_BENEFIT") continue;
-    const claimStatus = String(campaign["claim_status"] ?? "").toUpperCase();
-    if (claimStatus === "CLAIMED") return { state: "already_claimed", amount: 0, error: null };
-    if (claimStatus !== "CLAIMABLE") continue;
     const campaignId = String(campaign["campaign_id"] ?? "");
     if (!campaignId) continue;
     const claim = await claimWithHeaders(base, campaignId, headers, fetcher);
@@ -195,6 +198,18 @@ async function tryClaimDaily(
     if (claim.state === "not_eligible") return { state: "not_eligible", amount: 0, error: null };
     return { state: "error", amount: 0, error: "Campaign claim failed." };
   }
+  // Nothing claimable. Only a CREDITS-kind campaign that is `CLAIMED` proves
+  // today's credit was already taken; a claimed promo (`VIEW_DETAILS`, no
+  // benefit) says nothing about the daily grant, so it must not be reported
+  // as already_claimed. When the CREDITS campaign is absent entirely, the
+  // daily grant is simply not present (or hidden) for this account.
+  const anyCreditsClaimed = campaigns.some((c) => {
+    if (String(c["claim_status"] ?? "").toUpperCase() !== "CLAIMED") return false;
+    const kind = String(asRecord(c["benefit"])?.["kind"] ?? "").toUpperCase();
+    const action = String(c["action_type"] ?? "").toUpperCase();
+    return kind === "CREDITS" || action === "CLAIM_BENEFIT";
+  });
+  if (anyCreditsClaimed) return { state: "already_claimed", amount: 0, error: null };
   return { state: "unavailable", amount: 0, error: "No daily CREDITS campaign claimable." };
 }
 
@@ -224,6 +239,9 @@ async function probeDailyClaim(
 ): Promise<{ result: { state: DailyCheckinState; amount: number; error: string | null }; identity: QoderNativeIdentity | null }> {
   const basic = await tryClaimDaily(base, campaignHeaders(credential), fetcher);
   if (basic.state === "claimed" || basic.state === "already_claimed") {
+    // `tryClaimDaily` only claims CREDITS-kind campaigns, so a `claimed` or
+    // `already_claimed` basic result is already about the daily credit grant —
+    // terminal, no identity probe needed.
     return { result: basic, identity: null };
   }
   if (basic.state === "unavailable") {

package/src/providers/integrations/qoder/qoder-native-identity-store.ts

@@ -2,15 +2,16 @@
  * Persistence for the Qoder native machine identity (UMID) bound to an
  * account.
  *
- * The daily 100-credit check-in grant is device-scoped upstream, and the
- * server accepts only genuine, non-VM device identities. A device identity is
- * a deterministic function of a seed file (`~/.config/.locale_cfg`), so each
- * account gets its own minted seed — its own "device". The bound record lives
- * in `provider_accounts.native_identity` (plain JSON, not a secret).
+ * Same-account probes found that daily 100-credit grant visibility does not
+ * depend on machine headers. This store preserves native identities and seeds
+ * for deterministic replay and other surfaces that may use device identity.
+ * A native identity is a deterministic function of a seed file
+ * (`~/.config/.locale_cfg`). The bound record lives in
+ * `provider_accounts.native_identity` (plain JSON, not a secret).
  *
  * Uniqueness of the device is enforced by the partial unique index on the
- * extracted `machineToken`; this store keeps the JS side of that invariant
- * and surfaces the DB constraint as the backstop.
+ * extracted `machineToken`; this store keeps the JS side of that internal
+ * identity-allocation invariant and surfaces the DB constraint as the backstop.
  */
 import { and, eq, isNotNull, ne } from "drizzle-orm";
 import type { CartethyiaDatabase } from "../../../persistence/db-handle";
@@ -30,7 +31,7 @@ export interface QoderNativeIdentityStore {
   get(providerId: string, accountId: string): Promise<NativeIdentityRecord | undefined>;
   /**
    * Machine tokens already bound to **other** accounts, so a caller can mint
-   * a fresh device without colliding. A bound token is a physical device, and
+   * a fresh identity without colliding. A bound token represents a device identity, and
    * the unique index that backs this spans all `provider_accounts` rows. The
    * account's own bound token is not "occupied" — reusing one's own device is
    * the point.

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

@@ -39,6 +39,21 @@ export const QODER_CHAT_PATH =
   "/algo/api/v2/service/pro/sse/agent_chat_generation?FetchKeys=llm_model_result&AgentId=agent_common&Encode=1";
 export const QODER_MODELS_PATH = "/algo/api/v2/model/list?Encode=1";
 
+/**
+ * The modern model-server surface used by the IDE / QoderWake (OpenAI-shaped
+ * chunks, plain bearer auth). This surface streams immediately — the legacy
+ * `/algo` chat endpoint answers `10605 isQueued` and parks requests in a
+ * server-side queue, so dispatch prefers this surface when it is available.
+ */
+export const QODER_IDE_CHAT_PATH = "/model/v1/chat/completions";
+
+/** The model-server host for one realm (intl: `api2-v2`, cn: gateway). */
+export function qoderIdeChatUrl(realm: QoderRealm): string {
+  return realm === "cn"
+    ? `https://gateway.qoder.com.cn${QODER_IDE_CHAT_PATH}`
+    : `https://api2-v2.qoder.sh${QODER_IDE_CHAT_PATH}`;
+}
+
 /**
  * Realm → deployment.
  *

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

@@ -1,11 +1,10 @@
 /**
  * Qoder native machine identity (UMID) — the genuine SG bridge via umidpack.
  *
- * Research record (2026-10-30): the daily-credit campaign gates its CREDITS
- * grant on a *genuine* Alibaba SG-produced identity. Deterministic/generated
- * tokens do not reveal the grant on a fresh account; the `runtime-info`
- * bridge does. Primary path therefore runs the real bridge binary from
- * `vendor/qoder-umid/umidpack/`, auto-picked per host OS.
+ * Research record (2026-10-30): same-account controls found that the daily
+ * CREDITS campaign does not gate grants on machine identity. This module
+ * prefers the vendor bridge for stable native identity and seed replay, with
+ * a deterministic generated fallback when no bridge is available.
  *
  * Seed semantics (verified live): the Linux ELF resolves the user home via
  * the passwd entry — it ignores `$HOME`/`XDG_CONFIG_HOME`, so the seed file
@@ -18,15 +17,14 @@
  *
  * Platform behavior:
  *   win32  — the exe is hardware-bound: one identity per machine, no seed.
- *            Still a genuine SG identity (accepted by the campaign surface).
  *   linux  — direct spawn of the umidpack ELF, serialized seed file.
  *   darwin — the Mach-O runs directly; seed path is the macOS user home.
  *   win32 + WSL (this repo's primary deployment) — the ELF runs via WSL with
  *            flock serialization; the bridge binary is staged into /tmp once.
  *
- * The generated path remains a fallback for hosts with no usable bridge: it
- * produces well-shaped but *not* SG-signed tokens — fine for non-campaign
- * endpoints, will not surface the daily grant.
+ * The generated path remains a fallback for hosts with no usable bridge. It
+ * produces deterministic, well-shaped tokens but is not an SG identity. Live
+ * controls showed that machine identity does not gate daily CREDITS grants.
  *
  * Bridge CLI (donor-verified):
  *   linux : runtime-info <env>
@@ -155,15 +153,16 @@ function seedPath(): string {
 }
 
 /**
- * Mints a fresh genuine identity: wipe the seed (under the lock), run the
+ * Mints a fresh native identity: wipe the seed (under the lock), run the
  * bridge, capture the identity AND the seed it wrote. The seed is required
- * for later replay of this same identity. Returns `null` when the bridge
- * fails; falls back to the generated identity only when no bridge exists.
+ * for later replay of this same native identity. Returns `null` when the
+ * bridge fails; falls back to the generated identity only when no bridge
+ * exists.
  */
 export function mintQoderNativeIdentity(accountId: string): { identity: QoderNativeIdentity; seed: string } | null {
   const bridge = pickBridge();
   if (!bridge) {
-    log.warn("[qoder] no genuine bridge for this host — generated fallback (campaign grant will not surface)");
+    log.warn("[qoder] no native bridge for this host — using generated identity fallback");
     return { identity: mintQoderGeneratedIdentity(accountId), seed: "" };
   }
 

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

@@ -37,11 +37,11 @@ export const QODER_VIRTUAL_MODELS: readonly QoderVirtualModel[] = [
   { id: "qwen3.8-flash", target: "qfmodel", displayName: "Qwen3.8-Flash" },
   { id: "qwen3.7-max", target: "qmodel_latest", displayName: "Qwen3.7-Max" },
   { id: "qwen3.7-plus", target: "qmodel", displayName: "Qwen3.7-Plus" },
-  { id: "kimi-k3", target: "kmodel_latest", displayName: "Kimi-K3" },
+  { id: "kimi-k3", target: "kmodel_latest", displayName: "Kimi-K3.1-Pro" },
   { id: "kimi-k2.8-preview", target: "kmodel", displayName: "Kimi-K2.8-Preview" },
   { id: "glm-5.3", target: "gmodel", displayName: "GLM-5.3" },
   { id: "glm-5.3-flash", target: "gfmodel", displayName: "GLM-5.3-Flash" },
-  { id: "minimax-m3", target: "mmodel", displayName: "MiniMax-M3" },
+  { id: "minimax-m3", target: "mmodel", displayName: "MiniMax-M3.1-Flash" },
 ];
 
 /** Virtual id → roster key. */