@hasna/switcher 0.1.0

package/dist/serve/index.js

@@ -0,0 +1,2800 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/serve.ts
+import { parseArgs } from "util";
+import { join } from "path";
+
+// src/store.ts
+var {SQL } = globalThis.Bun;
+import { chmod, mkdir } from "fs/promises";
+import { dirname, resolve } from "path";
+
+// src/domain.ts
+import { z } from "zod";
+var VERSION = "0.1.0";
+var harnessSchema = z.enum(["claude", "codex", "grok", "opencode2"]);
+var protocolSchema = z.enum(["anthropic-messages", "openai-responses", "openai-chat"]);
+var idSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/);
+var label = z.string().min(1).max(200);
+var envRef = z.string().regex(/^SWITCHER_PROVIDER_[A-Z0-9_]+$/);
+function endpoint(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Fault(400, "invalid_url", "Use an absolute HTTPS URL (HTTP is allowed on loopback).");
+  }
+  const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && local) || url.username || url.password || url.search || url.hash)
+    throw new Fault(400, "invalid_url", "URL must use HTTPS, contain no credentials/query/fragment, or use HTTP on loopback.");
+  return url.href.replace(/\/+$/, "");
+}
+var urlSchema = z.string().max(2000).superRefine((v, ctx) => {
+  try {
+    endpoint(v);
+  } catch {
+    ctx.addIssue({ code: "custom", message: "Invalid endpoint URL" });
+  }
+}).transform(endpoint);
+var modelSchema = z.object({
+  id: z.string().min(1).max(300),
+  name: label,
+  description: z.string().max(8000).optional(),
+  contextWindow: z.number().int().positive().optional(),
+  maxOutputTokens: z.number().int().positive().optional(),
+  inputModalities: z.array(z.string().max(50)).max(20).optional(),
+  outputModalities: z.array(z.string().max(50)).max(20).optional(),
+  supportedParameters: z.array(z.string().max(100)).max(100).optional()
+}).strict();
+var providerInputSchema = z.object({
+  id: idSchema,
+  name: label,
+  baseUrl: urlSchema,
+  protocol: protocolSchema,
+  credentialEnv: envRef.optional(),
+  authStyle: z.enum(["bearer", "x-api-key"]).default("bearer"),
+  modelsPath: z.string().regex(/^[a-zA-Z0-9_/-]+$/).max(200).default("models"),
+  manualModels: z.array(modelSchema).max(1e4).default([])
+}).strict().refine((p) => !p.modelsPath.split("/").includes("..") && !p.modelsPath.startsWith("/"), "modelsPath must be relative");
+var profileInputSchema = z.object({
+  id: idSchema,
+  name: label,
+  providerId: idSchema,
+  harness: harnessSchema,
+  model: z.string().min(1).max(300)
+}).strict();
+var runInputSchema = z.object({
+  profileId: idSchema,
+  harness: harnessSchema,
+  model: z.string().min(1).max(300),
+  planToken: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var runUpdateSchema = z.object({
+  status: z.enum(["exited", "failed", "interrupted"]),
+  exitCode: z.number().int().min(0).max(255)
+}).strict();
+
+class Fault extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+}
+function parse(schema, value) {
+  const result = schema.safeParse(value);
+  if (!result.success)
+    throw new Fault(400, "invalid_request", result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; "));
+  return result.data;
+}
+function compatible(harness, protocol) {
+  return harness === "claude" ? protocol === "anthropic-messages" : harness === "codex" ? protocol === "openai-responses" : true;
+}
+function codingEligible(model) {
+  return (!model.outputModalities || model.outputModalities.includes("text")) && (!model.supportedParameters || model.supportedParameters.includes("tools"));
+}
+
+// src/store.ts
+class Store {
+  tail = Promise.resolve();
+  async exclusive(action) {
+    if (this.engine !== "sqlite")
+      return action();
+    const next = this.tail.then(action, action);
+    this.tail = next.catch(() => {});
+    return next;
+  }
+  sql;
+  engine;
+  constructor(sql, engine) {
+    this.sql = sql;
+    this.engine = engine;
+  }
+  static async open(config) {
+    if (!!config.databaseUrl === !!config.sqlitePath)
+      throw new Fault(500, "storage_config", "Choose exactly one PostgreSQL URL or SQLite path.");
+    let sql;
+    let engine;
+    if (config.databaseUrl) {
+      if (!/^postgres(ql)?:\/\//.test(config.databaseUrl))
+        throw new Fault(500, "storage_config", "Database URL must use PostgreSQL.");
+      sql = new SQL(config.databaseUrl);
+      engine = "postgresql";
+    } else {
+      const file = config.sqlitePath;
+      if (file !== ":memory:")
+        await mkdir(dirname(resolve(file)), { recursive: true, mode: 448 });
+      sql = new SQL({ adapter: "sqlite", filename: file });
+      engine = "sqlite";
+      await sql.unsafe("PRAGMA foreign_keys = ON");
+      await sql.unsafe("PRAGMA busy_timeout = 5000");
+      await sql.unsafe("PRAGMA journal_mode = WAL");
+      if (file !== ":memory:")
+        await chmod(file, 384);
+    }
+    const store = new Store(sql, engine);
+    try {
+      await store.migrate();
+    } catch {
+      await sql.close();
+      throw new Fault(500, "storage_unavailable", "Database migration failed; check server database configuration.");
+    }
+    return store;
+  }
+  async migrate() {
+    await this.sql.begin(async (tx) => {
+      if (this.engine === "postgresql")
+        await tx.unsafe("SELECT pg_advisory_xact_lock(782034215)");
+      await tx.unsafe("CREATE TABLE IF NOT EXISTS switcher_migrations (version INTEGER PRIMARY KEY)");
+      const versions = await tx.unsafe("SELECT version FROM switcher_migrations ORDER BY version");
+      if (versions.some((v) => v.version > 1))
+        throw new Error("Newer database schema");
+      if (versions.length)
+        return;
+      await tx.unsafe("CREATE TABLE switcher_providers (id TEXT PRIMARY KEY, version INTEGER NOT NULL, updated_at TEXT NOT NULL, payload TEXT NOT NULL)");
+      await tx.unsafe("CREATE TABLE switcher_profiles (id TEXT PRIMARY KEY, provider_id TEXT NOT NULL REFERENCES switcher_providers(id), version INTEGER NOT NULL, updated_at TEXT NOT NULL, payload TEXT NOT NULL)");
+      await tx.unsafe("CREATE TABLE switcher_catalogs (id TEXT PRIMARY KEY REFERENCES switcher_providers(id) ON DELETE CASCADE, version INTEGER NOT NULL, updated_at TEXT NOT NULL, payload TEXT NOT NULL)");
+      await tx.unsafe("CREATE TABLE switcher_runs (id TEXT PRIMARY KEY, profile_id TEXT NOT NULL REFERENCES switcher_profiles(id), version INTEGER NOT NULL, updated_at TEXT NOT NULL, payload TEXT NOT NULL)");
+      await tx.unsafe("CREATE TABLE switcher_idempotency (key TEXT PRIMARY KEY, fingerprint TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL)");
+      await tx.unsafe("INSERT INTO switcher_migrations(version) VALUES (1)");
+    });
+  }
+  async ready() {
+    await this.exclusive(async () => {
+      await this.sql.unsafe("SELECT 1");
+    });
+  }
+  async close() {
+    await this.tail;
+    await this.sql.close();
+  }
+  async get(kind, id, db = this.sql) {
+    if (db === this.sql && this.engine === "sqlite")
+      return this.exclusive(() => this.read(kind, id, db));
+    return this.read(kind, id, db);
+  }
+  async read(kind, id, db) {
+    const rows = await db.unsafe(`SELECT payload FROM switcher_${kind} WHERE id = $1`, [id]);
+    if (!rows.length)
+      throw new Fault(404, "not_found", `${kind} entry was not found.`);
+    return JSON.parse(rows[0].payload);
+  }
+  async list(kind, { limit = 100, offset = 0, search = "" } = {}) {
+    return this.exclusive(async () => {
+      const name = this.engine === "sqlite" ? "json_extract(payload, '$.name')" : "payload::jsonb->>'name'";
+      const pattern = `%${search.toLowerCase().replace(/[!%_]/g, (c) => "!" + c)}%`;
+      const where = `LOWER(id) LIKE $1 ESCAPE '!' OR LOWER(COALESCE(${name}, '')) LIKE $1 ESCAPE '!'`;
+      const total = await this.sql.unsafe(`SELECT COUNT(*) AS total FROM switcher_${kind} WHERE ${where}`, [pattern]);
+      const rows = await this.sql.unsafe(`SELECT payload FROM switcher_${kind} WHERE ${where} ORDER BY id LIMIT $2 OFFSET $3`, [pattern, limit, offset]);
+      return { data: rows.map((r) => JSON.parse(r.payload)), total: Number(total[0].total), limit, offset };
+    });
+  }
+  async put(kind, input, expectedVersion, db) {
+    const now = new Date().toISOString();
+    const value = { ...input, version: expectedVersion === undefined ? 1 : expectedVersion + 1, updatedAt: now };
+    if (expectedVersion === undefined) {
+      const extraColumn = kind === "profiles" ? ", provider_id" : kind === "runs" ? ", profile_id" : "";
+      const extraValue = kind === "profiles" ? input.providerId : kind === "runs" ? input.profileId : undefined;
+      await db.unsafe(`INSERT INTO switcher_${kind} (id, version, updated_at, payload${extraColumn}) VALUES ($1, $2, $3, $4${extraColumn ? ", $5" : ""})`, [input.id, value.version, now, JSON.stringify(value), ...extraColumn ? [extraValue] : []]);
+    } else {
+      const extra = kind === "profiles" ? ", provider_id = $4" : "";
+      const rows = await db.unsafe(`UPDATE switcher_${kind} SET version = $1, updated_at = $2, payload = $3${extra} WHERE id = $${extra ? 5 : 4} AND version = $${extra ? 6 : 5} RETURNING id`, [value.version, now, JSON.stringify(value), ...extra ? [input.providerId] : [], input.id, expectedVersion]);
+      if (!rows.length)
+        throw new Fault(409, "version_conflict", "Entry changed or is missing; reload before retrying.");
+    }
+    return value;
+  }
+  async remove(kind, id, version, db) {
+    const rows = await db.unsafe(`DELETE FROM switcher_${kind} WHERE id = $1 AND version = $2 RETURNING id`, [id, version]);
+    if (!rows.length)
+      throw new Fault(409, "version_conflict", "Entry changed or is missing; reload before retrying.");
+    return { deleted: id };
+  }
+  async mutate(key, fingerprint, action) {
+    return this.exclusive(() => this.transaction(key, fingerprint, action));
+  }
+  async replay(key, fingerprint) {
+    return this.exclusive(async () => {
+      const rows = await this.sql.unsafe("SELECT fingerprint, payload FROM switcher_idempotency WHERE key = $1", [key]);
+      if (!rows.length)
+        return { found: false };
+      if (rows[0].fingerprint !== fingerprint)
+        throw new Fault(409, "idempotency_conflict", "Idempotency key was already used for a different request.");
+      return { found: true, value: JSON.parse(rows[0].payload) };
+    });
+  }
+  async transaction(key, fingerprint, action) {
+    try {
+      return await this.sql.begin(async (tx) => {
+        const inserted = await tx.unsafe("INSERT INTO switcher_idempotency (key, fingerprint, payload, created_at) VALUES ($1, $2, '', $3) ON CONFLICT (key) DO NOTHING RETURNING key", [key, fingerprint, new Date().toISOString()]);
+        if (!inserted.length) {
+          const rows = await tx.unsafe("SELECT fingerprint, payload FROM switcher_idempotency WHERE key = $1", [key]);
+          if (rows[0].fingerprint !== fingerprint)
+            throw new Fault(409, "idempotency_conflict", "Idempotency key was already used for a different request.");
+          return JSON.parse(rows[0].payload);
+        }
+        const value = await action(tx);
+        await tx.unsafe("UPDATE switcher_idempotency SET payload = $1 WHERE key = $2", [JSON.stringify(value), key]);
+        return value;
+      });
+    } catch (error) {
+      if (error instanceof Fault)
+        throw error;
+      const code = String(this.engine === "postgresql" ? error?.errno : error?.code);
+      if (["23505", "23503", "SQLITE_CONSTRAINT", "SQLITE_CONSTRAINT_PRIMARYKEY", "SQLITE_CONSTRAINT_FOREIGNKEY"].includes(code))
+        throw new Fault(409, "conflict", "Duplicate entry or an entry still referenced by another resource.");
+      throw new Fault(503, "storage_unavailable", "Storage operation failed.");
+    }
+  }
+}
+
+// src/service.ts
+import { createHash, timingSafeEqual } from "crypto";
+import { z as z2 } from "zod";
+
+// src/http.ts
+var MAX_BYTES = 16 * 1024 * 1024;
+async function boundedJson(response, maxBytes = MAX_BYTES) {
+  if (!response.body)
+    throw new Fault(502, "invalid_upstream", "Upstream returned no body.");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const item = await reader.read();
+      if (item.done)
+        break;
+      size += item.value.byteLength;
+      if (size > maxBytes)
+        throw new Fault(502, "response_too_large", "Response exceeds the size limit.");
+      chunks.push(item.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    try {
+      return JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      throw new Fault(502, "invalid_upstream", "Upstream returned invalid JSON.");
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+}
+
+// src/catalog.ts
+var positive = (v) => typeof v === "number" && Number.isInteger(v) && v > 0 ? v : undefined;
+var strings = (v) => Array.isArray(v) && v.every((i) => typeof i === "string") ? v : undefined;
+async function discover(provider, env = process.env) {
+  const refreshedAt = new Date().toISOString();
+  if (provider.manualModels.length)
+    return { models: provider.manualModels, source: "manual", refreshedAt };
+  const headers = { accept: "application/json" };
+  if (provider.credentialEnv) {
+    const credential = env[provider.credentialEnv];
+    if (!credential)
+      throw new Fault(422, "credential_missing", "Provider credential environment variable is not available on the server.");
+    headers[provider.authStyle === "x-api-key" ? "x-api-key" : "authorization"] = provider.authStyle === "x-api-key" ? credential : `Bearer ${credential}`;
+  }
+  const url = new URL(`${provider.baseUrl}/${provider.modelsPath}`);
+  if (provider.protocol === "anthropic-messages" && url.hostname !== "openrouter.ai")
+    headers["anthropic-version"] = "2023-06-01";
+  if (url.hostname === "openrouter.ai")
+    url.searchParams.set("output_modalities", "all");
+  const models = new Map;
+  const seenCursors = new Set;
+  for (let page = 0;page < 100; page++) {
+    let response;
+    try {
+      response = await fetch(url, { headers, redirect: "manual", signal: AbortSignal.timeout(20000) });
+    } catch {
+      throw new Fault(502, "provider_unavailable", "Provider catalog request failed.");
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new Fault(502, "provider_rejected", `Provider catalog returned HTTP ${response.status}.`);
+    }
+    const data = await boundedJson(response);
+    if (!Array.isArray(data.data))
+      throw new Fault(502, "invalid_catalog", "Expected a provider catalog with a data array.");
+    for (const row of data.data) {
+      if (!row || typeof row.id !== "string")
+        throw new Fault(502, "invalid_catalog", "Catalog entry is missing a model ID.");
+      const candidate = {
+        id: row.id,
+        name: row.name ?? row.display_name ?? row.id,
+        description: typeof row.description === "string" ? row.description.slice(0, 8000) : undefined,
+        contextWindow: positive(row.context_length ?? row.context_window),
+        maxOutputTokens: positive(row.top_provider?.max_completion_tokens ?? row.max_output_tokens),
+        inputModalities: strings(row.architecture?.input_modalities ?? row.input_modalities),
+        outputModalities: strings(row.architecture?.output_modalities ?? row.output_modalities),
+        supportedParameters: strings(row.supported_parameters)
+      };
+      const parsed = modelSchema.safeParse(candidate);
+      if (!parsed.success)
+        throw new Fault(502, "invalid_catalog", "Provider returned malformed model metadata.");
+      models.set(candidate.id, parsed.data);
+      if (models.size > 1e4)
+        throw new Fault(502, "catalog_too_large", "Catalog exceeds 10,000 models; configure a narrower endpoint.");
+    }
+    if (!data.has_more)
+      return { models: [...models.values()], source: "remote", refreshedAt };
+    const cursor = data.last_id;
+    if (typeof cursor !== "string" || seenCursors.has(cursor))
+      throw new Fault(502, "invalid_catalog", "Provider catalog pagination did not advance.");
+    seenCursors.add(cursor);
+    url.searchParams.set("after_id", cursor);
+    url.searchParams.set("limit", "1000");
+  }
+  throw new Fault(502, "catalog_too_large", "Provider catalog pagination exceeded 100 pages.");
+}
+// openapi.json
+var openapi_default = {
+  openapi: "3.0.3",
+  info: {
+    title: "Switcher API",
+    version: "0.1.0",
+    description: "Authenticated provider/profile/catalog control plane. Launches run locally; the API never returns provider credentials."
+  },
+  security: [
+    {
+      bearerAuth: []
+    }
+  ],
+  paths: {
+    "/v1/providers": {
+      get: {
+        operationId: "listProviders",
+        parameters: [
+          {
+            name: "limit",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 1,
+              maximum: 1000,
+              default: 100
+            }
+          },
+          {
+            name: "offset",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 0,
+              default: 0
+            }
+          },
+          {
+            name: "search",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "data",
+                    "total",
+                    "limit",
+                    "offset"
+                  ],
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/Provider"
+                      }
+                    },
+                    total: {
+                      type: "integer"
+                    },
+                    limit: {
+                      type: "integer"
+                    },
+                    offset: {
+                      type: "integer"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "createProvider",
+        parameters: [
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/ProviderInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "201": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Provider"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/providers/{id}": {
+      get: {
+        operationId: "getProvider",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Provider"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      },
+      put: {
+        operationId: "updateProvider",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          },
+          {
+            name: "If-Match",
+            in: "header",
+            required: true,
+            schema: {
+              type: "integer",
+              minimum: 1
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/ProviderInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Provider"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      },
+      delete: {
+        operationId: "deleteProvider",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          },
+          {
+            name: "If-Match",
+            in: "header",
+            required: true,
+            schema: {
+              type: "integer",
+              minimum: 1
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    deleted: {
+                      type: "string"
+                    }
+                  },
+                  required: [
+                    "deleted"
+                  ]
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/profiles": {
+      get: {
+        operationId: "listProfiles",
+        parameters: [
+          {
+            name: "limit",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 1,
+              maximum: 1000,
+              default: 100
+            }
+          },
+          {
+            name: "offset",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 0,
+              default: 0
+            }
+          },
+          {
+            name: "search",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "data",
+                    "total",
+                    "limit",
+                    "offset"
+                  ],
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/Profile"
+                      }
+                    },
+                    total: {
+                      type: "integer"
+                    },
+                    limit: {
+                      type: "integer"
+                    },
+                    offset: {
+                      type: "integer"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "createProfile",
+        parameters: [
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/ProfileInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "201": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Profile"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/profiles/{id}": {
+      get: {
+        operationId: "getProfile",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Profile"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      },
+      put: {
+        operationId: "updateProfile",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          },
+          {
+            name: "If-Match",
+            in: "header",
+            required: true,
+            schema: {
+              type: "integer",
+              minimum: 1
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/ProfileInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Profile"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      },
+      delete: {
+        operationId: "deleteProfile",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          },
+          {
+            name: "If-Match",
+            in: "header",
+            required: true,
+            schema: {
+              type: "integer",
+              minimum: 1
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    deleted: {
+                      type: "string"
+                    }
+                  },
+                  required: [
+                    "deleted"
+                  ]
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/providers/{id}/models": {
+      get: {
+        operationId: "listModels",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "limit",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 1,
+              maximum: 1000,
+              default: 100
+            }
+          },
+          {
+            name: "offset",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 0,
+              default: 0
+            }
+          },
+          {
+            name: "search",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/ModelPage"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/providers/{id}/refresh": {
+      post: {
+        operationId: "refreshModels",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/Empty"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Catalog"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/launch-plans": {
+      post: {
+        operationId: "launchPlan",
+        parameters: [
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/LaunchInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/LaunchPlan"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/runs": {
+      get: {
+        operationId: "listRuns",
+        parameters: [
+          {
+            name: "limit",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 1,
+              maximum: 1000,
+              default: 100
+            }
+          },
+          {
+            name: "offset",
+            in: "query",
+            schema: {
+              type: "integer",
+              minimum: 0,
+              default: 0
+            }
+          },
+          {
+            name: "search",
+            in: "query",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: [
+                    "data",
+                    "total",
+                    "limit",
+                    "offset"
+                  ],
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: {
+                        $ref: "#/components/schemas/Run"
+                      }
+                    },
+                    total: {
+                      type: "integer"
+                    },
+                    limit: {
+                      type: "integer"
+                    },
+                    offset: {
+                      type: "integer"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        operationId: "createRun",
+        parameters: [
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/RunInput"
+              }
+            }
+          }
+        },
+        responses: {
+          "201": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Run"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/runs/{id}": {
+      get: {
+        operationId: "getRun",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Run"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      },
+      patch: {
+        operationId: "finishRun",
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: {
+              type: "string"
+            }
+          },
+          {
+            name: "Idempotency-Key",
+            in: "header",
+            required: true,
+            schema: {
+              type: "string",
+              minLength: 8,
+              maxLength: 128
+            }
+          },
+          {
+            name: "If-Match",
+            in: "header",
+            required: true,
+            schema: {
+              type: "integer",
+              minimum: 1
+            }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/RunUpdate"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Run"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/health": {
+      get: {
+        operationId: "health",
+        parameters: [],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Health"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        },
+        security: []
+      }
+    },
+    "/ready": {
+      get: {
+        operationId: "ready",
+        parameters: [],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Ready"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        },
+        security: []
+      }
+    },
+    "/version": {
+      get: {
+        operationId: "version",
+        parameters: [],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Version"
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        },
+        security: []
+      }
+    },
+    "/v1/openapi.json": {
+      get: {
+        operationId: "openApi",
+        parameters: [],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  additionalProperties: true
+                }
+              }
+            }
+          },
+          default: {
+            description: "Structured error",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/Error"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  components: {
+    securitySchemes: {
+      bearerAuth: {
+        type: "http",
+        scheme: "bearer"
+      }
+    },
+    schemas: {
+      ProviderInput: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          name: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200
+          },
+          baseUrl: {
+            type: "string",
+            maxLength: 2000
+          },
+          protocol: {
+            type: "string",
+            enum: [
+              "anthropic-messages",
+              "openai-responses",
+              "openai-chat"
+            ]
+          },
+          credentialEnv: {
+            type: "string",
+            pattern: "^SWITCHER_PROVIDER_[A-Z0-9_]+$"
+          },
+          authStyle: {
+            type: "string",
+            enum: [
+              "bearer",
+              "x-api-key"
+            ],
+            default: "bearer"
+          },
+          modelsPath: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9_/-]+$",
+            maxLength: 200,
+            default: "models"
+          },
+          manualModels: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300
+                },
+                name: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 200
+                },
+                description: {
+                  type: "string",
+                  maxLength: 8000
+                },
+                contextWindow: {
+                  type: "integer",
+                  exclusiveMinimum: true,
+                  minimum: 0
+                },
+                maxOutputTokens: {
+                  type: "integer",
+                  exclusiveMinimum: true,
+                  minimum: 0
+                },
+                inputModalities: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 50
+                  },
+                  maxItems: 20
+                },
+                outputModalities: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 50
+                  },
+                  maxItems: 20
+                },
+                supportedParameters: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 100
+                  },
+                  maxItems: 100
+                }
+              },
+              required: [
+                "id",
+                "name"
+              ],
+              additionalProperties: false
+            },
+            maxItems: 1e4,
+            default: []
+          }
+        },
+        required: [
+          "id",
+          "name",
+          "baseUrl",
+          "protocol"
+        ],
+        additionalProperties: false
+      },
+      Provider: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          name: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200
+          },
+          baseUrl: {
+            type: "string",
+            maxLength: 2000
+          },
+          protocol: {
+            type: "string",
+            enum: [
+              "anthropic-messages",
+              "openai-responses",
+              "openai-chat"
+            ]
+          },
+          credentialEnv: {
+            type: "string",
+            pattern: "^SWITCHER_PROVIDER_[A-Z0-9_]+$"
+          },
+          authStyle: {
+            type: "string",
+            enum: [
+              "bearer",
+              "x-api-key"
+            ],
+            default: "bearer"
+          },
+          modelsPath: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9_/-]+$",
+            maxLength: 200,
+            default: "models"
+          },
+          manualModels: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300
+                },
+                name: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 200
+                },
+                description: {
+                  type: "string",
+                  maxLength: 8000
+                },
+                contextWindow: {
+                  type: "integer",
+                  exclusiveMinimum: true,
+                  minimum: 0
+                },
+                maxOutputTokens: {
+                  type: "integer",
+                  exclusiveMinimum: true,
+                  minimum: 0
+                },
+                inputModalities: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 50
+                  },
+                  maxItems: 20
+                },
+                outputModalities: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 50
+                  },
+                  maxItems: 20
+                },
+                supportedParameters: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 100
+                  },
+                  maxItems: 100
+                }
+              },
+              required: [
+                "id",
+                "name"
+              ],
+              additionalProperties: false
+            },
+            maxItems: 1e4,
+            default: []
+          },
+          version: {
+            type: "integer",
+            exclusiveMinimum: true,
+            minimum: 0
+          },
+          updatedAt: {
+            type: "string"
+          }
+        },
+        required: [
+          "id",
+          "name",
+          "baseUrl",
+          "protocol",
+          "version",
+          "updatedAt"
+        ],
+        additionalProperties: false
+      },
+      ProfileInput: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          name: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200
+          },
+          providerId: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          harness: {
+            type: "string",
+            enum: [
+              "claude",
+              "codex",
+              "grok",
+              "opencode2"
+            ]
+          },
+          model: {
+            type: "string",
+            minLength: 1,
+            maxLength: 300
+          }
+        },
+        required: [
+          "id",
+          "name",
+          "providerId",
+          "harness",
+          "model"
+        ],
+        additionalProperties: false
+      },
+      Profile: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          name: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200
+          },
+          providerId: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          harness: {
+            type: "string",
+            enum: [
+              "claude",
+              "codex",
+              "grok",
+              "opencode2"
+            ]
+          },
+          model: {
+            type: "string",
+            minLength: 1,
+            maxLength: 300
+          },
+          version: {
+            type: "integer",
+            exclusiveMinimum: true,
+            minimum: 0
+          },
+          updatedAt: {
+            type: "string"
+          }
+        },
+        required: [
+          "id",
+          "name",
+          "providerId",
+          "harness",
+          "model",
+          "version",
+          "updatedAt"
+        ],
+        additionalProperties: false
+      },
+      Model: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            minLength: 1,
+            maxLength: 300
+          },
+          name: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200
+          },
+          description: {
+            type: "string",
+            maxLength: 8000
+          },
+          contextWindow: {
+            type: "integer",
+            exclusiveMinimum: true,
+            minimum: 0
+          },
+          maxOutputTokens: {
+            type: "integer",
+            exclusiveMinimum: true,
+            minimum: 0
+          },
+          inputModalities: {
+            type: "array",
+            items: {
+              type: "string",
+              maxLength: 50
+            },
+            maxItems: 20
+          },
+          outputModalities: {
+            type: "array",
+            items: {
+              type: "string",
+              maxLength: 50
+            },
+            maxItems: 20
+          },
+          supportedParameters: {
+            type: "array",
+            items: {
+              type: "string",
+              maxLength: 100
+            },
+            maxItems: 100
+          }
+        },
+        required: [
+          "id",
+          "name"
+        ],
+        additionalProperties: false
+      },
+      ModelPage: {
+        type: "object",
+        properties: {
+          data: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300
+                },
+                name: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 200
+                },
+                description: {
+                  type: "string",
+                  maxLength: 8000
+                },
+                contextWindow: {
+                  type: "integer",
+                  exclusiveMinimum: true,
+                  minimum: 0
+                },
+                maxOutputTokens: {
+                  type: "integer",
+                  exclusiveMinimum: true,
+                  minimum: 0
+                },
+                inputModalities: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 50
+                  },
+                  maxItems: 20
+                },
+                outputModalities: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 50
+                  },
+                  maxItems: 20
+                },
+                supportedParameters: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 100
+                  },
+                  maxItems: 100
+                },
+                codingEligible: {
+                  type: "boolean"
+                }
+              },
+              required: [
+                "id",
+                "name",
+                "codingEligible"
+              ],
+              additionalProperties: false
+            }
+          },
+          total: {
+            type: "integer"
+          },
+          limit: {
+            type: "integer"
+          },
+          offset: {
+            type: "integer"
+          },
+          refreshedAt: {
+            type: "string"
+          },
+          source: {
+            type: "string",
+            enum: [
+              "remote",
+              "manual"
+            ]
+          }
+        },
+        required: [
+          "data",
+          "total",
+          "limit",
+          "offset",
+          "refreshedAt",
+          "source"
+        ],
+        additionalProperties: false
+      },
+      Catalog: {
+        type: "object",
+        properties: {
+          models: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300
+                },
+                name: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 200
+                },
+                description: {
+                  type: "string",
+                  maxLength: 8000
+                },
+                contextWindow: {
+                  type: "integer",
+                  exclusiveMinimum: true,
+                  minimum: 0
+                },
+                maxOutputTokens: {
+                  type: "integer",
+                  exclusiveMinimum: true,
+                  minimum: 0
+                },
+                inputModalities: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 50
+                  },
+                  maxItems: 20
+                },
+                outputModalities: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 50
+                  },
+                  maxItems: 20
+                },
+                supportedParameters: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    maxLength: 100
+                  },
+                  maxItems: 100
+                }
+              },
+              required: [
+                "id",
+                "name"
+              ],
+              additionalProperties: false
+            }
+          },
+          refreshedAt: {
+            type: "string"
+          },
+          source: {
+            type: "string",
+            enum: [
+              "remote",
+              "manual"
+            ]
+          }
+        },
+        required: [
+          "models",
+          "refreshedAt",
+          "source"
+        ],
+        additionalProperties: false
+      },
+      LaunchPlan: {
+        type: "object",
+        properties: {
+          provider: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string",
+                pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+              },
+              name: {
+                type: "string",
+                minLength: 1,
+                maxLength: 200
+              },
+              baseUrl: {
+                type: "string",
+                maxLength: 2000
+              },
+              protocol: {
+                type: "string",
+                enum: [
+                  "anthropic-messages",
+                  "openai-responses",
+                  "openai-chat"
+                ]
+              },
+              credentialEnv: {
+                type: "string",
+                pattern: "^SWITCHER_PROVIDER_[A-Z0-9_]+$"
+              },
+              authStyle: {
+                type: "string",
+                enum: [
+                  "bearer",
+                  "x-api-key"
+                ],
+                default: "bearer"
+              },
+              modelsPath: {
+                type: "string",
+                pattern: "^[a-zA-Z0-9_/-]+$",
+                maxLength: 200,
+                default: "models"
+              },
+              manualModels: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 300
+                    },
+                    name: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 200
+                    },
+                    description: {
+                      type: "string",
+                      maxLength: 8000
+                    },
+                    contextWindow: {
+                      type: "integer",
+                      exclusiveMinimum: true,
+                      minimum: 0
+                    },
+                    maxOutputTokens: {
+                      type: "integer",
+                      exclusiveMinimum: true,
+                      minimum: 0
+                    },
+                    inputModalities: {
+                      type: "array",
+                      items: {
+                        type: "string",
+                        maxLength: 50
+                      },
+                      maxItems: 20
+                    },
+                    outputModalities: {
+                      type: "array",
+                      items: {
+                        type: "string",
+                        maxLength: 50
+                      },
+                      maxItems: 20
+                    },
+                    supportedParameters: {
+                      type: "array",
+                      items: {
+                        type: "string",
+                        maxLength: 100
+                      },
+                      maxItems: 100
+                    }
+                  },
+                  required: [
+                    "id",
+                    "name"
+                  ],
+                  additionalProperties: false
+                },
+                maxItems: 1e4,
+                default: []
+              },
+              version: {
+                type: "integer",
+                exclusiveMinimum: true,
+                minimum: 0
+              },
+              updatedAt: {
+                type: "string"
+              }
+            },
+            required: [
+              "id",
+              "name",
+              "baseUrl",
+              "protocol",
+              "version",
+              "updatedAt"
+            ],
+            additionalProperties: false
+          },
+          profile: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string",
+                pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+              },
+              name: {
+                type: "string",
+                minLength: 1,
+                maxLength: 200
+              },
+              providerId: {
+                type: "string",
+                pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+              },
+              harness: {
+                type: "string",
+                enum: [
+                  "claude",
+                  "codex",
+                  "grok",
+                  "opencode2"
+                ]
+              },
+              model: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300
+              },
+              version: {
+                type: "integer",
+                exclusiveMinimum: true,
+                minimum: 0
+              },
+              updatedAt: {
+                type: "string"
+              }
+            },
+            required: [
+              "id",
+              "name",
+              "providerId",
+              "harness",
+              "model",
+              "version",
+              "updatedAt"
+            ],
+            additionalProperties: false
+          },
+          catalog: {
+            type: "object",
+            properties: {
+              models: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 300
+                    },
+                    name: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 200
+                    },
+                    description: {
+                      type: "string",
+                      maxLength: 8000
+                    },
+                    contextWindow: {
+                      type: "integer",
+                      exclusiveMinimum: true,
+                      minimum: 0
+                    },
+                    maxOutputTokens: {
+                      type: "integer",
+                      exclusiveMinimum: true,
+                      minimum: 0
+                    },
+                    inputModalities: {
+                      type: "array",
+                      items: {
+                        type: "string",
+                        maxLength: 50
+                      },
+                      maxItems: 20
+                    },
+                    outputModalities: {
+                      type: "array",
+                      items: {
+                        type: "string",
+                        maxLength: 50
+                      },
+                      maxItems: 20
+                    },
+                    supportedParameters: {
+                      type: "array",
+                      items: {
+                        type: "string",
+                        maxLength: 100
+                      },
+                      maxItems: 100
+                    }
+                  },
+                  required: [
+                    "id",
+                    "name"
+                  ],
+                  additionalProperties: false
+                }
+              },
+              refreshedAt: {
+                type: "string"
+              },
+              source: {
+                type: "string",
+                enum: [
+                  "remote",
+                  "manual"
+                ]
+              }
+            },
+            required: [
+              "models",
+              "refreshedAt",
+              "source"
+            ],
+            additionalProperties: false
+          },
+          planToken: {
+            type: "string"
+          },
+          warnings: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        required: [
+          "provider",
+          "profile",
+          "catalog",
+          "planToken",
+          "warnings"
+        ],
+        additionalProperties: false
+      },
+      RunInput: {
+        type: "object",
+        properties: {
+          profileId: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          harness: {
+            type: "string",
+            enum: [
+              "claude",
+              "codex",
+              "grok",
+              "opencode2"
+            ]
+          },
+          model: {
+            type: "string",
+            minLength: 1,
+            maxLength: 300
+          },
+          planToken: {
+            type: "string",
+            pattern: "^[a-f0-9]{64}$"
+          }
+        },
+        required: [
+          "profileId",
+          "harness",
+          "model",
+          "planToken"
+        ],
+        additionalProperties: false
+      },
+      RunUpdate: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            enum: [
+              "exited",
+              "failed",
+              "interrupted"
+            ]
+          },
+          exitCode: {
+            type: "integer",
+            minimum: 0,
+            maximum: 255
+          }
+        },
+        required: [
+          "status",
+          "exitCode"
+        ],
+        additionalProperties: false
+      },
+      Run: {
+        type: "object",
+        properties: {
+          profileId: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          harness: {
+            type: "string",
+            enum: [
+              "claude",
+              "codex",
+              "grok",
+              "opencode2"
+            ]
+          },
+          model: {
+            type: "string",
+            minLength: 1,
+            maxLength: 300
+          },
+          planToken: {
+            type: "string",
+            pattern: "^[a-f0-9]{64}$"
+          },
+          version: {
+            type: "integer",
+            exclusiveMinimum: true,
+            minimum: 0
+          },
+          updatedAt: {
+            type: "string"
+          },
+          providerId: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          providerVersion: {
+            type: "integer",
+            exclusiveMinimum: true,
+            minimum: 0
+          },
+          profileVersion: {
+            type: "integer",
+            exclusiveMinimum: true,
+            minimum: 0
+          },
+          id: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          },
+          status: {
+            type: "string",
+            enum: [
+              "running",
+              "exited",
+              "failed",
+              "interrupted"
+            ]
+          },
+          startedAt: {
+            type: "string"
+          },
+          endedAt: {
+            type: "string"
+          },
+          exitCode: {
+            type: "integer"
+          }
+        },
+        required: [
+          "profileId",
+          "harness",
+          "model",
+          "planToken",
+          "version",
+          "updatedAt",
+          "providerId",
+          "providerVersion",
+          "profileVersion",
+          "id",
+          "status",
+          "startedAt"
+        ],
+        additionalProperties: false
+      },
+      Health: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            enum: [
+              "ok",
+              "degraded",
+              "unavailable"
+            ]
+          },
+          version: {
+            type: "string"
+          },
+          backend: {
+            type: "string",
+            enum: [
+              "sqlite",
+              "postgresql"
+            ]
+          }
+        },
+        required: [
+          "status",
+          "version",
+          "backend"
+        ],
+        additionalProperties: false
+      },
+      Ready: {
+        type: "object",
+        properties: {
+          ready: {
+            type: "boolean"
+          },
+          reason: {
+            type: "string"
+          }
+        },
+        required: [
+          "ready"
+        ],
+        additionalProperties: false
+      },
+      Version: {
+        type: "object",
+        properties: {
+          version: {
+            type: "string"
+          }
+        },
+        required: [
+          "version"
+        ],
+        additionalProperties: false
+      },
+      LaunchInput: {
+        type: "object",
+        properties: {
+          profileId: {
+            type: "string",
+            pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
+          }
+        },
+        required: [
+          "profileId"
+        ],
+        additionalProperties: false
+      },
+      Empty: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      Error: {
+        type: "object",
+        properties: {
+          error: {
+            type: "object",
+            properties: {
+              code: {
+                type: "string"
+              },
+              message: {
+                type: "string"
+              },
+              requestId: {
+                type: "string"
+              }
+            },
+            required: [
+              "code",
+              "message",
+              "requestId"
+            ],
+            additionalProperties: false
+          }
+        },
+        required: [
+          "error"
+        ],
+        additionalProperties: false
+      }
+    }
+  }
+};
+
+// src/service.ts
+var snapshot = (profile, provider, catalog) => createHash("sha256").update(JSON.stringify([profile, provider, { models: catalog.models, source: catalog.source }])).digest("hex");
+var hash = (s) => createHash("sha256").update(s).digest();
+function createHandler(store, apiKey, providerEnv = process.env) {
+  if (!apiKey || apiKey.length < 24)
+    throw new Fault(500, "auth_config", "Set HASNA_SWITCHER_API_KEY to a random token of at least 24 characters.");
+  const expected = hash(`Bearer ${apiKey}`);
+  return async (request) => {
+    const requestId = crypto.randomUUID();
+    const json = (body, status = 200) => Response.json(body, { status, headers: { "x-request-id": requestId, "cache-control": "no-store", "x-content-type-options": "nosniff" } });
+    try {
+      const url = new URL(request.url);
+      const route = url.pathname.replace(/\/$/, "");
+      if (request.method === "GET" && route === "/health")
+        return json({ status: "ok", version: VERSION, backend: store.engine });
+      if (request.method === "GET" && route === "/version")
+        return json({ version: VERSION });
+      if (request.method === "GET" && route === "/ready") {
+        try {
+          await store.ready();
+          return json({ ready: true });
+        } catch {
+          return json({ ready: false, reason: "Storage is unavailable." }, 503);
+        }
+      }
+      if (!timingSafeEqual(expected, hash(request.headers.get("authorization") ?? "")))
+        throw new Fault(401, "unauthorized", "A valid API bearer token is required.");
+      if (request.method === "GET" && ["/v1/openapi.json", "/openapi.json"].includes(route))
+        return json(openapi_default);
+      const parts = route.split("/").filter(Boolean);
+      if (parts[0] !== "v1")
+        throw new Fault(404, "not_found", "Route was not found.");
+      const resource = parts[1];
+      const id = parts[2];
+      if (id)
+        parse(idSchema, id);
+      const page = () => parse(z2.object({
+        limit: z2.coerce.number().int().min(1).max(1000).default(100),
+        offset: z2.coerce.number().int().min(0).max(1e6).default(0),
+        search: z2.string().max(200).default("")
+      }).strict(), Object.fromEntries(url.searchParams));
+      if (request.method === "GET") {
+        if (["providers", "profiles", "runs"].includes(resource) && parts.length <= 3) {
+          const kind = resource;
+          return json(id ? await store.get(kind, id) : await store.list(kind, page()));
+        }
+        if (resource === "providers" && id && parts[3] === "models" && parts.length === 4) {
+          const catalog = await store.get("catalogs", id);
+          const p = page();
+          const filtered = catalog.models.filter((m) => [m.id, m.name].some((s) => s.toLowerCase().includes(p.search.toLowerCase())));
+          return json({ ...catalog, models: undefined, data: filtered.slice(p.offset, p.offset + p.limit).map((m) => ({ ...m, codingEligible: codingEligible(m) })), total: filtered.length, ...p });
+        }
+        throw new Fault(404, "not_found", "Route was not found.");
+      }
+      if (!["POST", "PUT", "PATCH", "DELETE"].includes(request.method))
+        throw new Fault(405, "method_not_allowed", "Method is not supported.");
+      const key = request.headers.get("idempotency-key");
+      if (!key || !/^[a-zA-Z0-9._:-]{8,128}$/.test(key))
+        throw new Fault(400, "idempotency_required", "Supply an Idempotency-Key of 8\u2013128 ASCII letters, digits, dots, colons, underscores or dashes.");
+      let body = {};
+      if (request.method !== "DELETE") {
+        if (!request.headers.get("content-type")?.startsWith("application/json"))
+          throw new Fault(415, "content_type", "Send application/json.");
+        try {
+          body = await boundedJson(request, 1024 * 1024);
+        } catch {
+          throw new Fault(400, "invalid_json", "Request must contain valid JSON under 1 MiB.");
+        }
+      }
+      const fingerprint = hash(JSON.stringify([request.method, route, body, request.headers.get("if-match")])).toString("hex");
+      const version = () => {
+        const v = request.headers.get("if-match");
+        if (!v || !/^[1-9]\d*$/.test(v))
+          throw new Fault(428, "version_required", "Supply the current numeric version in If-Match.");
+        return Number(v);
+      };
+      const replay = await store.replay(key, fingerprint);
+      if (replay.found)
+        return json(replay.value, request.method === "POST" && ["providers", "profiles", "runs"].includes(resource) && !id ? 201 : 200);
+      let refreshed;
+      if (resource === "providers" && id && parts[3] === "refresh" && parts.length === 4 && request.method === "POST") {
+        parse(z2.object({}).strict(), body);
+        const provider = await store.get("providers", id);
+        refreshed = { provider, catalog: await discover(provider, providerEnv) };
+      }
+      const result = await store.mutate(key, fingerprint, async (db) => {
+        if ((resource === "providers" || resource === "profiles") && parts.length <= 3) {
+          if (request.method === "DELETE" && id)
+            return store.remove(resource, id, version(), db);
+          if (request.method === "POST" && !id || request.method === "PUT" && id) {
+            const value = resource === "providers" ? parse(providerInputSchema, body) : parse(profileInputSchema, body);
+            if (id && value.id !== id)
+              throw new Fault(400, "id_mismatch", "Path and body IDs must match.");
+            if (resource === "profiles") {
+              const profile = value;
+              const provider = await store.get("providers", profile.providerId, db);
+              if (!compatible(profile.harness, provider.protocol))
+                throw new Fault(422, "protocol_mismatch", "Harness does not support this provider protocol.");
+            }
+            const saved = await store.put(resource, value, id ? version() : undefined, db);
+            if (resource === "providers" && id)
+              await db.unsafe("DELETE FROM switcher_catalogs WHERE id = $1", [id]);
+            return saved;
+          }
+        }
+        if (resource === "providers" && id && parts[3] === "refresh" && parts.length === 4 && request.method === "POST") {
+          if (store.engine === "postgresql")
+            await db.unsafe("SELECT id FROM switcher_providers WHERE id = $1 FOR SHARE", [id]);
+          const provider = await store.get("providers", id, db);
+          if (!refreshed || provider.version !== refreshed.provider.version)
+            throw new Fault(409, "provider_changed", "Provider changed during discovery; refresh again.");
+          const catalog = refreshed.catalog;
+          let old;
+          try {
+            old = await store.get("catalogs", id, db);
+          } catch (e) {
+            if (!(e instanceof Fault && e.status === 404))
+              throw e;
+          }
+          return store.put("catalogs", { id, ...catalog }, old?.version, db);
+        }
+        if (resource === "launch-plans" && !id && request.method === "POST") {
+          const { profileId } = parse(z2.object({ profileId: idSchema }).strict(), body);
+          const profile = await store.get("profiles", profileId, db);
+          const provider = await store.get("providers", profile.providerId, db);
+          if (!compatible(profile.harness, provider.protocol))
+            throw new Fault(422, "protocol_mismatch", "Harness does not support this provider protocol.");
+          let catalog;
+          try {
+            catalog = await store.get("catalogs", provider.id, db);
+          } catch (e) {
+            if (e instanceof Fault && e.status === 404)
+              throw new Fault(422, "catalog_missing", "Refresh the provider catalog before launching.");
+            throw e;
+          }
+          const selected = catalog.models.find((m) => m.id === profile.model);
+          if (!selected)
+            throw new Fault(422, "model_missing", "Selected model is not in the provider catalog.");
+          if (!codingEligible(selected))
+            throw new Fault(422, "model_ineligible", "Selected model explicitly lacks text output or tool support.");
+          const warnings = [];
+          if (!selected.supportedParameters)
+            warnings.push("Provider does not declare tool capabilities; execution compatibility is unverified.");
+          if (profile.harness === "claude" && !/claude/i.test(profile.model))
+            warnings.push("Anthropic does not support non-Claude models in Claude Code; this combination is experimental.");
+          if (Date.now() - Date.parse(catalog.refreshedAt) > 300000)
+            warnings.push("Catalog snapshot is older than five minutes; refresh before launching.");
+          return { profile, provider, catalog, warnings, planToken: snapshot(profile, provider, catalog) };
+        }
+        if (resource === "runs" && !id && request.method === "POST") {
+          const input = parse(runInputSchema, body);
+          if (store.engine === "postgresql")
+            await db.unsafe("SELECT id FROM switcher_profiles WHERE id = $1 FOR SHARE", [input.profileId]);
+          const profile = await store.get("profiles", input.profileId, db);
+          if (store.engine === "postgresql") {
+            await db.unsafe("SELECT id FROM switcher_providers WHERE id = $1 FOR SHARE", [profile.providerId]);
+            await db.unsafe("SELECT id FROM switcher_catalogs WHERE id = $1 FOR SHARE", [profile.providerId]);
+          }
+          const provider = await store.get("providers", profile.providerId, db);
+          let catalog;
+          try {
+            catalog = await store.get("catalogs", profile.providerId, db);
+          } catch (error) {
+            if (error instanceof Fault && error.status === 404)
+              throw new Fault(409, "plan_changed", "Catalog changed; request a fresh launch plan.");
+            throw error;
+          }
+          if (profile.harness !== input.harness || profile.model !== input.model || snapshot(profile, provider, catalog) !== input.planToken)
+            throw new Fault(409, "plan_changed", "Provider, profile or catalog changed; request a fresh launch plan.");
+          return store.put("runs", { ...input, providerId: provider.id, providerVersion: provider.version, profileVersion: profile.version, id: crypto.randomUUID(), status: "running", startedAt: new Date().toISOString() }, undefined, db);
+        }
+        if (resource === "runs" && id && request.method === "PATCH" && parts.length === 3) {
+          const input = parse(runUpdateSchema, body);
+          const run = await store.get("runs", id, db);
+          if (run.status !== "running")
+            throw new Fault(409, "run_finished", "Run has already finished.");
+          return store.put("runs", { ...run, ...input, endedAt: new Date().toISOString() }, version(), db);
+        }
+        throw new Fault(404, "not_found", "Route was not found.");
+      });
+      return json(result, request.method === "POST" && ["providers", "profiles", "runs"].includes(resource) && !id ? 201 : 200);
+    } catch (error) {
+      const safe = error instanceof Fault ? error : new Fault(500, "internal_error", "Request failed.");
+      return json({ error: { code: safe.code, message: safe.message, requestId } }, safe.status);
+    }
+  };
+}
+
+// src/serve.ts
+async function main(args = process.argv.slice(2)) {
+  const { values } = parseArgs({ args, options: {
+    host: { type: "string" },
+    port: { type: "string" },
+    "data-dir": { type: "string" },
+    sqlite: { type: "string" },
+    json: { type: "boolean" },
+    version: { type: "boolean" },
+    help: { type: "boolean" }
+  } });
+  if (values.version) {
+    console.log(VERSION);
+    return;
+  }
+  if (values.help) {
+    console.log(`switcher-serve --sqlite PATH | --data-dir DIR | inject HASNA_SWITCHER_DATABASE_URL
+  --host HOST (127.0.0.1) --port PORT (8080; 0 allocates a port) --json --version
+Requires HASNA_SWITCHER_API_KEY (24+ characters). Provider credentials: SWITCHER_PROVIDER_* environment references.`);
+    return;
+  }
+  const port = Number(values.port ?? process.env.PORT ?? 8080);
+  if (!Number.isInteger(port) || port < 0 || port > 65535)
+    throw new Fault(400, "invalid_port", "Port must be an integer between 0 and 65535.");
+  const apiKey = process.env.HASNA_SWITCHER_API_KEY ?? "";
+  if (apiKey.length < 24)
+    throw new Fault(500, "auth_config", "Set HASNA_SWITCHER_API_KEY to a random token of at least 24 characters.");
+  if (values.sqlite && values["data-dir"])
+    throw new Fault(400, "storage_config", "Choose --sqlite or --data-dir.");
+  const store = await Store.open({ databaseUrl: process.env.HASNA_SWITCHER_DATABASE_URL, sqlitePath: values.sqlite ?? (values["data-dir"] ? join(values["data-dir"], "switcher.db") : process.env.HASNA_SWITCHER_SQLITE_PATH) });
+  const server = Bun.serve({ hostname: values.host ?? "127.0.0.1", port, maxRequestBodySize: 1024 * 1024, idleTimeout: 60, fetch: createHandler(store, apiKey) });
+  console.log(JSON.stringify({ event: "listening", version: VERSION, url: server.url.href, storage: store.engine }));
+  let stopping = false;
+  const stop = async () => {
+    if (stopping)
+      return;
+    stopping = true;
+    await server.stop();
+    await store.close();
+  };
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+}
+if (import.meta.main)
+  main().catch((error) => {
+    console.error(JSON.stringify({ error: error instanceof Fault ? error.message : "Server startup failed; check configuration." }));
+    process.exitCode = 1;
+  });
+export {
+  main
+};