@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/agent/agent-loop.ts

@@ -1,520 +0,0 @@
-/**
- * Agent Loop — native implementation, no LangGraph.
- *
- * Replaces supervisor.ts + graph.ts.
- *
- * Pattern:
- *   user message → context compiler → model call → [tool call → model call]* → response
- *
- * Exposes an async generator compatible with the existing providers/index.ts stream API:
- *   yield { agent: { messages: [AIMessage] } }
- *   yield { tools: { messages: [ToolMessage] } }
- *
- * Also used directly by runAgentIsolated() for worker tasks.
- */
-
-import { logger } from "../utils/logger"
-import { getDb } from "../storage/sqlite"
-import { callLLM, resolveProviderConfig, type LLMMessage } from "./llm-client"
-import { addMessage } from "./conversation-store"
-import { saveTrace, recordLLMUsage } from "./tracer"
-import { maybeCompact, clearOldToolResults } from "./compaction"
-import { emitCanvas } from "../canvas/emitter"
-import type { MCPClientManager } from "@johpaz/hive-mcp"
-import { compileContext } from "./context-compiler"
-import { formatToolResult, parse as parseToon } from "../utils/toon"
-import { resolveUserId, resolveAgentId } from "../storage/onboarding"
-
-/**
- * Execute a tool by name from the available tools list
- * This is a local helper function since executeTool is not exported elsewhere
- * 
- * Tool results are formatted in TOON to save tokens on input to the model.
- */
-async function executeTool(
-  allTools: Array<{ name: string; execute?: (params: Record<string, unknown>, config?: any) => Promise<unknown> }>,
-  toolName: string,
-  args: unknown,
-  config: { user_id?: string; thread_id?: string; channel?: string; workspace?: string | null }
-): Promise<string> {
-  const tool = allTools.find(t => t.name === toolName)
-  if (!tool?.execute) {
-    return `[Tool Error] Tool '${toolName}' not found or not executable`
-  }
-  try {
-    const parsedArgs = typeof args === 'string' ? JSON.parse(args) : args
-    const result = await tool.execute(parsedArgs as Record<string, unknown>, { configurable: config })
-    // TOON format for token savings on model input
-    return formatToolResult(result)
-  } catch (err) {
-    // Also format errors as TOON
-    return formatToolResult({
-      error: true,
-      tool: toolName,
-      message: (err as Error).message,
-      timestamp: new Date().toISOString(),
-    })
-  }
-}
-
-const log = logger.child("agent-loop")
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export interface AgentLoopOptions {
-  agentId: string
-  userMessage: string
-  threadId: string
-  channel?: string
-  mcpManager?: MCPClientManager | null
-  /** System prompt override (from server.ts config) */
-  systemPromptOverride?: string
-  /** Worker mode: isolated context + single-task execution */
-  isolated?: boolean
-  taskContext?: string
-  onStep?: (step: StepEvent) => Promise<void>
-  /** User ID for context propagation */
-  userId?: string
-}
-
-export interface StepEvent {
-  type: "text" | "tool_call" | "tool_result"
-  message: string
-  toolName?: string
-  isError?: boolean
-}
-
-// ─── Stream chunk types (compatible with providers/index.ts) ─────────────────
-
-export interface StreamChunk {
-  agent?: { messages: any[] }
-  tools?: { messages: any[] }
-}
-
-// ─── Main agent loop ──────────────────────────────────────────────────────────
-
-export async function* runAgent(
-  opts: AgentLoopOptions
-): AsyncGenerator<StreamChunk> {
-  const t0 = performance.now()
-  const db = getDb()
-
-  // Load agent config from DB
-  const agent = db.query<any, [string]>("SELECT * FROM agents WHERE id = ?").get(opts.agentId)
-  if (!agent) throw new Error(`Agent not found: ${opts.agentId}`)
-
-  const agentName = agent.name || opts.agentId
-  const maxIterations = agent.max_iterations || 10
-
-  // Resolve LLM provider config
-  const providerCfg = await resolveProviderConfig(
-    agent.provider_id || "openai",
-    agent.model_id || "gpt-4o-mini"
-  )
-
-  const cleanModel = providerCfg.model.replace(new RegExp(`^${providerCfg.provider}\\/`), "")
-  log.info(`[agent-loop] Starting: agent=${agentName} thread=${opts.threadId} provider=${providerCfg.provider}/${cleanModel}`)
-
-  emitCanvas("canvas:node_update", {
-    nodeId: agentName,
-    changes: { status: "thinking" },
-  })
-
-  // Store the user message in conversation history
-  if (!opts.isolated) {
-    addMessage(opts.threadId, "user", opts.userMessage, { channel: opts.channel })
-    // Run compaction if conversation history is getting large
-    await maybeCompact(opts.threadId)
-  }
-
-  // Compile context (system prompt + history + tools)
-  const ctx = await compileContext({
-    agentId: opts.agentId,
-    threadId: opts.threadId,
-    userMessage: opts.userMessage,
-    channel: opts.channel,
-    mcpManager: opts.mcpManager,
-    isolated: opts.isolated,
-    taskContext: opts.taskContext,
-    userId: opts.userId,
-  })
-
-  const systemPrompt = opts.systemPromptOverride || ctx.systemPrompt
-
-  // Build initial messages array for the model
-  let messages: LLMMessage[] = [
-    { role: "system", content: systemPrompt },
-    ...ctx.messages,
-  ]
-
-  // For isolated workers the user message is the task context, not from history
-  if (opts.isolated) {
-    messages.push({ role: "user", content: opts.userMessage })
-  }
-
-  let iterations = 0
-  let totalInputTokens = 0
-  let totalOutputTokens = 0
-  let finalContent = ""
-  // Loop detection: track last tool call signature to break identical consecutive calls
-  let lastToolSignature = ""
-  let consecutiveRepeat = 0
-
-  // ── The loop ────────────────────────────────────────────────────────────
-  while (iterations < maxIterations) {
-    iterations++
-
-    const response = await callLLM({
-      ...providerCfg,
-      messages: clearOldToolResults(messages) as LLMMessage[],
-      tools: ctx.tools.length > 0 ? ctx.tools : undefined,
-    })
-
-    // Accumulate usage
-    if (response.usage) {
-      totalInputTokens += response.usage.input_tokens
-      totalOutputTokens += response.usage.output_tokens
-    }
-
-    // Emit agent chunk (compatible with providers/index.ts)
-    const agentMsg: any = { content: response.content }
-    if (response.tool_calls?.length) agentMsg.tool_calls = response.tool_calls
-    yield { agent: { messages: [agentMsg] } }
-
-    // Notify onStep for narration text
-    if (opts.onStep && response.content) {
-      await opts.onStep({ type: "text", message: response.content })
-    }
-
-    // ── No tool calls → final response ──────────────────────────────────
-    if (!response.tool_calls?.length || response.stop_reason !== "tool_calls") {
-      // Use response.content if available, otherwise use fallback message for successful tool execution
-      finalContent = response.content && response.content.trim().length > 0
-        ? response.content
-        : "Tarea completada exitosamente."
-      // Save assistant message to history
-      if (!opts.isolated) {
-        addMessage(opts.threadId, "assistant", finalContent)
-      }
-      break
-    }
-
-    // ── Tool calls → execute each tool ──────────────────────────────────
-    // Add assistant message with tool_calls to local messages array
-    messages.push({
-      role: "assistant",
-      content: response.content,
-      tool_calls: response.tool_calls,
-    })
-
-    for (const tc of response.tool_calls) {
-      const toolName = tc.function.name
-
-      emitCanvas("canvas:node_update", {
-        nodeId: agentName,
-        changes: { status: "tool_call", currentTool: toolName },
-      })
-
-      if (opts.onStep) {
-        if (response.content) {
-          await opts.onStep({ type: "text", message: response.content })
-        }
-        await opts.onStep({
-          type: "tool_call",
-          toolName,
-          message: `Calling tool: \`${toolName}\``,
-        })
-      }
-
-      const tTool = performance.now()
-      const toolResult = await executeTool(
-        ctx.allTools,
-        toolName,
-        tc.function.arguments,
-        {
-          user_id: opts.userId,
-          thread_id: opts.threadId,
-          channel: opts.channel,
-          workspace: agent.workspace ?? null,
-        }
-      )
-      const toolMs = Math.round(performance.now() - tTool)
-
-      log.info(`[agent-loop] Tool ${toolName} completed in ${toolMs}ms`)
-
-      // Log tool result before returning to agent (truncated to avoid flooding logs)
-      const resultPreview = toolResult.length > 500
-        ? toolResult.substring(0, 500) + `… (+${toolResult.length - 500} chars)`
-        : toolResult
-      log.info(`[agent-loop] Tool result [${toolName}]: ${resultPreview}`)
-
-      // Clean timestamp from message for trace
-      const cleanMessage = opts.userMessage.replace(/^\[Timestamp:.*?\]\n/, "")
-
-      // Save tool call trace
-      saveTrace({
-        threadId: opts.threadId,
-        agentId: opts.agentId,
-        agentName,
-        toolUsed: toolName,
-        inputSummary: `${cleanMessage.substring(0, 200)} → ${toolName}`,
-        outputSummary: toolResult.substring(0, 300),
-        success: !toolResult.startsWith("[Tool Error]"),
-        errorMessage: toolResult.startsWith("[Tool Error]") ? toolResult : null,
-        durationMs: toolMs,
-      })
-
-      // Emit tool chunk
-      yield { tools: { messages: [{ content: toolResult, tool_call_id: tc.id }] } }
-
-      if (opts.onStep) {
-        await opts.onStep({ type: "tool_result", message: toolResult })
-      }
-
-      // Add tool result to messages for next model call
-      messages.push({
-        role: "tool",
-        content: toolResult,
-        tool_call_id: tc.id,
-      })
-
-      // Dynamic tool injection: when search_knowledge finds tools, add them to ctx.tools
-      // so the LLM can call them in subsequent iterations without re-searching
-      if (toolName === "search_knowledge") {
-        try {
-          const parsed = parseToon(toolResult).data
-          const foundTools: Array<{ name: string }> = parsed?.tools ?? []
-          const currentToolNames = new Set(ctx.tools.map((t: any) => t.function?.name))
-          for (const found of foundTools) {
-            if (!currentToolNames.has(found.name)) {
-              const nativeTool = ctx.allTools.find(t => t.name === found.name)
-              if (nativeTool) {
-                ctx.tools.push({
-                  type: "function",
-                  function: {
-                    name: nativeTool.name,
-                    description: (nativeTool as any).description ?? "",
-                    parameters: (nativeTool as any).parameters ?? { type: "object", properties: {} },
-                  },
-                })
-                log.info(`[agent-loop] Injected discovered tool into loadout: ${nativeTool.name}`)
-                currentToolNames.add(found.name)
-              }
-            }
-          }
-        } catch {
-          // Non-critical — tool injection is best-effort
-        }
-      }
-
-      // Loop detection: same tool + same args called consecutively → break
-      const sig = `${toolName}:${JSON.stringify(tc.function.arguments)}`
-      if (sig === lastToolSignature) {
-        consecutiveRepeat++
-        if (consecutiveRepeat >= 2) {
-          log.warn(`[agent-loop] Loop detected: "${toolName}" called ${consecutiveRepeat + 1} times with same args. Breaking.`)
-          finalContent = "No pude completar la tarea porque no encontré las herramientas necesarias para ello."
-          break
-        }
-      } else {
-        lastToolSignature = sig
-        consecutiveRepeat = 0
-      }
-    }
-
-    emitCanvas("canvas:node_update", {
-      nodeId: agentName,
-      changes: { status: "thinking", currentTool: null },
-    })
-  }
-
-  // ── Synthesis call when max iterations hit without a text response ────────
-  // The agent spent all iterations on tool calls and never produced a final message.
-  // Make one extra call without tools so it summarizes what it did.
-  if (!finalContent && !opts.isolated) {
-    log.info(`[agent-loop] Max iterations hit with no text response — requesting synthesis`)
-    try {
-      messages.push({
-        role: "user",
-        content: "Basándote en lo que hiciste hasta ahora, responde al usuario con un resumen claro de lo que completaste o del estado actual. Sé conciso.",
-      })
-      const synthesis = await callLLM({
-        ...providerCfg,
-        messages: clearOldToolResults(messages) as LLMMessage[],
-        tools: undefined, // no tools — force text response
-      })
-      if (synthesis.usage) {
-        totalInputTokens += synthesis.usage.input_tokens
-        totalOutputTokens += synthesis.usage.output_tokens
-      }
-      finalContent = synthesis.content?.trim() || "He completado las tareas solicitadas."
-      addMessage(opts.threadId, "assistant", finalContent)
-      yield { agent: { messages: [{ content: finalContent }] } }
-    } catch (err) {
-      log.warn(`[agent-loop] Synthesis call failed: ${(err as Error).message}`)
-      finalContent = "He completado las tareas solicitadas."
-      addMessage(opts.threadId, "assistant", finalContent)
-      yield { agent: { messages: [{ content: finalContent }] } }
-    }
-  }
-
-  // ── Post-loop ────────────────────────────────────────────────────────────
-  const durationMs = Math.round(performance.now() - t0)
-
-  emitCanvas("canvas:node_update", {
-    nodeId: agentName,
-    changes: { status: "idle", currentTool: null },
-  })
-
-  // Record usage
-  recordLLMUsage({
-    provider: providerCfg.provider,
-    model: providerCfg.model,
-    inputTokens: totalInputTokens,
-    outputTokens: totalOutputTokens,
-  })
-
-  // Save overall trace
-  const cleanMessageFinal = opts.userMessage.replace(/^\[Timestamp:.*?\]\n/, "")
-  saveTrace({
-    threadId: opts.threadId,
-    agentId: opts.agentId,
-    agentName,
-    inputSummary: cleanMessageFinal.substring(0, 300),
-    outputSummary: finalContent.substring(0, 300),
-    success: true,
-    durationMs,
-    tokensUsed: totalInputTokens + totalOutputTokens,
-  })
-
-  log.info(
-    `[agent-loop] Done: agent=${agentName} iterations=${iterations} ` +
-    `tokens=${totalInputTokens + totalOutputTokens} elapsed=${durationMs}ms`
-  )
-}
-
-// ─── Isolated worker execution (Fase 4.4) ───────────────────────────────────
-
-/**
- * Run a worker agent in an isolated context.
- * Returns the final response string.
- */
-export async function runAgentIsolated(opts: {
-  agentId: string
-  taskDescription: string
-  threadId: string
-  mcpManager?: MCPClientManager | null
-}): Promise<string> {
-  let lastContent = ""
-  for await (const chunk of runAgent({
-    agentId: opts.agentId,
-    userMessage: opts.taskDescription,
-    threadId: opts.threadId,
-    isolated: true,
-    taskContext: opts.taskDescription,
-    mcpManager: opts.mcpManager,
-  })) {
-    if (chunk.agent?.messages?.[0]?.content) {
-      lastContent = chunk.agent.messages[0].content
-    }
-  }
-  return lastContent
-}
-
-// ─── Shim: AgentLoop class with stream() compatible with providers/index.ts ──
-
-export class AgentLoop {
-  private mcpManager: MCPClientManager | null = null
-
-  setMCPManager(m: MCPClientManager) {
-    this.mcpManager = m
-  }
-
-  /**
-   * Returns an async iterable that emits chunks compatible with
-   * the existing providers/index.ts stream consumer.
-   */
-  stream(
-    input: { messages: Array<{ role: string; content: string }> },
-    config: {
-      configurable?: {
-        thread_id?: string
-        agent_id?: string
-        user_id?: string
-        system_prompt?: string
-        channel?: string
-        raw_user_message?: string
-      }
-    }
-  ): AsyncIterable<StreamChunk> {
-    // Resolve from database with priority: explicit param → DB lookup → single user/agent
-    const threadId = config.configurable?.thread_id || resolveUserId({}) || "default"
-    const agentId = config.configurable?.agent_id || resolveAgentId(config.configurable?.agent_id) || this._resolveCoordinatorId() || "main"
-    const systemPromptOverride = config.configurable?.system_prompt
-    const channel = config.configurable?.channel
-    const userId = config.configurable?.user_id || resolveUserId({
-      channel: config.configurable?.channel ? (config.configurable?.channel as string).split(':')[0] : null,
-      channelUserId: config.configurable?.thread_id
-    })
-
-    // Log MCP Manager status
-    console.log(`[AgentLoop.stream] MCP Manager available: ${this.mcpManager !== null}`)
-    if (this.mcpManager) {
-      try {
-        const servers = this.mcpManager.listServers?.() || []
-        console.log(`[AgentLoop.stream] MCP servers: ${servers.length} registered`)
-        for (const s of servers) {
-          console.log(`  - ${s.name}: ${s.status} (${s.tools?.length || 0} tools)`)
-        }
-      } catch (e) {
-        console.log(`[AgentLoop.stream] Failed to list MCP servers: ${(e as Error).message}`)
-      }
-    }
-
-    // Extract the last user message from the input
-    const lastUserMsg = [...input.messages].reverse().find((m) => m.role === "user")
-    const userMessage = lastUserMsg?.content || ""
-
-    // Use clean message (without timestamp) for FTS5 selectors
-    const rawUserMessage = config.configurable?.raw_user_message || userMessage
-
-    return runAgent({
-      agentId,
-      userMessage: rawUserMessage,  // Clean message for FTS5 selectors
-      threadId,
-      channel,
-      systemPromptOverride,
-      mcpManager: this.mcpManager,
-      userId,
-    })
-  }
-
-  private _resolveCoordinatorId(): string {
-    // Use the storage helper to get coordinator agent ID from database
-    const coordinatorId = resolveAgentId(null);
-    return coordinatorId || "main";
-  }
-}
-
-// Singleton
-let _agentLoop: AgentLoop | null = null
-
-export function getAgentLoop(): AgentLoop | null {
-  return _agentLoop
-}
-
-export function buildAgentLoop(opts: { mcpManager?: MCPClientManager | null } = {}): AgentLoop {
-  _agentLoop = new AgentLoop()
-  if (opts.mcpManager) {
-    _agentLoop.setMCPManager(opts.mcpManager)
-    console.log("[buildAgentLoop] MCP Manager set successfully")
-  } else {
-    console.log("[buildAgentLoop] WARNING: No MCP Manager provided, agent will not have MCP tools")
-  }
-  return _agentLoop
-}
-
-export async function rebuildAgentLoop(opts: { mcpManager?: MCPClientManager | null } = {}): Promise<AgentLoop> {
-  _agentLoop = null
-  return buildAgentLoop(opts)
-}

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

@@ -1,183 +0,0 @@
-/**
- * Compaction — Fase 6.
- *
- * Compresses conversation history when token count exceeds threshold.
- * Uses the active LLM to summarize old messages, preserving:
- *   - User data and preferences
- *   - Decisions made
- *   - Tool results
- *   - Context needed to continue
- *
- * Saves summary to `summaries` table. Original messages are kept (audit trail)
- * but the Context Compiler uses the summary instead of old messages.
- *
- * Also implements "tool result clearing": replaces old tool results with
- * short summaries in the in-memory message array before model calls.
- */
-
-import { logger } from "../utils/logger"
-import {
-  getTotalTokens,
-  getHistory,
-  getSummary,
-  saveSummary,
-  toAPIMessages,
-  getMessageCount,
-} from "./conversation-store"
-import { estimateTokens } from "../utils/toon"
-import { callLLM, resolveProviderConfig } from "./llm-client"
-import { getDb } from "../storage/sqlite"
-
-const log = logger.child("compaction")
-
-// Token budget: compress when stored tokens exceed this threshold
-const COMPACT_TOKEN_THRESHOLD = 6000   // ~60% of 10K context window
-const KEEP_LAST_N_MESSAGES = 5         // always keep most recent N messages
-const TOOL_RESULT_MAX_CHARS = 200      // max chars for old tool results after clearing
-const MAX_TRANSCRIPT_MSGS = 30         // cap messages sent to summarizer (avoids OOM on small models)
-const MAX_MSG_CHARS = 300              // chars per message in transcript
-
-/**
- * Check if compaction is needed and run it if so.
- * Called at the start of each agent loop iteration.
- */
-export async function maybeCompact(threadId: string): Promise<void> {
-  try {
-    const totalTokens = getTotalTokens(threadId)
-    if (totalTokens < COMPACT_TOKEN_THRESHOLD) return
-
-    const summary = getSummary(threadId)
-    const totalMessages = getMessageCount(threadId)
-
-    // Already summarized up to near the current state
-    if (summary && summary.last_message_id > totalMessages - KEEP_LAST_N_MESSAGES) return
-
-    log.info(`[compaction] Compacting thread=${threadId} tokens=${totalTokens}`)
-    await compactThread(threadId)
-  } catch (err) {
-    log.warn("[compaction] Error during compaction check:", err)
-  }
-}
-
-/**
- * Compress a thread's history into a summary.
- */
-export async function compactThread(threadId: string): Promise<void> {
-  const allMessages = getHistory(threadId)
-  if (allMessages.length <= KEEP_LAST_N_MESSAGES) return
-
-  const toSummarize = allMessages.slice(0, allMessages.length - KEEP_LAST_N_MESSAGES)
-  if (toSummarize.length === 0) return
-
-  const lastSummarizedId = toSummarize[toSummarize.length - 1].id
-
-  const existingSummary = getSummary(threadId)
-  if (existingSummary && existingSummary.last_message_id >= lastSummarizedId) return
-
-  // Cap transcript to avoid overflowing small model contexts
-  const capped = toSummarize.slice(-MAX_TRANSCRIPT_MSGS)
-  const apiMessages = toAPIMessages(capped)
-  const transcript = apiMessages
-    .map((m) => `[${m.role.toUpperCase()}]: ${m.content.substring(0, MAX_MSG_CHARS)}`)
-    .join("\n\n")
-
-  const db = getDb()
-  const coordinator = db.query<any, []>(
-    "SELECT provider_id, model_id FROM agents WHERE role = 'coordinator' LIMIT 1"
-  ).get()
-
-  const providerCfg = await resolveProviderConfig(
-    coordinator?.provider_id || "openai",
-    coordinator?.model_id || "gpt-4o-mini"
-  )
-
-  const summaryResponse = await callLLM({
-    ...providerCfg,
-    messages: [
-      {
-        role: "system",
-        content:
-          "You are a conversation summarizer. Create a concise summary preserving: " +
-          "user preferences, decisions made, important facts, tool results, and context needed to continue.",
-      },
-      {
-        role: "user",
-        content: `Summarize this conversation (${toSummarize.length} messages) in 3-5 sentences:\n\n${transcript}`,
-      },
-    ],
-  })
-
-  const summary = summaryResponse.content.trim()
-  if (!summary) return
-
-  saveSummary(threadId, summary, toSummarize.length, lastSummarizedId)
-  log.info(
-    `[compaction] Thread ${threadId} compacted: ${toSummarize.length} msgs → ${estimateTokens(summary)} tokens`
-  )
-}
-
-/**
- * Clear old tool results in-memory to reduce tokens before a model call.
- * Does NOT modify the database — only the in-memory messages array.
- * 
- * Strategy: COMPRESS (Context Engineering)
- * - Replaces old tool results with short summaries
- * - Keeps recent tool results intact (keepLastN)
- * - Uses TOON format for compact representation
- */
-export function clearOldToolResults<T extends { role: string; content: string }>(
-  messages: T[],
-  keepLastN = 6
-): T[] {
-  if (messages.length <= keepLastN) return messages
-  const cutoffIndex = messages.length - keepLastN
-
-  return messages.map((msg, i) => {
-    if (i >= cutoffIndex) return msg
-    
-    if (msg.role === "tool") {
-      // For tool results older than keepLastN, summarize
-      if (msg.content.length > TOOL_RESULT_MAX_CHARS) {
-        // Try to extract key info from TOON/JSON format
-        let summary = msg.content.substring(0, TOOL_RESULT_MAX_CHARS)
-        
-        // If it looks like JSON/TOON, add a marker
-        if (msg.content.trim().startsWith('{') || msg.content.trim().includes(':')) {
-          summary = `[Tool result summarized: ${summary}...]`
-        } else {
-          summary = `[Result truncated: ${summary}...]`
-        }
-        
-        return {
-          ...msg,
-          content: summary,
-        }
-      }
-    }
-    
-    return msg
-  })
-}
-
-/**
- * Summarize a tool result to a single line
- * Used for very old tool results (> 10 turns)
- */
-export function summarizeToolResult(content: string, toolName?: string): string {
-  // Try to extract success/failure status
-  const isError = content.includes('error') || content.includes('failed') || content.startsWith('[Tool Error]')
-  const isSuccess = content.includes('ok') || content.includes('success') || content.includes('true')
-  
-  // Try to extract key result field from JSON/TOON
-  let keyInfo = ""
-  try {
-    // Simple extraction of first key value
-    const firstLine = content.split('\n')[0].substring(0, 80)
-    keyInfo = firstLine
-  } catch {
-    keyInfo = content.substring(0, 80)
-  }
-  
-  const status = isError ? "failed" : isSuccess ? "success" : "completed"
-  return `[${toolName || 'Tool'} ${status}: ${keyInfo}...]`
-}