@johpaz/hive-sdk 0.0.14 → 0.0.15

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

@@ -0,0 +1,212 @@
+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/gemini.ts

@@ -0,0 +1,215 @@
+import { logger } from "../../utils/logger.ts"
+import { sanitizeMessages } 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 GeminiProvider implements LLMProvider {
+  private _convertContentPart(part: ContentPart): any {
+    switch (part.type) {
+      case "text":
+        return { 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 { inlineData: { mimeType: match[1], data: match[2] } }
+        }
+        return { text: `[Image URL: ${url}]` }
+      }
+      case "image_base64":
+        return { inlineData: { mimeType: part.mimeType, data: part.base64 } }
+      case "document":
+        return { inlineData: { mimeType: part.mimeType, data: part.base64 } }
+      default:
+        return { text: JSON.stringify(part) }
+    }
+  }
+
+  private _convertUserParts(msg: LLMMessage): any[] {
+    if (Array.isArray(msg.content)) {
+      return msg.content.map(p => this._convertContentPart(p))
+    }
+    return [{ text: msg.content }]
+  }
+
+  async call(options: LLMCallOptions): Promise<LLMResponse> {
+    const { GoogleGenAI } = await import("@google/genai")
+
+    const clientOpts: any = { apiKey: options.apiKey }
+    if (options.baseUrl?.trim()) clientOpts.httpOptions = { baseUrl: options.baseUrl.trim() }
+
+    const ai = new GoogleGenAI(clientOpts)
+
+    const cleanMessages = sanitizeMessages(options.messages)
+
+    // Build toolCallId → name map for converting tool results
+    const toolNameMap = new Map<string, string>()
+    for (const msg of cleanMessages) {
+      if (msg.role === "assistant" && msg.tool_calls) {
+        for (const tc of msg.tool_calls) toolNameMap.set(tc.id, tc.function.name)
+      }
+    }
+
+    // Convert canonical messages → Gemini Content[]
+    let systemText = ""
+    const rawContents: any[] = []
+
+    for (const msg of cleanMessages) {
+      if (msg.role === "system") {
+        systemText += (systemText ? "\n\n" : "") + msg.content
+        continue
+      }
+    if (msg.role === "user") {
+      rawContents.push({ role: "user", parts: this._convertUserParts(msg) })
+      continue
+    }
+      if (msg.role === "assistant") {
+        const parts: any[] = []
+        if (msg.content) parts.push({ text: msg.content })
+        for (const tc of msg.tool_calls ?? []) {
+          const fcPart: any = { functionCall: { name: tc.function.name, args: JSON.parse(tc.function.arguments || "{}") } }
+          if (tc.thought_signature) fcPart.thoughtSignature = tc.thought_signature
+          parts.push(fcPart)
+        }
+        if (parts.length) rawContents.push({ role: "model", parts })
+        continue
+      }
+      if (msg.role === "tool") {
+        const fnName = toolNameMap.get(msg.tool_call_id || "") || msg.name || "tool"
+        const frPart = { functionResponse: { name: fnName, response: { output: msg.content } } }
+        const last = rawContents[rawContents.length - 1]
+        if (last?.role === "user" && Array.isArray(last.parts)) {
+          last.parts.push(frPart)
+        } else {
+          rawContents.push({ role: "user", parts: [frPart] })
+        }
+      }
+    }
+
+    // Gemini constraint enforcement
+    const contents: any[] = rawContents
+
+    while (contents.length > 0 && contents[0].role === "model") {
+      log.warn(`[llm-client] Gemini: removed leading model turn (no preceding user turn)`)
+      contents.shift()
+    }
+
+    let changed = true
+    let safetyLimit = 10
+    while (changed && safetyLimit-- > 0) {
+      changed = false
+
+      for (let i = 0; i < contents.length; i++) {
+        const turn = contents[i]
+        const prev = i > 0 ? contents[i - 1] : null
+
+        // INV-3: merge consecutive model turns
+        if (turn.role === "model" && prev?.role === "model") {
+          prev.parts.push(...(turn.parts ?? []))
+          contents.splice(i, 1)
+          i--
+          changed = true
+          continue
+        }
+
+        // INV-1: model(fc) must come after user
+        if (turn.role === "model") {
+          const hasFc = turn.parts?.some((p: any) => p.functionCall)
+          if (hasFc && prev?.role !== "user") {
+            turn.parts = (turn.parts ?? []).filter((p: any) => !p.functionCall)
+            log.warn(`[llm-client] Gemini: stripped functionCall not after user turn (i=${i})`)
+            if (turn.parts.length === 0) { contents.splice(i, 1); i-- }
+            changed = true
+            continue
+          }
+        }
+
+        // INV-2: user(fr) must come after model(fc)
+        if (turn.role === "user") {
+          const hasFr = turn.parts?.some((p: any) => p.functionResponse)
+          const prevHasFc = prev?.role === "model" && prev?.parts?.some((p: any) => p.functionCall)
+          if (hasFr && !prevHasFc) {
+            turn.parts = (turn.parts ?? []).filter((p: any) => !p.functionResponse)
+            log.warn(`[llm-client] Gemini: stripped orphaned functionResponse (i=${i})`)
+            if (turn.parts.length === 0) { contents.splice(i, 1); i-- }
+            changed = true
+            continue
+          }
+        }
+      }
+    }
+
+    if (safetyLimit <= 0) {
+      log.error(`[llm-client] Gemini: constraint enforcement loop exhausted — message history may still violate Gemini constraints`)
+    }
+
+    const config: any = {}
+    if (systemText) config.systemInstruction = systemText
+    if (options.maxTokens) config.maxOutputTokens = options.maxTokens
+    if (options.temperature !== undefined) config.temperature = options.temperature
+    if (options.tools?.length) {
+      config.tools = [{
+        functionDeclarations: options.tools.map((t) => ({
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters,
+        })),
+      }]
+    }
+
+    log.info(`[llm-client] gemini/${options.model} — ${contents.length} turns, ${options.tools?.length ?? 0} tools`)
+
+    const response = await ai.models.generateContent({ model: options.model, contents, config })
+
+    const candidate = response.candidates?.[0]
+
+    // Handle safety blocks explicitly
+    if (candidate?.finishReason === "SAFETY") {
+      log.warn(`[llm-client] Gemini: response blocked by safety filters (model=${options.model})`)
+      return {
+        content: "[Response blocked by Gemini safety filters]",
+        stop_reason: "stop",
+        usage: response.usageMetadata ? {
+          input_tokens: response.usageMetadata.promptTokenCount ?? 0,
+          output_tokens: 0,
+        } : undefined,
+      }
+    }
+
+    const parts: any[] = candidate?.content?.parts ?? []
+
+    let content = ""
+    const tool_calls: LLMToolCall[] = []
+
+    for (const part of parts) {
+      if (part.text) content += part.text
+      if (part.functionCall) {
+        tool_calls.push({
+          id: crypto.randomUUID(),
+          type: "function",
+          function: { name: part.functionCall.name, arguments: JSON.stringify(part.functionCall.args ?? {}) },
+          thought_signature: part.thoughtSignature ?? undefined,
+        })
+      }
+    }
+
+    const stop_reason: LLMResponse["stop_reason"] =
+      tool_calls.length > 0 ? "tool_calls"
+        : candidate?.finishReason === "MAX_TOKENS" ? "max_tokens"
+          : "stop"
+
+    const usageMeta = response.usageMetadata
+    return {
+      content,
+      tool_calls: tool_calls.length ? tool_calls : undefined,
+      stop_reason,
+      usage: usageMeta ? {
+        input_tokens: usageMeta.promptTokenCount ?? 0,
+        output_tokens: usageMeta.candidatesTokenCount ?? 0,
+        thinking_tokens: (usageMeta as any).thoughtsTokenCount ?? 0,
+      } : undefined,
+    }
+  }
+}

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

@@ -0,0 +1,199 @@
+/**
+ * AgentRunner — thin wrapper over the native AgentLoop.
+ *
+ * Keeps the same public API (generate()) so server.ts doesn't need changes.
+ * Internally uses agent-loop.ts instead of LangGraph.
+ */
+
+import type { Config } from "../../config/loader.ts"
+import { logger } from "../../utils/logger.ts"
+import { getDb } from "../../storage/SQLiteStorage.ts"
+import { getAgentLoop } from "../AgentRunner.ts"
+import { resolveUserId, resolveAgentId } from "../../storage/onboarding.ts"
+import type { ContentPart } from "../../multimodal/types.ts"
+
+export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek" | "nvidia"
+
+import type { StepEvent } from "../AgentRunner.ts"
+
+export interface ModelOptions {
+  provider?: Provider
+  model?: string
+  maxTokens?: number
+  temperature?: number
+  system?: string
+  messages: Array<{ role: string; content: string | ContentPart[] }>
+  tools?: Record<string, any>
+  maxSteps?: number
+  onToken?: (token: string) => void
+  onStep?: (step: StepEvent) => Promise<void>
+  threadId?: string
+  userId?: string
+  channel?: string
+  rawUserMessage?: string
+  signal?: AbortSignal
+}
+
+export interface ModelResponse {
+  content: string
+  toolCalls?: Array<{
+    id: string
+    name: string
+    args: Record<string, unknown>
+  }>
+  usage?: {
+    promptTokens: number
+    completionTokens: number
+    totalTokens: number
+  }
+  finishReason?: string
+}
+
+export class AgentRunner {
+  private config: Config
+
+  constructor(config: Config) {
+    this.config = config
+  }
+
+  async generate(options: ModelOptions): Promise<ModelResponse> {
+    const db = getDb()
+    // Resolve agentId from database (coordinator or first enabled)
+    const agentId = resolveAgentId(null) || "main"
+
+    // Resolve userId from database
+    const userId = options.userId || resolveUserId({})
+    if (!userId) {
+      throw new Error("No userId provided. Please complete onboarding first.")
+    }
+    const threadId = options.threadId || userId
+
+    const agentLoop = getAgentLoop()
+    if (!agentLoop) {
+      throw new Error("AgentLoop not initialized")
+    }
+
+    let lastAgentContent = ""
+    let accumulatedAgentContent = ""  // Accumulate content from all agent chunks
+    let toolCalls: ModelResponse["toolCalls"] = []
+    let totalInputTokens = 0
+    let totalOutputTokens = 0
+
+    try {
+      const stream = agentLoop.stream(
+        { messages: options.messages },
+        {
+          configurable: {
+            thread_id: threadId,
+            agent_id: agentId,
+            user_id: userId,
+            // system_prompt intentionally omitted — context-compiler builds it
+            channel: options.channel,
+            raw_user_message: options.rawUserMessage,
+          },
+          signal: options.signal,
+        }
+      )
+
+      let chunkCount = 0
+      for await (const chunk of stream) {
+        chunkCount++
+
+        if (chunk.agent?.messages) {
+          const lastMsg = chunk.agent.messages[chunk.agent.messages.length - 1]
+          const hasToolCalls = (lastMsg as any)?.tool_calls?.length > 0
+          const contentLen = lastMsg?.content?.length ?? 0
+          const contentType = typeof lastMsg?.content
+          logger.info(
+            `[STREAM] chunk#${chunkCount} agent: contentLen=${contentLen} hasToolCalls=${hasToolCalls} contentType=${contentType}`
+          )
+
+          if (lastMsg?.content) {
+            const content = typeof lastMsg.content === "string" 
+              ? lastMsg.content 
+              : Array.isArray(lastMsg.content)
+                ? lastMsg.content.filter(p => p.type === "text").map(p => (p as any).text).join("\n")
+                : ""
+            lastAgentContent = content
+            // Accumulate non-empty content that's not just whitespace
+            if (content && content.trim().length > 0) {
+              accumulatedAgentContent += (accumulatedAgentContent ? "\n" : "") + content
+              logger.debug(`[STREAM] Accumulated content: total length=${accumulatedAgentContent.length}`)
+            } else {
+              logger.debug(`[STREAM] Content empty or whitespace only, skipping accumulation`)
+            }
+            if (options.onToken) options.onToken(content)
+          } else {
+            logger.debug(`[STREAM] No content in chunk, lastMsg.content is falsy`)
+          }
+
+          if (hasToolCalls) {
+            toolCalls = (lastMsg as any).tool_calls.map((tc: any) => ({
+              id: tc.id || tc.function?.name,
+              name: tc.function?.name || tc.name,
+              args: tc.function?.arguments
+                ? (typeof tc.function.arguments === "string"
+                    ? JSON.parse(tc.function.arguments)
+                    : tc.function.arguments)
+                : {},
+            }))
+
+            const narration = lastMsg?.content || ""
+            if (options.onStep && narration) {
+              await options.onStep({ type: "text", message: narration })
+            }
+            if (options.onStep) {
+              for (const tc of toolCalls) {
+                await options.onStep({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  message: `Calling tool: \`${tc.name}\``,
+                })
+              }
+            }
+          }
+        }
+
+        if (chunk.tools?.messages) {
+          const lastMsg = chunk.tools.messages[chunk.tools.messages.length - 1]
+          if (lastMsg?.content && options.onStep) {
+            await options.onStep({
+              type: "tool_result",
+              message: typeof lastMsg.content === "string" ? lastMsg.content : "",
+            })
+          }
+        }
+
+        if (chunk.usage) {
+          totalInputTokens += chunk.usage.input_tokens
+          totalOutputTokens += chunk.usage.output_tokens
+        }
+      }
+
+      logger.debug(`[STREAM] done. totalChunks=${chunkCount} lastAgentContent length=${lastAgentContent.length}, accumulated length=${accumulatedAgentContent.length}`)
+
+      // Use accumulated content if lastAgentContent is empty (handles case where final chunk has no text)
+      const finalContent = lastAgentContent || accumulatedAgentContent
+      
+      logger.info(`[STREAM] Returning response: finalContent length=${finalContent.length}, lastAgentContent length=${lastAgentContent.length}, accumulated length=${accumulatedAgentContent.length}`)
+
+      return {
+        content: finalContent,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        usage: {
+          promptTokens: totalInputTokens,
+          completionTokens: totalOutputTokens,
+          totalTokens: totalInputTokens + totalOutputTokens,
+        },
+        finishReason: "stop",
+      }
+    } catch (error) {
+      logger.error("AgentRunner error:", error)
+      throw error
+    }
+  }
+}
+
+export function createAgentRunner(config: Config): AgentRunner {
+  return new AgentRunner(config)
+}