cartethyia 2.4.5 → 2.5.0

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

@@ -1,146 +1,153 @@
-/**
- * Kilo Code adapter.
- *
- * Kilo Code resells the OpenRouter catalog behind a bearer device token on an
- * OpenAI-compatible chat surface, so this adapter reuses the shared factory for
- * payload translation, transport, and SSE decoding.
- *
- * One thing sits outside the declarative `ApiKeyProviderSpec`: the stored
- * credential is a JSON envelope (`{ accessToken, orgId }`) because the gateway
- * scopes every request to the account's organization and the console stores one
- * opaque string per account. The factory forwards that string as the bearer
- * verbatim, so the envelope is decoded at the auth boundary here — the same
- * arrangement `kimi/kimi.ts` uses for its own envelope credential.
- *
- * The base URL is the completions path itself, because that is the path Kilo
- * Code publishes (`/api/openrouter/chat/completions`) and it is not derivable
- * from an origin plus a wire-family suffix.
- */
-import { defineModel } from "../../provider-model-definition";
-import type { ModelDefinition } from "../../provider-model-definition";
-import type { ProviderAdapter, ProviderDispatchContext, ProviderDispatchTarget } from "../../provider-contracts";
-import type { CanonicalRequest } from "../../../protocol/canonical-model";
-import { OpenAICompatibleAdapter, withBearerAuthentication } from "../../adapters/compatible-adapter";
-import { providerBaseUrl } from "../../provider-metadata";
-import { decodeKiloCredential } from "../../../security/credential-codec";
-
-export const KILO_PROVIDER_ID = "kilo" as const;
-export const KILO_BASE_URL = providerBaseUrl("kilo");
-
-/**
- * Endpoint path recorded on this provider's model rows and used by the adapter.
- *
- * The base URL carries Kilo Code's API prefix (`/api/openrouter`), so this is
- * the wire suffix that completes it — the same split Cline uses for
- * `/api/v1` + `/chat/completions`.
- */
-export const KILO_ENDPOINT_PATH = "/chat/completions" as const;
-
-interface KiloModelOptions {
-  readonly vision?: boolean;
-  readonly document?: boolean;
-  readonly audio?: boolean;
-  readonly reasoning?: boolean;
-  readonly toolCall?: boolean;
-}
-
-function kiloModel(
-  modelId: string,
-  contextLimit: number,
-  outputLimit: number,
-  options: KiloModelOptions = {},
-): ModelDefinition {
-  return defineModel({
-    id: modelId,
-    providerId: KILO_PROVIDER_ID,
-    wireFamily: "chat",
-    endpoint: KILO_ENDPOINT_PATH,
-    ctx: contextLimit,
-    out: outputLimit,
-    vision: options.vision ?? false,
-    document: options.document ?? false,
-    audio: options.audio ?? false,
-    reasoning: options.reasoning ?? false,
-    toolCall: options.toolCall ?? true,
-  });
-}
-
-/**
- * Static fallback catalog, read from the live `/api/gateway/models` directory.
- *
- * Live discovery replaces this list whenever an account is available, so these
- * rows are the offline floor: the gateway's own routing aliases plus one
- * current model per family it resells. Limits and capability come from the
- * directory entry's own `top_provider` / `architecture` /
- * `supported_parameters` fields rather than from the base catalog, which prices
- * the underlying model and not this reseller's serving.
- */
-export const KILO_MODELS: readonly ModelDefinition[] = [
-  kiloModel("kilo-auto/frontier", 1_000_000, 128_000, { vision: true, document: true, reasoning: true }),
-  kiloModel("kilo-auto/balanced", 1_000_000, 65_536, { vision: true, reasoning: true }),
-  kiloModel("kilo-auto/efficient", 1_000_000, 65_536, { vision: true, reasoning: true }),
-  kiloModel("kilo-auto/small", 262_144, 32_768, { vision: true, reasoning: true }),
-  kiloModel("kilo-auto/free", 256_000, 32_768, { reasoning: true }),
-  kiloModel("anthropic/claude-opus-4.8", 1_000_000, 128_000, { vision: true, document: true, reasoning: true }),
-  kiloModel("anthropic/claude-opus-4.7", 1_000_000, 128_000, { vision: true, document: true, reasoning: true }),
-  kiloModel("anthropic/claude-sonnet-4.6", 1_000_000, 128_000, { vision: true, document: true, reasoning: true }),
-  kiloModel("openai/gpt-6-sol", 1_050_000, 128_000, { vision: true, document: true, reasoning: true }),
-  kiloModel("openai/gpt-6-luna", 1_050_000, 128_000, { vision: true, document: true, reasoning: true }),
-  kiloModel("openai/gpt-4.1", 1_047_576, 32_768, { vision: true, document: true }),
-  kiloModel("openai/o3", 200_000, 100_000, { vision: true, document: true, reasoning: true }),
-  kiloModel("google/gemini-2.5-pro", 1_048_576, 65_536, { vision: true, document: true, audio: true, reasoning: true }),
-  kiloModel("google/gemini-2.5-flash", 1_048_576, 65_535, { vision: true, document: true, audio: true, reasoning: true }),
-  kiloModel("x-ai/grok-4.7", 500_000, 450_000, { vision: true, document: true, reasoning: true }),
-  kiloModel("moonshotai/kimi-k3", 1_048_576, 943_718, { vision: true, reasoning: true }),
-  kiloModel("z-ai/glm-5.3-flash", 1_048_576, 131_072, { vision: true, reasoning: true }),
-  kiloModel("deepseek/deepseek-chat", 163_840, 16_384),
-];
-
-/**
- * Adapter that decodes the credential envelope before the shared pipeline
- * authenticates the request.
- *
- * `prepareHeaders` is corrected rather than rebuilt: every other header the
- * factory contributes (content type, gateway identity, operator custom headers,
- * route user-agent) stays exactly as every other provider gets it.
- */
-class KiloAdapter extends OpenAICompatibleAdapter {
-  constructor(fetchImpl?: typeof fetch) {
-    super(
-      withBearerAuthentication({
-        provider_id: KILO_PROVIDER_ID,
-        base_url: KILO_BASE_URL,
-        endpoint_paths_by_wire_family: { chat: KILO_ENDPOINT_PATH },
-        ...(fetchImpl ? { fetchImpl } : {}),
-      }),
-    );
-  }
-
-  protected override async prepareHeaders(
-    context: ProviderDispatchContext,
-    request: CanonicalRequest,
-    candidate: ProviderDispatchTarget,
-  ): Promise<Record<string, string>> {
-    const headers = await super.prepareHeaders(context, request, candidate);
-    const secret = context.credential.secret;
-    if (secret === undefined || secret.length === 0) return headers;
-    // A credential that does not decode is left as the factory sent it: the
-    // request then fails closed at the upstream auth boundary, and the parse
-    // error belongs to the credential boundary rather than to this hook.
-    let credential: ReturnType<typeof decodeKiloCredential>;
-    try {
-      credential = decodeKiloCredential(secret);
-    } catch {
-      return headers;
-    }
-    headers.authorization = `Bearer ${credential.accessToken}`;
-    // The upstream's own header name, not ours: renaming the Cartethyia
-    // provider id does not rename a field the upstream reads.
-    if (credential.orgId !== undefined) headers["X-Kilocode-OrganizationID"] = credential.orgId;
-    return headers;
-  }
-}
-
-/** Kilo Code provider adapter. */
-export const kiloAdapter: ProviderAdapter = new KiloAdapter();
-
+/**
+ * Kilo Code adapter.
+ *
+ * Kilo Code resells the OpenRouter catalog behind a bearer device token on an
+ * OpenAI-compatible chat surface, so this adapter reuses the shared factory for
+ * payload translation, transport, and SSE decoding.
+ *
+ * One thing sits outside the declarative `ApiKeyProviderSpec`: the stored
+ * credential is a JSON envelope (`{ accessToken, orgId }`) because the gateway
+ * scopes every request to the account's organization and the console stores one
+ * opaque string per account. The factory forwards that string as the bearer
+ * verbatim, so the envelope is decoded at the auth boundary here — the same
+ * arrangement `kimi/kimi.ts` uses for its own envelope credential.
+ *
+ * The base URL is the completions path itself, because that is the path Kilo
+ * Code publishes (`/api/openrouter/chat/completions`) and it is not derivable
+ * from an origin plus a wire-family suffix.
+ */
+import { defineModel } from "../../provider-model-definition";
+import { openrouterFreeRoster } from "../../discovery/openrouter-free-roster";
+import type { ModelDefinition } from "../../provider-model-definition";
+import type { ProviderAdapter, ProviderDispatchContext, ProviderDispatchTarget } from "../../provider-contracts";
+import type { CanonicalRequest } from "../../../protocol/canonical-model";
+import { OpenAICompatibleAdapter, withBearerAuthentication } from "../../adapters/compatible-adapter";
+import { providerBaseUrl } from "../../provider-metadata";
+import { decodeKiloCredential } from "../../../security/credential-codec";
+
+export const KILO_PROVIDER_ID = "kilo" as const;
+export const KILO_BASE_URL = providerBaseUrl("kilo");
+
+/**
+ * Endpoint path recorded on this provider's model rows and used by the adapter.
+ *
+ * The base URL carries Kilo Code's API prefix (`/api/openrouter`), so this is
+ * the wire suffix that completes it — the same split Cline uses for
+ * `/api/v1` + `/chat/completions`.
+ */
+export const KILO_ENDPOINT_PATH = "/chat/completions" as const;
+
+interface KiloModelOptions {
+  readonly vision?: boolean;
+  readonly document?: boolean;
+  readonly audio?: boolean;
+  readonly reasoning?: boolean;
+  readonly toolCall?: boolean;
+}
+
+function kiloModel(
+  modelId: string,
+  contextLimit: number,
+  outputLimit: number,
+  options: KiloModelOptions = {},
+): ModelDefinition {
+  return defineModel({
+    id: modelId,
+    providerId: KILO_PROVIDER_ID,
+    wireFamily: "chat",
+    endpoint: KILO_ENDPOINT_PATH,
+    ctx: contextLimit,
+    out: outputLimit,
+    vision: options.vision ?? false,
+    document: options.document ?? false,
+    audio: options.audio ?? false,
+    reasoning: options.reasoning ?? false,
+    toolCall: options.toolCall ?? true,
+  });
+}
+
+/**
+ * Static fallback catalog, read from the live `/api/gateway/models` directory.
+ *
+ * Live discovery replaces this list whenever an account is available, so these
+ * rows are the offline floor: the gateway's own routing aliases plus one
+ * current model per family it resells. Limits and capability come from the
+ * directory entry's own `top_provider` / `architecture` /
+ * `supported_parameters` fields rather than from the base catalog, which prices
+ * the underlying model and not this reseller's serving.
+ */
+export const KILO_MODELS: readonly ModelDefinition[] = [
+  // Three routers, and nothing else. A committed catalog of specific ids was a
+  // snapshot of one afternoon: this provider resells the OpenRouter catalog,
+  // which adds and pulls models within days, so discovery is the authority and
+  // every hand-kept row outside these drifts out of truth.
+  //
+  // `kilo-auto/free` bills zero and `kilo-auto/small` bills a fraction of a
+  // cent; both route on the provider's own side, so their limits are the
+  // window the router may select into rather than one model's.
+  kiloModel("kilo-auto/free", 256_000, 32_768, { reasoning: true }),
+  kiloModel("kilo-auto/small", 262_144, 32_768, { vision: true, reasoning: true }),
+  kiloModel("openrouter/auto", 2_000_000, 128_000, { reasoning: true }),
+];
+
+/**
+ * The shared free roster, spelled for this provider's endpoint.
+ *
+ * The same 17 `:free` ids Cline and OpenRouter serve, because this is the same
+ * catalog behind a different origin. Kept separate from `KILO_MODELS` so the
+ * free tier is its own statement: those three rows are routers, these are the
+ * zero-cost models, and the model list groups them differently.
+ */
+export const KILO_FREE_MODELS: readonly ModelDefinition[] = openrouterFreeRoster({
+  providerId: KILO_PROVIDER_ID,
+  endpoint: KILO_ENDPOINT_PATH,
+});
+
+/**
+ * Adapter that decodes the credential envelope before the shared pipeline
+ * authenticates the request.
+ *
+ * `prepareHeaders` is corrected rather than rebuilt: every other header the
+ * factory contributes (content type, gateway identity, operator custom headers,
+ * route user-agent) stays exactly as every other provider gets it.
+ */
+class KiloAdapter extends OpenAICompatibleAdapter {
+  constructor(fetchImpl?: typeof fetch) {
+    super(
+      withBearerAuthentication({
+        provider_id: KILO_PROVIDER_ID,
+        base_url: KILO_BASE_URL,
+        endpoint_paths_by_wire_family: { chat: KILO_ENDPOINT_PATH },
+        ...(fetchImpl ? { fetchImpl } : {}),
+      }),
+    );
+  }
+
+  protected override async prepareHeaders(
+    context: ProviderDispatchContext,
+    request: CanonicalRequest,
+    candidate: ProviderDispatchTarget,
+  ): Promise<Record<string, string>> {
+    const headers = await super.prepareHeaders(context, request, candidate);
+    const secret = context.credential.secret;
+    if (secret === undefined || secret.length === 0) return headers;
+    // A credential that does not decode is left as the factory sent it: the
+    // request then fails closed at the upstream auth boundary, and the parse
+    // error belongs to the credential boundary rather than to this hook.
+    let credential: ReturnType<typeof decodeKiloCredential>;
+    try {
+      credential = decodeKiloCredential(secret);
+    } catch {
+      return headers;
+    }
+    headers.authorization = `Bearer ${credential.accessToken}`;
+    // The upstream's own header name, not ours: renaming the Cartethyia
+    // provider id does not rename a field the upstream reads.
+    if (credential.orgId !== undefined) headers["X-Kilocode-OrganizationID"] = credential.orgId;
+    return headers;
+  }
+}
+
+/** Kilo Code provider adapter. */
+export const kiloAdapter: ProviderAdapter = new KiloAdapter();
+

package/src/providers/integrations/opencode/opencode-go-quota.ts

@@ -0,0 +1,130 @@
+import {
+  getJson,
+  type FetchLike,
+  type ProviderQuotaResult,
+  type ProviderQuotaWindow,
+} from "../../quota/quota-contracts";
+import type { QuotaCollectionContext } from "../../quota/quota-support";
+
+const SOURCE = "opencode-go";
+
+/**
+ * The Go plan's `/v1/usage` answer.
+ *
+ * `usage` carries exactly three windows in the reference implementation —
+ * `rolling`, `weekly`, `monthly` — each with a `percent` and a `resetsAt`.
+ * The shape is read defensively: an unknown window name is still reported
+ * rather than dropped, since a new window is more useful to an operator than
+ * a silently narrower view.
+ */
+interface GoUsageWindow {
+  readonly percent?: number | null;
+  readonly resetsAt?: string | null;
+  readonly status?: string | null;
+}
+
+interface GoUsagePayload {
+  readonly usage?: Readonly<Record<string, GoUsageWindow | undefined>> | null;
+  readonly plan?: string | null;
+}
+
+/** Windows whose meaning the reference names, in the order it lists them. */
+const KNOWN_WINDOWS: readonly (readonly [string, string])[] = [
+  ["rolling", "Rolling"],
+  ["weekly", "Weekly"],
+  ["monthly", "Monthly"],
+];
+
+function labelFor(kind: string): string {
+  for (const [name, label] of KNOWN_WINDOWS) {
+    if (name === kind) return label;
+  }
+  return kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+
+function resetIso(value: string | null | undefined): string | null {
+  if (typeof value !== "string" || value.trim() === "") return null;
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) return null;
+  return new Date(parsed).toISOString();
+}
+
+/**
+ * One window, or `undefined` when the upstream omitted what makes it usable.
+ *
+ * A window with no percentage is not a zero-percent window — it is an absent
+ * measurement, and reporting it as `0` would tell the operator the plan is
+ * exhausted when the upstream simply did not say.
+ */
+function windowFor(
+  kind: string,
+  raw: GoUsageWindow | undefined,
+): ProviderQuotaWindow | undefined {
+  if (!raw) return undefined;
+  const percent = typeof raw.percent === "number" && Number.isFinite(raw.percent)
+    ? Math.min(100, Math.max(0, raw.percent))
+    : null;
+  if (percent === null) return undefined;
+  return {
+    kind,
+    label: labelFor(kind),
+    // The endpoint reports subscription-wide percentages, never per-key or
+    // per-model balances. Every window of one subscription reads the same
+    // budget, so adding them would double-count: they are independent, and
+    // the lowest gates the account.
+    accounting: "independent",
+    usedPercent: percent,
+    remainingPercent: 100 - percent,
+    resetsAt: resetIso(raw.resetsAt),
+  };
+}
+
+function parseWindows(payload: GoUsagePayload): readonly ProviderQuotaWindow[] {
+  const usage = payload.usage;
+  if (!usage) return [];
+  const windows: ProviderQuotaWindow[] = [];
+  const seen = new Set<string>();
+  // Known windows first, in their documented order, so the dashboard is
+  // stable across refreshes; anything novel is appended.
+  for (const [name] of KNOWN_WINDOWS) {
+    seen.add(name);
+    const window = windowFor(name, usage[name]);
+    if (window) windows.push(window);
+  }
+  for (const [name, raw] of Object.entries(usage)) {
+    if (seen.has(name)) continue;
+    const window = windowFor(name, raw);
+    if (window) windows.push(window);
+  }
+  return windows;
+}
+
+/**
+ * Fetches the OpenCode Go plan's subscription quota from `/v1/usage`.
+ *
+ * The anonymous free tier has no usage surface — it is rate-limited by egress
+ * IP, not by an account balance — so this is the keyed `opencode-go` tier
+ * only. The endpoint reports percentages for a *shared* subscription: several
+ * Go keys can draw on one plan, so no window here may be summed against
+ * another account's.
+ */
+export async function fetchOpenCodeGoQuota(
+  credential: string,
+  fetcher: FetchLike,
+  _context?: QuotaCollectionContext,
+): Promise<ProviderQuotaResult> {
+  const token = credential.trim();
+  const payload = (await getJson(
+    `https://opencode.ai/zen/go/v1/usage`,
+    {
+      authorization: `Bearer ${token}`,
+      accept: "application/json",
+      "x-opencode-client": "cli",
+    },
+    fetcher,
+  )) as GoUsagePayload;
+  const windows = parseWindows(payload);
+  const plan =
+    (typeof payload.plan === "string" && payload.plan.trim()) || "OpenCode Go";
+  return { source: SOURCE, plan, windows, error: null };
+}