cartethyia 2.4.5 → 2.5.0

package/src/providers/integrations/cursor/protocol/struct.ts

@@ -0,0 +1,305 @@
+/**
+ * Vendored from `cursor-opencode-provider` (protocol layer only).
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Oleksiy Akimov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+// Minimal encoder for google.protobuf.Value / Struct / ListValue.
+//
+// Cursor's per-turn tool descriptors carry the tool `input_schema` (a JSON
+// Schema object) as a `google.protobuf.Value` whose `struct_value` holds the
+// schema — NOT a JSON string. Verified against a live capture
+// (request_context #7 → McpToolDefinition #3):
+//   2a 9a07  0a10 0a04 74797065 1208 1a06 6f626a656374 ...
+//   = Value{#5 struct_value: Struct{#1 fields: {"type": Value{#3 string "object"}}}}
+//
+// Field numbers (well-known types):
+//   Value:     1 null_value, 2 number_value(double), 3 string_value,
+//              4 bool_value, 5 struct_value(Struct), 6 list_value(ListValue)
+//   Struct:    1 fields (map<string, Value>) — each entry msg{1 key, 2 value}
+//   ListValue: 1 values (repeated Value)
+
+function writeVarint(out: number[], n: number): void {
+  let v = n >>> 0
+  while (v > 0x7f) {
+    out.push((v & 0x7f) | 0x80)
+    v >>>= 7
+  }
+  out.push(v)
+}
+
+function writeTag(out: number[], field: number, wire: number): void {
+  writeVarint(out, (field << 3) | wire)
+}
+
+function writeLengthDelimited(out: number[], field: number, bytes: Uint8Array): void {
+  writeTag(out, field, 2)
+  writeVarint(out, bytes.length)
+  for (let i = 0; i < bytes.length; i++) out.push(bytes[i] ?? 0)
+}
+
+function writeString(out: number[], field: number, str: string): void {
+  writeLengthDelimited(out, field, new TextEncoder().encode(str))
+}
+
+function writeDouble(out: number[], field: number, num: number): void {
+  writeTag(out, field, 1) // 64-bit
+  const buf = new ArrayBuffer(8)
+  new DataView(buf).setFloat64(0, num, true) // little-endian
+  const view = new Uint8Array(buf)
+  for (let i = 0; i < 8; i++) out.push(view[i] ?? 0)
+}
+
+// ── Decoding (reverse): google.protobuf.Value bytes → JSON ──
+
+export type RawField = { fn: number; wt: number; varint: number; bytes?: Uint8Array; i64?: Uint8Array }
+
+function readVarintAt(b: Uint8Array, i: number): [number, number] {
+  let r = 0, s = 0
+  while (i < b.length) {
+    const x = b[i++] ?? 0
+    r |= (x & 0x7f) << s
+    if (!(x & 0x80)) break
+    s += 7
+  }
+  return [r >>> 0, i]
+}
+
+/** Walk a protobuf message's top-level fields off the raw wire bytes. */
+export function readAllFields(b: Uint8Array): RawField[] {
+  let i = 0
+  const out: RawField[] = []
+  while (i < b.length) {
+    let key: number
+    ;[key, i] = readVarintAt(b, i)
+    const fn = key >>> 3, wt = key & 7
+    if (wt === 0) {
+      let v: number
+      ;[v, i] = readVarintAt(b, i)
+      out.push({ fn, wt, varint: v })
+    } else if (wt === 2) {
+      let len: number
+      ;[len, i] = readVarintAt(b, i)
+      out.push({ fn, wt, varint: 0, bytes: b.subarray(i, i + len) })
+      i += len
+    } else if (wt === 1) {
+      out.push({ fn, wt, varint: 0, i64: b.subarray(i, i + 8) })
+      i += 8
+    } else if (wt === 5) {
+      i += 4 // i32 — not used by Value
+    } else break
+  }
+  return out
+}
+
+export type StrictRawField = {
+  fn: number
+  wt: number
+  varint?: bigint
+  bytes?: Uint8Array
+  fixed64?: Uint8Array
+  fixed32?: Uint8Array
+}
+
+type DecodedVarint = { value: bigint; nextOffset: number }
+
+const MAX_UINT32 = 0xffff_ffffn
+const MAX_UINT64 = 0xffff_ffff_ffff_ffffn
+const MAX_PROTOBUF_FIELD_NUMBER = 0x1fff_ffff
+
+/**
+ * Decode one unsigned protobuf varint without JavaScript's 32-bit bitwise
+ * truncation. `maximum` also enforces the protocol width: tags and lengths are
+ * uint32, while wire-type 0 scalar values may use the full uint64 range.
+ */
+function readBoundedVarint(
+  bytes: Uint8Array,
+  offset: number,
+  maximum: bigint,
+): DecodedVarint | undefined {
+  let value = 0n
+  let shift = 0n
+  for (let index = offset; index < bytes.length && index < offset + 10; index++) {
+    const byte = bytes[index]!
+    value |= BigInt(byte & 0x7f) << shift
+    if (value > maximum) return undefined
+    if ((byte & 0x80) === 0) return { value, nextOffset: index + 1 }
+    shift += 7n
+  }
+  return undefined
+}
+
+/**
+ * Strictly walk a protobuf message for security/replay decisions.
+ *
+ * Unlike `readAllFields`, this parser consumes the complete input, preserves
+ * uint64 varints as bigint, represents fixed-width fields, and rejects invalid
+ * tags, truncation, overflow, groups, and unsupported wire types. It deliberately
+ * returns `undefined` instead of a partial result: callers must fail closed when
+ * deciding whether replay is safe.
+ */
+export function readAllFieldsStrict(bytes: Uint8Array): StrictRawField[] | undefined {
+  let offset = 0
+  const fields: StrictRawField[] = []
+
+  while (offset < bytes.length) {
+    const tag = readBoundedVarint(bytes, offset, MAX_UINT32)
+    if (!tag) return undefined
+    offset = tag.nextOffset
+
+    const fieldNumber = Number(tag.value >> 3n)
+    const wireType = Number(tag.value & 7n)
+    if (fieldNumber === 0 || fieldNumber > MAX_PROTOBUF_FIELD_NUMBER) return undefined
+
+    if (wireType === 0) {
+      const scalar = readBoundedVarint(bytes, offset, MAX_UINT64)
+      if (!scalar) return undefined
+      fields.push({ fn: fieldNumber, wt: wireType, varint: scalar.value })
+      offset = scalar.nextOffset
+      continue
+    }
+
+    if (wireType === 1) {
+      if (offset + 8 > bytes.length) return undefined
+      fields.push({ fn: fieldNumber, wt: wireType, fixed64: bytes.subarray(offset, offset + 8) })
+      offset += 8
+      continue
+    }
+
+    if (wireType === 2) {
+      const encodedLength = readBoundedVarint(bytes, offset, MAX_UINT32)
+      if (!encodedLength) return undefined
+      offset = encodedLength.nextOffset
+      const length = Number(encodedLength.value)
+      if (offset + length > bytes.length) return undefined
+      fields.push({ fn: fieldNumber, wt: wireType, bytes: bytes.subarray(offset, offset + length) })
+      offset += length
+      continue
+    }
+
+    if (wireType === 5) {
+      if (offset + 4 > bytes.length) return undefined
+      fields.push({ fn: fieldNumber, wt: wireType, fixed32: bytes.subarray(offset, offset + 4) })
+      offset += 4
+      continue
+    }
+
+    // Groups (3/4) are deprecated and recursive; no replay-safe frame uses them.
+    return undefined
+  }
+
+  return fields
+}
+
+function decodeStructBytes(b: Uint8Array): Record<string, unknown> {
+  const obj: Record<string, unknown> = {}
+  for (const f of readAllFields(b)) {
+    if (f.fn !== 1 || !f.bytes) continue // Struct.fields (map) entries
+    const { key, valBytes } = readMapEntry(f.bytes)
+    if (key !== undefined) obj[key] = valBytes ? decodeValueToJson(valBytes) : null
+  }
+  return obj
+}
+
+function decodeListBytes(b: Uint8Array): unknown[] {
+  const arr: unknown[] = []
+  for (const f of readAllFields(b)) {
+    if (f.fn === 1 && f.bytes) arr.push(decodeValueToJson(f.bytes))
+  }
+  return arr
+}
+
+function readMapEntry(b: Uint8Array): { key?: string; valBytes?: Uint8Array } {
+  let key: string | undefined
+  let valBytes: Uint8Array | undefined
+  for (const e of readAllFields(b)) {
+    if (e.fn === 1 && e.bytes) key = new TextDecoder().decode(e.bytes)
+    else if (e.fn === 2 && e.bytes) valBytes = e.bytes
+  }
+  return { ...(key === undefined ? {} : { key }), ...(valBytes === undefined ? {} : { valBytes }) }
+}
+
+/** Decode a google.protobuf.Value message (bytes) back into a JSON value. */
+export function decodeValueToJson(bytes: Uint8Array): unknown {
+  const fs = readAllFields(bytes)
+  const f = fs[0]
+  if (f === undefined) return null
+  switch (f.fn) {
+    case 1: return null // null_value
+    case 2: return f.i64 ? new DataView(f.i64.buffer, f.i64.byteOffset, 8).getFloat64(0, true) : 0
+    case 3: return f.bytes ? new TextDecoder().decode(f.bytes) : ""
+    case 4: return f.varint !== 0
+    case 5: return f.bytes ? decodeStructBytes(f.bytes) : {}
+    case 6: return f.bytes ? decodeListBytes(f.bytes) : []
+    default: return null
+  }
+}
+
+/**
+ * Decode a `map<string, Value>` field that was captured as repeated map-entry
+ * messages (each `{1 key, 2 value}`) into a plain JSON object. Used for
+ * `McpArgs.args`, which arrives as repeated field #2 on the wire.
+ */
+export function decodeStructEntriesToJson(entries: Uint8Array[]): Record<string, unknown> {
+  const obj: Record<string, unknown> = {}
+  for (const entry of entries) {
+    const { key, valBytes } = readMapEntry(entry)
+    if (key !== undefined) obj[key] = valBytes ? decodeValueToJson(valBytes) : null
+  }
+  return obj
+}
+
+/** Encode an arbitrary JSON value as google.protobuf.Value bytes. */
+export function encodeJsonAsValue(v: unknown): Uint8Array {
+  const out: number[] = []
+  if (v === null || v === undefined) {
+    writeTag(out, 1, 0) // null_value = 0
+    writeVarint(out, 0)
+  } else if (typeof v === "number") {
+    writeDouble(out, 2, v)
+  } else if (typeof v === "boolean") {
+    writeTag(out, 4, 0)
+    writeVarint(out, v ? 1 : 0)
+  } else if (typeof v === "string") {
+    writeString(out, 3, v)
+  } else if (Array.isArray(v)) {
+    const lv: number[] = []
+    for (const item of v) writeLengthDelimited(lv, 1, encodeJsonAsValue(item))
+    writeLengthDelimited(out, 6, new Uint8Array(lv))
+  } else if (typeof v === "object") {
+    const st: number[] = []
+    for (const [key, val] of Object.entries(v as Record<string, unknown>).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
+      if (val === undefined) continue
+      const entry: number[] = []
+      writeString(entry, 1, key)
+      writeLengthDelimited(entry, 2, encodeJsonAsValue(val))
+      writeLengthDelimited(st, 1, new Uint8Array(entry))
+    }
+    writeLengthDelimited(out, 5, new Uint8Array(st))
+  } else {
+    // Fallback: treat as null.
+    writeTag(out, 1, 0)
+    writeVarint(out, 0)
+  }
+  return new Uint8Array(out)
+}

package/src/providers/integrations/factory/factory-oauth.ts

@@ -29,6 +29,7 @@ import type {
 } from "../../authentication/oauth-flow-store";
 import {
   devicePollBackoff,
+  decodeJwtPayload,
   nonEmptyTrimmedString,
   readJsonResponse,
   record,
@@ -71,19 +72,14 @@ export type { FactoryDroidEnvelope } from "../../../security/credential-codec";
  * Repeating it on every refresh would add a JWKS fetch to the dispatch path for
  * no additional guarantee: the signature cannot change without the payload
  * changing, and the payload is what this reads.
+ *
+ * Delegates to the shared decoder rather than hand-rolling a base64url pass:
+ * `atob` decodes to a Latin-1 string, so a claim carrying multi-byte UTF-8
+ * came back as mojibake. `Buffer.from(segment, "base64url")` round-trips the
+ * original bytes.
  */
 function jwtClaims(token: string): Record<string, unknown> | undefined {
-  const segments = token.split(".");
-  const payload = segments[1];
-  if (segments.length < 2 || payload === undefined || payload.length === 0) return undefined;
-  try {
-    const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
-    const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), "=");
-    const parsed: unknown = JSON.parse(atob(padded));
-    return record(parsed);
-  } catch {
-    return undefined;
-  }
+  return decodeJwtPayload(token);
 }
 
 /** Expiry from the token's own `exp` claim, or the fallback when absent. */

package/src/providers/integrations/github/github.ts

@@ -72,9 +72,7 @@ function clampGithubReasoningEffort(payload: Record<string, unknown>): void {
 /** Supported virtual Copilot Auto catalog ids and their router tiers. */
 export const GITHUB_AUTO_MODEL_TIERS: ReadonlyMap<string, "efficiency" | "balance" | "intelligence"> = new Map([
   ["auto", "balance"],
-  ["gpt-6-luna-low", "efficiency"],
-  ["gpt-6-luna-medium", "balance"],
-  ["gpt-6-luna-high", "intelligence"],
+  ["gpt-6-luna", "efficiency"],
 ]);
 
 /** Copilot model ids excluded from both the fallback and discovered catalogs. */
@@ -86,7 +84,9 @@ export const GITHUB_EXCLUDED_MODEL_IDS: ReadonlySet<string> = new Set([
   "gpt-5.4-mini-free-auto",
   "gpt-5.6-luna",
   "gpt-5.6-luna-free-auto",
-  "gpt-6-luna",
+  "gpt-6-luna-low",
+  "gpt-6-luna-medium",
+  "gpt-6-luna-high",
   "kimi-k3",
   "kimi-k3-base",
   "kimi-k3-copilot",

package/src/providers/integrations/hermes.ts

@@ -3,18 +3,57 @@ import type { ProviderDispatchTarget } from "../provider-contracts";
 import type { ApiKeyProviderSpec } from "../configured-provider";
 import { isRecord } from "../../protocol/codecs";
 import { boundedUpstreamArray, boundedUpstreamNumber, sanitizeUpstreamLabel } from "../provider-sanitize";
+import { getHermesVersion } from "../operations/client-versions";
 
 const HERMES_PROVIDER_ID = "hermes" as const;
 
-/** Portal attribution tags required by the Nous Research inference API. */
-const HERMES_PORTAL_TAGS = ["product=hermes-agent", "client=hermes-client-v0.13.0"] as const;
+/**
+ * Portal attribution tags the Nous Research inference API requires.
+ *
+ * The endpoint validates the *shape* and rejects the request with 400 `missing
+ * user tag` when no `user=` tag is present. Measured against the live API:
+ *
+ *   tags=[user=u1]   → 200      tags=[a=b]   → 400 missing user tag
+ *   tags=[user=]     → 200      tags=[x]     → 400 missing user tag
+ *   tags=[] / absent → 400      no user tag  → 400
+ *
+ * The value is not validated — any non-empty value passes — so `user=` is a
+ * required field rather than a credential. That matters for what to put in it:
+ * a fabricated product name would be a false attribution, and there is no
+ * account identity to send, because the inference API exposes no account,
+ * usage or quota endpoint (every candidate answers 404). `user=hermes-agent`
+ * names the client rather than inventing an end user.
+ *
+ * `product=` and `client=` are the tags Hermes' own client sends
+ * (`agent/portal_tags.py` in `NousResearch/hermes-agent`). Neither is required
+ * for dispatch — a request carrying only `user=` answers 200 — but they are
+ * sent because they are the client's real attribution and cost nothing. The
+ * client version tracks the released tag `v2026.9.24`, which is date-based:
+ * Hermes does not publish a semver, so the `0.13.0` this used to claim was not
+ * a version Hermes ever had.
+ */
+/**
+ * Builds the portal tags for one dispatch.
+ *
+ * `client=` carries the version in the shape the released tag used
+ * (`v<version>`), but the version itself is now the resolved one: the previous
+ * constant named a date tag (`v2026.9.24`) that was neither a release nor the
+ * version the project publishes. `getHermesVersion()` tracks the real release.
+ */
+function hermesPortalTags(): readonly string[] {
+  return [
+    "product=hermes-agent",
+    `client=hermes-client-v${getHermesVersion()}`,
+    "user=hermes-agent",
+  ];
+}
 
 function injectHermesTags(
   payload: Record<string, unknown>,
   _request: CanonicalRequest,
   _candidate: ProviderDispatchTarget,
 ): void {
-  payload["tags"] = [...HERMES_PORTAL_TAGS];
+  payload["tags"] = hermesPortalTags();
 }
 
 
@@ -37,10 +76,27 @@ import type { ModelDefinition } from "../provider-model-definition";
  * `upstage/solar-mini4:free` exist).
  */
 export const HERMES_MODELS: readonly ModelDefinition[] = [
-  defineModel({ id: "poolside/laguna-s-2.1:free", ctx: 262144, out: 131072, reasoning: true }),
-  defineModel({ id: "poolside/laguna-xs-2.1:free", ctx: 262144, out: 32768, reasoning: true }),
-  defineModel({ id: "stepfun/step-3.7-flash:free", ctx: 262144, out: 256000, vision: true, reasoning: true }),
-  defineModel({ id: "meituan/longcat-2.0:free", ctx: 1048756, out: 262144, reasoning: true }),
+  // The live `/models` free rows, with the limits the catalog states. Verified
+  // against the API: every id here answers 200.
+  //
+  // `meituan/longcat-2.0:free` is gone: the catalog still lists the id, but
+  // dispatching it answers 404 "This model is no longer free", so keeping it
+  // would be a card that can only ever fail. `meituan/longcat-2.5-preview:free`
+  // replaces it and answers 200.
+  //
+  // `stepfun/step-5-preview:free` is gone: it is absent from the live catalog
+  // entirely and dispatching it answers 404 "This model's free period has
+  // ended" — a retired row, not a capacity blip, so it cannot be left in.
+  //
+  // Output caps are the catalog's own `top_provider.max_completion_tokens`,
+  // which differ per row: `poolside/laguna-xs-2.1:free` is 32768 while its
+  // sibling `laguna-s` is 131072, so a uniform value overstates one of them.
+  defineModel({ id: "poolside/laguna-s-2.1:free", ctx: 262144, out: 131072, reasoning: true, free: true, freeTier: true }),
+  defineModel({ id: "poolside/laguna-xs-2.1:free", ctx: 262144, out: 32768, reasoning: true, free: true, freeTier: true }),
+  defineModel({ id: "stepfun/step-3.7-flash:free", ctx: 262144, out: 256000, vision: true, reasoning: true, free: true, freeTier: true }),
+  defineModel({ id: "upstage/solar-mini4:free", ctx: 524288, out: 131072, reasoning: true, free: true, freeTier: true }),
+  defineModel({ id: "reflection/beam-1.0-501b-a23b:free", ctx: 262144, out: 131072, reasoning: true, free: true, freeTier: true }),
+  defineModel({ id: "meituan/longcat-2.5-preview:free", ctx: 1048576, out: 131072, reasoning: true, free: true, freeTier: true }),
 ];
 
 
@@ -53,6 +109,16 @@ export const HERMES_SPEC: ApiKeyProviderSpec = {
   provider_id: HERMES_PROVIDER_ID,
   endpoint_paths_by_wire_family: {},
   prePayload: injectHermesTags,
+  // The origin sits behind Cloudflare, which answers a request carrying no
+  // `user-agent` with 403 "Attention Required!" while the same request with any
+  // non-empty UA answers 200 — measured directly against the API: an empty UA
+  // is 403, and `curl`, `node`, `python-requests`, `undici` and Bun's own
+  // default are all accepted.
+  //
+  // The value names this client as Hermes rather than claiming to be the
+  // gateway: the upstream meters by the product tag, and the version is the
+  // resolved release so a stale pin cannot drift into a mismatch.
+  extra_headers: { "user-agent": `hermes-agent/${getHermesVersion()}` },
 };
 
 /**
@@ -123,7 +189,12 @@ export async function discoverHermesFreeModels(options: {
       modalities: { input: hasImage ? ["text", "image"] : ["text"], output: ["text"] },
       reasoning: true,
       toolCall: true,
-      // The row reached this point only because both rates parse to zero.
+      // The row reached this point only because both rates parse to zero, so
+      // it is the free tier by the provider's own pricing. `free` is the
+      // billing statement and `freeTier` the catalog one; the model list groups
+      // on the tier, so without it these rows land in the fetched tail instead
+      // of the free section.
+      freeTier: true,
       cost: { input: 0, output: 0, pricing_model: "pay-per-use" },
     });
   }

package/src/providers/integrations/kilo/kilo-discovery.ts

@@ -76,6 +76,10 @@ function toModelDefinition(entry: Record<string, unknown>): ModelDefinition | un
   // clamped the same way every other catalog row is.
   const outputLimit = Math.min(declaredOutput, contextLimit);
   const parameters = supportedParameters(entry);
+  // Kilo resells the OpenRouter catalog, so the `:free` suffix is the same
+  // zero-cost spelling it carries there. Matched exactly rather than as a
+  // substring, so an id whose own name contains "free" is not swept in.
+  const freeTier = modelId.endsWith(":free");
   return {
     modelId,
     // Kilo Code exposes one OpenAI-compatible chat surface; its directory
@@ -87,7 +91,12 @@ function toModelDefinition(entry: Record<string, unknown>): ModelDefinition | un
     modalities: { input: inputModalities(entry), output: ["text"] },
     reasoning: parameters.has("reasoning") || parameters.has("include_reasoning"),
     toolCall: parameters.has("tools"),
-    cost: modelsDevCatalog.costFor(KILO_PROVIDER_ID, modelId),
+    // A `:free` row bills zero, and the catalog lookup would otherwise price it
+    // from a models.dev row that describes the paid listing.
+    ...(freeTier ? { free: true, freeTier: true } : {}),
+    cost: freeTier
+      ? { input: 0, output: 0, pricing_model: "pay-per-use" as const }
+      : modelsDevCatalog.costFor(KILO_PROVIDER_ID, modelId),
   };
 }