cartethyia 2.6.7 → 2.7.1

package/src/providers/integrations/inception/provider.ts

@@ -0,0 +1,91 @@
+import type { ApiKeyProviderSpec } from "../../configured-provider";
+import { fetchOpenAICompatibleModels } from "../../discovery/openai-model-discovery";
+import { defineModel, type ModelDefinition } from "../../provider-model-definition";
+
+const INCEPTION_PROVIDER_ID = "inception" as const;
+
+/**
+ * Inception Labs (Mercury) — bearer-authenticated OpenAI-compatible chat.
+ *
+ * The upstream is a plain `POST /v1/chat/completions` service (SSE streaming,
+ * tool calling, structured outputs, `reasoning_effort`). Base URL comes from
+ * `BUNDLED_PROVIDER_METADATA`; the chat path is declared below the `/v1`
+ * root, exactly like every other version-rooted OpenAI-compatible provider.
+ */
+export const INCEPTION_SPEC: ApiKeyProviderSpec = {
+  provider_id: INCEPTION_PROVIDER_ID,
+  endpoint_paths_by_wire_family: {},
+};
+
+/**
+ * Offline floor: the Mercury chat model this provider serves, pinned to the
+ * free-tier allowance (100M free tokens at signup).
+ *
+ * The roster intentionally carries only `mercury-3` — the operator's choice.
+ * Mercury Voice is enterprise-gated, Mercury Decide is a native decisions
+ * endpoint, and Mercury Edit 2 is FIM/edit; none of them is a chat model, and
+ * a chat wire would not serve them.
+ *
+ * `freeTier` is the catalog flag the console groups on; `free: true` zeroes
+ * the cost the way every other free-allowance provider models its rows — the
+ * allowance does not bill, so the row must not show a price. Limits are
+ * mercury-3's own chat-completions numbers: 1M context, 131072 max output,
+ * reasoning (instant/low/medium/high), tool calling.
+ */
+export const INCEPTION_MODELS: readonly ModelDefinition[] = [
+  defineModel({
+    id: "mercury-3",
+    wireFamily: "chat",
+    endpoint: "/chat/completions",
+    ctx: 1_000_000,
+    out: 131_072,
+    reasoning: true,
+    toolCall: true,
+    free: true,
+    freeTier: true,
+  }),
+];
+
+/**
+ * Live `/v1/models` listing, pinned to the free tier.
+ *
+ * The listing requires the API key (matches the chat endpoint's bearer), so
+ * the credential is forwarded when present; an unauthenticated fetch fails
+ * cleanly and the static roster stays authoritative.
+ *
+ * Every fetched row is stamped `freeTier` and zero-priced, the same rule the
+ * static roster declares: this provider is pinned to its free allowance, so a
+ * model upstream adds must not land in the billed tail.
+ *
+ * A fetched id that the static roster already knows keeps the roster row
+ * whole, not the listing's fields: upstream publishes `max_output_length` and
+ * no `reasoning`/`tool_call` keys, so the shared OpenAI-compatible reader
+ * would otherwise overwrite mercury-3's advertised 131072 output and reasoning
+ * flag with its 64k/not-reasoning defaults. The roster is the canonical
+ * metadata for the models we know; the listing only adds genuinely new ids.
+ */
+export async function discoverInceptionFreeModels(options: {
+  readonly baseUrl: string;
+  readonly credential?: string;
+  readonly fetcher?: typeof fetch;
+}): Promise<readonly ModelDefinition[] | null> {
+  const listed = await fetchOpenAICompatibleModels({
+    baseUrl: options.baseUrl,
+    providerId: "inception",
+    ...(typeof options.credential === "string" && options.credential.trim().length > 0
+      ? { headers: { authorization: `Bearer ${options.credential}` } }
+      : {}),
+    ...(options.fetcher === undefined ? {} : { fetcher: options.fetcher }),
+  });
+  if (listed === null) return null;
+  const known = new Map(INCEPTION_MODELS.map((model) => [model.modelId, model]));
+  return listed.map((model) => {
+    const roster = known.get(model.modelId);
+    if (roster !== undefined) return roster;
+    return {
+      ...model,
+      freeTier: true,
+      cost: { input: 0, output: 0, pricing_model: "pay-per-use" },
+    };
+  });
+}

package/src/providers/integrations/inferhub.ts

@@ -11,7 +11,7 @@ import type { FetchLike, ProviderQuotaResult } from "../quota/quota-contracts";
 import { probeApiKeyConnectivity } from "../quota/quota-support";
 import type { CanonicalEvent, CanonicalRequest, ContentPart } from "../../protocol/canonical-model";
 import { GatewayError } from "../../protocol/gateway-error";
-import { applyParamQuirks } from "../../transport/translation/quirks";
+import { applyParamQuirks } from "../../protocol/translation/quirks";
 import { buildClaudeMessagesRequest, filterClaudeCustomHeaders } from "./shared/claude-messages";
 import { resolveInboundSessionId } from "../operations/session-resolution";
 import { isRecord } from "../../protocol/codecs";

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

@@ -21,7 +21,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import type { CanonicalMessage, CanonicalRequest, ContentPart, ToolDefinition } from "../../../protocol/canonical-model";
 import { resolveImageSource, splitDataUrl } from "../../../protocol/codecs";
-import type { ReasoningEffortLevel } from "../../../transport/translation/thinking";
+import type { ReasoningEffortLevel } from "../../../protocol/translation/thinking";
 
 /** Longest tool name the upstream accepts, counted in code points. */
 export const KIRO_TOOL_NAME_MAX_LENGTH = 64;

package/src/providers/integrations/mistral.ts

@@ -4,14 +4,11 @@ import { defineModel } from "../provider-model-definition";
 const MISTRAL_PROVIDER_ID = "mistral" as const;
 
 /**
- * Mistral's own current generalist tiers.
+ * Mistral's catalog for the generic OpenAI-compatible API-key provider.
  *
- * The provider is registered as a generic OpenAI-compatible API-key provider,
- * which carries no catalog of its own: without this list, every model it serves
- * stays absent until a discovery run happens to fetch them. These are the two
- * `latest` aliases Mistral keeps pointed at its current generalist models —
- * `mistral-large-latest` (Large 4) and `mistral-medium-latest` (Medium 3.5),
- * per the Mistral model overview.
+ * The provider is registered as a generic API-key provider, which carries no
+ * catalog of its own: without this list, every model it serves stays absent
+ * until a discovery run happens to fetch them.
  *
  * Limits and pricing come from the base catalog via `providerId`: `defineModel`
  * resolves `mistral:<id>` and falls back to the majority row, so no number is
@@ -19,28 +16,110 @@ const MISTRAL_PROVIDER_ID = "mistral" as const;
  * because the base catalog is keyed by bare id and a bare id maps to many
  * providers' servings.
  *
+ * Which rows are here: the chat models live on a real Mistral account (the
+ * code/codestral family, the ministral small/medium/large sizes, voxtral
+ * small, and the small/medium generalist tiers). A live probe against the
+ * Mistral API verified each of these responds on `/v1/chat/completions`.
+ *
  * Deliberately not included:
  *
- * - The dated rows (`mistral-large-2411`, `mistral-medium-2508`). Each is on
- *   Mistral's retired list with a named successor.
- * - `mistral-small-latest`. Still live, but the operator asked for the two
- *   frontier tiers, and listing a model is a routing claim rather than a
- *   completeness claim.
- * - Both Magistral rows. Mistral deprecated Magistral Medium and Small in
- *   favour of Mistral Medium 3.5 and Mistral Small 4, so listing them
- *   advertises models the provider is actively retiring.
- * - The open-weights rows (`open-mistral-7b`, `open-mixtral-8x7b`), the
- *   embedding row (`mistral-embed`, not a chat model), and the devstral and
- *   codestral families — Mistral publishes those as separate product lines.
+ * - `mistral-large-latest` / dated large rows — tier-gated (Mistral answers
+ *   403 `tier_not_allowed` on many subscription tiers).
+ * - The embed/moderation/OCR/transcribe/TTS/realtime rows — they speak a
+ *   different endpoint, not chat.
+ * - The Labs rows (`labs-leanstral-*`) — need an organization admin flag.
+ * - The open-weights rows (`open-mistral-7b`, `open-mixtral-8x7b`) and the
+ *   devstral family — separate product lines.
  */
 export const MISTRAL_MODELS: readonly ModelDefinition[] = [
+  // Code / coding family
+  defineModel({
+    id: "codestral-2508",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "codestral-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-code-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-code-fim-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  // Ministral sizes
+  defineModel({
+    id: "ministral-14b-2512",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "ministral-14b-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
   defineModel({
-    id: "mistral-large-latest",
+    id: "ministral-8b-2512",
     providerId: MISTRAL_PROVIDER_ID,
     wireFamily: "chat",
     vision: true,
     toolCall: true,
   }),
+  defineModel({
+    id: "ministral-8b-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "ministral-3b-2512",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "ministral-3b-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  // Voxtral small (chat-capable)
+  defineModel({
+    id: "voxtral-small-2507",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "voxtral-small-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  // Medium generalist tiers
   defineModel({
     id: "mistral-medium-latest",
     providerId: MISTRAL_PROVIDER_ID,
@@ -49,4 +128,99 @@ export const MISTRAL_MODELS: readonly ModelDefinition[] = [
     reasoning: true,
     toolCall: true,
   }),
+  defineModel({
+    id: "mistral-medium",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-medium-3-5",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-medium-3.5",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-medium-3",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-medium-2604",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  // Vibe CLI family
+  defineModel({
+    id: "mistral-vibe-cli-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-vibe-cli-with-tools",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-vibe-cli-fast",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  // Magistral / small generalist tiers (chat-capable)
+  defineModel({
+    id: "magistral-medium-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-small-2603",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-small-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "magistral-small-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
 ];

package/src/providers/integrations/opencode/fingerprint.ts

@@ -1,6 +1,14 @@
 import { getOpenCodeVersion } from "../../operations/client-versions";
 import { createHash, randomBytes } from "node:crypto";
 
+/**
+ * The OpenCode fallback client identity, used only while version discovery has
+ * not resolved yet. The live feed (`opencode/latest/<version>/cli`) wins once
+ * it is available; upstream accepts a range of releases, so the fallback does
+ * not need chasing.
+ */
+export const OPENCODE_CLIENT_VERSION = "2.1.1";
+
 let lastTimestamp = 0;
 let sequenceCounter = 0;
 const SESSION_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -118,11 +126,19 @@ function createTraceHeaders(): Record<string, string> {
   };
 }
 
-/** Build the observed OpenCode CLI identity headers for an upstream dispatch. */
+/**
+ * Build the observed OpenCode CLI identity headers for an upstream dispatch.
+ *
+ * The v2 lane splits root and child session ids exactly like the reference
+ * gateway: `x-opencode-session` / `x-session-affinity` / `x-session-id` carry
+ * the root session, while `x-opencode-session-id` carries the child (the
+ * client's own session id when it sent one, else the root).
+ */
 export function buildOpenCodeHeaders(
   version = getOpenCodeVersion(),
   affinity?: string,
   projectId?: string,
+  childSessionId?: string,
 ): Record<string, string> {
   let sessionId: string;
   if (isOpenCodeSessionId(affinity)) {
@@ -132,6 +148,7 @@ export function buildOpenCodeHeaders(
   } else {
     sessionId = generateOpenCodeSessionId();
   }
+  const childId = isOpenCodeSessionId(childSessionId) ? childSessionId : sessionId;
   return {
     // The gate accepts both "cli" and "desktop" (measured 2026-10-17), so this
     // is not a refusal either way. It is "cli" because that is what the client
@@ -140,7 +157,7 @@ export function buildOpenCodeHeaders(
     // client identity this adapter does not have, for no measured benefit.
     "x-opencode-client": "cli",
     "x-opencode-session": sessionId,
-    "x-opencode-session-id": sessionId,
+    "x-opencode-session-id": childId,
     "x-session-affinity": sessionId,
     "x-session-id": sessionId,
     // No `x-opencode-request`: the current client no longer sends it, and

package/src/providers/integrations/opencode/prompt.ts

@@ -0,0 +1,111 @@
+/**
+ * The minimal system prompt injected into free-tier OpenCode payloads.
+ *
+ * The full CLI prompt is unnecessary: live trimming showed the free-tier gate
+ * accepts any system content that carries the `<env>` block with a
+ * `Working directory:` line — even a ~30-character placeholder passes. The
+ * marker line below is kept so `carriesOpenCodePrompt` can detect an already-
+ * injected prompt and avoid duplication.
+ */
+
+/** The marker that identifies a body already carrying the injected prompt. */
+export const OPENCODE_PROMPT_MARKER = "You are an interactive coding agent that helps users";
+
+/**
+ * Assembles the minimal prompt: the marker line plus the `<env>` block the
+ * gate requires. No model identity, no skills, no style rules — the model is
+ * a gateway proxy and should not claim an upstream identity.
+ */
+export function opencodeSystemPrompt(): string {
+  const directory = process.cwd().trim() || "/workspace";
+  return `You are an interactive coding agent that helps users with software engineering tasks.\n<env>  Working directory: ${directory}</env>`;
+}
+
+/** Flattens a system/instruction value into its text fragments. */
+export function textFragments(value: unknown): string[] {
+  if (typeof value === "string") {
+    return value.trim() === "" ? [] : [value];
+  }
+  if (Array.isArray(value)) return value.flatMap((item) => textFragments(item));
+  if (typeof value === "object" && value !== null) {
+    const record = value as Record<string, unknown>;
+    if (typeof record["text"] === "string") return textFragments(record["text"]);
+    if (record["content"] !== undefined) return textFragments(record["content"]);
+  }
+  return [];
+}
+
+/** Whether any text inside `value` already contains the injected prompt marker. */
+export function carriesOpenCodePrompt(value: unknown): boolean {
+  return textFragments(value).some((part) => part.includes(OPENCODE_PROMPT_MARKER));
+}
+
+/**
+ * Appends the `<env>` block to the first existing system/developer message
+ * instead of prepending a new leading system message. The tool's own system
+ * content (Claude Code, DSH, …) keeps its place; the gate-required env block
+ * is tacked on at the end of it.
+ */
+export function injectChatPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const messages = payload["messages"];
+  if (!Array.isArray(messages)) return false;
+  const firstSystem = messages.findIndex((raw) => {
+    if (typeof raw !== "object" || raw === null) return false;
+    const role = (raw as Record<string, unknown>)["role"];
+    return role === "system" || role === "developer";
+  });
+  if (firstSystem === -1) {
+    payload["messages"] = [{ role: "system", content: prompt }, ...messages];
+    return true;
+  }
+  const message = messages[firstSystem] as Record<string, unknown>;
+  if (carriesOpenCodePrompt(message["content"])) return false;
+  const existing = textFragments(message["content"]).join("\n");
+  message["content"] = existing === "" ? prompt : `${existing}\n\n${prompt}`;
+  return true;
+}
+
+/** Appends the prompt to the top-level Anthropic `system` value. */
+export function injectAnthropicPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const system = payload["system"];
+  if (system !== undefined && carriesOpenCodePrompt(system)) return false;
+  if (system === undefined) {
+    payload["system"] = prompt;
+    return true;
+  }
+  if (typeof system === "string") {
+    payload["system"] = system.trim() === "" ? prompt : system + "\n\n" + prompt;
+  } else if (Array.isArray(system)) {
+    payload["system"] = [...system, { type: "text", text: prompt }];
+  } else {
+    payload["system"] = prompt;
+  }
+  return true;
+}
+
+/** Appends the prompt to the Responses `instructions` value. */
+export function injectResponsesPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const instructions = payload["instructions"];
+  if (instructions !== undefined && carriesOpenCodePrompt(instructions)) return false;
+  if (typeof instructions === "string") {
+    payload["instructions"] = instructions.trim() === "" ? prompt : instructions + "\n\n" + prompt;
+  } else {
+    payload["instructions"] = prompt;
+  }
+  return true;
+}
+
+/**
+ * Injects the prompt into a free-tier payload for the given wire family.
+ * System One payloads are never touched. Reports whether changed.
+ */
+export function injectOpenCodePrompt(
+  payload: Record<string, unknown>,
+  wireFamily: "chat" | "responses" | "messages" | "systemone",
+): boolean {
+  if (wireFamily === "systemone") return false;
+  const prompt = opencodeSystemPrompt();
+  if (wireFamily === "chat") return injectChatPrompt(payload, prompt);
+  if (wireFamily === "messages") return injectAnthropicPrompt(payload, prompt);
+  return injectResponsesPrompt(payload, prompt);
+}