ada-agent 0.1.0

package/src/server/providers/openai-compat.ts

@@ -0,0 +1,76 @@
+// OpenAI-compatible adapter. Covers every provider that speaks the OpenAI Chat
+// Completions format: OpenAI, Mistral, Groq, DeepSeek, xAI, OpenRouter, Together, Ollama,
+// and Gemini (via Google's OpenAI-compatible endpoint). Because the client also speaks
+// that format, this adapter just swaps in the upstream base URL + key and streams the
+// response straight back — no translation needed.
+
+import type { ProviderName } from "../../shared/types.ts";
+import { PROVIDERS, providerKey } from "../config.ts";
+import { SSE_HEADERS } from "../sse.ts";
+import type { Adapter, ChatRequest } from "./adapter.ts";
+
+function authHeaders(provider: ProviderName): Record<string, string> {
+  const key = providerKey(provider);
+  const base: Record<string, string> = key ? { authorization: `Bearer ${key}` } : {};
+  // GitHub Copilot's endpoint requires these editor-identification headers.
+  if (provider === "copilot") return { ...base, "Copilot-Integration-Id": "vscode-chat", "Editor-Version": "ada/0.0.1", "Editor-Plugin-Version": "ada/0.0.1" };
+  return base;
+}
+
+export const openAICompatAdapter: Adapter = {
+  async chat({ provider, body, res }: ChatRequest): Promise<void> {
+    const def = PROVIDERS[provider];
+    // Copilot is addressed as "copilot/<model>" but the endpoint wants the bare model id.
+    const outBody = provider === "copilot" && typeof body.model === "string" && body.model.startsWith("copilot/") ? { ...body, model: body.model.slice("copilot/".length) } : body;
+    let upstream: Awaited<ReturnType<typeof fetch>>;
+    try {
+      upstream = await fetch(`${def.baseURL}/chat/completions`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authHeaders(provider) },
+        body: JSON.stringify(outBody),
+      });
+    } catch (e) {
+      res.writeHead(502, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: { message: `could not reach ${provider} upstream at ${def.baseURL}: ${e instanceof Error ? e.message : String(e)}` },
+        }),
+      );
+      return;
+    }
+
+    if (!upstream.ok || !upstream.body) {
+      const text = await upstream.text().catch(() => "");
+      res.writeHead(upstream.status || 502, { "content-type": "application/json" });
+      res.end(text || JSON.stringify({ error: { message: `upstream error ${upstream.status}` } }));
+      return;
+    }
+
+    if (body.stream) {
+      res.writeHead(200, SSE_HEADERS);
+      const reader = upstream.body.getReader();
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) res.write(Buffer.from(value));
+      }
+      res.end();
+    } else {
+      const text = await upstream.text();
+      res.writeHead(upstream.status, { "content-type": upstream.headers.get("content-type") ?? "application/json" });
+      res.end(text);
+    }
+  },
+
+  async listModels(provider: ProviderName): Promise<string[]> {
+    const def = PROVIDERS[provider];
+    try {
+      const r = await fetch(`${def.baseURL}/models`, { headers: authHeaders(provider) });
+      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 [];
+    }
+  },
+};

package/src/server/providers/registry.ts

@@ -0,0 +1,31 @@
+// Provider → adapter map. This table is the whole routing story at a glance:
+// who shares the OpenAI-compatible adapter, and who has a dedicated one.
+//
+// Adding support is obvious from here:
+//   - new model on an existing provider      → nothing to change
+//   - new OpenAI-compatible provider          → add it in config.ts + a line below
+//   - new provider with a divergent format    → write an adapter, map it below
+
+import type { ProviderName } from "../../shared/types.ts";
+import type { Adapter } from "./adapter.ts";
+import { anthropicAdapter } from "./anthropic.ts";
+import { openAICompatAdapter } from "./openai-compat.ts";
+
+const ADAPTERS: Record<ProviderName, Adapter> = {
+  anthropic: anthropicAdapter, // native: Anthropic Messages API
+  openai: openAICompatAdapter,
+  google: openAICompatAdapter, // via Google's OpenAI-compatible endpoint
+  mistral: openAICompatAdapter,
+  openrouter: openAICompatAdapter,
+  groq: openAICompatAdapter,
+  deepseek: openAICompatAdapter,
+  together: openAICompatAdapter,
+  xai: openAICompatAdapter,
+  dashscope: openAICompatAdapter, // Alibaba Qwen via DashScope's OpenAI-compatible endpoint
+  copilot: openAICompatAdapter, // GitHub Copilot's OpenAI-compatible endpoint (+ custom headers in the adapter)
+  ollama: openAICompatAdapter,
+};
+
+export function adapterFor(provider: ProviderName): Adapter {
+  return ADAPTERS[provider];
+}

package/src/server/router.ts

@@ -0,0 +1,29 @@
+// Map a model id (and optional explicit provider) to a provider.
+// Order matters: explicit wins; then the shape of the id (namespaced / local); then base-name prefixes.
+
+import type { ProviderName } from "../shared/types.ts";
+import { PROVIDERS } from "./config.ts";
+
+export function route(model: string, explicit?: string): ProviderName {
+  if (explicit && explicit in PROVIDERS) return explicit as ProviderName;
+
+  const m = model.toLowerCase();
+
+  // "vendor/model" → OpenRouter's namespacing convention. Checked before base-name prefixes
+  // so e.g. "mistralai/…" routes to OpenRouter, not the Mistral API.
+  // "copilot/<model>" → GitHub Copilot (checked before the OpenRouter "/" rule).
+  if (m.startsWith("copilot/")) return "copilot";
+  if (m.includes("/")) return "openrouter";
+  // "model:tag" → a local Ollama model (e.g. gemma4:latest).
+  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"; // default: one key, every model
+}

package/src/server/sse.ts

@@ -0,0 +1,20 @@
+// Server-Sent Events helpers shared by the adapters.
+
+import type { ServerResponse } from "node:http";
+
+export const SSE_HEADERS = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache",
+  connection: "keep-alive",
+} as const;
+
+/** Write one OpenAI-style `data: {...}` SSE chunk. */
+export function writeChunk(res: ServerResponse, chunk: unknown): void {
+  res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+}
+
+/** Write the terminal `data: [DONE]` line and end the response. */
+export function endStream(res: ServerResponse): void {
+  res.write("data: [DONE]\n\n");
+  res.end();
+}

package/src/shared/types.ts

@@ -0,0 +1,20 @@
+// Types shared between the ada client and backend.
+
+export type ProviderName =
+  | "openai"
+  | "anthropic"
+  | "google"
+  | "mistral"
+  | "openrouter"
+  | "groq"
+  | "deepseek"
+  | "together"
+  | "xai"
+  | "dashscope"
+  | "copilot"
+  | "ollama";
+
+export interface ModelInfo {
+  id: string;
+  provider: ProviderName;
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2023"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": ["node"]
+  },
+  "include": ["src"]
+}