refactor!(llm): Remove bootstrapper in favor of setup-provider

refactor!(llm): implement new model registration system
feat(llm): Dynamically fetch available models from providers
2026-07-22 03:52:48 +05:30 · 2026-07-16 22:21:59 +05:30 · 2026-07-16 22:05:45 +05:30 · 2026-07-16 19:16:55 +05:30 · 2026-07-16 18:25:07 +05:30
37 changed files with 3292 additions and 1502 deletions
--- a/apps/gui/src/app/actions.ts
+++ b/apps/gui/src/app/actions.ts
@@ -7,8 +7,10 @@ import type { SimSnapshot } from "@/lib/simulation";
 import {
  ProviderManager,
  ModelProviderInstance,
-  AVAILABLE_PROVIDERS,
+  getAvailableProviders as listAvailableProviders,
  ModelProviderMeta,
+  ModelLister,
+  ModelInfo,
 } from "@omnia/llm";

 function resolveScenarioPath(relative: string): string {
@@ -309,7 +311,7 @@ export async function setProviderMapping(
 }

 export async function getAvailableProviders(): Promise<ModelProviderMeta[]> {
-  return AVAILABLE_PROVIDERS;
+  return listAvailableProviders();
 }

 export async function regenerateEmbeddings(
@@ -317,3 +319,32 @@ export async function regenerateEmbeddings(
 ): Promise<void> {
  await simulationManager.regenerateAllEmbeddings(newProviderInstanceId);
 }
+
+/**
+ * Fetch available models for a provider given its credentials.
+ * Used when creating a new instance (before it's saved to the DB).
+ */
+export async function fetchAvailableModels(
+  providerName: string,
+  apiKey: string,
+  endpointUrl?: string,
+): Promise<ModelInfo[]> {
+  return ModelLister.listModels(providerName, apiKey, endpointUrl);
+}
+
+/**
+ * Fetch available models for an existing saved provider instance.
+ * The API key is retrieved from the DB server-side — never sent to the client.
+ */
+export async function fetchAvailableModelsForInstance(
+  instanceId: string,
+): Promise<ModelInfo[]> {
+  const instances = ProviderManager.list();
+  const inst = instances.find((i) => i.id === instanceId);
+  if (!inst) return [];
+  return ModelLister.listModels(
+    inst.providerName,
+    inst.apiKey,
+    inst.endpointUrl,
+  );
+}
--- a/apps/gui/src/components/config/ProviderInstancesConfig.tsx
+++ b/apps/gui/src/components/config/ProviderInstancesConfig.tsx
@@ -1,14 +1,20 @@
 "use client";

-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import {
  createProviderInstance,
  updateProviderInstance,
  setActiveProviderInstance,
  regenerateEmbeddings,
  deleteProviderInstance,
+  fetchAvailableModels,
+  fetchAvailableModelsForInstance,
 } from "@/app/actions";
-import type { ModelProviderInstance, ModelProviderMeta } from "@omnia/llm";
+import type {
+  ModelInfo,
+  ModelProviderInstance,
+  ModelProviderMeta,
+} from "@omnia/llm";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
@@ -22,6 +28,14 @@ import {
  SelectTrigger,
  SelectValue,
 } from "@/components/ui/select";
+import {
+  Combobox,
+  ComboboxContent,
+  ComboboxEmpty,
+  ComboboxInput,
+  ComboboxItem,
+  ComboboxList,
+} from "@/components/ui/combobox";
 import {
  Card,
  CardHeader,
@@ -38,6 +52,7 @@ import {
 } from "@/components/ui/item";
 import { Empty, EmptyTitle, EmptyDescription } from "@/components/ui/empty";
 import { cn } from "@/lib/utils";
+import { RefreshCwIcon } from "lucide-react";

 interface ProviderInstancesConfigProps {
  instances: ModelProviderInstance[];
@@ -68,6 +83,61 @@ export function ProviderInstancesConfig({
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState("");

+  // Model listing state
+  const [availableModels, setAvailableModels] = useState<ModelInfo[]>([]);
+  const [modelsLoading, setModelsLoading] = useState(false);
+  const debounceTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  // Fetch models for an existing saved instance
+  const fetchModelsForExistingInstance = async (instanceId: string) => {
+    setModelsLoading(true);
+    setAvailableModels([]);
+    try {
+      const models = await fetchAvailableModelsForInstance(instanceId);
+      setAvailableModels(models);
+    } catch {
+      setAvailableModels([]);
+    } finally {
+      setModelsLoading(false);
+    }
+  };
+
+  // Fetch models for a new instance (using live key/endpoint from form)
+  const fetchModelsForNewInstance = (
+    provider: string,
+    apiKey: string,
+    endpointUrl: string,
+  ) => {
+    if (debounceTimer.current) clearTimeout(debounceTimer.current);
+
+    const isOllama = provider === "ollama";
+    const hasCredentials = isOllama
+      ? endpointUrl.trim().length > 0
+      : apiKey.trim().length > 8; // don't spam API with partial keys
+
+    if (!hasCredentials) {
+      setAvailableModels([]);
+      return;
+    }
+
+    debounceTimer.current = setTimeout(async () => {
+      setModelsLoading(true);
+      setAvailableModels([]);
+      try {
+        const models = await fetchAvailableModels(
+          provider,
+          isOllama ? "none" : apiKey,
+          isOllama ? endpointUrl : undefined,
+        );
+        setAvailableModels(models);
+      } catch {
+        setAvailableModels([]);
+      } finally {
+        setModelsLoading(false);
+      }
+    }, 600);
+  };
+
  useEffect(() => {
    if (selectedInstanceId === null) {
      setEditName("");
@@ -78,6 +148,7 @@ export function ProviderInstancesConfig({
      setEditType("generative");
      setEditMaxContext(32768);
      setEditEndpointUrl("");
+      setAvailableModels([]);
    } else if (selectedInstanceId === "new") {
      setEditName("");
      const defaultProvider = "google-genai";
@@ -89,6 +160,7 @@ export function ProviderInstancesConfig({
      setEditIsActive(false);
      setEditMaxContext(32768);
      setEditEndpointUrl("");
+      setAvailableModels([]);
    } else {
      const inst = instances.find((i) => i.id === selectedInstanceId);
      if (inst) {
@@ -113,10 +185,21 @@ export function ProviderInstancesConfig({
            : 32768,
        );
        setEditEndpointUrl(inst.endpointUrl || "");
+        setAvailableModels([]);
+        // Auto-fetch models for existing instances
+        fetchModelsForExistingInstance(selectedInstanceId);
      }
    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [selectedInstanceId, instances, availableProviders]);

+  // Re-fetch models when provider/key/endpoint changes on new instance form
+  useEffect(() => {
+    if (selectedInstanceId !== "new") return;
+    fetchModelsForNewInstance(editProvider, editKey, editEndpointUrl);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editProvider, editKey, editEndpointUrl, selectedInstanceId]);
+
  const handleProviderChange = (providerId: string | null) => {
    if (!providerId) return;
    setEditProvider(providerId);
@@ -126,6 +209,7 @@ export function ProviderInstancesConfig({
        ? pMeta?.defaultEmbeddingModel || ""
        : pMeta?.defaultModel || "",
    );
+    setAvailableModels([]);
  };

  const handleTypeChange = (type: "generative" | "embedding") => {
@@ -138,6 +222,14 @@ export function ProviderInstancesConfig({
    );
  };

+  const handleRefreshModels = () => {
+    if (selectedInstanceId && selectedInstanceId !== "new") {
+      fetchModelsForExistingInstance(selectedInstanceId);
+    } else {
+      fetchModelsForNewInstance(editProvider, editKey, editEndpointUrl);
+    }
+  };
+
  const handleSave = async (e: React.FormEvent) => {
    e.preventDefault();
    if (!editName.trim()) {
@@ -440,13 +532,77 @@ export function ProviderInstancesConfig({
                )}

                <div className="flex flex-col gap-1.5">
-                  <Label htmlFor="formModel">Model Name</Label>
-                  <Input
-                    id="formModel"
+                  <div className="flex items-center justify-between">
+                    <Label htmlFor="formModel">Model</Label>
+                    <button
+                      type="button"
+                      onClick={handleRefreshModels}
+                      disabled={modelsLoading}
+                      className="flex items-center gap-1 rounded px-1.5 py-0.5 text-xs text-muted-foreground transition-colors hover:bg-muted hover:text-foreground disabled:opacity-40"
+                      title="Refresh model list"
+                    >
+                      <RefreshCwIcon
+                        className={cn(
+                          "size-3",
+                          modelsLoading && "animate-spin",
+                        )}
+                      />
+                      {modelsLoading
+                        ? "Fetching…"
+                        : availableModels.length > 0
+                          ? `${availableModels.length} models`
+                          : "Fetch models"}
+                    </button>
+                  </div>
+                  <Combobox
                    value={editModel}
-                    onChange={(e) => setEditModel(e.target.value)}
-                    placeholder="e.g. gemini-2.5-flash, gemini-2.5-pro"
-                  />
+                    onValueChange={(v) => {
+                      if (v) setEditModel(v);
+                    }}
+                    items={availableModels.map((m) => m.id)}
+                  >
+                    <ComboboxInput
+                      id="formModel"
+                      placeholder={
+                        modelsLoading
+                          ? "Fetching models…"
+                          : availableModels.length > 0
+                            ? "Search or select a model…"
+                            : "e.g. gemini-2.5-flash"
+                      }
+                      disabled={modelsLoading}
+                      showClear={false}
+                      value={editModel}
+                      onChange={(e) =>
+                        setEditModel((e.target as HTMLInputElement).value)
+                      }
+                      className="w-full"
+                    />
+                    <ComboboxContent>
+                      <ComboboxEmpty>
+                        {modelsLoading
+                          ? "Fetching models…"
+                          : "No models found. Type a custom model name above."}
+                      </ComboboxEmpty>
+                      <ComboboxList>
+                        {(modelId: string) => {
+                          const model = availableModels.find(
+                            (m) => m.id === modelId,
+                          );
+                          return (
+                            <ComboboxItem key={modelId} value={modelId}>
+                              <span className="flex-1 truncate">{modelId}</span>
+                              {model?.ownedBy && (
+                                <span className="ml-2 shrink-0 text-xs text-muted-foreground">
+                                  {model.ownedBy}
+                                </span>
+                              )}
+                            </ComboboxItem>
+                          );
+                        }}
+                      </ComboboxList>
+                    </ComboboxContent>
+                  </Combobox>
                </div>

                {editType === "generative" && (
--- a/apps/gui/src/components/ui/combobox.tsx
+++ b/apps/gui/src/components/ui/combobox.tsx
@@ -0,0 +1,300 @@
+"use client";
+
+import * as React from "react";
+import { Combobox as ComboboxPrimitive } from "@base-ui/react";
+import { CheckIcon, ChevronDownIcon, XIcon } from "lucide-react";
+
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import {
+  InputGroup,
+  InputGroupAddon,
+  InputGroupButton,
+  InputGroupInput,
+} from "@/components/ui/input-group";
+
+const Combobox = ComboboxPrimitive.Root;
+
+function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props) {
+  return <ComboboxPrimitive.Value data-slot="combobox-value" {...props} />;
+}
+
+function ComboboxTrigger({
+  className,
+  children,
+  ...props
+}: ComboboxPrimitive.Trigger.Props) {
+  return (
+    <ComboboxPrimitive.Trigger
+      data-slot="combobox-trigger"
+      className={cn("[&_svg:not([class*='size-'])]:size-4", className)}
+      {...props}
+    >
+      {children}
+      <ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
+    </ComboboxPrimitive.Trigger>
+  );
+}
+
+function ComboboxClear({ className, ...props }: ComboboxPrimitive.Clear.Props) {
+  return (
+    <ComboboxPrimitive.Clear
+      data-slot="combobox-clear"
+      render={<InputGroupButton variant="ghost" size="icon-xs" />}
+      className={cn(className)}
+      {...props}
+    >
+      <XIcon className="pointer-events-none" />
+    </ComboboxPrimitive.Clear>
+  );
+}
+
+function ComboboxInput({
+  className,
+  children,
+  disabled = false,
+  showTrigger = true,
+  showClear = false,
+  ...props
+}: ComboboxPrimitive.Input.Props & {
+  showTrigger?: boolean;
+  showClear?: boolean;
+}) {
+  return (
+    <InputGroup className={cn("w-auto", className)}>
+      <ComboboxPrimitive.Input
+        render={<InputGroupInput disabled={disabled} />}
+        {...props}
+      />
+      <InputGroupAddon align="inline-end">
+        {showTrigger && (
+          <InputGroupButton
+            size="icon-xs"
+            variant="ghost"
+            render={<ComboboxTrigger />}
+            data-slot="input-group-button"
+            className="group-has-data-[slot=combobox-clear]/input-group:hidden data-pressed:bg-transparent"
+            disabled={disabled}
+          />
+        )}
+        {showClear && <ComboboxClear disabled={disabled} />}
+      </InputGroupAddon>
+      {children}
+    </InputGroup>
+  );
+}
+
+function ComboboxContent({
+  className,
+  side = "bottom",
+  sideOffset = 6,
+  align = "start",
+  alignOffset = 0,
+  anchor,
+  ...props
+}: ComboboxPrimitive.Popup.Props &
+  Pick<
+    ComboboxPrimitive.Positioner.Props,
+    "side" | "align" | "sideOffset" | "alignOffset" | "anchor"
+  >) {
+  return (
+    <ComboboxPrimitive.Portal>
+      <ComboboxPrimitive.Positioner
+        side={side}
+        sideOffset={sideOffset}
+        align={align}
+        alignOffset={alignOffset}
+        anchor={anchor}
+        className="isolate z-50"
+      >
+        <ComboboxPrimitive.Popup
+          data-slot="combobox-content"
+          data-chips={!!anchor}
+          className={cn(
+            "cn-menu-target cn-menu-translucent group/combobox-content relative max-h-(--available-height) w-(--anchor-width) max-w-(--available-width) min-w-[calc(var(--anchor-width)+var(--spacing-7,1.75rem))] origin-(--transform-origin) overflow-hidden rounded border-2 bg-popover text-popover-foreground shadow-md duration-100 data-[chips=true]:min-w-(--anchor-width) data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 *:data-[slot=input-group]:m-1 *:data-[slot=input-group]:mb-0 *:data-[slot=input-group]:h-8 *:data-[slot=input-group]:border-input/30 *:data-[slot=input-group]:bg-input/30 *:data-[slot=input-group]:shadow-none data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+            className,
+          )}
+          {...props}
+        />
+      </ComboboxPrimitive.Positioner>
+    </ComboboxPrimitive.Portal>
+  );
+}
+
+function ComboboxList({ className, ...props }: ComboboxPrimitive.List.Props) {
+  return (
+    <ComboboxPrimitive.List
+      data-slot="combobox-list"
+      className={cn(
+        "no-scrollbar max-h-72 scroll-py-1 overflow-y-auto overscroll-contain p-1 data-empty:p-0",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function ComboboxItem({
+  className,
+  children,
+  ...props
+}: ComboboxPrimitive.Item.Props) {
+  return (
+    <ComboboxPrimitive.Item
+      data-slot="combobox-item"
+      className={cn(
+        "relative flex w-full cursor-default items-center gap-2 rounded-sm py-1 pr-8 pl-1.5 text-sm outline-hidden select-none data-highlighted:bg-accent data-highlighted:text-accent-foreground not-data-[variant=destructive]:data-highlighted:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      <ComboboxPrimitive.ItemIndicator
+        render={
+          <span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />
+        }
+      >
+        <CheckIcon className="pointer-events-none" />
+      </ComboboxPrimitive.ItemIndicator>
+    </ComboboxPrimitive.Item>
+  );
+}
+
+function ComboboxGroup({ className, ...props }: ComboboxPrimitive.Group.Props) {
+  return (
+    <ComboboxPrimitive.Group
+      data-slot="combobox-group"
+      className={cn(className)}
+      {...props}
+    />
+  );
+}
+
+function ComboboxLabel({
+  className,
+  ...props
+}: ComboboxPrimitive.GroupLabel.Props) {
+  return (
+    <ComboboxPrimitive.GroupLabel
+      data-slot="combobox-label"
+      className={cn("px-2 py-1.5 text-xs text-muted-foreground", className)}
+      {...props}
+    />
+  );
+}
+
+function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props) {
+  return (
+    <ComboboxPrimitive.Collection data-slot="combobox-collection" {...props} />
+  );
+}
+
+function ComboboxEmpty({ className, ...props }: ComboboxPrimitive.Empty.Props) {
+  return (
+    <ComboboxPrimitive.Empty
+      data-slot="combobox-empty"
+      className={cn(
+        "hidden w-full justify-center py-2 text-center text-sm text-muted-foreground group-data-empty/combobox-content:flex",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function ComboboxSeparator({
+  className,
+  ...props
+}: ComboboxPrimitive.Separator.Props) {
+  return (
+    <ComboboxPrimitive.Separator
+      data-slot="combobox-separator"
+      className={cn("-mx-1 my-1 h-px bg-border", className)}
+      {...props}
+    />
+  );
+}
+
+function ComboboxChips({
+  className,
+  ...props
+}: React.ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> &
+  ComboboxPrimitive.Chips.Props) {
+  return (
+    <ComboboxPrimitive.Chips
+      data-slot="combobox-chips"
+      className={cn(
+        "flex min-h-8 flex-wrap items-center gap-1 rounded border-2 bg-input bg-clip-padding px-2.5 py-1 text-sm shadow-sm transition-colors focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-primary has-aria-invalid:border-destructive has-data-[slot=combobox-chip]:px-1",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function ComboboxChip({
+  className,
+  children,
+  showRemove = true,
+  ...props
+}: ComboboxPrimitive.Chip.Props & {
+  showRemove?: boolean;
+}) {
+  return (
+    <ComboboxPrimitive.Chip
+      data-slot="combobox-chip"
+      className={cn(
+        "flex h-[calc(var(--spacing,0.25rem)*5.25)] w-fit items-center justify-center gap-1 rounded-sm border-2 bg-muted px-1.5 text-xs font-medium whitespace-nowrap text-foreground has-disabled:pointer-events-none has-disabled:cursor-not-allowed has-disabled:opacity-50 has-data-[slot=combobox-chip-remove]:pr-0",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+      {showRemove && (
+        <ComboboxPrimitive.ChipRemove
+          render={<InputGroupButton variant="ghost" size="icon-xs" />}
+          className="-ml-1 opacity-50 hover:opacity-100"
+          data-slot="combobox-chip-remove"
+        >
+          <XIcon className="pointer-events-none" />
+        </ComboboxPrimitive.ChipRemove>
+      )}
+    </ComboboxPrimitive.Chip>
+  );
+}
+
+function ComboboxChipsInput({
+  className,
+  ...props
+}: ComboboxPrimitive.Input.Props) {
+  return (
+    <ComboboxPrimitive.Input
+      data-slot="combobox-chip-input"
+      className={cn("min-w-16 flex-1 outline-none", className)}
+      {...props}
+    />
+  );
+}
+
+function useComboboxAnchor() {
+  return React.useRef<HTMLDivElement | null>(null);
+}
+
+export {
+  Combobox,
+  ComboboxInput,
+  ComboboxContent,
+  ComboboxList,
+  ComboboxItem,
+  ComboboxGroup,
+  ComboboxLabel,
+  ComboboxCollection,
+  ComboboxEmpty,
+  ComboboxSeparator,
+  ComboboxChips,
+  ComboboxChip,
+  ComboboxChipsInput,
+  ComboboxTrigger,
+  ComboboxValue,
+  useComboboxAnchor,
+};
--- a/apps/gui/src/components/ui/input-group.tsx
+++ b/apps/gui/src/components/ui/input-group.tsx
@@ -0,0 +1,172 @@
+"use client";
+
+import * as React from "react";
+import { cva, type VariantProps } from "class-variance-authority";
+
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+
+function InputGroup({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="input-group"
+      role="group"
+      className={cn(
+        "group/input-group relative flex h-8 w-full min-w-0 items-center rounded border-2 bg-input shadow-sm transition-colors outline-none in-data-[slot=combobox-content]:focus-within:border-inherit in-data-[slot=combobox-content]:focus-within:ring-0 has-disabled:bg-input/50 has-disabled:opacity-50 has-[[data-slot=input-group-control]:focus-visible]:outline-2 has-[[data-slot=input-group-control]:focus-visible]:outline-offset-2 has-[[data-slot=input-group-control]:focus-visible]:outline-primary has-[[data-slot][aria-invalid=true]]:border-destructive has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>textarea]:h-auto has-[>[data-align=block-end]]:[&>input]:pt-3 has-[>[data-align=block-start]]:[&>input]:pb-3 has-[>[data-align=inline-end]]:[&>input]:pr-1.5 has-[>[data-align=inline-start]]:[&>input]:pl-1.5",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+const inputGroupAddonVariants = cva(
+  "flex h-auto cursor-text items-center justify-center gap-2 py-1.5 text-sm font-medium text-muted-foreground select-none group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      align: {
+        "inline-start":
+          "order-first pl-2 has-[>button]:ml-[-0.3rem] has-[>kbd]:ml-[-0.15rem]",
+        "inline-end":
+          "order-last pr-2 has-[>button]:mr-[-0.3rem] has-[>kbd]:mr-[-0.15rem]",
+        "block-start":
+          "order-first w-full justify-start px-2.5 pt-2 group-has-[>input]/input-group:pt-2 [.border-b]:pb-2",
+        "block-end":
+          "order-last w-full justify-start px-2.5 pb-2 group-has-[>input]/input-group:pb-2 [.border-t]:pt-2",
+      },
+    },
+    defaultVariants: {
+      align: "inline-start",
+    },
+  },
+);
+
+function InputGroupAddon({
+  className,
+  align = "inline-start",
+  ...props
+}: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>) {
+  return (
+    <div
+      role="group"
+      data-slot="input-group-addon"
+      data-align={align}
+      className={cn(inputGroupAddonVariants({ align }), className)}
+      onClick={(e) => {
+        if ((e.target as HTMLElement).closest("button")) {
+          return;
+        }
+        e.currentTarget.parentElement?.querySelector("input")?.focus();
+      }}
+      {...props}
+    />
+  );
+}
+
+const inputGroupButtonVariants = cva(
+  "flex items-center gap-2 text-sm shadow-none",
+  {
+    variants: {
+      size: {
+        xs: "h-6 gap-1 rounded-[calc(var(--radius)-3px)] px-1.5 [&>svg:not([class*='size-'])]:size-3.5",
+        sm: "",
+        "icon-xs":
+          "size-6 rounded-[calc(var(--radius)-3px)] p-0 has-[>svg]:p-0",
+        "icon-sm": "size-8 p-0 has-[>svg]:p-0",
+      },
+    },
+    defaultVariants: {
+      size: "xs",
+    },
+  },
+);
+
+function InputGroupButton({
+  className,
+  type = "button",
+  variant = "ghost",
+  size = "xs",
+  render,
+  ...props
+}: Omit<React.ComponentProps<typeof Button>, "size" | "type"> &
+  VariantProps<typeof inputGroupButtonVariants> & {
+    type?: "button" | "submit" | "reset";
+    render?: React.ReactElement;
+  }) {
+  if (render) {
+    return React.cloneElement(render, {
+      className: cn(
+        inputGroupButtonVariants({ size }),
+        (render.props as any)?.className,
+        className,
+      ),
+      type,
+      ...props,
+    } as any);
+  }
+
+  return (
+    <Button
+      type={type}
+      data-size={size}
+      variant={variant}
+      className={cn(inputGroupButtonVariants({ size }), className)}
+      {...props}
+    />
+  );
+}
+
+function InputGroupText({ className, ...props }: React.ComponentProps<"span">) {
+  return (
+    <span
+      className={cn(
+        "flex items-center gap-2 text-sm text-muted-foreground [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function InputGroupInput({
+  className,
+  ...props
+}: React.ComponentProps<"input">) {
+  return (
+    <Input
+      data-slot="input-group-control"
+      className={cn(
+        "flex-1 rounded-none border-0 bg-transparent shadow-none outline-none focus-visible:outline-none disabled:bg-transparent aria-invalid:outline-none dark:bg-transparent dark:disabled:bg-transparent",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+function InputGroupTextarea({
+  className,
+  ...props
+}: React.ComponentProps<"textarea">) {
+  return (
+    <Textarea
+      data-slot="input-group-control"
+      className={cn(
+        "flex-1 resize-none rounded-none border-0 bg-transparent py-2 shadow-none outline-none focus-visible:outline-none disabled:bg-transparent aria-invalid:outline-none dark:bg-transparent dark:disabled:bg-transparent",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export {
+  InputGroup,
+  InputGroupAddon,
+  InputGroupButton,
+  InputGroupText,
+  InputGroupInput,
+  InputGroupTextarea,
+};
--- a/apps/gui/src/lib/simulation/provider-resolver.ts
+++ b/apps/gui/src/lib/simulation/provider-resolver.ts
@@ -1,15 +1,9 @@
 import {
-  GeminiProvider,
  MockLLMProvider,
-  OllamaProvider,
-  OllamaEmbeddingProvider,
-  ProviderManager,
-  OpenRouterProvider,
-  AnthropicProvider,
-  OpenAIProvider,
-  OpenAIEmbeddingProvider,
-  GeminiEmbeddingProvider,
  MockEmbeddingProvider,
+  ProviderManager,
+  buildLLMProvider,
+  buildEmbeddingProvider,
 } from "@omnia/llm";
 import type {
  ILLMProvider,
@@ -45,63 +39,10 @@ export interface ProviderResolverOptions {
 }

 // ---------------------------------------------------------------------------
-// Private builders
+// Resolution logic
 // ---------------------------------------------------------------------------

-function buildLLMProvider(inst: ModelProviderInstance): ILLMProvider {
-  if (inst.providerName === "google-genai") {
-    return new GeminiProvider(
-      inst.apiKey,
-      inst.modelName,
-      inst.name,
-      inst.maxContext,
-    );
-  } else if (inst.providerName === "openrouter") {
-    return new OpenRouterProvider(
-      inst.apiKey,
-      inst.modelName,
-      inst.name,
-      inst.maxContext,
-    );
-  } else if (inst.providerName === "ollama") {
-    return new OllamaProvider(
-      inst.endpointUrl,
-      inst.modelName,
-      inst.name,
-      inst.maxContext,
-    );
-  } else if (inst.providerName === "anthropic") {
-    return new AnthropicProvider(
-      inst.apiKey,
-      inst.modelName,
-      inst.name,
-      inst.maxContext,
-    );
-  } else if (inst.providerName === "openai") {
-    return new OpenAIProvider(
-      inst.apiKey,
-      inst.modelName,
-      inst.name,
-      inst.maxContext,
-    );
-  }
-  return new MockLLMProvider([]);
-}
-
-function buildEmbeddingProvider(
-  inst: ModelProviderInstance,
-): IEmbeddingProvider {
-  if (inst.providerName === "google-genai") {
-    return new GeminiEmbeddingProvider(inst.apiKey, inst.modelName);
-  } else if (inst.providerName === "ollama") {
-    return new OllamaEmbeddingProvider(inst.endpointUrl, inst.modelName);
-  } else if (inst.providerName === "openai") {
-    return new OpenAIEmbeddingProvider(inst.apiKey, inst.modelName);
-  }
-  return new MockEmbeddingProvider(inst.modelName);
-}
-
-// ---------------------------------------------------------------------------
+/**
 // Public API
 // ---------------------------------------------------------------------------

--- a/apps/gui/src/lib/simulation/simulation-manager.ts
+++ b/apps/gui/src/lib/simulation/simulation-manager.ts
@@ -5,11 +5,7 @@ import fs from "fs";
 import { SQLiteRepository } from "@omnia/core";
 import { BufferRepository, LedgerRepository } from "@omnia/memory";
 import { Architect, AliasDeltaGenerator } from "@omnia/architect";
-import {
-  ProviderManager,
-  GeminiEmbeddingProvider,
-  MockEmbeddingProvider,
-} from "@omnia/llm";
+import { ProviderManager, buildEmbeddingProvider } from "@omnia/llm";
 import type { ModelProviderInstance, IEmbeddingProvider } from "@omnia/llm";
 import { ScenarioLoader } from "@omnia/scenario";
 import type { SimSnapshot } from "../simulation-types";
@@ -398,14 +394,34 @@ export class SimulationManager {
      inst = ProviderManager.getActive("embedding");
    }

-    const key = inst ? inst.apiKey : process.env.GOOGLE_API_KEY || "";
-    const providerName = inst ? inst.providerName : "google-genai";
-    const modelName = inst ? inst.modelName : undefined;
+    if (!inst) {
+      const envKey = process.env.GOOGLE_API_KEY || "";
+      if (envKey) {
+        inst = {
+          id: "regen-env-fallback",
+          name: "Gemini Embed (Env)",
+          providerName: "google-genai",
+          apiKey: envKey,
+          isActive: true,
+          modelName: "gemini-embedding-001",
+          type: "embedding",
+          maxContext: 0,
+        };
+      } else {
+        inst = {
+          id: "regen-mock-fallback",
+          name: "Mock Embed (Fallback)",
+          providerName: "mock",
+          apiKey: "",
+          isActive: true,
+          modelName: undefined,
+          type: "embedding",
+          maxContext: 0,
+        };
+      }
+    }

-    const embeddingProvider: IEmbeddingProvider =
-      providerName === "google-genai"
-        ? new GeminiEmbeddingProvider(key, modelName)
-        : new MockEmbeddingProvider(modelName);
+    const embeddingProvider: IEmbeddingProvider = buildEmbeddingProvider(inst);

    for (const file of files) {
      const dbPath = path.join(DATA_DIR, file);
--- a/package.json
+++ b/package.json
@@ -19,7 +19,8 @@
    "watch": "tsc -b --watch",
    "test": "vitest run --project unit",
    "test:watch": "vitest --project unit",
-    "test:evals": "vitest run --project evals"
+    "test:evals": "vitest run --project evals",
+    "setup-provider": "node packages/llm/dist/bin/setup-provider.js"
  },
  "keywords": [],
  "author": "sortedcord",
@@ -48,7 +49,9 @@
  },
  "dependencies": {
    "@langchain/anthropic": "^0.3.11",
+    "@langchain/deepseek": "^1.1.5",
    "@langchain/google-genai": "^2.2.0",
+    "@langchain/groq": "^1.3.1",
    "@langchain/ollama": "^0.2.3",
    "@langchain/openai": "^0.3.17",
    "@langchain/openrouter": "^0.4.3",
--- a/packages/llm/README.md
+++ b/packages/llm/README.md
@@ -4,21 +4,16 @@ LLM abstraction layer providing pluggable, database-backed provider instances fo

 ## Architecture Overview

-The system is built around three layers:
+The system is built around four layers:

-1. **Interfaces** — contracts that all providers implement
-2. **Provider Manager** — SQLite-backed CRUD for persisted provider instances
-3. **Provider Resolver** — runtime instantiation of concrete provider classes from stored instances
+1. **Registry** — each provider class self-registers its metadata (id, envVar, capabilities, default model, etc.) via `static {}` blocks; `PROVIDER_REGISTRY` is derived from these registrations at runtime — there is no hand-maintained provider list
+2. **Provider Manager** — SQLite-backed CRUD for persisted provider instances, with env-var bootstrap driven by the registry
+3. **Provider Factory** — `buildLLMProvider(inst)` / `buildEmbeddingProvider(inst)` resolve a stored instance to a live provider class via the registry
+4. **Interfaces** — contracts that all providers implement

 ```mermaid
 graph TD
-    subgraph Interfaces
-        ILP["ILLMProvider"]
-        IEP["IEmbeddingProvider"]
-        MPI["ModelProviderInstance"]
-    end
-
-    subgraph Concrete Providers
+    subgraph Self-Registering Providers
        GP["GeminiProvider"]
        ORP["OpenRouterProvider"]
        MP["MockLLMProvider"]
@@ -26,32 +21,31 @@ graph TD
        MEP["MockEmbeddingProvider"]
    end

+    subgraph Registry
+        PR["ProviderRegistry\n(derived, not authored)"]
+    end
+
    subgraph Storage
-        PM["ProviderManager"]
-        DB[("settings.db\nprovider_instances")]
-        DBMAP[("settings.db\nprovider_mappings")]
+        PM["ProviderManager\n(db.ts + bootstrap.ts + row-mapper.ts)"]
+        DB[("settings.db")]
    end

-    subgraph Resolution
-        PR["resolveProviders()"]
+    subgraph Factory
+        PF["buildLLMProvider()\nbuildEmbeddingProvider()"]
    end

-    GP -->|implements| ILP
-    ORP -->|implements| ILP
-    MP -->|implements| ILP
-    GEP -->|implements| IEP
-    MEP -->|implements| IEP
+    GP -->|static block| PR
+    ORP -->|static block| PR
+    MP -->|static block| PR
+    GEP -->|static block| PR
+    MEP -->|static block| PR

    PM -->|reads/writes| DB
-    PM -->|reads/writes| DBMAP
-    PM -->|returns| MPI
+    PM -->|bootstrap from| PR

-    PR -->|queries| PM
-    PR -->|instantiates| GP
-    PR -->|instantiates| ORP
-    PR -->|instantiates| GEP
-    PR -->|fallback| MP
-    PR -->|fallback| MEP
+    PF -->|looks up| PR
+    PF -->|instantiates| GP
+    PF -->|instantiates| ORP
 ```

 ## Core Interfaces
@@ -140,11 +134,16 @@ Static metadata for each available provider type (used by the UI's provider pick
 | `defaultModel`          | `string` | Default generative model                                     |
 | `defaultEmbeddingModel` | `string` | Default embedding model                                      |

-The [`AVAILABLE_PROVIDERS`](src/llm.ts#L70-L103) constant exports all four provider metas.
+Provider metadata is **self-declared** by each provider class in a `static {}` block and collected into `PROVIDER_REGISTRY` (derived, not authored). The `getAvailableProviders()` function and `AVAILABLE_PROVIDERS` helper in [`llm.ts`](src/llm.ts) read from the registry at call time.

 ## Provider Manager

-[`ProviderManager`](src/provider-manager.ts) is a **static class** that provides full CRUD over provider instances, backed by a SQLite database (`data/settings.db` at the workspace root).
+`ProviderManager` is a **static class** that provides full CRUD over provider instances, backed by a SQLite database (`data/settings.db` at the workspace root). Internally split across:
+
+- [`db.ts`](src/db.ts) — memoized DB handle + schema migrations (`PRAGMA user_version`)
+- [`bin/setup-provider.ts`](src/bin/setup-provider.ts) — CLI tool to set up provider instances in the database
+- [`row-mapper.ts`](src/row-mapper.ts) — `mapRow()` (written once, used everywhere)
+- [`provider-manager.ts`](src/provider-manager.ts) — thin CRUD: `list`, `create`, `delete`, `setActive`, `update`, `getActive`, `getMappings`, `setMapping`

 ### Storage

@@ -191,47 +190,31 @@ CREATE TABLE IF NOT EXISTS provider_mappings (
 - **Auto-promotion on delete** — if the deleted instance was active, the first remaining instance of the same type is promoted.
 - **Auto-activation on create** — if no active instance exists for the type, the new instance is automatically activated.

-### Environment Variable Bootstrap
+### Manual Seeding via CLI

-On first database access (and if the `provider_instances` table is empty), the manager auto-seeds instances from environment variables:
+Rather than automatically bootstrapping from environment variables at runtime, which adds runtime complexity, you can quickly seed the database using the CLI setup tool:

-```mermaid
-flowchart TD
-    A["getSettingsDb() called"] --> B{"DB has 0 rows?"}
-    B -- No --> Z["Return DB"]
-    B -- Yes --> C{"GOOGLE_API_KEY set?"}
-    C -- Yes --> D["Insert 'Gemini (Env)'\ntype: generative, active: true"]
-    D --> E["Insert 'Gemini Embed (Env)'\ntype: embedding, active: true"]
-    E --> F{"OPENROUTER_API_KEY set?"}
-    C -- No --> F
-    F -- Yes --> G["Insert 'OpenRouter (Env)'\ntype: generative\nactive: only if no Google key"]
-    F -- No --> Z
-    G --> Z
+#### Seeding All Environment-Variable Providers
+
+```bash
+pnpm setup-provider --all
 ```

-This same bootstrap logic is **duplicated** inside `getActive()` as a safety net — if the DB is empty at query time, it re-attempts the same env-var seeding.
+This command auto-detects and inserts provider instances into `data/settings.db` for any registered providers whose corresponding environment variables (such as `GOOGLE_API_KEY`, `OPENAI_API_KEY`, etc.) are defined.

-### Fallback Chain in `getActive()`
-
-When no active row is found for the requested type:
+#### Creating a Specific Provider Instance

+```bash
+pnpm setup-provider --provider google-genai --key YOUR_API_KEY [--name "My Gemini"] [--model gemini-2.5-flash] [--type generative] [--max-context 32768] [--endpoint url]
 ```
-1. DB query for isActive=1 AND type=<requested>
-   ├── Found → return it
-   └── Not found
-       ├── DB is empty → bootstrap from env vars → retry query
-       │   ├── Found → return it
-       │   └── Still empty → promote first row of same type
-       │       ├── Found → activate & return
-       │       └── None → return null
-       └── DB has rows but none active for this type
-           → promote first row of same type (same as above)

-2. On any DB error (catch block) → direct env var fallback
-   ├── GOOGLE_API_KEY → synthetic "Gemini (Env Fallback)" instance
-   ├── OPENROUTER_API_KEY → synthetic "OpenRouter (Env Fallback)" instance
-   └── Neither → return null
-```
+### Credential Resolution Cascade
+
+When initializing a provider (e.g. `new GeminiProvider()`):
+
+1. **Explicit Credentials** — If `apiKey`, `modelName`, etc. are passed directly to the constructor, they are used.
+2. **Active DB Instance** — If not explicitly passed, it looks up the active DB instance via `ProviderManager.getActive()`. If found and matches the provider, its API key and configuration are used.
+3. **Environment Fallback** — If there is no matching active DB instance, it resolves the key directly from the corresponding environment variable (e.g., `GOOGLE_API_KEY`) via `resolveCredentials`.

 ## Available Providers

@@ -279,6 +262,48 @@ Also exports `GeminiEmbeddingProvider` (implements `IEmbeddingProvider`) using t
 4. None found                     → throw Error
 ```

+### Groq — `GroqProvider`
+
+| Property                    | Value                                        |
+| --------------------------- | -------------------------------------------- |
+| **File**                    | [`providers/groq.ts`](src/providers/groq.ts) |
+| **Provider ID**             | `groq`                                       |
+| **SDK**                     | `@langchain/groq` (`ChatGroq`)               |
+| **Default Model**           | `llama-3.3-70b-versatile`                    |
+| **Default Embedding Model** | _(none)_                                     |
+| **Default Max Context**     | `8192`                                       |
+| **Type**                    | Generative only (no embedding provider)      |
+
+**Key resolution** in the constructor follows this cascade:
+
+```
+1. Explicit apiKey argument       → use it
+2. ProviderManager.getActive()    → if providerName matches "groq"
+3. GROQ_API_KEY env var           → final fallback
+4. None found                     → throw Error
+```
+
+### DeepSeek — `DeepSeekProvider`
+
+| Property                    | Value                                                |
+| --------------------------- | ---------------------------------------------------- |
+| **File**                    | [`providers/deepseek.ts`](src/providers/deepseek.ts) |
+| **Provider ID**             | `deepseek`                                           |
+| **SDK**                     | `@langchain/deepseek` (`ChatDeepSeek`)               |
+| **Default Model**           | `deepseek-chat`                                      |
+| **Default Embedding Model** | _(none)_                                             |
+| **Default Max Context**     | `64000`                                              |
+| **Type**                    | Generative only (no embedding provider)              |
+
+**Key resolution** in the constructor follows this cascade:
+
+```
+1. Explicit apiKey argument       → use it
+2. ProviderManager.getActive()    → if providerName matches "deepseek"
+3. DEEPSEEK_API_KEY env var       → final fallback
+4. None found                     → throw Error
+```
+
 ### OpenAI — `OpenAIProvider`

 | Property                    | Value                                                  |
@@ -404,8 +429,42 @@ The `buildLLMProvider()` and `buildEmbeddingProvider()` functions perform the fi
 | `"openrouter"`    | `OpenRouterProvider` | _(falls through to mock)_ |
 | `"ollama"`        | `OllamaProvider`     | `OllamaEmbeddingProvider` |
 | `"anthropic"`     | `AnthropicProvider`  | _(falls through to mock)_ |
+| `"groq"`          | `GroqProvider`       | _(falls through to mock)_ |
+| `"deepseek"`      | `DeepSeekProvider`   | _(falls through to mock)_ |
 | _(anything else)_ | `MockLLMProvider`    | `MockEmbeddingProvider`   |

+## Model Listing and Discovery
+
+The `ModelLister` class provides a unified interface to dynamically query available models from the remote provider APIs.
+
+### Caching and TTL
+
+All list requests are cached in-memory with a **5-minute TTL** (`300,000ms`) to prevent rapid, repetitive remote API requests and avoid rate limit exhaustion.
+
+- **Cache Key**: Generated using `providerName` combined with either the `apiKey` or `endpointUrl`.
+- **Invalidation**: Call `ModelLister.invalidateCache(providerName, apiKey, endpointUrl)` to clear cache for specific instances, or `ModelLister.clearCache()` to wipe all lists.
+
+### Provider Integration Details
+
+| Provider          | Endpoint                     | Auth Header             | Pagination                  |
+| ----------------- | ---------------------------- | ----------------------- | --------------------------- |
+| **Google Gemini** | `GET /v1beta/models?key=KEY` | Query Param             | ✅ Loop via `nextPageToken` |
+| **OpenAI**        | `GET /v1/models`             | `Authorization: Bearer` | ❌                          |
+| **Anthropic**     | `GET /v1/models`             | `x-api-key`             | ✅ Loop via `after_id`      |
+| **Groq**          | `GET /openai/v1/models`      | `Authorization: Bearer` | ❌                          |
+| **DeepSeek**      | `GET /models`                | `Authorization: Bearer` | ❌                          |
+| **Ollama**        | `GET /api/tags`              | None (Local)            | ❌                          |
+| **OpenRouter**    | `GET /api/v1/models`         | Optional Bearer         | ❌                          |
+| **Mock**          | Instant return (no fetch)    | —                       | —                           |
+
+### Methods
+
+- `listModels(providerName: string, apiKey: string, endpointUrl?: string): Promise<ModelInfo[]>`
+- `invalidateCache(providerName: string, apiKey: string, endpointUrl?: string): void`
+- `clearCache(): void`
+
+---
+
 ## Structured Output

 All real providers use LangChain's `.withStructuredOutput(schema, { includeRaw: true })` pattern:
@@ -432,8 +491,10 @@ This sends the Zod schema to the model as a structured output constraint. The re
 | `OPENAI_API_KEY`     | No       | OpenAI API key           |
 | `OPENROUTER_API_KEY` | No       | OpenRouter API key       |
 | `ANTHROPIC_API_KEY`  | No       | Anthropic Claude API key |
+| `GROQ_API_KEY`       | No       | Groq API key             |
+| `DEEPSEEK_API_KEY`   | No       | DeepSeek API key         |

-Both are optional because providers can also be configured through the database via the GUI settings page.
+Env var keys are derived from `PROVIDER_REGISTRY` — each provider's `envVar` field is read by `getLlmConfig()` to build the zod schema lazily. Adding a new provider with `envVar: "NEW_KEY"` automatically adds it to config validation.

 ## File Map

@@ -441,19 +502,31 @@ Both are optional because providers can also be configured through the database
 packages/llm/
 ├── src/
 │   ├── index.ts              # Re-exports everything
-│   ├── llm.ts                # Interfaces, types, AVAILABLE_PROVIDERS
-│   ├── config.ts             # Env var parsing (Zod)
-│   ├── provider-manager.ts   # ProviderManager (SQLite CRUD)
+│   ├── llm.ts                # Interfaces, types, getAvailableProviders()
+│   ├── registry.ts           # ProviderRegistry (derived), registerProvider/registerGenerative/registerEmbedding
+│   ├── base-provider.ts      # BaseLLMProvider (shared generateStructuredResponse), resolveCredentials
+│   ├── config.ts             # Env var parsing (lazy, registry-derived Zod)
+│   ├── model-lister.ts       # ModelLister (cache + fetchWithTimeout), fetchOpenAICompatibleModels
+│   ├── provider-factory.ts   # buildLLMProvider() / buildEmbeddingProvider() (registry lookup)
+│   ├── provider-manager.ts   # ProviderManager (thin CRUD)
+│   ├── db.ts                 # Memoized DB handle + migrations
+│   ├── row-mapper.ts         # mapRow()
+│   ├── bin/
+│   │   └── setup-provider.ts # CLI tool to set up provider instances in the database
 │   └── providers/
-│       ├── google-genai.ts   # GeminiProvider + GeminiEmbeddingProvider
+│       ├── google-genai.ts   # GeminiProvider + GeminiEmbeddingProvider (self-registering)
 │       ├── ollama.ts         # OllamaProvider + OllamaEmbeddingProvider
 │       ├── openrouter.ts     # OpenRouterProvider
 │       ├── anthropic.ts      # AnthropicProvider
 │       ├── openai.ts         # OpenAIProvider + OpenAIEmbeddingProvider
+│       ├── groq.ts           # GroqProvider
+│       ├── deepseek.ts       # DeepSeekProvider
 │       └── mock.ts           # MockLLMProvider + MockEmbeddingProvider
 ├── tests/
 │   ├── mock.test.ts
 │   ├── openrouter.test.ts
-│   └── provider-manager.test.ts
+│   ├── model-lister.test.ts  # ModelLister cache and fetch logic unit tests
+│   ├── provider-manager.test.ts
+│   └── cli.test.ts           # Integration tests for setup-provider CLI tool
 └── package.json
 ```
--- a/packages/llm/package.json
+++ b/packages/llm/package.json
@@ -6,6 +6,9 @@
  "exports": {
    ".": "./dist/index.js"
  },
+  "scripts": {
+    "setup-provider": "node ./dist/bin/setup-provider.js"
+  },
  "dependencies": {
    "@types/node": "^26.1.0",
    "better-sqlite3": "^12.11.1"
--- a/packages/llm/src/base-provider.ts
+++ b/packages/llm/src/base-provider.ts
@@ -0,0 +1,112 @@
+import { z } from "zod";
+import type {
+  ILLMProvider,
+  LLMRequest,
+  LLMResponse,
+  LLMCallRecord,
+} from "./llm.js";
+import { ProviderManager } from "./provider-manager.js";
+import { getLlmConfig } from "./config.js";
+
+export interface ResolvedCredentials {
+  key: string | undefined;
+  model: string | undefined;
+  providerInstanceName: string | undefined;
+  maxContext: number | undefined;
+}
+
+export function resolveCredentials(opts: {
+  explicitKey?: string;
+  explicitModel?: string;
+  explicitProviderInstanceName?: string;
+  explicitMaxContext?: number;
+  providerId: string;
+  envVarName: string;
+  type: "generative" | "embedding";
+}): ResolvedCredentials {
+  let key = opts.explicitKey;
+  let model = opts.explicitModel;
+  let providerInstanceName = opts.explicitProviderInstanceName;
+  let maxContext = opts.explicitMaxContext;
+
+  if (!key) {
+    const active = ProviderManager.getActive(opts.type);
+    if (active && active.providerName === opts.providerId) {
+      key = active.apiKey;
+      if (!model) model = active.modelName;
+      if (!providerInstanceName) providerInstanceName = active.name;
+      if (maxContext === undefined) maxContext = active.maxContext;
+    }
+  }
+
+  if (!key) {
+    const cfg = getLlmConfig();
+    key = cfg[opts.envVarName];
+    if (!providerInstanceName && key) {
+      providerInstanceName = "Environment Variable";
+    }
+  }
+
+  return { key, model, providerInstanceName, maxContext };
+}
+
+export abstract class BaseLLMProvider implements ILLMProvider {
+  abstract providerName: string;
+  protected abstract readonly model: unknown;
+  protected abstract modelNameUsed: string;
+  protected abstract providerInstanceName?: string;
+  protected abstract maxContextUsed?: number;
+  protected abstract defaultMaxContext: number;
+  lastCalls: LLMCallRecord[] = [];
+
+  async generateStructuredResponse<T extends z.ZodTypeAny>(
+    request: LLMRequest<T>,
+  ): Promise<LLMResponse<z.infer<T>>> {
+    const structuredModel = (
+      this.model as {
+        withStructuredOutput(
+          s: z.ZodTypeAny,
+          o: { includeRaw: true },
+        ): {
+          invoke(m: unknown): Promise<unknown>;
+        };
+      }
+    ).withStructuredOutput(request.schema, { includeRaw: true });
+    const result = (await structuredModel.invoke([
+      { role: "system", content: request.systemPrompt },
+      { role: "user", content: request.userContext },
+    ])) as unknown as {
+      parsed?: z.infer<T>;
+      raw?: {
+        usage_metadata?: {
+          input_tokens?: number;
+          output_tokens?: number;
+          total_tokens?: number;
+        };
+      };
+    };
+
+    const parsed = result?.parsed;
+    const raw = result?.raw;
+
+    const usage = {
+      inputTokens: raw?.usage_metadata?.input_tokens || 0,
+      outputTokens: raw?.usage_metadata?.output_tokens || 0,
+      totalTokens: raw?.usage_metadata?.total_tokens || 0,
+      modelName: this.modelNameUsed,
+      providerInstanceName: this.providerInstanceName || "Default",
+      maxContext:
+        this.maxContextUsed !== undefined
+          ? this.maxContextUsed
+          : this.defaultMaxContext,
+    };
+
+    this.lastCalls.push({
+      systemPrompt: request.systemPrompt,
+      userContext: request.userContext,
+      usage,
+    });
+
+    return { success: true, data: parsed, usage };
+  }
+}
--- a/packages/llm/src/bin/setup-provider.ts
+++ b/packages/llm/src/bin/setup-provider.ts
@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import { ProviderRegistry, ProviderManager } from "../index.js";
+import dotenv from "dotenv";
+import path from "path";
+import fs from "fs";
+
+// Load dotenv from workspace root
+function loadEnv() {
+  let current = process.cwd();
+  while (current !== "/" && current !== path.parse(current).root) {
+    if (fs.existsSync(path.join(current, "pnpm-workspace.yaml"))) {
+      dotenv.config({ path: path.join(current, ".env") });
+      return;
+    }
+    current = path.dirname(current);
+  }
+  dotenv.config();
+}
+
+loadEnv();
+
+function printHelp() {
+  console.log(`
+Usage:
+  node packages/llm/dist/bin/setup-provider.js [options]
+
+Options:
+  --provider <id>     ID of the provider (e.g. google-genai, openai, anthropic, groq, etc.)
+  --name <name>       Display name for the instance (default: provider displayName)
+  --key <key>         API key (default: loaded from the provider's env variable, e.g. GOOGLE_API_KEY)
+  --model <model>     Model name (default: provider's default model)
+  --type <type>       "generative" | "embedding" (default: "generative")
+  --max-context <num> Max context window tokens (default: provider's default max context)
+  --endpoint <url>    Custom endpoint URL (optional)
+  --all               Auto-detect and seed all providers whose environment variables are set
+  -h, --help          Show this help message
+
+Registered Providers:
+${ProviderRegistry.all()
+  .map((p) => `  - ${p.id} (${p.displayName}) [Env: ${p.envVar || "None"}]`)
+  .join("\n")}
+`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("-h") || args.includes("--help") || args.length === 0) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const options: Record<string, string> = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const nextVal = args[i + 1];
+      if (nextVal && !nextVal.startsWith("--")) {
+        options[key] = nextVal;
+        i++;
+      } else {
+        options[key] = "true";
+      }
+    }
+  }
+
+  if (options.all === "true") {
+    // Seed all providers from environment variables
+    const existing = ProviderManager.list();
+    let seededCount = 0;
+
+    for (const def of ProviderRegistry.all()) {
+      if (!def.envVar) continue;
+      const key = process.env[def.envVar]?.trim();
+      if (!key) continue;
+
+      if (def.capabilities.generative) {
+        const hasGen = existing.some(
+          (p) => p.providerName === def.id && p.type === "generative",
+        );
+        if (!hasGen) {
+          const name = `${def.displayName} (CLI)`;
+          ProviderManager.create(
+            name,
+            def.id,
+            key,
+            def.defaultModel,
+            "generative",
+            def.defaultMaxContext,
+          );
+          console.log(`Created generative instance: ${name}`);
+          seededCount++;
+        }
+      }
+
+      if (def.capabilities.embedding) {
+        const hasEmbed = existing.some(
+          (p) => p.providerName === def.id && p.type === "embedding",
+        );
+        if (!hasEmbed) {
+          const name = `${def.displayName} Embed (CLI)`;
+          ProviderManager.create(
+            name,
+            def.id,
+            key,
+            def.defaultEmbeddingModel || "",
+            "embedding",
+            0,
+          );
+          console.log(`Created embedding instance: ${name}`);
+          seededCount++;
+        }
+      }
+    }
+
+    if (seededCount === 0) {
+      console.log(
+        "No new provider instances seeded. (Either already existed or env vars not set)",
+      );
+    } else {
+      console.log(`Successfully seeded ${seededCount} provider instance(s).`);
+    }
+    process.exit(0);
+  }
+
+  const providerId = options.provider;
+  if (!providerId) {
+    console.error("Error: --provider <id> or --all is required.");
+    printHelp();
+    process.exit(1);
+  }
+
+  const def = ProviderRegistry.get(providerId);
+  if (!def) {
+    console.error(`Error: Provider '${providerId}' is not registered.`);
+    console.error(
+      `Available providers: ${ProviderRegistry.all()
+        .map((p) => p.id)
+        .join(", ")}`,
+    );
+    process.exit(1);
+  }
+
+  const type = (options.type === "embedding" ? "embedding" : "generative") as
+    "generative" | "embedding";
+
+  // Resolve key
+  let apiKey: string | undefined = options.key;
+  if (!apiKey && def.envVar) {
+    apiKey = process.env[def.envVar]?.trim();
+  }
+  if (!apiKey) {
+    console.error(
+      `Error: API Key is required. Please set ${def.envVar || "the environment variable"} or pass --key <apiKey>.`,
+    );
+    process.exit(1);
+  }
+
+  // Resolve model
+  const defaultModel =
+    type === "embedding" ? def.defaultEmbeddingModel || "" : def.defaultModel;
+  const modelName = options.model || defaultModel;
+
+  // Resolve name
+  const name = options.name || `${def.displayName} (CLI)`;
+
+  // Resolve maxContext
+  const maxContext = options["max-context"]
+    ? parseInt(options["max-context"], 10)
+    : type === "embedding"
+      ? 0
+      : def.defaultMaxContext;
+
+  const endpointUrl = options.endpoint;
+
+  const instance = ProviderManager.create(
+    name,
+    def.id,
+    apiKey,
+    modelName,
+    type,
+    maxContext,
+    endpointUrl,
+  );
+
+  console.log(`Successfully created provider instance:`);
+  console.log(JSON.stringify(instance, null, 2));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
--- a/packages/llm/src/config.ts
+++ b/packages/llm/src/config.ts
@@ -1,10 +1,25 @@
 import { z } from "zod";
+import { ProviderRegistry } from "./registry.js";

-const LLMConfigSchema = z.object({
-  GOOGLE_API_KEY: z.string().optional(),
-  OPENROUTER_API_KEY: z.string().optional(),
-  ANTHROPIC_API_KEY: z.string().optional(),
-  OPENAI_API_KEY: z.string().optional(),
-});
+let _config: Record<string, string | undefined> | null = null;

-export const llmConfig = LLMConfigSchema.parse(process.env);
+export function getLlmConfig(): Record<string, string | undefined> {
+  if (!_config) {
+    const envVars: string[] = [];
+    for (const def of ProviderRegistry.all()) {
+      if (def.envVar && !envVars.includes(def.envVar)) {
+        envVars.push(def.envVar);
+      }
+    }
+    const shape: Record<string, z.ZodOptional<z.ZodString>> = {};
+    for (const key of envVars) {
+      shape[key] = z.string().optional();
+    }
+    _config = z.object(shape).parse(process.env);
+  }
+  return _config;
+}
+
+export function resetLlmConfig(): void {
+  _config = null;
+}
--- a/packages/llm/src/db.ts
+++ b/packages/llm/src/db.ts
@@ -0,0 +1,82 @@
+import Database from "better-sqlite3";
+import type BetterSqlite3 from "better-sqlite3";
+import path from "path";
+import fs from "fs";
+
+let _db: BetterSqlite3.Database | null = null;
+let _dbPathOverride: string | null = null;
+
+export function setDbPath(p: string | null) {
+  if (_dbPathOverride !== p) {
+    _db?.close();
+    _db = null;
+    _dbPathOverride = p;
+  }
+}
+
+function findDbPath(): string {
+  if (process.env.OMNIA_DB_PATH) {
+    const dir = path.dirname(process.env.OMNIA_DB_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    return process.env.OMNIA_DB_PATH;
+  }
+  let current = process.cwd();
+  while (current !== "/" && current !== path.parse(current).root) {
+    if (fs.existsSync(path.join(current, "pnpm-workspace.yaml"))) {
+      const dbDir = path.resolve(current, "data");
+      if (!fs.existsSync(dbDir)) {
+        fs.mkdirSync(dbDir, { recursive: true });
+      }
+      return path.join(dbDir, "settings.db");
+    }
+    current = path.dirname(current);
+  }
+  const dbDir = path.resolve(process.cwd(), "data");
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true });
+  }
+  return path.join(dbDir, "settings.db");
+}
+
+function runMigrations(db: BetterSqlite3.Database): void {
+  const version = db.pragma("user_version", { simple: true }) as number;
+
+  if (version < 1) {
+    db.prepare(
+      `
+      CREATE TABLE IF NOT EXISTS provider_instances (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        providerName TEXT NOT NULL,
+        apiKey TEXT NOT NULL,
+        isActive INTEGER NOT NULL DEFAULT 0,
+        modelName TEXT,
+        type TEXT NOT NULL DEFAULT 'generative',
+        maxContext INTEGER,
+        endpointUrl TEXT
+      )
+      `,
+    ).run();
+    db.pragma("user_version = 1");
+  }
+
+  db.prepare(
+    `
+    CREATE TABLE IF NOT EXISTS provider_mappings (
+      task TEXT PRIMARY KEY,
+      providerInstanceId TEXT NOT NULL
+    )
+    `,
+  ).run();
+}
+
+export function getDb(): BetterSqlite3.Database {
+  if (!_db) {
+    const dbPath = _dbPathOverride ?? findDbPath();
+    _db = new Database(dbPath);
+    runMigrations(_db);
+  }
+  return _db;
+}
--- a/packages/llm/src/index.ts
+++ b/packages/llm/src/index.ts
@@ -1,9 +1,14 @@
 export * from "./llm.js";
 export * from "./config.js";
+export * from "./registry.js";
+export * from "./provider-factory.js";
+export * from "./model-lister.js";
+export * from "./provider-manager.js";
 export * from "./providers/google-genai.js";
 export * from "./providers/mock.js";
 export * from "./providers/ollama.js";
 export * from "./providers/openrouter.js";
 export * from "./providers/anthropic.js";
 export * from "./providers/openai.js";
-export * from "./provider-manager.js";
+export * from "./providers/groq.js";
+export * from "./providers/deepseek.js";
--- a/packages/llm/src/llm.ts
+++ b/packages/llm/src/llm.ts
@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ProviderRegistry } from "./registry.js";

 export interface LLMRequest<T extends z.ZodTypeAny> {
  systemPrompt: string;
@@ -68,49 +69,21 @@ export interface ModelProviderMeta {
  defaultEmbeddingModel: string;
 }

-export const AVAILABLE_PROVIDERS: ModelProviderMeta[] = [
-  {
-    id: "google-genai",
-    displayName: "Google Gemini",
-    description: "Official Gemini integration using Google Gen AI SDK",
-    defaultModel: "gemini-2.5-flash",
-    defaultEmbeddingModel: "gemini-embedding-001",
+export function getAvailableProviders(): ModelProviderMeta[] {
+  return ProviderRegistry.all().map((def) => ({
+    id: def.id,
+    displayName: def.displayName,
+    description: def.description,
+    defaultModel: def.defaultModel,
+    defaultEmbeddingModel: def.defaultEmbeddingModel || "",
+  }));
+}
+
+export const AVAILABLE_PROVIDERS = {
+  get count(): number {
+    return getAvailableProviders().length;
  },
-  {
-    id: "openai",
-    displayName: "OpenAI",
-    description: "Official OpenAI integration using @langchain/openai SDK",
-    defaultModel: "gpt-4o-mini",
-    defaultEmbeddingModel: "text-embedding-3-small",
+  toArray(): ModelProviderMeta[] {
+    return getAvailableProviders();
  },
-  {
-    id: "anthropic",
-    displayName: "Anthropic Claude",
-    description: "Official Claude integration using @langchain/anthropic SDK",
-    defaultModel: "claude-3-5-sonnet-latest",
-    defaultEmbeddingModel: "",
-  },
-  {
-    id: "openrouter",
-    displayName: "OpenRouter",
-    description:
-      "Multi-model router supporting Anthropic, OpenAI, DeepSeek, and local models",
-    defaultModel: "google/gemini-2.5-flash",
-    defaultEmbeddingModel: "openai/text-embedding-3-small",
-  },
-  {
-    id: "ollama",
-    displayName: "Ollama",
-    description:
-      "Local model runner — no API key required, uses the Ollama server base URL instead",
-    defaultModel: "llama3.1",
-    defaultEmbeddingModel: "nomic-embed-text",
-  },
-  {
-    id: "mock",
-    displayName: "Mock LLM Provider",
-    description: "Stateless mock provider for testing and offline development",
-    defaultModel: "mock",
-    defaultEmbeddingModel: "mock-embeddings",
-  },
-];
+};
--- a/packages/llm/src/model-lister.ts
+++ b/packages/llm/src/model-lister.ts
@@ -0,0 +1,105 @@
+/**
+ * ModelLister — fetches available models from each provider's REST API.
+ * Results are cached in-memory with a 5-minute TTL to avoid repeated calls.
+ */
+
+import { ProviderRegistry } from "./registry.js";
+
+export interface ModelInfo {
+  id: string;
+  name: string;
+  ownedBy?: string;
+}
+
+interface CacheEntry {
+  models: ModelInfo[];
+  fetchedAt: number;
+}
+
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 10_000;
+
+const modelCache = new Map<string, CacheEntry>();
+
+function cacheKey(
+  providerName: string,
+  apiKey: string,
+  endpointUrl?: string,
+): string {
+  return `${providerName}:${endpointUrl || apiKey}`;
+}
+
+export async function fetchWithTimeout(
+  url: string,
+  init?: RequestInit,
+): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function fetchOpenAICompatibleModels(
+  baseUrl: string,
+  apiKey: string,
+): Promise<ModelInfo[]> {
+  const res = await fetchWithTimeout(`${baseUrl}/models`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      Accept: "application/json",
+    },
+  });
+  if (!res.ok) return [];
+
+  const json = (await res.json()) as {
+    data?: { id: string; owned_by?: string; name?: string }[];
+  };
+
+  return (json.data ?? []).map((m) => ({
+    id: m.id,
+    name: m.name || m.id,
+    ownedBy: m.owned_by,
+  }));
+}
+
+export class ModelLister {
+  static async listModels(
+    providerName: string,
+    apiKey: string,
+    endpointUrl?: string,
+  ): Promise<ModelInfo[]> {
+    const key = cacheKey(providerName, apiKey, endpointUrl);
+    const cached = modelCache.get(key);
+    if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+      return cached.models;
+    }
+
+    const def = ProviderRegistry.get(providerName);
+    let models: ModelInfo[] = [];
+    try {
+      if (def?.listModels) {
+        models = await def.listModels(apiKey, endpointUrl);
+      }
+    } catch {
+      models = [];
+    }
+
+    modelCache.set(key, { models, fetchedAt: Date.now() });
+    return models;
+  }
+
+  static invalidateCache(
+    providerName: string,
+    apiKey: string,
+    endpointUrl?: string,
+  ): void {
+    modelCache.delete(cacheKey(providerName, apiKey, endpointUrl));
+  }
+
+  static clearCache(): void {
+    modelCache.clear();
+  }
+}
--- a/packages/llm/src/provider-factory.ts
+++ b/packages/llm/src/provider-factory.ts
@@ -0,0 +1,21 @@
+import type {
+  ILLMProvider,
+  IEmbeddingProvider,
+  ModelProviderInstance,
+} from "./llm.js";
+import { MockLLMProvider, MockEmbeddingProvider } from "./providers/mock.js";
+import { ProviderRegistry } from "./registry.js";
+
+export function buildLLMProvider(inst: ModelProviderInstance): ILLMProvider {
+  const def = ProviderRegistry.get(inst.providerName);
+  return def?.generativeCreate?.(inst) ?? new MockLLMProvider([]);
+}
+
+export function buildEmbeddingProvider(
+  inst: ModelProviderInstance,
+): IEmbeddingProvider {
+  const def = ProviderRegistry.get(inst.providerName);
+  return (
+    def?.embeddingCreate?.(inst) ?? new MockEmbeddingProvider(inst.modelName)
+  );
+}
--- a/packages/llm/src/provider-manager.ts
+++ b/packages/llm/src/provider-manager.ts
@@ -1,277 +1,16 @@
-import Database from "better-sqlite3";
-import path from "path";
-import fs from "fs";
 import type { ModelProviderInstance } from "./llm.js";
+import { getDb } from "./db.js";
+import { mapRow, type DbRow } from "./row-mapper.js";

-let dbPathOverride: string | null = null;
-let hasBootstrapped = false;
-
-export function setDbPathOverride(p: string | null) {
-  dbPathOverride = p;
-}
-
-export function resetHasBootstrapped() {
-  hasBootstrapped = false;
-}
-
-function getWorkspaceRoot() {
-  let current = process.cwd();
-  while (current !== "/" && current !== path.parse(current).root) {
-    if (
-      fs.existsSync(path.join(current, "pnpm-workspace.yaml")) ||
-      fs.existsSync(path.join(current, "package.json"))
-    ) {
-      if (fs.existsSync(path.join(current, "pnpm-workspace.yaml"))) {
-        return current;
-      }
-    }
-    current = path.dirname(current);
-  }
-  return process.cwd();
-}
-
-function getSettingsDb() {
-  let dbPath: string;
-  if (dbPathOverride) {
-    dbPath = dbPathOverride;
-  } else {
-    const wsRoot = getWorkspaceRoot();
-    const dbDir = path.resolve(wsRoot, "data");
-    if (!fs.existsSync(dbDir)) {
-      fs.mkdirSync(dbDir, { recursive: true });
-    }
-    dbPath = path.join(dbDir, "settings.db");
-  }
-  const db = new Database(dbPath);
-
-  db.prepare(
-    `
-    CREATE TABLE IF NOT EXISTS provider_instances (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      providerName TEXT NOT NULL,
-      apiKey TEXT NOT NULL,
-      isActive INTEGER NOT NULL DEFAULT 0,
-      modelName TEXT,
-      type TEXT NOT NULL DEFAULT 'generative'
-    )
-  `,
-  ).run();
-
-  try {
-    db.prepare(
-      `ALTER TABLE provider_instances ADD COLUMN modelName TEXT`,
-    ).run();
-  } catch {
-    // ignore
-  }
-
-  try {
-    db.prepare(
-      `ALTER TABLE provider_instances ADD COLUMN type TEXT NOT NULL DEFAULT 'generative'`,
-    ).run();
-  } catch {
-    // ignore
-  }
-
-  try {
-    db.prepare(
-      `ALTER TABLE provider_instances ADD COLUMN maxContext INTEGER`,
-    ).run();
-  } catch {
-    // ignore
-  }
-
-  try {
-    db.prepare(
-      `ALTER TABLE provider_instances ADD COLUMN endpointUrl TEXT`,
-    ).run();
-  } catch {
-    // ignore
-  }
-
-  // Auto-bootstrap environment variables if DB contains 0 instances
-  try {
-    if (!hasBootstrapped) {
-      const totalCount = db
-        .prepare(`SELECT COUNT(*) as count FROM provider_instances`)
-        .get() as { count: number };
-      if (totalCount.count === 0) {
-        const googleKey = process.env.GOOGLE_API_KEY;
-        const openRouterKey = process.env.OPENROUTER_API_KEY;
-        const anthropicKey = process.env.ANTHROPIC_API_KEY;
-        const openaiKey = process.env.OPENAI_API_KEY;
-        let hasInsertedGenerative = false;
-        let hasInsertedEmbedding = false;
-
-        if (googleKey && googleKey.trim()) {
-          const id = "provider-default-google";
-          db.prepare(
-            `
-            INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-          `,
-          ).run(
-            id,
-            "Gemini (Env)",
-            "google-genai",
-            googleKey.trim(),
-            1,
-            "gemini-2.5-flash",
-            "generative",
-            32768,
-          );
-          hasInsertedGenerative = true;
-
-          const embedId = "provider-default-google-embed";
-          db.prepare(
-            `
-            INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-          `,
-          ).run(
-            embedId,
-            "Gemini Embed (Env)",
-            "google-genai",
-            googleKey.trim(),
-            1,
-            "gemini-embedding-001",
-            "embedding",
-            0,
-          );
-          hasInsertedEmbedding = true;
-        }
-
-        if (anthropicKey && anthropicKey.trim()) {
-          const id = "provider-default-anthropic";
-          const isActive = hasInsertedGenerative ? 0 : 1;
-          db.prepare(
-            `
-            INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-          `,
-          ).run(
-            id,
-            "Anthropic (Env)",
-            "anthropic",
-            anthropicKey.trim(),
-            isActive,
-            "claude-3-5-sonnet-latest",
-            "generative",
-            200000,
-          );
-          if (isActive === 1) {
-            hasInsertedGenerative = true;
-          }
-        }
-
-        if (openaiKey && openaiKey.trim()) {
-          const id = "provider-default-openai";
-          const isActive = hasInsertedGenerative ? 0 : 1;
-          db.prepare(
-            `
-            INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-          `,
-          ).run(
-            id,
-            "OpenAI (Env)",
-            "openai",
-            openaiKey.trim(),
-            isActive,
-            "gpt-4o-mini",
-            "generative",
-            128000,
-          );
-          if (isActive === 1) {
-            hasInsertedGenerative = true;
-          }
-
-          const embedId = "provider-default-openai-embed";
-          const isEmbedActive = hasInsertedEmbedding ? 0 : 1;
-          db.prepare(
-            `
-            INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-          `,
-          ).run(
-            embedId,
-            "OpenAI Embed (Env)",
-            "openai",
-            openaiKey.trim(),
-            isEmbedActive,
-            "text-embedding-3-small",
-            "embedding",
-            0,
-          );
-          if (isEmbedActive === 1) {
-            hasInsertedEmbedding = true;
-          }
-        }
-
-        if (openRouterKey && openRouterKey.trim()) {
-          const id = "provider-default-openrouter";
-          const isActive = hasInsertedGenerative ? 0 : 1;
-          db.prepare(
-            `
-            INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-          `,
-          ).run(
-            id,
-            "OpenRouter (Env)",
-            "openrouter",
-            openRouterKey.trim(),
-            isActive,
-            "google/gemini-2.5-flash",
-            "generative",
-            32768,
-          );
-        }
-      }
-      hasBootstrapped = true;
-    }
-  } catch {
-    // ignore write lock issues or other DB errors during bootstrap
-  }
-
-  return db;
-}
+export { setDbPath as setDbPathOverride } from "./db.js";

 export class ProviderManager {
  static list(): ModelProviderInstance[] {
-    const db = getSettingsDb();
-    try {
-      const rows = db.prepare(`SELECT * FROM provider_instances`).all() as {
-        id: string;
-        name: string;
-        providerName: string;
-        apiKey: string;
-        isActive: number;
-        modelName?: string;
-        type: string;
-        maxContext?: number;
-        endpointUrl?: string;
-      }[];
-      return rows.map((r) => ({
-        id: r.id,
-        name: r.name,
-        providerName: r.providerName,
-        apiKey: r.apiKey,
-        isActive: r.isActive === 1,
-        modelName: r.modelName || undefined,
-        type: (r.type as "generative" | "embedding") || "generative",
-        maxContext:
-          r.maxContext !== undefined && r.maxContext !== null
-            ? r.maxContext
-            : r.type === "embedding"
-              ? 0
-              : 32768,
-        endpointUrl: r.endpointUrl || undefined,
-      }));
-    } finally {
-      db.close();
-    }
+    const db = getDb();
+    const rows = db
+      .prepare("SELECT * FROM provider_instances")
+      .all() as DbRow[];
+    return rows.map(mapRow);
  }

  static create(
@@ -283,95 +22,77 @@ export class ProviderManager {
    maxContext?: number,
    endpointUrl?: string,
  ): ModelProviderInstance {
-    const db = getSettingsDb();
-    try {
-      const id = "provider-" + Date.now();
-      const activeCount = db
-        .prepare(
-          `SELECT COUNT(*) as count FROM provider_instances WHERE isActive = 1 AND type = ?`,
-        )
-        .get(type) as { count: number };
-      const isActive = activeCount.count === 0 ? 1 : 0;
+    const db = getDb();
+    const id = "provider-" + Date.now();
+    const activeCount = db
+      .prepare(
+        "SELECT COUNT(*) as count FROM provider_instances WHERE isActive = 1 AND type = ?",
+      )
+      .get(type) as { count: number };
+    const isActive = activeCount.count === 0 ? 1 : 0;

-      const actualMaxContext =
-        maxContext !== undefined
-          ? maxContext
-          : type === "generative"
-            ? 32768
-            : 0;
+    const actualMaxContext =
+      maxContext !== undefined ? maxContext : type === "generative" ? 32768 : 0;

-      db.prepare(
-        `
-        INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext, endpointUrl)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-      ).run(
-        id,
-        name,
-        providerName,
-        apiKey,
-        isActive,
-        modelName || null,
-        type,
-        actualMaxContext,
-        endpointUrl || null,
-      );
+    db.prepare(
+      `INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext, endpointUrl)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      id,
+      name,
+      providerName,
+      apiKey,
+      isActive,
+      modelName || null,
+      type,
+      actualMaxContext,
+      endpointUrl || null,
+    );

-      return {
-        id,
-        name,
-        providerName,
-        apiKey,
-        isActive: isActive === 1,
-        modelName,
-        type,
-        maxContext: actualMaxContext,
-        endpointUrl,
-      };
-    } finally {
-      db.close();
-    }
+    return {
+      id,
+      name,
+      providerName,
+      apiKey,
+      isActive: isActive === 1,
+      modelName,
+      type,
+      maxContext: actualMaxContext,
+      endpointUrl,
+    };
  }

  static delete(id: string): void {
-    const db = getSettingsDb();
-    try {
-      const provider = db
-        .prepare(`SELECT isActive, type FROM provider_instances WHERE id = ?`)
-        .get(id) as { isActive: number; type: string } | undefined;
-      db.prepare(`DELETE FROM provider_instances WHERE id = ?`).run(id);
+    const db = getDb();
+    const provider = db
+      .prepare("SELECT isActive, type FROM provider_instances WHERE id = ?")
+      .get(id) as { isActive: number; type: string } | undefined;
+    db.prepare("DELETE FROM provider_instances WHERE id = ?").run(id);

-      if (provider && provider.isActive === 1) {
-        const next = db
-          .prepare(`SELECT id FROM provider_instances WHERE type = ? LIMIT 1`)
-          .get(provider.type) as { id: string } | undefined;
-        if (next) {
-          db.prepare(
-            `UPDATE provider_instances SET isActive = 1 WHERE id = ?`,
-          ).run(next.id);
-        }
+    if (provider && provider.isActive === 1) {
+      const next = db
+        .prepare("SELECT id FROM provider_instances WHERE type = ? LIMIT 1")
+        .get(provider.type) as { id: string } | undefined;
+      if (next) {
+        db.prepare(
+          "UPDATE provider_instances SET isActive = 1 WHERE id = ?",
+        ).run(next.id);
      }
-    } finally {
-      db.close();
    }
  }

  static setActive(id: string): void {
-    const db = getSettingsDb();
-    try {
-      const target = db
-        .prepare(`SELECT type FROM provider_instances WHERE id = ?`)
-        .get(id) as { type: string } | undefined;
-      if (target) {
-        db.prepare(
-          `UPDATE provider_instances SET isActive = 0 WHERE type = ?`,
-        ).run(target.type);
-        db.prepare(
-          `UPDATE provider_instances SET isActive = 1 WHERE id = ?`,
-        ).run(id);
-      }
-    } finally {
-      db.close();
+    const db = getDb();
+    const target = db
+      .prepare("SELECT type FROM provider_instances WHERE id = ?")
+      .get(id) as { type: string } | undefined;
+    if (target) {
+      db.prepare(
+        "UPDATE provider_instances SET isActive = 0 WHERE type = ?",
+      ).run(target.type);
+      db.prepare("UPDATE provider_instances SET isActive = 1 WHERE id = ?").run(
+        id,
+      );
    }
  }

@@ -385,446 +106,97 @@ export class ProviderManager {
    maxContext?: number,
    endpointUrl?: string,
  ): void {
-    const db = getSettingsDb();
-    try {
-      const actualMaxContext =
-        maxContext !== undefined
-          ? maxContext
-          : type === "generative"
-            ? 32768
-            : 0;
-      if (apiKey && apiKey.trim()) {
-        db.prepare(
-          `
-          UPDATE provider_instances
-          SET name = ?, providerName = ?, apiKey = ?, modelName = ?, type = ?, maxContext = ?, endpointUrl = ?
-          WHERE id = ?
-        `,
-        ).run(
-          name,
-          providerName,
-          apiKey,
-          modelName || null,
-          type,
-          actualMaxContext,
-          endpointUrl || null,
-          id,
-        );
-      } else {
-        db.prepare(
-          `
-          UPDATE provider_instances
-          SET name = ?, providerName = ?, modelName = ?, type = ?, maxContext = ?, endpointUrl = ?
-          WHERE id = ?
-        `,
-        ).run(
-          name,
-          providerName,
-          modelName || null,
-          type,
-          actualMaxContext,
-          endpointUrl || null,
-          id,
-        );
-      }
-    } finally {
-      db.close();
+    const db = getDb();
+    const actualMaxContext =
+      maxContext !== undefined ? maxContext : type === "generative" ? 32768 : 0;
+
+    if (apiKey && apiKey.trim()) {
+      db.prepare(
+        `UPDATE provider_instances
+         SET name = ?, providerName = ?, apiKey = ?, modelName = ?, type = ?, maxContext = ?, endpointUrl = ?
+         WHERE id = ?`,
+      ).run(
+        name,
+        providerName,
+        apiKey,
+        modelName || null,
+        type,
+        actualMaxContext,
+        endpointUrl || null,
+        id,
+      );
+    } else {
+      db.prepare(
+        `UPDATE provider_instances
+         SET name = ?, providerName = ?, modelName = ?, type = ?, maxContext = ?, endpointUrl = ?
+         WHERE id = ?`,
+      ).run(
+        name,
+        providerName,
+        modelName || null,
+        type,
+        actualMaxContext,
+        endpointUrl || null,
+        id,
+      );
    }
  }

  static getActive(
    type: "generative" | "embedding" = "generative",
  ): ModelProviderInstance | null {
-    const db = getSettingsDb();
+    const db = getDb();
    try {
      const row = db
        .prepare(
-          `SELECT * FROM provider_instances WHERE isActive = 1 AND type = ?`,
+          "SELECT * FROM provider_instances WHERE isActive = 1 AND type = ?",
        )
-        .get(type) as
-        | {
-            id: string;
-            name: string;
-            providerName: string;
-            apiKey: string;
-            isActive: number;
-            modelName?: string;
-            type: string;
-            maxContext?: number;
-            endpointUrl?: string;
-          }
-        | undefined;
+        .get(type) as DbRow | undefined;

-      if (!row) {
-        const totalCount = db
-          .prepare(`SELECT COUNT(*) as count FROM provider_instances`)
-          .get() as { count: number };
-        if (totalCount.count === 0) {
-          const googleKey = process.env.GOOGLE_API_KEY;
-          const openRouterKey = process.env.OPENROUTER_API_KEY;
-          const anthropicKey = process.env.ANTHROPIC_API_KEY;
-          const openaiKey = process.env.OPENAI_API_KEY;
-          let hasInsertedGenerative = false;
-          let hasInsertedEmbedding = false;
-
-          if (googleKey && googleKey.trim()) {
-            const id = "provider-default-google";
-            db.prepare(
-              `
-              INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `,
-            ).run(
-              id,
-              "Gemini (Env)",
-              "google-genai",
-              googleKey.trim(),
-              1,
-              "gemini-2.5-flash",
-              "generative",
-              32768,
-            );
-            hasInsertedGenerative = true;
-
-            const embedId = "provider-default-google-embed";
-            db.prepare(
-              `
-              INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `,
-            ).run(
-              embedId,
-              "Gemini Embed (Env)",
-              "google-genai",
-              googleKey.trim(),
-              1,
-              "gemini-embedding-001",
-              "embedding",
-              0,
-            );
-            hasInsertedEmbedding = true;
-          }
-
-          if (anthropicKey && anthropicKey.trim()) {
-            const id = "provider-default-anthropic";
-            const isActive = hasInsertedGenerative ? 0 : 1;
-            db.prepare(
-              `
-              INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `,
-            ).run(
-              id,
-              "Anthropic (Env)",
-              "anthropic",
-              anthropicKey.trim(),
-              isActive,
-              "claude-3-5-sonnet-latest",
-              "generative",
-              200000,
-            );
-            if (isActive === 1) {
-              hasInsertedGenerative = true;
-            }
-          }
-
-          if (openaiKey && openaiKey.trim()) {
-            const id = "provider-default-openai";
-            const isActive = hasInsertedGenerative ? 0 : 1;
-            db.prepare(
-              `
-              INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `,
-            ).run(
-              id,
-              "OpenAI (Env)",
-              "openai",
-              openaiKey.trim(),
-              isActive,
-              "gpt-4o-mini",
-              "generative",
-              128000,
-            );
-            if (isActive === 1) {
-              hasInsertedGenerative = true;
-            }
-
-            const embedId = "provider-default-openai-embed";
-            const isEmbedActive = hasInsertedEmbedding ? 0 : 1;
-            db.prepare(
-              `
-              INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `,
-            ).run(
-              embedId,
-              "OpenAI Embed (Env)",
-              "openai",
-              openaiKey.trim(),
-              isEmbedActive,
-              "text-embedding-3-small",
-              "embedding",
-              0,
-            );
-            if (isEmbedActive === 1) {
-              hasInsertedEmbedding = true;
-            }
-          }
-
-          if (openRouterKey && openRouterKey.trim()) {
-            const id = "provider-default-openrouter";
-            const isActive = hasInsertedGenerative ? 0 : 1;
-            db.prepare(
-              `
-              INSERT INTO provider_instances (id, name, providerName, apiKey, isActive, modelName, type, maxContext)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            `,
-            ).run(
-              id,
-              "OpenRouter (Env)",
-              "openrouter",
-              openRouterKey.trim(),
-              isActive,
-              "google/gemini-2.5-flash",
-              "generative",
-              32768,
-            );
-          }
-
-          const retryRow = db
-            .prepare(
-              `SELECT * FROM provider_instances WHERE isActive = 1 AND type = ?`,
-            )
-            .get(type) as
-            | {
-                id: string;
-                name: string;
-                providerName: string;
-                apiKey: string;
-                isActive: number;
-                modelName?: string;
-                type: string;
-                maxContext?: number;
-                endpointUrl?: string;
-              }
-            | undefined;
-
-          if (retryRow) {
-            return {
-              id: retryRow.id,
-              name: retryRow.name,
-              providerName: retryRow.providerName,
-              apiKey: retryRow.apiKey,
-              isActive: true,
-              modelName: retryRow.modelName || undefined,
-              type: retryRow.type as "generative" | "embedding",
-              maxContext:
-                retryRow.maxContext !== undefined &&
-                retryRow.maxContext !== null
-                  ? retryRow.maxContext
-                  : retryRow.type === "embedding"
-                    ? 0
-                    : 32768,
-              endpointUrl: retryRow.endpointUrl || undefined,
-            };
-          }
-        }
-
-        // If there's no active row but some rows exist, return the first one as active, or update it
-        const firstRow = db
-          .prepare(`SELECT * FROM provider_instances WHERE type = ? LIMIT 1`)
-          .get(type) as
-          | {
-              id: string;
-              name: string;
-              providerName: string;
-              apiKey: string;
-              isActive: number;
-              modelName?: string;
-              type: string;
-              maxContext?: number;
-              endpointUrl?: string;
-            }
-          | undefined;
-        if (firstRow) {
-          db.prepare(
-            `UPDATE provider_instances SET isActive = 1 WHERE id = ?`,
-          ).run(firstRow.id);
-          return {
-            id: firstRow.id,
-            name: firstRow.name,
-            providerName: firstRow.providerName,
-            apiKey: firstRow.apiKey,
-            isActive: true,
-            modelName: firstRow.modelName || undefined,
-            type: firstRow.type as "generative" | "embedding",
-            maxContext:
-              firstRow.maxContext !== undefined && firstRow.maxContext !== null
-                ? firstRow.maxContext
-                : firstRow.type === "embedding"
-                  ? 0
-                  : 32768,
-            endpointUrl: firstRow.endpointUrl || undefined,
-          };
-        }
-        return null;
+      if (row) {
+        return mapRow(row);
      }

-      return {
-        id: row.id,
-        name: row.name,
-        providerName: row.providerName,
-        apiKey: row.apiKey,
-        isActive: true,
-        modelName: row.modelName || undefined,
-        type: (row.type as "generative" | "embedding") || "generative",
-        maxContext:
-          row.maxContext !== undefined && row.maxContext !== null
-            ? row.maxContext
-            : row.type === "embedding"
-              ? 0
-              : 32768,
-        endpointUrl: row.endpointUrl || undefined,
-      };
-    } catch {
-      const googleKey = process.env.GOOGLE_API_KEY;
-      if (type === "embedding") {
-        if (googleKey && googleKey.trim()) {
-          return {
-            id: "provider-default-env-embed-fallback",
-            name: "Gemini Embed (Env Fallback)",
-            providerName: "google-genai",
-            apiKey: googleKey.trim(),
-            isActive: true,
-            modelName: "gemini-embedding-001",
-            type: "embedding",
-            maxContext: 0,
-          };
-        }
-        const openaiKey = process.env.OPENAI_API_KEY;
-        if (openaiKey && openaiKey.trim()) {
-          return {
-            id: "provider-default-env-embed-fallback",
-            name: "OpenAI Embed (Env Fallback)",
-            providerName: "openai",
-            apiKey: openaiKey.trim(),
-            isActive: true,
-            modelName: "text-embedding-3-small",
-            type: "embedding",
-            maxContext: 0,
-          };
-        }
-        return null;
+      const firstRow = db
+        .prepare("SELECT * FROM provider_instances WHERE type = ? LIMIT 1")
+        .get(type) as DbRow | undefined;
+
+      if (firstRow) {
+        db.prepare(
+          "UPDATE provider_instances SET isActive = 1 WHERE id = ?",
+        ).run(firstRow.id);
+        return mapRow(firstRow);
      }

-      // generative fallback
-      if (googleKey && googleKey.trim()) {
-        return {
-          id: "provider-default-env-fallback",
-          name: "Gemini (Env Fallback)",
-          providerName: "google-genai",
-          apiKey: googleKey.trim(),
-          isActive: true,
-          modelName: "gemini-2.5-flash",
-          type: "generative",
-          maxContext: 32768,
-        };
-      }
-      const openaiKey = process.env.OPENAI_API_KEY;
-      if (openaiKey && openaiKey.trim()) {
-        return {
-          id: "provider-default-env-fallback",
-          name: "OpenAI (Env Fallback)",
-          providerName: "openai",
-          apiKey: openaiKey.trim(),
-          isActive: true,
-          modelName: "gpt-4o-mini",
-          type: "generative",
-          maxContext: 128000,
-        };
-      }
-      const anthropicKey = process.env.ANTHROPIC_API_KEY;
-      if (anthropicKey && anthropicKey.trim()) {
-        return {
-          id: "provider-default-env-fallback",
-          name: "Anthropic (Env Fallback)",
-          providerName: "anthropic",
-          apiKey: anthropicKey.trim(),
-          isActive: true,
-          modelName: "claude-3-5-sonnet-latest",
-          type: "generative",
-          maxContext: 200000,
-        };
-      }
-      const openRouterKey = process.env.OPENROUTER_API_KEY;
-      if (openRouterKey && openRouterKey.trim()) {
-        return {
-          id: "provider-default-env-fallback",
-          name: "OpenRouter (Env Fallback)",
-          providerName: "openrouter",
-          apiKey: openRouterKey.trim(),
-          isActive: true,
-          modelName: "google/gemini-2.5-flash",
-          type: "generative",
-          maxContext: 32768,
-        };
-      }
      return null;
-    } finally {
-      db.close();
+    } catch {
+      return null;
    }
  }

  static getMappings(): Record<string, string> {
-    const db = getSettingsDb();
-    try {
-      db.prepare(
-        `
-        CREATE TABLE IF NOT EXISTS provider_mappings (
-          task TEXT PRIMARY KEY,
-          providerInstanceId TEXT NOT NULL
-        )
-      `,
-      ).run();
-      const rows = db.prepare(`SELECT * FROM provider_mappings`).all() as {
-        task: string;
-        providerInstanceId: string;
-      }[];
-      const mappings: Record<string, string> = {};
-      for (const row of rows) {
-        mappings[row.task] = row.providerInstanceId;
-      }
-      return mappings;
-    } finally {
-      db.close();
+    const db = getDb();
+    const rows = db.prepare("SELECT * FROM provider_mappings").all() as {
+      task: string;
+      providerInstanceId: string;
+    }[];
+    const mappings: Record<string, string> = {};
+    for (const row of rows) {
+      mappings[row.task] = row.providerInstanceId;
    }
+    return mappings;
  }

  static setMapping(task: string, providerInstanceId: string): void {
-    const db = getSettingsDb();
-    try {
+    const db = getDb();
+    if (!providerInstanceId) {
+      db.prepare("DELETE FROM provider_mappings WHERE task = ?").run(task);
+    } else {
      db.prepare(
-        `
-        CREATE TABLE IF NOT EXISTS provider_mappings (
-          task TEXT PRIMARY KEY,
-          providerInstanceId TEXT NOT NULL
-        )
-      `,
-      ).run();
-      if (!providerInstanceId) {
-        db.prepare(`DELETE FROM provider_mappings WHERE task = ?`).run(task);
-      } else {
-        db.prepare(
-          `
-          INSERT INTO provider_mappings (task, providerInstanceId)
-          VALUES (?, ?)
-          ON CONFLICT(task) DO UPDATE SET providerInstanceId = excluded.providerInstanceId
-        `,
-        ).run(task, providerInstanceId);
-      }
-    } finally {
-      db.close();
+        `INSERT INTO provider_mappings (task, providerInstanceId)
+         VALUES (?, ?)
+         ON CONFLICT(task) DO UPDATE SET providerInstanceId = excluded.providerInstanceId`,
+      ).run(task, providerInstanceId);
    }
  }
 }
--- a/packages/llm/src/providers/anthropic.ts
+++ b/packages/llm/src/providers/anthropic.ts
@@ -1,27 +1,86 @@
-import { z } from "zod";
 import { ChatAnthropic } from "@langchain/anthropic";
-import {
-  ILLMProvider,
-  LLMRequest,
-  LLMResponse,
-  LLMCallRecord,
-} from "../llm.js";
-import { llmConfig } from "../config.js";
-import { ProviderManager } from "../provider-manager.js";
+import { ILLMProvider } from "../llm.js";
+import type { ModelProviderInstance } from "../llm.js";
+import { BaseLLMProvider, resolveCredentials } from "../base-provider.js";
+import { registerProvider, registerGenerative } from "../registry.js";
+import { fetchWithTimeout, type ModelInfo } from "../model-lister.js";

-export class AnthropicProvider implements ILLMProvider {
-  static readonly providerId = "anthropic";
-  static readonly displayName = "Anthropic Claude";
-  static readonly description =
-    "Official Claude integration using @langchain/anthropic SDK";
-  static readonly defaultModel = "claude-3-5-sonnet-latest";
+async function fetchAnthropicModels(apiKey: string): Promise<ModelInfo[]> {
+  const models: ModelInfo[] = [];
+  let afterId: string | undefined;
+
+  do {
+    const url = new URL("https://api.anthropic.com/v1/models");
+    url.searchParams.set("limit", "1000");
+    if (afterId) {
+      url.searchParams.set("after_id", afterId);
+    }
+
+    const res = await fetchWithTimeout(url.toString(), {
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        Accept: "application/json",
+      },
+    });
+    if (!res.ok) return models;
+
+    const json = (await res.json()) as {
+      data?: { id: string; display_name?: string }[];
+      has_more?: boolean;
+      last_id?: string;
+    };
+
+    for (const m of json.data ?? []) {
+      models.push({ id: m.id, name: m.display_name || m.id });
+    }
+
+    afterId = json.has_more ? json.last_id : undefined;
+  } while (afterId);
+
+  return models;
+}
+
+export class AnthropicProvider extends BaseLLMProvider {
+  static {
+    registerProvider({
+      id: "anthropic",
+      displayName: "Anthropic Claude",
+      description: "Official Claude integration using @langchain/anthropic SDK",
+      envVar: "ANTHROPIC_API_KEY",
+      capabilities: { generative: true, embedding: false },
+      defaultModel: "claude-3-5-sonnet-latest",
+      defaultMaxContext: 200000,
+      fallbackPriority: 2,
+      listModels: fetchAnthropicModels,
+    });
+    registerGenerative(
+      "anthropic",
+      (inst: ModelProviderInstance) =>
+        new AnthropicProvider(
+          inst.apiKey,
+          inst.modelName,
+          inst.name,
+          inst.maxContext,
+        ),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): ILLMProvider {
+    return new AnthropicProvider(
+      inst.apiKey,
+      inst.modelName,
+      inst.name,
+      inst.maxContext,
+    );
+  }

  providerName = "Anthropic";
-  private model: ChatAnthropic;
-  private modelNameUsed: string;
-  private providerInstanceName?: string;
-  private maxContextUsed?: number;
-  lastCalls: LLMCallRecord[] = [];
+  protected readonly model: ChatAnthropic;
+  protected modelNameUsed: string;
+  protected providerInstanceName?: string;
+  protected maxContextUsed?: number;
+  protected defaultMaxContext = 200000;

  constructor(
    apiKey?: string,
@@ -29,86 +88,29 @@ export class AnthropicProvider implements ILLMProvider {
    providerInstanceName?: string,
    maxContext?: number,
  ) {
-    let key = apiKey;
-    let model = modelName;
-    this.providerInstanceName = providerInstanceName;
-    this.maxContextUsed = maxContext;
-
-    if (!key) {
-      const active = ProviderManager.getActive("generative");
-      if (active && active.providerName === AnthropicProvider.providerId) {
-        key = active.apiKey;
-        if (!model) {
-          model = active.modelName;
-        }
-        if (!this.providerInstanceName) {
-          this.providerInstanceName = active.name;
-        }
-        if (this.maxContextUsed === undefined) {
-          this.maxContextUsed = active.maxContext;
-        }
-      }
-    }
-
-    if (!key) {
-      key = llmConfig.ANTHROPIC_API_KEY;
-      if (!this.providerInstanceName && key) {
-        this.providerInstanceName = "Environment Variable";
-      }
-    }
-
+    super();
+    const {
+      key,
+      model,
+      providerInstanceName: resolvedName,
+      maxContext: resolvedMax,
+    } = resolveCredentials({
+      explicitKey: apiKey,
+      explicitModel: modelName,
+      explicitProviderInstanceName: providerInstanceName,
+      explicitMaxContext: maxContext,
+      providerId: "anthropic",
+      envVarName: "ANTHROPIC_API_KEY",
+      type: "generative",
+    });
    if (!key) {
      throw new Error(
        "ANTHROPIC_API_KEY is required to initialize AnthropicProvider",
      );
    }
-
-    this.modelNameUsed = model || AnthropicProvider.defaultModel;
-    this.model = new ChatAnthropic({
-      apiKey: key,
-      model: this.modelNameUsed,
-    });
-  }
-
-  async generateStructuredResponse<T extends z.ZodTypeAny>(
-    request: LLMRequest<T>,
-  ): Promise<LLMResponse<z.infer<T>>> {
-    const structuredModel = this.model.withStructuredOutput(request.schema, {
-      includeRaw: true,
-    });
-    const result = (await structuredModel.invoke([
-      { role: "system", content: request.systemPrompt },
-      { role: "user", content: request.userContext },
-    ])) as unknown as {
-      parsed?: z.infer<T>;
-      raw?: {
-        usage_metadata?: {
-          input_tokens?: number;
-          output_tokens?: number;
-          total_tokens?: number;
-        };
-      };
-    };
-
-    const parsed = result?.parsed;
-    const raw = result?.raw;
-
-    const usage = {
-      inputTokens: raw?.usage_metadata?.input_tokens || 0,
-      outputTokens: raw?.usage_metadata?.output_tokens || 0,
-      totalTokens: raw?.usage_metadata?.total_tokens || 0,
-      modelName: this.modelNameUsed,
-      providerInstanceName: this.providerInstanceName || "Default",
-      maxContext:
-        this.maxContextUsed !== undefined ? this.maxContextUsed : 200000,
-    };
-
-    this.lastCalls.push({
-      systemPrompt: request.systemPrompt,
-      userContext: request.userContext,
-      usage,
-    });
-
-    return { success: true, data: parsed, usage };
+    this.providerInstanceName = resolvedName;
+    this.maxContextUsed = resolvedMax;
+    this.modelNameUsed = model || "claude-3-5-sonnet-latest";
+    this.model = new ChatAnthropic({ apiKey: key, model: this.modelNameUsed });
  }
 }
--- a/packages/llm/src/providers/deepseek.ts
+++ b/packages/llm/src/providers/deepseek.ts
@@ -0,0 +1,82 @@
+import { ChatDeepSeek } from "@langchain/deepseek";
+import { ILLMProvider } from "../llm.js";
+import type { ModelProviderInstance } from "../llm.js";
+import { BaseLLMProvider, resolveCredentials } from "../base-provider.js";
+import { registerProvider, registerGenerative } from "../registry.js";
+import { fetchOpenAICompatibleModels } from "../model-lister.js";
+
+export class DeepSeekProvider extends BaseLLMProvider {
+  static {
+    registerProvider({
+      id: "deepseek",
+      displayName: "DeepSeek",
+      description:
+        "Official DeepSeek integration using @langchain/deepseek SDK",
+      envVar: "DEEPSEEK_API_KEY",
+      capabilities: { generative: true, embedding: false },
+      defaultModel: "deepseek-chat",
+      defaultMaxContext: 64000,
+      fallbackPriority: 4,
+      listModels: (apiKey) =>
+        fetchOpenAICompatibleModels("https://api.deepseek.com", apiKey),
+    });
+    registerGenerative(
+      "deepseek",
+      (inst: ModelProviderInstance) =>
+        new DeepSeekProvider(
+          inst.apiKey,
+          inst.modelName,
+          inst.name,
+          inst.maxContext,
+        ),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): ILLMProvider {
+    return new DeepSeekProvider(
+      inst.apiKey,
+      inst.modelName,
+      inst.name,
+      inst.maxContext,
+    );
+  }
+
+  providerName = "DeepSeek";
+  protected readonly model: ChatDeepSeek;
+  protected modelNameUsed: string;
+  protected providerInstanceName?: string;
+  protected maxContextUsed?: number;
+  protected defaultMaxContext = 64000;
+
+  constructor(
+    apiKey?: string,
+    modelName?: string,
+    providerInstanceName?: string,
+    maxContext?: number,
+  ) {
+    super();
+    const {
+      key,
+      model,
+      providerInstanceName: resolvedName,
+      maxContext: resolvedMax,
+    } = resolveCredentials({
+      explicitKey: apiKey,
+      explicitModel: modelName,
+      explicitProviderInstanceName: providerInstanceName,
+      explicitMaxContext: maxContext,
+      providerId: "deepseek",
+      envVarName: "DEEPSEEK_API_KEY",
+      type: "generative",
+    });
+    if (!key) {
+      throw new Error(
+        "DEEPSEEK_API_KEY is required to initialize DeepSeekProvider",
+      );
+    }
+    this.providerInstanceName = resolvedName;
+    this.maxContextUsed = resolvedMax;
+    this.modelNameUsed = model || "deepseek-chat";
+    this.model = new ChatDeepSeek({ apiKey: key, model: this.modelNameUsed });
+  }
+}
--- a/packages/llm/src/providers/google-genai.ts
+++ b/packages/llm/src/providers/google-genai.ts
@@ -1,31 +1,96 @@
-import { z } from "zod";
 import {
  ChatGoogleGenerativeAI,
  GoogleGenerativeAIEmbeddings,
 } from "@langchain/google-genai";
-import {
+import type {
  ILLMProvider,
-  LLMRequest,
-  LLMResponse,
-  LLMCallRecord,
  IEmbeddingProvider,
+  ModelProviderInstance,
 } from "../llm.js";
-import { llmConfig } from "../config.js";
+import {
+  registerProvider,
+  registerGenerative,
+  registerEmbedding,
+} from "../registry.js";
+import { fetchWithTimeout, type ModelInfo } from "../model-lister.js";
+import { BaseLLMProvider, resolveCredentials } from "../base-provider.js";
+import { getLlmConfig } from "../config.js";
 import { ProviderManager } from "../provider-manager.js";

-export class GeminiProvider implements ILLMProvider {
-  static readonly providerId = "google-genai";
-  static readonly displayName = "Google Gemini";
-  static readonly description =
-    "Official Gemini integration using Google Gen AI SDK";
-  static readonly defaultModel = "gemini-2.5-flash";
+async function fetchGeminiModels(apiKey: string): Promise<ModelInfo[]> {
+  const models: ModelInfo[] = [];
+  let pageToken: string | undefined;
+
+  do {
+    const url = new URL(
+      "https://generativelanguage.googleapis.com/v1beta/models",
+    );
+    url.searchParams.set("key", apiKey);
+    url.searchParams.set("pageSize", "100");
+    if (pageToken) {
+      url.searchParams.set("pageToken", pageToken);
+    }
+
+    const res = await fetchWithTimeout(url.toString());
+    if (!res.ok) return models;
+
+    const json = (await res.json()) as {
+      models?: { name: string; displayName?: string }[];
+      nextPageToken?: string;
+    };
+
+    for (const m of json.models ?? []) {
+      const id = m.name.replace(/^models\//, "");
+      models.push({ id, name: m.displayName || id });
+    }
+
+    pageToken = json.nextPageToken;
+  } while (pageToken);
+
+  return models;
+}
+
+export class GeminiProvider extends BaseLLMProvider {
+  static {
+    registerProvider({
+      id: "google-genai",
+      displayName: "Google Gemini",
+      description: "Official Gemini integration using Google Gen AI SDK",
+      envVar: "GOOGLE_API_KEY",
+      capabilities: { generative: true, embedding: true },
+      defaultModel: "gemini-2.5-flash",
+      defaultEmbeddingModel: "gemini-embedding-001",
+      defaultMaxContext: 32768,
+      fallbackPriority: 0,
+      listModels: fetchGeminiModels,
+    });
+    registerGenerative(
+      "google-genai",
+      (inst: ModelProviderInstance) =>
+        new GeminiProvider(
+          inst.apiKey,
+          inst.modelName,
+          inst.name,
+          inst.maxContext,
+        ),
+    );
+  }

  providerName = "Gemini";
-  private model: ChatGoogleGenerativeAI;
-  private modelNameUsed: string;
-  private providerInstanceName?: string;
-  private maxContextUsed?: number;
-  lastCalls: LLMCallRecord[] = [];
+  protected readonly model: ChatGoogleGenerativeAI;
+  protected modelNameUsed: string;
+  protected providerInstanceName?: string;
+  protected maxContextUsed?: number;
+  protected readonly defaultMaxContext = 32768;
+
+  static create(inst: ModelProviderInstance): ILLMProvider {
+    return new GeminiProvider(
+      inst.apiKey,
+      inst.modelName,
+      inst.name,
+      inst.maxContext,
+    );
+  }

  constructor(
    apiKey?: string,
@@ -33,113 +98,66 @@ export class GeminiProvider implements ILLMProvider {
    providerInstanceName?: string,
    maxContext?: number,
  ) {
-    let key = apiKey;
-    let model = modelName;
-    this.providerInstanceName = providerInstanceName;
-    this.maxContextUsed = maxContext;
-
-    if (!key) {
-      const active = ProviderManager.getActive("generative");
-      if (active && active.providerName === GeminiProvider.providerId) {
-        key = active.apiKey;
-        if (!model) {
-          model = active.modelName;
-        }
-        if (!this.providerInstanceName) {
-          this.providerInstanceName = active.name;
-        }
-        if (this.maxContextUsed === undefined) {
-          this.maxContextUsed = active.maxContext;
-        }
-      }
-    }
-
-    if (!key) {
-      key = llmConfig.GOOGLE_API_KEY;
-      if (!this.providerInstanceName && key) {
-        this.providerInstanceName = "Environment Variable";
-      }
-    }
-
+    super();
+    const {
+      key,
+      model,
+      providerInstanceName: pn,
+      maxContext: mc,
+    } = resolveCredentials({
+      explicitKey: apiKey,
+      explicitModel: modelName,
+      explicitProviderInstanceName: providerInstanceName,
+      explicitMaxContext: maxContext,
+      providerId: "google-genai",
+      envVarName: "GOOGLE_API_KEY",
+      type: "generative",
+    });
    if (!key) {
      throw new Error(
        "GOOGLE_API_KEY is required to initialize GeminiProvider",
      );
    }
-
+    this.providerInstanceName = pn;
+    this.maxContextUsed = mc;
    this.modelNameUsed = model || "gemini-2.5-flash";
    this.model = new ChatGoogleGenerativeAI({
      apiKey: key,
      model: this.modelNameUsed,
    });
  }
-
-  async generateStructuredResponse<T extends z.ZodTypeAny>(
-    request: LLMRequest<T>,
-  ): Promise<LLMResponse<z.infer<T>>> {
-    const structuredModel = this.model.withStructuredOutput(request.schema, {
-      includeRaw: true,
-    });
-    const result = (await structuredModel.invoke([
-      { role: "system", content: request.systemPrompt },
-      { role: "user", content: request.userContext },
-    ])) as unknown as {
-      parsed?: z.infer<T>;
-      raw?: {
-        usage_metadata?: {
-          input_tokens?: number;
-          output_tokens?: number;
-          total_tokens?: number;
-        };
-      };
-    };
-
-    const parsed = result?.parsed;
-    const raw = result?.raw;
-
-    const usage = {
-      inputTokens: raw?.usage_metadata?.input_tokens || 0,
-      outputTokens: raw?.usage_metadata?.output_tokens || 0,
-      totalTokens: raw?.usage_metadata?.total_tokens || 0,
-      modelName: this.modelNameUsed,
-      providerInstanceName: this.providerInstanceName || "Default",
-      maxContext:
-        this.maxContextUsed !== undefined ? this.maxContextUsed : 32768,
-    };
-
-    this.lastCalls.push({
-      systemPrompt: request.systemPrompt,
-      userContext: request.userContext,
-      usage,
-    });
-
-    return { success: true, data: parsed, usage };
-  }
 }

 export class GeminiEmbeddingProvider implements IEmbeddingProvider {
-  static readonly providerId = "google-genai";
-  static readonly displayName = "Google Gemini Embeddings";
+  static {
+    registerEmbedding(
+      "google-genai",
+      (inst: ModelProviderInstance) =>
+        new GeminiEmbeddingProvider(inst.apiKey, inst.modelName),
+    );
+  }

  providerName = "Gemini";
  private model: GoogleGenerativeAIEmbeddings;

+  static create(inst: ModelProviderInstance): IEmbeddingProvider {
+    return new GeminiEmbeddingProvider(inst.apiKey, inst.modelName);
+  }
+
  constructor(apiKey?: string, modelName?: string) {
    let key = apiKey;
    let model = modelName;

    if (!key) {
      const active = ProviderManager.getActive("embedding");
-      if (active) {
+      if (active && active.providerName === "google-genai") {
        key = active.apiKey;
-        if (!model) {
-          model = active.modelName;
-        }
+        if (!model) model = active.modelName;
      }
    }

    if (!key) {
-      key = llmConfig.GOOGLE_API_KEY;
+      key = getLlmConfig().GOOGLE_API_KEY;
    }

    if (!key) {
--- a/packages/llm/src/providers/groq.ts
+++ b/packages/llm/src/providers/groq.ts
@@ -0,0 +1,79 @@
+import { ChatGroq } from "@langchain/groq";
+import { ILLMProvider } from "../llm.js";
+import type { ModelProviderInstance } from "../llm.js";
+import { BaseLLMProvider, resolveCredentials } from "../base-provider.js";
+import { registerProvider, registerGenerative } from "../registry.js";
+import { fetchOpenAICompatibleModels } from "../model-lister.js";
+
+export class GroqProvider extends BaseLLMProvider {
+  static {
+    registerProvider({
+      id: "groq",
+      displayName: "Groq",
+      description: "Official Groq integration using @langchain/groq SDK",
+      envVar: "GROQ_API_KEY",
+      capabilities: { generative: true, embedding: false },
+      defaultModel: "llama-3.3-70b-versatile",
+      defaultMaxContext: 8192,
+      fallbackPriority: 3,
+      listModels: (apiKey) =>
+        fetchOpenAICompatibleModels("https://api.groq.com/openai/v1", apiKey),
+    });
+    registerGenerative(
+      "groq",
+      (inst: ModelProviderInstance) =>
+        new GroqProvider(
+          inst.apiKey,
+          inst.modelName,
+          inst.name,
+          inst.maxContext,
+        ),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): ILLMProvider {
+    return new GroqProvider(
+      inst.apiKey,
+      inst.modelName,
+      inst.name,
+      inst.maxContext,
+    );
+  }
+
+  providerName = "Groq";
+  protected readonly model: ChatGroq;
+  protected modelNameUsed: string;
+  protected providerInstanceName?: string;
+  protected maxContextUsed?: number;
+  protected defaultMaxContext = 8192;
+
+  constructor(
+    apiKey?: string,
+    modelName?: string,
+    providerInstanceName?: string,
+    maxContext?: number,
+  ) {
+    super();
+    const {
+      key,
+      model,
+      providerInstanceName: resolvedName,
+      maxContext: resolvedMax,
+    } = resolveCredentials({
+      explicitKey: apiKey,
+      explicitModel: modelName,
+      explicitProviderInstanceName: providerInstanceName,
+      explicitMaxContext: maxContext,
+      providerId: "groq",
+      envVarName: "GROQ_API_KEY",
+      type: "generative",
+    });
+    if (!key) {
+      throw new Error("GROQ_API_KEY is required to initialize GroqProvider");
+    }
+    this.providerInstanceName = resolvedName;
+    this.maxContextUsed = resolvedMax;
+    this.modelNameUsed = model || "llama-3.3-70b-versatile";
+    this.model = new ChatGroq({ apiKey: key, model: this.modelNameUsed });
+  }
+}
--- a/packages/llm/src/providers/mock.ts
+++ b/packages/llm/src/providers/mock.ts
@@ -6,13 +6,33 @@ import {
  LLMCallRecord,
  IEmbeddingProvider,
 } from "../llm.js";
+import type { ModelProviderInstance } from "../llm.js";
+import {
+  registerProvider,
+  registerGenerative,
+  registerEmbedding,
+} from "../registry.js";

 export class MockLLMProvider implements ILLMProvider {
-  static readonly providerId = "mock";
-  static readonly displayName = "Mock LLM Provider";
-  static readonly description =
-    "Stateless mock provider for testing and offline development";
-  static readonly defaultModel = "mock";
+  static {
+    registerProvider({
+      id: "mock",
+      displayName: "Mock LLM Provider",
+      description:
+        "Stateless mock provider for testing and offline development",
+      capabilities: { generative: true, embedding: true },
+      defaultModel: "mock",
+      defaultEmbeddingModel: "mock-embeddings",
+      defaultMaxContext: 0,
+      fallbackPriority: 1000,
+      listModels: () => Promise.resolve([{ id: "mock", name: "Mock Model" }]),
+    });
+    registerGenerative("mock", () => new MockLLMProvider([]));
+  }
+
+  static create(inst: ModelProviderInstance): ILLMProvider {
+    return new MockLLMProvider([]);
+  }

  providerName = "mock";
  private callCount = 0;
@@ -46,7 +66,17 @@ export class MockLLMProvider implements ILLMProvider {
 }

 export class MockEmbeddingProvider implements IEmbeddingProvider {
-  static readonly providerId = "mock";
+  static {
+    registerEmbedding(
+      "mock",
+      (inst: ModelProviderInstance) =>
+        new MockEmbeddingProvider(inst.modelName),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): IEmbeddingProvider {
+    return new MockEmbeddingProvider(inst.modelName);
+  }

  providerName = "mock";

--- a/packages/llm/src/providers/ollama.ts
+++ b/packages/llm/src/providers/ollama.ts
@@ -1,27 +1,72 @@
-import { z } from "zod";
 import { ChatOllama, OllamaEmbeddings } from "@langchain/ollama";
-import {
-  ILLMProvider,
-  LLMRequest,
-  LLMResponse,
-  LLMCallRecord,
-  IEmbeddingProvider,
-} from "../llm.js";
+import { ILLMProvider, IEmbeddingProvider } from "../llm.js";
+import type { ModelProviderInstance } from "../llm.js";
 import { ProviderManager } from "../provider-manager.js";
+import { BaseLLMProvider } from "../base-provider.js";
+import {
+  registerProvider,
+  registerGenerative,
+  registerEmbedding,
+} from "../registry.js";
+import { fetchWithTimeout, type ModelInfo } from "../model-lister.js";

-export class OllamaProvider implements ILLMProvider {
-  static readonly providerId = "ollama";
-  static readonly displayName = "Ollama";
-  static readonly description =
-    "Local model runner supporting open-source LLMs via the Ollama server";
-  static readonly defaultModel = "llama3.1";
+async function fetchOllamaModels(endpointUrl: string): Promise<ModelInfo[]> {
+  const base = endpointUrl.replace(/\/$/, "");
+  const res = await fetchWithTimeout(`${base}/api/tags`);
+  if (!res.ok) return [];
+
+  const json = (await res.json()) as {
+    models?: { name: string; model?: string }[];
+  };
+
+  return (json.models ?? []).map((m) => ({
+    id: m.name,
+    name: m.name,
+  }));
+}
+
+export class OllamaProvider extends BaseLLMProvider {
+  static {
+    registerProvider({
+      id: "ollama",
+      displayName: "Ollama",
+      description:
+        "Local model runner supporting open-source LLMs via the Ollama server",
+      capabilities: { generative: true, embedding: true },
+      defaultModel: "llama3.1",
+      defaultEmbeddingModel: "nomic-embed-text",
+      defaultMaxContext: 32768,
+      fallbackPriority: 100,
+      listModels: (_apiKey, endpointUrl) =>
+        fetchOllamaModels(endpointUrl || "http://localhost:11434"),
+    });
+    registerGenerative(
+      "ollama",
+      (inst: ModelProviderInstance) =>
+        new OllamaProvider(
+          inst.endpointUrl,
+          inst.modelName,
+          inst.name,
+          inst.maxContext,
+        ),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): ILLMProvider {
+    return new OllamaProvider(
+      inst.endpointUrl,
+      inst.modelName,
+      inst.name,
+      inst.maxContext,
+    );
+  }

  providerName = "Ollama";
-  private model: ChatOllama;
-  private modelNameUsed: string;
-  private providerInstanceName?: string;
-  private maxContextUsed?: number;
-  lastCalls: LLMCallRecord[] = [];
+  protected readonly model: ChatOllama;
+  protected modelNameUsed: string;
+  protected providerInstanceName?: string;
+  protected maxContextUsed?: number;
+  protected defaultMaxContext = 32768;

  /**
   * Creates an OllamaProvider.
@@ -41,6 +86,7 @@ export class OllamaProvider implements ILLMProvider {
    providerInstanceName?: string,
    maxContext?: number,
  ) {
+    super();
    let url = baseUrl;
    let model = modelName;
    this.providerInstanceName = providerInstanceName;
@@ -48,7 +94,7 @@ export class OllamaProvider implements ILLMProvider {

    if (!url || !model) {
      const active = ProviderManager.getActive("generative");
-      if (active && active.providerName === OllamaProvider.providerId) {
+      if (active && active.providerName === "ollama") {
        if (!url) {
          url = active.endpointUrl;
        }
@@ -64,59 +110,26 @@ export class OllamaProvider implements ILLMProvider {
      }
    }

-    this.modelNameUsed = model || OllamaProvider.defaultModel;
+    this.modelNameUsed = model || "llama3.1";
    this.model = new ChatOllama({
      baseUrl: url || "http://localhost:11434",
      model: this.modelNameUsed,
    });
  }
-
-  async generateStructuredResponse<T extends z.ZodTypeAny>(
-    request: LLMRequest<T>,
-  ): Promise<LLMResponse<z.infer<T>>> {
-    const structuredModel = this.model.withStructuredOutput(request.schema, {
-      includeRaw: true,
-    });
-    const result = (await structuredModel.invoke([
-      { role: "system", content: request.systemPrompt },
-      { role: "user", content: request.userContext },
-    ])) as unknown as {
-      parsed?: z.infer<T>;
-      raw?: {
-        usage_metadata?: {
-          input_tokens?: number;
-          output_tokens?: number;
-          total_tokens?: number;
-        };
-      };
-    };
-
-    const parsed = result?.parsed;
-    const raw = result?.raw;
-
-    const usage = {
-      inputTokens: raw?.usage_metadata?.input_tokens || 0,
-      outputTokens: raw?.usage_metadata?.output_tokens || 0,
-      totalTokens: raw?.usage_metadata?.total_tokens || 0,
-      modelName: this.modelNameUsed,
-      providerInstanceName: this.providerInstanceName || "Default",
-      maxContext:
-        this.maxContextUsed !== undefined ? this.maxContextUsed : 32768,
-    };
-
-    this.lastCalls.push({
-      systemPrompt: request.systemPrompt,
-      userContext: request.userContext,
-      usage,
-    });
-
-    return { success: true, data: parsed, usage };
-  }
 }

 export class OllamaEmbeddingProvider implements IEmbeddingProvider {
-  static readonly providerId = "ollama";
-  static readonly displayName = "Ollama Embeddings";
+  static {
+    registerEmbedding(
+      "ollama",
+      (inst: ModelProviderInstance) =>
+        new OllamaEmbeddingProvider(inst.endpointUrl, inst.modelName),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): IEmbeddingProvider {
+    return new OllamaEmbeddingProvider(inst.endpointUrl, inst.modelName);
+  }

  providerName = "Ollama";
  private model: OllamaEmbeddings;
@@ -137,10 +150,7 @@ export class OllamaEmbeddingProvider implements IEmbeddingProvider {

    if (!url || !model) {
      const active = ProviderManager.getActive("embedding");
-      if (
-        active &&
-        active.providerName === OllamaEmbeddingProvider.providerId
-      ) {
+      if (active && active.providerName === "ollama") {
        if (!url) {
          url = active.endpointUrl;
        }
--- a/packages/llm/src/providers/openai.ts
+++ b/packages/llm/src/providers/openai.ts
@@ -1,28 +1,58 @@
-import { z } from "zod";
 import { ChatOpenAI, OpenAIEmbeddings } from "@langchain/openai";
-import {
-  ILLMProvider,
-  LLMRequest,
-  LLMResponse,
-  LLMCallRecord,
-  IEmbeddingProvider,
-} from "../llm.js";
-import { llmConfig } from "../config.js";
+import { ILLMProvider, IEmbeddingProvider } from "../llm.js";
+import type { ModelProviderInstance } from "../llm.js";
+import { getLlmConfig } from "../config.js";
 import { ProviderManager } from "../provider-manager.js";
+import { BaseLLMProvider, resolveCredentials } from "../base-provider.js";
+import {
+  registerProvider,
+  registerGenerative,
+  registerEmbedding,
+} from "../registry.js";
+import { fetchOpenAICompatibleModels } from "../model-lister.js";

-export class OpenAIProvider implements ILLMProvider {
-  static readonly providerId = "openai";
-  static readonly displayName = "OpenAI";
-  static readonly description =
-    "Official OpenAI integration using @langchain/openai SDK";
-  static readonly defaultModel = "gpt-4o-mini";
+export class OpenAIProvider extends BaseLLMProvider {
+  static {
+    registerProvider({
+      id: "openai",
+      displayName: "OpenAI",
+      description: "Official OpenAI integration using @langchain/openai SDK",
+      envVar: "OPENAI_API_KEY",
+      capabilities: { generative: true, embedding: true },
+      defaultModel: "gpt-4o-mini",
+      defaultEmbeddingModel: "text-embedding-3-small",
+      defaultMaxContext: 128000,
+      fallbackPriority: 1,
+      listModels: (apiKey) =>
+        fetchOpenAICompatibleModels("https://api.openai.com/v1", apiKey),
+    });
+    registerGenerative(
+      "openai",
+      (inst: ModelProviderInstance) =>
+        new OpenAIProvider(
+          inst.apiKey,
+          inst.modelName,
+          inst.name,
+          inst.maxContext,
+        ),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): ILLMProvider {
+    return new OpenAIProvider(
+      inst.apiKey,
+      inst.modelName,
+      inst.name,
+      inst.maxContext,
+    );
+  }

  providerName = "OpenAI";
-  private model: ChatOpenAI;
-  private modelNameUsed: string;
-  private providerInstanceName?: string;
-  private maxContextUsed?: number;
-  lastCalls: LLMCallRecord[] = [];
+  protected readonly model: ChatOpenAI;
+  protected modelNameUsed: string;
+  protected providerInstanceName?: string;
+  protected maxContextUsed?: number;
+  protected defaultMaxContext = 128000;

  constructor(
    apiKey?: string,
@@ -30,93 +60,45 @@ export class OpenAIProvider implements ILLMProvider {
    providerInstanceName?: string,
    maxContext?: number,
  ) {
-    let key = apiKey;
-    let model = modelName;
-    this.providerInstanceName = providerInstanceName;
-    this.maxContextUsed = maxContext;
-
-    if (!key) {
-      const active = ProviderManager.getActive("generative");
-      if (active && active.providerName === OpenAIProvider.providerId) {
-        key = active.apiKey;
-        if (!model) {
-          model = active.modelName;
-        }
-        if (!this.providerInstanceName) {
-          this.providerInstanceName = active.name;
-        }
-        if (this.maxContextUsed === undefined) {
-          this.maxContextUsed = active.maxContext;
-        }
-      }
-    }
-
-    if (!key) {
-      key = llmConfig.OPENAI_API_KEY;
-      if (!this.providerInstanceName && key) {
-        this.providerInstanceName = "Environment Variable";
-      }
-    }
-
+    super();
+    const {
+      key,
+      model,
+      providerInstanceName: resolvedName,
+      maxContext: resolvedMax,
+    } = resolveCredentials({
+      explicitKey: apiKey,
+      explicitModel: modelName,
+      explicitProviderInstanceName: providerInstanceName,
+      explicitMaxContext: maxContext,
+      providerId: "openai",
+      envVarName: "OPENAI_API_KEY",
+      type: "generative",
+    });
    if (!key) {
      throw new Error(
        "OPENAI_API_KEY is required to initialize OpenAIProvider",
      );
    }
-
-    this.modelNameUsed = model || OpenAIProvider.defaultModel;
-    this.model = new ChatOpenAI({
-      apiKey: key,
-      model: this.modelNameUsed,
-    });
-  }
-
-  async generateStructuredResponse<T extends z.ZodTypeAny>(
-    request: LLMRequest<T>,
-  ): Promise<LLMResponse<z.infer<T>>> {
-    const structuredModel = this.model.withStructuredOutput(request.schema, {
-      includeRaw: true,
-    });
-    const result = (await structuredModel.invoke([
-      { role: "system", content: request.systemPrompt },
-      { role: "user", content: request.userContext },
-    ])) as unknown as {
-      parsed?: z.infer<T>;
-      raw?: {
-        usage_metadata?: {
-          input_tokens?: number;
-          output_tokens?: number;
-          total_tokens?: number;
-        };
-      };
-    };
-
-    const parsed = result?.parsed;
-    const raw = result?.raw;
-
-    const usage = {
-      inputTokens: raw?.usage_metadata?.input_tokens || 0,
-      outputTokens: raw?.usage_metadata?.output_tokens || 0,
-      totalTokens: raw?.usage_metadata?.total_tokens || 0,
-      modelName: this.modelNameUsed,
-      providerInstanceName: this.providerInstanceName || "Default",
-      maxContext:
-        this.maxContextUsed !== undefined ? this.maxContextUsed : 128000,
-    };
-
-    this.lastCalls.push({
-      systemPrompt: request.systemPrompt,
-      userContext: request.userContext,
-      usage,
-    });
-
-    return { success: true, data: parsed, usage };
+    this.providerInstanceName = resolvedName;
+    this.maxContextUsed = resolvedMax;
+    this.modelNameUsed = model || "gpt-4o-mini";
+    this.model = new ChatOpenAI({ apiKey: key, model: this.modelNameUsed });
  }
 }

 export class OpenAIEmbeddingProvider implements IEmbeddingProvider {
-  static readonly providerId = "openai";
-  static readonly displayName = "OpenAI Embeddings";
+  static {
+    registerEmbedding(
+      "openai",
+      (inst: ModelProviderInstance) =>
+        new OpenAIEmbeddingProvider(inst.apiKey, inst.modelName),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): IEmbeddingProvider {
+    return new OpenAIEmbeddingProvider(inst.apiKey, inst.modelName);
+  }

  providerName = "OpenAI";
  private model: OpenAIEmbeddings;
@@ -127,10 +109,7 @@ export class OpenAIEmbeddingProvider implements IEmbeddingProvider {

    if (!key) {
      const active = ProviderManager.getActive("embedding");
-      if (
-        active &&
-        active.providerName === OpenAIEmbeddingProvider.providerId
-      ) {
+      if (active && active.providerName === "openai") {
        key = active.apiKey;
        if (!model) {
          model = active.modelName;
@@ -139,7 +118,7 @@ export class OpenAIEmbeddingProvider implements IEmbeddingProvider {
    }

    if (!key) {
-      key = llmConfig.OPENAI_API_KEY;
+      key = getLlmConfig().OPENAI_API_KEY;
    }

    if (!key) {
--- a/packages/llm/src/providers/openrouter.ts
+++ b/packages/llm/src/providers/openrouter.ts
@@ -1,27 +1,77 @@
-import { z } from "zod";
 import { ChatOpenRouter } from "@langchain/openrouter";
-import {
-  ILLMProvider,
-  LLMRequest,
-  LLMResponse,
-  LLMCallRecord,
-} from "../llm.js";
-import { llmConfig } from "../config.js";
-import { ProviderManager } from "../provider-manager.js";
+import { ILLMProvider } from "../llm.js";
+import type { ModelProviderInstance } from "../llm.js";
+import { BaseLLMProvider, resolveCredentials } from "../base-provider.js";
+import { registerProvider, registerGenerative } from "../registry.js";
+import { fetchWithTimeout, type ModelInfo } from "../model-lister.js";

-export class OpenRouterProvider implements ILLMProvider {
-  static readonly providerId = "openrouter";
-  static readonly displayName = "OpenRouter";
-  static readonly description =
-    "Multi-model router supporting Anthropic, OpenAI, DeepSeek, and local models";
-  static readonly defaultModel = "google/gemini-2.5-flash";
+async function fetchOpenRouterModels(apiKey: string): Promise<ModelInfo[]> {
+  const res = await fetchWithTimeout(
+    "https://openrouter.ai/api/v1/models",
+    apiKey
+      ? {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+          },
+        }
+      : { headers: { Accept: "application/json" } },
+  );
+  if (!res.ok) return [];
+
+  const json = (await res.json()) as {
+    data?: { id: string; name?: string; owned_by?: string }[];
+  };
+
+  return (json.data ?? []).map((m) => ({
+    id: m.id,
+    name: m.name || m.id,
+    ownedBy: m.owned_by,
+  }));
+}
+
+export class OpenRouterProvider extends BaseLLMProvider {
+  static {
+    registerProvider({
+      id: "openrouter",
+      displayName: "OpenRouter",
+      description:
+        "Multi-model router supporting Anthropic, OpenAI, DeepSeek, and local models",
+      envVar: "OPENROUTER_API_KEY",
+      capabilities: { generative: true, embedding: false },
+      defaultModel: "google/gemini-2.5-flash",
+      defaultEmbeddingModel: "openai/text-embedding-3-small",
+      defaultMaxContext: 32768,
+      fallbackPriority: 5,
+      listModels: fetchOpenRouterModels,
+    });
+    registerGenerative(
+      "openrouter",
+      (inst: ModelProviderInstance) =>
+        new OpenRouterProvider(
+          inst.apiKey,
+          inst.modelName,
+          inst.name,
+          inst.maxContext,
+        ),
+    );
+  }
+
+  static create(inst: ModelProviderInstance): ILLMProvider {
+    return new OpenRouterProvider(
+      inst.apiKey,
+      inst.modelName,
+      inst.name,
+      inst.maxContext,
+    );
+  }

  providerName = "OpenRouter";
-  private model: ChatOpenRouter;
-  private modelNameUsed: string;
-  private providerInstanceName?: string;
-  private maxContextUsed?: number;
-  lastCalls: LLMCallRecord[] = [];
+  protected readonly model: ChatOpenRouter;
+  protected modelNameUsed: string;
+  protected providerInstanceName?: string;
+  protected maxContextUsed?: number;
+  protected defaultMaxContext = 32768;

  constructor(
    apiKey?: string,
@@ -29,86 +79,29 @@ export class OpenRouterProvider implements ILLMProvider {
    providerInstanceName?: string,
    maxContext?: number,
  ) {
-    let key = apiKey;
-    let model = modelName;
-    this.providerInstanceName = providerInstanceName;
-    this.maxContextUsed = maxContext;
-
-    if (!key) {
-      const active = ProviderManager.getActive("generative");
-      if (active && active.providerName === OpenRouterProvider.providerId) {
-        key = active.apiKey;
-        if (!model) {
-          model = active.modelName;
-        }
-        if (!this.providerInstanceName) {
-          this.providerInstanceName = active.name;
-        }
-        if (this.maxContextUsed === undefined) {
-          this.maxContextUsed = active.maxContext;
-        }
-      }
-    }
-
-    if (!key) {
-      key = llmConfig.OPENROUTER_API_KEY;
-      if (!this.providerInstanceName && key) {
-        this.providerInstanceName = "Environment Variable";
-      }
-    }
-
+    super();
+    const {
+      key,
+      model,
+      providerInstanceName: resolvedName,
+      maxContext: resolvedMax,
+    } = resolveCredentials({
+      explicitKey: apiKey,
+      explicitModel: modelName,
+      explicitProviderInstanceName: providerInstanceName,
+      explicitMaxContext: maxContext,
+      providerId: "openrouter",
+      envVarName: "OPENROUTER_API_KEY",
+      type: "generative",
+    });
    if (!key) {
      throw new Error(
        "OPENROUTER_API_KEY is required to initialize OpenRouterProvider",
      );
    }
-
+    this.providerInstanceName = resolvedName;
+    this.maxContextUsed = resolvedMax;
    this.modelNameUsed = model || "google/gemini-2.5-flash";
-    this.model = new ChatOpenRouter({
-      apiKey: key,
-      model: this.modelNameUsed,
-    });
-  }
-
-  async generateStructuredResponse<T extends z.ZodTypeAny>(
-    request: LLMRequest<T>,
-  ): Promise<LLMResponse<z.infer<T>>> {
-    const structuredModel = this.model.withStructuredOutput(request.schema, {
-      includeRaw: true,
-    });
-    const result = (await structuredModel.invoke([
-      { role: "system", content: request.systemPrompt },
-      { role: "user", content: request.userContext },
-    ])) as unknown as {
-      parsed?: z.infer<T>;
-      raw?: {
-        usage_metadata?: {
-          input_tokens?: number;
-          output_tokens?: number;
-          total_tokens?: number;
-        };
-      };
-    };
-
-    const parsed = result?.parsed;
-    const raw = result?.raw;
-
-    const usage = {
-      inputTokens: raw?.usage_metadata?.input_tokens || 0,
-      outputTokens: raw?.usage_metadata?.output_tokens || 0,
-      totalTokens: raw?.usage_metadata?.total_tokens || 0,
-      modelName: this.modelNameUsed,
-      providerInstanceName: this.providerInstanceName || "Default",
-      maxContext:
-        this.maxContextUsed !== undefined ? this.maxContextUsed : 32768,
-    };
-
-    this.lastCalls.push({
-      systemPrompt: request.systemPrompt,
-      userContext: request.userContext,
-      usage,
-    });
-
-    return { success: true, data: parsed, usage };
+    this.model = new ChatOpenRouter({ apiKey: key, model: this.modelNameUsed });
  }
 }
--- a/packages/llm/src/registry.ts
+++ b/packages/llm/src/registry.ts
@@ -0,0 +1,79 @@
+import type {
+  ILLMProvider,
+  IEmbeddingProvider,
+  ModelProviderInstance,
+  ModelProviderMeta,
+} from "./llm.js";
+import type { ModelInfo } from "./model-lister.js";
+
+export interface ProviderDefinition {
+  id: string;
+  displayName: string;
+  description: string;
+  envVar?: string;
+  capabilities: { generative: boolean; embedding: boolean };
+  defaultModel: string;
+  defaultEmbeddingModel?: string;
+  defaultMaxContext: number;
+  fallbackPriority: number;
+  listModels?: (apiKey: string, endpointUrl?: string) => Promise<ModelInfo[]>;
+  generativeCreate?: (inst: ModelProviderInstance) => ILLMProvider;
+  embeddingCreate?: (inst: ModelProviderInstance) => IEmbeddingProvider;
+}
+
+const _entries = new Map<string, ProviderDefinition>();
+
+type ProviderMeta = Omit<
+  ProviderDefinition,
+  "generativeCreate" | "embeddingCreate"
+>;
+
+export function registerProvider(meta: ProviderMeta) {
+  const existing = _entries.get(meta.id);
+  _entries.set(meta.id, {
+    ...existing,
+    ...meta,
+    generativeCreate: existing?.generativeCreate,
+    embeddingCreate: existing?.embeddingCreate,
+  });
+}
+
+export function registerGenerative(
+  id: string,
+  createFn: (inst: ModelProviderInstance) => ILLMProvider,
+) {
+  const existing = _entries.get(id);
+  if (existing) {
+    existing.generativeCreate = createFn;
+  } else {
+    _entries.set(id, { id, generativeCreate: createFn } as ProviderDefinition);
+  }
+}
+
+export function registerEmbedding(
+  id: string,
+  createFn: (inst: ModelProviderInstance) => IEmbeddingProvider,
+) {
+  const existing = _entries.get(id);
+  if (existing) {
+    existing.embeddingCreate = createFn;
+  } else {
+    _entries.set(id, { id, embeddingCreate: createFn } as ProviderDefinition);
+  }
+}
+
+export const ProviderRegistry = {
+  all: (): ProviderDefinition[] => [..._entries.values()],
+  get: (id: string): ProviderDefinition | undefined => _entries.get(id),
+  has: (id: string): boolean => _entries.has(id),
+} as const;
+
+export function toProviderMeta(def: ProviderDefinition): ModelProviderMeta {
+  return {
+    id: def.id,
+    displayName: def.displayName,
+    description: def.description,
+    defaultModel: def.defaultModel,
+    defaultEmbeddingModel: def.defaultEmbeddingModel || "",
+  };
+}
--- a/packages/llm/src/row-mapper.ts
+++ b/packages/llm/src/row-mapper.ts
@@ -0,0 +1,32 @@
+import type { ModelProviderInstance } from "./llm.js";
+
+export type DbRow = {
+  id: string;
+  name: string;
+  providerName: string;
+  apiKey: string;
+  isActive: number;
+  modelName?: string;
+  type: string;
+  maxContext?: number;
+  endpointUrl?: string;
+};
+
+export function mapRow(r: DbRow): ModelProviderInstance {
+  return {
+    id: r.id,
+    name: r.name,
+    providerName: r.providerName,
+    apiKey: r.apiKey,
+    isActive: r.isActive === 1,
+    modelName: r.modelName || undefined,
+    type: (r.type as "generative" | "embedding") || "generative",
+    maxContext:
+      r.maxContext !== undefined && r.maxContext !== null
+        ? r.maxContext
+        : r.type === "embedding"
+          ? 0
+          : 32768,
+    endpointUrl: r.endpointUrl || undefined,
+  };
+}
--- a/packages/llm/tests/cli.test.ts
+++ b/packages/llm/tests/cli.test.ts
@@ -0,0 +1,126 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+
+describe("setup-provider CLI Tool Tests", () => {
+  let tempDbPath: string;
+  let scriptPath: string;
+
+  beforeEach(() => {
+    // Generate a unique temp database path
+    tempDbPath = path.resolve(
+      process.cwd(),
+      `test-cli-${Date.now()}-${Math.random().toString(36).substring(2)}.db`,
+    );
+    scriptPath = path.resolve(
+      process.cwd(),
+      "packages/llm/dist/bin/setup-provider.js",
+    );
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDbPath)) {
+      try {
+        fs.unlinkSync(tempDbPath);
+      } catch {
+        // ignore
+      }
+    }
+  });
+
+  test("prints help message when --help or -h is passed", () => {
+    const stdout = execSync(`node ${scriptPath} --help`).toString();
+    expect(stdout).toContain("Usage:");
+    expect(stdout).toContain("Options:");
+    expect(stdout).toContain("Registered Providers:");
+  });
+
+  test("creates a provider instance successfully via CLI flags", () => {
+    const cmd = `node ${scriptPath} --provider google-genai --key mock-key-abc --name "Test Gemini" --model "gemini-2.5-flash"`;
+    const stdout = execSync(cmd, {
+      env: { ...process.env, OMNIA_DB_PATH: tempDbPath },
+    }).toString();
+
+    expect(stdout).toContain("Successfully created provider instance:");
+    expect(stdout).toContain("Test Gemini");
+    expect(stdout).toContain("google-genai");
+    expect(stdout).toContain("mock-key-abc");
+
+    // Read the SQLite db directly to verify
+    const db = new Database(tempDbPath);
+    const rows = db.prepare("SELECT * FROM provider_instances").all() as {
+      name: string;
+      providerName: string;
+      apiKey: string;
+      modelName: string;
+      isActive: number;
+    }[];
+    expect(rows.length).toBe(1);
+    expect(rows[0].name).toBe("Test Gemini");
+    expect(rows[0].providerName).toBe("google-genai");
+    expect(rows[0].apiKey).toBe("mock-key-abc");
+    expect(rows[0].modelName).toBe("gemini-2.5-flash");
+    expect(rows[0].isActive).toBe(1);
+    db.close();
+  });
+
+  test("fails when required key is missing and env var is not set", () => {
+    let error: { status?: number; stderr?: Buffer } | undefined;
+    try {
+      execSync(`node ${scriptPath} --provider google-genai`, {
+        env: { ...process.env, OMNIA_DB_PATH: tempDbPath, GOOGLE_API_KEY: "" },
+        stdio: "pipe",
+      });
+    } catch (e) {
+      error = e as { status?: number; stderr?: Buffer };
+    }
+    expect(error).toBeDefined();
+    expect(error?.status).toBe(1);
+    expect(error?.stderr?.toString()).toContain("Error: API Key is required");
+  });
+
+  test("seeds from environment variables when using --all", () => {
+    const cmd = `node ${scriptPath} --all`;
+    const stdout = execSync(cmd, {
+      env: {
+        ...process.env,
+        OMNIA_DB_PATH: tempDbPath,
+        GOOGLE_API_KEY: "mock-google-key-all",
+        OPENAI_API_KEY: "",
+        ANTHROPIC_API_KEY: "",
+        GROQ_API_KEY: "",
+        DEEPSEEK_API_KEY: "",
+        OPENROUTER_API_KEY: "",
+      },
+    }).toString();
+
+    expect(stdout).toContain(
+      "Created generative instance: Google Gemini (CLI)",
+    );
+    expect(stdout).toContain(
+      "Created embedding instance: Google Gemini Embed (CLI)",
+    );
+
+    const db = new Database(tempDbPath);
+    const rows = db.prepare("SELECT * FROM provider_instances").all() as {
+      type: string;
+      apiKey: string;
+      modelName: string;
+    }[];
+    // Should have both generative and embedding instances
+    expect(rows.length).toBe(2);
+    const gen = rows.find((r) => r.type === "generative");
+    const embed = rows.find((r) => r.type === "embedding");
+
+    expect(gen).toBeDefined();
+    expect(gen?.apiKey).toBe("mock-google-key-all");
+    expect(gen?.modelName).toBe("gemini-2.5-flash");
+
+    expect(embed).toBeDefined();
+    expect(embed?.apiKey).toBe("mock-google-key-all");
+    expect(embed?.modelName).toBe("gemini-embedding-001");
+    db.close();
+  });
+});
--- a/packages/llm/tests/deepseek.test.ts
+++ b/packages/llm/tests/deepseek.test.ts
@@ -0,0 +1,128 @@
+import { describe, test, expect, vi } from "vitest";
+import { z } from "zod";
+
+const mockConfig: Record<string, string | undefined> = {};
+
+vi.mock("../src/config.js", () => ({
+  getLlmConfig: () => mockConfig,
+  resetLlmConfig: () => {
+    for (const key of Object.keys(mockConfig)) {
+      delete mockConfig[key];
+    }
+  },
+}));
+
+const { getActiveMock } = vi.hoisted(() => ({
+  getActiveMock: vi.fn().mockReturnValue(null),
+}));
+
+vi.mock("../src/provider-manager.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../src/provider-manager.js")>();
+  return {
+    ...actual,
+    ProviderManager: {
+      ...actual.ProviderManager,
+      getActive: getActiveMock,
+    },
+  };
+});
+
+import { DeepSeekProvider } from "../src/providers/deepseek.js";
+
+// Mock the ChatDeepSeek class
+vi.mock("@langchain/deepseek", () => {
+  return {
+    ChatDeepSeek: class {
+      config: unknown;
+      constructor(config: unknown) {
+        this.config = config;
+      }
+      withStructuredOutput = vi.fn().mockImplementation(() => {
+        return {
+          invoke: vi.fn().mockImplementation(async () => {
+            return {
+              parsed: {
+                name: "mocked response",
+                success: true,
+              },
+              raw: {
+                usage_metadata: {
+                  input_tokens: 10,
+                  output_tokens: 5,
+                  total_tokens: 15,
+                },
+              },
+            };
+          }),
+        };
+      });
+    },
+  };
+});
+
+describe("DeepSeekProvider Unit Tests (Tier 1)", () => {
+  test("initializes successfully with a provided apiKey", () => {
+    const provider = new DeepSeekProvider("dummy-key");
+    expect(provider.providerName).toBe("DeepSeek");
+  });
+
+  test("initializes successfully with apiKey from config", () => {
+    const originalKey = process.env.DEEPSEEK_API_KEY;
+    process.env.DEEPSEEK_API_KEY = "env-dummy-key";
+    mockConfig.DEEPSEEK_API_KEY = "env-dummy-key";
+
+    try {
+      const provider = new DeepSeekProvider();
+      expect(provider.providerName).toBe("DeepSeek");
+    } finally {
+      process.env.DEEPSEEK_API_KEY = originalKey;
+      delete mockConfig.DEEPSEEK_API_KEY;
+    }
+  });
+
+  test("throws error if no API key is provided or in config", () => {
+    const originalKey = process.env.DEEPSEEK_API_KEY;
+    process.env.DEEPSEEK_API_KEY = undefined;
+    mockConfig.DEEPSEEK_API_KEY = undefined;
+
+    try {
+      expect(() => new DeepSeekProvider()).toThrow(
+        "DEEPSEEK_API_KEY is required to initialize DeepSeekProvider",
+      );
+    } finally {
+      process.env.DEEPSEEK_API_KEY = originalKey;
+    }
+  });
+
+  test("generateStructuredResponse invokes the model with structured output, records usage and updates lastCalls", async () => {
+    const provider = new DeepSeekProvider("dummy-key");
+    const TestSchema = z.object({
+      name: z.string(),
+      success: z.boolean(),
+    });
+
+    const response = await provider.generateStructuredResponse({
+      systemPrompt: "system prompt",
+      userContext: "user context",
+      schema: TestSchema,
+    });
+
+    expect(response.success).toBe(true);
+    expect(response.data).toEqual({
+      name: "mocked response",
+      success: true,
+    });
+
+    expect(response.usage).toEqual({
+      inputTokens: 10,
+      outputTokens: 5,
+      totalTokens: 15,
+      modelName: "deepseek-chat",
+      providerInstanceName: "Default",
+      maxContext: 64000,
+    });
+
+    expect(provider.lastCalls.length).toBe(1);
+  });
+});
--- a/packages/llm/tests/groq.test.ts
+++ b/packages/llm/tests/groq.test.ts
@@ -0,0 +1,128 @@
+import { describe, test, expect, vi } from "vitest";
+import { z } from "zod";
+
+const mockConfig: Record<string, string | undefined> = {};
+
+vi.mock("../src/config.js", () => ({
+  getLlmConfig: () => mockConfig,
+  resetLlmConfig: () => {
+    for (const key of Object.keys(mockConfig)) {
+      delete mockConfig[key];
+    }
+  },
+}));
+
+const { getActiveMock } = vi.hoisted(() => ({
+  getActiveMock: vi.fn().mockReturnValue(null),
+}));
+
+vi.mock("../src/provider-manager.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../src/provider-manager.js")>();
+  return {
+    ...actual,
+    ProviderManager: {
+      ...actual.ProviderManager,
+      getActive: getActiveMock,
+    },
+  };
+});
+
+import { GroqProvider } from "../src/providers/groq.js";
+
+// Mock the ChatGroq class
+vi.mock("@langchain/groq", () => {
+  return {
+    ChatGroq: class {
+      config: unknown;
+      constructor(config: unknown) {
+        this.config = config;
+      }
+      withStructuredOutput = vi.fn().mockImplementation(() => {
+        return {
+          invoke: vi.fn().mockImplementation(async () => {
+            return {
+              parsed: {
+                name: "mocked response",
+                success: true,
+              },
+              raw: {
+                usage_metadata: {
+                  input_tokens: 10,
+                  output_tokens: 5,
+                  total_tokens: 15,
+                },
+              },
+            };
+          }),
+        };
+      });
+    },
+  };
+});
+
+describe("GroqProvider Unit Tests (Tier 1)", () => {
+  test("initializes successfully with a provided apiKey", () => {
+    const provider = new GroqProvider("dummy-key");
+    expect(provider.providerName).toBe("Groq");
+  });
+
+  test("initializes successfully with apiKey from config", () => {
+    const originalKey = process.env.GROQ_API_KEY;
+    process.env.GROQ_API_KEY = "env-dummy-key";
+    mockConfig.GROQ_API_KEY = "env-dummy-key";
+
+    try {
+      const provider = new GroqProvider();
+      expect(provider.providerName).toBe("Groq");
+    } finally {
+      process.env.GROQ_API_KEY = originalKey;
+      delete mockConfig.GROQ_API_KEY;
+    }
+  });
+
+  test("throws error if no API key is provided or in config", () => {
+    const originalKey = process.env.GROQ_API_KEY;
+    process.env.GROQ_API_KEY = undefined;
+    mockConfig.GROQ_API_KEY = undefined;
+
+    try {
+      expect(() => new GroqProvider()).toThrow(
+        "GROQ_API_KEY is required to initialize GroqProvider",
+      );
+    } finally {
+      process.env.GROQ_API_KEY = originalKey;
+    }
+  });
+
+  test("generateStructuredResponse invokes the model with structured output, records usage and updates lastCalls", async () => {
+    const provider = new GroqProvider("dummy-key");
+    const TestSchema = z.object({
+      name: z.string(),
+      success: z.boolean(),
+    });
+
+    const response = await provider.generateStructuredResponse({
+      systemPrompt: "system prompt",
+      userContext: "user context",
+      schema: TestSchema,
+    });
+
+    expect(response.success).toBe(true);
+    expect(response.data).toEqual({
+      name: "mocked response",
+      success: true,
+    });
+
+    expect(response.usage).toEqual({
+      inputTokens: 10,
+      outputTokens: 5,
+      totalTokens: 15,
+      modelName: "llama-3.3-70b-versatile",
+      providerInstanceName: "Default",
+      maxContext: 8192,
+    });
+
+    expect(provider.lastCalls.length).toBe(1);
+  });
+});
--- a/packages/llm/tests/model-lister.test.ts
+++ b/packages/llm/tests/model-lister.test.ts
@@ -0,0 +1,120 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import { ModelLister } from "@omnia/llm";
+
+describe("ModelLister Unit Tests (Tier 1)", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", vi.fn());
+    ModelLister.clearCache();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("returns mock provider list instantly without fetch", async () => {
+    const models = await ModelLister.listModels("mock", "none");
+    expect(models).toEqual([{ id: "mock", name: "Mock Model" }]);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  test("fetches and caches OpenAI-compatible models", async () => {
+    const mockResponse = {
+      data: [
+        { id: "gpt-4o", owned_by: "openai" },
+        { id: "gpt-4o-mini", owned_by: "openai" },
+      ],
+    };
+
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse,
+    });
+    vi.stubGlobal("fetch", mockFetch);
+
+    // First call: Should fetch
+    const models = await ModelLister.listModels("openai", "test-key");
+    expect(models).toEqual([
+      { id: "gpt-4o", name: "gpt-4o", ownedBy: "openai" },
+      { id: "gpt-4o-mini", name: "gpt-4o-mini", ownedBy: "openai" },
+    ]);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.openai.com/v1/models",
+      expect.objectContaining({
+        headers: {
+          Authorization: "Bearer test-key",
+          Accept: "application/json",
+        },
+      }),
+    );
+
+    // Second call: Should read from cache
+    const cachedModels = await ModelLister.listModels("openai", "test-key");
+    expect(cachedModels).toEqual(models);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  test("respects cache invalidation", async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ data: [{ id: "model-1" }] }),
+    });
+    vi.stubGlobal("fetch", mockFetch);
+
+    await ModelLister.listModels("openai", "test-key");
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+
+    // Invalidate
+    ModelLister.invalidateCache("openai", "test-key");
+
+    // Second call: Should fetch again
+    await ModelLister.listModels("openai", "test-key");
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  test("gracefully returns empty array on fetch failure", async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+    });
+    vi.stubGlobal("fetch", mockFetch);
+
+    const models = await ModelLister.listModels("openai", "bad-key");
+    expect(models).toEqual([]);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  test("handles Gemini pagination correctly", async () => {
+    const mockFetch = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          models: [
+            {
+              name: "models/gemini-2.5-flash",
+              displayName: "Gemini 2.5 Flash",
+            },
+          ],
+          nextPageToken: "token-1",
+        }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          models: [
+            { name: "models/gemini-2.5-pro", displayName: "Gemini 2.5 Pro" },
+          ],
+        }),
+      });
+
+    vi.stubGlobal("fetch", mockFetch);
+
+    const models = await ModelLister.listModels("google-genai", "gemini-key");
+    expect(models).toEqual([
+      { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash" },
+      { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro" },
+    ]);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+});
--- a/packages/llm/tests/openai.test.ts
+++ b/packages/llm/tests/openai.test.ts
@@ -0,0 +1,167 @@
+import { describe, test, expect, vi } from "vitest";
+import { z } from "zod";
+
+const mockConfig: Record<string, string | undefined> = {};
+
+vi.mock("../src/config.js", () => ({
+  getLlmConfig: () => mockConfig,
+  resetLlmConfig: () => {
+    for (const key of Object.keys(mockConfig)) {
+      delete mockConfig[key];
+    }
+  },
+}));
+
+const { getActiveMock } = vi.hoisted(() => ({
+  getActiveMock: vi.fn().mockReturnValue(null),
+}));
+
+vi.mock("../src/provider-manager.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../src/provider-manager.js")>();
+  return {
+    ...actual,
+    ProviderManager: {
+      ...actual.ProviderManager,
+      getActive: getActiveMock,
+    },
+  };
+});
+
+import {
+  OpenAIProvider,
+  OpenAIEmbeddingProvider,
+} from "../src/providers/openai.js";
+
+// Mock the ChatOpenAI and OpenAIEmbeddings classes
+vi.mock("@langchain/openai", () => {
+  return {
+    ChatOpenAI: class {
+      config: unknown;
+      constructor(config: unknown) {
+        this.config = config;
+      }
+      withStructuredOutput = vi.fn().mockImplementation(() => {
+        return {
+          invoke: vi.fn().mockImplementation(async () => {
+            return {
+              parsed: {
+                name: "mocked response",
+                success: true,
+              },
+              raw: {
+                usage_metadata: {
+                  input_tokens: 10,
+                  output_tokens: 5,
+                  total_tokens: 15,
+                },
+              },
+            };
+          }),
+        };
+      });
+    },
+    OpenAIEmbeddings: class {
+      config: unknown;
+      constructor(config: unknown) {
+        this.config = config;
+      }
+      embedQuery = vi.fn().mockImplementation(async (text: string) => {
+        return [0.1, 0.2, 0.3];
+      });
+    },
+  };
+});
+
+describe("OpenAIProvider Unit Tests (Tier 1)", () => {
+  test("initializes successfully with a provided apiKey", () => {
+    const provider = new OpenAIProvider("dummy-key");
+    expect(provider.providerName).toBe("OpenAI");
+  });
+
+  test("initializes successfully with apiKey from config", () => {
+    const originalKey = process.env.OPENAI_API_KEY;
+    process.env.OPENAI_API_KEY = "env-dummy-key";
+    mockConfig.OPENAI_API_KEY = "env-dummy-key";
+
+    try {
+      const provider = new OpenAIProvider();
+      expect(provider.providerName).toBe("OpenAI");
+    } finally {
+      process.env.OPENAI_API_KEY = originalKey;
+      delete mockConfig.OPENAI_API_KEY;
+    }
+  });
+
+  test("throws error if no API key is provided or in config", () => {
+    const originalKey = process.env.OPENAI_API_KEY;
+    process.env.OPENAI_API_KEY = undefined;
+    mockConfig.OPENAI_API_KEY = undefined;
+
+    try {
+      expect(() => new OpenAIProvider()).toThrow(
+        "OPENAI_API_KEY is required to initialize OpenAIProvider",
+      );
+    } finally {
+      process.env.OPENAI_API_KEY = originalKey;
+    }
+  });
+
+  test("generateStructuredResponse invokes the model with structured output, records usage and updates lastCalls", async () => {
+    const provider = new OpenAIProvider("dummy-key");
+    const TestSchema = z.object({
+      name: z.string(),
+      success: z.boolean(),
+    });
+
+    const response = await provider.generateStructuredResponse({
+      systemPrompt: "system prompt",
+      userContext: "user context",
+      schema: TestSchema,
+    });
+
+    expect(response.success).toBe(true);
+    expect(response.data).toEqual({
+      name: "mocked response",
+      success: true,
+    });
+
+    expect(response.usage).toEqual({
+      inputTokens: 10,
+      outputTokens: 5,
+      totalTokens: 15,
+      modelName: "gpt-4o-mini",
+      providerInstanceName: "Default",
+      maxContext: 128000,
+    });
+
+    expect(provider.lastCalls.length).toBe(1);
+  });
+});
+
+describe("OpenAIEmbeddingProvider Unit Tests (Tier 1)", () => {
+  test("initializes successfully with a provided apiKey", () => {
+    const provider = new OpenAIEmbeddingProvider("dummy-key");
+    expect(provider.providerName).toBe("OpenAI");
+  });
+
+  test("initializes successfully with apiKey from config", () => {
+    const originalKey = process.env.OPENAI_API_KEY;
+    process.env.OPENAI_API_KEY = "env-dummy-key";
+    mockConfig.OPENAI_API_KEY = "env-dummy-key";
+
+    try {
+      const provider = new OpenAIEmbeddingProvider();
+      expect(provider.providerName).toBe("OpenAI");
+    } finally {
+      process.env.OPENAI_API_KEY = originalKey;
+      delete mockConfig.OPENAI_API_KEY;
+    }
+  });
+
+  test("embed returns dummy array successfully", async () => {
+    const provider = new OpenAIEmbeddingProvider("dummy-key");
+    const result = await provider.embed("hello");
+    expect(result).toEqual([0.1, 0.2, 0.3]);
+  });
+});
--- a/packages/llm/tests/openrouter.test.ts
+++ b/packages/llm/tests/openrouter.test.ts
@@ -1,7 +1,34 @@
 import { describe, test, expect, vi } from "vitest";
 import { z } from "zod";
+
+const mockConfig: Record<string, string | undefined> = {};
+
+vi.mock("../src/config.js", () => ({
+  getLlmConfig: () => mockConfig,
+  resetLlmConfig: () => {
+    for (const key of Object.keys(mockConfig)) {
+      delete mockConfig[key];
+    }
+  },
+}));
+
+const { getActiveMock } = vi.hoisted(() => ({
+  getActiveMock: vi.fn().mockReturnValue(null),
+}));
+
+vi.mock("../src/provider-manager.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../src/provider-manager.js")>();
+  return {
+    ...actual,
+    ProviderManager: {
+      ...actual.ProviderManager,
+      getActive: getActiveMock,
+    },
+  };
+});
+
 import { OpenRouterProvider } from "../src/providers/openrouter.js";
-import { llmConfig } from "../src/config.js";

 // Mock the ChatOpenRouter class
 vi.mock("@langchain/openrouter", () => {
@@ -14,7 +41,6 @@ vi.mock("@langchain/openrouter", () => {
      withStructuredOutput = vi.fn().mockImplementation(() => {
        return {
          invoke: vi.fn().mockImplementation(async () => {
-            // Return a mock output that matches the includeRaw: true structure
            return {
              parsed: {
                name: "mocked response",
@@ -42,29 +68,30 @@ describe("OpenRouterProvider Unit Tests (Tier 1)", () => {
  });

  test("initializes successfully with apiKey from config", () => {
-    // Save current config
-    const originalKey = llmConfig.OPENROUTER_API_KEY;
-    llmConfig.OPENROUTER_API_KEY = "env-dummy-key";
+    const originalKey = process.env.OPENROUTER_API_KEY;
+    process.env.OPENROUTER_API_KEY = "env-dummy-key";
+    mockConfig.OPENROUTER_API_KEY = "env-dummy-key";

    try {
      const provider = new OpenRouterProvider();
      expect(provider.providerName).toBe("OpenRouter");
    } finally {
-      llmConfig.OPENROUTER_API_KEY = originalKey;
+      process.env.OPENROUTER_API_KEY = originalKey;
+      delete mockConfig.OPENROUTER_API_KEY;
    }
  });

  test("throws error if no API key is provided or in config", () => {
-    // Save current config
-    const originalKey = llmConfig.OPENROUTER_API_KEY;
-    llmConfig.OPENROUTER_API_KEY = undefined;
+    const originalKey = process.env.OPENROUTER_API_KEY;
+    process.env.OPENROUTER_API_KEY = undefined;
+    mockConfig.OPENROUTER_API_KEY = undefined;

    try {
      expect(() => new OpenRouterProvider()).toThrow(
        "OPENROUTER_API_KEY is required to initialize OpenRouterProvider",
      );
    } finally {
-      llmConfig.OPENROUTER_API_KEY = originalKey;
+      process.env.OPENROUTER_API_KEY = originalKey;
    }
  });

--- a/packages/llm/tests/provider-manager.test.ts
+++ b/packages/llm/tests/provider-manager.test.ts
@@ -1,24 +1,27 @@
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import fs from "fs";
 import path from "path";
-import {
-  ProviderManager,
-  setDbPathOverride,
-  resetHasBootstrapped,
-} from "../src/index.js";
+import { ProviderManager, setDbPathOverride } from "../src/index.js";

 describe("ProviderManager Bootstrapping & CRUD Unit Tests", () => {
  let tempDbPath: string;
-  let originalGoogle: string | undefined;
-  let originalOpenRouter: string | undefined;
+  let savedEnv: Record<string, string | undefined>;

  beforeEach(() => {
-    originalGoogle = process.env.GOOGLE_API_KEY;
-    originalOpenRouter = process.env.OPENROUTER_API_KEY;
+    savedEnv = {
+      GOOGLE_API_KEY: process.env.GOOGLE_API_KEY,
+      OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
+      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+      OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+      GROQ_API_KEY: process.env.GROQ_API_KEY,
+      DEEPSEEK_API_KEY: process.env.DEEPSEEK_API_KEY,
+    };
    delete process.env.GOOGLE_API_KEY;
    delete process.env.OPENROUTER_API_KEY;
-
-    resetHasBootstrapped();
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.GROQ_API_KEY;
+    delete process.env.DEEPSEEK_API_KEY;

    // Generate a unique temp database path for this test run
    tempDbPath = path.resolve(
@@ -37,54 +40,189 @@ describe("ProviderManager Bootstrapping & CRUD Unit Tests", () => {
        // ignore
      }
    }
-    if (originalGoogle !== undefined) {
-      process.env.GOOGLE_API_KEY = originalGoogle;
-    } else {
-      delete process.env.GOOGLE_API_KEY;
-    }
-    if (originalOpenRouter !== undefined) {
-      process.env.OPENROUTER_API_KEY = originalOpenRouter;
-    } else {
-      delete process.env.OPENROUTER_API_KEY;
+    for (const [key, value] of Object.entries(savedEnv)) {
+      if (value !== undefined) {
+        process.env[key] = value;
+      } else {
+        delete process.env[key];
+      }
    }
  });

-  test("auto-bootstraps Gemini and OpenRouter when database is empty and environment variables are present", () => {
-    process.env.GOOGLE_API_KEY = "mock-google-key-123";
-    process.env.OPENROUTER_API_KEY = "mock-openrouter-key-456";
-
+  test("returns empty list when database is empty and no auto-bootstraps", () => {
+    process.env.GOOGLE_API_KEY = "mock-google-key";
    const list = ProviderManager.list();
-    expect(list.length).toBe(3);
-
-    const gemini = list.find((p) => p.providerName === "google-genai");
-    expect(gemini).toBeDefined();
-    expect(gemini?.name).toBe("Gemini (Env)");
-    expect(gemini?.apiKey).toBe("mock-google-key-123");
-    expect(gemini?.modelName).toBe("gemini-2.5-flash");
-    expect(gemini?.isActive).toBe(true); // first inserted is active
-
-    const openrouter = list.find((p) => p.providerName === "openrouter");
-    expect(openrouter).toBeDefined();
-    expect(openrouter?.name).toBe("OpenRouter (Env)");
-    expect(openrouter?.apiKey).toBe("mock-openrouter-key-456");
-    expect(openrouter?.modelName).toBe("google/gemini-2.5-flash");
-    expect(openrouter?.isActive).toBe(false); // second inserted is inactive
+    expect(list.length).toBe(0);
  });

-  test("treats bootstrapped instances as normal provider instances (editable and deletable)", () => {
-    process.env.GOOGLE_API_KEY = "mock-google-key-123";
+  test("getActive returns null when no providers exist and no env vars", () => {
+    const active = ProviderManager.getActive("generative");
+    expect(active).toBeNull();
+    const activeEmbed = ProviderManager.getActive("embedding");
+    expect(activeEmbed).toBeNull();
+  });
+
+  test("getActive returns null when DB is empty", () => {
+    process.env.GOOGLE_API_KEY = "mock-google-key-123";
+    const active = ProviderManager.getActive("generative");
+    expect(active).toBeNull();
+  });
+
+  test("getActive returns first instance of type when none is active", () => {
+    // Manually create instances without any env var bootstrap
+    const inst1 = ProviderManager.create("Test Gemini", "google-genai", "key1");
+    const inst2 = ProviderManager.create(
+      "Test OpenAI",
+      "openai",
+      "key2",
+      "gpt-4o",
+      "generative",
+      128000,
+    );
+    expect(inst1.isActive).toBe(true); // first created auto-activates
+    expect(inst2.isActive).toBe(false);
+
+    // Deactivate both
+    ProviderManager.setActive("__nonexistent__"); // no-op for nonexistent
+
+    // Deactivate inst1 by setting another as active, then delete that
+    ProviderManager.setActive(inst2.id);
+    expect(
+      ProviderManager.list().find((p) => p.id === inst2.id)?.isActive,
+    ).toBe(true);
+    expect(
+      ProviderManager.list().find((p) => p.id === inst1.id)?.isActive,
+    ).toBe(false);
+
+    // Delete the active one → auto-promotes inst1
+    ProviderManager.delete(inst2.id);
+    const promoted = ProviderManager.list().find((p) => p.id === inst1.id);
+    expect(promoted?.isActive).toBe(true);
+  });
+
+  test("setActive correctly deactivates siblings and activates target", () => {
+    const inst1 = ProviderManager.create(
+      "First Gemini",
+      "google-genai",
+      "key1",
+      undefined,
+      "generative",
+    );
+    const inst2 = ProviderManager.create(
+      "Second Gemini",
+      "google-genai",
+      "key2",
+      undefined,
+      "generative",
+    );
+
+    expect(inst1.isActive).toBe(true);
+    expect(inst2.isActive).toBe(false);
+
+    ProviderManager.setActive(inst2.id);

-    // Trigger bootstrap
    const list = ProviderManager.list();
-    expect(list.length).toBe(2);
-    const bootstrapped = list.find((p) => p.name === "Gemini (Env)");
-    expect(bootstrapped).toBeDefined();
-    if (!bootstrapped) return;
-    expect(bootstrapped.isActive).toBe(true);
+    const updated1 = list.find((p) => p.id === inst1.id);
+    const updated2 = list.find((p) => p.id === inst2.id);
+    expect(updated1?.isActive).toBe(false);
+    expect(updated2?.isActive).toBe(true);
+  });
+
+  test("getMappings returns empty object initially, setMapping persists mappings", () => {
+    const mappings = ProviderManager.getMappings();
+    expect(mappings).toEqual({});
+
+    const inst = ProviderManager.create(
+      "Test Provider",
+      "google-genai",
+      "key1",
+    );
+
+    ProviderManager.setMapping("actor-prose", inst.id);
+    ProviderManager.setMapping("embeddings", inst.id);
+
+    const updated = ProviderManager.getMappings();
+    expect(updated["actor-prose"]).toBe(inst.id);
+    expect(updated["embeddings"]).toBe(inst.id);
+  });
+
+  test("setMapping with empty providerInstanceId deletes the mapping", () => {
+    const inst = ProviderManager.create(
+      "Test Provider",
+      "google-genai",
+      "key1",
+    );
+
+    ProviderManager.setMapping("test-task", inst.id);
+    expect(ProviderManager.getMappings()["test-task"]).toBe(inst.id);
+
+    ProviderManager.setMapping("test-task", "");
+    expect(ProviderManager.getMappings()["test-task"]).toBeUndefined();
+  });
+
+  test("create returns instance with correct fields and endpointUrl support", () => {
+    const inst = ProviderManager.create(
+      "Ollama Local",
+      "ollama",
+      "",
+      "llama3.1",
+      "generative",
+      32768,
+      "http://localhost:11434",
+    );
+
+    expect(inst.id).toMatch(/^provider-/);
+    expect(inst.name).toBe("Ollama Local");
+    expect(inst.providerName).toBe("ollama");
+    expect(inst.modelName).toBe("llama3.1");
+    expect(inst.endpointUrl).toBe("http://localhost:11434");
+  });
+
+  test("update preserves apiKey when not provided", () => {
+    const inst = ProviderManager.create(
+      "Original",
+      "openai",
+      "original-key",
+      "gpt-4o",
+      "generative",
+      128000,
+    );
+
+    ProviderManager.update(
+      inst.id,
+      "Renamed",
+      "openai",
+      undefined, // no apiKey → preserve existing
+      "gpt-4o-mini",
+      "generative",
+      64000,
+    );
+
+    const updated = ProviderManager.list().find((p) => p.id === inst.id);
+    expect(updated?.name).toBe("Renamed");
+    expect(updated?.apiKey).toBe("original-key"); // preserved
+    expect(updated?.modelName).toBe("gpt-4o-mini");
+    expect(updated?.maxContext).toBe(64000);
+  });
+  test("treats created instances as normal provider instances (editable and deletable)", () => {
+    const inst = ProviderManager.create(
+      "Google Gemini (Env)",
+      "google-genai",
+      "mock-google-key-123",
+      "gemini-2.5-flash",
+      "generative",
+    );
+
+    const list = ProviderManager.list();
+    expect(list.length).toBe(1);
+    const created = list.find((p) => p.id === inst.id);
+    expect(created).toBeDefined();
+    if (!created) return;
+    expect(created.isActive).toBe(true);

    // Edit name and key
    ProviderManager.update(
-      bootstrapped.id,
+      created.id,
      "My Gemini Key",
      "google-genai",
      "new-secret-key",
@@ -92,8 +230,8 @@ describe("ProviderManager Bootstrapping & CRUD Unit Tests", () => {
    );

    const listAfterUpdate = ProviderManager.list();
-    expect(listAfterUpdate.length).toBe(2);
-    const updated = listAfterUpdate.find((p) => p.id === bootstrapped.id);
+    expect(listAfterUpdate.length).toBe(1);
+    const updated = listAfterUpdate.find((p) => p.id === created.id);
    expect(updated).toBeDefined();
    if (!updated) return;
    expect(updated.name).toBe("My Gemini Key");
@@ -101,8 +239,8 @@ describe("ProviderManager Bootstrapping & CRUD Unit Tests", () => {
    expect(updated.modelName).toBe("gemini-2.5-pro");

    // Delete instance
-    ProviderManager.delete(bootstrapped.id);
+    ProviderManager.delete(created.id);
    const listAfterDelete = ProviderManager.list();
-    expect(listAfterDelete.length).toBe(1);
+    expect(listAfterDelete.length).toBe(0);
  });
 });
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -263,9 +263,15 @@ importers:
      "@langchain/anthropic":
        specifier: ^0.3.11
        version: 0.3.34(zod@4.4.3)
+      "@langchain/deepseek":
+        specifier: ^1.1.5
+        version: 1.1.5(ws@8.21.0)
      "@langchain/google-genai":
        specifier: ^2.2.0
        version: 2.2.0(@langchain/core@1.2.1(openai@6.45.0(ws@8.21.0)(zod@4.4.3))(ws@8.21.0))
+      "@langchain/groq":
+        specifier: ^1.3.1
+        version: 1.3.1
      "@langchain/ollama":
        specifier: ^0.2.3
        version: 0.2.4
@@ -2086,6 +2092,15 @@ packages:
      }
    engines: { node: ">=20" }

+  "@langchain/deepseek@1.1.5":
+    resolution:
+      {
+        integrity: sha512-5IRoEUaHAgIF8TyIncNVhhjavCqsjWTjakWsnus1yJN2X3W15Bw8Qmf+vJzCnFo7yndICsGdOGfHJoIN5xNxoQ==,
+      }
+    engines: { node: ">=20" }
+    peerDependencies:
+      "@langchain/core": ^1.0.0
+
  "@langchain/google-genai@2.2.0":
    resolution:
      {
@@ -2095,6 +2110,15 @@ packages:
    peerDependencies:
      "@langchain/core": ^1.2.0

+  "@langchain/groq@1.3.1":
+    resolution:
+      {
+        integrity: sha512-ImxfGBis4FEHpZdeT6dot6V6l09uBLYm/1BHQ6x3XEQmJFF7aKwbOeSOV5h/h5IeRx+2gaInR+LfyYoqT8satQ==,
+      }
+    engines: { node: ">=20" }
+    peerDependencies:
+      "@langchain/core": ^1.1.30
+
  "@langchain/ollama@0.2.4":
    resolution:
      {
@@ -2122,6 +2146,15 @@ packages:
    peerDependencies:
      "@langchain/core": ^1.2.1

+  "@langchain/openai@1.5.5":
+    resolution:
+      {
+        integrity: sha512-wX7dwb9z4nf5FHXlIl/X2mk08pzonvRHCt1D4+s1zXLP0duYDC95j7dulPIQJ6fmhbyYQc9Ki8mEhY/D1lB8kw==,
+      }
+    engines: { node: ">=20" }
+    peerDependencies:
+      "@langchain/core": ^1.2.2
+
  "@langchain/openrouter@0.4.3":
    resolution:
      {
@@ -6081,6 +6114,13 @@ packages:
        integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==,
      }

+  groq-sdk@1.3.0:
+    resolution:
+      {
+        integrity: sha512-mvgUIpAxlk/VxWIoliHx4R+Ha78Bd/g0t24OFjCXtdLbNiY1rW4h9AcznKBwFho7K/Nq732ZSjxMYkNb1xeCFg==,
+      }
+    hasBin: true
+
  h3@1.15.11:
    resolution:
      {
@@ -10631,11 +10671,24 @@ snapshots:
      - openai
      - ws

+  "@langchain/deepseek@1.1.5(ws@8.21.0)":
+    dependencies:
+      "@langchain/openai": 1.5.5(ws@8.21.0)
+    transitivePeerDependencies:
+      - "@aws-sdk/credential-provider-node"
+      - "@smithy/hash-node"
+      - "@smithy/signature-v4"
+      - ws
+
  "@langchain/google-genai@2.2.0(@langchain/core@1.2.1(openai@6.45.0(ws@8.21.0)(zod@4.4.3))(ws@8.21.0))":
    dependencies:
      "@google/generative-ai": 0.24.1
      "@langchain/core": 1.2.1(openai@6.45.0(ws@8.21.0)(zod@4.4.3))(ws@8.21.0)

+  "@langchain/groq@1.3.1":
+    dependencies:
+      groq-sdk: 1.3.0
+
  "@langchain/ollama@0.2.4":
    dependencies:
      ollama: 0.5.18
@@ -10662,6 +10715,17 @@ snapshots:
      - "@smithy/signature-v4"
      - ws

+  "@langchain/openai@1.5.5(ws@8.21.0)":
+    dependencies:
+      js-tiktoken: 1.0.21
+      openai: 6.45.0(ws@8.21.0)(zod@4.4.3)
+      zod: 4.4.3
+    transitivePeerDependencies:
+      - "@aws-sdk/credential-provider-node"
+      - "@smithy/hash-node"
+      - "@smithy/signature-v4"
+      - ws
+
  "@langchain/openrouter@0.4.3(ws@8.21.0)(zod@4.4.3)":
    dependencies:
      "@langchain/openai": 1.5.3(ws@8.21.0)
@@ -13315,6 +13379,8 @@ snapshots:

  graceful-fs@4.2.11: {}

+  groq-sdk@1.3.0: {}
+
  h3@1.15.11:
    dependencies:
      cookie-es: 1.2.3
--- a/web/docs/src/content/docs/architecture/llm-providers.md
+++ b/web/docs/src/content/docs/architecture/llm-providers.md
@@ -71,14 +71,27 @@ If no specific provider instance is mapped to a task, the task automatically rou

 ---

-## Automatic Bootstrapping (Environment Key Fallback)
+## CLI Setup & Seeding

-To maintain backwards-compatibility and support headless runs, live evaluation suites, and automated unit tests without requiring database pre-configuration, the config manager supports **self-bootstrapping**:
+Rather than automatically bootstrapping from environment variables at runtime, which adds runtime complexity, you can quickly seed the database using the CLI setup tool:

-1. When any database connection is initialized via the provider manager, if `data/settings.db` contains **0 registered keys**, it checks the process environment for `GOOGLE_API_KEY` and `OPENROUTER_API_KEY`.
-2. If `process.env.GOOGLE_API_KEY` is present, it automatically creates, saves, and activates a default provider instance (`Gemini (Env)`) in `settings.db`.
-3. If `process.env.OPENROUTER_API_KEY` is present, it automatically creates and saves a default provider instance (`OpenRouter (Env)`) in `settings.db`.
-4. If database write locks occur (e.g., during high-concurrency Vitest test suites), the system seamlessly returns a temporary in-memory `LLMProviderInstance` (`Gemini (Env Fallback)` or `OpenRouter (Env Fallback)`) to keep execution fluent and error-free.
+### Seeding All Environment-Variable Providers
+
+```bash
+pnpm setup-provider --all
+```
+
+This command auto-detects and inserts provider instances into `data/settings.db` for any registered providers whose corresponding environment variables (such as `GOOGLE_API_KEY`, `OPENAI_API_KEY`, etc.) are defined.
+
+### Creating a Specific Provider Instance
+
+```bash
+pnpm setup-provider --provider google-genai --key YOUR_API_KEY [--name "My Gemini"] [--model gemini-2.5-flash] [--type generative] [--max-context 32768] [--endpoint url]
+```
+
+### Environment Variable Fallback
+
+If the database contains no active provider instances, the LLM providers (e.g. `GeminiProvider`, `OpenAIProvider`, etc.) will fall back directly to reading their keys from environment variables (e.g. `GOOGLE_API_KEY`, `OPENAI_API_KEY`) via `resolveCredentials`.

 ---
Author	SHA1	Message	Date
Tom Pike	61ea9fe237	refactor!(llm): Remove bootstrapper in favor of setup-provider	2026-07-16 22:21:59 +05:30
Aditya Gupta	250bb87a8d	refactor!(llm): implement new model registration system	2026-07-16 22:05:45 +05:30
Aditya Gupta	8ad94d3fc2	feat(llm): Dynamically fetch available models from providers	2026-07-16 19:16:55 +05:30
Aditya Gupta	2b56c01e4c	feat(llm): Added Groq and Deepseek providers	2026-07-16 18:25:07 +05:30