@johpaz/hive-sdk 0.1.3 → 0.1.5

package/packages/core/src/agent/providers/anthropic.ts

@@ -1,212 +0,0 @@
-import { logger } from "../../utils/logger.ts"
-import type { LLMCallOptions, LLMProvider, LLMResponse, LLMToolCall } from "./interface"
-import type { ContentPart, LLMMessage } from "./LLMClient.ts"
-
-const log = logger.child("llm-client")
-
-// Models that support extended thinking (claude-3-7+ and claude-4.x).
-const THINKING_CAPABLE_MODELS = new Set([
-  "claude-3-7-sonnet-20250219",
-  "claude-sonnet-4-5",
-  "claude-sonnet-4-6",
-  "claude-opus-4-5",
-  "claude-opus-4-6",
-  "claude-opus-4-7",
-  "claude-haiku-4-5",
-  "claude-haiku-4-5-20251001",
-])
-
-function supportsThinking(model: string): boolean {
-  if (THINKING_CAPABLE_MODELS.has(model)) return true
-  // Also match any claude-4.x or claude-3-7+ by prefix
-  return /^claude-(4|3-7)/.test(model)
-}
-
-export class AnthropicProvider implements LLMProvider {
-  private _convertContentPart(part: ContentPart): any {
-    switch (part.type) {
-      case "text":
-        return { type: "text", text: part.text }
-      case "image_url": {
-        const url = part.image_url.url
-        if (url.startsWith("data:")) {
-          const match = url.match(/^data:([^;]+);base64,(.+)$/)
-          if (match) return { type: "image", source: { type: "base64", media_type: match[1], data: match[2] } }
-        }
-        return { type: "image", source: { type: "url", url } }
-      }
-      case "image_base64":
-        return { type: "image", source: { type: "base64", media_type: part.mimeType, data: part.base64 } }
-      case "document":
-        return { type: "document", source: { type: "base64", media_type: part.mimeType, data: part.base64 } }
-      default:
-        return { type: "text", text: JSON.stringify(part) }
-    }
-  }
-
-  private _convertUserContent(msg: LLMMessage): any[] {
-    if (Array.isArray(msg.content)) {
-      return msg.content.map(p => this._convertContentPart(p))
-    }
-    return [{ type: "text", text: msg.content }]
-  }
-
-  async call(options: LLMCallOptions): Promise<LLMResponse> {
-    const Anthropic = await import("@anthropic-ai/sdk")
-    const client = new Anthropic.default({ apiKey: options.apiKey })
-
-    const systemText = options.messages
-      .filter((m) => m.role === "system")
-      .map((m) => m.content)
-      .join("\n\n")
-
-    const anthropicMessages: any[] = []
-
-    for (const msg of options.messages) {
-      if (msg.role === "system") continue
-
-      if (msg.role === "tool") {
-        const block = { type: "tool_result", tool_use_id: msg.tool_call_id, content: msg.content }
-        const last = anthropicMessages[anthropicMessages.length - 1]
-        if (last?.role === "user" && Array.isArray(last.content)) {
-          last.content.push(block)
-        } else {
-          anthropicMessages.push({ role: "user", content: [block] })
-        }
-        continue
-      }
-
-      if (msg.role === "assistant" && msg.tool_calls?.length) {
-        const content: any[] = []
-        if (msg.content) content.push({ type: "text", text: msg.content })
-        for (const tc of msg.tool_calls) {
-          let input: Record<string, unknown>
-          try { input = JSON.parse(tc.function.arguments || "{}") } catch { input = {} }
-          content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input })
-        }
-        anthropicMessages.push({ role: "assistant", content })
-        continue
-      }
-
-      anthropicMessages.push({ role: msg.role, content: Array.isArray(msg.content) ? this._convertUserContent(msg) : msg.content })
-    }
-
-    const tools: any[] = (options.tools ?? []).map((t) => ({
-      name: t.function.name,
-      description: t.function.description,
-      input_schema: t.function.parameters,
-    }))
-
-    const body: any = {
-      model: options.model,
-      max_tokens: options.maxTokens ?? 16384,
-      messages: anthropicMessages,
-    }
-    if (systemText) body.system = systemText
-    if (tools.length) body.tools = tools
-
-    // Extended thinking — only for supported models
-    const thinkingEnabled = options.thinking?.enabled && supportsThinking(options.model)
-    if (thinkingEnabled) {
-      body.thinking = { type: "enabled", budget_tokens: options.thinking?.budget_tokens ?? 10000 }
-    }
-
-    log.info(
-      `[llm-client] anthropic/${options.model} — ${anthropicMessages.length} msgs, ${tools.length} tools` +
-      (thinkingEnabled ? ` thinking=${body.thinking.budget_tokens}tok` : "")
-    )
-
-    let content = ""
-    let thinking_content = ""
-    const tool_calls: LLMToolCall[] = []
-
-    // Streaming via messages.stream()
-    const useStream = true  // Always stream for better UX
-    if (useStream) {
-      const stream = client.messages.stream({ ...body, ...(options.signal ? {} : {}) })
-
-      // Track partial tool inputs by index
-      const partialInputs: Record<number, string> = {}
-      const toolMeta: Record<number, { id: string; name: string }> = {}
-
-      for await (const event of stream) {
-        if (event.type === "content_block_start") {
-          if (event.content_block.type === "tool_use") {
-            toolMeta[event.index] = { id: event.content_block.id, name: event.content_block.name }
-            partialInputs[event.index] = ""
-          }
-        } else if (event.type === "content_block_delta") {
-          if (event.delta.type === "text_delta") {
-            content += event.delta.text
-            if (options.onToken) options.onToken(event.delta.text)
-          } else if (event.delta.type === "thinking_delta") {
-            thinking_content += event.delta.thinking
-          } else if (event.delta.type === "input_json_delta") {
-            if (partialInputs[event.index] !== undefined) {
-              partialInputs[event.index] += event.delta.partial_json
-            }
-          }
-        }
-      }
-
-      const finalMsg = await stream.finalMessage()
-
-      // Build tool_calls from accumulated partial inputs
-      for (const [idx, meta] of Object.entries(toolMeta)) {
-        const args = partialInputs[Number(idx)] ?? "{}"
-        tool_calls.push({
-          id: meta.id,
-          type: "function",
-          function: { name: meta.name, arguments: args },
-        })
-      }
-
-      const usage = finalMsg.usage
-      return {
-        content,
-        thinking_content: thinking_content || undefined,
-        tool_calls: tool_calls.length ? tool_calls : undefined,
-        stop_reason:
-          finalMsg.stop_reason === "tool_use" ? "tool_calls"
-            : finalMsg.stop_reason === "max_tokens" ? "max_tokens"
-              : "stop",
-        usage: {
-          input_tokens: usage.input_tokens,
-          output_tokens: usage.output_tokens,
-          thinking_tokens: (usage as any).thinking_tokens ?? 0,
-        },
-      }
-    }
-
-    // Non-streaming fallback (kept for reference, unreachable with useStream=true)
-    const response = await client.messages.create(body)
-
-    for (const block of response.content) {
-      if (block.type === "text") content = block.text
-      if (block.type === "thinking") thinking_content = (block as any).thinking ?? ""
-      if (block.type === "tool_use") {
-        let args: string
-        try { args = JSON.stringify(block.input) } catch { args = "{}" }
-        tool_calls.push({
-          id: block.id,
-          type: "function",
-          function: { name: block.name, arguments: args },
-        })
-      }
-    }
-
-    return {
-      content,
-      thinking_content: thinking_content || undefined,
-      tool_calls: tool_calls.length ? tool_calls : undefined,
-      stop_reason:
-        response.stop_reason === "tool_use" ? "tool_calls"
-          : response.stop_reason === "max_tokens" ? "max_tokens"
-            : "stop",
-      usage: {
-        input_tokens: response.usage.input_tokens,
-        output_tokens: response.usage.output_tokens,
-      },
-    }
-  }
-}

package/packages/core/src/agent/providers/openai-compat.ts

@@ -1,231 +0,0 @@
-import { logger } from "../../utils/logger.ts"
-import {
-  sanitizeMessages, requiresTemperature1, OPENAI_COMPAT_BASE_URLS,
-  getProviderProfile, modelSupportsTools, normalizeToolName, normalizeToolSchema,
-} from "./interface"
-import type { LLMCallOptions, LLMProvider, LLMResponse, LLMToolCall } from "./interface"
-import type { ContentPart, LLMMessage } from "./LLMClient.ts"
-
-const log = logger.child("llm-client")
-
-export class OpenAICompatProvider implements LLMProvider {
-  private _convertContentPart(part: ContentPart): any {
-    switch (part.type) {
-      case "text":
-        return { type: "text", text: part.text }
-      case "image_url":
-        return { type: "image_url", image_url: { url: part.image_url.url } }
-      case "image_base64":
-        return { type: "image_url", image_url: { url: `data:${part.mimeType};base64,${part.base64}` } }
-      case "document":
-        return { type: "text", text: `[Document: ${part.fileName || "file"}] (base64 content not displayed)` }
-      default:
-        return { type: "text", text: JSON.stringify(part) }
-    }
-  }
-
-  private _convertMessage(msg: LLMMessage): any {
-    if (Array.isArray(msg.content)) {
-      return { ...msg, content: msg.content.map(p => this._convertContentPart(p)) }
-    }
-    return msg
-  }
-
-  async call(options: LLMCallOptions): Promise<LLMResponse> {
-    const { default: OpenAI } = await import("openai")
-
-    const baseURL = options.baseUrl?.trim() || OPENAI_COMPAT_BASE_URLS[options.provider] || undefined
-    const isLocal = baseURL?.includes("localhost") || baseURL?.includes("127.0.0.1") || baseURL?.includes("::1")
-    const apiKey = options.apiKey || (isLocal ? "ollama" : undefined)
-
-    if (!apiKey) {
-      throw new Error(`API key missing for provider: ${options.provider}. Configure it in Settings → Providers.`)
-    }
-
-    const client = new OpenAI({ apiKey, baseURL })
-
-    const isKimi = options.provider === "kimi"
-    const isDeepSeek = options.provider === "deepseek"
-    // Kimi K2 and DeepSeek reasoner require reasoning_content to be round-tripped
-    const needsReasoningRoundtrip = isKimi || isDeepSeek
-
-    const sanitized = sanitizeMessages(options.messages)
-    const rawMessages = needsReasoningRoundtrip
-      ? sanitized
-      : sanitized.map(({ reasoning_content: _rc, ...rest }) => rest as typeof sanitized[number])
-    const messagesForProvider = rawMessages.map(m => this._convertMessage(m))
-
-    const providerPrefix = new RegExp(`^${options.provider}\\/`, "i")
-    const body: any = {
-      model: options.model.replace(providerPrefix, ""),
-      messages: messagesForProvider,
-      temperature: requiresTemperature1(options.provider, options.model) ? 1 : (options.temperature ?? 0.7),
-    }
-    if (options.maxTokens) body.max_tokens = options.maxTokens
-    if (options.numCtx && isLocal) body.num_ctx = options.numCtx
-
-    // Per-provider profile drives tool call behavior
-    const profile = getProviderProfile(options.provider)
-    const sendTools = modelSupportsTools(options.provider, options.model) && !!(options.tools?.length)
-
-    // Map from wire name (normalized) → original name for denormalizing responses
-    const toolNameMap = new Map<string, string>()
-
-    if (sendTools) {
-      const preparedTools = options.tools!.map((t) => {
-        const originalName = t.function.name
-        const wireName = profile.normalizeToolNames
-          ? normalizeToolName(originalName, profile.toolNameReplacement)
-          : originalName
-        if (wireName !== originalName) toolNameMap.set(wireName, originalName)
-        return {
-          ...t,
-          function: {
-            ...t.function,
-            name: wireName,
-            parameters: normalizeToolSchema(t.function.parameters as Record<string, unknown>, profile),
-          },
-        }
-      })
-      body.tools = preparedTools
-      body.tool_choice = profile.toolChoiceAuto
-      if (profile.disableParallelToolCalls) body.parallel_tool_calls = false
-    }
-
-    log.info(`[llm-client] ${options.provider}/${body.model} — ${options.messages.length} msgs, ${options.tools?.length ?? 0} tools${sendTools ? "" : " (tools suppressed)"}`)
-
-    if (options.onToken) {
-      return this._streamCall(client, body, options, toolNameMap, sendTools, profile)
-    }
-
-    let response
-    try {
-      response = await client.chat.completions.create(body)
-    } catch (err: any) {
-      const status = err?.status ?? err?.response?.status
-      if (sendTools && profile.retryWithoutToolsOnCodes.includes(status)) {
-        log.warn(`[llm-client] ${options.provider}: tools rejected (HTTP ${status}) — retrying without tools`)
-        const bodyNoTools = { ...body }
-        delete bodyNoTools.tools
-        delete bodyNoTools.tool_choice
-        delete bodyNoTools.parallel_tool_calls
-        response = await client.chat.completions.create(bodyNoTools)
-      } else {
-        throw err
-      }
-    }
-
-    const choice = response.choices[0]
-    const msg = choice.message
-
-    const tool_calls: LLMToolCall[] | undefined = (msg.tool_calls as any[])?.map((tc: any) => ({
-      id: tc.id,
-      type: "function" as const,
-      function: {
-        name: toolNameMap.get(tc.function.name) ?? tc.function.name,
-        arguments: tc.function.arguments,
-      },
-    }))
-
-    return {
-      content: msg.content ?? "",
-      tool_calls: tool_calls?.length ? tool_calls : undefined,
-      reasoning_content: (msg as any).reasoning_content ?? undefined,
-      stop_reason:
-        choice.finish_reason === "tool_calls" ? "tool_calls"
-          : choice.finish_reason === "length" ? "max_tokens"
-            : "stop",
-      usage: response.usage ? {
-        input_tokens: response.usage.prompt_tokens,
-        output_tokens: response.usage.completion_tokens,
-      } : undefined,
-    }
-  }
-
-  private async _streamCall(
-    client: any,
-    body: any,
-    options: LLMCallOptions,
-    toolNameMap: Map<string, string>,
-    sendTools: boolean,
-    profile: ReturnType<typeof getProviderProfile>,
-  ): Promise<LLMResponse> {
-    let stream
-    try {
-      stream = await client.chat.completions.create({ ...body, stream: true })
-    } catch (err: any) {
-      const status = err?.status ?? err?.response?.status
-      if (sendTools && profile.retryWithoutToolsOnCodes.includes(status)) {
-        log.warn(`[llm-client] ${options.provider}: tools rejected (HTTP ${status}) — retrying stream without tools`)
-        const bodyNoTools = { ...body }
-        delete bodyNoTools.tools
-        delete bodyNoTools.tool_choice
-        delete bodyNoTools.parallel_tool_calls
-        stream = await client.chat.completions.create({ ...bodyNoTools, stream: true })
-      } else {
-        throw err
-      }
-    }
-
-    let content = ""
-    let reasoning_content = ""
-    let finish_reason = "stop"
-    const toolCallMap: Map<number, { id: string; name: string; arguments: string }> = new Map()
-    let input_tokens = 0
-    let output_tokens = 0
-
-    for await (const chunk of stream) {
-      const choice = chunk.choices?.[0]
-      if (!choice) continue
-
-      const delta = choice.delta as any
-      if (delta.content) {
-        content += delta.content
-        options.onToken!(delta.content)
-      }
-      if (delta.reasoning_content) {
-        reasoning_content += delta.reasoning_content
-      }
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const idx: number = tc.index
-          if (!toolCallMap.has(idx)) {
-            toolCallMap.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: "" })
-          }
-          const entry = toolCallMap.get(idx)!
-          if (tc.id) entry.id = tc.id
-          if (tc.function?.name) entry.name = tc.function.name
-          if (tc.function?.arguments) entry.arguments += tc.function.arguments
-        }
-      }
-      if (choice.finish_reason) finish_reason = choice.finish_reason
-
-      if (chunk.usage) {
-        input_tokens = chunk.usage.prompt_tokens ?? 0
-        output_tokens = chunk.usage.completion_tokens ?? 0
-      }
-    }
-
-    const tool_calls: LLMToolCall[] = [...toolCallMap.values()].map((tc) => ({
-      id: tc.id,
-      type: "function" as const,
-      function: {
-        name: toolNameMap.get(tc.name) ?? tc.name,
-        arguments: tc.arguments || "{}",
-      },
-    }))
-
-    return {
-      content,
-      tool_calls: tool_calls.length ? tool_calls : undefined,
-      reasoning_content: reasoning_content || undefined,
-      stop_reason:
-        finish_reason === "tool_calls" ? "tool_calls"
-          : finish_reason === "length" ? "max_tokens"
-            : "stop",
-      usage: input_tokens > 0 || output_tokens > 0
-        ? { input_tokens, output_tokens }
-        : undefined,
-    }
-  }
-}

package/packages/core/src/agent/selectors/PlaybookSelector.ts

@@ -1,121 +0,0 @@
-/**
- * HiveDB-based Playbook Rules Selector (ACE Curator)
- *
- * Uses HiveDB hybrid search over the playbook index.
- */
-
-import { getHiveDB } from "../../storage/HiveDBStorage.ts"
-import { logger } from "../../utils/logger.ts"
-import type { HivePlaybookDoc } from "../../storage/hiveSeed.ts"
-import type { IndexDoc } from "@johpaz/hive-db"
-
-const log = logger.child("playbook-selector")
-
-// ─── Types ───────────────────────────────────────────────────────────────────────
-
-export interface PlaybookRule {
-    id: string
-    rule: string
-    category: string
-    applicable_to?: string
-}
-
-// ─── Configuration ─────────────────────────────────────────────────────────────
-
-const MAX_RULES_PER_TURN = 5
-
-const MIN_RELEVANCE_THRESHOLD = 0.5
-
-// ─── Selection Logic ───────────────────────────────────────────────────────────
-
-function toRule(id: string, doc: HivePlaybookDoc): PlaybookRule {
-    return {
-        id,
-        rule: doc.rule,
-        category: doc.category,
-        applicable_to: doc.applicableTo ? doc.applicableTo.join(",") : undefined,
-    }
-}
-
-export async function selectPlaybookRules(message: string): Promise<PlaybookRule[]> {
-    const db = await getHiveDB()
-    const startTime = performance.now()
-
-    const keywords = message
-        .toLowerCase()
-        .replace(/[^\p{L}\p{N}\s]/gu, " ")
-        .split(/\s+/)
-        .filter(w => w.length > 3)
-        .slice(0, 5)
-
-    if (keywords.length === 0) return []
-
-    const query = keywords.join(" ")
-
-    try {
-        const hits = await db.queryHybrid({
-            text: query,
-            k: MAX_RULES_PER_TURN,
-            boosts: { body: 5.0, tags: 2.0, name: 1.0 },
-        })
-
-        const relevantIds = hits
-            .filter(r => r.score >= MIN_RELEVANCE_THRESHOLD)
-            .map(r => r.id)
-
-        if (relevantIds.length === 0) return []
-
-        const playbookCol = db.collection<HivePlaybookDoc>("playbook")
-        const rules: PlaybookRule[] = []
-        for (const id of relevantIds) {
-            const entry = await playbookCol.get(id)
-            if (entry && entry.doc.active) {
-                rules.push(toRule(id, entry.doc))
-            }
-        }
-
-        const timing = performance.now() - startTime
-        log.info(`[playbook-selector] Selected ${rules.length} rules in ${timing.toFixed(2)}ms`)
-        if (rules.length > 0) {
-          log.debug(`[playbook-selector] Rules: ${rules.map(r => `[${r.id}] ${r.rule.substring(0, 60)}`).join(', ')}`)
-        }
-
-        return rules
-    } catch (err) {
-        log.error(`[playbook-selector] Failed to select rules:`, err)
-        return []
-    }
-}
-
-// ─── Sync Logic ───────────────────────────────────────────────────────────────
-
-export async function syncPlaybookToFTS(): Promise<void> {
-    const db = await getHiveDB()
-
-    try {
-        const playbookCol = db.collection<HivePlaybookDoc>("playbook")
-        const entries = await playbookCol.scan()
-        const rules = entries.map(e => ({ id: e.id, doc: e.doc })).filter(r => r.doc.active)
-
-        if (rules.length === 0) {
-            log.debug(`[playbook-selector] No rules in playbook to sync`)
-            return
-        }
-
-        const docs: IndexDoc[] = rules.map(r => ({
-            id: r.id,
-            name: r.doc.category,
-            body: r.doc.rule,
-            tags: r.doc.applicableTo ? r.doc.applicableTo.join(" ") : "",
-            filters: [{ field: "type", value: "playbook" }],
-        }))
-
-        await db.upsertBatch(docs)
-
-        log.info(`[playbook-selector] Atomic sync complete: ${rules.length} rules indexed in HiveDB`)
-
-    } catch (err) {
-        log.error(`[playbook-selector] Transactional sync failed:`, err)
-        throw err
-    }
-}