codeblog-app 2.3.1 → 2.3.2

package/src/ai/provider.ts

@@ -1,264 +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"
-import { BUILTIN_MODELS as CORE_MODELS, DEFAULT_MODEL as CORE_DEFAULT_MODEL, type ModelInfo as CoreModelInfo } from "./models"
-import { loadProviders, PROVIDER_BASE_URL_ENV, PROVIDER_ENV, routeModel } from "./provider-registry"
-import { patchRequestByCompat, resolveCompat, type ModelApi, type ModelCompatConfig } from "./types"
-
-const log = Log.create({ service: "ai-provider" })
-
-export namespace AIProvider {
-  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,
-  }
-
-  const PROVIDER_NPM: Record<ModelApi, string> = {
-    anthropic: "@ai-sdk/anthropic",
-    openai: "@ai-sdk/openai",
-    google: "@ai-sdk/google",
-    "openai-compatible": "@ai-sdk/openai-compatible",
-  }
-
-  export const BUILTIN_MODELS = CORE_MODELS
-  export const DEFAULT_MODEL = CORE_DEFAULT_MODEL
-  export type ModelInfo = CoreModelInfo
-
-  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
-  }
-
-  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
-  }
-
-  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")
-    const compatBase = await getBaseUrl("openai-compatible")
-    if (compatKey && compatBase) {
-      const remoteModels = await fetchRemoteModels(compatBase, compatKey)
-      result["openai-compatible"] = { name: "OpenAI Compatible", models: remoteModels, hasKey: true }
-    }
-
-    const loaded = await loadProviders()
-    for (const provider of Object.values(loaded.providers)) {
-      if (result[provider.id]) continue
-      if (!provider.apiKey) continue
-      result[provider.id] = { name: provider.id, models: [], hasKey: true }
-    }
-
-    return result
-  }
-
-  const sdkCache = new Map<string, SDK>()
-
-  export async function getModel(modelID?: string): Promise<LanguageModel> {
-    const useRegistry = await Config.featureEnabled("ai_provider_registry_v2")
-    if (useRegistry) {
-      const route = await routeModel(modelID)
-      return getLanguageModel(route.providerID, route.modelID, route.apiKey, undefined, route.baseURL, route.compat)
-    }
-    return getModelLegacy(modelID)
-  }
-
-  export async function resolveModelCompat(modelID?: string): Promise<ModelCompatConfig> {
-    const useRegistry = await Config.featureEnabled("ai_provider_registry_v2")
-    if (useRegistry) return (await routeModel(modelID)).compat
-    return (await resolveLegacyRoute(modelID)).compat
-  }
-
-  async function getModelLegacy(modelID?: string): Promise<LanguageModel> {
-    const route = await resolveLegacyRoute(modelID)
-    return getLanguageModel(route.providerID, route.modelID, route.apiKey, undefined, route.baseURL, route.compat)
-  }
-
-  async function resolveLegacyRoute(modelID?: string): Promise<{
-    providerID: string
-    modelID: string
-    apiKey: string
-    baseURL?: string
-    compat: ModelCompatConfig
-  }> {
-    const requested = modelID || (await getConfiguredModel()) || DEFAULT_MODEL
-    const cfg = await Config.load()
-
-    const builtin = BUILTIN_MODELS[requested]
-    if (builtin) {
-      const apiKey = await getApiKey(builtin.providerID)
-      if (!apiKey) throw noKeyError(builtin.providerID)
-      const baseURL = await getBaseUrl(builtin.providerID)
-      return {
-        providerID: builtin.providerID,
-        modelID: requested,
-        apiKey,
-        baseURL,
-        compat: resolveCompat({ providerID: builtin.providerID, modelID: requested, providerConfig: cfg.providers?.[builtin.providerID] }),
-      }
-    }
-
-    if (requested.includes("/")) {
-      const [providerID, ...rest] = requested.split("/")
-      const modelID = rest.join("/")
-      const apiKey = await getApiKey(providerID!)
-      if (!apiKey) throw noKeyError(providerID!)
-      const baseURL = await getBaseUrl(providerID!)
-      return {
-        providerID: providerID!,
-        modelID,
-        apiKey,
-        baseURL,
-        compat: resolveCompat({ providerID: providerID!, modelID, providerConfig: cfg.providers?.[providerID!] }),
-      }
-    }
-
-    if (cfg.providers) {
-      for (const [providerID, p] of Object.entries(cfg.providers)) {
-        if (!p.api_key) continue
-        const baseURL = p.base_url || (await getBaseUrl(providerID))
-        if (!baseURL) continue
-        log.info("legacy fallback: unknown model routed to first provider with base_url", { provider: providerID, model: requested })
-        return {
-          providerID,
-          modelID: requested,
-          apiKey: p.api_key,
-          baseURL,
-          compat: resolveCompat({ providerID, modelID: requested, providerConfig: p }),
-        }
-      }
-    }
-
-    throw new Error(`Unknown model: ${requested}. Run: codeblog config --list`)
-  }
-
-  function packageForCompat(compat: ModelCompatConfig): string {
-    let pkg = PROVIDER_NPM[compat.api]
-    if (compat.modelID.startsWith("claude-") && pkg === "@ai-sdk/openai-compatible") {
-      pkg = "@ai-sdk/anthropic"
-      log.info("auto-detected claude model for openai-compatible route, using anthropic sdk", { model: compat.modelID })
-    }
-    return pkg
-  }
-
-  function getLanguageModel(
-    providerID: string,
-    modelID: string,
-    apiKey: string,
-    npm?: string,
-    baseURL?: string,
-    providedCompat?: ModelCompatConfig,
-  ): LanguageModel {
-    const compat = providedCompat || resolveCompat({ providerID, modelID })
-    const pkg = npm || packageForCompat(compat)
-    const cacheKey = `${providerID}:${pkg}:${compat.cacheKey}:${apiKey.slice(0, 8)}:${baseURL || ""}`
-
-    let sdk = sdkCache.get(cacheKey)
-    if (!sdk) {
-      const createFn = BUNDLED_PROVIDERS[pkg]
-      if (!createFn) throw new Error(`No bundled provider for ${pkg}.`)
-      const opts: Record<string, unknown> = { apiKey, name: providerID }
-      if (baseURL) {
-        const clean = baseURL.replace(/\/+$/, "")
-        opts.baseURL = clean.endsWith("/v1") ? clean : `${clean}/v1`
-      }
-      if (pkg === "@ai-sdk/openai-compatible") {
-        opts.transformRequestBody = (body: Record<string, any>) => patchRequestByCompat(compat, 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
-  }
-
-  export async function hasAnyKey(): Promise<boolean> {
-    const loaded = await loadProviders()
-    return Object.values(loaded.providers).some((p) => !!p.apiKey)
-  }
-
-  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 })
-    }
-
-    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
-  }
-
-  export function parseModel(model: string) {
-    const [providerID, ...rest] = model.split("/")
-    return { providerID, modelID: rest.join("/") }
-  }
-}

package/src/ai/stream-events.ts

@@ -1,64 +0,0 @@
-export type StreamEventType =
-  | "run-start"
-  | "text-delta"
-  | "tool-start"
-  | "tool-result"
-  | "error"
-  | "run-finish"
-
-interface StreamEventBase {
-  type: StreamEventType
-  runId: string
-  seq: number
-}
-
-export interface RunStartEvent extends StreamEventBase {
-  type: "run-start"
-  modelID: string
-  messageCount: number
-}
-
-export interface TextDeltaEvent extends StreamEventBase {
-  type: "text-delta"
-  text: string
-}
-
-export interface ToolStartEvent extends StreamEventBase {
-  type: "tool-start"
-  callID: string
-  name: string
-  args: unknown
-}
-
-export interface ToolResultEvent extends StreamEventBase {
-  type: "tool-result"
-  callID: string
-  name: string
-  result: unknown
-}
-
-export interface ErrorEvent extends StreamEventBase {
-  type: "error"
-  error: Error
-}
-
-export interface RunFinishEvent extends StreamEventBase {
-  type: "run-finish"
-  text: string
-  aborted: boolean
-}
-
-export type StreamEvent =
-  | RunStartEvent
-  | TextDeltaEvent
-  | ToolStartEvent
-  | ToolResultEvent
-  | ErrorEvent
-  | RunFinishEvent
-
-export function createRunEventFactory(runId: string = crypto.randomUUID()) {
-  let seq = 0
-  const next = <T extends StreamEventType, P extends Record<string, unknown>>(type: T, payload: P) =>
-    ({ type, runId, seq: ++seq, ...payload }) as unknown as Extract<StreamEvent, { type: T }>
-  return { runId, next }
-}

package/src/ai/tools.ts

@@ -1,118 +0,0 @@
-import { tool, jsonSchema } from "ai"
-import { McpBridge } from "../mcp/client"
-import { Log } from "../util/log"
-import type { ModelCompatConfig } from "./types"
-
-const log = Log.create({ service: "ai-tools" })
-
-// ---------------------------------------------------------------------------
-// Tool display labels for the TUI streaming indicator.
-// Kept as a static fallback — new tools added to MCP will show their name
-// as-is if not listed here, which is acceptable.
-// ---------------------------------------------------------------------------
-export const TOOL_LABELS: Record<string, string> = {
-  scan_sessions: "Scanning IDE sessions...",
-  read_session: "Reading session...",
-  analyze_session: "Analyzing session...",
-  post_to_codeblog: "Publishing post...",
-  auto_post: "Auto-posting...",
-  weekly_digest: "Generating weekly digest...",
-  browse_posts: "Browsing posts...",
-  search_posts: "Searching posts...",
-  read_post: "Reading post...",
-  comment_on_post: "Posting comment...",
-  vote_on_post: "Voting...",
-  edit_post: "Editing post...",
-  delete_post: "Deleting post...",
-  bookmark_post: "Bookmarking...",
-  browse_by_tag: "Browsing tags...",
-  trending_topics: "Loading trending...",
-  explore_and_engage: "Exploring posts...",
-  join_debate: "Loading debates...",
-  my_notifications: "Checking notifications...",
-  manage_agents: "Managing agents...",
-  my_posts: "Loading your posts...",
-  my_dashboard: "Loading dashboard...",
-  follow_user: "Processing follow...",
-  codeblog_setup: "Configuring CodeBlog...",
-  codeblog_status: "Checking status...",
-}
-
-// ---------------------------------------------------------------------------
-// Helper: call MCP tool and return result
-// ---------------------------------------------------------------------------
-async function mcp(name: string, args: Record<string, unknown> = {}): Promise<any> {
-  return McpBridge.callToolJSON(name, args)
-}
-
-// Strip undefined/null values from args before sending to MCP
-function clean(obj: Record<string, unknown>): Record<string, unknown> {
-  const result: Record<string, unknown> = {}
-  for (const [k, v] of Object.entries(obj)) {
-    if (v !== undefined && v !== null) result[k] = v
-  }
-  return result
-}
-
-// ---------------------------------------------------------------------------
-// Schema normalization: ensure all JSON schemas are valid tool input schemas.
-// Some MCP tools have empty inputSchema ({}) which produces schemas without
-// "type": "object", causing providers like DeepSeek/Qwen to reject them.
-// ---------------------------------------------------------------------------
-function normalizeToolSchema(schema: Record<string, unknown>): Record<string, unknown> {
-  const normalized = { ...schema }
-  if (!normalized.type) normalized.type = "object"
-  if (normalized.type === "object" && !normalized.properties) normalized.properties = {}
-  return normalized
-}
-
-// ---------------------------------------------------------------------------
-// Dynamic tool discovery from MCP server
-// ---------------------------------------------------------------------------
-const cache = new Map<string, Record<string, any>>()
-
-/**
- * Build AI SDK tools dynamically from the MCP server's listTools() response.
- * Results are cached after the first successful call.
- */
-export async function getChatTools(compat?: ModelCompatConfig | string): Promise<Record<string, any>> {
-  const key = typeof compat === "string" ? compat : compat?.cacheKey || "default"
-  const normalizeSchema = typeof compat === "string" ? true : (compat?.normalizeToolSchema ?? true)
-  const cached = cache.get(key)
-  if (cached) return cached
-
-  const { tools: mcpTools } = await McpBridge.listTools()
-  log.info("discovered MCP tools", { count: mcpTools.length, names: mcpTools.map((t) => t.name) })
-
-  const tools: Record<string, any> = {}
-
-  for (const t of mcpTools) {
-    const name = t.name
-    const rawSchema = (t.inputSchema ?? {}) as Record<string, unknown>
-
-    tools[name] = tool({
-      description: t.description || name,
-      inputSchema: jsonSchema(normalizeSchema ? normalizeToolSchema(rawSchema) : rawSchema),
-      execute: async (args: any) => {
-        log.info("execute tool", { name, args })
-        const result = await mcp(name, clean(args))
-        const resultStr = typeof result === "string" ? result : JSON.stringify(result)
-        log.info("execute tool result", { name, resultType: typeof result, resultLength: resultStr.length, resultPreview: resultStr.slice(0, 300) })
-        // Truncate very large tool results to avoid overwhelming the LLM context
-        if (resultStr.length > 8000) {
-          log.info("truncating large tool result", { name, originalLength: resultStr.length })
-          return resultStr.slice(0, 8000) + "\n...(truncated)"
-        }
-        return resultStr
-      },
-    })
-  }
-
-  cache.set(key, tools)
-  return tools
-}
-
-/** Clear the cached tools (useful for testing or reconnection). */
-export function clearChatToolsCache(): void {
-  cache.clear()
-}

package/src/ai/types.ts

@@ -1,105 +0,0 @@
-import type { Config } from "../config"
-
-export type ModelApi = "anthropic" | "openai" | "google" | "openai-compatible"
-export type CompatProfile = "anthropic" | "openai" | "openai-compatible" | "google"
-
-export interface ModelCompatConfig {
-  providerID: string
-  modelID: string
-  api: ModelApi
-  compatProfile: CompatProfile
-  cacheKey: string
-  stripParallelToolCalls: boolean
-  normalizeToolSchema: boolean
-}
-
-export const COMPAT_PRESETS: Record<CompatProfile, Omit<ModelCompatConfig, "providerID" | "modelID" | "cacheKey">> = {
-  anthropic: {
-    api: "anthropic",
-    compatProfile: "anthropic",
-    stripParallelToolCalls: false,
-    normalizeToolSchema: false,
-  },
-  openai: {
-    api: "openai",
-    compatProfile: "openai",
-    stripParallelToolCalls: false,
-    normalizeToolSchema: false,
-  },
-  google: {
-    api: "google",
-    compatProfile: "google",
-    stripParallelToolCalls: false,
-    normalizeToolSchema: false,
-  },
-  "openai-compatible": {
-    api: "openai-compatible",
-    compatProfile: "openai-compatible",
-    stripParallelToolCalls: true,
-    normalizeToolSchema: true,
-  },
-}
-
-function isOfficialOpenAIBase(baseURL?: string): boolean {
-  if (!baseURL) return false
-  try {
-    return new URL(baseURL).hostname === "api.openai.com"
-  } catch {
-    return false
-  }
-}
-
-function resolveApiFromProvider(providerID: string, cfg?: Config.ProviderConfig): ModelApi {
-  if (providerID === "openai" && cfg?.base_url && !isOfficialOpenAIBase(cfg.base_url)) {
-    return "openai-compatible"
-  }
-  if (cfg?.api) return cfg.api
-  if (providerID === "anthropic") return "anthropic"
-  if (providerID === "openai") return "openai"
-  if (providerID === "google") return "google"
-  if (providerID === "openai-compatible") return "openai-compatible"
-  return "openai-compatible"
-}
-
-function defaultCompatForApi(api: ModelApi): CompatProfile {
-  if (api === "anthropic") return "anthropic"
-  if (api === "openai") return "openai"
-  if (api === "google") return "google"
-  return "openai-compatible"
-}
-
-export function resolveCompat(args: {
-  providerID: string
-  modelID: string
-  providerConfig?: Config.ProviderConfig
-}): ModelCompatConfig {
-  const api = resolveApiFromProvider(args.providerID, args.providerConfig)
-  const configured = args.providerConfig?.compat_profile
-  const compatProfile = api === "openai-compatible" && configured === "openai"
-    ? "openai-compatible"
-    : configured || defaultCompatForApi(api)
-  const preset = COMPAT_PRESETS[compatProfile]
-  return {
-    ...preset,
-    providerID: args.providerID,
-    modelID: args.modelID,
-    cacheKey: `${api}:${compatProfile}`,
-  }
-}
-
-export function patchRequestByCompat(compat: ModelCompatConfig, body: Record<string, any>): Record<string, any> {
-  if (compat.stripParallelToolCalls) {
-    delete body.parallel_tool_calls
-  }
-
-  if (compat.normalizeToolSchema && Array.isArray(body.tools)) {
-    for (const t of body.tools) {
-      const params = t?.function?.parameters
-      if (!params || typeof params !== "object") continue
-      if (!params.type) params.type = "object"
-      if (params.type === "object" && !params.properties) params.properties = {}
-    }
-  }
-
-  return body
-}

package/src/auth/index.ts

@@ -1,49 +0,0 @@
-import path from "path"
-import { chmod, writeFile } from "fs/promises"
-import { Global } from "../global"
-import z from "zod"
-
-export namespace Auth {
-  export const Token = z
-    .object({
-      type: z.enum(["jwt", "apikey"]),
-      value: z.string(),
-      expires: z.number().optional(),
-      username: z.string().optional(),
-    })
-    .meta({ ref: "AuthToken" })
-  export type Token = z.infer<typeof Token>
-
-  const filepath = path.join(Global.Path.data, "auth.json")
-
-  export async function get(): Promise<Token | null> {
-    const file = Bun.file(filepath)
-    const data = await file.json().catch(() => null)
-    if (!data) return null
-    const parsed = Token.safeParse(data)
-    if (!parsed.success) return null
-    return parsed.data
-  }
-
-  export async function set(token: Token) {
-    await writeFile(filepath, JSON.stringify(token, null, 2))
-    await chmod(filepath, 0o600).catch(() => {})
-  }
-
-  export async function remove() {
-    const fs = await import("fs/promises")
-    await fs.unlink(filepath).catch(() => {})
-  }
-
-  export async function header(): Promise<Record<string, string>> {
-    const token = await get()
-    if (!token) return {}
-    if (token.type === "apikey") return { Authorization: `Bearer ${token.value}` }
-    return { Authorization: `Bearer ${token.value}` }
-  }
-
-  export async function authenticated(): Promise<boolean> {
-    const token = await get()
-    return token !== null
-  }
-}