cartethyia 2.7.6 → 2.7.8

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

@@ -0,0 +1,514 @@
+/**
+ * Qoder legacy COSY chat builder & transport.
+ *
+ * `buildQoderRequest` translates one canonical request into the legacy
+ * `/algo/.../agent_chat_generation` body (and, by reuse, the messages/tools
+ * shared by the IDE and gRPC surfaces). `callQoder` signs and sends it over
+ * the COSY surface with the real client's headers (Bun UA, machine identity,
+ * `x-model-key/source`, SSE accept).
+ */
+import { createHash, randomUUID } from "node:crypto";
+import type {
+  CanonicalRequest,
+  ContentPart,
+} from "../../../protocol/canonical-model";
+import { toolResultParts, toolCallParts } from "../../../protocol/canonical-model";
+import { reasoningEffortFromIntent } from "../../../protocol/reasoning";
+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 { transformQoderBody, qoderBuildCosyHeaders } from "./qoder-cosy";
+import { qoderSessionId } from "./qoder-auth";
+import { flattenCanonicalContent, qoderToolChoice, qoderTools } from "./qoder-body";
+import type { QoderRealm } from "./qoder-realm";
+import type { QoderAuth, QoderModelConfig } from "./qoder-types";
+
+export interface QoderModeProfile {
+  readonly businessProduct: string;
+  readonly businessType: string;
+  readonly cosyScene: string;
+  readonly mirrorTopLevelSystem: boolean;
+  readonly sendBusinessHeaders: boolean;
+  readonly sendModelSourceHeaders: boolean;
+  readonly emptyAliyunUserType: boolean;
+}
+
+export const MODERN_PROFILE: QoderModeProfile = {
+  businessProduct: "cli",
+  businessType: "agent",
+  cosyScene: "assistant",
+  mirrorTopLevelSystem: true,
+  sendBusinessHeaders: true,
+  sendModelSourceHeaders: true,
+  emptyAliyunUserType: true,
+};
+
+function qoderStableRecordId(modelId: string, messages: CanonicalRequest["messages"], maxTokens: number): string {
+  const h = createHash("sha256");
+  h.update("qoder-record\0");
+  h.update(modelId);
+  for (const m of messages) {
+    h.update("\0");
+    h.update(m.role);
+    const text = flattenCanonicalContent(m.content);
+    if (text) {
+      h.update("\0");
+      h.update(text);
+    }
+  }
+  h.update(`\0mt=${maxTokens}`);
+  return h.digest("hex").slice(0, 16);
+}
+
+/**
+ * The widest selectable context window for one model key.
+ *
+ * The live list's `context_config` is the authority when discovery has run:
+ * it names every window the account can switch to, and the widest one is what
+ * a dispatch should send (`model_config.max_input_tokens`) so a conversation is
+ * 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,
+  realm: QoderRealm,
+): number {
+  /**
+   * The ceiling is the roster's stated one. A fixed 32k fallback would clamp
+   * every model alike, so a request asking for more would be silently lowered
+   * no matter which model it named. A discovered row carries no
+   * `max_output_tokens` (upstream's model list reports none), so consult the
+   * static roster for the key before the 65_536 last resort — and keep that
+   * last resort only when neither the caller nor the roster states a limit.
+   */
+  const configured =
+    typeof modelConfig.max_output_tokens === "number"
+      ? modelConfig.max_output_tokens
+      : qoderRosterMaxOutput(modelConfig.id, realm) ?? 65_536;
+  const controls = request.generation_controls as Record<string, unknown>;
+  const requested =
+    typeof controls["max_tokens"] === "number"
+      ? (controls["max_tokens"] as number)
+      : typeof controls["max_output_tokens"] === "number"
+        ? (controls["max_output_tokens"] as number)
+        : null;
+  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.
+ *
+ * The DeepSeek family ties multi-turn consistency to `reasoning_content`: an
+ * assistant turn that thought must be replayed with that field or the upstream
+ * refuses the whole history. The upstream reference bridge keeps it for exactly
+ * these models and drops it as noise for every other one
+ * (`keep_reasoning=is_deepseek_model(...)`, and `reasoning_content` in
+ * `NOISE_KEYS` otherwise), and notes the symptom when it is missed: occasional
+ * failures that sometimes pass on retry.
+ *
+ * Matched by the upstream key and by the display name, because a caller may
+ * name either — the reference warns that matching only the "deepseek" prefix
+ * missed every request that used the key.
+ */
+function qoderKeepsReasoning(modelId: string): boolean {
+  const key = modelId.trim().toLowerCase();
+  if (key === "dmodel" || key === "dfmodel") return true;
+  return key.startsWith("deepseek");
+}
+
+/**
+ * The `reasoning_content` field for an assistant turn, when one is needed.
+ *
+ * Presence, not length, decides: a client that already knows the rule sends
+ * `""` on a thinking turn whose text is not readable back, and dropping that
+ * empty string re-triggers the complaint it was sent to avoid.
+ *
+ * DeepSeek multi-turn consistency also backfills the field on every assistant
+ * turn once the conversation carries a reasoning trace at all — the reference
+ * bridge does the same (`backfill_reasoning_content`), and notes the symptom
+ * when it is missed: occasional failures that sometimes pass on retry. An
+ * assistant turn with no reasoning and no trace gains nothing, so nothing is
+ * fabricated.
+ */
+function qoderReasoningEcho(
+  message: { content: readonly ContentPart[] },
+  modelId: string,
+  hasReasoningTrace = false,
+): { reasoning_content: string } | Record<string, never> {
+  if (!qoderKeepsReasoning(modelId)) return {};
+  const reasoning = message.content.filter((part) => part.kind === "reasoning");
+  if (reasoning.length === 0) {
+    return hasReasoningTrace ? { reasoning_content: "" } : {};
+  }
+  const text = reasoning
+    .map((part) => (part.kind === "reasoning" ? (part.summary ?? part.payload ?? "") : ""))
+    .join("");
+  return { reasoning_content: text };
+}
+
+/**
+ * Whether this request sends its tool history as structured turns.
+ *
+ * Qoder's wire is OpenAI-compatible `tool_calls` deltas on every realm; the
+ * model is fed the same structured turns in both INTL and CN. Writing a past
+ * call as prose (`[assistant 请求调用工具] …`) contaminates the conversation
+ * history with a text echo the model starts imitating — the origin of the
+ * text-leak feedback loop. Structured history keeps the model seeing only real
+ * tool calls, so it never learns the prose marker.
+ */
+function qoderStructuredTools(_realm: QoderRealm): boolean {
+  return true;
+}
+
+export function buildQoderRequest(
+  modelId: string,
+  request: CanonicalRequest,
+  modelConfig: QoderModelConfig,
+  auth: QoderAuth,
+  realm: QoderRealm = "intl",
+): Record<string, unknown> {
+  const allMessages = request.messages;
+  const systemParts: string[] = [];
+  if (request.system) {
+    for (const p of request.system) if (p.kind === "text") systemParts.push(p.text);
+  }
+  if (request.instructions) {
+    for (const p of request.instructions) if (p.kind === "text") systemParts.push(p.text);
+  }
+  for (const m of allMessages) {
+    if (m.role === "system" || m.role === "developer") {
+      const t = flattenCanonicalContent(m.content);
+      if (t) systemParts.push(t);
+    }
+  }
+  const systemPrompt = systemParts.join("\n\n").trim();
+  const qoderMessages: Array<Record<string, unknown>> = [];
+  const structuredTools = qoderStructuredTools(realm);
+  // DeepSeek multi-turn: once any turn in the conversation carries a reasoning
+  // trace, every assistant message must replay `reasoning_content` (see
+  // `qoderReasoningEcho`).
+  const hasReasoningTrace = allMessages.some((message) =>
+    message.content.some((part) => part.kind === "reasoning"),
+  );
+  if (MODERN_PROFILE.mirrorTopLevelSystem && systemPrompt.length > 0) {
+    qoderMessages.push({
+      role: "system",
+      content: systemPrompt,
+    });
+  }
+  // Every tool result across the whole conversation, keyed by call id. An
+  // assistant `tool_calls` turn is only sent structured when every call has a
+  // matching result somewhere in the history — otherwise the upstream rejects
+  // the transcript ("An assistant message with 'tool_calls' must be followed by
+  // tool messages responding to each 'tool_call_id'"). Calls without a result
+  // are left out of the structured turn instead of poisoning it.
+  const toolResultsById = new Map<string, string>();
+  for (const msg of allMessages) {
+    for (const part of toolResultParts(msg)) {
+      if (typeof part.call_id === "string" && part.call_id.length > 0) {
+        toolResultsById.set(part.call_id, part.call_id);
+      }
+    }
+  }
+  // The tool calls that actually survive onto the wire. A call only makes it
+  // when every call on its assistant turn carries an id AND a matching result
+  // exists in the history. This is the single source of truth for both sides
+  // of the transcript: the assistant `tool_calls` emit and the `tool` result
+  // turns. If a result's call is not here, its `tool` turn is dropped too —
+  // leaving it would emit an orphan `tool` turn with no preceding call, which
+  // the upstream rejects ("Messages with role 'tool' must be a response to a
+  // preceding message with 'tool_calls'"). This is what a cancelled or
+  // compacted parallel call looks like, and it is the "insufficient tool
+  // messages" failure the client sees on the turn after.
+  const emittableCallIds = new Set<string>();
+  for (const msg of allMessages) {
+    if (msg.role !== "assistant") continue;
+    const calls = toolCallParts(msg);
+    if (calls.length === 0) continue;
+    const idsOk = calls.every(
+      (part) => typeof part.call_id === "string" && part.call_id.length > 0,
+    );
+    const everyCallHasResult = calls.every((part) =>
+      typeof part.call_id === "string" ? toolResultsById.has(part.call_id) : false,
+    );
+    if (idsOk && everyCallHasResult) {
+      for (const part of calls) emittableCallIds.add(part.call_id as string);
+    }
+  }
+  for (const m of allMessages) {
+    if (m.role === "system" || m.role === "developer") continue;
+    // Answers may live in a `user` turn (the Messages ledger re-homes them),
+    // so the result scan is role-agnostic. Each result becomes its own `tool`
+    // turn carrying its `tool_call_id`; any non-result content on the same turn
+    // is emitted after, so nothing is duplicated or lost.
+    const results = structuredTools ? toolResultParts(m) : [];
+    if (results.length > 0) {
+      let emittedAnyTool = false;
+      for (const block of results) {
+        // Drop orphan results: their assistant `tool_calls` turn was filtered
+        // out (a sibling call has no result), and emitting the `tool` turn
+        // anyway would make the upstream reject the whole transcript.
+        if (!emittableCallIds.has(block.call_id)) continue;
+        emittedAnyTool = true;
+        const text = flattenCanonicalContent(
+          typeof block.content === "string"
+            ? [{ kind: "text", text: block.content }]
+            : block.content,
+        );
+        qoderMessages.push({
+          role: "tool",
+          content: text,
+          tool_call_id: block.call_id,
+        });
+      }
+      // Text that shared the turn with a result is emitted after it, minus the
+      // result itself. Re-emitting the result's own text here was doubling
+      // every tool answer: the `tool` turn above and a `user` turn with the
+      // same content, which doubled the payload for no reason.
+      const remaining = m.content.filter((part) => part.kind !== "toolResult");
+      const flat = flattenCanonicalContent(remaining);
+      if (flat.length === 0 && !emittedAnyTool) continue;
+      if (flat.length > 0) {
+        qoderMessages.push({
+          role: "user",
+          content: flat,
+        });
+      }
+      continue;
+    }
+    // An assistant turn that called tools must carry the calls, not just its
+    // text. Falling through to the text-only emit dropped them, so the payload
+    // arrived as a `tool` result with no preceding call and the upstream
+    // rejected the whole transcript: "Messages with role 'tool' must be a
+    // response to a preceding message with 'tool_calls'".
+    const allCalls = m.content.filter((part) => part.kind === "toolCall");
+    const reasoningEcho = qoderReasoningEcho(m, modelId, hasReasoningTrace);
+    // Structured tool turns are only safe when every call carries an id AND a
+    // matching result exists in the history — the upstream rejects a transcript
+    // whose `tool_calls` is not fully answered by `tool` turns. The same set
+    // that gates the `tool` emit above decides this, so the two halves of the
+    // transcript can never disagree.
+    const calls =
+      structuredTools && allCalls.every((part) => emittableCallIds.has(part.call_id))
+        ? allCalls
+        : [];
+    if (calls.length > 0) {
+      const textParts = m.content.filter((part) => part.kind !== "toolCall");
+      const flat = flattenCanonicalContent(textParts);
+      qoderMessages.push({
+        role: "assistant",
+        content: flat,
+        ...reasoningEcho,
+        tool_calls: calls.map((part) => ({
+          id: part.call_id,
+          type: "function",
+          function: {
+            name: part.name,
+            arguments:
+              typeof part.arguments === "string"
+                ? part.arguments
+                : part.arguments !== undefined && part.arguments !== null
+                  ? JSON.stringify(part.arguments)
+                  : "",
+          },
+        })),
+      });
+      continue;
+    }
+    const role = m.role === "assistant" ? "assistant" : "user";
+    // Images must travel as structured OpenAI parts inside the message content —
+    // the upstream reads `image_url` parts there and not the top-level
+    // `image_urls` (mirroring `flatten_messages` in the reference bridge). A
+    // bare file_id reference degrades to a text note instead of being dropped.
+    const hasImages = m.content.some((part) => part.kind === "image");
+    if (hasImages) {
+      const parts: Array<Record<string, unknown>> = [];
+      for (const part of m.content) {
+        if (part.kind === "text") {
+          parts.push({ type: "text", text: part.text });
+        } else if (part.kind === "image") {
+          const source = resolveImageSource(part.payload);
+          if (source?.url !== undefined) {
+            parts.push({ type: "image_url", image_url: { url: source.url } });
+          } else {
+            parts.push({
+              type: "text",
+              text: source?.fileId !== undefined ? `[image: ${source.fileId}]` : "[image: unsupported source]",
+            });
+          }
+        }
+      }
+      qoderMessages.push({
+        role,
+        content: parts,
+        ...(role === "assistant" ? qoderReasoningEcho(m, modelId, hasReasoningTrace) : {}),
+      });
+      continue;
+    }
+    const flat = flattenCanonicalContent(m.content);
+    qoderMessages.push({
+      role,
+      content: flat,
+      ...(role === "assistant" ? qoderReasoningEcho(m, modelId, hasReasoningTrace) : {}),
+    });
+  }
+  const latestUserMessage = [...qoderMessages].reverse().find((m) => m["role"] === "user");
+  const latestUserText = typeof latestUserMessage?.["content"] === "string" ? (latestUserMessage["content"] as string) : "";
+  const maxTokens = qoderRequestedMaxTokens(request, modelConfig, realm);
+  const reasoning = modelConfig.is_reasoning === true;
+  // 1:1 with the IDE worker's `FTn` legacy builder, which sends reasoning
+  // effort as a top-level camelCase field (`reasoningEffort`), derived from
+  // the canonical intent when one is present. Omitted entirely when the
+  // caller asked for no reasoning, matching the reference's conditional send.
+  // When the caller sends no intent but the model needs the push to think
+  // (verified live: Sonus/Cantus stream no reasoning without it), use the
+  // roster's default effort.
+  //
+  // Only a reasoning-capable model carries the field. A non-reasoning model
+  // (e.g. `lite`) cannot think, so an effort is meaningless there; sending it
+  // would also assert a capability the model does not advertise. The upstream
+  // tolerates it today, but declaring reasoning on a model that has none is a
+  // latent contract violation, so the field is kept off non-reasoning models.
+  const reasoningEffort =
+    reasoning
+      ? (reasoningEffortFromIntent(request.reasoning) ?? modelConfig.default_reasoning_effort)
+      : undefined;
+  const sessionId = qoderSessionId(auth.userId, modelId);
+  const recordId = qoderStableRecordId(modelId, allMessages, maxTokens);
+  return {
+    // 1:1 with the IDE worker's `FTn` legacy request builder, which always
+    // sends a top-level `model` equal to the resolved roster key (falling
+    // back to "auto" only when no key is known). The upstream honours
+    // `model_config.key` for actual dispatch and echoes a fixed "auto" in
+    // stream chunks, but the field is part of the wire shape the IDE sends.
+    model: modelId,
+    request_id: randomUUID(),
+    request_set_id: recordId,
+    chat_record_id: recordId,
+    session_id: sessionId,
+    source_session_id: "",
+    stream: true,
+    ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+    ...(MODERN_PROFILE.emptyAliyunUserType ? { aliyun_user_type: "" } : {}),
+    chat_task: "FREE_INPUT",
+    is_reply: true,
+    is_retry: false,
+    source: 1,
+    version: "3",
+    session_type: "qodercli",
+    agent_id: "agent_common",
+    task_id: "common",
+    code_language: "",
+    chat_prompt: MODERN_PROFILE.mirrorTopLevelSystem ? systemPrompt : "",
+    image_urls: null,
+    chat_context: {
+      chatPrompt: MODERN_PROFILE.mirrorTopLevelSystem ? systemPrompt : "",
+      imageUrls: null,
+      extra: { context: [], modelConfig: { key: modelId, is_reasoning: reasoning }, originalContent: { text: latestUserText } },
+      features: [],
+      // An object, as the reference sends it: `cc["text"]["text"] = prompt`.
+      text: { text: latestUserText },
+    },
+    model_config: {
+      key: modelId,
+      display_name: modelConfig.display_name,
+      // Declares the wire dialect for the tool calls. Without it the upstream
+      // does not read the OpenAI-shaped `tools` array the same way, and the
+      // model then emits a call with no arguments filled in.
+      format: "openai",
+      model: "",
+      api_key: "",
+      url: "",
+      is_vl: modelConfig.is_vl,
+      is_reasoning: modelConfig.is_reasoning,
+      // Send the widest selectable window from the live list's `context_config`
+      // (falling back to the static roster's stated window). Without this, the
+      // request would declare the *currently active* window — often 180k — even
+      // when the account can use 1M, capping the conversation the upstream sees.
+      max_input_tokens: qoderMaxContextFor(modelId, modelConfig, realm),
+      // Mirrors the roster's stated ceiling. A fixed 32k fallback would be sent
+      // 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,
+      source: modelConfig.source ?? "system",
+    },
+    messages: qoderMessages,
+    max_tokens: maxTokens,
+    // Always present, even when empty. Omitting the field makes Qoder fall back
+    // to the desktop agent's own toolset (Bash/Edit/...), which then leaks to a
+    // caller that declared none — the reference bridge sends `[]` for exactly
+    // that reason. Parallel calls are stated explicitly rather than left to the
+    // upstream default, so a caller expecting them is not served serial
+    // behaviour.
+    tools: qoderTools(request.tools),
+    parallel_tool_calls: true,
+    ...(() => {
+      const choice = qoderToolChoice(request.tool_choice);
+      return choice === undefined ? {} : { tool_choice: choice };
+    })(),
+    // Passthrough knobs the IDE surface reads from `parameters` (worker `vyl`):
+    // parallel_tool_calls, tool_choice, top_p, seed, user, response_format, …
+    // Only include what the caller actually set.
+    parameters: (() => {
+      const out: Record<string, unknown> = {};
+      const choice = qoderToolChoice(request.tool_choice);
+      if (choice !== undefined) out["tool_choice"] = choice;
+      const parallel = request.generation_controls.parallel_tool_calls;
+      if (parallel !== undefined) out["parallel_tool_calls"] = parallel;
+      return Object.keys(out).length > 0 ? out : undefined;
+    })(),
+  };
+}
+
+type QoderFetcher = (url: string, init: RequestInit) => Promise<Response>;
+
+/**
+ * Signs and sends one legacy COSY chat request. The body is alphabet-scrambled
+ * before signing; headers come from `qoderBuildCosyHeaders` plus the modern
+ * `x-model-key`/`x-model-source` and SSE accepts.
+ */
+export async function callQoder(
+  url: string,
+  body: Record<string, unknown>,
+  modelId: string,
+  auth: QoderAuth,
+  signal: AbortSignal,
+  fetcher: QoderFetcher,
+  version = getQoderVersion(),
+): Promise<Response> {
+  const encoded = transformQoderBody(JSON.stringify(body));
+  const modelConfig = (body["model_config"] as Record<string, unknown> | null) ?? null;
+  return fetcher(url, {
+    method: "POST",
+    headers: {
+      ...qoderBuildCosyHeaders(encoded, url, auth, version),
+      ...(MODERN_PROFILE.sendModelSourceHeaders
+        ? { "x-model-key": modelId, "x-model-source": typeof modelConfig?.["source"] === "string" ? (modelConfig["source"] as string) : "system" }
+        : {}),
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Accept-Encoding": "identity",
+    },
+    body: encoded as unknown as BodyInit,
+    signal,
+  });
+}

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

@@ -0,0 +1,162 @@
+/**
+ * Qoder COSY signing — AES-128-CBC identity encryption + RSA PKCS1 key +
+ * md5 chain, and the alphabet-scrambled body transform. This is the donor of
+ * the WASM `prepareInferRequest` output of the real client, and the only chat
+ * surface a free/lite account can use.
+ *
+ * Header values mirror live captures of the real client (v1.1.83,
+ * 2026-11-05): `User-Agent: Bun/1.4.2`, machine identity headers from the
+ * UMID (`cosy-machineid/token/type/code/os/hostname`), business headers,
+ * and the static `signature` md5 chain.
+ */
+import { constants, createCipheriv, createHash, publicEncrypt, randomUUID } from "node:crypto";
+import { getQoderVersion } from "../../operations/client-versions";
+import { qoderMachineHostname, qoderMachineOs } from "../../operations/cli-platform";
+import { QODER_UA_CLI } from "./qoder-realm";
+import type { QoderAuth } from "./qoder-types";
+
+const QODER_APPCODE = "cosy";
+const QODER_SIG_SECRET = "d2FyLCB3YXIgbmV2ZXIgY2hhbmdlcw==";
+const QODER_STANDARD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const QODER_ALPHABET = "_doRTgHZBKcGVjlvpC,@aFSx#DPuNJme&i*MzLOEn)sUrthbf%Y^w.(kIQyXqWA!";
+const QODER_RSA_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;
+
+function qoderMd5(value: string | Uint8Array): string {
+  return createHash("md5").update(value).digest("hex");
+}
+
+/**
+ * Canonical compact JSON used by Qoder's COSY signing: keys sorted
+ * lexicographically, no whitespace, null/undefined rendered as empty string.
+ * The upstream verifies the signature against this exact serialization, so a
+ * payload built with plain `JSON.stringify` (insertion order) fails with
+ * `code 101 / Signature invalid`.
+ */
+function qoderJsonSortedCompact(mapping: Record<string, unknown>): string {
+  const parts: string[] = [];
+  for (const key of Object.keys(mapping).sort()) {
+    const value = mapping[key] === null || mapping[key] === undefined ? "" : mapping[key];
+    parts.push(`${JSON.stringify(key)}:${JSON.stringify(value)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+
+function qoderPathSignature(url: string): string {
+  const path = new URL(url).pathname;
+  return path.startsWith("/algo") ? path.slice(5) : path;
+}
+
+/**
+ * Qoder's own base64 alphabet transform for a request body: base64, rotate
+ * thirds, then map each character through the custom alphabet (`=` → `$`).
+ */
+export function transformQoderBody(plaintext: string): Uint8Array {
+  const base64 = Buffer.from(plaintext).toString("base64");
+  const third = Math.floor(base64.length / 3);
+  const reordered = base64.slice(base64.length - third) + base64.slice(third, base64.length - third) + base64.slice(0, third);
+  let encoded = "";
+  for (const char of reordered) {
+    if (char === "=") encoded += "$";
+    else encoded += QODER_ALPHABET[QODER_STANDARD_ALPHABET.indexOf(char)] ?? char;
+  }
+  return Buffer.from(encoded, "latin1");
+}
+
+/**
+ * Builds the COSY Bearer headers for one signed request. The identity payload
+ * is encrypted AES-128-CBC (random 16-byte key, IV = key), the key is RSA
+ * PKCS1-encrypted, and the signature is md5 over
+ * `payload\ncosyKey\ndate\nbody\nsigPath`.
+ *
+ * Machine identity headers mirror the live 1.1.83 capture: `cosy-machineid`
+ * (the account's machine id), `cosy-machinetoken/type/code` when a native
+ * UMID identity is bound (otherwise they fall back to the machine id / `5`),
+ * real `cosy-machineos`, and the sanitized hostname.
+ */
+export function qoderBuildCosyHeaders(
+  body: Uint8Array,
+  url: string,
+  auth: QoderAuth,
+  version = getQoderVersion(),
+): Record<string, string> {
+  const key = randomUUID().replaceAll("-", "").slice(0, 16);
+  const identity = qoderJsonSortedCompact({
+    name: auth.userName,
+    aid: auth.userId,
+    uid: auth.userId,
+    yx_uid: "",
+    organization_id: "",
+    organization_name: "",
+    user_type: auth.userType,
+    security_oauth_token: auth.securityOauthToken,
+    refresh_token: auth.refreshToken,
+  });
+  const cipher = createCipheriv("aes-128-cbc", Buffer.from(key), Buffer.from(key));
+  const info = Buffer.concat([cipher.update(identity), cipher.final()]).toString("base64");
+  const cosyKey = publicEncrypt({ key: QODER_RSA_PUBLIC_KEY, padding: constants.RSA_PKCS1_PADDING }, Buffer.from(key)).toString("base64");
+  const payload = Buffer.from(
+    qoderJsonSortedCompact({ version: "v1", requestId: randomUUID(), info, cosyVersion: version, ideVersion: "" }),
+  ).toString("base64");
+  const date = String(Math.floor(Date.now() / 1000));
+  const signature = qoderMd5(`${payload}\n${cosyKey}\n${date}\n${Buffer.from(body).toString("latin1")}\n${qoderPathSignature(url)}`);
+  return {
+    authorization: `Bearer COSY.${payload}.${signature}`,
+    "cosy-data-policy": "agree",
+    "cosy-machinetype": auth.machineType ?? "5",
+    "cosy-machineos": qoderMachineOs(),
+    "cosy-clienttype": "5",
+    "cosy-date": date,
+    "cosy-user": auth.userId,
+    "cosy-key": cosyKey,
+    "cosy-bodyhash": qoderMd5(body),
+    "cosy-bodylength": String(body.byteLength),
+    "cosy-sigpath": qoderPathSignature(url),
+    "cosy-machineid": auth.machineId,
+    ...(auth.machineToken !== undefined && auth.machineToken.length > 0 ? { "cosy-machinetoken": auth.machineToken } : {}),
+    ...(auth.machineCode !== undefined && auth.machineCode.length > 0 ? { "cosy-machinecode": auth.machineCode } : {}),
+    "cosy-machinehostname": qoderMachineHostname(),
+    "cosy-organization-id": "",
+    "cosy-organization-tags": "",
+    "x-request-id": randomUUID(),
+    "cosy-business-product": "cli",
+    "cosy-business-type": "agent",
+    "cosy-business-version": version,
+    "cosy-scene": "assistant",
+    "cosy-version": version,
+    "login-version": "v2",
+    appcode: QODER_APPCODE,
+    accept: "application/json",
+    "accept-encoding": "identity",
+    date: new Date().toUTCString(),
+    signature: qoderMd5(`${QODER_APPCODE}&${QODER_SIG_SECRET}&${new Date().toUTCString()}`),
+    "content-type": "application/json",
+    "user-agent": QODER_UA_CLI,
+  };
+}
+
+/**
+ * A COSY signer for one already-resolved account identity.
+ *
+ * Discovery needs signed headers but lives in `qoder-catalog.ts`, which cannot
+ * import this module (the adapter imports its rosters — that would be a cycle).
+ * Exporting the signer keeps one signing implementation and lets discovery
+ * stay pure and injectable.
+ */
+export function qoderSignerFor(
+  auth: QoderAuth,
+  version = getQoderVersion(),
+): (url: string, body: string) => Record<string, string> {
+  return (url: string, body: string): Record<string, string> =>
+    qoderBuildCosyHeaders(Buffer.from(body, "latin1"), url, auth, version);
+}
+
+/** Qoder's own base64 alphabet transform, for a request body. */
+export function qoderEncodeBody(plaintext: Uint8Array | string): string {
+  const text = typeof plaintext === "string" ? plaintext : new TextDecoder().decode(plaintext);
+  return Buffer.from(transformQoderBody(text)).toString("latin1");
+}