bazilion 0.0.0 → 0.1.0

package/apps/daemon/test/runtime/messaging.test.ts

@@ -1,213 +0,0 @@
-// Unit tests for the messaging `ToolHandler`s that Bazilion exposes as pi
-// customTools. Called directly here (not through the LLM loop) because the
-// tests are about tool *behaviour* — DB side effects, polling, error paths —
-// not about round-tripping through pi's agent loop.
-
-import { mkdirSync, mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import type { ResolvedAgent } from '@bazilion/api-types'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import {
-  agentRepo,
-  type BazilionDb,
-  createProfile,
-  messageRepo,
-  openInMemoryDb,
-  type Paths,
-  registerGroup,
-  resolveAgent,
-  resolvePaths,
-  runMigrations,
-  spawnAgent,
-} from '../../src/core/index.ts'
-import { messagingTools } from '../../src/runtime/tools/messaging.ts'
-import type { ToolHandler } from '../../src/runtime/tools/types.ts'
-import type { MessagingHost } from '../../src/runtime/worker/ipc-protocol.ts'
-
-function dbHost(db: BazilionDb): MessagingHost {
-  return {
-    agentExists: (id) => agentRepo.get(db, id) !== null,
-    sendMessage: (input) => ({ messageId: messageRepo.send(db, input).id }),
-    listInbox: (id, opts) => messageRepo.listInbox(db, id, opts),
-    markRead: (id) => messageRepo.markRead(db, id),
-    findReplies: (id, replyTo) => messageRepo.findReplies(db, id, replyTo),
-  }
-}
-
-interface Env {
-  home: string
-  paths: Paths
-  db: BazilionDb
-  groupId: string
-  cleanup(): void
-}
-
-function makeEnv(): Env {
-  const home = mkdtempSync(join(tmpdir(), 'bazilion-msg-'))
-  const paths = resolvePaths(home)
-  for (const d of [
-    paths.profilesDir,
-    paths.agentsDir,
-    paths.skillsDir,
-    paths.logsDir,
-    paths.groupsDir,
-  ]) {
-    mkdirSync(d, { recursive: true })
-  }
-  const db = openInMemoryDb()
-  runMigrations(db)
-  const g = registerGroup(db, { id: 'test-group', name: 'test' }, paths)
-  return {
-    home,
-    paths,
-    db,
-    groupId: g.id,
-    cleanup() {
-      db.close()
-      rmSync(home, { recursive: true, force: true })
-    },
-  }
-}
-
-function makeAgent(env: Env, name: string): ResolvedAgent {
-  const a = spawnAgent(env.db, env.paths, {
-    profileId: 'p',
-    name,
-    groupId: env.groupId,
-  })
-  return resolveAgent(env.db, env.paths, a.id)
-}
-
-function findHandler(handlers: ToolHandler[], name: string): ToolHandler {
-  const h = handlers.find((x) => x.def.name === name)
-  if (!h) throw new Error(`no handler: ${name}`)
-  return h
-}
-
-let env: Env
-beforeEach(() => {
-  env = makeEnv()
-  createProfile(env.db, env.paths, {
-    id: 'p',
-    defaultModel: 'mock:m',
-  })
-})
-afterEach(() => env.cleanup())
-
-test('send_message tool inserts a row addressed to the recipient', async () => {
-  const a = makeAgent(env, 'A')
-  const b = makeAgent(env, 'B')
-  const handlers = messagingTools(dbHost(env.db), a.agent.id)
-  const send = findHandler(handlers, 'send_message')
-
-  await send.invoke({ to: b.agent.id, text: 'hi B, this is A' })
-
-  const inbox = messageRepo.listInbox(env.db, b.agent.id)
-  expect(inbox).toHaveLength(1)
-  expect(inbox[0]?.fromAgentId).toBe(a.agent.id)
-  const payload = JSON.parse(inbox[0]?.payload ?? '{}')
-  expect(payload.text).toBe('hi B, this is A')
-})
-
-test('read_inbox returns unread messages and marks them read', async () => {
-  const a = makeAgent(env, 'A')
-  const b = makeAgent(env, 'B')
-
-  messageRepo.send(env.db, {
-    from: a.agent.id,
-    to: b.agent.id,
-    payload: JSON.stringify({ text: 'first' }),
-  })
-  messageRepo.send(env.db, {
-    from: a.agent.id,
-    to: b.agent.id,
-    payload: JSON.stringify({ text: 'second' }),
-  })
-
-  const handlers = messagingTools(dbHost(env.db), b.agent.id)
-  const read = findHandler(handlers, 'read_inbox')
-  const result = await read.invoke({})
-  expect(result).toContain('first')
-  expect(result).toContain('second')
-
-  // After read, inbox shows nothing (unreadOnly default)
-  const after = messageRepo.listInbox(env.db, b.agent.id, { unreadOnly: true })
-  expect(after).toHaveLength(0)
-})
-
-test('send_message + read_inbox round-trip preserves reply_to pointer', async () => {
-  const a = makeAgent(env, 'A')
-  const b = makeAgent(env, 'B')
-
-  // A sends B a question
-  const aHandlers = messagingTools(dbHost(env.db), a.agent.id)
-  const aSend = findHandler(aHandlers, 'send_message')
-  await aSend.invoke({ to: b.agent.id, text: 'B, what is 2+2?' })
-
-  const bInbox = messageRepo.listInbox(env.db, b.agent.id)
-  expect(bInbox).toHaveLength(1)
-  const originalMsgId = bInbox[0]?.id
-  expect(originalMsgId).toBeDefined()
-
-  // B replies with reply_to pointer
-  const bHandlers = messagingTools(dbHost(env.db), b.agent.id)
-  const bSend = findHandler(bHandlers, 'send_message')
-  await bSend.invoke({ to: a.agent.id, text: '4', reply_to: originalMsgId })
-
-  // A can see B's reply in its own inbox
-  const aInbox = messageRepo.listInbox(env.db, a.agent.id)
-  expect(aInbox).toHaveLength(1)
-  expect(aInbox[0]?.replyTo).toBe(originalMsgId)
-  const payload = JSON.parse(aInbox[0]?.payload ?? '{}')
-  expect(payload.text).toBe('4')
-})
-
-test('wait_for_reply resolves when a reply arrives', async () => {
-  const a = makeAgent(env, 'A')
-  const b = makeAgent(env, 'B')
-
-  const sent = messageRepo.send(env.db, {
-    from: a.agent.id,
-    to: b.agent.id,
-    payload: JSON.stringify({ text: 'ping' }),
-  })
-
-  const reply = setTimeout(() => {
-    messageRepo.send(env.db, {
-      from: b.agent.id,
-      to: a.agent.id,
-      payload: JSON.stringify({ text: 'pong' }),
-      replyTo: sent.id,
-    })
-  }, 100)
-
-  const handlers = messagingTools(dbHost(env.db), a.agent.id)
-  const wait = findHandler(handlers, 'wait_for_reply')
-  const result = await wait.invoke({ message_id: sent.id, timeout_ms: 2000, poll_ms: 50 })
-  clearTimeout(reply)
-
-  expect(result).toContain('pong')
-})
-
-test('wait_for_reply times out cleanly when no reply arrives', async () => {
-  const a = makeAgent(env, 'A')
-  const b = makeAgent(env, 'B')
-  const sent = messageRepo.send(env.db, {
-    from: a.agent.id,
-    to: b.agent.id,
-    payload: JSON.stringify({ text: 'ping' }),
-  })
-
-  const handlers = messagingTools(dbHost(env.db), a.agent.id)
-  const wait = findHandler(handlers, 'wait_for_reply')
-  const result = await wait.invoke({ message_id: sent.id, timeout_ms: 200, poll_ms: 50 })
-  expect(result).toContain('no reply within')
-})
-
-test('send_message rejects unknown recipient', async () => {
-  const a = makeAgent(env, 'A')
-  const handlers = messagingTools(dbHost(env.db), a.agent.id)
-  const send = findHandler(handlers, 'send_message')
-  await expect(send.invoke({ to: 'nope', text: 'hi' })).rejects.toThrow()
-})

package/apps/daemon/test/runtime/mock-server.ts

@@ -1,65 +0,0 @@
-import { createServer, type IncomingMessage, type ServerResponse } from 'node:http'
-
-export interface MockServer {
-  url: string
-  stop(): Promise<void>
-}
-
-/**
- * Starts a node:http server on an ephemeral port that adapts Node's
- * (req, res) to the Fetch-API Request/Response shape, then dispatches to the
- * provided handler. Lets tests keep Request/Response handler code.
- */
-export function startMockServer(
-  handler: (req: Request) => Response | Promise<Response>,
-): Promise<MockServer> {
-  const server = createServer((nodeReq: IncomingMessage, nodeRes: ServerResponse) => {
-    const chunks: Buffer[] = []
-    nodeReq.on('data', (c: Buffer) => chunks.push(c))
-    nodeReq.on('end', async () => {
-      try {
-        const bodyBuf = chunks.length > 0 ? Buffer.concat(chunks) : undefined
-        const addr = server.address()
-        const hostHeader =
-          nodeReq.headers.host ??
-          (addr && typeof addr !== 'string' ? `localhost:${addr.port}` : 'localhost')
-        const url = `http://${hostHeader}${nodeReq.url ?? '/'}`
-        const headerEntries: [string, string][] = []
-        for (const [k, v] of Object.entries(nodeReq.headers)) {
-          if (typeof v === 'string') headerEntries.push([k, v])
-          else if (Array.isArray(v)) headerEntries.push([k, v.join(', ')])
-        }
-        const method = nodeReq.method ?? 'GET'
-        const req = new Request(url, {
-          method,
-          headers: headerEntries,
-          body: method === 'GET' || method === 'HEAD' ? undefined : bodyBuf,
-        })
-        const res = await handler(req)
-        const outHeaders: Record<string, string> = {}
-        res.headers.forEach((v, k) => {
-          outHeaders[k] = v
-        })
-        nodeRes.writeHead(res.status, outHeaders)
-        if (res.body) {
-          nodeRes.end(Buffer.from(await res.arrayBuffer()))
-        } else {
-          nodeRes.end()
-        }
-      } catch (err) {
-        nodeRes.writeHead(500, { 'content-type': 'text/plain' })
-        nodeRes.end(`mock handler error: ${(err as Error).message}`)
-      }
-    })
-  })
-  return new Promise((resolve) => {
-    server.listen(0, () => {
-      const addr = server.address()
-      if (!addr || typeof addr === 'string') throw new Error('unexpected server address')
-      resolve({
-        url: `http://localhost:${addr.port}`,
-        stop: () => new Promise((r) => server.close(() => r())),
-      })
-    })
-  })
-}

package/apps/daemon/test/runtime/openai-codex-auth.test.ts

@@ -1,116 +0,0 @@
-import { randomBytes } from 'node:crypto'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import {
-  type BazilionDb,
-  openDb,
-  openSecrets,
-  resolvePaths,
-  runMigrations,
-} from '../../src/core/index.ts'
-import {
-  clearCredentials,
-  getStatus,
-  hasCredentials,
-  loadAccessToken,
-  OPENAI_CODEX_SECRET_KEY,
-  saveLoginCredentials,
-} from '../../src/runtime/auth/openai-codex.ts'
-
-// These tests exercise the storage + expiry logic directly. Pi-ai's network
-// calls (login flow + token refresh) are out of scope and not hit — the
-// refresh path is driven by a shimmed stored refresh token so we can assert
-// behaviour before expiry without the wire.
-
-let home: string
-let db: BazilionDb
-let authToken: string
-
-beforeEach(() => {
-  home = mkdtempSync(join(tmpdir(), 'bazilion-oauth-test-'))
-  const paths = resolvePaths(home)
-  mkdirSync(paths.home, { recursive: true })
-  // Stamp out an auth.json with a fake bootstrap token — secretsRepo derives
-  // its PBKDF2 key from this string, so encryption round-trip works.
-  authToken = randomBytes(24).toString('hex')
-  writeFileSync(paths.authFile, JSON.stringify({ token: authToken }))
-  db = openDb(paths.db)
-  runMigrations(db)
-})
-afterEach(() => {
-  db.close()
-  rmSync(home, { recursive: true, force: true })
-})
-
-function fakeAccessJwt(accountId: string): string {
-  // A minimal three-part JWT so decodeAccountId can extract the chatgpt_account_id
-  // from the JSON claim. Signature isn't validated locally.
-  const header = Buffer.from(JSON.stringify({ alg: 'none', typ: 'JWT' })).toString('base64url')
-  const payload = Buffer.from(
-    JSON.stringify({ 'https://api.openai.com/auth': { chatgpt_account_id: accountId } }),
-  ).toString('base64url')
-  return `${header}.${payload}.sig`
-}
-
-test('hasCredentials / getStatus return disconnected on a fresh home', () => {
-  expect(hasCredentials(db, authToken)).toBe(false)
-  const status = getStatus(db, authToken)
-  expect(status).toEqual({ connected: false, expiresAt: null, accountId: null })
-})
-
-test('saveLoginCredentials persists and getStatus reflects it', () => {
-  saveLoginCredentials(db, authToken, {
-    refresh: 'refresh-token',
-    access: fakeAccessJwt('acct-abc'),
-    expires: Date.now() + 30 * 60_000,
-  })
-  expect(hasCredentials(db, authToken)).toBe(true)
-  const status = getStatus(db, authToken)
-  expect(status.connected).toBe(true)
-  expect(status.accountId).toBe('acct-abc')
-  expect(status.expiresAt).toBeGreaterThan(Date.now())
-})
-
-test('loadAccessToken returns the stored access when still fresh', async () => {
-  const access = fakeAccessJwt('acct-abc')
-  saveLoginCredentials(db, authToken, {
-    refresh: 'refresh-token',
-    access,
-    expires: Date.now() + 30 * 60_000,
-  })
-  await expect(loadAccessToken(db, authToken)).resolves.toBe(access)
-})
-
-test('loadAccessToken throws a helpful error when not configured', async () => {
-  await expect(loadAccessToken(db, authToken)).rejects.toThrow(/not configured/)
-})
-
-test('clearCredentials wipes the stored blob', () => {
-  saveLoginCredentials(db, authToken, {
-    refresh: 'r',
-    access: fakeAccessJwt('x'),
-    expires: Date.now() + 60_000,
-  })
-  expect(hasCredentials(db, authToken)).toBe(true)
-  clearCredentials(db, authToken)
-  expect(hasCredentials(db, authToken)).toBe(false)
-})
-
-test('credential blob is stored under OPENAI_CODEX_SECRET_KEY and decrypts to JSON', () => {
-  const access = fakeAccessJwt('acct-1')
-  saveLoginCredentials(db, authToken, { refresh: 'r1', access, expires: 1000 })
-  const secrets = openSecrets(db, authToken)
-  const raw = secrets.get(OPENAI_CODEX_SECRET_KEY)
-  expect(raw).toBeTruthy()
-  const parsed = JSON.parse(raw as string)
-  expect(parsed).toEqual({ refresh: 'r1', access, expires: 1000 })
-})
-
-test('malformed blob is treated as disconnected', () => {
-  const secrets = openSecrets(db, authToken)
-  secrets.set(OPENAI_CODEX_SECRET_KEY, 'not-json{')
-  expect(hasCredentials(db, authToken)).toBe(false)
-  expect(getStatus(db, authToken).connected).toBe(false)
-})

package/apps/daemon/test/runtime/providers.test.ts

@@ -1,306 +0,0 @@
-import {
-  createAssistantMessageEventStream,
-  registerApiProvider,
-  unregisterApiProviders,
-} from '@mariozechner/pi-ai'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { piProvider } from '../../src/runtime/providers/pi-adapter.ts'
-import {
-  createProviderRegistry,
-  loadProviderConfigFromEnv,
-} from '../../src/runtime/providers/registry.ts'
-
-// These tests cover the pi-ai adapter's semantics — message/tool/response
-// conversion and delta plumbing — by registering a fake pi `Api` that returns
-// canned event streams. Wire-format correctness (SSE framing, provider-specific
-// request shapes) is pi-ai's responsibility and covered by its own test suite.
-
-const FAKE_API = 'bazilion-test-fake' as const
-const TEST_SRC = 'bazilion-tests'
-
-beforeEach(() => {
-  unregisterApiProviders(TEST_SRC)
-})
-afterEach(() => {
-  unregisterApiProviders(TEST_SRC)
-})
-
-function registerFakeApi(build: () => ReturnType<typeof createAssistantMessageEventStream>): void {
-  registerApiProvider(
-    {
-      api: FAKE_API,
-      stream: () => build(),
-      streamSimple: () => build(),
-    },
-    TEST_SRC,
-  )
-}
-
-function cannedAssistantText(text: string): ReturnType<typeof createAssistantMessageEventStream> {
-  const stream = createAssistantMessageEventStream()
-  const assistant = {
-    role: 'assistant' as const,
-    content: [{ type: 'text' as const, text }],
-    api: FAKE_API,
-    provider: 'fake',
-    model: 'm',
-    usage: {
-      input: 10,
-      output: 5,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 15,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    },
-    stopReason: 'stop' as const,
-    timestamp: Date.now(),
-  }
-  // Push chunked deltas to exercise the delta path, then a terminal done event.
-  queueMicrotask(() => {
-    stream.push({ type: 'start', partial: assistant })
-    stream.push({ type: 'text_start', contentIndex: 0, partial: assistant })
-    stream.push({
-      type: 'text_delta',
-      contentIndex: 0,
-      delta: text.slice(0, 3),
-      partial: assistant,
-    })
-    stream.push({ type: 'text_delta', contentIndex: 0, delta: text.slice(3), partial: assistant })
-    stream.push({ type: 'text_end', contentIndex: 0, content: text, partial: assistant })
-    stream.push({ type: 'done', reason: 'stop', message: assistant })
-    stream.end(assistant)
-  })
-  return stream
-}
-
-function cannedToolCall(
-  id: string,
-  name: string,
-  args: Record<string, unknown>,
-): ReturnType<typeof createAssistantMessageEventStream> {
-  const stream = createAssistantMessageEventStream()
-  const assistant = {
-    role: 'assistant' as const,
-    content: [{ type: 'toolCall' as const, id, name, arguments: args }],
-    api: FAKE_API,
-    provider: 'fake',
-    model: 'm',
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    },
-    stopReason: 'toolUse' as const,
-    timestamp: Date.now(),
-  }
-  queueMicrotask(() => {
-    stream.push({ type: 'start', partial: assistant })
-    stream.push({ type: 'done', reason: 'toolUse', message: assistant })
-    stream.end(assistant)
-  })
-  return stream
-}
-
-function cannedError(message: string): ReturnType<typeof createAssistantMessageEventStream> {
-  const stream = createAssistantMessageEventStream()
-  const assistant = {
-    role: 'assistant' as const,
-    content: [],
-    api: FAKE_API,
-    provider: 'fake',
-    model: 'm',
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    },
-    stopReason: 'error' as const,
-    errorMessage: message,
-    timestamp: Date.now(),
-  }
-  queueMicrotask(() => {
-    stream.push({ type: 'error', reason: 'error', error: assistant })
-    stream.end(assistant)
-  })
-  return stream
-}
-
-test('piProvider surfaces text, usage, and stopReason from a completed stream', async () => {
-  registerFakeApi(() => cannedAssistantText('hello there'))
-  const provider = piProvider({
-    providerName: 'bazilion-fake',
-    fallbackApi: FAKE_API,
-    apiKey: 'k',
-  })
-  const res = await provider.chat({
-    model: 'm',
-    messages: [{ role: 'user', content: 'hi' }],
-  })
-  expect(res.content).toBe('hello there')
-  expect(res.toolCalls).toEqual([])
-  expect(res.stopReason).toBe('stop')
-  expect(res.usage).toEqual({ promptTokens: 10, completionTokens: 5 })
-})
-
-test('piProvider calls onDelta for each streamed chunk', async () => {
-  registerFakeApi(() => cannedAssistantText('abcdef'))
-  const provider = piProvider({
-    providerName: 'bazilion-fake',
-    fallbackApi: FAKE_API,
-    apiKey: 'k',
-  })
-  const deltas: string[] = []
-  const res = await provider.chat({
-    model: 'm',
-    messages: [{ role: 'user', content: 'hi' }],
-    onDelta: (d) => deltas.push(d),
-  })
-  expect(deltas.join('')).toBe('abcdef')
-  expect(res.content).toBe('abcdef')
-})
-
-test('piProvider extracts toolCalls with JSON-stringified arguments', async () => {
-  registerFakeApi(() => cannedToolCall('call_1', 'memory_write', { key: 'x.md', content: 'y' }))
-  const provider = piProvider({
-    providerName: 'bazilion-fake',
-    fallbackApi: FAKE_API,
-    apiKey: 'k',
-  })
-  const res = await provider.chat({
-    model: 'm',
-    messages: [{ role: 'user', content: 'remember' }],
-    tools: [
-      {
-        name: 'memory_write',
-        description: 'write memory',
-        parameters: { type: 'object', properties: { key: { type: 'string' } } },
-      },
-    ],
-  })
-  expect(res.stopReason).toBe('tool_use')
-  expect(res.toolCalls).toHaveLength(1)
-  expect(res.toolCalls[0]?.name).toBe('memory_write')
-  expect(JSON.parse(res.toolCalls[0]?.arguments ?? '{}')).toEqual({
-    key: 'x.md',
-    content: 'y',
-  })
-})
-
-test('piProvider surfaces errorMessage as a thrown Error', async () => {
-  registerFakeApi(() => cannedError('upstream blew up'))
-  const provider = piProvider({
-    providerName: 'bazilion-fake',
-    fallbackApi: FAKE_API,
-    apiKey: 'k',
-  })
-  await expect(
-    provider.chat({ model: 'm', messages: [{ role: 'user', content: 'hi' }] }),
-  ).rejects.toThrow(/upstream blew up/)
-})
-
-// --- registry ---
-
-test('registry resolves all 16 provider:model strings', () => {
-  const reg = createProviderRegistry({
-    anthropic: { apiKey: 'k' },
-    openai: { apiKey: 'k' },
-    google: { apiKey: 'k' },
-    azureOpenai: { apiKey: 'k' },
-    bedrock: {},
-    googleVertex: {},
-    mistral: { apiKey: 'k' },
-    groq: { apiKey: 'k' },
-    cerebras: { apiKey: 'k' },
-    xai: { apiKey: 'k' },
-    zai: { apiKey: 'k' },
-    huggingface: { apiKey: 'k' },
-    openrouter: { apiKey: 'k' },
-    vercelAiGateway: { apiKey: 'k' },
-  })
-  for (const p of [
-    'anthropic',
-    'openai',
-    'google',
-    'google-vertex',
-    'azure-openai',
-    'bedrock',
-    'mistral',
-    'groq',
-    'cerebras',
-    'xai',
-    'zai',
-    'huggingface',
-    'openrouter',
-    'vercel-ai-gateway',
-    'lmstudio',
-    'ollama',
-  ]) {
-    const r = reg.resolve(`${p}:some-model`)
-    expect(r.provider.name).toBe(p)
-    expect(r.model).toBe('some-model')
-  }
-})
-
-test('registry exposes lmstudio and ollama without any env config', () => {
-  const reg = createProviderRegistry({})
-  const lm = reg.resolve('lmstudio:llama-3-8b')
-  expect(lm.provider.name).toBe('lmstudio')
-  const ol = reg.resolve('ollama:llama2')
-  expect(ol.provider.name).toBe('ollama')
-})
-
-test('registry rejects unknown names, malformed strings, and unconfigured providers', () => {
-  const reg = createProviderRegistry({})
-  expect(() => reg.resolve('martian:foo')).toThrow(/unknown provider/)
-  expect(() => reg.resolve('not-a-model')).toThrow(/expected "provider:model"/)
-  expect(() => reg.resolve('anthropic:m')).toThrow(/not configured/)
-  expect(() => reg.resolve('groq:m')).toThrow(/GROQ_API_KEY/)
-})
-
-test('loadProviderConfigFromEnv picks up every standard env var', () => {
-  const config = loadProviderConfigFromEnv({
-    ANTHROPIC_API_KEY: 'a',
-    OPENAI_API_KEY: 'o',
-    GEMINI_API_KEY: 'g',
-    GROQ_API_KEY: 'gr',
-    CEREBRAS_API_KEY: 'ce',
-    XAI_API_KEY: 'x',
-    MISTRAL_API_KEY: 'mi',
-    HF_TOKEN: 'hf',
-    OPENROUTER_API_KEY: 'or',
-    AI_GATEWAY_API_KEY: 'vg',
-  } as NodeJS.ProcessEnv)
-  expect(config.anthropic?.apiKey).toBe('a')
-  expect(config.openai?.apiKey).toBe('o')
-  expect(config.google?.apiKey).toBe('g')
-  expect(config.groq?.apiKey).toBe('gr')
-  expect(config.cerebras?.apiKey).toBe('ce')
-  expect(config.xai?.apiKey).toBe('x')
-  expect(config.mistral?.apiKey).toBe('mi')
-  expect(config.huggingface?.apiKey).toBe('hf')
-  expect(config.openrouter?.apiKey).toBe('or')
-  expect(config.vercelAiGateway?.apiKey).toBe('vg')
-})
-
-test('loadProviderConfigFromEnv recognizes Bedrock auth via AWS_PROFILE', () => {
-  const cfg = loadProviderConfigFromEnv({ AWS_PROFILE: 'default' } as NodeJS.ProcessEnv)
-  expect(cfg.bedrock).toBeDefined()
-})
-
-test('loadProviderConfigFromEnv requires both project and location for Vertex', () => {
-  expect(
-    loadProviderConfigFromEnv({ GOOGLE_CLOUD_PROJECT: 'p' } as NodeJS.ProcessEnv).googleVertex,
-  ).toBeUndefined()
-  expect(
-    loadProviderConfigFromEnv({
-      GOOGLE_CLOUD_PROJECT: 'p',
-      GOOGLE_CLOUD_LOCATION: 'us-central1',
-    } as NodeJS.ProcessEnv).googleVertex,
-  ).toBeDefined()
-})