ada-agent 0.1.0

package/src/server/config.ts

@@ -0,0 +1,58 @@
+// Backend configuration: provider upstreams, keys, client-key auth, port.
+// Everything is env-driven. The backend is the only place provider keys live.
+
+import { getCredential } from "./credentials.ts";
+import type { ProviderName } from "../shared/types.ts";
+
+export interface ProviderDef {
+  baseURL: string; // OpenAI-compatible base (…/v1) — every provider is proxied as-is
+  keyEnv: string; // env var holding this provider's key ("" = keyless, e.g. local Ollama)
+}
+
+export const PROVIDERS: Record<ProviderName, ProviderDef> = {
+  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: process.env.DASHSCOPE_BASE_URL ?? "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+    keyEnv: "DASHSCOPE_API_KEY",
+  },
+  // GitHub Copilot — OpenAI-compatible chat endpoint. COPILOT_API_KEY must be a Copilot *bearer*
+  // token (exchanged from a GitHub OAuth token at /copilot_internal/v2/token — that exchange is not
+  // implemented here; it needs a Copilot subscription). Required headers are added in the adapter.
+  copilot: { baseURL: process.env.COPILOT_BASE_URL ?? "https://api.githubcopilot.com", keyEnv: "COPILOT_API_KEY" },
+  ollama: { baseURL: process.env.OLLAMA_BASE_URL ?? "http://localhost:11434/v1", keyEnv: "" },
+};
+
+export const PORT = Number(process.env.ADA_PORT) || 8787;
+
+/** The ada client keys allowed to use this backend. null = auth disabled (dev mode). */
+export function clientKeys(): string[] | null {
+  const v = process.env.ADA_CLIENT_KEYS;
+  if (!v) return null;
+  return v.split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+/** The upstream provider key: env var first, then a stored credential (API key or OAuth token). */
+export function providerKey(p: ProviderName): string | undefined {
+  const env = PROVIDERS[p].keyEnv;
+  if (env && process.env[env]) return process.env[env];
+  const cred = getCredential(p);
+  if (cred) return cred.type === "oauth" ? cred.access : cred.key;
+  return undefined; // keyless provider (Ollama) or unconfigured
+}
+
+/** A provider is usable if it's keyless, its key env var is set, or a credential is stored. */
+export function isConfigured(p: ProviderName): boolean {
+  return PROVIDERS[p].keyEnv === "" || !!process.env[PROVIDERS[p].keyEnv] || !!getCredential(p);
+}
+
+export function configuredProviders(): ProviderName[] {
+  return (Object.keys(PROVIDERS) as ProviderName[]).filter(isConfigured);
+}

package/src/server/credentials.ts

@@ -0,0 +1,89 @@
+// Credential store at ~/.ada/credentials.json. Holds API keys and OAuth tokens so the
+// backend can use them as provider keys. Writes are atomic (temp + rename) and guarded by a
+// coarse cross-process lock (an atomically-created lock dir) so a token refresh can't race.
+
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const FILE = join(homedir(), ".ada", "credentials.json");
+
+export interface Credential {
+  type: "api_key" | "oauth";
+  key?: string; // api_key
+  access?: string; // oauth access token
+  refresh?: string; // oauth refresh token
+  expires?: number; // epoch ms
+}
+
+type Store = Record<string, Credential>;
+
+function read(): Store {
+  try {
+    return JSON.parse(readFileSync(FILE, "utf8")) as Store;
+  } catch {
+    return {};
+  }
+}
+
+function write(s: Store): void {
+  mkdirSync(dirname(FILE), { recursive: true });
+  const tmp = `${FILE}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(s, null, 2), "utf8");
+  renameSync(tmp, FILE); // atomic replace
+}
+
+async function withLock<T>(fn: () => T): Promise<T> {
+  mkdirSync(dirname(FILE), { recursive: true }); // ensure ~/.ada exists so the lock dir can be created
+  const lock = `${FILE}.lock`;
+  for (let i = 0; ; i++) {
+    try {
+      mkdirSync(lock); // mkdir is atomic: succeeds for exactly one holder
+      break;
+    } catch {
+      try {
+        if (Date.now() - statSync(lock).mtimeMs > 30_000) {
+          rmSync(lock, { recursive: true, force: true }); // break a stale lock from a crashed run
+          continue;
+        }
+      } catch {
+        /* lock vanished — retry */
+      }
+      if (i >= 50) throw new Error("could not acquire credential lock");
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    try {
+      rmSync(lock, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+export function getCredential(provider: string): Credential | undefined {
+  return read()[provider];
+}
+
+export function listCredentials(): string[] {
+  return Object.keys(read());
+}
+
+export async function setCredential(provider: string, cred: Credential): Promise<void> {
+  await withLock(() => {
+    const s = read();
+    s[provider] = cred;
+    write(s);
+  });
+}
+
+export async function deleteCredential(provider: string): Promise<void> {
+  await withLock(() => {
+    const s = read();
+    delete s[provider];
+    write(s);
+  });
+}

package/src/server/identity.ts

@@ -0,0 +1,58 @@
+// Identity verification for "sign in with GitHub / Google". A login token is an IDENTITY
+// ("this is user X"), not a provider key — so the backend verifies it with the provider and
+// (optionally) checks an allowlist, instead of using it to call a model. Results are cached
+// briefly to avoid hitting the provider on every request.
+
+interface Identity {
+  provider: string;
+  user: string;
+}
+
+const cache = new Map<string, { id: Identity; exp: number }>();
+const TTL = 5 * 60_000;
+
+async function verifyGitHub(token: string): Promise<Identity | null> {
+  const r = await fetch("https://api.github.com/user", {
+    headers: { authorization: `Bearer ${token}`, "user-agent": "ada", accept: "application/vnd.github+json" },
+  });
+  if (!r.ok) return null;
+  const j = (await r.json()) as { login?: string };
+  return j.login ? { provider: "github", user: j.login } : null;
+}
+
+async function verifyGoogle(token: string): Promise<Identity | null> {
+  const r = await fetch("https://www.googleapis.com/oauth2/v3/userinfo", { headers: { authorization: `Bearer ${token}` } });
+  if (!r.ok) return null;
+  const j = (await r.json()) as { email?: string };
+  return j.email ? { provider: "google", user: j.email } : null;
+}
+
+/** Resolve a bearer token to an identity (GitHub or Google), or null. */
+export async function verifyIdentity(token: string): Promise<Identity | null> {
+  if (!token) return null;
+  const hit = cache.get(token);
+  if (hit && hit.exp > Date.now()) return hit.id;
+
+  let id: Identity | null = null;
+  try {
+    if (/^gh[opsu]_/.test(token) || token.startsWith("github_pat_")) id = await verifyGitHub(token);
+    else if (token.startsWith("ya29.")) id = await verifyGoogle(token);
+    else id = (await verifyGitHub(token)) ?? (await verifyGoogle(token)); // unknown shape: try both
+  } catch {
+    id = null;
+  }
+  if (id) cache.set(token, { id, exp: Date.now() + TTL });
+  return id;
+}
+
+/** Allowed login users (GitHub logins / Google emails), or null = any authenticated user. */
+export function allowedUsers(): string[] | null {
+  const v = process.env.ADA_ALLOWED_USERS;
+  if (!v) return null;
+  return v.split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+export function isAllowed(user: string): boolean {
+  const a = allowedUsers();
+  return !a || a.includes(user);
+}

package/src/server/index.ts

@@ -0,0 +1,113 @@
+// ada backend — the Cursor-style routing layer.
+// Client → here (auth → route → dispatch to an adapter) → upstream providers.
+// Provider keys live ONLY here; the client never sees them.
+
+import { createServer } from "node:http";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { PORT, PROVIDERS, clientKeys, configuredProviders, isConfigured } from "./config.ts";
+import { allowedUsers, isAllowed, verifyIdentity } from "./identity.ts";
+import { adapterFor } from "./providers/registry.ts";
+import { route } from "./router.ts";
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (c) => (data += c));
+    req.on("end", () => resolve(data));
+    req.on("error", reject);
+  });
+}
+
+function locked(): boolean {
+  return clientKeys() !== null || allowedUsers() !== null || !!process.env.ADA_REQUIRE_LOGIN;
+}
+
+/** A request is allowed if it carries a known static client key, OR a valid GitHub/Google
+ *  login token (allowlisted). With nothing configured, the backend is open (dev mode). */
+async function authorized(req: IncomingMessage): Promise<boolean> {
+  if (!locked()) return true; // dev mode: no auth configured
+  const h = req.headers["authorization"];
+  const token = typeof h === "string" && h.startsWith("Bearer ") ? h.slice(7) : "";
+  if (!token) return false;
+  const keys = clientKeys();
+  if (keys?.includes(token)) return true; // static client key
+  const id = await verifyIdentity(token); // GitHub / Google login
+  return !!id && isAllowed(id.user);
+}
+
+function json(res: ServerResponse, status: number, obj: unknown): void {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(obj));
+}
+
+async function handleModels(res: ServerResponse): Promise<void> {
+  const data: Array<{ id: string; object: "model"; owned_by: string }> = [];
+  for (const p of configuredProviders()) {
+    const ids = await adapterFor(p).listModels(p);
+    for (const id of ids) data.push({ id, object: "model", owned_by: p });
+  }
+  json(res, 200, { object: "list", data });
+}
+
+async function handleChat(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const raw = await readBody(req);
+  let body: Record<string, unknown>;
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    return json(res, 400, { error: { message: "invalid JSON body" } });
+  }
+
+  const model = String(body.model ?? "");
+  if (!model) return json(res, 400, { error: { message: "missing 'model'" } });
+
+  const provider = route(model, typeof body.provider === "string" ? body.provider : undefined);
+  if (!isConfigured(provider)) {
+    return json(res, 400, {
+      error: { message: `provider '${provider}' not configured — set ${PROVIDERS[provider].keyEnv} on the backend` },
+    });
+  }
+
+  delete body.provider; // our routing hint; never forward it upstream
+  await adapterFor(provider).chat({ provider, model, body, res });
+}
+
+const server = createServer(async (req, res) => {
+  try {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (url.pathname === "/" || url.pathname === "/health") {
+      res.writeHead(200, { "content-type": "text/plain" });
+      return res.end("ada backend ok");
+    }
+    if (req.method === "GET" && url.pathname === "/v1/whoami") {
+      if (!(await authorized(req))) return json(res, 401, { error: { message: "not logged in" } });
+      return json(res, 200, { ok: true });
+    }
+    if (req.method === "GET" && url.pathname === "/v1/models") {
+      if (!(await authorized(req))) return json(res, 401, { error: { message: "unauthorized — invalid client key or login" } });
+      return await handleModels(res);
+    }
+    if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+      if (!(await authorized(req))) return json(res, 401, { error: { message: "unauthorized — invalid client key or login" } });
+      return await handleChat(req, res);
+    }
+    return json(res, 404, { error: { message: "not found" } });
+  } catch (err) {
+    if (!res.headersSent) json(res, 500, { error: { message: err instanceof Error ? err.message : String(err) } });
+    else
+      try {
+        res.end();
+      } catch {
+        /* ignore */
+      }
+  }
+});
+
+server.listen(PORT, () => {
+  const auth = locked()
+    ? `auth ON (client keys + GitHub/Google login${allowedUsers() ? `, allowlist: ${allowedUsers()!.length}` : ""})`
+    : "AUTH DISABLED (dev) — set ADA_CLIENT_KEYS or ADA_ALLOWED_USERS to lock down";
+  const provs = configuredProviders();
+  console.log(`ada backend → http://localhost:${PORT}  [${auth}]`);
+  console.log(`providers: ${provs.length ? provs.join(", ") : "(none configured — set provider API keys)"}`);
+});

package/src/server/oauth.ts

@@ -0,0 +1,93 @@
+// OAuth 2.0 Device Authorization Grant (RFC 8628). Works against any compliant provider
+// (GitHub, Google, …). Provider client IDs / endpoints are env-driven because they are
+// provider-specific: ADA_OAUTH_<PROVIDER>_{CLIENT_ID,DEVICE_URL,TOKEN_URL,SCOPE}.
+
+import { setCredential } from "./credentials.ts";
+
+export interface OAuthConfig {
+  clientId: string;
+  deviceUrl: string;
+  tokenUrl: string;
+  scope?: string;
+  clientSecret?: string; // GitHub device flow omits this; Google requires it
+}
+
+// Built-in OAuth app config. A client_id and these endpoints are PUBLIC (they show up in browser
+// URLs) — they identify the *app* (ada), not the user — so we ship them. Like `gh`, the user sets
+// nothing. Env vars (ADA_OAUTH_<P>_*) override, e.g. to point ada at your own OAuth app.
+const DEFAULTS: Record<string, Partial<OAuthConfig>> = {
+  github: {
+    clientId: "Ov23lirXtvfJWAt9C8et",
+    deviceUrl: "https://github.com/login/device/code",
+    tokenUrl: "https://github.com/login/oauth/access_token",
+    scope: "read:user",
+  },
+  google: {
+    // Google device flow needs a client_id (+ secret) from your own GCP project — set via env.
+    deviceUrl: "https://oauth2.googleapis.com/device/code",
+    tokenUrl: "https://oauth2.googleapis.com/token",
+    scope: "openid email",
+  },
+};
+
+export function oauthConfig(provider: string): OAuthConfig | null {
+  const up = provider.toUpperCase();
+  const d = DEFAULTS[provider] ?? {};
+  const clientId = process.env[`ADA_OAUTH_${up}_CLIENT_ID`] ?? d.clientId;
+  const deviceUrl = process.env[`ADA_OAUTH_${up}_DEVICE_URL`] ?? d.deviceUrl;
+  const tokenUrl = process.env[`ADA_OAUTH_${up}_TOKEN_URL`] ?? d.tokenUrl;
+  if (!clientId || !deviceUrl || !tokenUrl) return null;
+  return {
+    clientId,
+    deviceUrl,
+    tokenUrl,
+    scope: process.env[`ADA_OAUTH_${up}_SCOPE`] ?? d.scope,
+    clientSecret: process.env[`ADA_OAUTH_${up}_CLIENT_SECRET`] ?? d.clientSecret,
+  };
+}
+
+async function postForm(url: string, body: Record<string, string>): Promise<Record<string, unknown>> {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
+    body: new URLSearchParams(body),
+  });
+  return (await res.json()) as Record<string, unknown>;
+}
+
+/** Run the device flow: print the user code, poll for the token, store it on success. */
+export async function deviceLogin(provider: string, cfg: OAuthConfig, print: (s: string) => void): Promise<void> {
+  const secret: Record<string, string> = cfg.clientSecret ? { client_secret: cfg.clientSecret } : {};
+  const dev = await postForm(cfg.deviceUrl, { client_id: cfg.clientId, scope: cfg.scope ?? "", ...secret });
+  const deviceCode = dev.device_code as string;
+  if (!deviceCode) throw new Error(`device request failed: ${JSON.stringify(dev)}`);
+  print(`\nTo log in to ${provider}, open:\n  ${dev.verification_uri ?? dev.verification_uri_complete ?? dev.verification_url}`);
+  print(`and enter the code:  ${dev.user_code}\n`);
+
+  const interval = (Number(dev.interval) || 5) * 1000;
+  const deadline = Date.now() + (Number(dev.expires_in) || 900) * 1000;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, interval));
+    const tok = await postForm(cfg.tokenUrl, {
+      client_id: cfg.clientId,
+      device_code: deviceCode,
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      ...secret,
+    });
+    if (tok.access_token) {
+      await setCredential(provider, {
+        type: "oauth",
+        access: tok.access_token as string,
+        refresh: tok.refresh_token as string | undefined,
+        expires: tok.expires_in ? Date.now() + Number(tok.expires_in) * 1000 : undefined,
+      });
+      print(`Logged in to ${provider}.`);
+      return;
+    }
+    const err = tok.error as string | undefined;
+    if (err && err !== "authorization_pending" && err !== "slow_down") {
+      throw new Error((tok.error_description as string) ?? err);
+    }
+  }
+  throw new Error("device login timed out");
+}

package/src/server/providers/adapter.ts

@@ -0,0 +1,25 @@
+// The provider adapter pattern.
+//
+// One adapter per WIRE FORMAT — not per model, not per provider. Most providers speak
+// the OpenAI Chat Completions format and share `openAICompatAdapter`; only providers whose
+// format genuinely diverges (e.g. Anthropic's Messages API) get their own adapter.
+//
+// Every adapter takes an OpenAI-format request and streams an OpenAI-format SSE response,
+// so the client only ever deals with one wire format.
+
+import type { ServerResponse } from "node:http";
+import type { ProviderName } from "../../shared/types.ts";
+
+export interface ChatRequest {
+  provider: ProviderName;
+  model: string;
+  body: Record<string, unknown>; // an OpenAI Chat Completions request body
+  res: ServerResponse;
+}
+
+export interface Adapter {
+  /** Stream an OpenAI-format chat completion (SSE) for `req.provider`. */
+  chat(req: ChatRequest): Promise<void>;
+  /** List the model ids this provider exposes. */
+  listModels(provider: ProviderName): Promise<string[]>;
+}

package/src/server/providers/anthropic.ts

@@ -0,0 +1,189 @@
+// Native Anthropic adapter. Anthropic's Messages API is NOT OpenAI-shaped, so this adapter
+// translates the OpenAI request → Anthropic Messages, streams it, and re-emits Anthropic
+// events as OpenAI SSE chunks. The @anthropic-ai/sdk is loaded lazily (top-level `import type`
+// is erased at runtime; the dynamic import() only runs the first time a Claude request
+// arrives) — so the SDK never loads unless Anthropic is actually used.
+
+import type AnthropicSDK from "@anthropic-ai/sdk";
+import { providerKey } from "../config.ts";
+import { endStream, SSE_HEADERS, writeChunk } from "../sse.ts";
+import type { Adapter, ChatRequest } from "./adapter.ts";
+
+let cached: AnthropicSDK | null = null;
+async function getClient(): Promise<AnthropicSDK> {
+  if (!cached) {
+    const { default: Anthropic } = await import("@anthropic-ai/sdk");
+    cached = new Anthropic({ apiKey: providerKey("anthropic") });
+  }
+  return cached;
+}
+
+type OAIMessage = {
+  role: string;
+  content?: unknown;
+  tool_calls?: Array<{ id: string; function: { name: string; arguments: string } }>;
+  tool_call_id?: string;
+};
+
+type Block = Record<string, unknown>;
+
+/** OpenAI messages[] → Anthropic { system, messages[] }. */
+function convert(messages: OAIMessage[]): { system?: string; messages: Block[] } {
+  const system: string[] = [];
+  const out: Block[] = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i]!;
+
+    if (msg.role === "system") {
+      if (typeof msg.content === "string") system.push(msg.content);
+      continue;
+    }
+
+    if (msg.role === "tool") {
+      // Merge a run of consecutive tool messages into one Anthropic user turn.
+      const results: Block[] = [];
+      let j = i;
+      while (j < messages.length && messages[j]!.role === "tool") {
+        const t = messages[j]!;
+        results.push({ type: "tool_result", tool_use_id: t.tool_call_id, content: String(t.content ?? "") });
+        j++;
+      }
+      out.push({ role: "user", content: results });
+      i = j - 1;
+      continue;
+    }
+
+    if (msg.role === "assistant") {
+      const blocks: Block[] = [];
+      if (msg.content) blocks.push({ type: "text", text: String(msg.content) });
+      for (const tc of msg.tool_calls ?? []) {
+        let input: unknown = {};
+        try {
+          input = JSON.parse(tc.function.arguments || "{}");
+        } catch {
+          input = {};
+        }
+        blocks.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
+      }
+      out.push({ role: "assistant", content: blocks.length ? blocks : [{ type: "text", text: "(no content)" }] });
+      continue;
+    }
+
+    if (Array.isArray(msg.content)) {
+      // multimodal user turn: translate OpenAI parts → Anthropic blocks (text + base64 images)
+      const blocks: Block[] = (msg.content as Array<Record<string, unknown>>).map((part) => {
+        if (part.type === "image_url") {
+          const url = String((part.image_url as { url?: string })?.url ?? "");
+          const m = /^data:(.+?);base64,(.*)$/.exec(url);
+          if (m) return { type: "image", source: { type: "base64", media_type: m[1], data: m[2] } };
+          return { type: "image", source: { type: "url", url } };
+        }
+        return { type: "text", text: String(part.text ?? "") };
+      });
+      out.push({ role: "user", content: blocks });
+    } else {
+      out.push({ role: "user", content: typeof msg.content === "string" ? msg.content : String(msg.content ?? "") });
+    }
+  }
+
+  return { system: system.length ? system.join("\n\n") : undefined, messages: out };
+}
+
+function mapStop(reason: string | null | undefined): string {
+  switch (reason) {
+    case "tool_use":
+      return "tool_calls";
+    case "max_tokens":
+      return "length";
+    default:
+      return "stop";
+  }
+}
+
+export const anthropicAdapter: Adapter = {
+  async chat({ body, res }: ChatRequest): Promise<void> {
+    const id = `chatcmpl-${Math.random().toString(16).slice(2, 12)}`;
+    const created = Math.floor(Date.now() / 1000);
+    const model = String(body.model);
+    const chunk = (delta: Block, finish: string | null = null) =>
+      writeChunk(res, { id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta, finish_reason: finish }] });
+
+    res.writeHead(200, SSE_HEADERS);
+    chunk({ role: "assistant" });
+
+    let stop = "stop";
+    let toolIndex = -1;
+
+    try {
+      const client = await getClient();
+      const { system, messages } = convert((body.messages as OAIMessage[]) ?? []);
+      const tools = (
+        (body.tools as Array<{ function: { name: string; description?: string; parameters?: unknown } }>) ?? []
+      ).map((t) => ({
+        name: t.function.name,
+        description: t.function.description ?? "",
+        input_schema: (t.function.parameters as object) ?? { type: "object", properties: {} },
+      }));
+
+      // Prompt caching: mark the stable prefix (system + tools) cacheable. ADA_CACHE_TTL=1h opts
+      // into the 1-hour cache (otherwise Anthropic's default 5-minute ephemeral cache applies).
+      const ttl1h = process.env.ADA_CACHE_TTL === "1h";
+      const cacheControl: Record<string, string> = { type: "ephemeral" };
+      if (ttl1h) cacheControl.ttl = "1h";
+      if (tools.length) (tools[tools.length - 1] as Record<string, unknown>).cache_control = cacheControl;
+      const systemParam = system ? [{ type: "text", text: system, cache_control: cacheControl }] : undefined;
+
+      const params = {
+        model,
+        max_tokens: typeof body.max_tokens === "number" ? body.max_tokens : 8192,
+        ...(systemParam ? { system: systemParam } : {}),
+        messages: messages as unknown as AnthropicSDK.MessageParam[],
+        ...(tools.length ? { tools: tools as AnthropicSDK.Tool[] } : {}),
+      } as unknown as Parameters<typeof client.messages.stream>[0];
+
+      const stream = client.messages.stream(
+        params,
+        ttl1h ? { headers: { "anthropic-beta": "extended-cache-ttl-2025-04-11" } } : undefined,
+      );
+
+      for await (const event of stream) {
+        if (event.type === "content_block_start") {
+          const cb = event.content_block as { type: string; id?: string; name?: string };
+          if (cb.type === "tool_use") {
+            toolIndex++;
+            chunk({ tool_calls: [{ index: toolIndex, id: cb.id, type: "function", function: { name: cb.name, arguments: "" } }] });
+          }
+        } else if (event.type === "content_block_delta") {
+          const d = event.delta as { type: string; text?: string; partial_json?: string };
+          if (d.type === "text_delta") chunk({ content: d.text });
+          else if (d.type === "input_json_delta") chunk({ tool_calls: [{ index: toolIndex, function: { arguments: d.partial_json } }] });
+        } else if (event.type === "message_delta") {
+          const reason = (event.delta as { stop_reason?: string | null }).stop_reason;
+          if (reason) stop = mapStop(reason);
+        }
+      }
+
+      chunk({}, stop);
+      endStream(res);
+    } catch (err) {
+      chunk({ content: `\n[backend: anthropic error: ${err instanceof Error ? err.message : String(err)}]` }, "stop");
+      endStream(res);
+    }
+  },
+
+  async listModels(): Promise<string[]> {
+    const key = providerKey("anthropic");
+    if (!key) return [];
+    try {
+      const r = await fetch("https://api.anthropic.com/v1/models?limit=1000", {
+        headers: { "x-api-key": key, "anthropic-version": "2023-06-01" },
+      });
+      if (!r.ok) return [];
+      const j = (await r.json()) as { data?: Array<{ id?: unknown }> };
+      return (j.data ?? []).map((m) => m.id).filter((x): x is string => typeof x === "string");
+    } catch {
+      return [];
+    }
+  },
+};