@johpaz/hive 1.1.0

package/packages/core/src/agent/prompt-builder.ts

@@ -0,0 +1,532 @@
+import { getDb } from "../storage/sqlite"
+import { getGlobalStore } from "../storage/bun-sqlite-store"
+import { logger } from "../utils/logger"
+import { getUserDate, getUserTime } from "../utils/date"
+
+const log = logger.child("prompt-builder")
+
+export interface BuildPromptOptions {
+  agentId: string
+  userId: string
+}
+
+export async function buildSystemPrompt(options: BuildPromptOptions): Promise<string> {
+  const agentId = options.agentId
+  const userId = options.userId
+  if (!userId) {
+    throw new Error("No userId provided. Please set HIVE_USER_ID or complete onboarding.");
+  }
+  const db = getDb()
+  const store = getGlobalStore(db)
+  const parts: string[] = []
+
+  const t0 = performance.now()
+  log.info(`\n[CONTEXT] Building system prompt for Agent: ${agentId}, User: ${userId}`)
+
+  const agentRow = db
+    .query<any, [string]>("SELECT * FROM agents WHERE id = ?")
+    .get(agentId)
+
+  const t1 = performance.now()
+  if (agentRow) {
+    log.info(`[CONTEXT] ✓ Layer 1: Agent identity loaded (${(t1 - t0).toFixed(2)}ms) - ID: ${agentId}`)
+    parts.push(`# AGENT IDENTITY
+## Internal ID: ${agentRow.id}
+## Name: ${agentRow.name}
+## Description: ${agentRow.description || "Personal AI assistant"}
+## Tone: ${agentRow.tone || "friendly"}
+## Expertise: ${agentRow.expertise || "general assistance"}
+
+You are ${agentRow.name}, ${agentRow.description || "a helpful AI assistant"}.
+- Be ${agentRow.tone || "friendly and helpful"} in your responses
+- Focus on your areas of expertise
+- Never expose your internal agent_id to the user
+`)
+  } else {
+    parts.push(`# AGENT IDENTITY
+## Internal ID: ${agentId}
+You are Hive, a helpful AI assistant.
+`)
+  }
+
+  const userRow = db
+    .query<any, [string]>("SELECT * FROM users WHERE id = ?")
+    .get(userId)
+
+  const t2 = performance.now()
+  if (userRow) {
+    log.info(`[CONTEXT] ✓ Layer 1: User profile loaded (${(t2 - t1).toFixed(2)}ms) - User/Thread ID: ${userId}`)
+    const userInfo: string[] = []
+    if (userRow.name) userInfo.push(`Name: ${userRow.name}`)
+    if (userRow.occupation) userInfo.push(`Occupation: ${userRow.occupation}`)
+    if (userRow.language) userInfo.push(`Language: ${userRow.language}`)
+    if (userRow.timezone) userInfo.push(`Timezone: ${userRow.timezone}`)
+    if (userRow.notes) userInfo.push(`Notes: ${userRow.notes}`)
+
+    if (userInfo.length > 0) {
+      parts.push(`# USER PROFILE
+${userInfo.join("\n")}
+`)
+    }
+  }
+
+  try {
+    const tTools = performance.now()
+    const toolsData = await store.get("tools:active")
+    if (toolsData && toolsData.tools && Array.isArray(toolsData.tools)) {
+      log.info(`[CONTEXT] ✓ Layer 2: Tools loaded (${(performance.now() - tTools).toFixed(2)}ms) - ${toolsData.tools.length} active`)
+      const toolsList = toolsData.tools
+        .filter((t: any) => t && t.name)
+        .map((t: any) => `- **${t.name}**: ${t.description || "No description"} (${t.category || "general"})`)
+        .join("\n")
+
+      if (toolsList) {
+        parts.push(`# AVAILABLE TOOLS
+${toolsList}
+`)
+      }
+    }
+  } catch (e) {
+    log.warn("[prompt-builder] Failed to load tools from store:", e)
+  }
+
+  try {
+    const tSkills = performance.now()
+    const skillsData = await store.get("skills:active")
+    if (skillsData && skillsData.skills && Array.isArray(skillsData.skills)) {
+      log.info(`[CONTEXT] ✓ Layer 2: Skills loaded (${(performance.now() - tSkills).toFixed(2)}ms) - ${skillsData.skills.length} active`)
+      const skillsList = skillsData.skills
+        .filter((s: any) => s && s.name)
+        .map((s: any) => `- **${s.name}**: ${s.description || "No description"}`)
+        .join("\n")
+
+      if (skillsList) {
+        parts.push(`# AVAILABLE SKILLS
+${skillsList}
+`)
+      }
+    }
+  } catch (e) {
+    log.warn("[prompt-builder] Failed to load skills from store:", e)
+  }
+
+  try {
+    const mcpData = await store.get("mcp:connected")
+    if (mcpData && mcpData.servers && Array.isArray(mcpData.servers)) {
+      const mcpList = mcpData.servers
+        .filter((s: any) => s && s.name)
+        .map((s: any) => `- **${s.name}**: ${s.transport} (${s.command || s.url || "local"})`)
+        .join("\n")
+
+      if (mcpList) {
+        parts.push(`# CONNECTED MCP SERVERS
+${mcpList}
+`)
+      }
+    }
+  } catch (e) {
+    log.warn("[prompt-builder] Failed to load MCP from store:", e)
+  }
+
+  try {
+    const tEthics = performance.now()
+    const ethicsData = await store.get("ethics:rules")
+    if (ethicsData && ethicsData.rules && Array.isArray(ethicsData.rules)) {
+      log.info(`[CONTEXT] ✓ Layer 2: Ethics loaded (${(performance.now() - tEthics).toFixed(2)}ms) - ${ethicsData.rules.length} active rules`)
+      const alwaysRules = ethicsData.rules.filter((r: any) => r.content?.startsWith("ALWAYS:"))
+      const neverRules = ethicsData.rules.filter((r: any) => r.content?.startsWith("NEVER:"))
+      const confirmRules = ethicsData.rules.filter((r: any) => r.content?.startsWith("CONFIRM:"))
+
+      const ethicsParts: string[] = []
+      if (alwaysRules.length > 0) {
+        ethicsParts.push("## Always\n" + alwaysRules.map((r: any) => `- ${r.content.replace("ALWAYS:", "").trim()}`).join("\n"))
+      }
+      if (neverRules.length > 0) {
+        ethicsParts.push("## Never\n" + neverRules.map((r: any) => `- ${r.content.replace("NEVER:", "").trim()}`).join("\n"))
+      }
+      if (confirmRules.length > 0) {
+        ethicsParts.push("## Confirm Before\n" + confirmRules.map((r: any) => `- ${r.content.replace("CONFIRM:", "").trim()}`).join("\n"))
+      }
+
+      if (ethicsParts.length > 0) {
+        parts.push(`# ETHICS GUIDELINES\n${ethicsParts.join("\n\n")}\n`)
+      }
+    }
+  } catch (e) {
+    log.warn("[prompt-builder] Failed to load ethics from store:", e)
+  }
+
+  // Active providers (with API key OR local like Ollama) and their active models
+  try {
+    const activeProviders = db.query<any, []>(`
+      SELECT p.id, p.name, p.base_url,
+             CASE WHEN p.api_key_encrypted IS NOT NULL THEN 1 ELSE 0 END as has_api_key,
+             GROUP_CONCAT(m.name, ', ') as model_names
+      FROM providers p
+      LEFT JOIN models m ON m.provider_id = p.id AND (m.active = 1 OR m.enabled = 1)
+      WHERE p.active = 1
+        AND (
+          p.api_key_encrypted IS NOT NULL
+          OR p.base_url LIKE '%localhost%'
+          OR p.base_url LIKE '%127.0.0.1%'
+          OR p.id = 'ollama'
+        )
+      GROUP BY p.id
+    `).all()
+
+    if (activeProviders.length > 0) {
+      const providerList = activeProviders
+        .map((p: any) => {
+          const authInfo = p.has_api_key ? "API key configurada" : "local (sin API key)"
+          const base = p.base_url ? ` — ${p.base_url}` : ""
+          const modelList = p.model_names ? `\n  Modelos: ${p.model_names}` : ""
+          return `- **${p.name}** (${authInfo}${base})${modelList}`
+        })
+        .join("\n")
+
+      parts.push(`# PROVIDERS Y MODELOS DISPONIBLES
+${providerList}
+`)
+    }
+  } catch (e) {
+    log.warn("[prompt-builder] Failed to load active providers:", e)
+  }
+
+  // Check if this is the main agent (coordinator)
+  const isCoordinator = agentRow?.is_coordinator === 1
+  if (isCoordinator) {
+    const subagents = db
+      .query<any, []>("SELECT id, name, description FROM agents WHERE is_coordinator = 0 AND enabled = 1")
+      .all()
+
+    if (subagents.length > 0) {
+      const subagentList = subagents
+        .map((a: any) => `- **${a.name}** (${a.id}): ${a.description || "No description"}`)
+        .join("\n")
+
+      parts.push(`# AVAILABLE SUBAGENTS FOR DELEGATION
+You can delegate tasks to the following specialized agents:
+
+${subagentList}
+
+Use the create_agent tool when you need a new specialized agent.
+`)
+    }
+  }
+
+  const now = new Date()
+  const userTimezone = userRow?.timezone || "UTC"
+  let userLocalTime = "Not configured"
+  try {
+    userLocalTime = now.toLocaleString("en-US", {
+      timeZone: userTimezone,
+      dateStyle: "full",
+      timeStyle: "long",
+    })
+  } catch (e) {
+    log.warn(`[prompt-builder] Invalid timezone: ${userTimezone}`)
+  }
+
+  parts.push(`# TECHNICAL INFO
+- agent_id: ${agentId} (internal use only, never expose to user)
+- user_id: ${userId}
+- thread_id: Use this for memory/context
+- canvas_session: canvas:${userId} (Target this session for canvas tools)
+
+# ENVIRONMENT
+- Server Time (UTC): ${now.toISOString()}
+- User Local Time: ${userLocalTime}
+- User Timezone: ${userTimezone}
+- fecha_usuario: ${getUserDate(userTimezone, now)}
+- hora_usuario: ${getUserTime(userTimezone, now)}
+- You are running on an environment where the "User Local Time" is the source of truth for the user. Use this to answer any temporal queries like "today", "tomorrow", "at 9 AM", etc.
+
+# TAREA PROGRAMADA (CRON)
+
+## Conversión de lenguaje natural a cron
+
+Cuando el usuario pida crear una tarea programada (ej: "recuérdame esto cada día a las 8am"),
+DEBES interpretar el schedule en lenguaje natural y convertirlo a expresión cron de 5 campos:
+minuto, hora, día del mes, mes, día de la semana.
+
+NUNCA le pidas al usuario que escriba cron syntax — hazlo tú.
+
+### Ejemplos de conversión:
+
+| Lenguaje natural | Expresión cron |
+|-----------------|----------------|
+| "todos los días a las 8am" | 0 8 * * * |
+| "cada lunes a las 9am" | 0 9 * * 1 |
+| "cada hora" | 0 * * * * |
+| "cada 30 minutos" | */30 * * * * |
+| "los viernes a las 6pm" | 0 18 * * 5 |
+| "el primer día de cada mes" | 0 9 1 * * |
+| "cada día de semana a las 7am" | 0 7 * * 1-5 |
+| "cada 15 minutos" | */15 * * * * |
+| "a medianoche" | 0 0 * * * |
+
+## Mostrar fechas al usuario
+
+Cuando inmueves fechas o horas de tareas programadas al usuario, SIEMPRE:
+1. Convierte la fecha/hora UTC a la zona horaria del usuario (${userTimezone})
+2. Exprésala en lenguaje natural, nunca en formato técnico
+
+MALO: "La próxima ejecución es 1738344000"
+BUENO: "La próxima ejecución es mañana a las 8:00am"
+
+MALO: "Schedule: 0 8 * * *"
+BUENO: "Se ejecutará todos los días a las 8:00am"
+
+## Cambio de timezone del usuario
+
+Si el usuario cambia su zona horaria (ej: "ahora estoy en Ciudad de México"),
+DEBES recalcular el next_run de todas sus tareas programadas existentes:
+
+1. Obtén la nueva zona horaria del usuario
+2. Para cada tarea programada, usa croner con la nueva timezone para recalcular
+3. Actualiza cada tarea en la base de datos con el nuevo next_run
+
+Ejemplo de cómo recalcular:
+- Nueva timezone: America/Mexico_City
+- Expresión cron original: 0 8 * * *
+- Nue Calcula el próximo run usando croner con la nueva timezone
+- Actualiza el campo next_run en la base de datos
+`)
+
+
+  // Instruir al agente para reportar progreso y narrar acciones
+  parts.push(`# COMMUNICATION GUIDELINES
+
+## Narración Obligatoria
+
+Durante tareas que toman tiempo en completarse, DEBES narrar tus acciones en lenguaje natural
+ANTES y DESPUÉS de usar cada herramienta. Esto mantiene al usuario informado en tiempo real.
+
+### Antes de usar una herramienta:
+
+Escribe UNA frase corta explicando qué vas a hacer. Esta frase llegará al usuario inmediatamente.
+
+Ejemplos de narración correcta:
+- Antes de buscar en internet: "Buscando en internet información sobre..."
+- Antes de revisar código: "Revisando el archivo auth.ts..."
+- Antes de activar un subagente: "Activando bee_test para ejecutar los tests..."
+- Antes de analizar documentos: "Analizando los documentos de la carpeta..."
+- Antes de hacer un commit: "Voy a hacer commit con los cambios corregidos..."
+- Antes de ejecutar tests: "Ejecutando los tests unitarios..."
+
+### Después de usar una herramienta:
+
+Escribe UNA frase corta resumiendo qué encontraste o qué hiciste. NUNCA incluyas datos técnicos
+ni JSON en la narración. Solo el resumen humano.
+
+Ejemplos de narración correcta:
+- Después de encontrar errores: "Encontré 3 problemas en el código, voy a corregirlos uno por uno"
+- Después de una búsqueda: "Encontré información relevante, analizándola..."
+- Después de ejecutar tests: "Los tests pasaron correctamente, no hay errores"
+- Después de analizar archivos: "Hay 5 archivos modificados en el último commit"
+
+### Reglas importantes:
+
+1. El resultado CRUDO de las herramientas (JSON, arrays, datos técnicos) NUNCA debe llegar al usuario
+2. Solo tu narración en lenguaje natural llega al usuario
+3. Si una tarea tiene múltiples pasos, menciona brevemente al inicio qué vas a hacer
+4. Usa la herramienta "report_progress" SOLO para estados formales (started, thinking, searching, processing, writing, completed, error, info)
+
+El usuario no debe esperar a ciegas - manténgase informado de cada paso importante.
+`)
+
+  parts.push(`
+# TOON FORMAT
+
+Tool and MCP responses use TOON (Token-Oriented Object Notation), a compact JSON alternative:
+
+## Arrays (tabular format):
+\`\`\`
+field1,field2,field3
+value1,value2,value3
+value4,value5,value6
+\`\`\`
+
+## Simple objects:
+\`\`\`
+name: Alice
+age: 30
+active: true
+\`\`\`
+
+## Nested objects:
+\`\`\`
+user:
+  name: John
+  profile:
+    age: 30
+\`\`\`
+
+Parse all tool/MCP responses as TOON format, not JSON.
+`)
+
+  log.info(`[CONTEXT] System prompt built in ${(performance.now() - t0).toFixed(2)}ms\n`)
+  return parts.join("\n\n")
+}
+
+async function loadCodeBridgeContext(userId: string): Promise<string> {
+  try {
+    const db = getDb()
+    const bridges = db
+      .query<any, [string]>(
+        "SELECT name, cli_command FROM code_bridge WHERE user_id = ? AND enabled = 1 AND active = 1"
+      )
+      .all(userId)
+
+    if (!bridges || bridges.length === 0) return ""
+
+    const list = bridges
+      .map((b: any) => `- **${b.name}**: \`${b.cli_command}\``)
+      .join("\n")
+
+    return `
+# HERRAMIENTAS CLI DISPONIBLES PARA PROYECTOS DE CÓDIGO
+
+Tienes acceso a las siguientes herramientas de desarrollo activadas en tu entorno:
+
+${list}
+
+Úsalas con la herramienta de ejecución de comandos cuando trabajes en proyectos de tipo "code".
+Casos de uso habituales: linting, tests, build, git, deploy, formateo.
+`
+  } catch {
+    return ""
+  }
+}
+
+export async function buildSystemPromptWithProjects(options: BuildPromptOptions): Promise<string> {
+  const basePrompt = await buildSystemPrompt(options)
+
+  const codeBridgeSection = await loadCodeBridgeContext(options.userId)
+
+  const projectInstructions = `
+# GESTIÓN DE PROYECTOS Y TAREAS COMPLEJAS
+
+Cuando recibas una solicitud que involucre código, múltiples pasos interdependientes,
+investigación estructurada, creación de contenido extenso, análisis de datos, o cualquier
+trabajo que requiera más de 2 herramientas o pasos — SIEMPRE debes:
+
+1. Llamar \`project_create\` ANTES de comenzar el trabajo
+2. Descomponer el trabajo en tareas atómicas dentro del mismo \`project_create\`
+3. Llamar \`task_update\` al iniciar y al completar cada tarea
+4. Llamar \`project_done\` o \`project_fail\` al finalizar
+
+## SEÑALES DE QUE NECESITAS UN PROYECTO
+
+- La solicitud usa verbos como: crear, construir, desarrollar, analizar, investigar, escribir, refactorizar, optimizar
+- Tu plan mental tiene más de 2 pasos
+- El resultado final tiene múltiples entregables (archivos, reportes, módulos)
+- Necesitas usar más de 2 herramientas diferentes
+- La tarea tomará varios turnos de conversación
+
+## TIPOS DE PROYECTO
+
+| Tipo | Cuándo usarlo |
+|------|---------------|
+| \`code\` | Desarrollo de software, scripts, APIs, debugging, refactoring |
+| \`research\` | Investigación, análisis de mercado, síntesis de información |
+| \`content\` | Escritura, documentación, presentaciones, emails extensos |
+| \`data\` | Análisis de datos, reportes, visualizaciones |
+| \`general\` | Cualquier otra tarea estructurada de múltiples pasos |
+
+## HERRAMIENTAS DISPONIBLES
+
+### \`project_create\` — Crear proyecto con tareas
+Parámetros:
+- \`name\`: Nombre descriptivo del proyecto
+- \`description\`: Objetivo del proyecto
+- \`type\`: "code" | "research" | "content" | "data" | "general"
+- \`tasks\`: Lista de tareas con \`name\`, \`description\`, y opcionalmente \`agent_id\`
+- Retorna: \`{ projectId, taskIds[] }\` — guarda estos IDs para las llamadas posteriores
+
+### \`task_update\` — Actualizar estado de una tarea
+Parámetros:
+- \`task_id\`: ID numérico de la tarea (de taskIds[])
+- \`status\`: "pending" | "in_progress" | "completed" | "failed" | "blocked"
+- \`progress\`: 0–100
+- \`result\`: Resultado o resumen al completar
+- \`agent_id\`: Reasignar a otro agente (opcional)
+
+### \`task_create\` — Agregar tarea extra a un proyecto existente
+### \`project_update\` — Actualizar progreso global del proyecto
+### \`project_done\` — Marcar proyecto completado (progress=100)
+### \`project_fail\` — Marcar proyecto fallido con motivo
+
+## EJEMPLO 1 — Proyecto de código
+
+**Usuario:** "Crea una API REST en Node.js con autenticación JWT y base de datos SQLite"
+
+\`\`\`
+1. project_create({
+     name: "API REST Node.js con JWT",
+     description: "API con autenticación JWT y persistencia SQLite",
+     type: "code",
+     tasks: [
+       { name: "Estructura y dependencias", description: "Inicializar proyecto, package.json, instalar deps" },
+       { name: "Configurar SQLite", description: "Schema de base de datos, migrations, conexión" },
+       { name: "Autenticación JWT", description: "Rutas /login y /register, middleware de verificación" },
+       { name: "Endpoints CRUD", description: "Rutas protegidas con JWT" },
+       { name: "Tests y documentación", description: "Tests básicos y README" }
+     ]
+   })
+   → Recibe: { projectId: "abc123", taskIds: [1, 2, 3, 4, 5] }
+
+2. task_update({ task_id: 1, status: "in_progress", progress: 0 })
+   [realiza trabajo de la tarea 1]
+   task_update({ task_id: 1, status: "completed", progress: 100, result: "package.json y deps instalados" })
+
+3. task_update({ task_id: 2, status: "in_progress", progress: 0 })
+   [realiza trabajo de la tarea 2]
+   task_update({ task_id: 2, status: "completed", progress: 100, result: "Schema SQL: users(id, email, password_hash)" })
+
+4. [... continúa con tareas 3, 4, 5 ...]
+
+5. project_done({ projectId: "abc123", summary: "API REST completa. 5 endpoints. Tests OK." })
+\`\`\`
+
+## EJEMPLO 2 — Proyecto con delegación a sub-agentes
+
+**Usuario:** "Investiga competidores, crea una landing page y un plan de marketing"
+
+\`\`\`
+1. project_create({
+     name: "Lanzamiento de producto",
+     type: "general",
+     tasks: [
+       { name: "Análisis de competidores", description: "Investigar 5 competidores principales" },
+       { name: "Diseño de landing page", description: "Estructura y copy de la página" },
+       { name: "Plan de marketing", description: "Estrategia de canales y mensajes" }
+     ]
+   })
+
+2. create_agent({ name: "researcher", description: "Especialista en análisis de mercado" })
+   create_agent({ name: "copywriter", description: "Especialista en contenido web y marketing" })
+
+3. task_update({ task_id: [id tarea 1], status: "in_progress", agent_id: [id researcher] })
+   [researcher investiga]
+   task_update({ task_id: [id], status: "completed", result: "Reporte de 5 competidores completo" })
+
+4. task_update({ task_id: [id tarea 2], status: "in_progress", agent_id: [id copywriter] })
+   [copywriter crea landing]
+   task_update({ task_id: [id], status: "completed", result: "Landing page con 5 secciones" })
+
+5. project_done({ projectId: "...", summary: "Landing, análisis y plan de marketing completados" })
+\`\`\`
+
+## REGLAS CRÍTICAS
+
+1. **SIEMPRE** crea el proyecto ANTES de empezar cualquier trabajo complejo
+2. **NUNCA** dejes una tarea en "in_progress" sin actualizarla al terminar
+3. Si una tarea falla, márcala como "failed" con el error en "result"
+4. El progreso del proyecto se calcula automáticamente como promedio de las tareas
+5. Usa \`task_create\` para agregar tareas imprevistas que surjan durante el trabajo
+6. Narra siempre al usuario qué tarea estás ejecutando antes de hacerlo
+`
+
+  return basePrompt + "\n\n" + projectInstructions + codeBridgeSection
+}

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

@@ -0,0 +1,167 @@
+/**
+ * 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/sqlite.ts"
+import { getSupervisorGraph } from "../supervisor.ts"
+
+export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek"
+
+export interface StepEvent {
+  type: "text" | "plan" | "tool_call" | "tool_result"
+  message: string
+  toolName?: string
+  isError?: boolean
+}
+
+export interface ModelOptions {
+  provider?: Provider
+  model?: string
+  maxTokens?: number
+  temperature?: number
+  system?: string
+  messages: Array<{ role: string; content: string }>
+  tools?: Record<string, any>
+  maxSteps?: number
+  onToken?: (token: string) => void
+  onStep?: (step: StepEvent) => Promise<void>
+  threadId?: string
+  userId?: string
+  channel?: string
+}
+
+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()
+    const coordinatorAgent = db
+      .query<any, []>("SELECT id FROM agents WHERE is_coordinator = 1 LIMIT 1")
+      .get()
+    const agentId = process.env.HIVE_AGENT_ID || coordinatorAgent?.id || "main"
+
+    const userId = options.userId || process.env.HIVE_USER_ID
+    if (!userId) {
+      throw new Error("No userId provided. Please set HIVE_USER_ID or complete onboarding.")
+    }
+    const threadId = options.threadId || userId
+
+    const agentLoop = getSupervisorGraph()
+    if (!agentLoop) {
+      throw new Error("AgentLoop not initialized")
+    }
+
+    let lastAgentContent = ""
+    let toolCalls: ModelResponse["toolCalls"] = []
+
+    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,
+          },
+        }
+      )
+
+      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
+          logger.info(
+            `[STREAM] chunk#${chunkCount} agent: contentLen=${lastMsg?.content?.length ?? 0} hasToolCalls=${hasToolCalls}`
+          )
+
+          if (lastMsg?.content) {
+            const content = typeof lastMsg.content === "string" ? lastMsg.content : ""
+            lastAgentContent = content
+            if (options.onToken) options.onToken(content)
+          }
+
+          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 : "",
+            })
+          }
+        }
+      }
+
+      logger.debug(`[STREAM] done. totalChunks=${chunkCount} lastAgentContent length=${lastAgentContent.length}`)
+
+      return {
+        content: lastAgentContent,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        finishReason: "stop",
+      }
+    } catch (error) {
+      logger.error("AgentRunner error:", error)
+      throw error
+    }
+  }
+}
+
+export function createAgentRunner(config: Config): AgentRunner {
+  return new AgentRunner(config)
+}

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

@@ -0,0 +1 @@
+export * from "./providers/index.ts";