ada-agent 0.9.0 → 0.10.0

package/docs/deploy.md

@@ -62,17 +62,30 @@ unified logging, caching, rate-limiting), point `CLOUDFLARE_BASE_URL` at your ga
   is stateless-leaning — durable seat/usage/audit state wants **R2/D1**, not a container disk. For a
   Cloudflare-native, stateful deploy, prefer the port below.
 
-### Phase 2 — Workers-native port (planned)
+### Cloudflare Worker (edge-native) — `src/worker/`
 
-The container is deliberately step one. The edge-native version swaps:
+An edge-native port of the backend ships in `src/worker/` (config: `wrangler.toml`, schema:
+`src/worker/schema.sql`). It's a self-contained Workers `fetch` handler: auth (D1 seats + admin key),
+the org model-allowlist, and provider passthrough with server-side metering — **Cloudflare Workers AI
+(`@cf/*`) is the first-class provider**. Use *either* this Worker *or* the container, not both.
 
-- the Node HTTP server → a Workers `fetch` handler,
-- the file-backed stores (already isolated behind `dataDir()` in `enterprise.ts`) → **D1** (seats /
-  policy / usage / audit) or **KV**,
-- streaming metering (currently a `res.write` tee) → **AI Gateway** request logs,
-- and uses **Workers AI** directly for `@cf/*`.
+```bash
+npx wrangler d1 create ada                                   # → paste the id into wrangler.toml
+npx wrangler d1 execute ada --file src/worker/schema.sql --remote
+npx wrangler secret put ADA_ADMIN_KEY                        # bootstrap admin
+npx wrangler secret put CLOUDFLARE_ACCOUNT_ID                # for @cf/* Workers AI models
+npx wrangler secret put CLOUDFLARE_API_TOKEN
+npx wrangler deploy
+# then create seats: curl -X POST -H "Authorization: Bearer $ADA_ADMIN_KEY" -d '{"name":"alice"}' https://<worker>/v1/users
+```
+
+Endpoints match the Node backend (`/v1/models`, `/v1/chat/completions`, `/v1/embeddings`, and the
+admin `/v1/users` · `/v1/policy` · `/v1/usage` · `/v1/audit`). Stores are strongly-consistent **D1**.
 
-Tracked as a follow-up; the container unblocks distribution first.
+**Deferred to a follow-up** (the Worker returns a clear error meanwhile): **native Anthropic** — reach
+Claude via OpenRouter (`anthropic/claude-…`) or point `CLOUDFLARE_BASE_URL` at an AI Gateway; and
+**OIDC SSO**, which needs a Web Crypto port of `oidc.ts` (`node:crypto`/`node:net` aren't on Workers).
+Metering is a `TransformStream` tee today; an **AI Gateway** in front gives it to you for free.
 
 ## Hardening
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ada-agent",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "A from-zero terminal coding agent with a Cursor-style routing backend, ~285 skills, MCP connectors, and ask/plan/auto modes",
   "type": "module",
   "license": "MIT",
@@ -49,6 +49,7 @@
     "start": "tsx src/client/cli.ts",
     "server": "tsx src/server/index.ts",
     "typecheck": "tsc --noEmit",
+    "typecheck:worker": "tsc -p src/worker/tsconfig.json --noEmit",
     "selfcheck": "tsx src/selfcheck.ts",
     "bench:swebench": "node bench/swebench.mjs",
     "catalog:refresh": "node scripts/refresh-catalog.mjs",
@@ -63,6 +64,7 @@
     "node-pty": "^1.1.0"
   },
   "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260702.1",
     "@types/node": "^26.0.1",
     "typescript": "^6.0.3"
   }

package/src/worker/index.ts

@@ -0,0 +1,213 @@
+// ada backend on Cloudflare Workers (R4 v1). A self-contained edge port of the Node routing server:
+// auth (D1 seats + admin key) → org model-allowlist → provider passthrough with server-side metering.
+// Cloudflare Workers AI (@cf/*) is the first-class provider. See docs/deploy.md.
+//
+// v1 scope: /health, /v1/models, /v1/chat/completions, /v1/embeddings, and the admin control plane
+// (/v1/users, /v1/policy, /v1/usage, /v1/audit). DEFERRED (follow-ups): native Anthropic (use Claude
+// via OpenRouter or a Cloudflare AI Gateway meanwhile), OIDC SSO (needs a Web Crypto port of oidc.ts).
+
+import { providerKey, providers, route } from "./providers.ts";
+import { appendAudit, appendUsage, createSeat, disableSeat, extractLastUsage, identifySeat, listSeats, loadPolicy, modelAllowed, savePolicy, seatCount, usageSummary, type Identity, type Policy } from "./store.ts";
+
+interface Env {
+  DB: D1Database;
+  ADA_ADMIN_KEY?: string;
+  [key: string]: unknown;
+}
+
+function json(status: number, obj: unknown): Response {
+  return new Response(JSON.stringify(obj), { status, headers: { "content-type": "application/json" } });
+}
+
+/** Tee a response stream to accumulate the upstream's reported token usage, recorded after the body
+ *  drains (ctx.waitUntil). Works for streamed SSE and one-shot JSON alike. */
+function meterStream(env: Env, ctx: ExecutionContext, who: Identity, model: string, provider: string, body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> {
+  let tail = "";
+  const dec = new TextDecoder();
+  const ts = new TransformStream<Uint8Array, Uint8Array>({
+    transform(chunk, controller) {
+      tail = (tail + dec.decode(chunk, { stream: true })).slice(-16_384);
+      controller.enqueue(chunk);
+    },
+    flush() {
+      const u = extractLastUsage(tail);
+      if (u) ctx.waitUntil(appendUsage(env, { ts: Date.now(), user: who.user, model, provider, promptTokens: u.promptTokens, completionTokens: u.completionTokens }));
+    },
+  });
+  return body.pipeThrough(ts);
+}
+
+async function proxyChat(env: Env, ctx: ExecutionContext, who: Identity, body: Record<string, unknown>): Promise<Response> {
+  const model = String(body.model ?? "");
+  if (!model) return json(400, { error: { message: "missing 'model'" } });
+
+  const policy: Policy = await loadPolicy(env);
+  if (!modelAllowed(model, policy)) {
+    ctx.waitUntil(appendAudit(env, { ts: Date.now(), user: who.user, event: "policy_denied_model", detail: model }));
+    return json(403, { error: { message: `model '${model}' is not allowed by org policy (allowed: ${policy.models!.join(", ")})` } });
+  }
+
+  // With an allowlist active, ignore the client's provider hint (route by model id only).
+  const explicit = policy.models?.length ? undefined : typeof body.provider === "string" ? body.provider : undefined;
+  const provider = route(model, explicit);
+  const def = providers(env)[provider];
+  if (provider === "anthropic" && def.baseURL.includes("api.anthropic.com")) {
+    return json(400, { error: { message: "native Anthropic isn't available on the Worker backend yet — use Claude via OpenRouter (model 'anthropic/claude-…') or set CLOUDFLARE_BASE_URL to an AI Gateway." } });
+  }
+  const key = providerKey(env, def);
+  if (def.keyEnv && !key) return json(400, { error: { message: `provider '${provider}' not configured — set the ${def.keyEnv} secret` } });
+
+  if (body.stream) body.stream_options = { ...((body.stream_options as Record<string, unknown>) ?? {}), include_usage: true };
+  const prefix = `${provider}/`;
+  const outModel = typeof body.model === "string" && body.model.startsWith(prefix) ? body.model.slice(prefix.length) : body.model;
+  const outBody: Record<string, unknown> = { ...body, model: outModel };
+  delete outBody.provider;
+
+  let upstream: Response;
+  try {
+    upstream = await fetch(`${def.baseURL}/chat/completions`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...(key ? { authorization: `Bearer ${key}` } : {}) },
+      body: JSON.stringify(outBody),
+    });
+  } catch (e) {
+    return json(502, { error: { message: `could not reach ${provider}: ${e instanceof Error ? e.message : String(e)}` } });
+  }
+  if (!upstream.ok || !upstream.body) {
+    const text = await upstream.text().catch(() => "");
+    return new Response(text || JSON.stringify({ error: { message: `upstream error ${upstream.status}` } }), { status: upstream.status || 502, headers: { "content-type": "application/json" } });
+  }
+  const metered = meterStream(env, ctx, who, model, provider, upstream.body);
+  return new Response(metered, { status: 200, headers: { "content-type": upstream.headers.get("content-type") ?? "text/event-stream", "cache-control": "no-cache" } });
+}
+
+async function proxyEmbeddings(env: Env, ctx: ExecutionContext, who: Identity, body: Record<string, unknown>, raw: string): Promise<Response> {
+  const model = String(body.model ?? "");
+  const policy = await loadPolicy(env);
+  if (model && !modelAllowed(model, policy)) {
+    ctx.waitUntil(appendAudit(env, { ts: Date.now(), user: who.user, event: "policy_denied_model", detail: `embeddings:${model}` }));
+    return json(403, { error: { message: `embedding model '${model}' is not allowed by org policy` } });
+  }
+  const provider = route(model);
+  const def = providers(env)[provider];
+  const key = providerKey(env, def);
+  if (def.keyEnv && !key) return json(400, { error: { message: `provider '${provider}' not configured — set the ${def.keyEnv} secret` } });
+  let upstream: Response;
+  try {
+    upstream = await fetch(`${def.baseURL}/embeddings`, { method: "POST", headers: { "content-type": "application/json", ...(key ? { authorization: `Bearer ${key}` } : {}) }, body: raw });
+  } catch (e) {
+    return json(502, { error: { message: `could not reach ${provider}: ${e instanceof Error ? e.message : String(e)}` } });
+  }
+  const text = await upstream.text();
+  const u = extractLastUsage(text);
+  if (u) ctx.waitUntil(appendUsage(env, { ts: Date.now(), user: who.user, model, provider, promptTokens: u.promptTokens, completionTokens: 0 }));
+  return new Response(text, { status: upstream.status, headers: { "content-type": "application/json" } });
+}
+
+async function listModels(env: Env): Promise<Response> {
+  const table = providers(env);
+  const data: Array<{ id: string; object: "model"; owned_by: string }> = [];
+  await Promise.all((Object.keys(table) as Array<keyof typeof table>).map(async (p) => {
+    const def = table[p];
+    const key = providerKey(env, def);
+    if (def.keyEnv && !key) return; // not configured
+    try {
+      const r = await fetch(`${def.baseURL}/models`, { headers: key ? { authorization: `Bearer ${key}` } : {} });
+      if (!r.ok) return;
+      const j = (await r.json()) as { data?: Array<{ id?: unknown }> };
+      for (const m of j.data ?? []) if (typeof m.id === "string") data.push({ id: m.id, object: "model", owned_by: String(p) });
+    } catch { /* skip a provider that errors */ }
+  }));
+  return json(200, { object: "list", data });
+}
+
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    try {
+      const url = new URL(request.url);
+      const path = url.pathname;
+      if (path === "/" || path === "/health") return new Response("ada worker ok\n", { headers: { "content-type": "text/plain" } });
+
+      const auth = request.headers.get("authorization") ?? "";
+      const token = auth.startsWith("Bearer ") ? auth.slice(7) : "";
+      const who = token ? await identifySeat(env, token) : null;
+      if (!who) return json(401, { error: { message: "unauthorized — invalid seat key or admin key" } });
+
+      const readBody = async (): Promise<{ raw: string; body: Record<string, unknown> } | null> => {
+        const raw = await request.text();
+        try {
+          return { raw, body: JSON.parse(raw) as Record<string, unknown> };
+        } catch {
+          return null;
+        }
+      };
+      const adminOnly = (): Response | null => (who.role === "admin" ? null : json(403, { error: { message: "admin only" } }));
+
+      if (request.method === "GET" && path === "/v1/whoami") return json(200, { ok: true, user: who.user, role: who.role });
+      if (request.method === "GET" && path === "/v1/models") return await listModels(env);
+      if (request.method === "POST" && path === "/v1/chat/completions") {
+        const b = await readBody();
+        return b ? await proxyChat(env, ctx, who, b.body) : json(400, { error: { message: "invalid JSON body" } });
+      }
+      if (request.method === "POST" && path === "/v1/embeddings") {
+        const b = await readBody();
+        return b ? await proxyEmbeddings(env, ctx, who, b.body, b.raw) : json(400, { error: { message: "invalid JSON body" } });
+      }
+
+      // ---- control plane ----
+      if (path === "/v1/policy") {
+        if (request.method === "GET") return json(200, await loadPolicy(env));
+        if (request.method === "PUT") {
+          const deny = adminOnly();
+          if (deny) return deny;
+          const b = await readBody();
+          if (!b) return json(400, { error: { message: "invalid JSON body" } });
+          const models = b.body.models;
+          if (models !== undefined && (!Array.isArray(models) || models.some((m) => typeof m !== "string" || !m.trim()))) return json(400, { error: { message: "models must be an array of non-empty strings" } });
+          await savePolicy(env, b.body as Policy);
+          return json(200, { ok: true });
+        }
+      }
+      if (path === "/v1/users") {
+        const deny = adminOnly();
+        if (deny) return deny;
+        if (request.method === "GET") return json(200, { users: await listSeats(env) });
+        if (request.method === "POST") {
+          const b = await readBody();
+          const name = String((b?.body.name as string) ?? "").trim();
+          const role: "admin" | "dev" = b?.body.role === "admin" ? "admin" : "dev";
+          if (!name) return json(400, { error: { message: "missing 'name'" } });
+          return json(200, { key: await createSeat(env, name, role), name, role, note: "shown once — store it now" });
+        }
+      }
+      {
+        const m = request.method === "DELETE" && path.match(/^\/v1\/users\/([\w]+)$/);
+        if (m) {
+          const deny = adminOnly();
+          if (deny) return deny;
+          const name = await disableSeat(env, m[1]!);
+          return json(name ? 200 : 404, name ? { ok: true, disabled: name } : { error: { message: "unknown or ambiguous key prefix (send ≥12 chars)" } });
+        }
+      }
+      if (request.method === "GET" && path === "/v1/usage") {
+        const deny = adminOnly();
+        if (deny) return deny;
+        return json(200, await usageSummary(env, Math.min(Number(url.searchParams.get("days")) || 30, 365)));
+      }
+      if (request.method === "GET" && path === "/v1/audit") {
+        const deny = adminOnly();
+        if (deny) return deny;
+        const limit = Math.min(Number(url.searchParams.get("limit")) || 200, 2000);
+        const { results } = await env.DB.prepare("SELECT ts, user, event, detail FROM audit ORDER BY ts DESC LIMIT ?1").bind(limit).all();
+        return json(200, { events: (results ?? []).reverse() });
+      }
+      if (request.method === "GET" && path === "/v1/enterprise") {
+        return json(200, { seats: await seatCount(env), adminKey: !!env.ADA_ADMIN_KEY });
+      }
+
+      return json(404, { error: { message: "not found" } });
+    } catch (err) {
+      return json(500, { error: { message: err instanceof Error ? err.message : String(err) } });
+    }
+  },
+};

package/src/worker/providers.ts

@@ -0,0 +1,65 @@
+// Provider table + router for the Cloudflare Worker backend. A self-contained copy of the Node
+// server's PROVIDERS/route() (src/server/{config,router}.ts) with keys read from Worker `env`
+// bindings instead of process.env — the Node modules can't be imported here (they touch node:fs).
+
+export type ProviderName =
+  | "openai" | "anthropic" | "google" | "mistral" | "openrouter" | "groq"
+  | "deepseek" | "together" | "xai" | "dashscope" | "copilot" | "cloudflare" | "ollama";
+
+export interface ProviderDef {
+  baseURL: string;
+  keyEnv: string; // "" = keyless
+}
+
+const NAMES: ReadonlySet<string> = new Set([
+  "openai", "anthropic", "google", "mistral", "openrouter", "groq",
+  "deepseek", "together", "xai", "dashscope", "copilot", "cloudflare", "ollama",
+]);
+
+/** Build the provider table from env (some base URLs are env-driven, e.g. a Cloudflare AI Gateway). */
+export function providers(env: Record<string, unknown>): Record<ProviderName, ProviderDef> {
+  const s = (k: string): string | undefined => (typeof env[k] === "string" ? (env[k] as string) : undefined);
+  return {
+    openai: { baseURL: "https://api.openai.com/v1", keyEnv: "OPENAI_API_KEY" },
+    anthropic: { baseURL: "https://api.anthropic.com/v1", keyEnv: "ANTHROPIC_API_KEY" },
+    google: { baseURL: "https://generativelanguage.googleapis.com/v1beta/openai", keyEnv: "GEMINI_API_KEY" },
+    mistral: { baseURL: "https://api.mistral.ai/v1", keyEnv: "MISTRAL_API_KEY" },
+    openrouter: { baseURL: "https://openrouter.ai/api/v1", keyEnv: "OPENROUTER_API_KEY" },
+    groq: { baseURL: "https://api.groq.com/openai/v1", keyEnv: "GROQ_API_KEY" },
+    deepseek: { baseURL: "https://api.deepseek.com", keyEnv: "DEEPSEEK_API_KEY" },
+    together: { baseURL: "https://api.together.xyz/v1", keyEnv: "TOGETHER_API_KEY" },
+    xai: { baseURL: "https://api.x.ai/v1", keyEnv: "XAI_API_KEY" },
+    dashscope: { baseURL: s("DASHSCOPE_BASE_URL") ?? "https://dashscope-intl.aliyuncs.com/compatible-mode/v1", keyEnv: "DASHSCOPE_API_KEY" },
+    copilot: { baseURL: s("COPILOT_BASE_URL") ?? "https://api.githubcopilot.com", keyEnv: "COPILOT_API_KEY" },
+    // Cloudflare Workers AI (OpenAI-compatible) — the first-class provider on this backend. Point
+    // CLOUDFLARE_BASE_URL at an AI Gateway to get caching/analytics/rate-limiting across providers.
+    cloudflare: { baseURL: s("CLOUDFLARE_BASE_URL") ?? `https://api.cloudflare.com/client/v4/accounts/${s("CLOUDFLARE_ACCOUNT_ID") ?? ""}/ai/v1`, keyEnv: "CLOUDFLARE_API_TOKEN" },
+    ollama: { baseURL: s("OLLAMA_BASE_URL") ?? "http://localhost:11434/v1", keyEnv: "" },
+  };
+}
+
+/** Model id (+ optional explicit provider) → provider. Identical rules to the Node router. */
+export function route(model: string, explicit?: string): ProviderName {
+  if (explicit && NAMES.has(explicit)) return explicit as ProviderName;
+  const m = model.toLowerCase();
+  if (m.startsWith("@cf/")) return "cloudflare";
+  if (m.startsWith("copilot/")) return "copilot";
+  if (m.startsWith("groq/")) return "groq";
+  if (m.startsWith("together/")) return "together";
+  if (m.includes("/")) return "openrouter";
+  if (m.includes(":")) return "ollama";
+  if (/^(gpt|o1|o3|o4|chatgpt|text-|davinci)/.test(m)) return "openai";
+  if (m.startsWith("claude")) return "anthropic";
+  if (m.startsWith("gemini") || m.startsWith("gemma")) return "google";
+  if (/^(mistral|codestral|magistral|ministral|devstral|pixtral|open-mi)/.test(m)) return "mistral";
+  if (m.startsWith("grok")) return "xai";
+  if (m.startsWith("deepseek")) return "deepseek";
+  if (m.startsWith("qwen") || m.startsWith("qwq")) return "dashscope";
+  return "openrouter";
+}
+
+export function providerKey(env: Record<string, unknown>, def: ProviderDef): string | undefined {
+  if (!def.keyEnv) return undefined;
+  const v = env[def.keyEnv];
+  return typeof v === "string" && v ? v : undefined;
+}

package/src/worker/schema.sql

@@ -0,0 +1,36 @@
+-- D1 schema for the ada Worker backend (seats / policy / usage / audit).
+--   npx wrangler d1 execute ada --file src/worker/schema.sql --remote
+-- Prototype-safe auth by construction: seat lookup is a parameterized `WHERE key = ?` bind.
+
+CREATE TABLE IF NOT EXISTS seats (
+  key         TEXT PRIMARY KEY,
+  name        TEXT NOT NULL,
+  role        TEXT NOT NULL DEFAULT 'dev',
+  disabled    INTEGER NOT NULL DEFAULT 0,
+  external_id TEXT,               -- OIDC iss#sub (reserved for the SSO follow-up)
+  iss         TEXT,
+  created     TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS policy (
+  id   INTEGER PRIMARY KEY CHECK (id = 1),  -- single row
+  json TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS usage (
+  ts               INTEGER NOT NULL,
+  user             TEXT NOT NULL,
+  model            TEXT NOT NULL,
+  provider         TEXT NOT NULL,
+  prompt_tokens    INTEGER NOT NULL DEFAULT 0,
+  completion_tokens INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS usage_ts ON usage (ts);
+
+CREATE TABLE IF NOT EXISTS audit (
+  ts     INTEGER NOT NULL,
+  user   TEXT NOT NULL,
+  event  TEXT NOT NULL,
+  detail TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS audit_ts ON audit (ts);

package/src/worker/store.ts

@@ -0,0 +1,157 @@
+// D1-backed control-plane store for the Worker backend — the edge equivalent of the Node
+// enterprise.ts (seats / policy / usage), strongly consistent via D1 SQL. Schema in schema.sql.
+//
+// Auth is prototype-safe by construction: seat lookup is a parameterized `WHERE key = ?` bind, so a
+// token like "__proto__" is just a string that matches no row. Admin compare is constant-time.
+
+export interface Identity {
+  user: string;
+  role: "admin" | "dev";
+}
+export interface Policy {
+  models?: string[];
+  permissions?: Array<{ tool?: string; pattern?: string; action: "allow" | "ask" | "deny" }>;
+}
+
+interface Env {
+  DB: D1Database;
+  ADA_ADMIN_KEY?: string;
+}
+
+/** Constant-time string compare (Workers has no crypto.timingSafeEqual). */
+function ctEqual(a: string, b: string): boolean {
+  if (a.length !== b.length) return false;
+  let r = 0;
+  for (let i = 0; i < a.length; i++) r |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return r === 0;
+}
+
+function hex(bytes: Uint8Array): string {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+/** Resolve a bearer token → identity, or null. Admin key (env) first, then the seats table. */
+export async function identifySeat(env: Env, token: string): Promise<Identity | null> {
+  const admin = env.ADA_ADMIN_KEY;
+  if (admin && ctEqual(token, admin)) return { user: "admin", role: "admin" };
+  if (!token.startsWith("ada_sk_")) return null; // format guard
+  const row = await env.DB.prepare("SELECT name, role, disabled FROM seats WHERE key = ?1").bind(token).first<{ name: string; role: string; disabled: number }>();
+  if (!row || row.disabled) return null;
+  return { user: row.name, role: row.role === "admin" ? "admin" : "dev" };
+}
+
+export async function createSeat(env: Env, name: string, role: "admin" | "dev"): Promise<string> {
+  const key = "ada_sk_" + hex(crypto.getRandomValues(new Uint8Array(24)));
+  await env.DB.prepare("INSERT INTO seats (key, name, role, disabled, created) VALUES (?1, ?2, ?3, 0, ?4)")
+    .bind(key, name, role, new Date().toISOString()).run();
+  await appendAudit(env, { ts: Date.now(), user: "-", event: "seat_created", detail: `${name} (${role})` });
+  return key;
+}
+
+export async function listSeats(env: Env): Promise<Array<{ name: string; role: string; disabled: number; created: string; keyPrefix: string }>> {
+  const { results } = await env.DB.prepare("SELECT key, name, role, disabled, created FROM seats ORDER BY created").all<{ key: string; name: string; role: string; disabled: number; created: string }>();
+  return (results ?? []).map((r) => ({ name: r.name, role: r.role, disabled: r.disabled, created: r.created, keyPrefix: r.key.slice(0, 14) }));
+}
+
+export async function disableSeat(env: Env, prefix: string): Promise<string | null> {
+  if (prefix.length < 12) return null;
+  const rows = await env.DB.prepare("SELECT key, name FROM seats WHERE key LIKE ?1").bind(prefix + "%").all<{ key: string; name: string }>();
+  if ((rows.results?.length ?? 0) !== 1) return null;
+  const seat = rows.results![0]!;
+  await env.DB.prepare("UPDATE seats SET disabled = 1 WHERE key = ?1").bind(seat.key).run();
+  await appendAudit(env, { ts: Date.now(), user: "-", event: "seat_disabled", detail: seat.name });
+  return seat.name;
+}
+
+export async function loadPolicy(env: Env): Promise<Policy> {
+  const row = await env.DB.prepare("SELECT json FROM policy WHERE id = 1").first<{ json: string }>();
+  if (!row) return {};
+  try {
+    return JSON.parse(row.json) as Policy;
+  } catch {
+    return {}; // a corrupt single row shouldn't wedge routing; treat as no-allowlist
+  }
+}
+
+export async function savePolicy(env: Env, p: Policy): Promise<void> {
+  await env.DB.prepare("INSERT INTO policy (id, json) VALUES (1, ?1) ON CONFLICT(id) DO UPDATE SET json = ?1").bind(JSON.stringify(p)).run();
+  await appendAudit(env, { ts: Date.now(), user: "-", event: "policy_updated", detail: JSON.stringify(p).slice(0, 300) });
+}
+
+function globMatch(pattern: string, s: string): boolean {
+  const re = new RegExp("^" + pattern.split("*").map((x) => x.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$", "i");
+  return re.test(s);
+}
+
+export function modelAllowed(model: string, policy: Policy): boolean {
+  if (!Array.isArray(policy.models) || !policy.models.length) return true;
+  return policy.models.some((p) => globMatch(p, model));
+}
+
+export interface UsageRow { ts: number; user: string; model: string; provider: string; promptTokens: number; completionTokens: number }
+
+export async function appendUsage(env: Env, r: UsageRow): Promise<void> {
+  try {
+    await env.DB.prepare("INSERT INTO usage (ts, user, model, provider, prompt_tokens, completion_tokens) VALUES (?1,?2,?3,?4,?5,?6)")
+      .bind(r.ts, r.user, r.model, r.provider, r.promptTokens, r.completionTokens).run();
+  } catch { /* metering is best-effort; never fail a request over it */ }
+}
+
+export async function appendAudit(env: Env, r: { ts: number; user: string; event: string; detail: string }): Promise<void> {
+  try {
+    await env.DB.prepare("INSERT INTO audit (ts, user, event, detail) VALUES (?1,?2,?3,?4)").bind(r.ts, r.user, r.event, r.detail).run();
+  } catch { /* best-effort */ }
+}
+
+export async function usageSummary(env: Env, days: number): Promise<unknown> {
+  const since = Date.now() - days * 86_400_000;
+  const agg = async (groupBy: string): Promise<Record<string, unknown>> => {
+    const { results } = await env.DB.prepare(`SELECT ${groupBy} AS k, COUNT(*) AS requests, SUM(prompt_tokens) AS promptTokens, SUM(completion_tokens) AS completionTokens FROM usage WHERE ts >= ?1 GROUP BY ${groupBy}`).bind(since).all<{ k: string; requests: number; promptTokens: number; completionTokens: number }>();
+    const out: Record<string, unknown> = {};
+    for (const r of results ?? []) out[r.k] = { requests: r.requests, promptTokens: r.promptTokens ?? 0, completionTokens: r.completionTokens ?? 0 };
+    return out;
+  };
+  const totalsRow = await env.DB.prepare("SELECT COUNT(*) AS requests, SUM(prompt_tokens) AS promptTokens, SUM(completion_tokens) AS completionTokens FROM usage WHERE ts >= ?1").bind(since).first<{ requests: number; promptTokens: number; completionTokens: number }>();
+  return {
+    since,
+    totals: { requests: totalsRow?.requests ?? 0, promptTokens: totalsRow?.promptTokens ?? 0, completionTokens: totalsRow?.completionTokens ?? 0 },
+    byUser: await agg("user"),
+    byModel: await agg("model"),
+  };
+}
+
+export async function seatCount(env: Env): Promise<number> {
+  const row = await env.DB.prepare("SELECT COUNT(*) AS n FROM seats WHERE disabled = 0").first<{ n: number }>();
+  return row?.n ?? 0;
+}
+
+/** Pull the LAST real `"usage": {…}` object from streamed/response text (copy of enterprise.ts). */
+export function extractLastUsage(text: string): { promptTokens: number; completionTokens: number } | null {
+  const matchBraces = (t: string, start: number): string | null => {
+    let depth = 0, inStr = false, esc = false;
+    for (let i = start; i < t.length; i++) {
+      const c = t[i];
+      if (inStr) { if (esc) esc = false; else if (c === "\\") esc = true; else if (c === '"') inStr = false; }
+      else if (c === '"') inStr = true;
+      else if (c === "{") depth++;
+      else if (c === "}" && --depth === 0) return t.slice(start, i + 1);
+    }
+    return null;
+  };
+  let at = text.lastIndexOf('"usage"');
+  while (at >= 0) {
+    const brace = text.indexOf("{", at + 7);
+    const colon = text.indexOf(":", at + 7);
+    if (brace >= 0 && colon >= 0 && text.slice(colon + 1, brace).trim() === "") {
+      const obj = matchBraces(text, brace);
+      if (obj) {
+        try {
+          const u = JSON.parse(obj) as { prompt_tokens?: number; completion_tokens?: number };
+          if (u.prompt_tokens != null || u.completion_tokens != null) return { promptTokens: u.prompt_tokens ?? 0, completionTokens: u.completion_tokens ?? 0 };
+        } catch { /* keep scanning back */ }
+      }
+    }
+    at = text.lastIndexOf('"usage"', at - 1);
+  }
+  return null;
+}

package/src/worker/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "types": ["@cloudflare/workers-types"],
+    "lib": ["ES2023"]
+  },
+  "include": ["."],
+  "exclude": []
+}

package/tsconfig.json

@@ -11,5 +11,6 @@
     "allowImportingTsExtensions": true,
     "types": ["node"]
   },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": ["src/worker"]
 }