cartethyia 2.7.8 → 2.8.0

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

@@ -14,9 +14,10 @@ import type {
 } from "../../../protocol/canonical-model";
 import { toolResultParts, toolCallParts } from "../../../protocol/canonical-model";
 import { reasoningEffortFromIntent } from "../../../protocol/reasoning";
+import { reasoningTextForReplay } from "../../../protocol/reasoning-text";
 import { resolveImageSource } from "../../../protocol/codecs";
 import { getQoderVersion } from "../../operations/client-versions";
-import { qoderDiscoveredMaxContexts, QODER_CN_MODEL_CONFIGS, QODER_INTL_MODEL_CONFIGS } from "./qoder-catalog";
+import { qoderMaxContextFor, qoderRosterMaxOutput } from "./qoder-catalog";
 import { transformQoderBody, qoderBuildCosyHeaders } from "./qoder-cosy";
 import { qoderSessionId } from "./qoder-auth";
 import { flattenCanonicalContent, qoderToolChoice, qoderTools } from "./qoder-body";
@@ -69,12 +70,6 @@ function qoderStableRecordId(modelId: string, messages: CanonicalRequest["messag
  * never capped at the *currently active* window (often 180k) when the account
  * can use 1M. Falls back to the static roster's stated window otherwise.
  */
-function qoderMaxContextFor(modelId: string, modelConfig: QoderModelConfig, realm: QoderRealm): number {
-  const discovered = qoderDiscoveredMaxContexts(realm).get(modelId);
-  if (discovered !== undefined) return discovered;
-  return modelConfig.max_input_tokens;
-}
-
 function qoderRequestedMaxTokens(
   request: CanonicalRequest,
   modelConfig: QoderModelConfig,
@@ -91,7 +86,7 @@ function qoderRequestedMaxTokens(
   const configured =
     typeof modelConfig.max_output_tokens === "number"
       ? modelConfig.max_output_tokens
-      : qoderRosterMaxOutput(modelConfig.id, realm) ?? 65_536;
+      : qoderRosterMaxOutput(realm === "cn" ? "qodercn" : "qoder", modelConfig.id) ?? 65_536;
   const controls = request.generation_controls as Record<string, unknown>;
   const requested =
     typeof controls["max_tokens"] === "number"
@@ -102,17 +97,6 @@ function qoderRequestedMaxTokens(
   return typeof requested === "number" && requested > 0 ? Math.min(requested, configured) : configured;
 }
 
-/**
- * The static roster's stated output ceiling for one key, when the roster states
- * one. Dispatch builds a live-discovered model's config without an output limit
- * (upstream's model list reports none); this lookup restores the roster's
- * ceiling so such a model is not capped at the 65_536 last resort.
- */
-function qoderRosterMaxOutput(modelId: string, realm: QoderRealm): number | undefined {
-  const configs = realm === "cn" ? QODER_CN_MODEL_CONFIGS : QODER_INTL_MODEL_CONFIGS;
-  return configs[modelId]?.max_output_tokens;
-}
-
 /**
  * Whether this model needs the prior turn's reasoning echoed back.
  *
@@ -159,7 +143,9 @@ function qoderReasoningEcho(
     return hasReasoningTrace ? { reasoning_content: "" } : {};
   }
   const text = reasoning
-    .map((part) => (part.kind === "reasoning" ? (part.summary ?? part.payload ?? "") : ""))
+    .map((part) =>
+      part.kind === "reasoning" ? (reasoningTextForReplay(part) ?? part.payload ?? "") : "",
+    )
     .join("");
   return { reasoning_content: text };
 }
@@ -448,7 +434,7 @@ export function buildQoderRequest(
       // for every model alike, so the request would declare a cap the catalog
       // does not publish. A discovered model's config carries no output limit,
       // so consult the roster for the key before the 65_536 last resort.
-      max_output_tokens: modelConfig.max_output_tokens ?? qoderRosterMaxOutput(modelId, realm) ?? 65_536,
+      max_output_tokens: modelConfig.max_output_tokens ?? qoderRosterMaxOutput(realm === "cn" ? "qodercn" : "qoder", modelId) ?? 65_536,
       source: modelConfig.source ?? "system",
     },
     messages: qoderMessages,

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

@@ -1,6 +1,6 @@
 /**
  * Qoder daily check-in (streak / 100 Credits per day), ported from the
- * reference bridge (`qoder_accounts.py` in `qoder2api-hub`).
+ * reference bridge (`qoder_accounts.py` in the donor hub).
  *
  * Two upstream surfaces, tried in order:
  *
@@ -79,12 +79,12 @@ function campaignHeaders(credential: string): Record<string, string> {
   return buildCampaignHeaders(credential);
 }
 
-function asRecord(value: unknown): Record<string, unknown> | null {
+export function asRecord(value: unknown): Record<string, unknown> | null {
   if (typeof value !== "object" || value === null) return null;
   return value as Record<string, unknown>;
 }
 
-function asNumber(value: unknown): number | null {
+export function asNumber(value: unknown): number | null {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "string" && value.trim() !== "") {
     const parsed = Number(value);
@@ -93,7 +93,7 @@ function asNumber(value: unknown): number | null {
   return null;
 }
 
-function safeParse(raw: string): unknown {
+export function safeParse(raw: string): unknown {
   try {
     return JSON.parse(raw);
   } catch {
@@ -127,7 +127,7 @@ function asState(state: string, today: string, lastClaimedAt: unknown): { active
  * consumes. The API returns camelCase keys (`campaignId`, `actionType`,
  * `claimStatus`); the fixtures and the donor hub use snake_case — accept both.
  */
-function normalizeCampaign(raw: Record<string, unknown>): Record<string, unknown> {
+export function normalizeCampaign(raw: Record<string, unknown>): Record<string, unknown> {
   const benefit = asRecord(raw["benefit"]);
   return {
     campaign_id: String(raw["campaignId"] ?? raw["campaign_id"] ?? ""),
@@ -443,7 +443,7 @@ export async function fetchQoderDailyCheckin(args: {
     }
   }
   if (!bound && store) {
-    const minted = await allocateQoderNativeIdentity(store, providerId, accountId);
+    const minted = await allocateQoderNativeIdentity(store, providerId, accountId, { realm });
     if (minted) {
       boundRecord = minted;
       bound = {

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

@@ -20,7 +20,8 @@ import { join } from "node:path";
 import * as grpc from "@grpc/grpc-js";
 import * as protoLoader from "@grpc/proto-loader";
 import { GatewayError } from "../../../protocol/gateway-error";
-import type { CanonicalEvent, CanonicalRequest, CanonicalStopReason } from "../../../protocol/canonical-model";
+import type { CanonicalEvent, CanonicalRequest, CanonicalStopReason, UsageRecord } from "../../../protocol/canonical-model";
+import type { ProviderCaptureExchange } from "../../provider-contracts";
 import { usageFromProvider } from "../../provider-usage";
 import { getQoderVersion } from "../../operations/client-versions";
 import { qoderMachineOs, qoderMachineHostname } from "../../operations/cli-platform";
@@ -361,7 +362,6 @@ export function buildQoderGrpcRequest(
   modelId: string,
   request: CanonicalRequest,
   userId: string,
-  _contextWindow = 1_000_000,
   legacy?: {
     readonly messages: Array<Record<string, unknown>>;
     readonly tools?: Array<Record<string, unknown>>;
@@ -440,6 +440,65 @@ export function qoderGrpcMetadata(auth: QoderAuth, modelId = ""): grpc.Metadata
   return metadata;
 }
 
+/**
+ * gRPC metadata headers safe to persist in the provider-request panel.
+ *
+ * Mirrors the HTTP capture allowlist (`CAPTURED_REQUEST_HEADERS` in
+ * `transport/dispatch/attempt-finalize.ts`): session/identity framing is kept,
+ * but credentials are never stored. `authorization` (the Bearer job token) is
+ * deliberately excluded — the HTTP wrapper never captures it, and the gRPC
+ * capture must not either.
+ */
+const GRPC_CAPTURED_HEADERS = [
+  "x-request-id",
+  "x-session-id",
+  "cosy-version",
+  "cosy-clienttype",
+  "cosy-machineos",
+  "cosy-machinehostname",
+  "x-opencode-client",
+  "x-opencode-session",
+  "x-opencode-session-id",
+  "x-opencode-parent-session-id",
+  "x-opencode-request",
+  "x-opencode-project",
+  "x-conversation-id",
+  "x-conversation-request-id",
+  "x-conversation-message-id",
+  "x-root-request-id",
+  "x-trace-id",
+  "traceparent",
+  "b3",
+] as const;
+
+/**
+ * A gRPC exchange is not a `fetch`, so the HTTP capture wrapper never sees it.
+ * The adapter fills the sink directly with a faithful rendering of the proto
+ * call: the request line (grpc method, host, allowlisted metadata, and the
+ * translated body) and a deferred response that resolves to the collected
+ * stream summary.
+ */
+export function captureQoderGrpcRequest(
+  request: Record<string, unknown>,
+  metadata: grpc.Metadata,
+  realm: QoderRealm,
+): Record<string, unknown> {
+  const host = qoderGrpcHost(realm);
+  const map = metadata.getMap() as Record<string, string | string[]>;
+  const headers: Record<string, string> = {};
+  for (const name of GRPC_CAPTURED_HEADERS) {
+    const value = map[name];
+    if (value === undefined) continue;
+    headers[name] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return {
+    method: "POST",
+    url: `grpc://${host}/model.chat.ChatService/ChatCompletionStream`,
+    headers,
+    body: request,
+  };
+}
+
 /** Maps a proto `finish_reason` to the canonical stop reason. */
 function mapFinishReason(raw: string | undefined): CanonicalStopReason | undefined {
   switch (raw) {
@@ -450,6 +509,10 @@ function mapFinishReason(raw: string | undefined): CanonicalStopReason | undefin
       return "tool_use";
     case "length":
       return "length";
+    case "error":
+      return "error";
+    case "refusal":
+      return "refusal";
     default:
       return undefined;
   }
@@ -466,6 +529,7 @@ export async function* qoderGrpcToCanonicalEvents(
   metadata: grpc.Metadata,
   realm: QoderRealm,
   signal: AbortSignal,
+  capture?: ProviderCaptureExchange,
 ): AsyncGenerator<CanonicalEvent> {
   const ChatService = qoderGrpcClient();
   const host = qoderGrpcHost(realm);
@@ -483,6 +547,122 @@ export async function* qoderGrpcToCanonicalEvents(
     // clients reject content after the finish reason. A second terminal is
     // skipped too (the upstream can re-emit the finish frame).
     let finished = false;
+    // Last usage chunk seen; attached to the terminal event (the upstream
+    // streams usage after the finish-reason chunk, and a standalone `usage`
+    // event after terminal breaks strict Messages encoders).
+    let pendingUsage: UsageRecord | undefined;
+    /** Whether the terminal already carried the pending usage. */
+    let terminalEmitted = false;
+    // Capture sinks fed from the same `for await` loop that drives production
+    // events (see `feedCapture`). Declared here so the loop below can call
+    // them; they are assigned when capture is enabled.
+    let feedCapture: ((chunk: unknown) => void) | undefined;
+    let flushToolCalls: (() => void) | undefined;
+    if (capture !== undefined) {
+      capture.request = captureQoderGrpcRequest(request, metadata, realm);
+      capture.response = new Promise((resolve) => {
+        const summary: Record<string, unknown> = {
+          transport: "grpc",
+          chunks: 0,
+          answer_chars: 0,
+          reasoning_chars: 0,
+          tool_calls: 0,
+          models: [] as string[],
+          usage: undefined,
+          stop_reason: undefined,
+          status_code: 0,
+          // Materialized response content (bounded): the text the model
+          // emitted, the reasoning trace, and the tool calls that were
+          // announced. This is what Request Detail shows instead of a bare
+          // statistics block.
+          text: "",
+          reasoning: "",
+          toolCalls: [] as Array<{ index: number; id?: string; name?: string; arguments?: string }>,
+        };
+        // Per-index tool-call fragments (the upstream streams one call at a
+        // time: id + empty args, then argument fragments, index always 0).
+        const toolCallsByIndex = new Map<number, { id?: string; name?: string; arguments?: string }>();
+        const MAX_TEXT_CHARS = 16_000;
+        const MAX_TOOL_CALLS = 50;
+        const MAX_TOOL_ARGS_CHARS = 2_000;
+        // The summary is fed from the SAME `for await` loop that drives the
+        // production event stream (see `feedCapture` below) — a separate
+        // `data` listener raced the iterator and saw nothing (or a different
+        // decode), so tool calls and text never made it into the capture.
+        feedCapture = (chunk: unknown) => {
+          const rec = chunk as Record<string, unknown>;
+          summary["chunks"] = (summary["chunks"] as number) + 1;
+          const model = rec["model"];
+          if (typeof model === "string" && model.length > 0) {
+            const models = summary["models"] as string[];
+            if (!models.includes(model)) models.push(model);
+          }
+          const usage = rec["usage"];
+          if (usage !== undefined && typeof usage === "object") summary["usage"] = usage;
+          const choices = Array.isArray(rec["choices"]) ? (rec["choices"] as Array<Record<string, unknown>>) : [];
+          for (const choice of choices) {
+            const delta = choice["delta"] as Record<string, unknown> | undefined;
+            const content = delta?.["content"];
+            if (typeof content === "string" && content.length > 0) {
+              summary["answer_chars"] = (summary["answer_chars"] as number) + content.length;
+              const text = summary["text"] as string;
+              if (text.length < MAX_TEXT_CHARS) {
+                summary["text"] = (text + content).slice(0, MAX_TEXT_CHARS);
+              }
+            }
+            const reasoning = delta?.["reasoning_content"];
+            if (typeof reasoning === "string" && reasoning.length > 0) {
+              summary["reasoning_chars"] = (summary["reasoning_chars"] as number) + reasoning.length;
+              const reasoningText = summary["reasoning"] as string;
+              if (reasoningText.length < MAX_TEXT_CHARS) {
+                summary["reasoning"] = (reasoningText + reasoning).slice(0, MAX_TEXT_CHARS);
+              }
+            }
+            const calls = delta?.["tool_calls"];
+            if (Array.isArray(calls) && calls.length > 0) {
+              summary["tool_calls"] = (summary["tool_calls"] as number) + calls.length;
+              for (const rawTc of calls) {
+                const tc = fromProtoStruct(rawTc);
+                const index = typeof tc["index"] === "number" ? (tc["index"] as number) : 0;
+                const entry = toolCallsByIndex.get(index) ?? {};
+                const declaredId = tc["id"];
+                if (typeof declaredId === "string" && declaredId.trim().length > 0) entry.id = declaredId.trim();
+                const fn = (tc["function"] ?? {}) as Record<string, unknown>;
+                const name = fn["name"];
+                if (typeof name === "string" && name.trim().length > 0) entry.name = name.trim();
+                const args = fn["arguments"];
+                if (typeof args === "string" && args.length > 0) {
+                  entry.arguments = ((entry.arguments ?? "") + args).slice(0, MAX_TOOL_ARGS_CHARS);
+                }
+                toolCallsByIndex.set(index, entry);
+              }
+            }
+            const finish = choice["finish_reason"];
+            if (typeof finish === "string" && finish.length > 0) summary["stop_reason"] = finish;
+          }
+        };
+        flushToolCalls = () => {
+          const entries = [...toolCallsByIndex.entries()]
+            .sort((a, b) => a[0] - b[0])
+            .slice(0, MAX_TOOL_CALLS)
+            .map(([index, entry]) => ({ index, ...entry }));
+          if (entries.length > 0) summary["toolCalls"] = entries;
+        };
+        stream.on("status", (s: { code?: number; details?: string }) => {
+          summary["status_code"] = s.code ?? 0;
+          summary["grpc_message"] = s.details ?? "";
+        });
+        stream.on("error", (err: Error) => {
+          summary["error"] = err.message;
+          flushToolCalls?.();
+          resolve(summary);
+        });
+        stream.on("end", () => {
+          flushToolCalls?.();
+          resolve(summary);
+        });
+      });
+    }
 
     const abortHandler = () => {
       aborted = true;
@@ -502,6 +682,8 @@ export async function* qoderGrpcToCanonicalEvents(
       const fragmentState: QoderToolFragmentState = {};
       for await (const chunk of stream) {
         if (aborted || signal.aborted) break;
+        // Feed the capture summary from this same chunk (single consumer).
+        feedCapture?.(chunk);
         // The upstream names the model it actually ran in the chunk's `model`
         // field. Surface it once as `response_start` so probes and telemetry
         // can report the real echoed model (the gRPC surface has no HTTP body
@@ -599,24 +781,45 @@ export async function* qoderGrpcToCanonicalEvents(
               yield {
                 type: "terminal",
                 sequence_number: nextSeq(),
-                state: stop === "stop" || stop === "tool_use" ? "complete" : "failed",
+                // `tool_use` and `refusal` are *successful* terminal verdicts:
+                // the model decided to call a tool / declined to answer, but the
+                // response itself is valid — `complete`, never `failed`. A
+                // `failed` state here made attempt-finalize treat a healthy tool
+                // turn as an upstream failure ("empty-handed") and replay it.
+                // A key `error` (or `length`) is the failed case.
+                state: stop === "stop" || stop === "tool_use" || stop === "refusal" ? "complete" : "failed",
                 stop_reason: stop,
                 provider_stop_reason: choice.finish_reason,
+                // The upstream streams `usage` in a trailing chunk *after* the
+                // finish-reason chunk. A separate `usage` event after the
+                // terminal is rejected by strict Anthropic Messages encoders
+                // (the 2.7.8 regression), so the usage is carried here on the
+                // terminal instead — exactly like the IDE surface does.
+                ...(pendingUsage === undefined ? {} : { usage: pendingUsage }),
               };
+              if (pendingUsage !== undefined) terminalEmitted = true;
             }
           }
         }
-        if (chunk.usage && !finished) {
+        if (chunk.usage) {
           const usage = usageFromProvider(chunk.usage);
           if (usage !== undefined) {
-            yield { type: "usage", sequence_number: nextSeq(), usage };
+            // Keep the last usage chunk; it is attached to the terminal above
+            // (and only if no terminal ever arrives, emitted as a standalone
+            // event at stream end).
+            pendingUsage = usage;
           }
         }
       }
       // Tool-call deltas are emitted as they arrive — there is no end-of-stream
       // buffer to flush; the terminal event is yielded by the finish-reason
       // branch above (or synthesized by the caller if the stream ends without
-      // one).
+      // one). If no terminal carried the pending usage (the stream ended
+      // without a finish reason), emit it as a standalone event so telemetry
+      // still sees the upstream's numbers.
+      if (!terminalEmitted && pendingUsage !== undefined) {
+        yield { type: "usage", sequence_number: nextSeq(), usage: pendingUsage };
+      }
     } catch (err: any) {
       const status = err?.code;
       const details = err?.details ?? err?.message ?? "";
@@ -644,7 +847,7 @@ export async function* qoderGrpcToCanonicalEvents(
             "quota_exceeded",
             429,
             "Qoder quota exhausted on the gRPC surface (request {requestId})",
-            {},
+            { providerCode: "quota_exceeded" },
             "upstream",
           );
         }

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

@@ -163,6 +163,8 @@ function mapQoderFinishReason(raw: unknown): CanonicalStopReason | undefined {
   if (raw === "length") return "length";
   if (raw === "tool_calls") return "tool_use";
   if (raw === "content_filter") return "content_filter";
+  if (raw === "error") return "error";
+  if (raw === "refusal") return "refusal";
   return undefined;
 }
 
@@ -402,7 +404,9 @@ export async function* qoderBodyToCanonicalEvents(
   yield {
     type: "terminal",
     sequence_number: seq++,
-    state: "complete",
+    // `error` is a failed terminal; every other stop (stop, tool_use,
+    // refusal, content_filter, length) is a complete turn.
+    state: stopReason === "error" ? "failed" : "complete",
     ...(stopReason === undefined ? {} : { stop_reason: stopReason }),
     ...(_providerStop === undefined ? {} : { provider_stop_reason: _providerStop }),
     usage: usageFromProvider(rawUsage),
@@ -475,110 +479,3 @@ export function buildQoderIdeRequest(
   };
 }
 
-/**
- * Qoder upstream streams are flaky: the IDE surface sometimes answers a full
- * normal stop with reasoning only and no output text/tool calls (observed ~1
- * in 4 runs with Sonus). That is not a valid completion — the lab would show a
- * thought with "No text came back". Replay such a stream before committing to
- * it. `sniffQoderStream` below inspects just enough of the body to make that
- * call without buffering the whole (possibly long) stream.
- */
-
-/**
- * Reads the upstream body just far enough to decide whether it carries real
- * output, then returns a replay stream that re-emits the already-read bytes
- * followed by the rest of the original body. If the body ends before any
- * meaningful output is seen, `meaningful` is false and the caller replays the
- * whole request (empty / thought-only recovery) without ever buffering a large
- * response: the original `drainQoderResponse` read the entire stream before
- * forwarding, which made every stream appear to complete in one burst at the
- * end.
- */
-async function sniffQoderStream(
-  response: Response,
-  signal: AbortSignal,
-): Promise<{ meaningful: boolean; response: Response }> {
-  const body = response.body;
-  if (body === null) return { meaningful: true, response };
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  const pending: Uint8Array[] = [];
-  let inspected = "";
-  let meaningful = false;
-  for (let i = 0; i < 32 && !meaningful; i += 1) {
-    const { done, value } = await reader.read();
-    if (signal.aborted) break;
-    if (done) break;
-    pending.push(value);
-    inspected += decoder.decode(value, { stream: true });
-    // Peek at completed SSE frames only: a content delta or a tool-call
-    // fragment means real output is coming. Reasoning-only streams are NOT
-    // meaningful (they are exactly what empty-stream recovery replays), and a
-    // finish reason alone is not output either.
-    if (/data:/.test(inspected)) {
-      for (const frame of inspected.split(/\r?\n\r?\n/)) {
-        if (!frame.includes("data:")) continue;
-        if (frame.includes('"content":"') || frame.includes('"tool_calls"')) {
-          meaningful = true;
-          break;
-        }
-      }
-    }
-    if (inspected.length > 65536) {
-      meaningful = true;
-      break;
-    }
-  }
-  // Replay: previously-read bytes first, then continue the original body.
-  let offset = 0;
-  const replay = new ReadableStream<Uint8Array>({
-    start(controller) {
-      for (; offset < pending.length; offset += 1) controller.enqueue(pending[offset]);
-    },
-    async pull(controller) {
-      if (offset < pending.length) {
-        controller.enqueue(pending[offset]);
-        offset += 1;
-        return;
-      }
-      const { done, value } = await reader.read();
-      if (signal.aborted) {
-        controller.close();
-        return;
-      }
-      if (done) {
-        controller.close();
-        return;
-      }
-      controller.enqueue(value);
-    },
-    cancel(reason) {
-      return reader.cancel(reason);
-    },
-  });
-  return { meaningful, response: new Response(replay, response) };
-}
-
-/**
- * Runs the IDE request up to `1 + maxReplays` times, returning the first
- * response whose stream carried real output (text or tool calls). A 200 with
- * no output (empty or thought-only) is replayed rather than surfaced. The
- * stream is forwarded progressively (not buffered to completion).
- */
-async function fetchQoderIdeWithEmptyRecovery(
-  requestOnce: () => Promise<Response>,
-  signal: AbortSignal,
-  maxReplays = 2,
-): Promise<Response> {
-  let last: Response | undefined;
-  for (let attempt = 0; attempt <= maxReplays; attempt += 1) {
-    const res = await requestOnce();
-    if (!res.ok || !res.body) return res;
-    const sniff = await sniffQoderStream(res, signal);
-    last = sniff.response;
-    if (sniff.meaningful) return last;
-  }
-  return last!;
-}
-
-export { fetchQoderIdeWithEmptyRecovery };