bazilion 0.0.0 → 0.1.1

package/apps/daemon/src/runtime/providers/catalog.ts

@@ -1,145 +0,0 @@
-// Catalog lookup for config UI + CLI: "what models does provider X offer?"
-//
-// Two sources, merged and de-duplicated:
-//   1. pi-ai's typed catalog (`getModels(provider)`) — static list of
-//      known cloud models with cost + context-window metadata, bundled with
-//      pi-ai. Works for the 10ish KnownProvider names; empty for local /
-//      alias providers (lmstudio, ollama, bedrock-via-our-alias).
-//   2. For OpenAI-compat endpoints (lmstudio, ollama, openrouter,
-//      vercel-ai-gateway, openai with custom baseURL), we query
-//      `GET {baseURL}/models` and extract `data[].id`. This picks up
-//      newly released models, user-loaded local models, etc.
-//
-// `listCatalogModels(providerName)` returns the union. Errors from live
-// fetches are surfaced so callers can show "couldn't reach lmstudio" rather
-// than a silent empty list.
-
-import { getModels as piGetModels } from '@mariozechner/pi-ai'
-
-// piProviderName: what pi-ai's catalog indexes by. For bedrock we use the
-// Bazilion-registry-key 'bedrock' externally but pi uses 'amazon-bedrock'.
-const REGISTRY_TO_PI: Record<string, string> = {
-  bedrock: 'amazon-bedrock',
-  'azure-openai': 'azure-openai-responses',
-}
-
-// baseURL for providers whose /v1/models we can probe. Omitted for the
-// big cloud APIs that require a real key and generally aren't "explore me"
-// — those come from the pi catalog. `process.env` reads pick up the same
-// secrets/config merge the rest of the runtime uses.
-function liveEndpointFor(providerName: string, env: NodeJS.ProcessEnv): string | null {
-  switch (providerName) {
-    case 'lmstudio':
-      return env.LMSTUDIO_URL ?? 'http://127.0.0.1:1234/v1'
-    case 'ollama':
-      // Ollama has its own /api/tags for model list; its OpenAI-compat /v1
-      // endpoint supports /models though, so use that.
-      return env.OLLAMA_URL ?? 'http://127.0.0.1:11434/v1'
-    case 'openrouter':
-      return 'https://openrouter.ai/api/v1'
-    case 'vercel-ai-gateway':
-      return env.AI_GATEWAY_BASE_URL ?? 'https://ai-gateway.vercel.sh/v1'
-    case 'groq':
-      return 'https://api.groq.com/openai/v1'
-    case 'cerebras':
-      return 'https://api.cerebras.ai/v1'
-    case 'xai':
-      return 'https://api.x.ai/v1'
-    case 'mistral':
-      return 'https://api.mistral.ai/v1'
-    default:
-      return null
-  }
-}
-
-function piModels(providerName: string): string[] {
-  const piName = REGISTRY_TO_PI[providerName] ?? providerName
-  try {
-    const models = (piGetModels as unknown as (p: string) => { id: string }[] | undefined)(piName)
-    if (!models) return []
-    return models.map((m) => m.id)
-  } catch {
-    return []
-  }
-}
-
-export interface LiveFetchResult {
-  models: string[]
-  /** Only populated on failure; caller renders for UX. */
-  error?: string
-}
-
-async function fetchModelsFrom(
-  baseURL: string,
-  apiKey: string | undefined,
-  signal?: AbortSignal,
-): Promise<LiveFetchResult> {
-  try {
-    const headers: Record<string, string> = { accept: 'application/json' }
-    if (apiKey) headers.authorization = `Bearer ${apiKey}`
-    const res = await fetch(`${baseURL.replace(/\/$/, '')}/models`, { headers, signal })
-    if (!res.ok) return { models: [], error: `${res.status} ${res.statusText}` }
-    const body = (await res.json()) as { data?: Array<{ id?: string }> } | null
-    const ids = (body?.data ?? []).map((m) => m.id).filter((id): id is string => !!id)
-    return { models: ids }
-  } catch (err) {
-    return { models: [], error: (err as Error).message }
-  }
-}
-
-function apiKeyFor(providerName: string, env: NodeJS.ProcessEnv): string | undefined {
-  switch (providerName) {
-    case 'lmstudio':
-      return env.LMSTUDIO_API_KEY ?? 'lm-studio'
-    case 'ollama':
-      return env.OLLAMA_API_KEY ?? 'ollama'
-    case 'openrouter':
-      return env.OPENROUTER_API_KEY
-    case 'vercel-ai-gateway':
-      return env.AI_GATEWAY_API_KEY
-    case 'groq':
-      return env.GROQ_API_KEY
-    case 'cerebras':
-      return env.CEREBRAS_API_KEY
-    case 'xai':
-      return env.XAI_API_KEY
-    case 'mistral':
-      return env.MISTRAL_API_KEY
-    default:
-      return undefined
-  }
-}
-
-export interface CatalogResult {
-  /** Models from pi-ai's typed catalog — stable, no network. */
-  catalog: string[]
-  /** Live `/v1/models` query — populated only for openai-compat endpoints we know how to probe. */
-  live?: LiveFetchResult
-}
-
-/**
- * List known models for a provider. Combines pi's static catalog with a live
- * `/v1/models` query for endpoints that expose one. Returns both separately
- * so the UI can surface which ones come from where.
- *
- * `live` is omitted (not just empty) when the provider doesn't expose a
- * `/v1/models` endpoint — e.g. Anthropic or Bedrock. Those rely on the
- * catalog only.
- */
-export async function listCatalogModels(
-  providerName: string,
-  env: NodeJS.ProcessEnv = process.env,
-  signal?: AbortSignal,
-): Promise<CatalogResult> {
-  const catalog = piModels(providerName)
-  const endpoint = liveEndpointFor(providerName, env)
-  if (!endpoint) return { catalog }
-  const key = apiKeyFor(providerName, env)
-  const live = await fetchModelsFrom(endpoint, key, signal)
-  return { catalog, live }
-}
-
-/** Synchronous variant for contexts that only want the pi catalog slice. */
-export function listCatalogModelsSync(providerName: string): string[] {
-  return piModels(providerName)
-}

package/apps/daemon/src/runtime/providers/pi-adapter.ts

@@ -1,272 +0,0 @@
-// Adapter from Bazilion's Provider interface → pi-ai's streamSimple.
-//
-// Pi-ai (`@mariozechner/pi-ai`) is Mario Zechner's unified LLM SDK — 15+
-// providers behind one event-stream API. This file is the only place in the
-// codebase that touches pi-ai directly; everything else downstream
-// (`runTurnStream`, `persistRun`, the worker entry, CLI, web) sees the same
-// `Provider.chat(ProviderRequest): Promise<ProviderResponse>` contract it
-// always has. That keeps the wire format, DB schema, and chat UI stable while
-// giving us cost/usage, thinking levels, prompt caching, and every provider
-// pi supports — for free.
-//
-// Model resolution: we prefer pi's typed catalog via `getModel(provider, id)`
-// which carries cost + context-window metadata; for anything outside the
-// catalog (local models, newly-released models, custom OpenAI-compat
-// endpoints) we construct a `Model<>` literal with sensible defaults. This
-// preserves Bazilion's "any model string" flexibility.
-
-import type { ProviderMessage, ReasoningLevel, ToolCall, ToolDef } from '@bazilion/api-types'
-import {
-  type AssistantMessage,
-  getModel,
-  type Model,
-  type Message as PiMessage,
-  type Tool as PiTool,
-  type ToolCall as PiToolCall,
-  streamSimple,
-  type TextContent,
-  Type,
-} from '@mariozechner/pi-ai'
-import type { Provider, ProviderRequest, ProviderResponse, StopReason } from './types.ts'
-
-export interface PiProviderConfig {
-  /** Display name on the returned Provider; also the registry key (e.g. 'bedrock', 'azure-openai'). */
-  providerName: string
-  /** Pi's canonical provider name for catalog lookup (e.g. 'amazon-bedrock', 'azure-openai-responses'). Defaults to providerName. */
-  piProviderName?: string
-  /** Override baseUrl for openai-compat endpoints (lmstudio, ollama, custom). */
-  baseUrl?: string
-  /**
-   * Static key or an async supplier. Suppliers are called at the top of each
-   * chat() so OAuth-backed providers can refresh expiring tokens without
-   * rebuilding the Provider instance (which the registry caches).
-   */
-  apiKey?: string | (() => string | Promise<string>)
-  /** Which pi `Api` to use when the model isn't in pi's catalog. */
-  fallbackApi: string
-}
-
-function defaultBaseUrlFor(providerName: string): string {
-  switch (providerName) {
-    case 'lmstudio':
-      return process.env.LMSTUDIO_URL ?? 'http://127.0.0.1:1234/v1'
-    case 'ollama':
-      return process.env.OLLAMA_URL ?? 'http://127.0.0.1:11434/v1'
-    default:
-      return ''
-  }
-}
-
-function buildModelLiteral(cfg: PiProviderConfig, modelId: string): Model<string> {
-  return {
-    id: modelId,
-    name: modelId,
-    api: cfg.fallbackApi,
-    provider: cfg.providerName,
-    baseUrl: cfg.baseUrl ?? defaultBaseUrlFor(cfg.providerName),
-    reasoning: false,
-    input: ['text'],
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 32_768,
-    maxTokens: 4_096,
-  }
-}
-
-export function resolveModel(cfg: PiProviderConfig, modelId: string): Model<string> {
-  const lookupName = cfg.piProviderName ?? cfg.providerName
-  // Try pi's typed catalog first — gets us cost, context window, reasoning flags
-  // for free on the known providers' known models.
-  try {
-    // getModel's type signature is catalog-constrained, but at runtime it just
-    // indexes MODELS[provider][id]. Cast through unknown so unknown ids fall
-    // through to the literal builder instead of tripping the compiler.
-    const known = (getModel as unknown as (p: string, m: string) => Model<string> | undefined)(
-      lookupName,
-      modelId,
-    )
-    if (known && typeof known === 'object' && 'api' in known) {
-      // Override baseUrl + provider for local / compat endpoints — pi's catalog
-      // doesn't know about lmstudio/ollama but if a user types
-      // `openai:gpt-4o` with a custom OPENAI_BASE_URL, honor that here.
-      if (cfg.baseUrl) return { ...known, baseUrl: cfg.baseUrl }
-      return known
-    }
-  } catch {
-    // Fall through.
-  }
-  return buildModelLiteral(cfg, modelId)
-}
-
-function convertMessages(messages: ProviderMessage[]): PiMessage[] {
-  const out: PiMessage[] = []
-  const now = Date.now()
-  for (const m of messages) {
-    if (m.role === 'system') continue // pi takes system prompt separately
-    if (m.role === 'user') {
-      out.push({ role: 'user', content: m.content, timestamp: now })
-      continue
-    }
-    if (m.role === 'assistant') {
-      const content: AssistantMessage['content'] = []
-      if (m.content) content.push({ type: 'text', text: m.content } satisfies TextContent)
-      if (m.toolCalls) {
-        for (const tc of m.toolCalls) {
-          let parsed: Record<string, unknown> = {}
-          try {
-            parsed = JSON.parse(tc.arguments) as Record<string, unknown>
-          } catch {
-            // leave empty
-          }
-          content.push({
-            type: 'toolCall',
-            id: tc.id,
-            name: tc.name,
-            arguments: parsed,
-          } satisfies PiToolCall)
-        }
-      }
-      // Synthesize the AssistantMessage fields pi expects on replays — these
-      // are only load-bearing for the LLM that gets the transcript; since we
-      // don't persist usage/stopReason in Bazilion's message store, defaults
-      // are fine.
-      out.push({
-        role: 'assistant',
-        content,
-        api: 'anthropic-messages',
-        provider: 'anthropic',
-        model: 'unknown',
-        usage: {
-          input: 0,
-          output: 0,
-          cacheRead: 0,
-          cacheWrite: 0,
-          totalTokens: 0,
-          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-        stopReason: 'stop',
-        timestamp: now,
-      })
-      continue
-    }
-    if (m.role === 'tool') {
-      out.push({
-        role: 'toolResult',
-        toolCallId: m.toolCallId ?? '',
-        toolName: m.toolName ?? 'tool',
-        content: [{ type: 'text', text: m.content }],
-        isError: false,
-        timestamp: now,
-      })
-    }
-  }
-  return out
-}
-
-function convertTools(tools: ToolDef[] | undefined): PiTool[] | undefined {
-  if (!tools || tools.length === 0) return undefined
-  return tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    // Type.Unsafe lets us pass raw JSON Schema through without re-authoring in
-    // typebox. Providers validate against the schema, not typebox's TSchema.
-    parameters: Type.Unsafe<unknown>(t.parameters as Record<string, unknown>),
-  }))
-}
-
-function toBazilionStopReason(reason: string): StopReason {
-  switch (reason) {
-    case 'stop':
-      return 'stop'
-    case 'length':
-      return 'length'
-    case 'toolUse':
-      return 'tool_use'
-    default:
-      return 'error'
-  }
-}
-
-function extractFinalResponse(msg: AssistantMessage): ProviderResponse {
-  let text = ''
-  const toolCalls: ToolCall[] = []
-  for (const block of msg.content) {
-    if (block.type === 'text') {
-      text += block.text
-    } else if (block.type === 'toolCall') {
-      toolCalls.push({
-        id: block.id,
-        name: block.name,
-        arguments: JSON.stringify(block.arguments ?? {}),
-      })
-    }
-  }
-  const res: ProviderResponse = {
-    content: text,
-    toolCalls,
-    stopReason: toBazilionStopReason(msg.stopReason),
-  }
-  if (msg.usage) {
-    res.usage = {
-      promptTokens: msg.usage.input,
-      completionTokens: msg.usage.output,
-    }
-  }
-  return res
-}
-
-function mapReasoning(
-  r: ReasoningLevel | undefined,
-): 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | undefined {
-  if (!r || r === 'off') return undefined
-  return r
-}
-
-async function resolveApiKey(cfg: PiProviderConfig): Promise<string | undefined> {
-  if (typeof cfg.apiKey === 'function') return await cfg.apiKey()
-  return cfg.apiKey
-}
-
-export function piProvider(cfg: PiProviderConfig): Provider {
-  return {
-    name: cfg.providerName,
-    async chat(req: ProviderRequest): Promise<ProviderResponse> {
-      const model = resolveModel(cfg, req.model)
-      const apiKey = await resolveApiKey(cfg)
-
-      const stream = streamSimple(
-        model,
-        {
-          systemPrompt: req.system ?? '',
-          messages: convertMessages(req.messages),
-          tools: convertTools(req.tools),
-        },
-        {
-          signal: req.signal,
-          apiKey,
-          reasoning: mapReasoning(req.reasoning),
-          maxTokens: req.maxTokens,
-          temperature: req.temperature,
-        },
-      )
-
-      let finalMessage: AssistantMessage | null = null
-      for await (const event of stream) {
-        if (event.type === 'text_delta' && req.onDelta) {
-          req.onDelta(event.delta)
-        } else if (event.type === 'done') {
-          finalMessage = event.message
-        } else if (event.type === 'error') {
-          finalMessage = event.error
-        }
-      }
-      if (!finalMessage) {
-        throw new Error(`pi provider ${cfg.providerName} returned no terminal event`)
-      }
-      if (finalMessage.stopReason === 'aborted' || finalMessage.stopReason === 'error') {
-        const msg = finalMessage.errorMessage ?? 'provider error'
-        throw new Error(msg)
-      }
-      return extractFinalResponse(finalMessage)
-    },
-  }
-}