@johpaz/hive-sdk 0.1.6 → 0.3.0

package/packages/core/src/agent/context-compiler.ts

@@ -21,27 +21,28 @@
  * TODOS los datos se formatean en TOON para ahorro de tokens.
  */
 
-import { col, fromIndexable } from "../storage/hive"
-import type { AgentDoc, ModelDoc } from "../storage/collections"
-import { logger } from "../utils/logger"
-import type { LLMMessage, LLMToolDef, ContentPart } from "./llm-client"
+import { col, fromIndexable } from "../storage/hive.ts"
+import type { AgentDoc, ModelDoc } from "../storage/collections.ts"
+import { logger } from "../utils/logger.ts"
+import type { LLMMessage, LLMToolDef, ContentPart } from "./llm-client.ts"
 import type { MCPClientManager } from "../mcp/index.ts"
-import { syncToolCatalogToIndex, mcpToolFullName } from "./tool-selector"
-import { syncSkillsToIndex, getMinimalSkills, selectSkills, getSkillByName, type SkillDescriptor } from "./skill-selector"
-import { syncPlaybookToIndex, selectPlaybookRules } from "./playbook-selector"
-import { getRecentMessages, getSummary, getScratchpad, toAPIMessages } from "./conversation-store"
-import { formatContext, estimateTokens } from "../utils/toon"
-import { buildSystemPromptWithProjects } from "./prompt-builder"
+import { syncToolCatalogToIndex, mcpToolFullName } from "./tool-selector.ts"
+import { syncSkillsToIndex, getMinimalSkills, selectSkills, getSkillByName, type SkillDescriptor } from "./skill-selector.ts"
+import { syncPlaybookToIndex, selectPlaybookRules } from "./playbook-selector.ts"
+import { getRecentMessages, getSummary, getScratchpad, toAPIMessages, inflateRecentImages } from "./conversation-store.ts"
+import { formatContext, estimateTokens } from "../utils/toon.ts"
+import { buildSystemPromptWithProjects } from "./prompt-builder.ts"
 import { createAllTools } from "../tools/index.ts"
-import { resolveUserId } from "../storage/onboarding"
-import { getMCPManager as getSingletonMCPManager } from "../mcp/singleton"
-import { syncMCPToolsToDB, syncMCPToolsToIndex } from "../mcp/tool-sync"
-import { getUserDate, getUserTime } from "../utils/date"
-import { loadConfig } from "../config/loader"
-import { getHiveDb } from "../storage/hivedb"
-import { listCatalogAgents, renderAgentRoutingCatalog } from "./catalog-selector"
-import { expandToolAllowlist } from "./delegation-runtime"
-import { MINIMAL_TOOLS } from "./minimal-loadout"
+import { resolveUserId } from "../storage/onboarding.ts"
+import { getMCPManager as getSingletonMCPManager } from "../mcp/singleton.ts"
+import { syncMCPToolsToDB, syncMCPToolsToIndex } from "../mcp/tool-sync.ts"
+import { getUserDate, getUserTime } from "../utils/date.ts"
+import { loadConfig } from "../config/loader.ts"
+import { getHiveDb } from "../storage/hivedb.ts"
+import { listCatalogAgents, renderAgentRoutingCatalog } from "./catalog-selector.ts"
+import { expandToolAllowlist } from "./delegation-runtime.ts"
+import { MINIMAL_TOOLS } from "./minimal-loadout.ts"
+import { normalizeMcpResult } from "./mcp-result-normalizer.ts"
 
 const log = logger.child("context-compiler")
 
@@ -238,7 +239,7 @@ export async function compileContext(opts: {
 
   if (effectiveMcpManager) {
     try {
-      const mcpServersCol = await col<import("../storage/collections").McpServerDoc>("mcpServers")
+      const mcpServersCol = await col<import("../storage/collections.ts").McpServerDoc>("mcpServers")
       const assignedMcpIds = new Set<string>([
         ...(agent.mcp_server_ids_json ? JSON.parse(agent.mcp_server_ids_json) : []),
         ...(agent.active_mcp_json ? JSON.parse(agent.active_mcp_json) : []),
@@ -293,10 +294,20 @@ export async function compileContext(opts: {
               name: fullName,
               description: mcpTool.description || `Tool from ${server.name}`,
               parameters: mcpTool.inputSchema || { type: "object", properties: {} },
-              execute: async (params: Record<string, unknown>) => {
+              execute: async (params: Record<string, unknown>, config?: { configurable?: Record<string, unknown> }) => {
                 // Return raw JS value — agent-loop will TOON-encode via formatToolResult.
                 // Never pre-stringify here: formatToolResult(string) double-encodes.
-                return await effectiveMcpManager.callTool(resolvedServerKey, mcpTool.name, params)
+                const raw = await effectiveMcpManager.callTool(resolvedServerKey, mcpTool.name, params)
+                // MCP results can carry base64 image/audio/blob content blocks —
+                // normalize those into artifact_ref pointers so a large binary
+                // result never gets serialized whole into the LLM context (see
+                // mcp-result-normalizer.ts for the incident this prevents).
+                const configurable = config?.configurable ?? {}
+                return await normalizeMcpResult(raw, {
+                  userId: configurable.user_id ? String(configurable.user_id) : undefined,
+                  runId: configurable.run_id ? String(configurable.run_id) : null,
+                  taskId: configurable.task_id ? String(configurable.task_id) : null,
+                })
               },
             })
 
@@ -352,17 +363,30 @@ export async function compileContext(opts: {
   // Only native minimal tools in LLM context
   // MCP tools are discovered dynamically via search_knowledge(type="mcp")
   let filteredNativeTools: ContextTool[] = nativeTools.filter(t => MINIMAL_TOOLS.has(t.name))
-  if (isCatalogAgent) {
-    const allowedNames = new Set<string>(
-      agent.tool_allowlist_json
-        ? expandToolAllowlist(
-          JSON.parse(agent.tool_allowlist_json),
-          nativeTools.map((tool) => tool.name),
-        )
-        : agent.tools_json
-          ? JSON.parse(agent.tools_json)
-          : [],
+
+  // La lista blanca se aplica a `allTools`, no sólo al prompt inicial. Filtrar
+  // únicamente el loadout de arranque no restringe nada: `search_knowledge`
+  // busca contra el índice completo y agent-loop.ts inyecta lo que encuentre
+  // resolviéndolo contra `allTools`, así que un agente restringido llegaba
+  // igual a cualquier tool nativa por descubrimiento dinámico. Sacarla de
+  // `allTools` la vuelve irresoluble: se puede encontrar en el índice, pero no
+  // se puede cargar ni llamar.
+  //
+  // Antes esto dependía de `isCatalogAgent`, y los agentes creados por el
+  // usuario —que son los que un host multi-tenant define— quedaban sin límite.
+  // Ahora depende de que el agente declare una lista: el coordinador, que no
+  // declara ninguna, conserva el descubrimiento abierto.
+  const declaredAllowlist = agent.tool_allowlist_json
+    ? expandToolAllowlist(
+      JSON.parse(agent.tool_allowlist_json),
+      nativeTools.map((tool) => tool.name),
     )
+    : agent.tools_json
+      ? (JSON.parse(agent.tools_json) as string[])
+      : null
+
+  if (declaredAllowlist) {
+    const allowedNames = new Set<string>(declaredAllowlist)
     filteredNativeTools = nativeTools.filter((tool) => allowedNames.has(tool.name))
     allTools = [...filteredNativeTools, ...mcpToolExecutors]
   }
@@ -494,7 +518,10 @@ export async function compileContext(opts: {
   // or — on a context-overflow retry that keeps only the LAST system message
   // (openai-compat-base.ts) — silently replaces the real prompt. The summary
   // lives in `systemPrompt` instead (see conversationSummarySection below).
-  const messages: LLMMessage[] = toAPIMessages(recentMessages)
+  // En el historial las imágenes son referencias, para no reenviarlas enteras en
+  // cada turno. Las de los últimos mensajes se vuelven a poner en línea: el
+  // modelo todavía puede necesitar mirarlas, y una referencia no se mira.
+  const messages: LLMMessage[] = await inflateRecentImages(toAPIMessages(recentMessages))
 
   // [STEP-10] STRATEGY 4: ISOLATE — Build context based on agent role
   log.info(`[context-compiler] [STEP-10] Building system prompt...`)
@@ -508,7 +535,7 @@ export async function compileContext(opts: {
   }
 
   // [STEP-10b] Inject current date/time (ENTORNO ACTUAL)
-  const usersCol = await col<import("../storage/collections").UserDoc>("users")
+  const usersCol = await col<import("../storage/collections.ts").UserDoc>("users")
   const userRow = await usersCol.get(userId)
   const userTimezone = userRow?.doc.timezone || "UTC"
   const now = new Date()
@@ -538,7 +565,7 @@ export async function compileContext(opts: {
     : Array.isArray(playbookInput)
       ? playbookInput.filter((part) => part.type === "text").map((part) => (part as any).text).join("\n")
       : String(playbookInput)
-  const playbookRules = (await selectPlaybookRules(playbookText)).filter((rule) => {
+  const playbookRules = (await selectPlaybookRules(playbookText, userId)).filter((rule) => {
     if (!rule.applicable_to || !rule.applicable_to.includes("agent:")) return true
     return isCatalogAgent ? rule.applicable_to.includes(`agent:${agent.id}`) : false
   })
@@ -585,7 +612,7 @@ export async function compileContext(opts: {
         .filter((line): line is string => !!line)
 
       if (causalLines.length > 0) {
-        systemPrompt += `\n\n# CAUSAL CONTEXT (decisiones y tool calls de este turno, previos a la compactación — priorizá la conversación actual; usalo solo para no repetir algo que ya funcionó o ya falló)\n${causalLines.join("\n")}\n`
+        systemPrompt += `\n\n# CAUSAL CONTEXT (decisiones y tool calls de este turno, previos a la compactación — prioriza la conversación actual; úsalo solo para no repetir algo que ya funcionó o ya falló)\n${causalLines.join("\n")}\n`
         log.info(`[context-compiler] [STEP-9d] ✅ Injected ${causalLines.length} causal context item(s)`)
       }
     } catch (err) {

package/packages/core/src/agent/conversation-store.ts

@@ -5,12 +5,13 @@
  * Also manages: summaries and scratchpad, both HiveDB document collections.
  */
 
-import { col, nextId, bumpRollup } from "../storage/hive"
-import { getHiveDb } from "../storage/hivedb"
-import { logger } from "../utils/logger"
-import type { LLMMessage, ContentPart } from "./llm-client"
-import { estimateTokens } from "../utils/toon"
-import type { ConversationDoc, SummaryDoc, MessageSource } from "../storage/collections"
+import { col, nextId, bumpRollup } from "../storage/hive.ts"
+import { getHiveDb } from "../storage/hivedb.ts"
+import { logger } from "../utils/logger.ts"
+import type { LLMMessage, ContentPart } from "./llm-client.ts"
+import { estimateTokens } from "../utils/toon.ts"
+import type { ConversationDoc, SummaryDoc, MessageSource } from "../storage/collections.ts"
+import { touchThread } from "./thread-store.ts"
 
 const log = logger.child("conv-store")
 
@@ -45,13 +46,26 @@ export interface StoredMessage {
 // stays clean and the wording can evolve without a migration.
 
 export const INTERNAL_SOURCES: ReadonlySet<string> =
-  new Set(["task_complete", "delegation_summary", "legacy_internal"])
+  new Set(["task_complete", "delegation_summary", "legacy_internal", "realtime_chat"])
 
 export function isInternalSource(source: string | null | undefined): boolean {
   return !!source && INTERNAL_SOURCES.has(source)
 }
 
 export function formatInternalEvent(source: string, content: string): string {
+  // La charla hablada sí salió del usuario, pero la sesión de voz ya la
+  // respondió: es contexto, no trabajo por hacer. Sin esta distinción el
+  // coordinador leía cada frase suelta de una llamada como un pedido nuevo y
+  // delegaba una tarea por cada una.
+  if (source === "realtime_chat") {
+    return `<hive:voice_context>\n` +
+      `Fragmento de una conversación hablada que la voz de Hive YA respondió en el momento. ` +
+      `Es contexto de lo que vinieron hablando, NO un pedido pendiente: no ejecutes ni delegues nada por esto. ` +
+      `El trabajo real llega siempre como un mensaje aparte y explícito.\n\n` +
+      `${content}\n` +
+      `</hive:voice_context>`
+  }
+
   return `<hive:internal_event source="${source}">\n` +
     `Evento interno del sistema — NO es un mensaje del usuario. No lo cites literalmente, no expongas IDs internos (task_id, worker_id) ni JSON crudo. Respondé al usuario de forma natural y breve.\n\n` +
     `${content}\n` +
@@ -97,6 +111,66 @@ export function getRecentMessageCount(windowMs = 5 * 60_000): number {
   return recentMessageTimestamps.length
 }
 
+/** El threadId es `${userId}/${canal}/${peer}`, así que el dueño ya está ahí. */
+async function resolveOwnerId(threadId: string): Promise<string> {
+  const { parseThreadId } = await import("./thread-id.ts")
+  return parseThreadId(threadId)?.userId ?? threadId
+}
+
+/**
+ * Cuánto ocupa una imagen en la ventana de contexto.
+ *
+ * Los proveedores cobran por área, no por bytes: la fórmula es la de los
+ * modelos de visión más comunes (~750 px² por token). Es una estimación, pero
+ * cualquier estimación es infinitamente mejor que la anterior, que era cero: la
+ * compactación creía que un hilo con diez fotos ocupaba lo que ocupa su texto,
+ * y no se disparaba hasta que el proveedor rechazaba el turno.
+ */
+export function estimateImageTokens(width?: number | null, height?: number | null): number {
+  if (!width || !height) return 1_500;   // desconocida: el promedio de una foto
+  return Math.ceil((width * height) / 750);
+}
+
+/**
+ * Cambia las imágenes en línea por referencias a un artefacto.
+ *
+ * El base64 se guardaba entero en `content_multimodal` y `toAPIMessages` lo
+ * devolvía al modelo **en cada turno siguiente**: cinco fotos en una
+ * conversación eran cinco fotos reenviadas una y otra vez. Guardar el archivo y
+ * dejar una referencia corta ese crecimiento de raíz.
+ *
+ * La imagen no se pierde: `inflateRecentImages` la vuelve a poner en línea para
+ * los últimos turnos, que es donde el modelo todavía puede necesitar mirarla.
+ */
+async function imagesToRefs(content: ContentPart[], userId: string): Promise<ContentPart[]> {
+  const { createArtifact } = await import("../artifacts/store.ts")
+  const out: ContentPart[] = []
+
+  for (const part of content) {
+    if (part.type !== "image_base64") { out.push(part); continue }
+    try {
+      const bytes = Uint8Array.from(Buffer.from((part as { base64: string }).base64, "base64"))
+      const mimeType = (part as { mimeType?: string }).mimeType || "image/jpeg"
+      // Si no se puede medir, no es una imagen. Guardarla igual crearía un
+      // artefacto de tipo "image" con basura adentro, que aparecería en la
+      // galería del usuario; es mejor dejarla como venía.
+      const { measureImage } = await import("../images/index.ts")
+      const meta = await measureImage(bytes)
+
+      const art = await createArtifact({
+        bytes, mimeType, kind: "image", userId,
+        width: meta.width, height: meta.height, expiresAt: null,
+      })
+      out.push({ type: "artifact_ref", artifact_id: art.id, mime_type: mimeType, width: meta.width, height: meta.height } as unknown as ContentPart)
+    } catch {
+      // No es una imagen medible, o no se pudo guardar: viaja como venía.
+      // Perderla sería peor que no optimizarla.
+      out.push(part)
+    }
+  }
+  return out
+}
+
 export async function addMessage(
   threadId: string,
   role: StoredMessage["role"],
@@ -107,6 +181,8 @@ export async function addMessage(
     tool_call_id?: string
     reasoning_content?: string
     source?: MessageSource
+    /** Dueño de los artefactos que se creen para este mensaje (imágenes). */
+    userId?: string
   }
 ): Promise<number> {
   // Handle multimodal content by extracting text for the content column
@@ -116,7 +192,12 @@ export async function addMessage(
       ? 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
+  // Las imágenes se guardan como archivo y en el historial queda una
+  // referencia: el base64 entero se reenviaba al modelo en cada turno.
+  const partes = Array.isArray(content)
+    ? await imagesToRefs(content, opts?.userId ?? (await resolveOwnerId(threadId)))
+    : null
+  const content_multimodal = partes ? JSON.stringify(partes) : null
   const tool_calls_json = opts?.tool_calls ? JSON.stringify(opts.tool_calls) : null
 
   const paddedSeq = await nextId(`conversations:${threadId}`)
@@ -136,7 +217,19 @@ export async function addMessage(
     reasoning_content: opts?.reasoning_content ?? null,
     source: opts?.source ?? "message",
     // Estimate tokens: content + tool_calls JSON
-    token_count: Math.max(1, estimateTokens(textContent) + estimateTokens(tool_calls_json ?? "")),
+    // Las imágenes cuentan: antes sumaban cero y la compactación creía que un
+    // hilo lleno de fotos ocupaba lo que ocupa su texto.
+    token_count: Math.max(
+      1,
+      estimateTokens(textContent) +
+      estimateTokens(tool_calls_json ?? "") +
+      (partes ?? []).reduce((n, p) => {
+        const q = p as { type: string; width?: number | null; height?: number | null }
+        return q.type === "artifact_ref" || q.type === "image_base64" || q.type === "image_url"
+          ? n + estimateImageTokens(q.width, q.height)
+          : n
+      }, 0),
+    ),
     created_at: now,
     updated_at: now,
   }, { expectedVersion: 0 })
@@ -146,6 +239,16 @@ export async function addMessage(
   bumpRollup("activityRollups", hour, { messageCount: 1 }).catch(() => {})
   recentMessageTimestamps.push(now)
 
+  // Igual de opcional: el registro de conversaciones es el catálogo que alimenta la
+  // lista de la web (título, orden, contador). Se actualiza acá y no en cada llamador
+  // para que todo camino que escriba un mensaje —canales, webchat, API, voz— lo
+  // mantenga al día sin repetir la llamada.
+  touchThread(threadId, {
+    role,
+    text: textContent,
+    internal: isInternalSource(opts?.source),
+  }).catch(() => {})
+
   return seq
 }
 
@@ -228,6 +331,61 @@ export async function getMessagesAfter(threadId: string, afterId: number): Promi
 
 // ─── Convert stored messages → LLMMessage array ───────────────────────────────
 
+/**
+ * Cuántos mensajes del final conservan sus imágenes en línea.
+ *
+ * Mismo criterio que `clearOldToolResults` (compaction.ts), que ya poda
+ * resultados viejos y deja intactos los recientes. Es el compromiso: el modelo
+ * puede volver a mirar una imagen de hace un rato —"¿qué decía la factura?"—
+ * sin que una conversación larga arrastre todas las fotos para siempre.
+ */
+export const KEEP_IMAGES_LAST_N = 6
+
+/**
+ * Vuelve a poner en línea las imágenes de los últimos mensajes.
+ *
+ * En el historial las imágenes son referencias (ver `imagesToRefs`), que no
+ * ocupan contexto pero tampoco se pueden mirar: un modelo de visión no ve una
+ * foto desde un id. Para los últimos `keepLastN` mensajes se leen del disco y
+ * se devuelven como base64; los anteriores quedan como referencia, con sus
+ * dimensiones, para que el modelo sepa que hubo una imagen y cuál.
+ */
+export async function inflateRecentImages(
+  messages: LLMMessage[],
+  keepLastN = KEEP_IMAGES_LAST_N,
+): Promise<LLMMessage[]> {
+  const desde = Math.max(0, messages.length - keepLastN)
+  const tieneRefs = messages.slice(desde).some((m) =>
+    Array.isArray(m.content) && m.content.some((p) => (p as { type?: string }).type === "artifact_ref"))
+  if (!tieneRefs) return messages
+
+  const { readArtifactBytes } = await import("../artifacts/store.ts")
+
+  return Promise.all(messages.map(async (msg, i) => {
+    if (i < desde || !Array.isArray(msg.content)) return msg
+
+    const partes = await Promise.all(msg.content.map(async (part) => {
+      const p = part as { type: string; artifact_id?: string; mime_type?: string }
+      if (p.type !== "artifact_ref" || !p.artifact_id) return part
+      if (!String(p.mime_type ?? "").startsWith("image/")) return part
+
+      try {
+        const datos = await readArtifactBytes(p.artifact_id)
+        if (!datos) return part   // caducó o se borró: queda la referencia
+        return {
+          type: "image_base64",
+          base64: Buffer.from(datos.bytes).toString("base64"),
+          mimeType: datos.mimeType,
+        } as unknown as ContentPart
+      } catch {
+        return part
+      }
+    }))
+
+    return { ...msg, content: partes }
+  }))
+}
+
 export function toAPIMessages(rows: StoredMessage[]): LLMMessage[] {
   return rows.map((r) => {
     let content: string | ContentPart[] = r.content

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

@@ -13,8 +13,8 @@
  * (id="curator:lastReflection") instead of SQL's MAX(source_reflection_id).
  */
 
-import { logger } from "../utils/logger"
-import { col, nextId, toIndexable, fromIndexable } from "../storage/hive"
+import { logger } from "../utils/logger.ts"
+import { col, nextId, toIndexable, fromIndexable } from "../storage/hive.ts"
 import type {
   ReflectionDoc,
   PlaybookDoc,
@@ -22,7 +22,7 @@ import type {
   CursorDoc,
   AgentProposalDoc,
   TraceDoc,
-} from "../storage/collections"
+} from "../storage/collections.ts"
 
 const log = logger.child("curator")
 
@@ -149,7 +149,7 @@ async function curateAgentStructure(): Promise<void> {
     })
   }
 
-  const { syncCatalogAgentsToIndex } = await import("./catalog-selector")
+  const { syncCatalogAgentsToIndex } = await import("./catalog-selector.ts")
   await syncCatalogAgentsToIndex()
 }
 
@@ -201,7 +201,13 @@ async function processReflection(
 
   // Check if a similar rule already exists (fuzzy check by first 60 chars)
   const prefix = reflection.description.substring(0, 60)
-  const existing = allPlaybook.find(e => e.doc.active && e.doc.rule.startsWith(prefix))
+  // La deduplicación también va por usuario: si dos personas producen la misma
+  // observación, son dos reglas. Buscando sólo por texto, lo aprendido de la
+  // segunda reforzaría la regla de la primera y la haría pesar más en un
+  // playbook que no es suyo.
+  const existing = allPlaybook.find(
+    e => e.doc.active && e.doc.user_id === reflection.user_id && e.doc.rule.startsWith(prefix)
+  )
 
   if (existing) {
     // Reinforce existing rule
@@ -216,6 +222,7 @@ async function processReflection(
     id,
     rule: reflection.description,
     category,
+    user_id: reflection.user_id,
     applicable_to: applicableTo,
     helpful_count: 1,
     harmful_count: 0,
@@ -224,7 +231,7 @@ async function processReflection(
     created_at: now,
     updated_at: now,
   }, { expectedVersion: 0 })
-  allPlaybook.push({ id, version: 1, doc: { id, rule: reflection.description, category, applicable_to: applicableTo, helpful_count: 1, harmful_count: 0, active: true, source_reflection_id: toIndexable(reflection.id), created_at: now, updated_at: now } })
+  allPlaybook.push({ id, version: 1, doc: { id, rule: reflection.description, category, user_id: reflection.user_id, applicable_to: applicableTo, helpful_count: 1, harmful_count: 0, active: true, source_reflection_id: toIndexable(reflection.id), created_at: now, updated_at: now } })
 }
 
 function mapInsightTypeToCategory(
@@ -248,12 +255,13 @@ async function addOrUpdateRule(
   opts: {
     rule: string
     category: string
+    user_id: string
     applicable_to: string | null
     sourceReflectionId: string | null
   }
 ): Promise<void> {
   const prefix = opts.rule.substring(0, 60)
-  const existing = allPlaybook.find(e => e.doc.rule.startsWith(prefix))
+  const existing = allPlaybook.find(e => e.doc.user_id === opts.user_id && e.doc.rule.startsWith(prefix))
 
   if (existing) {
     await playbookCol.put(existing.id, { ...existing.doc, helpful_count: existing.doc.helpful_count + 1, updated_at: Date.now() }, { expectedVersion: existing.version })
@@ -264,6 +272,7 @@ async function addOrUpdateRule(
       id,
       rule: opts.rule,
       category: opts.category as PlaybookDoc["category"],
+      user_id: opts.user_id,
       applicable_to: opts.applicable_to,
       helpful_count: 1,
       harmful_count: 0,

package/packages/core/src/agent/delegation-runtime.ts

@@ -1,4 +1,4 @@
-import { col, toIndexable, fromIndexable, updateDoc } from "../storage/hive";
+import { col, toIndexable, fromIndexable, updateDoc } from "../storage/hive.ts";
 import type {
   AgentDoc,
   McpServerDoc,
@@ -6,11 +6,11 @@ import type {
   ProviderDoc,
   SkillDoc,
   AgentModelOverride,
-} from "../storage/collections";
-import { createAllTools } from "../tools";
-import { loadConfig } from "../config/loader";
+} from "../storage/collections.ts";
+import { createAllTools } from "../tools/index.ts";
+import { loadConfig } from "../config/loader.ts";
 import type { MCPClientManager } from "../mcp/index.ts";
-import { logger } from "../utils/logger";
+import { logger } from "../utils/logger.ts";
 
 const log = logger.child("delegation-runtime");
 const MCP_IDLE_TTL_MS = 2 * 60_000;

package/packages/core/src/agent/goal-runner.ts

@@ -14,15 +14,15 @@
  * entire run (not per-turn). This prevents endless loops.
  */
 
-import { logger } from "../utils/logger";
-import { callLLM, type LLMMessage } from "./llm-client";
-import { createRun, type AcceptanceCriterion } from "./run-store";
-import { clearOldToolResults } from "./compaction";
-import { loadConfig } from "../config/loader";
+import { logger } from "../utils/logger.ts";
+import { callLLM, type LLMMessage } from "./llm-client.ts";
+import { createRun, type AcceptanceCriterion } from "./run-store.ts";
+import { clearOldToolResults } from "./compaction.ts";
+import { loadConfig } from "../config/loader.ts";
 import { getDurableQueue } from "../gateway/durable-queue.ts";
-import { recordLLMUsage } from "./tracer";
+import { recordLLMUsage } from "./tracer.ts";
 
-export type { AcceptanceCriterion } from "./run-store";
+export type { AcceptanceCriterion } from "./run-store.ts";
 
 export interface AcceptanceResult {
   id: string;
@@ -126,8 +126,8 @@ export async function runGoal(opts: GoalRunOptions): Promise<GoalRunResult> {
 /** Runs a deterministic goal_check_tool, no LLM involved. */
 async function runDeterministicCheck(checkTool: string, goal: string): Promise<{ met: boolean; reason: string } | null> {
   try {
-    const { executeToolBatch } = await import("../tool-runtime");
-    const { createAllTools } = await import("../tools/index");
+    const { executeToolBatch } = await import("../tool-runtime/index.ts");
+    const { createAllTools } = await import("../tools/index.ts");
     const allTools = createAllTools(loadConfig());
     const toolDef = allTools.find((t) => t.name === checkTool);
     if (!toolDef) {

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

@@ -15,3 +15,4 @@ export * from "./run-store.ts";
 export * from "./service.ts";
 export * from "./skill-selector.ts";
 export * from "./tool-selector.ts";
+export * from "./realtime-providers/index.ts";