@useatlas/create 0.0.6 → 0.0.7

package/templates/nextjs-standalone/src/lib/db/__tests__/registry.test.ts

@@ -1,398 +0,0 @@
-/**
- * Tests for the ConnectionRegistry class and per-connection whitelists.
- *
- * Uses the cache-busting import pattern from connection.test.ts to bypass
- * global mocks registered by other test files. Mocks pg and mysql2/promise
- * so register() can create connections without real databases.
- */
-import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
-import { resolve } from "path";
-
-// Mock database drivers before importing connection module
-mock.module("pg", () => ({
-  Pool: class MockPool {
-    async query() {
-      return { rows: [], fields: [] };
-    }
-    async connect() {
-      return {
-        async query() {
-          return { rows: [], fields: [] };
-        },
-        release() {},
-      };
-    }
-    async end() {}
-  },
-}));
-
-mock.module("mysql2/promise", () => ({
-  createPool: () => ({
-    async getConnection() {
-      return {
-        async execute() {
-          return [[], []];
-        },
-        release() {},
-      };
-    },
-    async end() {},
-  }),
-}));
-
-// Note: ClickHouse, DuckDB, Snowflake adapter mocks removed — those
-// adapters are now plugins. See plugins/{clickhouse,duckdb,snowflake}-datasource/.
-
-// Cache-busting import to get a fresh module instance
-const connModPath = resolve(__dirname, "../connection.ts");
-const connMod = await import(`${connModPath}?t=${Date.now()}`);
-
-const ConnectionRegistry = connMod.ConnectionRegistry as typeof import("../connection").ConnectionRegistry;
-const connections = connMod.connections as import("../connection").ConnectionRegistry;
-const getDB = connMod.getDB as typeof import("../connection").getDB;
-const detectDBType = connMod.detectDBType as typeof import("../connection").detectDBType;
-
-// Import semantic module with cache-busting too
-const semModPath = resolve(__dirname, "../../semantic.ts");
-const semMod = await import(`${semModPath}?t=${Date.now()}`);
-const getWhitelistedTables = semMod.getWhitelistedTables as typeof import("../../semantic").getWhitelistedTables;
-const _resetWhitelists = semMod._resetWhitelists as typeof import("../../semantic")._resetWhitelists;
-
-describe("ConnectionRegistry", () => {
-  const origUrl = process.env.ATLAS_DATASOURCE_URL;
-  const origSchema = process.env.ATLAS_SCHEMA;
-
-  beforeEach(() => {
-    connections._reset();
-    delete process.env.ATLAS_DATASOURCE_URL;
-    delete process.env.ATLAS_SCHEMA;
-  });
-
-  afterEach(() => {
-    connections._reset();
-    if (origUrl !== undefined) {
-      process.env.ATLAS_DATASOURCE_URL = origUrl;
-    } else {
-      delete process.env.ATLAS_DATASOURCE_URL;
-    }
-    if (origSchema !== undefined) {
-      process.env.ATLAS_SCHEMA = origSchema;
-    } else {
-      delete process.env.ATLAS_SCHEMA;
-    }
-  });
-
-  describe("register + get", () => {
-    it("registers a connection and retrieves it by ID", () => {
-      connections.register("analytics", {
-        url: "postgresql://user:pass@localhost:5432/test",
-      });
-      const conn = connections.get("analytics");
-      expect(conn).toBeDefined();
-      expect(conn.query).toBeFunction();
-      expect(conn.close).toBeFunction();
-    });
-
-    it("overwrites existing connection on re-register (closes old)", async () => {
-      let closeCalled = 0;
-      connections.register("test", { url: "postgresql://user:pass@localhost:5432/a" });
-      const original = connections.get("test");
-      const origClose = original.close;
-      original.close = async () => {
-        closeCalled++;
-        return origClose.call(original);
-      };
-
-      connections.register("test", { url: "postgresql://user:pass@localhost:5432/b" });
-      // Give the async close a tick to resolve
-      await new Promise((r) => setTimeout(r, 10));
-      expect(closeCalled).toBe(1);
-
-      // New connection should be different
-      const replacement = connections.get("test");
-      expect(replacement).not.toBe(original);
-    });
-  });
-
-  describe("registerDirect", () => {
-    it("stores and retrieves a pre-built connection", async () => {
-      const mockConn: import("../connection").DBConnection = {
-        async query() { return { columns: [], rows: [] }; },
-        async close() {},
-      };
-      await connections.registerDirect("bench", mockConn, "postgres");
-      expect(connections.get("bench")).toBe(mockConn);
-      expect(connections.getDBType("bench")).toBe("postgres");
-    });
-
-    it("closes previous connection on re-registration", async () => {
-      let closeCalled = 0;
-      const firstConn: import("../connection").DBConnection = {
-        async query() { return { columns: [], rows: [] }; },
-        async close() { closeCalled++; },
-      };
-      const secondConn: import("../connection").DBConnection = {
-        async query() { return { columns: [], rows: [] }; },
-        async close() {},
-      };
-
-      await connections.registerDirect("bench", firstConn, "postgres");
-      await connections.registerDirect("bench", secondConn, "postgres");
-
-      expect(closeCalled).toBe(1);
-      expect(connections.get("bench")).toBe(secondConn);
-    });
-
-    it("stores optional description in metadata", async () => {
-      const mockConn: import("../connection").DBConnection = {
-        async query() { return { columns: [], rows: [] }; },
-        async close() {},
-      };
-      await connections.registerDirect("bench", mockConn, "duckdb", "Benchmark DB");
-
-      const meta = connections.describe();
-      const benchMeta = meta.find((m) => m.id === "bench");
-      expect(benchMeta).toBeDefined();
-      expect(benchMeta!.dbType).toBe("duckdb");
-      expect(benchMeta!.description).toBe("Benchmark DB");
-    });
-  });
-
-  describe("getDefault", () => {
-    it("auto-registers from ATLAS_DATASOURCE_URL on first call", () => {
-      process.env.ATLAS_DATASOURCE_URL = "postgresql://user:pass@localhost:5432/auto";
-      const conn = connections.getDefault();
-      expect(conn).toBeDefined();
-      expect(connections.list()).toContain("default");
-    });
-
-    it("throws when ATLAS_DATASOURCE_URL is not set and no default registered", () => {
-      expect(() => connections.getDefault()).toThrow(
-        "No analytics datasource configured"
-      );
-    });
-
-    it("returns same instance on repeated calls (lazy singleton)", () => {
-      process.env.ATLAS_DATASOURCE_URL = "postgresql://user:pass@localhost:5432/lazy";
-      const first = connections.getDefault();
-      const second = connections.getDefault();
-      expect(first).toBe(second);
-    });
-  });
-
-  describe("get", () => {
-    it("throws for unregistered connection ID", () => {
-      expect(() => connections.get("nonexistent")).toThrow(
-        'Connection "nonexistent" is not registered.'
-      );
-    });
-  });
-
-  describe("list", () => {
-    it("returns empty array when no connections registered", () => {
-      expect(connections.list()).toEqual([]);
-    });
-
-    it("returns all registered connection IDs", () => {
-      connections.register("a", { url: "postgresql://user:pass@localhost:5432/a" });
-      connections.register("b", { url: "mysql://user:pass@localhost:3306/b" });
-      const ids = connections.list();
-      expect(ids).toContain("a");
-      expect(ids).toContain("b");
-      expect(ids.length).toBe(2);
-    });
-  });
-
-  describe("database type detection", () => {
-    it("creates postgres connection for postgresql:// URLs", () => {
-      connections.register("pg", {
-        url: "postgresql://user:pass@localhost:5432/db",
-      });
-      expect(connections.get("pg")).toBeDefined();
-    });
-
-    it("creates mysql connection for mysql:// URLs", () => {
-      connections.register("my", {
-        url: "mysql://user:pass@localhost:3306/db",
-      });
-      expect(connections.get("my")).toBeDefined();
-    });
-
-    it("throws for non-core adapter URLs with plugin migration hint", () => {
-      expect(() => connections.register("ch", { url: "clickhouse://user:pass@localhost:8123/default" })).toThrow("plugin");
-      expect(() => connections.register("sf", { url: "snowflake://user:pass@account123/mydb" })).toThrow("plugin");
-      expect(() => connections.register("dk", { url: "duckdb://:memory:" })).toThrow("plugin");
-    });
-
-    it("throws for unrecognized URL scheme", () => {
-      expect(() =>
-        connections.register("sq", { url: "file:./test.db" })
-      ).toThrow();
-    });
-  });
-
-  describe("getDB backward compat", () => {
-    it("getDB() returns same connection as connections.getDefault()", () => {
-      process.env.ATLAS_DATASOURCE_URL = "postgresql://user:pass@localhost:5432/compat";
-      const fromGetDB = getDB();
-      const fromRegistry = connections.getDefault();
-      expect(fromGetDB).toBe(fromRegistry);
-    });
-  });
-
-  describe("getDBType", () => {
-    it("returns correct type for postgres connection", () => {
-      connections.register("pg", { url: "postgresql://user:pass@localhost:5432/db" });
-      expect(connections.getDBType("pg")).toBe("postgres");
-    });
-
-    it("returns correct type for mysql connection", () => {
-      connections.register("my", { url: "mysql://user:pass@localhost:3306/db" });
-      expect(connections.getDBType("my")).toBe("mysql");
-    });
-
-    it("returns correct type for plugin-registered connection", async () => {
-      const conn = { async query() { return { columns: [], rows: [] }; }, async close() {} };
-      await connections.registerDirect("ch", conn, "clickhouse");
-      expect(connections.getDBType("ch")).toBe("clickhouse");
-    });
-
-    it("throws for unregistered connection ID", () => {
-      expect(() => connections.getDBType("nonexistent")).toThrow(
-        'Connection "nonexistent" is not registered.'
-      );
-    });
-  });
-
-  describe("describe", () => {
-    it("returns metadata for all registered connections", () => {
-      connections.register("pg", {
-        url: "postgresql://user:pass@localhost:5432/db",
-        description: "Main database",
-      });
-      connections.register("my", {
-        url: "mysql://user:pass@localhost:3306/db",
-        description: "Reporting database",
-      });
-
-      const meta = connections.describe();
-      expect(meta).toHaveLength(2);
-
-      const pgMeta = meta.find((m) => m.id === "pg");
-      expect(pgMeta).toBeDefined();
-      expect(pgMeta!.dbType).toBe("postgres");
-      expect(pgMeta!.description).toBe("Main database");
-
-      const myMeta = meta.find((m) => m.id === "my");
-      expect(myMeta).toBeDefined();
-      expect(myMeta!.dbType).toBe("mysql");
-      expect(myMeta!.description).toBe("Reporting database");
-    });
-
-    it("returns empty array when no connections registered", () => {
-      expect(connections.describe()).toEqual([]);
-    });
-
-    it("includes connections without description", () => {
-      connections.register("bare", {
-        url: "postgresql://user:pass@localhost:5432/db",
-      });
-
-      const meta = connections.describe();
-      expect(meta).toHaveLength(1);
-      expect(meta[0].id).toBe("bare");
-      expect(meta[0].dbType).toBe("postgres");
-      expect(meta[0].description).toBeUndefined();
-    });
-  });
-
-  describe("_reset", () => {
-    it("clears all connections", () => {
-      connections.register("x", { url: "postgresql://user:pass@localhost:5432/x" });
-      connections.register("y", { url: "mysql://user:pass@localhost:3306/y" });
-      expect(connections.list().length).toBe(2);
-
-      connections._reset();
-      expect(connections.list()).toEqual([]);
-    });
-
-    it("also clears whitelist cache", async () => {
-      // Populate whitelist cache via the same semantic module that connection.ts uses
-      // (connection.ts imports _resetWhitelists from @atlas/api/lib/semantic, which is
-      // the non-cache-busted instance — so we import it the same way to test the contract)
-      const semOrigModPath = resolve(__dirname, "../../semantic.ts");
-      const semOrig = await import(semOrigModPath);
-      const origGetWhitelisted = semOrig.getWhitelistedTables as typeof getWhitelistedTables;
-
-      const before = origGetWhitelisted("reset-test-conn");
-      connections._reset();
-      // After reset, whitelist cache is cleared — new call returns a fresh Set
-      const after = origGetWhitelisted("reset-test-conn");
-      expect(before).not.toBe(after);
-    });
-  });
-
-  describe("detectDBType", () => {
-    it("returns 'postgres' for postgresql:// URLs", () => {
-      expect(detectDBType("postgresql://user:pass@localhost:5432/db")).toBe("postgres");
-    });
-
-    it("returns 'mysql' for mysql:// URLs", () => {
-      expect(detectDBType("mysql://user:pass@localhost:3306/db")).toBe("mysql");
-    });
-
-    it("throws for non-core URL schemes with plugin suggestion", () => {
-      expect(() => detectDBType("clickhouse://user:pass@localhost:8123/default")).toThrow("plugin");
-    });
-
-    it("throws for unsupported URL scheme", () => {
-      expect(() => detectDBType("file:./test.db")).toThrow("Unsupported database URL");
-    });
-  });
-
-  describe("constructor creates independent instances", () => {
-    it("new ConnectionRegistry is independent", () => {
-      const reg = new ConnectionRegistry();
-      reg.register("isolated", { url: "postgresql://user:pass@localhost:5432/isolated" });
-      expect(reg.list()).toEqual(["isolated"]);
-      expect(connections.list()).toEqual([]);
-      reg._reset();
-    });
-  });
-});
-
-describe("per-connection whitelist", () => {
-  beforeEach(() => {
-    _resetWhitelists();
-  });
-
-  afterEach(() => {
-    _resetWhitelists();
-  });
-
-  it("getWhitelistedTables() returns default set", () => {
-    const tables = getWhitelistedTables();
-    expect(tables).toBeInstanceOf(Set);
-  });
-
-  it("getWhitelistedTables('default') returns same set as no-arg call", () => {
-    const noArg = getWhitelistedTables();
-    const explicit = getWhitelistedTables("default");
-    expect(noArg).toBe(explicit);
-  });
-
-  it("_resetWhitelists() clears cache", () => {
-    const first = getWhitelistedTables();
-    _resetWhitelists();
-    const second = getWhitelistedTables();
-    // After reset, a new Set is created (not the same reference)
-    expect(first).not.toBe(second);
-  });
-
-  it("different connectionIds share the same whitelist in backward-compat mode", () => {
-    const a = getWhitelistedTables("a");
-    const b = getWhitelistedTables("b");
-    // When no entity uses `connection:`, all connections share the same table set
-    expect(a.size).toBe(b.size);
-  });
-});

package/templates/nextjs-standalone/src/lib/db/__tests__/source-rate-limit.test.ts

@@ -1,130 +0,0 @@
-/**
- * Tests for per-source rate limiting.
- */
-import { describe, it, expect, afterEach } from "bun:test";
-import {
-  checkSourceRateLimit,
-  registerSourceRateLimit,
-  clearSourceRateLimit,
-  incrementSourceConcurrency,
-  decrementSourceConcurrency,
-  _resetSourceRateLimits,
-  _stopSourceRateLimitCleanup,
-} from "../source-rate-limit";
-
-afterEach(() => {
-  _resetSourceRateLimits();
-});
-
-// Stop cleanup timer so it doesn't keep test runner alive
-afterEach(() => {
-  _stopSourceRateLimitCleanup();
-});
-
-describe("per-source rate limiting", () => {
-  describe("QPM enforcement", () => {
-    it("allows queries under the limit", () => {
-      registerSourceRateLimit("test", { queriesPerMinute: 5, concurrency: 10 });
-      for (let i = 0; i < 5; i++) {
-        expect(checkSourceRateLimit("test").allowed).toBe(true);
-      }
-    });
-
-    it("blocks queries over the QPM limit", () => {
-      registerSourceRateLimit("test", { queriesPerMinute: 3, concurrency: 10 });
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-      const result = checkSourceRateLimit("test");
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain("QPM limit reached");
-      expect(result.retryAfterMs).toBeGreaterThan(0);
-    });
-
-    it("uses default limit (60 QPM) when no custom limit is set", () => {
-      for (let i = 0; i < 60; i++) {
-        expect(checkSourceRateLimit("unregistered").allowed).toBe(true);
-      }
-      expect(checkSourceRateLimit("unregistered").allowed).toBe(false);
-    });
-  });
-
-  describe("concurrency enforcement", () => {
-    it("allows queries under the concurrency limit", () => {
-      registerSourceRateLimit("test", { queriesPerMinute: 100, concurrency: 2 });
-      incrementSourceConcurrency("test");
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-    });
-
-    it("blocks queries at the concurrency limit", () => {
-      registerSourceRateLimit("test", { queriesPerMinute: 100, concurrency: 2 });
-      incrementSourceConcurrency("test");
-      incrementSourceConcurrency("test");
-      const result = checkSourceRateLimit("test");
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toContain("concurrency limit reached");
-    });
-
-    it("allows queries after decrementing concurrency", () => {
-      registerSourceRateLimit("test", { queriesPerMinute: 100, concurrency: 1 });
-      incrementSourceConcurrency("test");
-      expect(checkSourceRateLimit("test").allowed).toBe(false);
-      decrementSourceConcurrency("test");
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-    });
-
-    it("concurrency does not go below zero", () => {
-      decrementSourceConcurrency("test");
-      decrementSourceConcurrency("test");
-      // Should not throw, count stays at 0
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-    });
-  });
-
-  describe("per-source isolation", () => {
-    it("limits are independent per source", () => {
-      registerSourceRateLimit("a", { queriesPerMinute: 2, concurrency: 10 });
-      registerSourceRateLimit("b", { queriesPerMinute: 2, concurrency: 10 });
-
-      expect(checkSourceRateLimit("a").allowed).toBe(true);
-      expect(checkSourceRateLimit("a").allowed).toBe(true);
-      expect(checkSourceRateLimit("a").allowed).toBe(false); // a is at limit
-
-      expect(checkSourceRateLimit("b").allowed).toBe(true); // b is independent
-      expect(checkSourceRateLimit("b").allowed).toBe(true);
-    });
-  });
-
-  describe("registerSourceRateLimit + clearSourceRateLimit", () => {
-    it("custom limits override defaults", () => {
-      registerSourceRateLimit("test", { queriesPerMinute: 2, concurrency: 1 });
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-      expect(checkSourceRateLimit("test").allowed).toBe(false);
-    });
-
-    it("clearSourceRateLimit reverts to defaults", () => {
-      registerSourceRateLimit("test", { queriesPerMinute: 1, concurrency: 10 });
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-      expect(checkSourceRateLimit("test").allowed).toBe(false);
-
-      _resetSourceRateLimits();
-      clearSourceRateLimit("test");
-      // Should use default (60 QPM) — should allow
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-    });
-  });
-
-  describe("_resetSourceRateLimits", () => {
-    it("clears all state", () => {
-      registerSourceRateLimit("test", { queriesPerMinute: 1, concurrency: 1 });
-      incrementSourceConcurrency("test");
-      checkSourceRateLimit("test");
-
-      _resetSourceRateLimits();
-
-      // After reset, limits/concurrency/windows are cleared
-      expect(checkSourceRateLimit("test").allowed).toBe(true);
-    });
-  });
-});

package/templates/nextjs-standalone/src/lib/errors.ts

@@ -1,154 +0,0 @@
-/**
- * Client-side error parsing for Atlas chat errors.
- *
- * The server returns JSON error bodies with { error, message, retryAfterSeconds? }.
- * This module parses those into user-friendly `ChatErrorInfo` objects.
- */
-
-import type { AuthMode } from "@atlas/api/lib/auth/types";
-
-/* ------------------------------------------------------------------ */
-/*  ChatErrorCode — all server error codes                             */
-/* ------------------------------------------------------------------ */
-
-export const CHAT_ERROR_CODES = [
-  "auth_error",
-  "rate_limited",
-  "configuration_error",
-  "no_datasource",
-  "invalid_request",
-  "provider_model_not_found",
-  "provider_auth_error",
-  "provider_rate_limit",
-  "provider_timeout",
-  "provider_unreachable",
-  "provider_error",
-  "internal_error",
-] as const;
-
-/** Union of all error codes the server can return in the `error` field. */
-export type ChatErrorCode = (typeof CHAT_ERROR_CODES)[number];
-
-/* ------------------------------------------------------------------ */
-/*  ChatErrorInfo                                                      */
-/* ------------------------------------------------------------------ */
-
-/**
- * Structured error info extracted from a chat error response.
- *
- * - `title`  — Primary user-facing message (always present).
- * - `detail` — Optional secondary message with extra context.
- * - `retryAfterSeconds` — Seconds to wait before retrying (rate_limited only).
- *   Clamped to [0, 300].
- * - `code` — The server error code, if the response was valid JSON with a known code.
- */
-export interface ChatErrorInfo {
-  title: string;
-  detail?: string;
-  retryAfterSeconds?: number;
-  code?: ChatErrorCode;
-}
-
-/* ------------------------------------------------------------------ */
-/*  authErrorMessage                                                   */
-/* ------------------------------------------------------------------ */
-
-/**
- * Map an auth mode to a user-friendly error message.
- *
- * Different auth modes require different guidance:
- * - `simple-key`: the user needs to check or re-enter their API key.
- * - `managed`: the session likely expired; a fresh sign-in is needed.
- * - `byot`: the external token may have expired or been revoked.
- * - `none`: auth should not fail in this mode; a generic message is shown.
- */
-export function authErrorMessage(authMode: AuthMode): string {
-  switch (authMode) {
-    case "simple-key":
-      return "Invalid or missing API key. Check your key and try again.";
-    case "managed":
-      return "Your session has expired. Please sign in again.";
-    case "byot":
-      return "Authentication failed. Your token may have expired.";
-    case "none":
-      return "An unexpected authentication error occurred. Please refresh the page.";
-    default: {
-      const _exhaustive: never = authMode;
-      return `Authentication failed (unknown mode: ${_exhaustive}).`;
-    }
-  }
-}
-
-/* ------------------------------------------------------------------ */
-/*  parseChatError                                                     */
-/* ------------------------------------------------------------------ */
-
-/**
- * Parse an AI SDK chat error into a user-friendly `ChatErrorInfo`.
- *
- * Expects `error.message` to contain a JSON string with `{ error, message, retryAfterSeconds? }`.
- * Falls back to a generic message when the body is not valid JSON (e.g. network failures,
- * HTML error pages, or unexpected formats).
- */
-export function parseChatError(error: Error, authMode: AuthMode): ChatErrorInfo {
-  let parsed: Record<string, unknown>;
-  try {
-    parsed = JSON.parse(error.message);
-  } catch {
-    return { title: "Something went wrong. Please try again." };
-  }
-
-  const code = typeof parsed.error === "string" ? parsed.error : undefined;
-  const serverMessage = typeof parsed.message === "string" ? parsed.message : undefined;
-
-  switch (code) {
-    case "auth_error":
-      return { title: authErrorMessage(authMode), code };
-
-    case "rate_limited": {
-      const raw = typeof parsed.retryAfterSeconds === "number" ? parsed.retryAfterSeconds : undefined;
-      const clamped = raw !== undefined ? Math.max(0, Math.min(raw, 300)) : undefined;
-      return {
-        title: "Too many requests.",
-        detail: clamped !== undefined
-          ? `Try again in ${clamped} seconds.`
-          : "Please wait before trying again.",
-        retryAfterSeconds: clamped,
-        code,
-      };
-    }
-
-    case "configuration_error":
-      return { title: "Atlas is not fully configured.", detail: serverMessage, code };
-
-    case "no_datasource":
-      return { title: "No data source configured.", detail: serverMessage, code };
-
-    case "invalid_request":
-      return { title: "Invalid request.", detail: serverMessage, code };
-
-    case "provider_model_not_found":
-      return { title: "The configured AI model was not found.", detail: serverMessage, code };
-
-    case "provider_auth_error":
-      return { title: "The AI provider could not authenticate.", detail: serverMessage, code };
-
-    case "provider_rate_limit":
-      return { title: "The AI provider is rate limiting requests.", detail: serverMessage, code };
-
-    case "provider_timeout":
-      return { title: "The AI provider timed out.", detail: serverMessage, code };
-
-    case "provider_unreachable":
-      return { title: "Could not reach the AI provider.", detail: serverMessage, code };
-
-    case "provider_error":
-      return { title: "The AI provider returned an error.", detail: serverMessage, code };
-
-    case "internal_error":
-      return { title: serverMessage ?? "An unexpected error occurred.", code };
-
-    default:
-      return { title: serverMessage ?? "Something went wrong. Please try again." };
-  }
-}