cartethyia 2.7.6 → 2.7.7

package/src/providers/discovery/discovery-types.ts

@@ -74,6 +74,17 @@ export interface ProbeModelRequest {
   reasoningEffort?: ProbeReasoningEffort;
   maxOutputTokens?: number;
   stream?: boolean;
+  /**
+   * Provider-specific transport override for the probe.
+   *
+   * `undefined` (default) probes through the same transport live traffic
+   * uses. A provider may expose extra surfaces that only a probe can force —
+   * Qoder's IDE surface (`/model/v1`) is the only one that echoes strategy
+   * metadata (`provider_model`, `target`, …) alongside the answer, while the
+   * production transports (gRPC / COSY) do not. Forcing it makes the probe
+   * result the richest available source of truth.
+   */
+  surface?: "default" | "cosy" | "grpc" | "ide";
 }
 export interface ProbeModelResult {
   accountId?: string;
@@ -93,6 +104,13 @@ export interface ProbeModelResult {
   reportedModel?: string;
   statusCode?: number;
   error?: string;
+  /**
+   * Provider-specific upstream metadata about the model that actually served
+   * the turn (native model id, supply target, tier). Filled when the probed
+   * transport exposes it — Qoder's IDE surface reports it in `raw_usage`;
+   * the production transports do not.
+   */
+  providerMetadata?: Readonly<Record<string, unknown>>;
   /** Normalized hits a `websearch` probe returned, so the console can show them. */
   searchResults?: ReadonlyArray<{
     readonly title: string;

package/src/providers/discovery/probe-phases.ts

@@ -150,6 +150,27 @@ export function extractSample(events: readonly CanonicalEvent[]): string | undef
   return trimmed.length > 0 ? trimmed.slice(0, 200) : undefined;
 }
 
+/**
+ * Reads the model an adapter reported in its canonical events.
+ *
+ * The HTTP-only `readReportedModel` inspects the raw response body, so it
+ * cannot see the model on non-HTTP transports (Qoder gRPC). Adapters surface
+ * the upstream echo as `response_start`/`message_start` with a `model` field;
+ * this reads that as a fallback.
+ */
+export function modelFromEvents(events: readonly CanonicalEvent[]): string | undefined {
+  for (const event of events) {
+    if (
+      (event.type === "response_start" || event.type === "message_start") &&
+      typeof event.model === "string" &&
+      event.model.trim().length > 0
+    ) {
+      return event.model.trim();
+    }
+  }
+  return undefined;
+}
+
 export function hasMeaningfulOutput(events: readonly CanonicalEvent[]): boolean {
   return events.some((event) => {
     if (event.type === "tool_call_delta") return true;
@@ -581,6 +602,30 @@ export async function loadProbePreferences(args: {
   return { probeReasoning, payloadCapture };
 }
 
+/**
+ * The probe's default identity prompt (`What model are you...`) works for
+ * every Qoder roster row except `cmodel` (virtual id `cantus`): that row's
+ * gRPC surface answers the identity question with `406 Upstream error [stream]`
+ * from the upstream proxy (verified live 2026-11-04; dmodel/qmodel/smodel all
+ * accept it). Returns the neutral replacement prompt when the probe targets
+ * that row with no explicit prompt, `undefined` otherwise.
+ *
+ * The replacement prompt must never *ask* an identity question: the upstream
+ * guardrail is content-based and swallows the reply (empty sample) for any
+ * phrasing that interrogates identity — even indirect ones (`what would you
+ * call yourself`, `which model are you`, `perkenalkan dirimu`). A plain
+ * greeting that *asserts* the wrong identity (`halo gpt`) makes the model
+ * correct us on its own, and returns a sample 3/3 runs (verified live
+ * 2026-11-04). We keep that phrasing — it is 100% consistent and the model
+ * names itself ("saya Claude... buatan Anthropic") without us ever asking.
+ */
+export function qoderCmodelProbePrompt(providerId: string, modelId: string, prompt: string | undefined): string | undefined {
+  if (prompt !== undefined) return undefined;
+  if (providerId !== "qoder" && providerId !== "qodercn") return undefined;
+  if (modelId !== "cmodel" && modelId !== "cantus") return undefined;
+  return "halo gpt";
+}
+
 /**
  * Phase 5 — build the canonical probe request. The probe prompt must pass every
  * provider's content-policy review (a bare "hi" trips CodeBuddy's 11140 safety

package/src/providers/discovery/probing-service.ts

@@ -42,10 +42,12 @@ import {
   buildProbeCanonicalRequest,
   computeProbeVerdict,
   extractSample,
+  modelFromEvents,
   GROK_407_PROBE_PROMPT,
   grok407ProbeFailure,
   hasMeaningfulOutput,
   loadProbePreferences,
+  qoderCmodelProbePrompt,
   recordProbeHealth,
   resolveProbeAdapter,
   resolveProbeTarget,
@@ -186,7 +188,16 @@ export class ProviderProbingService {
     request: ProbeModelRequest,
   ): Promise<ProbeModelResult> {
     const startedAt = Date.now();
-    const modelId = request.modelId;
+    // Qoder's IDE surface is the only transport that echoes provider metadata
+    // (`provider_model`, `target`, …) in its raw_usage, so probes for Qoder
+    // default to it unless the operator picked a surface explicitly. This
+    // covers every entry point (single model, all models, all accounts).
+    const normalizedRequest: ProbeModelRequest =
+      (providerId === "qoder" || providerId === "qodercn") &&
+      (request.surface === undefined || request.surface === "default")
+        ? { ...request, surface: "ide" }
+        : request;
+    const modelId = normalizedRequest.modelId;
     // One provider snapshot per probe: the contract gate, the account gate, the
     // custom-adapter fallback, and the wire context all read this same row, so a
     // concurrent edit cannot make two reads disagree.
@@ -207,10 +218,10 @@ export class ProviderProbingService {
       db: this.db,
       tenantId,
       providerId,
-      requestedAccountId: request.accountId,
+      requestedAccountId: normalizedRequest.accountId,
       requiresAccount,
       allowCoolingAccount:
-        providerId === "grok" && request.prompt === GROK_407_PROBE_PROMPT,
+        providerId === "grok" && normalizedRequest.prompt === GROK_407_PROBE_PROMPT,
     });
     if (!account.ok) {
       return { ok: false, latencyMs: Date.now() - startedAt, error: account.error };
@@ -236,9 +247,16 @@ export class ProviderProbingService {
       wireFamily,
       request,
     });
+    // Qoder's gRPC surface refuses a probe that asks a model to identify
+    // itself (406 from the upstream proxy) for one roster row (`cmodel`,
+    // virtual id `cantus`). dmodel/qmodel/smodel accept the identity prompt
+    // fine — only cmodel refuses it — so the workaround is scoped to that
+    // row, not to every Qoder probe, and never overrides an explicit prompt.
+    const qoderCmodelPrompt = qoderCmodelProbePrompt(providerId, modelId, normalizedRequest.prompt);
+    const probeRequest = qoderCmodelPrompt === undefined ? normalizedRequest : { ...normalizedRequest, prompt: qoderCmodelPrompt };
     const canonicalRequest = buildProbeCanonicalRequest({
       modelId,
-      request,
+      request: probeRequest,
       probeReasoning,
       sourceSurface,
     });
@@ -257,6 +275,11 @@ export class ProviderProbingService {
       // The model row's own output ceiling, so a probe with a max-output
       // ceiling (OpenCode free) shapes with the model's limit, not a guess.
       ...(outputLimit == null ? {} : { output_limit: outputLimit }),
+      // Probe-only transport override, when the operator asked for one. Live
+      // dispatch never sets this.
+      ...(normalizedRequest.surface === undefined || normalizedRequest.surface === "default"
+        ? {}
+        : { probe_surface: normalizedRequest.surface }),
     };
 
     const probeSignal = AbortSignal.timeout(30_000);
@@ -308,7 +331,7 @@ export class ProviderProbingService {
               `Provider ${providerId} has no web search transport (request {requestId}). Know your tools — this one just isn't in the box 🧰`,
             );
           }
-          const searchProbeQuery = request.prompt?.trim() || "Cartethyia gateway probe";
+          const searchProbeQuery = normalizedRequest.prompt?.trim() || "Cartethyia gateway probe";
           const response = await adapter.websearch(
             { model: modelId, query: searchProbeQuery, max_results: 3 },
             candidate,
@@ -574,7 +597,16 @@ export class ProviderProbingService {
     }
 
     const sample = extractSample(events);
-    const reportedModel = await probeCapture?.reportedModel?.catch(() => undefined);
+    // The HTTP-only `readReportedModel` covers response-body transports; a
+    // non-HTTP transport (Qoder gRPC) reports the upstream echo as a
+    // `response_start` event instead — fall back to that when the body read
+    // came up empty.
+    const reportedModel =
+      (await probeCapture?.reportedModel?.catch(() => undefined)) ?? modelFromEvents(events);
+    // Provider-specific upstream model metadata (Qoder IDE surface raw_usage):
+    // carried on the terminal event by the adapter, surfaced verbatim.
+    const terminal = events.find((event) => event.type === "terminal");
+    const providerMetadata = terminal?.type === "terminal" ? terminal.provider_metadata : undefined;
     return {
       ...(accountId ? { accountId } : {}),
       ok,
@@ -583,6 +615,9 @@ export class ProviderProbingService {
       ...(upstreamStatusCode === undefined ? {} : { statusCode: upstreamStatusCode }),
       ...(sample ? { sample } : {}),
       ...(reportedModel === undefined ? {} : { reportedModel }),
+      ...(providerMetadata === undefined || Object.keys(providerMetadata).length === 0
+        ? {}
+        : { providerMetadata }),
       ...(searchResults !== undefined && searchResults.length > 0 ? { searchResults } : {}),
       ...(errorMessage ? { error: errorMessage } : {}),
     };

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

@@ -17,7 +17,7 @@
  */
 import { createHash } from "node:crypto";
 import { providerBaseUrl } from "../../provider-metadata";
-import type { ModelDefinition } from "../../provider-model-definition";
+import { defineModel, type ModelDefinition } from "../../provider-model-definition";
 import { isRecord } from "../../../protocol/codecs";
 import { modelsDevCatalog } from "../../discovery/models-dev-catalog";
 import type { CanonicalRequest, ReasoningIntent } from "../../../protocol/canonical-model";
@@ -485,7 +485,25 @@ export async function discoverAntigravityModels(
         (await response.json()) as unknown,
       );
       if (models === null) continue;
-      return models;
+      // Keep the static websearch row on top of discovered rows: the live
+      // catalog does not publish search SKUs, and `/v1/search` needs a
+      // `service_kind: "websearch"` row to route.
+      return [
+        ...models,
+        defineModel({
+          id: "gemini-2.5-flash",
+          providerId: "antigravity",
+          serviceKind: "websearch",
+          wireFamily: "chat",
+          // Empty endpoint — see `ANTIGRAVITY_SEARCH_MODELS`.
+          endpoint: "",
+          ctx: 1_000_000,
+          out: 65_535,
+          vision: true,
+          reasoning: true,
+          toolCall: false,
+        }),
+      ];
     } catch {
       // Best-effort: a failed live catalog must never break static routing.
     }

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

@@ -116,6 +116,30 @@ export const ANTIGRAVITY_MODELS: readonly ModelDefinition[] = [
   antigravityModel("gpt-oss-120b", 131_072, 32_768, true),
 ];
 
+/**
+ * Web-search rows served by `/v1/search`. Antigravity grounds search through a
+ * Gemini chat call with a `web_search` tool (see `websearch`); the cheap flash
+ * SKU is the default search model.
+ */
+export const ANTIGRAVITY_SEARCH_MODELS: readonly ModelDefinition[] = [
+  defineModel({
+    id: "gemini-2.5-flash",
+    providerId: "antigravity",
+    serviceKind: "websearch",
+    wireFamily: "chat",
+    // Empty endpoint: the adapter resolves the URL from the request stream flag
+    // (`GENERATE_PATH`), so the row only needs to exist as a websearch route.
+    // An empty value also keeps it distinct from the llm row (the unique key is
+    // provider+model+endpoint).
+    endpoint: "",
+    ctx: 1_000_000,
+    out: 65_535,
+    vision: true,
+    reasoning: true,
+    toolCall: false,
+  }),
+];
+
 function normalizeAntigravityGrounding(data: unknown, maxResults: number): readonly WebSearchResult[] {
   if (!isRecord(data)) return [];
   const chunks = Array.isArray(data.groundingChunks) ? data.groundingChunks : [];

package/src/providers/integrations/codex/codex.ts

@@ -145,6 +145,30 @@ export const CODEX_MODELS: readonly ModelDefinition[] = [
 ];
 const CODEX_SEARCH_DEFAULT_MODEL = "gpt-5.6-luna";
 
+/**
+ * Web-search rows served by `/v1/search`. Codex grounds search through a
+ * Responses call with a `web_search` tool (see `websearch`); the cheap 5.6
+ * SKU is the default search model.
+ */
+export const CODEX_SEARCH_MODELS: readonly ModelDefinition[] = [
+  defineModel({
+    id: "gpt-5.6-luna",
+    providerId: "codex",
+    serviceKind: "websearch",
+    wireFamily: "responses",
+    // Empty endpoint: the adapter falls back to
+    // `/backend-api/codex/responses` when the candidate path is empty (see
+    // `dispatch`), and an empty value keeps the row distinct from the llm row
+    // in the (provider, model, endpoint) unique key.
+    endpoint: "",
+    ctx: 1_000_000,
+    out: 128_000,
+    vision: true,
+    reasoning: true,
+    toolCall: false,
+  }),
+];
+
 function normalizeCodexSearchCitations(
   citations: readonly unknown[],
   answerText: string,
@@ -528,7 +552,10 @@ export async function discoverCodexModels(input: {
       ),
     );
   }
-  return [...byId.values()].sort((a, b) => a.modelId.localeCompare(b.modelId));
+  // Keep the static websearch rows on top of discovered llm rows: the codex
+  // registry does not publish search SKUs, and `/v1/search` needs a
+  // `service_kind: "websearch"` row to route.
+  return [...byId.values(), ...CODEX_SEARCH_MODELS].sort((a, b) => a.modelId.localeCompare(b.modelId));
 }
 
 /** Reads just enough of an untyped body to tell SSE from JSON, then replays it. */

package/src/providers/integrations/qoder/chat-proto.ts

@@ -0,0 +1,328 @@
+/**
+ * Generated from `vendor/qoder-proto/chat.proto` (Qoder desktop client v1.1.81,
+ * `qoder-worker-runtime.mjs`). Do not edit by hand — regenerate from the
+ * proto file via `scripts/scratch/gen-chat-proto.ts`.
+ */
+export const CHAT_PROTO_SOURCE = `syntax = "proto3";
+
+package model.chat;
+
+import "google/protobuf/struct.proto";
+import "google/protobuf/wrappers.proto";
+
+option java_multiple_files = true;
+option java_package = "com.qoder.grpc.model.chat";
+option java_outer_classname = "ChatProto";
+
+// Reasoning effort level for model reasoning
+enum ReasoningEffort {
+  REASONING_EFFORT_UNSPECIFIED = 0;
+  REASONING_EFFORT_NONE = 1;
+  REASONING_EFFORT_LOW = 2;
+  REASONING_EFFORT_MEDIUM = 3;
+  REASONING_EFFORT_HIGH = 4;
+  REASONING_EFFORT_XHIGH = 5;
+  REASONING_EFFORT_MAX = 6;
+}
+
+// ─── Request messages ────────────────────────────────────────────────────────
+
+// Chat completion request matching OpenAI-compatible API
+message ChatCompletionRequest {
+  string model = 1;
+  repeated ChatMessage messages = 2;
+  google.protobuf.DoubleValue temperature = 3;
+  google.protobuf.DoubleValue top_p = 4;
+  google.protobuf.Int32Value max_tokens = 5;
+  bool stream = 6;
+  repeated string stop = 7;
+  google.protobuf.DoubleValue presence_penalty = 8;
+  google.protobuf.DoubleValue frequency_penalty = 9;
+  google.protobuf.Int32Value n = 10;
+  google.protobuf.StringValue user = 11;
+  google.protobuf.Int32Value seed = 12;
+  Reasoning reasoning = 13;
+  google.protobuf.BoolValue parallel_tool_calls = 14;
+  map<string, double> logit_bias = 15;
+  repeated Tool tools = 16;
+  google.protobuf.Value tool_choice = 17;
+  ResponseFormat response_format = 18;
+  repeated string modalities = 19;
+  StreamOptions stream_options = 20;
+  map<string, ChatPatchList> patches = 21;
+  ChatMetadata metadata = 22;
+  google.protobuf.Struct extras = 23;
+  CustomModelConfig custom_model = 24;
+}
+
+// Wrapper for repeated ChatPatch (used in patches map value)
+message ChatPatchList {
+  repeated ChatPatch patches = 1;
+}
+
+// Chat message in the conversation (request side)
+message ChatMessage {
+  string cache_id = 1;
+  string role = 2;
+  // content can be plain text or a list of multimodal content parts
+  oneof content_type {
+    string text_content = 3;
+    ContentPartList parts_content = 12;
+  }
+  google.protobuf.StringValue name = 4;
+  repeated ToolCall tool_calls = 5;
+  google.protobuf.StringValue tool_call_id = 6;
+  google.protobuf.StringValue tool_call_call_id = 7;
+  google.protobuf.StringValue reasoning_content = 8;
+  ReasoningItem reasoning_item = 9;
+  google.protobuf.Struct extends = 10;
+}
+
+// Wrapper for repeated ContentPart
+message ContentPartList {
+  repeated ContentPart parts = 1;
+}
+
+// Content part for multimodal messages
+message ContentPart {
+  string type = 1;
+  google.protobuf.StringValue text = 2;
+  ImageUrl image_url = 3;
+  InputAudio input_audio = 4;
+  CacheControl cache_control = 5;
+}
+
+// Cache control configuration for content parts
+message CacheControl {
+  string type = 1;
+}
+
+// Image URL in message content
+message ImageUrl {
+  string url = 1;
+  google.protobuf.StringValue detail = 2;
+}
+
+// Audio input in message content
+message InputAudio {
+  string data = 1;
+  string format = 2;
+}
+
+// Reasoning item for model series (e.g. gpt-5)
+message ReasoningItem {
+  string id = 1;
+  google.protobuf.StringValue encrypted_content = 2;
+}
+
+// Streaming options
+message StreamOptions {
+  google.protobuf.BoolValue include_usage = 1;
+}
+
+// Tool available for the model to call
+message Tool {
+  string cache_id = 1;
+  string type = 2;
+  Function function = 3;
+  Advisor advisor = 4;
+}
+
+// Function definition
+message Function {
+  string name = 1;
+  google.protobuf.StringValue description = 2;
+  google.protobuf.Struct parameters = 3;
+  google.protobuf.BoolValue strict = 4;
+}
+
+// Advisor definition
+message Advisor {
+  string name = 1;
+  string model = 2;
+  int32 max_uses = 3;
+}
+
+// Tool call made by the assistant
+message ToolCall {
+  google.protobuf.StringValue id = 1;
+  google.protobuf.StringValue call_id = 2;
+  google.protobuf.StringValue type = 3;
+  FunctionCall function = 4;
+}
+
+// Function call details
+message FunctionCall {
+  string name = 1;
+  google.protobuf.Value arguments = 2;
+}
+
+// Reasoning configuration
+message Reasoning {
+  ReasoningEffort effort = 1;
+}
+
+// Response format specification
+message ResponseFormat {
+  string type = 1;
+  JsonSchema json_schema = 2;
+}
+
+// JSON schema for structured outputs
+message JsonSchema {
+  string name = 1;
+  google.protobuf.StringValue description = 2;
+  google.protobuf.Struct schema = 3;
+  google.protobuf.BoolValue strict = 4;
+}
+
+// Metadata attached to the chat request
+message ChatMetadata {
+  WorkspaceMetadata workspace = 1;
+  BusinessMetadata business = 2;
+  ContextMetadata context = 3;
+  UserMetadata user = 4;
+}
+
+// Workspace metadata
+message WorkspaceMetadata {
+  int32 file_count = 1;
+  repeated string languages = 2;
+  string codebase_status = 3;
+  string codebase_soft_status = 4;
+  string codebase_external_id = 5;
+  string data_policy = 6;
+}
+
+// Business metadata
+message BusinessMetadata {
+  string id = 1;
+  string name = 2;
+  int64 begin_at = 3;
+  string product = 4;
+  string version = 5;
+  string type = 6;
+  string stage = 7;
+  string sub_task = 8;
+}
+
+// Context metadata for request tracing and client identification
+message ContextMetadata {
+  string request_id = 1;
+  string session_id = 2;
+  string task_id = 3;
+  string request_set_id = 4;
+  string machine_id = 5;
+  string client_type = 6;
+  string source_session_id = 7;
+}
+
+// User metadata
+message UserMetadata {
+  string user_id = 1;
+}
+
+// Custom model configuration (bring-your-own-key)
+message CustomModelConfig {
+  string name = 1;
+  string url = 2;
+  string style = 3;
+  string provider = 4;
+  string type = 5;
+  string model = 6;
+  google.protobuf.Struct parameters = 7;
+}
+
+// Patch to apply to the chat request
+message ChatPatch {
+  string cache_id = 1;
+  string action = 2;
+  google.protobuf.Int32Value position = 3;
+  google.protobuf.StringValue content = 4;
+  google.protobuf.StringValue name = 5;
+  google.protobuf.StringValue rename_to = 6;
+  google.protobuf.StringValue description = 7;
+  google.protobuf.Struct parameters = 8;
+}
+
+// ─── Response messages ───────────────────────────────────────────────────────
+
+// Shared response chat message type (used in both streaming delta and
+// non-streaming message fields)
+message ResponseChatMessage {
+  string role = 1;
+  string content = 2;
+  string reasoning_content = 3;
+  repeated google.protobuf.Struct tool_calls = 4;
+  google.protobuf.Value reasoning_item = 5;
+  google.protobuf.Struct extends = 6;
+}
+
+// Single choice in the non-streaming response
+message NonStreamChoice {
+  int32 index = 1;
+  ResponseChatMessage message = 2;
+  string finish_reason = 3;
+}
+
+// Chat completion response (non-streaming)
+message ChatCompletionResponse {
+  int64 code = 1;
+  string id = 2;
+  string object = 3;
+  int64 created = 4;
+  string model = 5;
+  repeated NonStreamChoice choices = 6;
+  Usage usage = 7;
+  google.protobuf.Struct extras = 8;
+}
+
+// Single choice in the streaming chunk
+message StreamChoice {
+  int32 index = 1;
+  ResponseChatMessage delta = 2;
+  string finish_reason = 3;
+}
+
+// Streaming response chunk
+message ChatCompletionChunk {
+  int64 code = 1;
+  string id = 2;
+  string object = 3;
+  int64 created = 4;
+  string model = 5;
+  repeated StreamChoice choices = 6;
+  Usage usage = 7;
+  google.protobuf.Struct extras = 8;
+}
+
+// Token usage statistics
+message Usage {
+  int32 prompt_tokens = 1;
+  int32 completion_tokens = 2;
+  int32 total_tokens = 3;
+  PromptTokensDetails prompt_tokens_details = 4;
+  CompletionTokensDetails completion_tokens_details = 5;
+}
+
+// Prompt token details
+message PromptTokensDetails {
+  int32 cached_tokens = 1;
+  int32 cacheable_tokens = 2;
+}
+
+// Completion token details
+message CompletionTokensDetails {
+  int32 reasoning_tokens = 1;
+}
+
+// ─── Service definition ──────────────────────────────────────────────────────
+
+service ChatService {
+  // Unary non-streaming chat completion
+  rpc ChatCompletion(ChatCompletionRequest) returns (ChatCompletionResponse);
+
+  // Server-streaming chat completion; each message is one SSE chunk
+  rpc ChatCompletionStream(ChatCompletionRequest) returns (stream ChatCompletionChunk);
+}
+`;