codeblog-app 2.2.4 → 2.3.0

package/src/ai/chat.ts

@@ -1,224 +0,0 @@
-import { streamText, stepCountIs } from "ai"
-import { AIProvider } from "./provider"
-import { getChatTools } from "./tools"
-import { Log } from "../util/log"
-
-const log = Log.create({ service: "ai-chat" })
-
-const SYSTEM_PROMPT = `You are CodeBlog AI — an assistant for the CodeBlog developer forum (codeblog.ai).
-
-You help developers with everything on the platform:
-- Scan and analyze their local IDE coding sessions
-- Write and publish blog posts from coding sessions
-- Browse, search, read, comment, vote on forum posts
-- Manage bookmarks, notifications, debates, tags, trending topics
-- Manage agents, view dashboard, follow users
-- Generate weekly digests
-
-You have 20+ tools. Use them whenever the user's request matches. Chain multiple tools if needed.
-After a tool returns results, summarize them naturally for the user.
-
-CRITICAL: When using tools, ALWAYS use the EXACT data returned by previous tool calls.
-- If scan_sessions returns a path like "/Users/zhaoyifei/...", use that EXACT path
-- NEVER modify, guess, or infer file paths — use them exactly as returned
-- If a tool call fails with "file not found", the path is wrong — check the scan results again
-
-Write casually like a dev talking to another dev. Be specific, opinionated, and genuine.
-Use code examples when relevant. Think Juejin / HN / Linux.do vibes — not a conference paper.`
-
-const IDLE_TIMEOUT_MS = 15_000 // 15s without any stream event → abort
-const DEFAULT_MAX_STEPS = 10 // Allow AI to retry tools up to 10 steps (each tool call + result = 1 step)
-
-export namespace AIChat {
-  export interface Message {
-    role: "user" | "assistant" | "system"
-    content: string
-  }
-
-  export interface StreamCallbacks {
-    onToken?: (token: string) => void
-    onFinish?: (text: string) => void
-    onError?: (error: Error) => void
-    onToolCall?: (name: string, args: unknown) => void
-    onToolResult?: (name: string, result: unknown) => void
-  }
-
-  export interface StreamOptions {
-    maxSteps?: number
-  }
-
-  export async function stream(
-    messages: Message[],
-    callbacks: StreamCallbacks,
-    modelID?: string,
-    signal?: AbortSignal,
-    options?: StreamOptions
-  ) {
-    const model = await AIProvider.getModel(modelID)
-    const tools = await getChatTools()
-    const maxSteps = options?.maxSteps ?? DEFAULT_MAX_STEPS
-    log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length, toolCount: Object.keys(tools).length, maxSteps })
-
-    const history = messages
-      .filter((m) => m.role === "user" || m.role === "assistant")
-      .map((m) => ({ role: m.role as "user" | "assistant", content: m.content }))
-    let full = ""
-
-    // Create an internal AbortController that we can trigger on idle timeout
-    const internalAbort = new AbortController()
-    const onExternalAbort = () => {
-      log.info("external abort signal received")
-      internalAbort.abort()
-    }
-    signal?.addEventListener("abort", onExternalAbort)
-
-    const result = streamText({
-      model,
-      system: SYSTEM_PROMPT,
-      messages: history,
-      tools,
-      stopWhen: stepCountIs(maxSteps),
-      toolChoice: "auto",
-      abortSignal: internalAbort.signal,
-      experimental_toolCallStreaming: false, // Disable streaming tool calls to avoid incomplete arguments bug
-      onStepFinish: (stepResult) => {
-        log.info("onStepFinish", {
-          stepNumber: stepResult.stepNumber,
-          finishReason: stepResult.finishReason,
-          textLength: stepResult.text?.length ?? 0,
-          toolCallsCount: stepResult.toolCalls?.length ?? 0,
-          toolResultsCount: stepResult.toolResults?.length ?? 0,
-        })
-      },
-    })
-
-    let partCount = 0
-    let toolExecuting = false
-    try {
-      // Idle timeout: if no stream events arrive for IDLE_TIMEOUT_MS, abort.
-      // Paused during tool execution (tools can take longer than 15s).
-      let idleTimer: ReturnType<typeof setTimeout> | undefined
-      const resetIdle = () => {
-        if (idleTimer) clearTimeout(idleTimer)
-        if (toolExecuting) return // Don't start timer while tool is running
-        idleTimer = setTimeout(() => {
-          log.info("IDLE TIMEOUT FIRED", { partCount, fullLength: full.length })
-          internalAbort.abort()
-        }, IDLE_TIMEOUT_MS)
-      }
-      resetIdle()
-
-      for await (const part of result.fullStream) {
-        partCount++
-        if (internalAbort.signal.aborted) {
-          log.info("abort detected in loop, breaking", { partCount })
-          break
-        }
-        resetIdle()
-
-        switch (part.type) {
-          case "text-delta": {
-            const delta = (part as any).text ?? (part as any).textDelta ?? ""
-            if (delta) { full += delta; callbacks.onToken?.(delta) }
-            break
-          }
-          case "tool-call": {
-            const toolName = (part as any).toolName
-            const toolArgs = (part as any).args ?? (part as any).input ?? {}
-            log.info("tool-call", { toolName, args: toolArgs, partCount })
-            // Pause idle timer — tool execution happens between tool-call and tool-result
-            toolExecuting = true
-            if (idleTimer) { clearTimeout(idleTimer); idleTimer = undefined }
-            callbacks.onToolCall?.(toolName, toolArgs)
-            break
-          }
-          case "tool-result": {
-            log.info("tool-result", { toolName: (part as any).toolName, partCount })
-            toolExecuting = false
-            callbacks.onToolResult?.((part as any).toolName, (part as any).output ?? (part as any).result ?? {})
-            break
-          }
-          case "tool-error" as any: {
-            const errorMsg = String((part as any).error).slice(0, 500)
-            log.error("tool-error", { toolName: (part as any).toolName, error: errorMsg })
-            toolExecuting = false
-            // Abort the stream on tool error to prevent infinite retry loops
-            log.info("aborting stream due to tool error")
-            internalAbort.abort()
-            break
-          }
-          case "error": {
-            const msg = (part as any).error instanceof Error ? (part as any).error.message : String((part as any).error)
-            log.error("stream part error", { error: msg })
-            callbacks.onError?.((part as any).error instanceof Error ? (part as any).error : new Error(msg))
-            break
-          }
-          default:
-            break
-        }
-      }
-
-      if (idleTimer) clearTimeout(idleTimer)
-      log.info("for-await loop exited normally", { partCount, fullLength: full.length })
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err))
-      log.info("catch block entered", { name: error.name, message: error.message.slice(0, 200), partCount })
-      // Don't treat abort as a real error
-      if (error.name !== "AbortError") {
-        log.error("stream error (non-abort)", { error: error.message })
-        if (callbacks.onError) callbacks.onError(error)
-        else throw error
-      } else {
-        log.info("AbortError caught — treating as normal completion")
-      }
-      // On abort or error, still call onFinish so UI cleans up
-      log.info("calling onFinish from catch", { fullLength: full.length })
-      callbacks.onFinish?.(full || "(No response)")
-      return full
-    } finally {
-      log.info("finally block", { partCount, fullLength: full.length })
-      signal?.removeEventListener("abort", onExternalAbort)
-    }
-
-    log.info("calling onFinish from normal path", { fullLength: full.length })
-    callbacks.onFinish?.(full || "(No response)")
-    return full
-  }
-
-  export async function generate(prompt: string, modelID?: string) {
-    let result = ""
-    await stream([{ role: "user", content: prompt }], { onFinish: (text) => (result = text) }, modelID)
-    return result
-  }
-
-  export async function analyzeAndPost(sessionContent: string, modelID?: string) {
-    const prompt = `Analyze this coding session and write a blog post about it.
-
-The post should:
-- Have a catchy, dev-friendly title (like HN or Juejin)
-- Tell a story: what you were doing, what went wrong/right, what you learned
-- Include relevant code snippets
-- Be casual and genuine, written in first person
-- End with key takeaways
-
-Also provide:
-- 3-8 relevant tags (lowercase, hyphenated)
-- A one-line summary/hook
-
-Session content:
-${sessionContent.slice(0, 50000)}
-
-Respond in this exact JSON format:
-{
-  "title": "...",
-  "content": "... (markdown)",
-  "tags": ["tag1", "tag2"],
-  "summary": "..."
-}`
-
-    const raw = await generate(prompt, modelID)
-    const jsonMatch = raw.match(/\{[\s\S]*\}/)
-    if (!jsonMatch) throw new Error("AI did not return valid JSON")
-    return JSON.parse(jsonMatch[0])
-  }
-}

package/src/ai/configure.ts

@@ -1,134 +0,0 @@
-// AI provider auto-detection and configuration
-
-function looksLikeApi(r: Response) {
-  const ct = r.headers.get("content-type") || ""
-  return ct.includes("json") || ct.includes("text/plain")
-}
-
-export async function probe(base: string, key: string): Promise<"openai" | "anthropic" | null> {
-  const clean = base.replace(/\/+$/, "")
-  try {
-    const r = await fetch(`${clean}/v1/models`, {
-      headers: { Authorization: `Bearer ${key}` },
-      signal: AbortSignal.timeout(8000),
-    })
-    if (r.ok || ((r.status === 401 || r.status === 403) && looksLikeApi(r))) return "openai"
-  } catch {}
-  try {
-    const r = await fetch(`${clean}/v1/messages`, {
-      method: "POST",
-      headers: { "x-api-key": key, "anthropic-version": "2023-06-01", "content-type": "application/json" },
-      body: JSON.stringify({ model: "test", max_tokens: 1, messages: [] }),
-      signal: AbortSignal.timeout(8000),
-    })
-    if (r.status !== 404 && looksLikeApi(r)) return "anthropic"
-  } catch {}
-  return null
-}
-
-const KEY_PREFIX_MAP: Record<string, string> = {
-  "sk-ant-": "anthropic",
-  "AIza": "google",
-  "xai-": "xai",
-  "gsk_": "groq",
-  "sk-or-": "openrouter",
-  "pplx-": "perplexity",
-}
-
-const ENV_MAP: Record<string, string> = {
-  anthropic: "ANTHROPIC_API_KEY",
-  openai: "OPENAI_API_KEY",
-  google: "GOOGLE_GENERATIVE_AI_API_KEY",
-  xai: "XAI_API_KEY",
-  groq: "GROQ_API_KEY",
-  openrouter: "OPENROUTER_API_KEY",
-  perplexity: "PERPLEXITY_API_KEY",
-  "openai-compatible": "OPENAI_COMPATIBLE_API_KEY",
-}
-
-async function fetchFirstModel(base: string, key: string): Promise<string | null> {
-  try {
-    const clean = base.replace(/\/+$/, "")
-    const r = await fetch(`${clean}/v1/models`, {
-      headers: { Authorization: `Bearer ${key}` },
-      signal: AbortSignal.timeout(8000),
-    })
-    if (!r.ok) return null
-    const data = await r.json() as { data?: Array<{ id: string }> }
-    if (!data.data || data.data.length === 0) return null
-
-    // Prefer capable models: claude-sonnet > gpt-4o > claude-opus > first available
-    const ids = data.data.map((m) => m.id)
-    const preferred = [/^claude-sonnet-4/, /^gpt-4o$/, /^claude-opus-4/, /^gpt-4o-mini$/, /^gemini-2\.5-flash$/]
-    for (const pattern of preferred) {
-      const match = ids.find((id) => pattern.test(id))
-      if (match) return match
-    }
-    return ids[0] ?? null
-  } catch {}
-  return null
-}
-
-export function detectProvider(key: string) {
-  for (const [prefix, provider] of Object.entries(KEY_PREFIX_MAP)) {
-    if (key.startsWith(prefix)) return provider
-  }
-  return "openai"
-}
-
-export async function saveProvider(url: string, key: string): Promise<{ provider: string; error?: string }> {
-  const { Config } = await import("../config")
-
-  if (url) {
-    const detected = await probe(url, key)
-    if (!detected) return { provider: "", error: "Could not connect. Check URL and key." }
-
-    const provider = detected === "anthropic" ? "anthropic" : "openai-compatible"
-    const envKey = detected === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_COMPATIBLE_API_KEY"
-    const envBase = detected === "anthropic" ? "ANTHROPIC_BASE_URL" : "OPENAI_COMPATIBLE_BASE_URL"
-    process.env[envKey] = key
-    process.env[envBase] = url
-
-    const cfg = await Config.load()
-    const providers = cfg.providers || {}
-    providers[provider] = { api_key: key, base_url: url }
-
-    // Auto-set model if not already configured
-    const update: Record<string, unknown> = { providers }
-    if (!cfg.model) {
-      if (detected === "anthropic") {
-        update.model = "claude-sonnet-4-20250514"
-      } else {
-        // For openai-compatible with custom URL, try to fetch available models
-        const model = await fetchFirstModel(url, key)
-        if (model) update.model = `openai-compatible/${model}`
-      }
-    }
-
-    await Config.save(update)
-    return { provider: `${detected} format` }
-  }
-
-  const provider = detectProvider(key)
-  if (ENV_MAP[provider]) process.env[ENV_MAP[provider]] = key
-
-  const cfg = await Config.load()
-  const providers = cfg.providers || {}
-  providers[provider] = { api_key: key }
-
-  // Auto-set model for known providers
-  const update: Record<string, unknown> = { providers }
-  if (!cfg.model) {
-    const { AIProvider } = await import("./provider")
-    const models = Object.values(AIProvider.BUILTIN_MODELS).filter((m) => m.providerID === provider)
-    if (models.length > 0) update.model = models[0]!.id
-  }
-
-  await Config.save(update)
-  return { provider }
-}
-
-export function mask(s: string) {
-  if (s.length <= 8) return s
-  return s.slice(0, 4) + "\u2022".repeat(Math.min(s.length - 8, 20)) + s.slice(-4)
-}

package/src/ai/provider.ts

@@ -1,302 +0,0 @@
-import { createAnthropic } from "@ai-sdk/anthropic"
-import { createOpenAI } from "@ai-sdk/openai"
-import { createGoogleGenerativeAI } from "@ai-sdk/google"
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
-import { type LanguageModel, type Provider as SDK } from "ai"
-import { Config } from "../config"
-import { Log } from "../util/log"
-
-const log = Log.create({ service: "ai-provider" })
-
-export namespace AIProvider {
-  // ---------------------------------------------------------------------------
-  // Bundled providers (4 core)
-  // ---------------------------------------------------------------------------
-  const BUNDLED_PROVIDERS: Record<string, (options: any) => SDK> = {
-    "@ai-sdk/anthropic": createAnthropic as any,
-    "@ai-sdk/openai": createOpenAI as any,
-    "@ai-sdk/google": createGoogleGenerativeAI as any,
-    "@ai-sdk/openai-compatible": createOpenAICompatible as any,
-  }
-
-  // ---------------------------------------------------------------------------
-  // Provider env key mapping
-  // ---------------------------------------------------------------------------
-  const PROVIDER_ENV: Record<string, string[]> = {
-    anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],
-    openai: ["OPENAI_API_KEY"],
-    google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
-    "openai-compatible": ["OPENAI_COMPATIBLE_API_KEY"],
-  }
-
-  // ---------------------------------------------------------------------------
-  // Provider base URL env mapping
-  // ---------------------------------------------------------------------------
-  const PROVIDER_BASE_URL_ENV: Record<string, string[]> = {
-    anthropic: ["ANTHROPIC_BASE_URL"],
-    openai: ["OPENAI_BASE_URL", "OPENAI_API_BASE"],
-    google: ["GOOGLE_API_BASE_URL"],
-    "openai-compatible": ["OPENAI_COMPATIBLE_BASE_URL"],
-  }
-
-  // ---------------------------------------------------------------------------
-  // Provider → npm package mapping
-  // ---------------------------------------------------------------------------
-  const PROVIDER_NPM: Record<string, string> = {
-    anthropic: "@ai-sdk/anthropic",
-    openai: "@ai-sdk/openai",
-    google: "@ai-sdk/google",
-    "openai-compatible": "@ai-sdk/openai-compatible",
-  }
-
-  // ---------------------------------------------------------------------------
-  // Model info type
-  // ---------------------------------------------------------------------------
-  export interface ModelInfo {
-    id: string
-    providerID: string
-    name: string
-    contextWindow: number
-    outputTokens: number
-  }
-
-  // ---------------------------------------------------------------------------
-  // Built-in model list
-  // ---------------------------------------------------------------------------
-  export const BUILTIN_MODELS: Record<string, ModelInfo> = {
-    "claude-sonnet-4-20250514": { id: "claude-sonnet-4-20250514", providerID: "anthropic", name: "Claude Sonnet 4", contextWindow: 200000, outputTokens: 16384 },
-    "claude-3-5-haiku-20241022": { id: "claude-3-5-haiku-20241022", providerID: "anthropic", name: "Claude 3.5 Haiku", contextWindow: 200000, outputTokens: 8192 },
-    "gpt-4o": { id: "gpt-4o", providerID: "openai", name: "GPT-4o", contextWindow: 128000, outputTokens: 16384 },
-    "gpt-4o-mini": { id: "gpt-4o-mini", providerID: "openai", name: "GPT-4o Mini", contextWindow: 128000, outputTokens: 16384 },
-    "o3-mini": { id: "o3-mini", providerID: "openai", name: "o3-mini", contextWindow: 200000, outputTokens: 100000 },
-    "gemini-2.5-flash": { id: "gemini-2.5-flash", providerID: "google", name: "Gemini 2.5 Flash", contextWindow: 1048576, outputTokens: 65536 },
-    "gemini-2.5-pro": { id: "gemini-2.5-pro", providerID: "google", name: "Gemini 2.5 Pro", contextWindow: 1048576, outputTokens: 65536 },
-  }
-
-  export const DEFAULT_MODEL = "claude-sonnet-4-20250514"
-
-  // ---------------------------------------------------------------------------
-  // Get API key for a provider
-  // ---------------------------------------------------------------------------
-  export async function getApiKey(providerID: string): Promise<string | undefined> {
-    const envKeys = PROVIDER_ENV[providerID] || []
-    for (const key of envKeys) {
-      if (process.env[key]) return process.env[key]
-    }
-    const cfg = await Config.load()
-    return cfg.providers?.[providerID]?.api_key
-  }
-
-  // ---------------------------------------------------------------------------
-  // Get base URL for a provider
-  // ---------------------------------------------------------------------------
-  export async function getBaseUrl(providerID: string): Promise<string | undefined> {
-    const envKeys = PROVIDER_BASE_URL_ENV[providerID] || []
-    for (const key of envKeys) {
-      if (process.env[key]) return process.env[key]
-    }
-    const cfg = await Config.load()
-    return cfg.providers?.[providerID]?.base_url
-  }
-
-  // ---------------------------------------------------------------------------
-  // List all available providers
-  // ---------------------------------------------------------------------------
-  export async function listProviders(): Promise<Record<string, { name: string; models: string[]; hasKey: boolean }>> {
-    const result: Record<string, { name: string; models: string[]; hasKey: boolean }> = {}
-    for (const model of Object.values(BUILTIN_MODELS)) {
-      if (!result[model.providerID]) {
-        const key = await getApiKey(model.providerID)
-        result[model.providerID] = { name: model.providerID, models: [], hasKey: !!key }
-      }
-      if (!result[model.providerID]!.models.includes(model.id)) {
-        result[model.providerID]!.models.push(model.id)
-      }
-    }
-    const compatKey = await getApiKey("openai-compatible")
-    if (compatKey) {
-      const compatBase = await getBaseUrl("openai-compatible")
-      const remoteModels = compatBase ? await fetchRemoteModels(compatBase, compatKey) : []
-      result["openai-compatible"] = { name: "OpenAI Compatible", models: remoteModels, hasKey: true }
-    }
-    return result
-  }
-
-  // ---------------------------------------------------------------------------
-  // Get a LanguageModel instance
-  // ---------------------------------------------------------------------------
-  const sdkCache = new Map<string, SDK>()
-
-  export async function getModel(modelID?: string): Promise<LanguageModel> {
-    const id = modelID || (await getConfiguredModel()) || DEFAULT_MODEL
-
-    const builtin = BUILTIN_MODELS[id]
-    if (builtin) {
-      const apiKey = await getApiKey(builtin.providerID)
-      if (!apiKey) throw noKeyError(builtin.providerID)
-      const base = await getBaseUrl(builtin.providerID)
-      return getLanguageModel(builtin.providerID, id, apiKey, undefined, base)
-    }
-
-    if (id.includes("/")) {
-      const [providerID, ...rest] = id.split("/")
-      const mid = rest.join("/")
-      const apiKey = await getApiKey(providerID!)
-      if (!apiKey) throw noKeyError(providerID!)
-      const base = await getBaseUrl(providerID!)
-      return getLanguageModel(providerID!, mid, apiKey, undefined, base)
-    }
-
-    const cfg = await Config.load()
-    if (cfg.providers) {
-      for (const [providerID, p] of Object.entries(cfg.providers)) {
-        if (!p.api_key) continue
-        const base = p.base_url || (await getBaseUrl(providerID))
-        if (base) {
-          log.info("fallback: sending unknown model to provider with base_url", { provider: providerID, model: id })
-          return getLanguageModel(providerID, id, p.api_key, undefined, base)
-        }
-      }
-    }
-
-    throw new Error(`Unknown model: ${id}. Run: codeblog config --list`)
-  }
-
-  function getLanguageModel(providerID: string, modelID: string, apiKey: string, npm?: string, baseURL?: string): LanguageModel {
-    // Auto-detect Anthropic models and use @ai-sdk/anthropic instead of openai-compatible
-    // This fixes streaming tool call argument parsing issues with openai-compatible provider
-    let pkg = npm || PROVIDER_NPM[providerID]
-
-    // Force Anthropic SDK for Claude models, even if provider is openai-compatible
-    if (modelID.startsWith("claude-") && pkg === "@ai-sdk/openai-compatible") {
-      pkg = "@ai-sdk/anthropic"
-      log.info("auto-detected Claude model, switching from openai-compatible to @ai-sdk/anthropic", { model: modelID })
-    }
-
-    if (!pkg) {
-      pkg = "@ai-sdk/openai-compatible"
-    }
-
-    const cacheKey = `${providerID}:${pkg}:${apiKey.slice(0, 8)}`
-
-    log.info("loading model", { provider: providerID, model: modelID, pkg })
-
-    let sdk = sdkCache.get(cacheKey)
-    if (!sdk) {
-      const createFn = BUNDLED_PROVIDERS[pkg]
-      if (!createFn) throw new Error(`No bundled provider for ${pkg}. Use openai-compatible with a base URL instead.`)
-      const opts: Record<string, unknown> = { apiKey, name: providerID }
-      if (baseURL) {
-        const clean = baseURL.replace(/\/+$/, "")
-        opts.baseURL = clean.endsWith("/v1") ? clean : `${clean}/v1`
-      }
-      // For openai-compatible providers, normalize request body for broader compatibility
-      if (pkg === "@ai-sdk/openai-compatible") {
-        opts.transformRequestBody = (body: Record<string, any>) => {
-          // Remove parallel_tool_calls — many proxies/providers don't support it
-          delete body.parallel_tool_calls
-
-          // Ensure all tool schemas have type: "object" (required by DeepSeek/Qwen/etc.)
-          if (Array.isArray(body.tools)) {
-            for (const t of body.tools) {
-              const params = t?.function?.parameters
-              if (params && !params.type) {
-                params.type = "object"
-                if (!params.properties) params.properties = {}
-              }
-            }
-          }
-
-          return body
-        }
-      }
-      sdk = createFn(opts)
-      sdkCache.set(cacheKey, sdk)
-    }
-
-    if (pkg === "@ai-sdk/openai-compatible" && typeof (sdk as any).chatModel === "function") {
-      return (sdk as any).chatModel(modelID)
-    }
-    if (typeof (sdk as any).languageModel === "function") {
-      return (sdk as any).languageModel(modelID)
-    }
-    return (sdk as any)(modelID)
-  }
-
-  async function fetchRemoteModels(base: string, key: string): Promise<string[]> {
-    try {
-      const clean = base.replace(/\/+$/, "")
-      const url = clean.endsWith("/v1") ? `${clean}/models` : `${clean}/v1/models`
-      const r = await fetch(url, {
-        headers: { Authorization: `Bearer ${key}` },
-        signal: AbortSignal.timeout(8000),
-      })
-      if (!r.ok) return []
-      const data = await r.json() as { data?: Array<{ id: string }> }
-      return data.data?.map((m) => m.id) ?? []
-    } catch {
-      return []
-    }
-  }
-
-  function noKeyError(providerID: string): Error {
-    const envKeys = PROVIDER_ENV[providerID] || []
-    const envHint = envKeys[0] || `${providerID.toUpperCase().replace(/-/g, "_")}_API_KEY`
-    return new Error(`No API key for ${providerID}. Set ${envHint} or run: codeblog config --provider ${providerID} --api-key <key>`)
-  }
-
-  async function getConfiguredModel(): Promise<string | undefined> {
-    const cfg = await Config.load()
-    return cfg.model
-  }
-
-  // ---------------------------------------------------------------------------
-  // Check if any AI provider has a key configured
-  // ---------------------------------------------------------------------------
-  export async function hasAnyKey(): Promise<boolean> {
-    for (const providerID of Object.keys(PROVIDER_ENV)) {
-      const key = await getApiKey(providerID)
-      if (key) return true
-    }
-    const cfg = await Config.load()
-    if (cfg.providers) {
-      for (const p of Object.values(cfg.providers)) {
-        if (p.api_key) return true
-      }
-    }
-    return false
-  }
-
-  // ---------------------------------------------------------------------------
-  // List available models with key status
-  // ---------------------------------------------------------------------------
-  export async function available(): Promise<Array<{ model: ModelInfo; hasKey: boolean }>> {
-    const result: Array<{ model: ModelInfo; hasKey: boolean }> = []
-    for (const model of Object.values(BUILTIN_MODELS)) {
-      const apiKey = await getApiKey(model.providerID)
-      result.push({ model, hasKey: !!apiKey })
-    }
-    // Include remote models from openai-compatible provider
-    const compatKey = await getApiKey("openai-compatible")
-    const compatBase = await getBaseUrl("openai-compatible")
-    if (compatKey && compatBase) {
-      const remoteModels = await fetchRemoteModels(compatBase, compatKey)
-      for (const id of remoteModels) {
-        if (BUILTIN_MODELS[id]) continue
-        result.push({
-          model: { id, providerID: "openai-compatible", name: id, contextWindow: 0, outputTokens: 0 },
-          hasKey: true,
-        })
-      }
-    }
-    return result
-  }
-
-  // ---------------------------------------------------------------------------
-  // Parse provider/model format
-  // ---------------------------------------------------------------------------
-  export function parseModel(model: string) {
-    const [providerID, ...rest] = model.split("/")
-    return { providerID, modelID: rest.join("/") }
-  }
-}