cartethyia 2.7.2 → 2.7.3

package/src/persistence/stores/share-store.ts

@@ -155,7 +155,18 @@ export type SharedApiKeyIssueResult =
       readonly keyPrefix: string;
       readonly createdAt: Date;
     }
-  | { readonly kind: "link_unavailable" };
+  | { readonly kind: "link_unavailable" }
+  | {
+      readonly kind: "already_issued";
+      readonly parentKeyId: string;
+      readonly tenantId: string;
+    }
+  | {
+      readonly kind: "slot_full";
+      readonly parentKeyId: string;
+      readonly tenantId: string;
+      readonly limit: number;
+    };
 
 type ApiKeyRow = typeof apiKeys.$inferSelect;
 type ShareLinkRow = typeof shareLinks.$inferSelect;
@@ -485,6 +496,53 @@ export class DrizzleShareLinkStore implements ShareLinkStore {
       );
       if (!activeLink) return { kind: "link_unavailable" };
 
+      // One child key per canonical client IP. The public route mints from an
+      // enrollment link, and a bot replaying the same URL from one IP was
+      // creating an unbounded number of children (observed: 331k `api_keys`
+      // rows from two Google Cloud IPs in three days). If this (parent, IP)
+      // pair already has a live child, that is the same enrollment — return it
+      // as `already_issued` instead of minting another.
+      if (material.clientIpKey.length > 0) {
+        const existing = await tx
+          .select({ id: apiKeys.id })
+          .from(apiKeys)
+          .where(
+            and(
+              eq(apiKeys.parentKeyId, parent.id),
+              eq(apiKeys.issuedClientIpKey, material.clientIpKey),
+              isNull(apiKeys.revokedAt),
+            ),
+          )
+          .limit(1);
+        if (existing[0] !== undefined) {
+          return {
+            kind: "already_issued",
+            parentKeyId: parent.id,
+            tenantId: parent.tenantId,
+          };
+        }
+      }
+
+      // Slot cap: a template may bound how many concurrently-active children
+      // exist. The public link is mint-able by anyone, so without this cap a
+      // bot rotating egress IPs (CDN edges, cloud egress, proxies) could mint
+      // without bound — observed: 331k children in three days. The count is
+      // live children only; revoked children free their slot for reuse.
+      if (parent.maxChildren !== null && parent.maxChildren !== undefined) {
+        const liveCount = await tx
+          .select({ value: sql<number>`count(*) filter (where ${apiKeys.revokedAt} is null)` })
+          .from(apiKeys)
+          .where(eq(apiKeys.parentKeyId, parent.id));
+        if (Number(liveCount[0]?.value ?? 0) >= parent.maxChildren) {
+          return {
+            kind: "slot_full",
+            parentKeyId: parent.id,
+            tenantId: parent.tenantId,
+            limit: parent.maxChildren,
+          };
+        }
+      }
+
       // The label is `hint + random`, capped at 12 chars — never the
       // parent's full label plus a suffix, which grew past every table
       // column it rendered in. Built here (not imported from the console
@@ -493,6 +551,12 @@ export class DrizzleShareLinkStore implements ShareLinkStore {
       const suffix = randomInt(1000, 10_000).toString();
       const label =
         hint.length === 0 ? `key-${suffix}` : `${hint}-${suffix}`.slice(0, 12);
+      // Child rows carry identity + scopes only. Auth resolves every policy
+      // field from the parent (`policy = parent ?? row`), so copying notes,
+      // limits, model_list, denylist, etc. was pure write-amplification.
+      // Nullable policy columns stay NULL; `model_access_mode` takes its
+      // NOT NULL default ('whitelist'). Keep in sync with migration 0029 and
+      // `normalizeShareChildPolicy` in `src/console/backup/store.ts`.
       const [child] = await tx
         .insert(apiKeys)
         .values({
@@ -506,18 +570,6 @@ export class DrizzleShareLinkStore implements ShareLinkStore {
           scopes: parent.scopes,
           keyPrefix: material.keyPrefix,
           keyEncrypted: null,
-          notesTitle: parent.notesTitle,
-          notesSubtitle: parent.notesSubtitle,
-          notesBody: parent.notesBody,
-          requestsPerMinute: parent.requestsPerMinute,
-          dailyTokenLimit: parent.dailyTokenLimit,
-          monthlyTokenLimit: parent.monthlyTokenLimit,
-          lifetimeTokenBudget: parent.lifetimeTokenBudget,
-          maxConcurrentRequests: parent.maxConcurrentRequests,
-          modelPrefix: parent.modelPrefix,
-          modelAccessMode: parent.modelAccessMode,
-          modelList: parent.modelList,
-          clientRouterDenylist: parent.clientRouterDenylist,
           lifetimeTokensConsumed: 0,
         })
         .returning({ id: apiKeys.id, tenantId: apiKeys.tenantId, createdAt: apiKeys.createdAt });

package/src/persistence/stores/telemetry-store.ts

@@ -1,9 +1,10 @@
 import { readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
-import { sql } from "drizzle-orm";
+import { inArray, sql } from "drizzle-orm";
 import { affectedRows, currentTimestamp, laterOf } from "../dialect";
 import type { CartethyiaDatabase } from "../db-handle";
 import {
+  apiKeys,
   telemetryEvents,
   telemetryPayloads,
   telemetryUsageTotals,
@@ -117,6 +118,31 @@ export class DrizzleTelemetryStore {
     this.eventWriter = eventWriter;
   }
 
+  /**
+   * Resolves the share-template key for each distinct api key in a batch.
+   *
+   * The template is the key itself when it is a top-level template, or its
+   * parent when it is a minted child. The column is denormalized onto the
+   * event so family rollups do not depend on the key row surviving.
+   */
+  private async resolveFamilyTemplateIds(
+    rows: readonly (typeof telemetryEvents.$inferInsert)[],
+  ): Promise<Map<string, string>> {
+    const ids = [
+      ...new Set(
+        rows
+          .map((row) => row.apiKeyId)
+          .filter((id): id is string => typeof id === "string" && id.length > 0),
+      ),
+    ];
+    if (ids.length === 0) return new Map();
+    const resolved = await this.db
+      .select({ id: apiKeys.id, parentKeyId: apiKeys.parentKeyId })
+      .from(apiKeys)
+      .where(inArray(apiKeys.id, ids));
+    return new Map(resolved.map((row) => [row.id, row.parentKeyId ?? row.id]));
+  }
+
   /**
    * Applies usage deltas inside an enclosing transaction.
    *
@@ -137,11 +163,34 @@ export class DrizzleTelemetryStore {
       left.tenantId.localeCompare(right.tenantId)
       || left.identityType.localeCompare(right.identityType)
       || left.entityId.localeCompare(right.entityId));
+    // Resolve the share-template key for each api_key identity in the batch so
+    // the durable totals row carries it — family reads then survive the key
+    // row being deleted.
+    const apiKeyIds = [
+      ...new Set(
+        ordered
+          .filter((delta) => delta.identityType === "api_key")
+          .map((delta) => delta.entityId),
+      ),
+    ];
+    const familyTemplates = new Map<string, string>();
+    if (apiKeyIds.length > 0) {
+      const keyRows = await tx
+        .select({ id: apiKeys.id, parentKeyId: apiKeys.parentKeyId })
+        .from(apiKeys)
+        .where(inArray(apiKeys.id, apiKeyIds));
+      for (const row of keyRows) {
+        familyTemplates.set(row.id, row.parentKeyId ?? row.id);
+      }
+    }
     const now = new Date();
     await tx
       .insert(telemetryUsageTotals)
       .values(ordered.map((delta) => ({
         ...delta,
+        ...(delta.identityType === "api_key" && familyTemplates.has(delta.entityId)
+          ? { familyTemplateKeyId: familyTemplates.get(delta.entityId) }
+          : {}),
         requests: delta.requests,
         errors: delta.errors,
         inputTokens: delta.inputTokens,
@@ -171,6 +220,13 @@ export class DrizzleTelemetryStore {
     // The file accepts anything, so a malformed row would be written and then
     // retried forever without ever failing. Rejecting it here keeps the buffer's
     // drop-and-count contract: one bad row fails the batch, once.
+    const familyTemplates = await this.resolveFamilyTemplateIds(rows);
+    for (const row of rows) {
+      if (typeof row.apiKeyId === "string" && row.apiKeyId.length > 0) {
+        const template = familyTemplates.get(row.apiKeyId);
+        if (template !== undefined) row.familyTemplateKeyId = template;
+      }
+    }
     const unique: Array<typeof telemetryEvents.$inferInsert> = [];
     const ids = new Set<string>();
     for (const row of rows) {

package/src/persistence/system-prompt-store.ts

@@ -0,0 +1,104 @@
+// Persistence for tenant system-prompt injection settings.
+//
+// One row per tenant. Mutations bump the settings revision so the dispatch
+// path's revision-keyed reader converges immediately (same mechanism as the
+// runtime-preferences cache).
+import { eq } from "drizzle-orm";
+import type { CartethyiaDatabase } from "./db-handle";
+import { tenantSystemPrompts } from "./schema";
+import type {
+  ProviderPromptEntry,
+  PromptSetting,
+  TenantSystemPrompts,
+} from "../console/system-prompt/contracts";
+import {
+  EMPTY_TENANT_SYSTEM_PROMPTS,
+  SYSTEM_PROMPT_MODEL_LIMIT,
+  SYSTEM_PROMPT_PROVIDER_LIMIT,
+  isPromptSetting,
+  parseSystemPromptModelKey,
+} from "../console/system-prompt/contracts";
+import { bumpSettingsRevision } from "./settings-revision";
+
+/** The stored row, normalized. Absent row reads as the empty configuration. */
+export type StoredTenantSystemPrompts = TenantSystemPrompts;
+
+/**
+ * Reads the tenant's stored configuration, defensively normalized: a
+ * hand-edited or legacy row must not poison the dispatch path, so malformed
+ * entries are dropped rather than trusted.
+ */
+export async function readTenantSystemPrompts(
+  db: CartethyiaDatabase,
+  tenantId: string,
+): Promise<StoredTenantSystemPrompts> {
+  const rows = await db
+    .select({
+      global: tenantSystemPrompts.global,
+      providers: tenantSystemPrompts.providers,
+      models: tenantSystemPrompts.models,
+    })
+    .from(tenantSystemPrompts)
+    .where(eq(tenantSystemPrompts.tenantId, tenantId))
+    .limit(1);
+  const row = rows[0];
+  if (row === undefined) return EMPTY_TENANT_SYSTEM_PROMPTS;
+
+  const providers: Record<string, ProviderPromptEntry> = {};
+  for (const [providerId, entry] of Object.entries(row.providers ?? {})) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const candidate = entry as Partial<ProviderPromptEntry>;
+    if (typeof candidate.followGlobal !== "boolean") continue;
+    if (candidate.followGlobal === false) {
+      if (!isPromptSetting(candidate.setting)) continue;
+      providers[providerId] = { followGlobal: false, setting: candidate.setting };
+    } else {
+      providers[providerId] = { followGlobal: true };
+    }
+  }
+
+  const models: Record<string, PromptSetting> = {};
+  for (const [key, setting] of Object.entries(row.models ?? {})) {
+    if (parseSystemPromptModelKey(key) === null) continue;
+    if (!isPromptSetting(setting)) continue;
+    models[key] = setting;
+  }
+
+  return {
+    global: row.global !== null && isPromptSetting(row.global) ? row.global : null,
+    providers,
+    models,
+  };
+}
+
+/** Upserts the tenant's configuration and bumps the settings revision. */
+export async function writeTenantSystemPrompts(
+  db: CartethyiaDatabase,
+  tenantId: string,
+  next: TenantSystemPrompts,
+): Promise<void> {
+  // Keep the row bounded even though the API already enforces the caps: a
+  // direct store caller must not be able to plant an unbounded map.
+  const providers = Object.entries(next.providers).slice(0, SYSTEM_PROMPT_PROVIDER_LIMIT);
+  const models = Object.entries(next.models).slice(0, SYSTEM_PROMPT_MODEL_LIMIT);
+  const values = {
+    global: next.global,
+    providers: Object.fromEntries(providers),
+    models: Object.fromEntries(models),
+    updatedAt: new Date(),
+  };
+  await db
+    .insert(tenantSystemPrompts)
+    .values({ tenantId, ...values })
+    .onConflictDoUpdate({ target: tenantSystemPrompts.tenantId, set: values });
+  bumpSettingsRevision();
+}
+
+/** Clears the tenant's configuration entirely (console "reset" path). */
+export async function clearTenantSystemPrompts(
+  db: CartethyiaDatabase,
+  tenantId: string,
+): Promise<void> {
+  await db.delete(tenantSystemPrompts).where(eq(tenantSystemPrompts.tenantId, tenantId));
+  bumpSettingsRevision();
+}

package/src/protocol/reasoning.ts

@@ -50,19 +50,83 @@ export function applyDeepSeekReasoning(payload: Record<string, unknown>): void {
     payload["reasoning_effort"] = "high";
 }
 
+/**
+ * Model families whose Chat-compatible upstream enforces the DeepSeek replay
+ * rule: every prior assistant turn must carry `reasoning_content`, or the
+ * upstream refuses the whole request with
+ * `Missing required parameter: 'messages[N].reasoning_content'`. Seen on
+ * Cline's resold `reflection/beam-free` (2026-10-30) and on the buddy
+ * DeepSeek family. Cline, OpenRouter, Hermes, and Kilo share one chat wire,
+ * so the rule is stated once, keyed on the model family.
+ */
+const REASONING_REPLAY_MODEL_RE = /(?:deepseek|reflection\/beam)/i;
+
+/**
+ * Ensures every assistant turn carries `reasoning_content` for model families
+ * whose upstream enforces the DeepSeek replay rule. The rule demands the field
+ * on *every* earlier assistant message — presence, not content — and the
+ * upstream rejects an absent field with
+ * `Missing required parameter: 'messages[N].reasoning_content'` even when the
+ * turn genuinely has no trace to replay. Clients that already learned the rule
+ * send `reasoning_content: ""` for exactly those turns (see the chat surface
+ * parser), so an empty string is the honest value for a turn with nothing to
+ * replay. Existing values are never overwritten.
+ *
+ * Unlike `backfillDeepSeekReasoningContent`, this runs only for the
+ * OpenAI-compatible resellers (Cline/OpenRouter/Hermes/Kilo), not the buddy
+ * family, whose upstream rejects empty reasoning as "stripped" and drops it.
+ */
+export function ensureChatReasoningReplayPresence(payload: Record<string, unknown>): void {
+  const model = typeof payload["model"] === "string" ? payload["model"] : "";
+  if (!REASONING_REPLAY_MODEL_RE.test(model)) return;
+  const messages = payload["messages"];
+  if (!Array.isArray(messages)) return;
+  const thinking = payload["thinking"];
+  const thinkingEnabled = isRecord(thinking) && thinking["type"] === "enabled";
+  const hasTrace = messages.some(
+    (message) =>
+      isRecord(message) &&
+      ((typeof message["reasoning"] === "string" && message["reasoning"].length > 0) ||
+        "reasoning_content" in message),
+  );
+  // Same gate as the backfill: a request that never entered thinking mode and
+  // carries no reasoning anywhere has nothing the model could demand, so do
+  // not start marking its turns as thinking turns.
+  if (!thinkingEnabled && !hasTrace) return;
+  for (const message of messages) {
+    if (!isRecord(message) || message["role"] !== "assistant") continue;
+    if (typeof message["reasoning_content"] === "string") continue;
+    message["reasoning_content"] = "";
+  }
+}
+
 /** Backfills DeepSeek assistant reasoning_content required for replayed turns. */
 export function backfillDeepSeekReasoningContent(payload: Record<string, unknown>): void {
+  const model = typeof payload["model"] === "string" ? payload["model"] : "";
   const thinking = payload["thinking"];
   const thinkingEnabled = isRecord(thinking) && thinking["type"] === "enabled";
   const messages = payload["messages"];
   if (!Array.isArray(messages)) return;
+  const requiresReplay = REASONING_REPLAY_MODEL_RE.test(model);
   const hasTrace = messages.some(
     (message) =>
       isRecord(message) &&
       ((typeof message["reasoning"] === "string" && message["reasoning"].length > 0) ||
         "reasoning_content" in message),
   );
-  if (!thinkingEnabled && !hasTrace) return;
+  if (!thinkingEnabled && !requiresReplay && !hasTrace) return;
+  // As an *input* (a caller replays a prior turn), the model's own `reasoning`
+  // key is the canonical record of a thinking turn. Without it there is no
+  // trace to replay, so an assistant turn stays bare even under the hard rule;
+  // fabricating `""` would be read by the upstream as "thinking mode with the
+  // reasoning stripped" and reject the request anyway.
+  const hasModelReasoning = messages.some(
+    (message) =>
+      isRecord(message) &&
+      typeof message["reasoning"] === "string" &&
+      message["reasoning"].length > 0,
+  );
+  if (requiresReplay && !thinkingEnabled && !hasModelReasoning && !hasTrace) return;
   for (const message of messages) {
     if (!isRecord(message) || message["role"] !== "assistant") continue;
     if (typeof message["reasoning_content"] === "string") continue;

package/src/protocol/request/chat.ts

@@ -549,6 +549,7 @@ export function canonicalToChatPayload(
     ...(options.maxOutputTokens === undefined ? {} : { maxOutputTokens: options.maxOutputTokens }),
   });
   delete payload["max_tokens"];
+  delete payload["max_completion_tokens"];
   if (bounded !== undefined) payload[tokenLimitField] = bounded;
   return payload;
 }

package/src/providers/integrations/antigravity/antigravity.ts

@@ -84,34 +84,31 @@ const antigravityModel = (
   });
 
 export const ANTIGRAVITY_MODELS: readonly ModelDefinition[] = [
-  // Claude via Antigravity (Anthropic-branded SKUs, Gemini wire)
+  // Claude via Antigravity (Anthropic-branded SKUs, Gemini wire). The 4.6
+  // rows are pinned at 64000 because Antigravity was observed rejecting
+  // anything higher on `daily-cloudcode-pa`; `out` is published metadata, not
+  // a request field (the envelope's `maxOutputTokens` comes from
+  // `ANTIGRAVITY_MODEL_WIRE_PROFILES`).
   antigravityModel("claude-sonnet-4-6", 250_000, 64_000, true),
   antigravityModel("claude-opus-4-6", 250_000, 64_000, true),
-  // The 5.5 generation. Anthropic's own model pages publish 1M context and
-  // 128k output for both, which is the same figure the Claude integration
-  // carries; Antigravity has no base-catalog rows of its own, so the numbers
-  // are stated here rather than resolved from a source that does not exist.
-  //
-  // `out` is published metadata, not a request field: the `maxOutputTokens` the
-  // envelope carries comes from `ANTIGRAVITY_MODEL_WIRE_PROFILES`, and an id
-  // absent from that table passes the caller's own value through. The 4.6 rows
-  // are pinned at 64000 because Antigravity was observed rejecting anything
-  // higher on `daily-cloudcode-pa`. The 5.5 cap is UNVERIFIED — no 5.5 request
-  // has been captured against that host — so if it turns out to carry the same
-  // 64000 ceiling, it needs its own profile entry; a catalog row cannot express
-  // it.
   antigravityModel("claude-sonnet-5-5", 1_000_000, 128_000, true),
   antigravityModel("claude-opus-5-5", 1_000_000, 128_000, true),
-  // Gemini
-  antigravityModel("gemini-2.5-flash", 1_048_576, 65_536, true),
-  antigravityModel("gemini-3-flash", 1_048_576, 65_536, true),
+  // Gemini text SKUs, as the Antigravity roster publishes them.
+  antigravityModel("gemini-2.5-flash", 1_000_000, 66_000, true),
+  antigravityModel("gemini-2.5-flash-thinking", 1_000_000, 66_000, true),
+  antigravityModel("gemini-3-flash", 1_000_000, 66_000, true),
+  antigravityModel("gemini-3.1-flash-lite", 1_000_000, 66_000, true),
+  antigravityModel("gemini-2.5-flash-lite", 1_000_000, 66_000, true),
+  antigravityModel("gemini-3.5-flash-lite", 1_000_000, 66_000, true),
+  antigravityModel("gemini-3.8-flash", 1_000_000, 66_000, true),
+  antigravityModel("gemini-4-argon", 1_000_000, 65_536, true),
+  antigravityModel("gemini-4-carbon", 1_000_000, 65_536, true),
+  // Tab (laptop-class) preview SKU.
+  antigravityModel("tab_flash_lite_preview", 16_000, 4_000, true),
+  // Gemini image generation. `gemini-3-pro-image` uses the same catalog
+  // limits/capabilities as the existing `gemini-3.1-flash-image` row.
   antigravityModel("gemini-3.1-flash-image", 200_000, 64_000, false, true),
-  antigravityModel("gemini-3.1-pro", 1_048_576, 65_535, true),
-  antigravityModel("gemini-3.6-flash", 1_048_576, 65_536, true),
-  antigravityModel("gemini-3.7-flash", 1_048_576, 65_536, true),
-  antigravityModel("gemini-3.8-flash", 1_048_576, 65_536, true),
-  // GPT-OSS
-  antigravityModel("gpt-oss-120b", 131_072, 32_768, true),
+  antigravityModel("gemini-3-pro-image", 200_000, 64_000, false, true),
 ];
 
 function normalizeAntigravityGrounding(data: unknown, maxResults: number): readonly WebSearchResult[] {

package/src/providers/integrations/buddy/buddy-chat-shared.ts

@@ -21,7 +21,7 @@ import { createHash } from "node:crypto";
 import { completeRequiredSchema } from "../../../protocol/codecs";
 import type { CanonicalRequest } from "../../../protocol/canonical-model";
 import { isRecord } from "../../../protocol/codecs";
-import { applyDeepSeekReasoning, applyOpenAIReasoning, backfillDeepSeekReasoningContent, clampedEffortOutputFloor } from "../../../protocol/reasoning";
+import { applyDeepSeekReasoning, applyOpenAIReasoning, backfillDeepSeekReasoningContent, clampedEffortOutputFloor, ensureChatReasoningReplayPresence } from "../../../protocol/reasoning";
 import { BUDDY_CN_EFFORTS, BUDDY_INTL_EFFORTS, BUDDY_SHARED_RAW } from "./buddy-catalog-shared";
 // Imported for the CN roster only: a CN-only id has no row in the shared
 // table, and without one `raiseOutputForRaisedEffort` silently no-ops, so a
@@ -30,6 +30,7 @@ import { BUDDY_CN_EFFORTS, BUDDY_INTL_EFFORTS, BUDDY_SHARED_RAW } from "./buddy-
 // cn-provider (which imports this module) resolves before any call.
 import { CODEBUDDY_CN_RAW } from "./codebuddy/cn-catalog";
 import { buddyAccountUid } from "./buddy-oauth-shared";
+import { SYSTEM_PROMPT_WRAPPER_PREFIX, SYSTEM_PROMPT_WRAPPER_SUFFIX } from "../../../console/system-prompt/contracts";
 import type { ProviderDispatchContext } from "../../provider-contracts";
 
 const BUDDY_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
@@ -409,6 +410,21 @@ export function scrubBuddyChannelIdentity(messages: Array<Record<string, unknown
   }
 }
 
+/**
+ * OpenAI-compatible adapters that need the DeepSeek reasoning-replay backfill
+ * on outbound chat payloads. The buddy family runs it inside
+ * `buddyPrePayloadCommon`; these adapters register here so the same rule
+ * reaches every reseller that serves a thinking model.
+ */
+export const clineReasoningReplayPrepares: readonly ((
+  payload: Record<string, unknown>,
+) => void)[] = [
+  (payload) => {
+    backfillDeepSeekReasoningContent(payload);
+    ensureChatReasoningReplayPresence(payload);
+  },
+];
+
 /**
  * Payload prefix shared by the buddy pre-payload hooks: force `stream=true`,
  * apply the provider's DeepSeek thinking contract, opt `reasoning_summary` in
@@ -1152,12 +1168,24 @@ export function finalizeBuddyMessages(
 export function applyBuddySystemPrompt(
   messages: Array<Record<string, unknown>>,
   systemPrompt: string,
+  extraSystemText?: string,
 ): void {
+  // Tenant injection (Inject System Prompt) rides AFTER the fixed prompt,
+  // inside the same system turn, framed by the gateway's marker prefix/suffix:
+  // the upstream validates the identity prompt as the channel opener, so the
+  // fixed text must stay first and byte-identical; the wrapped tail carries
+  // the tenant's directive without touching the identity. An override-mode
+  // tenant prompt degrades to this wrapped append (the caller decides via
+  // `isWrappedInjectionProvider` before passing the text).
+  const effectivePrompt =
+    extraSystemText === undefined || extraSystemText.length === 0
+      ? systemPrompt
+      : `${systemPrompt}\n\n${SYSTEM_PROMPT_WRAPPER_PREFIX}\n${extraSystemText}\n${SYSTEM_PROMPT_WRAPPER_SUFFIX}`;
   const source = messages.filter(
     (message) => message["role"] !== "system" && message["role"] !== "developer",
   );
   messages.length = 0;
-  messages.push({ role: "system", content: systemPrompt });
+  messages.push({ role: "system", content: effectivePrompt });
   for (const message of source) {
     if (message["role"] === "user" && typeof message["content"] === "string") {
       messages.push({

package/src/providers/integrations/buddy/buddy-media.ts

@@ -173,7 +173,11 @@ export async function buddyGenerateImage(
   buddyPrePayloadCommon(payload, undefined, "intl", context);
   const messages = payload["messages"];
   if (Array.isArray(messages)) {
-    applyBuddySystemPrompt(messages as Array<Record<string, unknown>>, config.systemPrompt);
+    applyBuddySystemPrompt(
+      messages as Array<Record<string, unknown>>,
+      config.systemPrompt,
+      context?.tenant_system_prompt,
+    );
   }
   const headers: Record<string, string> = {
     "content-type": "application/json",

package/src/providers/integrations/buddy/codebuddy/provider.ts

@@ -84,7 +84,11 @@ function codeBuddyIntlPrePayload(
   if (!source) throw new GatewayError("invalid_request", 400, "CodeBuddy model is required");
   const messages = payload["messages"];
   if (Array.isArray(messages)) {
-    applyBuddySystemPrompt(messages as Array<Record<string, unknown>>, CODEBUDDY_SYSTEM_PROMPT);
+    applyBuddySystemPrompt(
+      messages as Array<Record<string, unknown>>,
+      CODEBUDDY_SYSTEM_PROMPT,
+      context?.tenant_system_prompt,
+    );
   }
   normalizeBuddyToolNames(payload);
   injectBuddyParallelToolCalls(payload, request);

package/src/providers/integrations/buddy/workbuddy/provider.ts

@@ -138,7 +138,11 @@ export function workbuddyPrePayload(
   const messages = payload["messages"];
   if (Array.isArray(messages)) {
     const normalizedMessages = messages as Array<Record<string, unknown>>;
-    applyBuddySystemPrompt(normalizedMessages, WORKBUDDY_SYSTEM_PROMPT);
+    applyBuddySystemPrompt(
+      normalizedMessages,
+      WORKBUDDY_SYSTEM_PROMPT,
+      context?.tenant_system_prompt,
+    );
     restoreHistoricalToolDefinitions(payload, normalizedMessages);
   }
   normalizeBuddyToolNames(payload);

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

@@ -8,6 +8,7 @@ import { completeRequiredSchema, isRecord } from "../../../protocol/codecs";
 import { providerBaseUrl } from "../../provider-metadata";
 import { getCachedModelDiscovery } from "../../operations/model-discovery-cache";
 import { defineModel } from "../../provider-model-definition";
+import { clineReasoningReplayPrepares } from "../buddy/buddy-chat-shared";
 import { clinePlatform, clinePlatformVersion } from "../../operations/cli-platform";
 import {
   getClineCliVersion,
@@ -133,6 +134,12 @@ function clinePrePayload(
     ? messages
     : [{ role: "system", content: "You are a helpful assistant." }, ...messages];
 
+  // 1.5) DeepSeek-replay backfill: Cline resells thinking models (deepseek,
+  // reflection/beam) whose upstream rejects the whole history when any prior
+  // assistant turn lacks `reasoning_content`. Same wire as OpenRouter/Hermes/
+  // Kilo, so the shared helper runs here too — it only mirrors a real trace.
+  for (const prepare of clineReasoningReplayPrepares) prepare(payload);
+
   // 2) Materialize deepseek-v4-flash non-stream quirk
   const model = typeof payload["model"] === "string" ? (payload["model"] as string) : candidate.model_id;
   const needsMaterialize = !request.stream && model.includes("deepseek-v4-flash");

package/src/providers/integrations/github/github.ts

@@ -288,6 +288,23 @@ interface GithubAutoDecision {
   readonly sessionToken: string;
   readonly expiresAt: number;
   readonly hasImage: boolean;
+  readonly route?: GithubModelRoute;
+}
+
+function routeFromAutoModel(value: unknown): GithubModelRoute | undefined {
+  if (!isRecord(value) || !Array.isArray(value["supported_endpoints"])) return undefined;
+  const endpoints = new Set(
+    value["supported_endpoints"]
+      .filter((endpoint): endpoint is string => typeof endpoint === "string")
+      .map((endpoint) => endpoint.replace(/^\/v1(?=\/)/, "")),
+  );
+  if (endpoints.has("/chat/completions")) {
+    return { wireFamily: "chat", endpointPath: GITHUB_ENDPOINT_PATH };
+  }
+  if (endpoints.has("/responses")) {
+    return { wireFamily: "responses", endpointPath: GITHUB_RESPONSES_ENDPOINT_PATH };
+  }
+  return undefined;
 }
 
 interface CopilotModelOptions {
@@ -420,7 +437,7 @@ class GithubAdapter extends OpenAICompatibleAdapter {
       if (cacheKey !== undefined) this.#cacheAutoDecision(cacheKey, autoDecision);
     }
     const selectedModelId = autoDecision.modelId;
-    let route = await githubModelRoute(selectedModelId, credential);
+    let route = autoDecision.route ?? await githubModelRoute(selectedModelId, credential);
     if (route === undefined) {
       // dynamic-import: discovery module is only loaded when the first
       // request routes to a model id not in the bundled roster; off the hot
@@ -539,11 +556,13 @@ class GithubAdapter extends OpenAICompatibleAdapter {
       Number.isFinite(responsePayload.expires_at)
         ? responsePayload.expires_at
         : 0;
+    const route = routeFromAutoModel(responsePayload.selected_model);
     return {
       modelId: responsePayload.selected_model.id.trim(),
       sessionToken: responsePayload.session_token.trim(),
       expiresAt,
       hasImage,
+      ...(route === undefined ? {} : { route }),
     };
   }
 

package/src/providers/integrations/hermes.ts

@@ -4,6 +4,7 @@ import type { ApiKeyProviderSpec } from "../configured-provider";
 import { isRecord } from "../../protocol/codecs";
 import { boundedUpstreamArray, boundedUpstreamNumber, sanitizeUpstreamLabel } from "../provider-sanitize";
 import { getHermesVersion } from "../operations/client-versions";
+import { clineReasoningReplayPrepares } from "./buddy/buddy-chat-shared";
 
 const HERMES_PROVIDER_ID = "hermes" as const;
 
@@ -110,7 +111,10 @@ export const HERMES_MODELS: readonly ModelDefinition[] = [
 export const HERMES_SPEC: ApiKeyProviderSpec = {
   provider_id: HERMES_PROVIDER_ID,
   endpoint_paths_by_wire_family: {},
-  prePayload: injectHermesTags,
+  prePayload: (payload, request, candidate) => {
+    injectHermesTags(payload, request, candidate);
+    for (const prepare of clineReasoningReplayPrepares) prepare(payload);
+  },
   // The origin sits behind Cloudflare, which answers a request carrying no
   // `user-agent` with 403 "Attention Required!" while the same request with any
   // non-empty UA answers 200 — measured directly against the API: an empty UA

package/src/providers/integrations/kilo/kilo.ts

@@ -24,6 +24,7 @@ import type { CanonicalRequest } from "../../../protocol/canonical-model";
 import { OpenAICompatibleAdapter, withBearerAuthentication } from "../../adapters/compatible-adapter";
 import { providerBaseUrl } from "../../provider-metadata";
 import { decodeKiloCredential } from "../../../security/credential-codec";
+import { clineReasoningReplayPrepares } from "../buddy/buddy-chat-shared";
 
 export const KILO_PROVIDER_ID = "kilo" as const;
 export const KILO_BASE_URL = providerBaseUrl("kilo");
@@ -117,6 +118,9 @@ class KiloAdapter extends OpenAICompatibleAdapter {
         provider_id: KILO_PROVIDER_ID,
         base_url: KILO_BASE_URL,
         endpoint_paths_by_wire_family: { chat: KILO_ENDPOINT_PATH },
+        prePayload: (payload) => {
+          for (const prepare of clineReasoningReplayPrepares) prepare(payload);
+        },
         ...(fetchImpl ? { fetchImpl } : {}),
       }),
     );