feat(01-02): create provider registry and factory

Add provider registry in src/lib/providers/index.ts:
- Export all types from types.ts
- providerRegistry for storing provider implementations
- registerProvider() for providers to self-register
- getProvider() to retrieve provider by type
- getConfiguredProviders() to get providers with API keys
- getAllProviders() to get all registered providers

Registry will be populated when provider modules are imported
in Phase 2 (Replicate and fal.ai implementations).

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/lib/providers/index.ts

@@ -0,0 +1,90 @@
+/**
+ * Provider Registry and Factory
+ *
+ * Central registry for AI provider implementations. Providers register themselves
+ * when their modules are imported, enabling dynamic provider discovery.
+ *
+ * Usage:
+ *   import { getProvider, getConfiguredProviders } from "@/lib/providers";
+ *
+ *   // Get a specific provider
+ *   const replicate = getProvider("replicate");
+ *
+ *   // Get all providers with API keys configured
+ *   const available = getConfiguredProviders();
+ *
+ * Phase 2 Implementation Notes:
+ * - Replicate and fal.ai provider implementations will register themselves here
+ * - Gemini remains special-cased in existing generate route for now
+ * - Each provider module calls registerProvider() on import
+ */
+
+import { ProviderType } from "@/types";
+import { ProviderInterface } from "./types";
+
+// Re-export all types for convenient imports
+export * from "./types";
+
+/**
+ * Provider registry - populated by provider implementations when they are imported.
+ * Initially empty; providers call registerProvider() to add themselves.
+ *
+ * Phase 2 will add:
+ * - ReplicateProvider (registers as "replicate")
+ * - FalProvider (registers as "fal")
+ *
+ * Note: Gemini provider is currently implemented directly in /api/generate route.
+ * It may be migrated to this abstraction in a future phase.
+ */
+const providerRegistry: Partial<Record<ProviderType, ProviderInterface>> = {};
+
+/**
+ * Register a provider implementation in the registry.
+ * Called by provider modules when they are imported.
+ *
+ * @param provider - The provider implementation to register
+ *
+ * @example
+ * // In src/lib/providers/replicate.ts:
+ * import { registerProvider, ProviderInterface } from "@/lib/providers";
+ *
+ * const replicateProvider: ProviderInterface = { ... };
+ * registerProvider(replicateProvider);
+ */
+export function registerProvider(provider: ProviderInterface): void {
+  providerRegistry[provider.id] = provider;
+}
+
+/**
+ * Get a provider by its type identifier.
+ *
+ * @param id - The provider type (e.g., "replicate", "fal")
+ * @returns The provider implementation or undefined if not registered
+ */
+export function getProvider(id: ProviderType): ProviderInterface | undefined {
+  return providerRegistry[id];
+}
+
+/**
+ * Get all providers that have API keys configured.
+ * Useful for showing available options in the UI.
+ *
+ * @returns Array of configured provider implementations
+ */
+export function getConfiguredProviders(): ProviderInterface[] {
+  return Object.values(providerRegistry).filter(
+    (p): p is ProviderInterface => p !== undefined && p.isConfigured()
+  );
+}
+
+/**
+ * Get all registered providers regardless of configuration status.
+ * Useful for settings UI where users can configure API keys.
+ *
+ * @returns Array of all registered provider implementations
+ */
+export function getAllProviders(): ProviderInterface[] {
+  return Object.values(providerRegistry).filter(
+    (p): p is ProviderInterface => p !== undefined
+  );
+}