cartethyia 2.7.8 → 2.8.0

package/src/providers/integrations/alibabacp/alibabacp-models.ts

@@ -19,8 +19,7 @@
  */
 import { defineModel } from "../../provider-model-definition";
 import type { ModelDefinition } from "../../provider-model-definition";
-
-export const ALIBABACP_PROVIDER_ID = "alibabacp" as const;
+import { ALIBABACP_PROVIDER_ID } from "./alibabacp";
 
 /** Chat path below the region's `/compatible-mode/v1` base. */
 const CHAT_ENDPOINT = "/chat/completions";

package/src/providers/integrations/{dashscope-models.ts → alibabacp/dashscope-models.ts}

@@ -17,8 +17,8 @@
  * does not publish yet arrives through the sync control instead of being
  * asserted ahead of the upstream.
  */
-import { defineModel } from "../provider-model-definition";
-import type { ModelDefinition } from "../provider-model-definition";
+import { defineModel } from "../../provider-model-definition";
+import type { ModelDefinition } from "../../provider-model-definition";
 
 export const DASHSCOPE_PROVIDER_ID = "dashscope" as const;
 

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

@@ -267,6 +267,85 @@ export function normalizeAntigravityToolSchema(schema: unknown): unknown {
   return schema;
 }
 
+/**
+ * Flattens JSON-Schema constructs the Antigravity upstream rejects.
+ *
+ * Verified live (2026-11-05): the Claude-route upstream validates tool
+ * schemas as strict JSON Schema draft 2020-12 and refuses every `anyOf` /
+ * `oneOf` / multi-type `type: [...]` declaration — even a degenerate
+ * `anyOf` of two identical string schemas, and even at the root. The Gemini
+ * builder's sanitizer keeps those constructs (Gemini itself accepts them), so
+ * a tool that declares a union (e.g. OMP's `task` tool's `model` field)
+ * ships an invalid schema and the upstream 400s the whole request with
+ * `tools.N.custom.input_schema: JSON schema is invalid`.
+ *
+ * The rewrite replaces `anyOf`/`oneOf` with the single most permissive
+ * alternative's type (string when a choice is a string, otherwise any
+ * surviving type), and a multi-type `type: [...]` with its first entry —
+ * the most permissive shape a strict single-type validator can express.
+ * Recurses through `properties` and `items`.
+ */
+export function flattenAntigravitySchema(schema: unknown): unknown {
+  if (!isRecord(schema)) return schema;
+  const out: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(schema)) {
+    if (key === "anyOf" || key === "oneOf") {
+      if (!Array.isArray(child)) continue;
+      const chosen = child.map((entry) => flattenAntigravitySchema(entry)).find(isRecord);
+      if (chosen === undefined) continue;
+      if (typeof chosen["type"] === "string") out["type"] = chosen["type"];
+      for (const [nestedKey, nestedValue] of Object.entries(chosen)) {
+        if (nestedKey === "type") continue;
+        out[nestedKey] = nestedValue;
+      }
+      continue;
+    }
+    if (key === "type" && Array.isArray(child)) {
+      const first = child.find((entry): entry is string => typeof entry === "string");
+      if (first !== undefined) out["type"] = first;
+      continue;
+    }
+    if (key === "properties" && isRecord(child)) {
+      out["properties"] = Object.fromEntries(
+        Object.entries(child).map(([name, entry]) => [name, flattenAntigravitySchema(entry)]),
+      );
+      continue;
+    }
+    if (key === "items" && Array.isArray(child)) {
+      out["items"] = child.map((entry) => flattenAntigravitySchema(entry));
+      continue;
+    }
+    if (key === "items" && isRecord(child)) {
+      out["items"] = flattenAntigravitySchema(child);
+      continue;
+    }
+    out[key] = child;
+  }
+  return out;
+}
+
+/**
+ * Applies both tool-schema normalizations (unwrap `parametersJsonSchema`,
+ * flatten rejected union constructs) and reports whether anything changed.
+ *
+ * When flattening is a no-op, the *original* reference is returned so the
+ * request-level helper can detect an unchanged request without a deep compare.
+ */
+export function normalizeAntigravityToolSchemaForWire(schema: unknown): {
+  readonly schema: unknown;
+  readonly changed: boolean;
+} {
+  const unwrapped = normalizeAntigravityToolSchema(schema);
+  const flattened = flattenAntigravitySchema(unwrapped);
+  const unwrapChanged = unwrapped !== schema;
+  const flattenChanged =
+    flattened !== unwrapped && JSON.stringify(flattened) !== JSON.stringify(unwrapped);
+  return {
+    schema: flattenChanged ? flattened : unwrapped,
+    changed: unwrapChanged || flattenChanged,
+  };
+}
+
 /**
  * Normalizes every declared tool's schema on a canonical request, returning a
  * shallow copy of the request when anything changed and the original object
@@ -286,14 +365,54 @@ export function normalizeAntigravityToolSchemas(request: CanonicalRequest): Cano
   if (tools === undefined || tools.length === 0) return request;
   let changed = false;
   const normalized = tools.map((tool) => {
-    const schema = normalizeAntigravityToolSchema(tool.jsonSchema);
-    if (schema === tool.jsonSchema) return tool;
+    const { schema, changed: schemaChanged } = normalizeAntigravityToolSchemaForWire(tool.jsonSchema);
+    if (!schemaChanged) return tool;
     changed = true;
     return { ...tool, jsonSchema: schema };
   });
   return changed ? { ...request, tools: normalized } : request;
 }
 
+/**
+ * Drops replayed reasoning blocks that carry no signature on a Claude route.
+ *
+ * The Claude-route upstream requires every `thinking` block in a replayed
+ * assistant turn to carry a `signature`; an unsigned block is rejected with
+ * `400 messages.N.content.0.thinking.signature: Field required`. Chat-surface
+ * clients (e.g. OMP) replay reasoning as a bare `reasoning_content` string
+ * that has no signature — there is nothing to forward, and sending it as an
+ * unsigned `thought` part guarantees the 400.
+ *
+ * The reference client solves this with a `drop-unsigned-thinking` compat flag
+ * on `google-antigravity` (donor `anthropic.kdl:743-748`): a thinking block
+ * without a signature is simply not replayed. This mirrors that behavior —
+ * reasoning with a real signature still replays; reasoning without one is
+ * dropped so the upstream never sees an unsigned `thinking` part.
+ */
+export function dropAntigravityUnsignedReasoning(
+  request: CanonicalRequest,
+  isClaudeRoute: boolean,
+): CanonicalRequest {
+  if (!isClaudeRoute) return request;
+  const messages = request.messages;
+  let changed = false;
+  const next = messages.map((message) => {
+    if (message.role !== "assistant") return message;
+    const content = message.content.filter((part) => {
+      if (part.kind !== "reasoning") return true;
+      // A present-but-empty signature is still unsigned: upstream rejects a
+      // `thinking` part whose `signature` is missing *or* empty with
+      // `400 messages.N.content.0.thinking.signature: Field required`. Only a
+      // non-empty signature is a real one.
+      if (typeof part.signature === "string" && part.signature.length > 0) return true;
+      changed = true;
+      return false;
+    });
+    return changed ? { ...message, content } : message;
+  });
+  return changed ? { ...request, messages: next } : request;
+}
+
 // Last-good-endpoint stickiness
 
 /**

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

@@ -41,6 +41,7 @@ import {
 import {
   antigravityWireModelId,
   applySkipThoughtSignatureBypass,
+  dropAntigravityUnsignedReasoning,
   getAntigravityModelWireProfile,
   getAntigravityUserAgent,
   loadAntigravityProject,
@@ -334,6 +335,7 @@ class AntigravityAdapter implements ProviderAdapter {
               kind: "reasoning",
               payload: null,
               summary: output.thought,
+              ...(output.thoughtSignature ? { signature: output.thoughtSignature } : {}),
             },
           } as CanonicalEvent;
         }
@@ -448,6 +450,7 @@ class AntigravityAdapter implements ProviderAdapter {
               kind: "reasoning",
               payload: null,
               summary: output.thought,
+              ...(output.thoughtSignature ? { signature: output.thoughtSignature } : {}),
             },
           } as CanonicalEvent;
         }
@@ -912,7 +915,16 @@ export function buildAntigravityEnvelope(
   // for that key and would drop both the wrapper and the schema inside it —
   // the tool would ship as `{"type":"object"}` with every property gone.
   // Rewriting after the payload is built leaves nothing to recover.
-  const geminiPayload = buildGeminiPayload(normalizeAntigravityToolSchemas(request));
+  //
+  // Claude routes also drop replayed reasoning without a signature (donor
+  // `drop-unsigned-thinking`): upstream rejects an unsigned `thinking` part
+  // with 400 `messages.N.content.0.thinking.signature: Field required`.
+  const isClaudeRoute = logicalModelId.toLowerCase().includes("claude");
+  const geminiPayload = buildGeminiPayload(
+    normalizeAntigravityToolSchemas(
+      dropAntigravityUnsignedReasoning(request, isClaudeRoute),
+    ),
+  );
   const profile = getAntigravityModelWireProfile(wireModelId);
 
   const generationConfig = isRecord(geminiPayload["generationConfig"])
@@ -946,7 +958,6 @@ export function buildAntigravityEnvelope(
   const existingContents = Array.isArray(geminiPayload["contents"])
     ? (geminiPayload["contents"] as Record<string, unknown>[])
     : [];
-  const isClaudeRoute = logicalModelId.toLowerCase().includes("claude");
   // Forced choice on Gemini routes: the backend drops `toolConfig` here, so a
   // canonical `tool_choice=required` with no declared change is restated as a
   // trailing user directive (reference behavior). Claude routes implement

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

@@ -8,10 +8,9 @@
  * declarations.
  *
  * Only the row shape and the builder are shared. Identity headers are not:
- * `codebuddyHeaders` and `workbuddyHeaders` send genuinely different bytes
- * (`X-Product`/`X-IDE-Type`/`X-Domain` versus `origin`/`referer` and the
- * account-derived `x-user-id`/`x-machine-id`/`x-session-id`), and those stay
- * with their own provider.
+ * `codebuddyHeaders` sends genuinely different bytes per realm
+ * (`X-Product`/`X-IDE-Type`/`X-Domain` versus the CN CLI profile), and those
+ * stay with the provider.
  */
 import { GatewayError } from "../../../protocol/gateway-error";
 import { defineModel } from "../../provider-model-definition";
@@ -42,7 +41,8 @@ export const BUDDY_INTL_EFFORTS: Readonly<Record<string, readonly string[]>> = {
   "glm-5.2": ["high", "xhigh"],
   "glm-5.3": ["low", "high", "max"],
   hy3: ["low", "high"],
-  "hy4-preview-f": ["high"],
+  hy4: ["high"],
+  hy4free: ["high"],
 };
 export const BUDDY_CN_EFFORTS: Readonly<Record<string, readonly string[]>> = {
   "deepseek-v4-flash": ["low", "high", "max"],
@@ -53,7 +53,8 @@ export const BUDDY_CN_EFFORTS: Readonly<Record<string, readonly string[]>> = {
   "glm-5.3": ["low", "high", "max"],
   "glm-5.3-flash": ["low", "high", "max"],
   hy3: ["low", "high"],
-  "hy4-preview": ["high"],
+  hy4: ["high"],
+  hy4free: ["high"],
 };
 
 /** The image-generation ids the international buddy providers serve. */
@@ -75,9 +76,9 @@ const BUDDY_IMAGE_MODEL_IDS: readonly { id: string; endpoint: string; ctx: numbe
  * `seedance-2.5` is the text-to-video model the buddy facade exposes. It is a
  * distinct service kind (`videoGeneration`), not a chat or image row, so it is
  * built by {@link makeBuddyVideoModels} and reached through
- * `/videos/generations` (relative to each variant's own base, which is why the
- * WorkBuddy rows carry the `/v2` segment themselves) rather than a chat wire.
- * CodeBuddy CN is deliberately absent — it publishes a different roster.
+ * `/videos/generations` (relative to each variant's own base) rather than a
+ * chat wire. CodeBuddy CN is deliberately absent — it publishes a different
+ * roster.
  */
 const BUDDY_VIDEO_MODEL_IDS: readonly { id: string; endpoint: string; ctx: number; out: number }[] = [
   { id: "seedance-2.5", endpoint: "/videos/generations", ctx: 1_000_000, out: 128_000 },
@@ -103,16 +104,15 @@ export const BUDDY_IMAGE_MODEL_ID_SET: ReadonlySet<string> = new Set(
  * The CN realm's image-generation ids.
  *
  * Separate from {@link BUDDY_IMAGE_MODEL_IDS} because the realms do not share
- * a roster: `hunyuan-image-alpha` is published by the CN `/v3/config` only, and
- * the intl image ids are not served there. Sharing one list would either leak
- * CN-only ids onto the international catalogs or force a realm check into
- * every consumer.
- *
- * `hunyuan-image-alpha-edit` carries `image-to-image` and is deliberately NOT
- * here: it is not in the CLI roster, so it is not a routable generation model.
+ * a roster: `hunyuan-image-alpha` (text-to-image) and
+ * `hunyuan-image-alpha-edit` (image-to-image) are published by the CN
+ * `/v3/config` only, and the intl image ids are not served there. Sharing one
+ * list would either leak CN-only ids onto the international catalogs or force
+ * a realm check into every consumer.
  */
 const BUDDY_CN_IMAGE_MODEL_IDS: readonly { id: string; ctx: number; out: number }[] = [
   { id: "hunyuan-image-alpha", ctx: 1_000_000, out: 64_000 },
+  { id: "hunyuan-image-alpha-edit", ctx: 1_000_000, out: 64_000 },
 ];
 
 /** The CN analogue of {@link BUDDY_IMAGE_MODEL_ID_SET}. */
@@ -145,10 +145,54 @@ export function makeBuddyCnImageModels(
   );
 }
 
+/**
+ * The CN realm's video-generation ids.
+ *
+ * `kling-video-v3` (text-to-video + image-to-video) and
+ * `minimax-video-h3` (text-to-video) are published by the CN `/v3/config`,
+ * sharing the async task surface the intl video rows use.
+ */
+const BUDDY_CN_VIDEO_MODEL_IDS: readonly { id: string; ctx: number; out: number }[] = [
+  { id: "kling-video-v3", ctx: 1_000_000, out: 128_000 },
+  { id: "minimax-video-h3", ctx: 1_000_000, out: 128_000 },
+];
+
+/** The CN analogue of {@link BUDDY_VIDEO_MODEL_ID_SET}. */
+export const BUDDY_CN_VIDEO_MODEL_ID_SET: ReadonlySet<string> = new Set(
+  BUDDY_CN_VIDEO_MODEL_IDS.map((entry) => entry.id),
+);
+
+/**
+ * Builds the CN video-generation rows for one buddy CN provider.
+ *
+ * Same shape as {@link makeBuddyVideoModels}, scoped to the CN roster: a video
+ * row produces `["video"]` on the `videoGeneration` surface and is reached
+ * through the native video route, not a chat wire.
+ */
+export function makeBuddyCnVideoModels(
+  providerId: string,
+  endpoint: string,
+): readonly ModelDefinition[] {
+  return BUDDY_CN_VIDEO_MODEL_IDS.map((entry) =>
+    defineModel({
+      id: entry.id,
+      providerId,
+      serviceKind: "videoGeneration",
+      wireFamily: "chat",
+      endpoint,
+      ctx: entry.ctx,
+      out: entry.out,
+      vision: true,
+      output: ["video"],
+      toolCall: false,
+    }),
+  );
+}
+
 /**
  * Ids the buddy facade refuses on a free plan.
  *
- * The international CodeBuddy and WorkBuddy catalogs share this roster and
+ * The international CodeBuddy catalog shares this roster and
  * the same Pro-tier model classification.
  *
  * Nothing in the console directory predicts it. `credits` does not — `kimi-k3`
@@ -186,12 +230,12 @@ export const BUDDY_PRO_ONLY_MODEL_IDS: ReadonlySet<string> = new Set([
 /**
  * Builds the image-generation rows for one buddy provider.
  *
- * Shared rather than copied per provider: cb and WorkBuddy serve the same image
+ * Shared rather than copied per provider: cb serves the same image
  * models from the same facade, so the roster and the declared capabilities are
  * one decision instead of two that drift. CodeBuddy CN is deliberately absent —
  * it publishes a different roster.
  *
- * `endpoint` is explicit because the two families disagree about the path their
+ * `endpoint` is explicit because the realms disagree about the path their
  * base URL expects, and a bare `defineModel` would infer the generic default
  * and produce a URL the upstream rejects.
  */
@@ -260,12 +304,9 @@ export const BUDDY_VIDEO_MODEL_ID_SET: ReadonlySet<string> = new Set(
  * Builds one buddy catalog row.
  *
  * `endpoint` is explicit rather than left to the generic `/chat/completions`
- * default because the two families disagree about it: CodeBuddy's base URL
- * carries a version segment the default joins onto correctly, while
- * WorkBuddy's does not — the default would produce
- * `https://www.workbuddy.ai/chat/completions`, which that upstream answers
- * with a 405 HTML page. Callers pass the endpoint their base URL actually
- * serves, and `undefined` for the default.
+ * default because the family's CN base URL differs from the intl one; callers
+ * pass the endpoint their base URL actually serves, and `undefined` for the
+ * default.
  */
 export function makeBuddyModel(
   entry: BuddyRawEntry,
@@ -297,14 +338,11 @@ export function makeBuddyModel(
 }
 
 /**
- * The shared model roster for the two international buddy sites.
+ * The shared model roster for the international buddy site.
  *
- * CodeBuddy intl and WorkBuddy serve the same model set from the same console
- * directory shape, so the two catalogs were kept as separate hand-written lists
- * and had already drifted: each carried ids the other lacked. One list is the
- * single source of truth, and each provider maps it with its own endpoint
- * (`workbuddy.ts` needs the explicit `/v2/chat/completions`, `codebuddy.ts`
- * takes the family default) — the endpoint is the only thing that differs.
+ * CodeBuddy intl serves the model set from the same console directory shape, so
+ * the catalog is one hand-written list as the single source of truth, mapped
+ * with the provider's own endpoint (`codebuddy.ts` takes the family default).
  *
  * CodeBuddy CN is deliberately NOT on this list: its console publishes a
  * different roster (its own `glm-5v-turbo` / `kimi-k3-1` ids and CN-specific
@@ -349,8 +387,8 @@ export const BUDDY_SHARED_RAW: readonly BuddyRawEntry[] = [
   ["grok-4.6", "Grok 4.6", true, true, 500_000, 500_000],
   ["grok-4.7", "Grok 4.7", true, true, 500_000, 128_000],
   ["hy3", "Hy3", true, true, 192_000, 64_000, true],
-  ["hy4-preview", "Hy4 Preview", true, true, 1_000_000, 64_000, true],
-  ["hy4-preview-f", "Hy4 Preview F", true, true, 1_000_000, 64_000, true],
+  ["hy4", "Hy4", true, true, 1_000_000, 64_000, true],
+  ["hy4free", "Hy4 Free", true, true, 1_000_000, 64_000, true],
   ["kimi-k2.5", "Kimi K2.5", true, false, 164_000, 262_144],
   ["kimi-k2.6", "Kimi K2.6", true, false, 256_000, 262_144],
   ["kimi-k2.7", "Kimi K2.7", true, false, 256_000, 65_536],