@open-mercato/ai-assistant 0.4.11-develop.2226.2963a4b52d → 0.4.11-develop.2229.54cd746c6e

package/src/modules/ai_assistant/lib/__tests__/llm-adapters-google.test.ts

@@ -0,0 +1,71 @@
+import { createGoogleAdapter } from '../llm-adapters/google'
+
+describe('GoogleAdapter', () => {
+  const adapter = createGoogleAdapter()
+
+  it('has expected id, name, envKeys and defaultModel', () => {
+    expect(adapter.id).toBe('google')
+    expect(adapter.name).toBe('Google')
+    expect(adapter.envKeys).toEqual(['GOOGLE_GENERATIVE_AI_API_KEY', 'OPENCODE_GOOGLE_API_KEY'])
+    expect(adapter.defaultModel).toBe('gemini-3-flash')
+    expect(adapter.defaultModels.length).toBeGreaterThan(0)
+  })
+
+  it('detects configuration from env', () => {
+    expect(
+      adapter.isConfigured({ GOOGLE_GENERATIVE_AI_API_KEY: 'AIza-key' }),
+    ).toBe(true)
+    expect(adapter.isConfigured({})).toBe(false)
+    expect(
+      adapter.isConfigured({ GOOGLE_GENERATIVE_AI_API_KEY: '  ' }),
+    ).toBe(false)
+  })
+
+  it('detects configuration from OPENCODE_* fallback env', () => {
+    expect(
+      adapter.isConfigured({ OPENCODE_GOOGLE_API_KEY: 'AIza-key' }),
+    ).toBe(true)
+    expect(
+      adapter.isConfigured({ OPENCODE_GOOGLE_API_KEY: '' }),
+    ).toBe(false)
+  })
+
+  it('resolves API key from env', () => {
+    expect(
+      adapter.resolveApiKey({ GOOGLE_GENERATIVE_AI_API_KEY: 'AIza-key' }),
+    ).toBe('AIza-key')
+    expect(adapter.resolveApiKey({})).toBeNull()
+  })
+
+  it('resolves API key from OPENCODE_* fallback env', () => {
+    expect(
+      adapter.resolveApiKey({ OPENCODE_GOOGLE_API_KEY: 'opencode-key' }),
+    ).toBe('opencode-key')
+    expect(
+      adapter.resolveApiKey({
+        GOOGLE_GENERATIVE_AI_API_KEY: 'primary',
+        OPENCODE_GOOGLE_API_KEY: 'fallback',
+      }),
+    ).toBe('primary')
+  })
+
+  it('returns the configured env key name for diagnostics', () => {
+    expect(
+      adapter.getConfiguredEnvKey({
+        GOOGLE_GENERATIVE_AI_API_KEY: 'AIza',
+      }),
+    ).toBe('GOOGLE_GENERATIVE_AI_API_KEY')
+    expect(adapter.getConfiguredEnvKey({})).toBe(
+      'GOOGLE_GENERATIVE_AI_API_KEY',
+    )
+  })
+
+  it('createModel returns a non-null AI SDK model instance', () => {
+    const model = adapter.createModel({
+      apiKey: 'AIza-test',
+      modelId: 'gemini-3-flash',
+    })
+    expect(model).toBeDefined()
+    expect(model).not.toBeNull()
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/llm-adapters-openai.test.ts

@@ -0,0 +1,160 @@
+import {
+  createOpenAICompatibleProvider,
+  type OpenAICompatiblePreset,
+} from '../llm-adapters/openai'
+import { OPENAI_COMPATIBLE_PRESETS } from '../openai-compatible-presets'
+
+const DEEPINFRA_PRESET: OpenAICompatiblePreset = {
+  id: 'deepinfra',
+  name: 'DeepInfra',
+  baseURL: 'https://api.deepinfra.com/v1/openai',
+  envKeys: ['DEEPINFRA_API_KEY'],
+  defaultModel: 'zai-org/GLM-5.1',
+  defaultModels: [
+    {
+      id: 'zai-org/GLM-5.1',
+      name: 'GLM-5.1',
+      contextWindow: 202752,
+      tags: ['flagship'],
+    },
+  ],
+}
+
+describe('OpenAIAdapter (OpenAI-compatible provider factory)', () => {
+  it('validates preset shape at construction time', () => {
+    expect(() =>
+      createOpenAICompatibleProvider({
+        ...DEEPINFRA_PRESET,
+        id: '',
+      }),
+    ).toThrow('must have a non-empty id')
+
+    expect(() =>
+      createOpenAICompatibleProvider({
+        ...DEEPINFRA_PRESET,
+        envKeys: [],
+      }),
+    ).toThrow('must declare at least one env key')
+  })
+
+  it('exposes preset metadata through the LlmProvider port', () => {
+    const provider = createOpenAICompatibleProvider(DEEPINFRA_PRESET)
+    expect(provider.id).toBe('deepinfra')
+    expect(provider.name).toBe('DeepInfra')
+    expect(provider.envKeys).toEqual(['DEEPINFRA_API_KEY'])
+    expect(provider.defaultModel).toBe('zai-org/GLM-5.1')
+    expect(provider.defaultModels[0].id).toBe('zai-org/GLM-5.1')
+  })
+
+  it('detects configuration via the preset-specific env key', () => {
+    const provider = createOpenAICompatibleProvider(DEEPINFRA_PRESET)
+    expect(provider.isConfigured({ DEEPINFRA_API_KEY: 'key' })).toBe(true)
+    // Unrelated env key does NOT configure the preset.
+    expect(provider.isConfigured({ OPENAI_API_KEY: 'unrelated' })).toBe(
+      false,
+    )
+    expect(provider.isConfigured({})).toBe(false)
+  })
+
+  it('resolves API key and env key name for diagnostics', () => {
+    const provider = createOpenAICompatibleProvider(DEEPINFRA_PRESET)
+    expect(
+      provider.resolveApiKey({ DEEPINFRA_API_KEY: 'secret' }),
+    ).toBe('secret')
+    expect(
+      provider.getConfiguredEnvKey({ DEEPINFRA_API_KEY: 'secret' }),
+    ).toBe('DEEPINFRA_API_KEY')
+    expect(provider.getConfiguredEnvKey({})).toBe('DEEPINFRA_API_KEY')
+  })
+
+  it('createModel returns a non-null AI SDK model instance', () => {
+    const provider = createOpenAICompatibleProvider(DEEPINFRA_PRESET)
+    const model = provider.createModel({
+      apiKey: 'test-key',
+      modelId: 'zai-org/GLM-5.1',
+    })
+    expect(model).toBeDefined()
+    expect(model).not.toBeNull()
+  })
+
+  it('createModel honors per-call baseURL override', () => {
+    const provider = createOpenAICompatibleProvider(DEEPINFRA_PRESET)
+    // AI SDK does not crash when baseURL is overridden per-call.
+    const model = provider.createModel({
+      apiKey: 'test-key',
+      modelId: 'zai-org/GLM-5.1',
+      baseURL: 'https://example.com/v1',
+    })
+    expect(model).toBeDefined()
+  })
+
+  it('azure preset honors baseURLEnvKeys override', () => {
+    const azurePreset = OPENAI_COMPATIBLE_PRESETS.find(
+      (p) => p.id === 'azure',
+    )
+    expect(azurePreset).toBeDefined()
+    expect(azurePreset?.baseURLEnvKeys).toContain('AZURE_OPENAI_BASE_URL')
+    // Sanity: the adapter can be created from the preset.
+    const provider = createOpenAICompatibleProvider(azurePreset!)
+    expect(provider.id).toBe('azure')
+  })
+})
+
+describe('OpenAI preset OPENCODE_* fallback env keys', () => {
+  it('openai preset includes OPENCODE_OPENAI_API_KEY fallback', () => {
+    const openaiPreset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'openai')
+    expect(openaiPreset).toBeDefined()
+    expect(openaiPreset!.envKeys).toContain('OPENAI_API_KEY')
+    expect(openaiPreset!.envKeys).toContain('OPENCODE_OPENAI_API_KEY')
+  })
+
+  it('resolves API key from OPENCODE_OPENAI_API_KEY fallback', () => {
+    const openaiPreset = OPENAI_COMPATIBLE_PRESETS.find((p) => p.id === 'openai')
+    const provider = createOpenAICompatibleProvider(openaiPreset!)
+    expect(
+      provider.resolveApiKey({ OPENCODE_OPENAI_API_KEY: 'opencode-key' }),
+    ).toBe('opencode-key')
+    expect(
+      provider.resolveApiKey({
+        OPENAI_API_KEY: 'primary',
+        OPENCODE_OPENAI_API_KEY: 'fallback',
+      }),
+    ).toBe('primary')
+  })
+})
+
+describe('OPENAI_COMPATIBLE_PRESETS built-in catalog', () => {
+  it('ships at least 8 built-in presets including openai and deepinfra', () => {
+    expect(OPENAI_COMPATIBLE_PRESETS.length).toBeGreaterThanOrEqual(8)
+    const ids = OPENAI_COMPATIBLE_PRESETS.map((p) => p.id)
+    expect(ids).toContain('openai')
+    expect(ids).toContain('deepinfra')
+    expect(ids).toContain('groq')
+    expect(ids).toContain('together')
+    expect(ids).toContain('fireworks')
+    expect(ids).toContain('azure')
+    expect(ids).toContain('litellm')
+    expect(ids).toContain('ollama')
+  })
+
+  it('every preset has at least one model and one env key', () => {
+    for (const preset of OPENAI_COMPATIBLE_PRESETS) {
+      expect(preset.envKeys.length).toBeGreaterThan(0)
+      expect(preset.defaultModels.length).toBeGreaterThan(0)
+      expect(preset.defaultModel.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('every preset defaultModel exists in its defaultModels array', () => {
+    for (const preset of OPENAI_COMPATIBLE_PRESETS) {
+      const ids = preset.defaultModels.map((m) => m.id)
+      expect(ids).toContain(preset.defaultModel)
+    }
+  })
+
+  it('every preset id is unique', () => {
+    const ids = OPENAI_COMPATIBLE_PRESETS.map((p) => p.id)
+    const unique = new Set(ids)
+    expect(unique.size).toBe(ids.length)
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/llm-bootstrap.test.ts

@@ -0,0 +1,81 @@
+import { llmProviderRegistry } from '@open-mercato/shared/lib/ai/llm-provider-registry'
+import {
+  registerBuiltInLlmProviders,
+  resetLlmBootstrapState,
+} from '../llm-bootstrap'
+
+describe('llm-bootstrap — built-in provider registration', () => {
+  beforeEach(() => {
+    llmProviderRegistry.reset()
+    resetLlmBootstrapState()
+  })
+
+  it('registers the three native providers and all OpenAI-compatible presets', () => {
+    registerBuiltInLlmProviders()
+    const ids = llmProviderRegistry.list().map((p) => p.id)
+
+    // Native protocol adapters.
+    expect(ids).toContain('anthropic')
+    expect(ids).toContain('google')
+
+    // OpenAI-compatible presets.
+    expect(ids).toContain('openai')
+    expect(ids).toContain('deepinfra')
+    expect(ids).toContain('groq')
+    expect(ids).toContain('together')
+    expect(ids).toContain('fireworks')
+    expect(ids).toContain('azure')
+    expect(ids).toContain('litellm')
+    expect(ids).toContain('ollama')
+
+    expect(ids.length).toBeGreaterThanOrEqual(10)
+  })
+
+  it('is idempotent — calling twice does not duplicate entries', () => {
+    registerBuiltInLlmProviders()
+    const afterFirst = llmProviderRegistry.list().length
+    registerBuiltInLlmProviders()
+    const afterSecond = llmProviderRegistry.list().length
+    expect(afterSecond).toBe(afterFirst)
+  })
+
+  it('re-registers after registry reset when bootstrap state is reset', () => {
+    registerBuiltInLlmProviders()
+    expect(llmProviderRegistry.list().length).toBeGreaterThan(0)
+
+    llmProviderRegistry.reset()
+    resetLlmBootstrapState()
+    expect(llmProviderRegistry.list().length).toBe(0)
+
+    registerBuiltInLlmProviders()
+    expect(llmProviderRegistry.list().length).toBeGreaterThan(0)
+  })
+
+  it('anthropic provider comes from the AnthropicAdapter factory', () => {
+    registerBuiltInLlmProviders()
+    const anthropic = llmProviderRegistry.get('anthropic')
+    expect(anthropic).not.toBeNull()
+    expect(anthropic?.name).toBe('Anthropic')
+    expect(anthropic?.envKeys).toEqual(['ANTHROPIC_API_KEY', 'OPENCODE_ANTHROPIC_API_KEY'])
+    expect(anthropic?.defaultModel).toBe('claude-haiku-4-5-20251001')
+  })
+
+  it('deepinfra provider comes from the OpenAI-compatible preset', () => {
+    registerBuiltInLlmProviders()
+    const deepinfra = llmProviderRegistry.get('deepinfra')
+    expect(deepinfra).not.toBeNull()
+    expect(deepinfra?.envKeys).toEqual(['DEEPINFRA_API_KEY'])
+    expect(deepinfra?.defaultModel).toBe('zai-org/GLM-5.1')
+    const modelIds = deepinfra?.defaultModels.map((m) => m.id) ?? []
+    expect(modelIds).toContain('zai-org/GLM-5.1')
+    expect(modelIds).toContain('Qwen/Qwen3-235B-A22B-Instruct-2507')
+  })
+
+  it('resolveFirstConfigured picks a configured provider from the registry', () => {
+    registerBuiltInLlmProviders()
+    const picked = llmProviderRegistry.resolveFirstConfigured({
+      env: { DEEPINFRA_API_KEY: 'deepinfra-key' },
+    })
+    expect(picked?.id).toBe('deepinfra')
+  })
+})

package/src/modules/ai_assistant/lib/ai-sdk.ts

@@ -3,3 +3,13 @@ export { streamText, generateObject, stepCountIs } from 'ai'
 export { createOpenAI } from '@ai-sdk/openai'
 export { createAnthropic } from '@ai-sdk/anthropic'
 export { createGoogleGenerativeAI } from '@ai-sdk/google'
+
+// Side-effect import: registers built-in LLM providers (Anthropic, Google,
+// OpenAI + OpenAI-compatible presets for DeepInfra, Groq, Together, etc.)
+// with the shared `llmProviderRegistry` singleton. Consumers that import
+// from `./ai-sdk` transitively trigger provider bootstrap, so any module
+// using `generateObject` / `streamText` already has the registry populated.
+//
+// @see ./llm-bootstrap.ts
+// @see .ai/specs/2026-04-14-llm-provider-ports-and-adapters.md
+import './llm-bootstrap'

package/src/modules/ai_assistant/lib/chat-config.ts

@@ -1,13 +1,19 @@
 import type { ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
-import {
-  OPEN_CODE_PROVIDER_IDS,
-  OPEN_CODE_PROVIDERS,
-  isOpenCodeProviderConfigured,
-  type OpenCodeProviderId,
-} from '@open-mercato/shared/lib/ai/opencode-provider'
+import { llmProviderRegistry } from '@open-mercato/shared/lib/ai/llm-provider-registry'
+import type { LlmProvider } from '@open-mercato/shared/lib/ai/llm-provider'
+// Side-effect: ensures the registry is populated with built-in adapters
+// and OpenAI-compatible presets before this module's getters run.
+import './llm-bootstrap'
 
 // Types
-export type ChatProviderId = OpenCodeProviderId
+//
+// `ChatProviderId` was previously a narrow literal union of three ids
+// (`'anthropic' | 'openai' | 'google'`). After the ports & adapters
+// refactor the registry accepts any stable id string, so this type
+// becomes `string`. Backward-compatibility note: downstream callers that
+// used exhaustive switches on the old union must add a `default:` branch.
+// See `.ai/specs/2026-04-14-llm-provider-ports-and-adapters.md`.
+export type ChatProviderId = string
 
 export type ChatModelInfo = {
   id: string
@@ -31,51 +37,74 @@ export type ChatProviderConfig = {
 // Constants
 export const CHAT_CONFIG_KEY = 'chat_provider'
 
-export const CHAT_PROVIDERS: Record<ChatProviderId, ChatProviderInfo> = {
-  openai: {
-    name: OPEN_CODE_PROVIDERS.openai.name,
-    envKeyRequired: OPEN_CODE_PROVIDERS.openai.envKeys[0],
-    defaultModel: OPEN_CODE_PROVIDERS.openai.defaultModel,
-    models: [
-      { id: OPEN_CODE_PROVIDERS.openai.defaultModel, name: 'GPT-4o Mini', contextWindow: 128000 },
-    ],
-  },
-  anthropic: {
-    name: OPEN_CODE_PROVIDERS.anthropic.name,
-    envKeyRequired: OPEN_CODE_PROVIDERS.anthropic.envKeys[0],
-    defaultModel: OPEN_CODE_PROVIDERS.anthropic.defaultModel,
-    models: [
-      { id: OPEN_CODE_PROVIDERS.anthropic.defaultModel, name: 'Claude Haiku 4.5', contextWindow: 200000 },
-    ],
-  },
-  google: {
-    name: OPEN_CODE_PROVIDERS.google.name,
-    envKeyRequired: OPEN_CODE_PROVIDERS.google.envKeys[0],
-    defaultModel: OPEN_CODE_PROVIDERS.google.defaultModel,
-    models: [
-      { id: OPEN_CODE_PROVIDERS.google.defaultModel, name: 'Gemini 3 Flash', contextWindow: 1048576 },
-    ],
-  },
+function providerToChatInfo(provider: LlmProvider): ChatProviderInfo {
+  return {
+    name: provider.name,
+    envKeyRequired: provider.envKeys[0],
+    defaultModel: provider.defaultModel,
+    models: provider.defaultModels.map((m) => ({
+      id: m.id,
+      name: m.name,
+      contextWindow: m.contextWindow,
+    })),
+  }
 }
 
+/**
+ * `CHAT_PROVIDERS` is a dynamic getter that returns all providers
+ * registered with `llmProviderRegistry`. The shape
+ * (`Record<string, ChatProviderInfo>`) is preserved so existing code that
+ * indexed the map with a string literal (`CHAT_PROVIDERS['anthropic']`)
+ * keeps working — it is now a runtime lookup against the registry.
+ */
+export const CHAT_PROVIDERS: Record<string, ChatProviderInfo> = new Proxy(
+  {} as Record<string, ChatProviderInfo>,
+  {
+    get(_target, prop: string): ChatProviderInfo | undefined {
+      if (typeof prop !== 'string') return undefined
+      const provider = llmProviderRegistry.get(prop)
+      return provider ? providerToChatInfo(provider) : undefined
+    },
+    has(_target, prop: string): boolean {
+      if (typeof prop !== 'string') return false
+      return llmProviderRegistry.get(prop) !== null
+    },
+    ownKeys(): string[] {
+      return llmProviderRegistry.list().map((p) => p.id)
+    },
+    getOwnPropertyDescriptor(_target, prop: string): PropertyDescriptor | undefined {
+      if (typeof prop !== 'string') return undefined
+      const provider = llmProviderRegistry.get(prop)
+      if (!provider) return undefined
+      return {
+        enumerable: true,
+        configurable: true,
+        value: providerToChatInfo(provider),
+      }
+    },
+  },
+)
+
 export const DEFAULT_CHAT_CONFIG: Omit<ChatProviderConfig, 'updatedAt'> = {
   providerId: 'openai',
-  model: OPEN_CODE_PROVIDERS.openai.defaultModel,
+  get model(): string {
+    // Lazy resolution so the bootstrap has a chance to register providers
+    // before the default is computed.
+    const provider = llmProviderRegistry.get('openai')
+    return provider?.defaultModel ?? 'gpt-5-mini'
+  },
 }
 
 // Provider configuration checks
 export function isProviderConfigured(providerId: ChatProviderId): boolean {
-  return isOpenCodeProviderConfigured(providerId)
+  const provider = llmProviderRegistry.get(providerId)
+  return provider?.isConfigured() ?? false
 }
 
 export function getConfiguredProviders(): ChatProviderId[] {
-  const providers: ChatProviderId[] = []
-  for (const providerId of OPEN_CODE_PROVIDER_IDS) {
-    if (isProviderConfigured(providerId)) {
-      providers.push(providerId)
-    }
-  }
-  return providers
+  return llmProviderRegistry
+    .listConfigured()
+    .map((p) => p.id)
 }
 
 // Config resolution
@@ -121,7 +150,11 @@ export async function saveChatConfig(
 }
 
 export function createDefaultConfig(): ChatProviderConfig {
-  return { ...DEFAULT_CHAT_CONFIG, updatedAt: new Date().toISOString() }
+  return {
+    providerId: DEFAULT_CHAT_CONFIG.providerId,
+    model: DEFAULT_CHAT_CONFIG.model,
+    updatedAt: new Date().toISOString(),
+  }
 }
 
 // Get model info by ID

package/src/modules/ai_assistant/lib/llm-adapters/anthropic.ts

@@ -0,0 +1,91 @@
+/**
+ * AnthropicAdapter — implements the LlmProvider port for Anthropic's
+ * Messages API (Claude Haiku, Sonnet, Opus).
+ *
+ * Wraps `createAnthropic({ apiKey })` from `@ai-sdk/anthropic` and exposes
+ * a curated model list for the AI Assistant UI dropdown.
+ *
+ * @see packages/shared/src/lib/ai/llm-provider.ts
+ * @see .ai/specs/2026-04-14-llm-provider-ports-and-adapters.md
+ */
+
+import { createAnthropic } from '@ai-sdk/anthropic'
+import type {
+  EnvLookup,
+  LlmCreateModelOptions,
+  LlmModelInfo,
+  LlmProvider,
+} from '@open-mercato/shared/lib/ai/llm-provider'
+
+const DEFAULT_MODEL = 'claude-haiku-4-5-20251001'
+
+const DEFAULT_MODELS: readonly LlmModelInfo[] = [
+  {
+    id: 'claude-haiku-4-5-20251001',
+    name: 'Claude Haiku 4.5',
+    contextWindow: 200000,
+    tags: ['budget'],
+  },
+  {
+    id: 'claude-sonnet-4-6-20260107',
+    name: 'Claude Sonnet 4.6',
+    contextWindow: 200000,
+    tags: ['flagship'],
+  },
+  {
+    id: 'claude-opus-4-6-20260107',
+    name: 'Claude Opus 4.6',
+    contextWindow: 1000000,
+    tags: ['flagship', 'reasoning'],
+  },
+] as const
+
+/**
+ * Factory returning a fresh `AnthropicAdapter` instance. The adapter is
+ * stateless — caller is free to reuse the returned object.
+ */
+export function createAnthropicAdapter(): LlmProvider {
+  const envKeys = ['ANTHROPIC_API_KEY', 'OPENCODE_ANTHROPIC_API_KEY'] as const
+
+  function resolveApiKey(env?: EnvLookup): string | null {
+    const lookup = env ?? process.env
+    for (const key of envKeys) {
+      const value = lookup[key]
+      if (typeof value === 'string') {
+        const trimmed = value.trim()
+        if (trimmed.length > 0) return trimmed
+      }
+    }
+    return null
+  }
+
+  return {
+    id: 'anthropic',
+    name: 'Anthropic',
+    envKeys,
+    defaultModel: DEFAULT_MODEL,
+    defaultModels: DEFAULT_MODELS,
+
+    isConfigured(env?: EnvLookup): boolean {
+      return resolveApiKey(env) !== null
+    },
+
+    resolveApiKey,
+
+    getConfiguredEnvKey(env?: EnvLookup): string {
+      const lookup = env ?? process.env
+      for (const key of envKeys) {
+        const value = lookup[key]
+        if (typeof value === 'string' && value.trim().length > 0) {
+          return key
+        }
+      }
+      return envKeys[0]
+    },
+
+    createModel(options: LlmCreateModelOptions): unknown {
+      const anthropic = createAnthropic({ apiKey: options.apiKey })
+      return anthropic(options.modelId)
+    },
+  }
+}

package/src/modules/ai_assistant/lib/llm-adapters/google.ts

@@ -0,0 +1,80 @@
+/**
+ * GoogleAdapter — implements the LlmProvider port for Google's Generative
+ * AI API (Gemini Flash, Pro).
+ *
+ * Wraps `createGoogleGenerativeAI({ apiKey })` from `@ai-sdk/google`.
+ *
+ * @see packages/shared/src/lib/ai/llm-provider.ts
+ * @see .ai/specs/2026-04-14-llm-provider-ports-and-adapters.md
+ */
+
+import { createGoogleGenerativeAI } from '@ai-sdk/google'
+import type {
+  EnvLookup,
+  LlmCreateModelOptions,
+  LlmModelInfo,
+  LlmProvider,
+} from '@open-mercato/shared/lib/ai/llm-provider'
+
+const DEFAULT_MODEL = 'gemini-3-flash'
+
+const DEFAULT_MODELS: readonly LlmModelInfo[] = [
+  {
+    id: 'gemini-3-flash',
+    name: 'Gemini 3 Flash',
+    contextWindow: 1048576,
+    tags: ['budget'],
+  },
+  {
+    id: 'gemini-3-pro',
+    name: 'Gemini 3 Pro',
+    contextWindow: 1048576,
+    tags: ['flagship'],
+  },
+] as const
+
+export function createGoogleAdapter(): LlmProvider {
+  const envKeys = ['GOOGLE_GENERATIVE_AI_API_KEY', 'OPENCODE_GOOGLE_API_KEY'] as const
+
+  function resolveApiKey(env?: EnvLookup): string | null {
+    const lookup = env ?? process.env
+    for (const key of envKeys) {
+      const value = lookup[key]
+      if (typeof value === 'string') {
+        const trimmed = value.trim()
+        if (trimmed.length > 0) return trimmed
+      }
+    }
+    return null
+  }
+
+  return {
+    id: 'google',
+    name: 'Google',
+    envKeys,
+    defaultModel: DEFAULT_MODEL,
+    defaultModels: DEFAULT_MODELS,
+
+    isConfigured(env?: EnvLookup): boolean {
+      return resolveApiKey(env) !== null
+    },
+
+    resolveApiKey,
+
+    getConfiguredEnvKey(env?: EnvLookup): string {
+      const lookup = env ?? process.env
+      for (const key of envKeys) {
+        const value = lookup[key]
+        if (typeof value === 'string' && value.trim().length > 0) {
+          return key
+        }
+      }
+      return envKeys[0]
+    },
+
+    createModel(options: LlmCreateModelOptions): unknown {
+      const google = createGoogleGenerativeAI({ apiKey: options.apiKey })
+      return google(options.modelId)
+    },
+  }
+}