cartethyia 2.7.4 → 2.7.5

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

@@ -0,0 +1,159 @@
+/**
+ * Qoder-specific SSE decoding.
+ *
+ * The generic `decodeSseEvents` splits on newlines and treats a bare line
+ * (no `data:` prefix) with no open event as malformed. Qoder's IDE surface
+ * embeds literal newline bytes inside JSON string values (e.g. `raw_usage`
+ * keys like `"data_policy_preferre\n\nnd_count"`), which fragments one logical
+ * `data:` event into many physical lines — including blank lines that are not
+ * event boundaries. The generic decoder can throw `Malformed SSE line` on the
+ * trailing fragments of those giant events.
+ *
+ * This decoder is tolerant by construction: it accumulates one event's payload
+ * across `data:` lines, bare continuations, and blank lines until the payload
+ * is a complete JSON value or the `[DONE]` sentinel. It never throws on a
+ * bare fragment — payload completeness is the only way an event ends.
+ */
+
+export interface QoderSseEvent {
+  readonly event: string | null;
+  readonly data: string;
+}
+
+const DEFAULT_MAX_EVENT_BYTES = 8 * 1024 * 1024;
+
+/** True when the accumulated text is a complete JSON value (or non-JSON text). */
+function isCompleteJsonValue(data: string): boolean {
+  if (data.length === 0) return true;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < data.length; i += 1) {
+    const ch = data[i]!;
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{" || ch === "[") {
+      depth += 1;
+    } else if (ch === "}" || ch === "]") {
+      depth -= 1;
+      if (depth < 0) return true;
+    }
+  }
+  return depth <= 0;
+}
+
+/**
+ * Decodes Qoder SSE into complete events.
+ */
+export async function* decodeQoderSseEvents(
+  body: ReadableStream<Uint8Array> | null,
+  signal?: AbortSignal,
+  maxEventBytes = DEFAULT_MAX_EVENT_BYTES,
+): AsyncIterable<QoderSseEvent> {
+  if (body === null) return;
+
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let lineBuffer = "";
+  let current: string | null = null; // accumulated payload of the open event
+  let eventBytes = 0;
+
+  /** Returns the open payload when complete, else null (clearing it). */
+  const takeComplete = (): string | null => {
+    if (current === null) return null;
+    const trimmed = current.trim();
+    if (trimmed.length === 0) {
+      current = null;
+      eventBytes = 0;
+      return null;
+    }
+    if (trimmed === "[DONE]" || isCompleteJsonValue(trimmed)) {
+      const data = current;
+      current = null;
+      eventBytes = 0;
+      return data;
+    }
+    return null;
+  };
+
+  const appendPayload = (text: string): void => {
+    if (current === null) return;
+    current += text;
+    eventBytes += text.length;
+    if (eventBytes > maxEventBytes) throw new Error("SSE event exceeds size bound");
+  };
+
+  /** Emit a complete open payload, if any. Returns `true` when the stream ends. */
+  function* emitComplete(): Generator<QoderSseEvent, boolean, void> {
+    const data = takeComplete();
+    if (data === null) return false;
+    if (data.trim() === "[DONE]") return true;
+    yield { event: null, data };
+    return false;
+  }
+
+  try {
+    for (;;) {
+      if (signal?.aborted) return;
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value || value.byteLength === 0) continue;
+      lineBuffer += decoder.decode(value, { stream: true });
+
+      for (;;) {
+        const nl = lineBuffer.indexOf("\n");
+        if (nl < 0) break;
+        const line = lineBuffer.slice(0, nl);
+        lineBuffer = lineBuffer.slice(nl + 1);
+        const trimmed = line.trim();
+
+        // Comments, event names, and other fields carry no payload.
+        if (trimmed.startsWith(":") || trimmed.startsWith("event:")) continue;
+
+        if (trimmed.startsWith("data:")) {
+          // A fresh `data:` — flush a complete open event first, then start a
+          // new payload with the slice after the prefix.
+          if (yield* emitComplete()) return;
+          current = line.slice(5).trimStart();
+          eventBytes = current.length;
+          if (eventBytes > maxEventBytes) throw new Error("SSE event exceeds size bound");
+          continue;
+        }
+
+        // Other known fields (id:, retry:, vendor extensions) carry no payload.
+        if (/^[a-zA-Z0-9_-]+:/.test(trimmed)) continue;
+
+        if (trimmed.length === 0) {
+          // Blank line: an event boundary only when the open payload is
+          // complete; otherwise it is a literal newline inside the JSON string.
+          if (yield* emitComplete()) return;
+          if (current !== null) appendPayload("\n");
+          continue;
+        }
+
+        // Bare line: continuation of the open payload (Qoder fragments JSON
+        // across physical lines with literal newlines inside strings).
+        if (current !== null) {
+          appendPayload("\n" + line);
+          if (yield* emitComplete()) return;
+          continue;
+        }
+        // Bare line with no open payload: ignore (tolerant by design).
+      }
+    }
+
+    yield* emitComplete();
+  } finally {
+    reader.releaseLock();
+  }
+}

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

@@ -33,13 +33,10 @@
  */
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { log } from "../../../observability/logger";
 
-/** Valid environment codes (kept for validation/console surface). */
-export const QODER_ENV_CODES = ["0", "3", "4", "5", "6", "7"] as const;
-
 /** Environment code: an upstream "region/flavor", not a device identity. */
 const ENV_CODE = "3";
 
@@ -91,11 +88,6 @@ function pickBridge(): Bridge | null {
   return existsSync(join(umidpackDir(), "elf-x86_64", "runtime-info")) ? { kind: "elf" } : null;
 }
 
-/** True when a genuine bridge can run on this host. */
-export function hasGenuineBridge(): boolean {
-  return pickBridge() !== null;
-}
-
 /** Generated (software) identity — deterministic per account id, NOT SG-signed. */
 export function mintQoderGeneratedIdentity(accountId: string): QoderNativeIdentity {
   const first = createHash("sha256").update(accountId).digest("base64url");
@@ -144,6 +136,22 @@ function wsl(script: string, timeout = 120_000): string {
   return String(r.stdout ?? "");
 }
 
+/**
+ * Best-effort make a POSIX bridge binary executable before spawning it. The
+ * umidpack binaries are committed without the exec bit (git mode 100644) and
+ * nothing else in the delivery path sets it — a Docker image or a fresh clone
+ * on Linux/macOS would otherwise fail to spawn them (EACCES -> "[qoder] elf
+ * mint failed"). Idempotent; if it cannot set the bit, `spawnSync` reports
+ * the real failure as before.
+ */
+export function ensurePosixExecutable(file: string): void {
+  try {
+    chmodSync(file, 0o755);
+  } catch {
+    /* spawn will report the actual error */
+  }
+}
+
 /** Run the bridge inside WSL under flock; returns the identity or null. */
 
 function seedPath(): string {
@@ -179,6 +187,7 @@ export function mintQoderNativeIdentity(accountId: string): { identity: QoderNat
 
   if (bridge.kind === "elf") {
     const exe = join(umidpackDir(), process.arch === "arm64" ? "elf-aarch64" : "elf-x86_64", "runtime-info");
+    ensurePosixExecutable(exe);
     const seed = seedPath();
     const dir = seed.slice(0, seed.lastIndexOf("/"));
     mkdirSync(dir, { recursive: true });
@@ -192,6 +201,7 @@ export function mintQoderNativeIdentity(accountId: string): { identity: QoderNat
   if (bridge.kind === "macho") {
     const arch = process.arch === "arm64" ? "macho-arm64" : "macho-x86_64";
     const exe = join(umidpackDir(), arch, "runtime-info");
+    ensurePosixExecutable(exe);
     const seed = seedPath();
     const dir = seed.slice(0, seed.lastIndexOf("/"));
     mkdirSync(dir, { recursive: true });
@@ -236,6 +246,7 @@ export function replayQoderNativeIdentity(seed: string, accountId: string): Qode
 
   if (bridge.kind === "elf") {
     const exe = join(umidpackDir(), process.arch === "arm64" ? "elf-aarch64" : "elf-x86_64", "runtime-info");
+    ensurePosixExecutable(exe);
     const seed = seedPath();
     writeFileSync(seed, seed, "utf8");
     const r = spawnSync(exe, [ENV_CODE], { encoding: "utf8", timeout: 25_000 });
@@ -245,6 +256,7 @@ export function replayQoderNativeIdentity(seed: string, accountId: string): Qode
   if (bridge.kind === "macho") {
     const arch = process.arch === "arm64" ? "macho-arm64" : "macho-x86_64";
     const exe = join(umidpackDir(), arch, "runtime-info");
+    ensurePosixExecutable(exe);
     const seedPathStr = seedPath();
     writeFileSync(seedPathStr, seed, "utf8");
     const r = spawnSync(exe, [ENV_CODE, "--account-stdin"], {
@@ -258,17 +270,6 @@ export function replayQoderNativeIdentity(seed: string, accountId: string): Qode
   return null; // pe: cannot replay a seed on a hardware-bound identity
 }
 
-/** Reads the current seed file content (diagnostics). */
-export function readCurrentQoderSeed(): string {
-  const path = seedPath();
-  try {
-    if (process.platform === "win32") return wsl(`cat ${WSL_SEED} 2>/dev/null`);
-    return existsSync(path) ? readFileSync(path, "utf8") : "";
-  } catch {
-    return "";
-  }
-}
-
 /** The six native machine headers for one identity. */
 export function qoderMachineHeaders(identity: QoderNativeIdentity): Record<string, string> {
   return {
@@ -280,8 +281,3 @@ export function qoderMachineHeaders(identity: QoderNativeIdentity): Record<strin
     "cosy-machinehostname": "DESKTOP-QODER",
   };
 }
-
-/** For tests: force re-mint (identities are pure functions of their seed). */
-export function resetQoderNativeIdentityCache(): void {
-  // no persistent in-process identity cache remains
-}

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

@@ -18,6 +18,15 @@ export interface QoderVirtualModel {
   readonly target: string;
   /** Name shown where a human picks a model. */
   readonly displayName: string;
+  /**
+   * Tier/limit overrides for a virtual row whose upstream slot reports
+   * different numbers than the caller-facing card should show. `lite` is a
+   * free plan package over `qmodel` (Qwen3.7-Plus): same model, smaller
+   * output ceiling, free tier, and the full multimodal input set.
+   */
+  readonly free?: boolean;
+  readonly outputLimit?: number;
+  readonly vision?: boolean;
 }
 
 /**
@@ -42,6 +51,9 @@ export const QODER_VIRTUAL_MODELS: readonly QoderVirtualModel[] = [
   { id: "glm-5.3", target: "gmodel", displayName: "GLM-5.3" },
   { id: "glm-5.3-flash", target: "gfmodel", displayName: "GLM-5.3-Flash" },
   { id: "minimax-m3", target: "mmodel", displayName: "MiniMax-M3.1-Flash" },
+  // `lite` is the free-tier plan package over `qmodel` (Qwen3.7-Plus):
+  // same 1M window and multimodal input, capped at 64k output, free tier.
+  { id: "lite-qwen-3.7-plus", target: "lite", displayName: "Lite-Qwen-3.7-Plus", free: true, outputLimit: 65536, vision: true },
 ];
 
 /** Virtual id → roster key. */