@johpaz/hive-sdk 0.1.3 → 0.1.5

package/packages/core/src/agent/ConversationStore.ts

@@ -1,254 +0,0 @@
-/**
- * Conversation Store — persists message history in the `conversations` table.
- * Replaces the LangGraph BunSqliteSaver + lg_checkpoints approach.
- *
- * Also manages: summaries, scratchpad.
- */
-
-import { getDb } from "../storage/SQLiteStorage.ts"
-import { logger } from "../utils/logger.ts"
-import type { LLMMessage, ContentPart } from "./providers/LLMClient"
-import { estimateTokens } from "../utils/toon.ts"
-
-const log = logger.child("conv-store")
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export interface StoredMessage {
-  id: number
-  thread_id: string
-  channel: string
-  role: "user" | "assistant" | "tool" | "system"
-  content: string
-  tool_calls_json: string | null
-  tool_call_id: string | null
-  reasoning_content: string | null  // Kimi K2 thinking — must be round-tripped
-  content_multimodal: string | null // JSON array of ContentPart[]
-  token_count: number
-  created_at: number
-}
-
-// ─── Message operations ───────────────────────────────────────────────────────
-
-export function addMessage(
-  threadId: string,
-  role: StoredMessage["role"],
-  content: string | ContentPart[],
-  opts?: {
-    channel?: string
-    tool_calls?: LLMMessage["tool_calls"]
-    tool_call_id?: string
-    reasoning_content?: string
-  }
-): number {
-  const db = getDb()
-  // Handle multimodal content by extracting text for the content column
-  const textContent = typeof content === "string"
-    ? content
-    : Array.isArray(content)
-      ? content.filter(p => p.type === "text").map(p => (p as any).text).join("\n")
-      : String(content)
-
-  const content_multimodal = Array.isArray(content) ? JSON.stringify(content) : null
-  const tool_calls_json = opts?.tool_calls ? JSON.stringify(opts.tool_calls) : null
-
-  const result = db.query(`
-    INSERT INTO conversations (thread_id, channel, role, content, content_multimodal, tool_calls_json, tool_call_id, reasoning_content, token_count, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, unixepoch())
-    RETURNING id
-  `).get(
-    threadId,
-    opts?.channel ?? "webchat",
-    role,
-    textContent,
-    content_multimodal,
-    tool_calls_json,
-    opts?.tool_call_id ?? null,
-    opts?.reasoning_content ?? null,
-    // Estimate tokens: content + tool_calls JSON
-    Math.max(1, estimateTokens(textContent) + estimateTokens(tool_calls_json ?? "")),
-  ) as { id: number }
-
-  return result.id
-}
-
-/**
- * Returns all messages for the thread ordered oldest → newest.
- */
-export function getHistory(threadId: string, limit = 200): StoredMessage[] {
-  const db = getDb()
-  return db.query(`
-    SELECT * FROM conversations
-    WHERE thread_id = ?
-    ORDER BY id ASC
-    LIMIT ?
-  `).all(threadId, limit) as StoredMessage[]
-}
-
-/**
- * Returns only the last N messages (oldest → newest order),
- * with leading orphaned tool messages stripped from the window start.
- *
- * A tool message is "orphaned" when the assistant message that issued its
- * tool_call_id is not present in the loaded window (it was compacted away).
- * Sending orphaned tool messages to the LLM causes provider errors.
- */
-export function getRecentMessages(threadId: string, n: number): StoredMessage[] {
-  const db = getDb()
-  const rows = db.query(`
-    SELECT * FROM conversations
-    WHERE thread_id = ?
-    ORDER BY id DESC
-    LIMIT ?
-  `).all(threadId, n) as StoredMessage[]
-  return stripLeadingOrphanedTools(rows.reverse())
-}
-
-function stripLeadingOrphanedTools(rows: StoredMessage[]): StoredMessage[] {
-  // Collect all tool_call_ids referenced by assistant messages in this window
-  const knownIds = new Set<string>()
-  for (const r of rows) {
-    if (r.role === "assistant" && r.tool_calls_json) {
-      try {
-        const tcs = JSON.parse(r.tool_calls_json) as Array<{ id: string }>
-        for (const tc of tcs) knownIds.add(tc.id)
-      } catch { /* ignore malformed JSON */ }
-    }
-  }
-
-  // Drop tool messages at the start of the window whose assistant is missing
-  let start = 0
-  while (
-    start < rows.length &&
-    rows[start].role === "tool" &&
-    rows[start].tool_call_id !== null &&
-    !knownIds.has(rows[start].tool_call_id!)
-  ) {
-    start++
-  }
-
-  if (start > 0) {
-    log.warn(`[conv-store] Stripped ${start} leading orphaned tool message(s) from window (tool_call_ids outside window)`)
-  }
-  return start > 0 ? rows.slice(start) : rows
-}
-
-export function getMessageCount(threadId: string): number {
-  const db = getDb()
-  const row = db.query(
-    "SELECT COUNT(*) as cnt FROM conversations WHERE thread_id = ?"
-  ).get(threadId) as { cnt: number }
-  return row.cnt
-}
-
-export function getTotalTokens(threadId: string): number {
-  const db = getDb()
-  const row = db.query(
-    "SELECT COALESCE(SUM(token_count), 0) as total FROM conversations WHERE thread_id = ?"
-  ).get(threadId) as { total: number }
-  return row.total
-}
-
-/**
- * Messages after a given message ID (for incremental summary updates).
- */
-export function getMessagesAfter(threadId: string, afterId: number): StoredMessage[] {
-  const db = getDb()
-  return db.query(`
-    SELECT * FROM conversations
-    WHERE thread_id = ? AND id > ?
-    ORDER BY id ASC
-  `).all(threadId, afterId) as StoredMessage[]
-}
-
-// ─── Convert stored messages → LLMMessage array ───────────────────────────────
-
-export function toAPIMessages(rows: StoredMessage[]): LLMMessage[] {
-  return rows.map((r) => {
-    let content: string | ContentPart[] = r.content
-    if (r.content_multimodal) {
-      try { content = JSON.parse(r.content_multimodal) } catch { /* ignore */ }
-    }
-    const msg: LLMMessage = { role: r.role, content }
-    if (r.tool_calls_json) {
-      try { msg.tool_calls = JSON.parse(r.tool_calls_json) } catch { /* ignore */ }
-    }
-    if (r.tool_call_id) msg.tool_call_id = r.tool_call_id
-    if (r.reasoning_content) msg.reasoning_content = r.reasoning_content
-    return msg
-  })
-}
-
-// ─── Summaries ────────────────────────────────────────────────────────────────
-
-export interface Summary {
-  summary: string
-  last_message_id: number
-  messages_covered: number
-}
-
-export function getSummary(threadId: string): Summary | null {
-  const db = getDb()
-  return db.query(
-    "SELECT summary, last_message_id, messages_covered FROM summaries WHERE thread_id = ?"
-  ).get(threadId) as Summary | null
-}
-
-export function saveSummary(
-  threadId: string,
-  summary: string,
-  messagesCovered: number,
-  lastMessageId: number
-): void {
-  const db = getDb()
-  db.query(`
-    INSERT INTO summaries (thread_id, summary, messages_covered, last_message_id)
-    VALUES (?, ?, ?, ?)
-    ON CONFLICT(thread_id) DO UPDATE SET
-      summary        = excluded.summary,
-      messages_covered = excluded.messages_covered,
-      last_message_id  = excluded.last_message_id,
-      updated_at       = unixepoch()
-  `).run(threadId, summary, messagesCovered, lastMessageId)
-}
-
-import { getHiveDB } from "../storage/HiveDBStorage.ts";
-
-interface ScratchpadDoc {
-  threadId: string;
-  key: string;
-  value: string;
-  updatedAt: number;
-}
-
-function scratchpadDocId(threadId: string, key: string): string {
-  return `${threadId}:${key}`;
-}
-
-// ─── Scratchpad ───────────────────────────────────────────────────────────────
-
-export async function saveScratchpadNote(
-  threadId: string,
-  key: string,
-  value: string,
-  _source?: string
-): Promise<void> {
-  const db = await getHiveDB();
-  const col = db.collection<ScratchpadDoc>("scratchpad");
-  await col.put(scratchpadDocId(threadId, key), { threadId, key, value, updatedAt: Date.now() });
-}
-
-export async function getScratchpad(threadId: string): Promise<Array<{ key: string; value: string }>> {
-  const db = await getHiveDB();
-  const col = db.collection<ScratchpadDoc>("scratchpad");
-  const entries = await col.scan();
-  return entries
-    .filter(e => e.doc.threadId === threadId)
-    .map(e => ({ key: e.doc.key, value: e.doc.value }));
-}
-
-export async function deleteScratchpadNote(threadId: string, key: string): Promise<void> {
-  const db = await getHiveDB();
-  const col = db.collection<ScratchpadDoc>("scratchpad");
-  await col.delete(scratchpadDocId(threadId, key));
-}

package/packages/core/src/agent/Hooks.ts

@@ -1,166 +0,0 @@
-import type { Config } from "../config/loader.ts";
-import { logger } from "../utils/logger.ts";
-import * as childProcess from "node:child_process";
-
-export type HookName =
-  | "before_model_resolve"
-  | "before_prompt_build"
-  | "before_tool_call"
-  | "after_tool_call"
-  | "tool_result_persist"
-  | "before_compaction"
-  | "after_compaction"
-  | "message_received"
-  | "message_sending"
-  | "message_sent"
-  | "session_start"
-  | "session_end"
-  | "gateway_start"
-  | "gateway_stop";
-
-export interface HookContext {
-  sessionId?: string;
-  agentId?: string;
-  data?: Record<string, unknown>;
-  timestamp: Date;
-}
-
-export type HookHandler = (context: HookContext) => Promise<Record<string, unknown> | void>;
-
-export class HookPipeline {
-  private config: Config;
-  private log = logger.child("hooks");
-  private handlers: Map<HookName, HookHandler[]> = new Map();
-  private scriptCache: Map<HookName, string> = new Map();
-
-  constructor(config: Config) {
-    this.config = config;
-    this.loadScripts();
-  }
-
-  private loadScripts(): void {
-    const scripts = this.config.hooks?.scripts;
-    if (!scripts) return;
-
-    const hookNames: HookName[] = [
-      "before_model_resolve",
-      "before_prompt_build",
-      "before_tool_call",
-      "after_tool_call",
-      "tool_result_persist",
-      "before_compaction",
-      "after_compaction",
-      "message_received",
-      "message_sending",
-      "message_sent",
-      "session_start",
-      "session_end",
-      "gateway_start",
-      "gateway_stop",
-    ];
-
-    for (const name of hookNames) {
-      const script = scripts[name];
-      if (script) {
-        this.scriptCache.set(name, script);
-        this.log.debug(`Loaded script for hook: ${name}`);
-      }
-    }
-  }
-
-  registerHandler(name: HookName, handler: HookHandler): void {
-    const handlers = this.handlers.get(name) ?? [];
-    handlers.push(handler);
-    this.handlers.set(name, handlers);
-    this.log.debug(`Registered handler for hook: ${name}`);
-  }
-
-  unregisterHandler(name: HookName, handler: HookHandler): boolean {
-    const handlers = this.handlers.get(name);
-    if (!handlers) return false;
-
-    const index = handlers.indexOf(handler);
-    if (index >= 0) {
-      handlers.splice(index, 1);
-      return true;
-    }
-    return false;
-  }
-
-  async execute(name: HookName, context: HookContext): Promise<Record<string, unknown> | void> {
-    this.log.debug(`Executing hook: ${name}`, { sessionId: context.sessionId });
-
-    const handlers = this.handlers.get(name) ?? [];
-    for (const handler of handlers) {
-      try {
-        await handler(context);
-      } catch (error) {
-        this.log.error(`Handler failed for ${name}: ${(error as Error).message}`);
-      }
-    }
-
-    const script = this.scriptCache.get(name);
-    if (script) {
-      try {
-        const result = await this.executeScript(script, context);
-        return result;
-      } catch (error) {
-        this.log.error(`Script failed for ${name}: ${(error as Error).message}`);
-      }
-    }
-  }
-
-  private async executeScript(
-    scriptPath: string,
-    context: HookContext
-  ): Promise<Record<string, unknown> | void> {
-    return new Promise((resolve, reject) => {
-      const payload = JSON.stringify(context);
-
-      const proc = childProcess.spawn(scriptPath, [], {
-        stdio: ["pipe", "pipe", "pipe"],
-        shell: true,
-      }) as any;
-
-      let stdout = "";
-      let stderr = "";
-
-      proc.stdout?.on("data", (data) => {
-        stdout += data.toString();
-      });
-
-      proc.stderr?.on("data", (data) => {
-        stderr += data.toString();
-      });
-
-      proc.on("close", (code) => {
-        if (code === 0 && stdout) {
-          try {
-            resolve(JSON.parse(stdout));
-          } catch {
-            resolve();
-          }
-        } else if (stderr) {
-          reject(new Error(stderr));
-        } else {
-          resolve();
-        }
-      });
-
-      proc.on("error", (error) => {
-        reject(error);
-      });
-
-      proc.stdin?.write(payload);
-      proc.stdin?.end();
-    });
-  }
-
-  hasHandlers(name: HookName): boolean {
-    return (this.handlers.get(name)?.length ?? 0) > 0 || this.scriptCache.has(name);
-  }
-}
-
-export function createHookPipeline(config: Config): HookPipeline {
-  return new HookPipeline(config);
-}

package/packages/core/src/agent/StuckLoop.ts

@@ -1,133 +0,0 @@
-import type { Config } from "../config/loader.ts";
-import { logger } from "../utils/logger.ts";
-import { hashObject } from "../utils/crypto.ts";
-
-interface ToolCallRecord {
-  toolName: string;
-  argsHash: string;
-  errorMessage?: string;
-  timestamp: number;
-}
-
-interface StuckLoopState {
-  detected: boolean;
-  toolName: string;
-  count: number;
-  lastError?: string;
-}
-
-export class StuckLoopDetector {
-  private log = logger.child("stuck-loop");
-  private history: Map<string, ToolCallRecord[]> = new Map();
-  private readonly maxHistoryPerSession = 50;
-  private readonly triggerThreshold = 3;
-
-  constructor(_config: Config) {}
-
-  recordToolCall(
-    sessionId: string,
-    toolName: string,
-    args: Record<string, unknown>,
-    error?: string
-  ): void {
-    let sessionHistory = this.history.get(sessionId);
-    if (!sessionHistory) {
-      sessionHistory = [];
-      this.history.set(sessionId, sessionHistory);
-    }
-
-    const record: ToolCallRecord = {
-      toolName,
-      argsHash: hashObject(args),
-      errorMessage: error,
-      timestamp: Date.now(),
-    };
-
-    sessionHistory.push(record);
-
-    if (sessionHistory.length > this.maxHistoryPerSession) {
-      sessionHistory.shift();
-    }
-
-    this.log.debug(`Recorded tool call: ${toolName} for session ${sessionId}`);
-  }
-
-  check(sessionId: string): StuckLoopState {
-    const sessionHistory = this.history.get(sessionId) ?? [];
-    
-    if (sessionHistory.length < this.triggerThreshold) {
-      return { detected: false, toolName: "", count: 0 };
-    }
-
-    const recent = sessionHistory.slice(-10);
-    const counts = new Map<string, { count: number; error?: string }>();
-
-    for (const record of recent) {
-      const key = `${record.toolName}:${record.argsHash}`;
-      const existing = counts.get(key);
-      
-      if (existing) {
-        existing.count++;
-        if (record.errorMessage) {
-          existing.error = record.errorMessage;
-        }
-      } else {
-        counts.set(key, { count: 1, error: record.errorMessage });
-      }
-    }
-
-    for (const [key, data] of counts) {
-      if (data.count >= this.triggerThreshold && data.error) {
-        const toolName = key.split(":")[0] ?? "unknown";
-        
-        this.log.warn(`Stuck loop detected: ${toolName} called ${data.count} times with same args and error`);
-        
-        return {
-          detected: true,
-          toolName,
-          count: data.count,
-          lastError: data.error,
-        };
-      }
-    }
-
-    return { detected: false, toolName: "", count: 0 };
-  }
-
-  getInterventionMessage(state: StuckLoopState): string | null {
-    if (!state.detected) return null;
-
-    if (state.count >= this.triggerThreshold + 1) {
-      return `CRITICAL: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing with: "${state.lastError}". The user has been notified. You MUST try a completely different approach or ask the user for guidance.`;
-    }
-
-    return `WARNING: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing. You MUST try a completely different approach instead of repeating the same action.`;
-  }
-
-  clear(sessionId: string): void {
-    this.history.delete(sessionId);
-    this.log.debug(`Cleared stuck loop history for session ${sessionId}`);
-  }
-
-  prune(maxAgeMs: number = 30 * 60 * 1000): number {
-    const now = Date.now();
-    let pruned = 0;
-
-    for (const [sessionId, history] of this.history) {
-      const filtered = history.filter(r => now - r.timestamp < maxAgeMs);
-      
-      if (filtered.length === 0) {
-        this.history.delete(sessionId);
-        pruned++;
-      } else if (filtered.length !== history.length) {
-        this.history.set(sessionId, filtered);
-      }
-    }
-
-    return pruned;
-  }
-}
-
-export function createStuckLoopDetector(config: Config): StuckLoopDetector {
-  return new StuckLoopDetector(config);
-}

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

@@ -1,149 +0,0 @@
-/**
- * LLM client — direct official SDKs, no abstraction layers.
- *
- *   gemini / google  → native Gemini REST API (v1beta, ?key=)
- *   anthropic        → @anthropic-ai/sdk
- *   ollama           → ollama npm package
- *   everything else  → openai  npm package  (OpenAI-compatible endpoint)
- *
- * Public interface (LLMMessage, callLLM, resolveProviderConfig) is stable.
- */
-
-import { logger } from "../../utils/logger.ts"
-import { GeminiProvider } from "./gemini.ts"
-import { AnthropicProvider } from "./anthropic.ts"
-import { OllamaProvider } from "./ollama.ts"
-import { OpenAICompatProvider } from "./openai-compat.ts"
-import type { LLMProvider } from "./interface.ts"
-
-const log = logger.child("llm-client")
-
-// ─── Canonical types ───────────────────────────────────────────────────────────
-
-export interface LLMToolCall {
-  id: string
-  type: "function"
-  function: { name: string; arguments: string }
-  /** Gemini 3.x thought signature — must be round-tripped for tool-calling. */
-  thought_signature?: string
-}
-
-export type ContentPart =
-  | { type: "text"; text: string }
-  | { type: "image_url"; image_url: { url: string } }
-  | { type: "image_base64"; base64: string; mimeType: string }
-  | { type: "document"; base64: string; mimeType: string; fileName?: string }
-
-export interface LLMMessage {
-  role: "system" | "user" | "assistant" | "tool"
-  content: string | ContentPart[]
-  tool_calls?: LLMToolCall[]
-  tool_call_id?: string
-  name?: string
-  /** Kimi K2 thinking mode — must be round-tripped when tool calls are present. */
-  reasoning_content?: string
-}
-
-export interface LLMToolDef {
-  type: "function"
-  function: {
-    name: string
-    description: string
-    parameters: Record<string, unknown>
-  }
-}
-
-export interface LLMCallOptions {
-  provider: string
-  model: string
-  apiKey: string
-  baseUrl?: string
-  numCtx?: number
-  messages: LLMMessage[]
-  tools?: LLMToolDef[]
-  temperature?: number
-  maxTokens?: number
-  numGpu?: number
-  onToken?: (token: string) => void
-  signal?: AbortSignal
-  /** Enable extended thinking for supported models (Anthropic Claude 3.7+). */
-  thinking?: { enabled: boolean; budget_tokens?: number }
-}
-
-export interface LLMResponse {
-  content: string
-  tool_calls?: LLMToolCall[]
-  stop_reason: "stop" | "tool_calls" | "max_tokens" | "error"
-  usage?: { input_tokens: number; output_tokens: number; thinking_tokens?: number }
-  /** Kimi K2 / DeepSeek thinking mode — must be round-tripped in assistant messages. */
-  reasoning_content?: string
-  /** Anthropic extended thinking content (not sent to LLM, for display only). */
-  thinking_content?: string
-}
-
-// ─── Provider factory ─────────────────────────────────────────────────────────
-
-const GEMINI_PROVIDERS = new Set(["gemini", "google"])
-
-const KNOWN_PROVIDERS = new Set(["anthropic", "gemini", "google", "ollama", "openai", "groq", "mistral", "openrouter", "deepseek", "kimi", "local-llama", "nvidia"])
-
-function getProvider(provider: string): LLMProvider {
-  if (GEMINI_PROVIDERS.has(provider)) return new GeminiProvider()
-  if (provider === "anthropic") return new AnthropicProvider()
-  if (provider === "ollama") return new OllamaProvider()
-  if (!KNOWN_PROVIDERS.has(provider)) {
-    log.warn(`[llm-client] Unknown provider "${provider}" — falling back to OpenAI-compatible endpoint`)
-  }
-  return new OpenAICompatProvider()
-}
-
-// ─── Public API ────────────────────────────────────────────────────────────────
-
-/**
- * Call any LLM provider. Returns a canonical LLMResponse regardless of provider.
- */
-export async function callLLM(options: LLMCallOptions): Promise<LLMResponse> {
-  try {
-    return await getProvider(options.provider).call(options)
-  } catch (err) {
-    const msg = (err as Error).message
-    const cleanModel = options.model.replace(new RegExp(`^${options.provider}\\/`), "")
-    log.error(`[llm-client] Error calling ${options.provider}/${cleanModel}: ${msg}`, err)
-    return { content: `[LLM Error] ${msg}`, stop_reason: "error" }
-  }
-}
-
-/**
- * Resolve provider config from DB (decrypts API key).
- */
-export async function resolveProviderConfig(
-  providerId: string,
-  modelId: string
-): Promise<Pick<LLMCallOptions, "provider" | "model" | "apiKey" | "baseUrl" | "numCtx" | "numGpu">> {
-  const { getDb } = await import("../../storage/SQLiteStorage.ts")
-  const { decryptApiKey } = await import("../../storage/crypto.ts")
-
-  const db = getDb()
-  const providerRow = db
-    .query<any, [string]>("SELECT * FROM providers WHERE id = ? AND enabled = 1")
-    .get(providerId)
-
-  let apiKey = ""
-  if (providerRow?.api_key_encrypted && providerRow?.api_key_iv) {
-    try {
-      apiKey = await decryptApiKey(providerRow.api_key_encrypted, providerRow.api_key_iv)
-    } catch { /* fall through to env var */ }
-  }
-  if (!apiKey) {
-    apiKey = process.env[`${providerId.toUpperCase()}_API_KEY`] || ""
-  }
-
-  return {
-    provider: providerId,
-    model: modelId,
-    apiKey,
-    baseUrl: providerRow?.base_url || undefined,
-    numCtx: providerRow?.num_ctx ?? undefined,
-    numGpu: providerRow?.num_gpu ?? undefined,
-  }
-}