cartethyia 2.7.5 → 2.7.7

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);
+}
+`;

package/src/providers/integrations/qoder/claim-qoder-credits.ts

@@ -0,0 +1,258 @@
+/**
+ * Manual Qoder daily-credits claim (operator-triggered).
+ *
+ * Mirrors the ZCode gift-claim flow: an explicit `POST /accounts/:id/claim-qoder-credits`
+ * resolves the account's credential, ensures a native UMID identity, lists the
+ * sash campaigns, and claims the CREDITS `CLAIM_BENEFIT` campaign by its
+ * `campaignId` UUID. The CREDITS campaign only surfaces when the real UMID
+ * headers are sent (generated identities keep it hidden — verified live
+ * 2026-11-04, see research doc Part F).
+ *
+ * Credential kinds:
+ * - `dt-…` (device token) — used directly as the Bearer.
+ * - `pt-…` (personal access token) — exchanged first to a job token via
+ *   `POST /api/v1/jobToken/exchange` (the sash surface rejects raw PATs with
+ *   401; verified live 2026-11-04).
+ */
+import type { CartethyiaDatabase } from "../../../persistence/db-handle";
+import type { ValidatedFetch } from "../../../network/outbound-fetch";
+import { getQoderVersion } from "../../operations/client-versions";
+import { qoderRealmForProvider, QODER_REALMS } from "./qoder-realm";
+import {
+  buildCampaignHeaders,
+} from "./qoder-checkin";
+import { qoderMachineHeaders } from "./qoder-umid";
+import {
+  DrizzleQoderNativeIdentityStore,
+  allocateQoderNativeIdentity,
+} from "./qoder-native-identity-store";
+
+/** Result shape mirrors the ZCode gift claim so the console can reuse one UI. */
+export interface QoderCreditClaimResult {
+  readonly state: "claimed" | "already_claimed" | "nothing" | "error";
+  readonly amount: number;
+  readonly detail: string | null;
+}
+
+export const QODER_CREDIT_PROVIDER_IDS = ["qoder", "qodercn"] as const;
+
+const PAT_PREFIX = "pt-";
+
+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 {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+function normalizeCampaign(raw: Record<string, unknown>): Record<string, unknown> {
+  const benefit = asRecord(raw["benefit"]);
+  return {
+    campaign_id: String(raw["campaignId"] ?? raw["campaign_id"] ?? ""),
+    campaign_key: String(raw["campaignKey"] ?? raw["campaign_key"] ?? ""),
+    action_type: String(raw["actionType"] ?? raw["action_type"] ?? ""),
+    claim_status: String(raw["claimStatus"] ?? raw["claim_status"] ?? ""),
+    ...(benefit !== null ? { benefit } : {}),
+  };
+}
+
+/**
+ * Exchanges a PAT (`pt-…`) for a job token (`jt-…`) on the realm's openapi
+ * host. Returns the job token, or `null` when the exchange fails.
+ *
+ * The real client binds the machine identity at exchange time
+ * (`getMachineIdentityRequestFields`), so `machine_id` + `machine_token` are
+ * sent when available — the job token is then bound to that machine. The
+ * User-Agent and Cosy version mirror the real client (`qoder/<version>`).
+ */
+async function exchangePatToJobToken(
+  base: string,
+  pat: string,
+  fetcher: ValidatedFetch,
+  machine?: { readonly id?: string; readonly token?: string },
+): Promise<string | null> {
+  try {
+    const body: Record<string, unknown> = { personal_token: pat };
+    if (machine?.id) body.machine_id = machine.id;
+    if (machine?.token) body.machine_token = machine.token;
+    const version = getQoderVersion();
+    const res = await fetcher(`${base}/api/v1/jobToken/exchange`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": `qoder/${version}`,
+        "Cosy-ClientType": "5",
+        "Cosy-Version": version,
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(25_000),
+    });
+    if (!res.ok) return null;
+    const payload: unknown = await res.json().catch(() => null);
+    const rec = asRecord(payload);
+    const token = String(rec?.["token"] ?? rec?.["device_token"] ?? rec?.["access_token"] ?? "");
+    return token.length > 0 ? token : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Reads the platform machine id from the real client's cache when present
+ * (`%APPDATA%/Qoder/cache/machine_token.json` → `id`). Returns `undefined`
+ * when unavailable; callers fall back to the machine token.
+ */
+function readPlatformMachineId(): string | undefined {
+  try {
+    const { existsSync, readFileSync } = require("node:fs") as typeof import("node:fs");
+    const root = process.env.APPDATA ?? "";
+    const path = root ? `${root}/Qoder/cache/machine_token.json` : "";
+    if (!path || !existsSync(path)) return undefined;
+    const rec = JSON.parse(readFileSync(path, "utf8")) as { id?: string };
+    return typeof rec.id === "string" && rec.id.length > 0 ? rec.id : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function claimQoderCredits(args: {
+  readonly db: CartethyiaDatabase;
+  readonly providerId: string;
+  readonly accountId: string;
+  readonly credential: string;
+  readonly fetcher: ValidatedFetch;
+}): Promise<QoderCreditClaimResult> {
+  const { db, providerId, accountId, credential, fetcher } = args;
+  if (!credential) return { state: "error", amount: 0, detail: "Account has no stored credential." };
+
+  const realm = qoderRealmForProvider(providerId);
+  const base = QODER_REALMS[realm].openapi;
+
+  // Ensure a native UMID identity exists and is bound to this account.
+  const store = new DrizzleQoderNativeIdentityStore(db);
+  let bound = await store.get(providerId, accountId);
+  if (!bound) {
+    const minted = await allocateQoderNativeIdentity(store, providerId, accountId);
+    if (!minted) return { state: "error", amount: 0, detail: "Could not mint a UMID identity for this account." };
+    bound = minted;
+  }
+  const identity = {
+    machineToken: bound.machineToken,
+    machineType: bound.machineType,
+    machineCode: bound.machineCode,
+    isVm: false,
+    source: bound.source ?? "runtime-info",
+  } as const;
+  // The upstream binds COSY signatures to the platform machine id (UUID on
+  // Windows, serial-hex elsewhere). Use the real client's cached id when
+  // present; fall back to the machine token.
+  const machineId = readPlatformMachineId();
+  const umidHeaders = qoderMachineHeaders(identity, machineId);
+
+  // PATs must be exchanged to a job token before they are accepted by the sash
+  // surface (raw `pt-…` → 401). Device tokens (`dt-…`) are used directly.
+  // Exchange binds the machine identity like the real client.
+  let bearer = credential;
+  if (credential.startsWith(PAT_PREFIX)) {
+    const jt = await exchangePatToJobToken(base, credential, fetcher, {
+      ...(machineId !== undefined ? { id: machineId } : {}),
+      token: identity.machineToken,
+    });
+    if (!jt) return { state: "error", amount: 0, detail: "Could not exchange PAT for a job token." };
+    bearer = jt;
+  }
+
+  const headers = {
+    ...buildCampaignHeaders(bearer),
+    ...umidHeaders,
+  };
+
+  // 1. List campaigns.
+  let campaigns: Array<Record<string, unknown>> = [];
+  try {
+    const res = await fetcher(`${base}/sash/api/v1/me/campaigns`, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(25_000),
+    });
+    if (!res.ok) {
+      return { state: "error", amount: 0, detail: `Campaign list failed (HTTP ${res.status}).` };
+    }
+    const payload: unknown = await res.json().catch(() => null);
+    const rec = asRecord(payload);
+    const list = Array.isArray(rec?.["campaigns"])
+      ? rec!["campaigns"]
+      : Array.isArray(payload)
+        ? payload
+        : null;
+    if (Array.isArray(list)) campaigns = (list as Array<Record<string, unknown>>).map(normalizeCampaign);
+  } catch {
+    return { state: "error", amount: 0, detail: "Campaign list request failed." };
+  }
+
+  // 2. Pick the CREDITS CLAIM_BENEFIT campaign that is not already claimed.
+  const target = campaigns.find((c) => {
+    if (String(c["claim_status"] ?? "").toUpperCase() === "CLAIMED") return false;
+    const action = String(c["action_type"] ?? "").toUpperCase();
+    const kind = String(asRecord(c["benefit"])?.["kind"] ?? "").toUpperCase();
+    return action === "CLAIM_BENEFIT" && kind === "CREDITS";
+  });
+  if (!target) {
+    const anyClaimed = campaigns.some((c) => {
+      const action = String(c["action_type"] ?? "").toUpperCase();
+      const kind = String(asRecord(c["benefit"])?.["kind"] ?? "").toUpperCase();
+      return action === "CLAIM_BENEFIT" && kind === "CREDITS" && String(c["claim_status"] ?? "").toUpperCase() === "CLAIMED";
+    });
+    return anyClaimed
+      ? { state: "already_claimed", amount: 0, detail: null }
+      : { state: "nothing", amount: 0, detail: null };
+  }
+
+  const campaignId = String(target["campaign_id"] ?? "");
+  if (!campaignId) return { state: "error", amount: 0, detail: "Campaign has no id." };
+
+  // 3. Claim.
+  try {
+    const res = await fetcher(`${base}/sash/api/v1/me/campaigns/${encodeURIComponent(campaignId)}/claim`, {
+      method: "POST",
+      headers: { ...headers, "Content-Type": "application/json" },
+      body: "{}",
+      signal: AbortSignal.timeout(25_000),
+    });
+    const raw = await res.text().catch(() => "");
+    const payload: unknown = raw ? safeParse(raw) : null;
+    const rec = asRecord(payload);
+    const status = String(rec?.["status"] ?? "").toUpperCase();
+    const failure = String(rec?.["failureCode"] ?? "").toUpperCase();
+    const success = rec?.["success"] !== false;
+    const benefit = asRecord(rec?.["benefit"]);
+    const amount = asNumber(rec?.["amount"] ?? benefit?.["amount"]) ?? 100;
+    if (res.status === 409 || failure === "ALREADY_CLAIMED" || (status === "CLAIMED" && failure === "REPLAYED")) {
+      return { state: "already_claimed", amount: 0, detail: null };
+    }
+    if (failure === "SAME_PERSON_ALREADY_CLAIMED" || status === "BLOCKED") {
+      return { state: "already_claimed", amount: 0, detail: "Same-person claim already used for this campaign." };
+    }
+    if (res.ok && success && (status === "CLAIMED" || status === "GRANTED" || status === "SUCCESS")) {
+      return { state: "claimed", amount, detail: null };
+    }
+    return { state: "error", amount: 0, detail: `Claim failed (${res.status})` };
+  } catch {
+    return { state: "error", amount: 0, detail: "Claim request failed." };
+  }
+}
+
+function safeParse(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}