@johpaz/hive-agents 0.0.37 → 0.0.38

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

@@ -194,13 +194,9 @@ export async function* runAgent(
       tool_calls: response.tool_calls,
       reasoning_content: response.reasoning_content,
     })
-    if (!opts.isolated) {
-      addMessage(opts.threadId, "assistant", response.content || "", {
-        channel: opts.channel,
-        tool_calls: response.tool_calls,
-        reasoning_content: response.reasoning_content,
-      })
-    }
+    // Note: assistant messages with tool_calls are NOT persisted to DB.
+    // Only the final text response to the user is saved.
+    // Tool-call round-tripping happens in-memory via the 'messages' array above.
 
     for (const tc of response.tool_calls) {
       const toolName = tc.function.name
@@ -284,18 +280,12 @@ export async function* runAgent(
         await opts.onStep({ type: "tool_result", message: toolResultLLM })
       }
 
-      // Add tool result to messages for next model call AND persist (TOON encoded)
+      // Add tool result to messages for next model call (in-memory only, NOT persisted to DB)
       messages.push({
         role: "tool",
         content: toolResultLLM,
         tool_call_id: tc.id,
       })
-      if (!opts.isolated) {
-        addMessage(opts.threadId, "tool", toolResultLLM, {
-          channel: opts.channel,
-          tool_call_id: tc.id,
-        })
-      }
 
       // Dynamic tool injection: when search_knowledge finds tools (native or MCP), add them to ctx.tools
       if (toolName === "search_knowledge") {

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

@@ -40,7 +40,7 @@ import { getUserDate, getUserTime } from "../utils/date"
 const log = logger.child("context-compiler")
 
 // Configuration constants
-const KEEP_LAST_N_MESSAGES = 15      // Always keep last N messages (Strategy: SELECT) — increased because tool calls/results are now persisted
+const KEEP_LAST_N_MESSAGES = 30      // Always keep last N messages (Strategy: SELECT) — only user+assistant text, no tool results
 const DEFAULT_CONTEXT_WINDOW = 250000 // Default context window when model is unknown
 const COMPACT_RATIO = 0.80           // Compact when estimated input exceeds 70% of context window
 const MAX_SYSTEM_PROMPT_CHARS_CAP = 128000 // Hard cap for pathological prompts; normal budget is model-aware

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

@@ -97,7 +97,7 @@ export function getRecentMessages(threadId: string, n: number): StoredMessage[]
   const db = getDb()
   const rows = db.query(`
     SELECT * FROM conversations
-    WHERE thread_id = ?
+    WHERE thread_id = ? AND role != 'tool'
     ORDER BY id DESC
     LIMIT ?
   `).all(threadId, n) as StoredMessage[]
@@ -170,10 +170,9 @@ export function toAPIMessages(rows: StoredMessage[]): LLMMessage[] {
       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
+    // Note: tool_calls and tool_call_id are NOT reconstructed from DB.
+    // Tool results are kept in-memory during iteration but not persisted,
+    // so historical messages only contain text conversation.
     if (r.reasoning_content) msg.reasoning_content = r.reasoning_content
     return msg
   })

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

@@ -7,7 +7,6 @@
 
 import type { Config } from "../../config/loader.ts"
 import { logger } from "../../utils/logger.ts"
-import { getDb } from "../../storage/sqlite.ts"
 import { getAgentLoop } from "../agent-loop"
 import { resolveUserId, resolveAgentId } from "../../storage/onboarding"
 import type { ContentPart } from "../../multimodal/types"
@@ -34,6 +33,7 @@ export interface ModelOptions {
   onStep?: (step: StepEvent) => Promise<void>
   threadId?: string
   userId?: string
+  agentId?: string
   channel?: string
   rawUserMessage?: string
   signal?: AbortSignal
@@ -62,9 +62,8 @@ export class AgentRunner {
   }
 
   async generate(options: ModelOptions): Promise<ModelResponse> {
-    const db = getDb()
-    // Resolve agentId from database (coordinator or first enabled)
-    const agentId = resolveAgentId(null) || "main"
+    // Resolve agentId from explicit option or database (coordinator/first enabled)
+    const agentId = options.agentId || resolveAgentId(null) || "main"
 
     // Resolve userId from database
     const userId = options.userId || resolveUserId({})

package/packages/core/src/agent/tool-selector.ts

@@ -29,7 +29,6 @@
  * 
  * 6. Tool categorization: Tools are categorized by semantic domain:
  *    - scheduling (cron tools)
- *    - projects (project/task management)
  *    - filesystem (file operations)
  *    - web (search/fetch)
  *    - browser (browser automation)
@@ -527,10 +526,10 @@ function enrichToolDescription(tool: ToolDescriptor): string {
  *
  * Canonical format: `{safeServer}__{safeTool}` (double underscore as separator)
  */
-export function mcpToolFullName(_serverName: string, toolName: string): string {
+export function mcpToolFullName(serverName: string, toolName: string): string {
     const safe = (s: string) => s.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_\-]/g, '_')
-    const sanitized = safe(toolName)
-    const trimmed = sanitized.length > 64 ? sanitized.substring(0, 64) : sanitized
+    const full = `${safe(serverName)}__${safe(toolName)}`
+    const trimmed = full.length > 64 ? full.substring(0, 64) : full
     return /^[a-zA-Z_]/.test(trimmed) ? trimmed : `_${trimmed}`.substring(0, 64)
 }
 

package/packages/core/src/gateway/resolver.ts

@@ -2,6 +2,7 @@ import { getDb } from "../storage/sqlite"
 
 export interface ResolveContextResult {
   userId: string
+  threadId: string
   agentId: string
   isNewUser: boolean
 }
@@ -51,8 +52,11 @@ export function resolveContext(options: ResolveContextOptions): ResolveContextRe
     .get()
 
   const agentId = coordinatorAgent?.id || "bee"
+  // One canonical conversation thread is shared across channels. Transport
+  // session IDs route replies; conversations.thread_id owns agent context.
+  const threadId = userId
 
-  return { userId, agentId, isNewUser }
+  return { userId, threadId, agentId, isNewUser }
 }
 
 export function getDefaultAgentId(): string {

package/packages/core/src/gateway/routes/chat.ts

@@ -4,7 +4,7 @@
  * POST /api/chat
  * {
  *   "message": "Mensaje para el coordinador",
- *   "thread_id": "ID de sesión (opcional, se genera si no existe)",
+ *   "thread_id": "conversations.thread_id (opcional, usa el thread canónico del usuario si no existe)",
  *   "channel": "canal (opcional, default: webchat)"
  * }
  */
@@ -12,12 +12,11 @@
 import { getDb } from "../../storage/sqlite";
 import { resolveUserId, resolveAgentId } from "../../storage/onboarding";
 import { laneQueue } from "../lane-queue";
-import { getRecentMessages } from "../../agent/conversation-store";
 import { AgentRunner } from "../../agent/providers";
 import { logger } from "../../utils/logger";
-import { getUserDate, getUserTime } from "../../utils/date";
 
 const log = logger.child("api:chat");
+export const DEFAULT_CHAT_HISTORY_LIMIT = 40;
 
 export interface ChatRequest {
   message: string;
@@ -34,6 +33,11 @@ export interface ChatResponse {
   error?: string;
 }
 
+export function resolveChatThreadId(finalUserId: string, requestedThreadId?: string): string {
+  const trimmedThreadId = requestedThreadId?.trim();
+  return trimmedThreadId || finalUserId || "default";
+}
+
 export async function handleChat(
   req: Request,
   addCorsHeaders: (res: Response, req: Request) => Response
@@ -60,8 +64,8 @@ export async function handleChat(
     // Resolve agent ID (coordinator by default)
     const finalAgentId = agentId || resolveAgentId(null) || "main";
 
-    // Generate or use provided thread_id
-    const threadId = thread_id || `${finalUserId}-${Date.now()}`;
+    // conversations.thread_id is the context key; never generate a per-request thread.
+    const threadId = resolveChatThreadId(finalUserId, thread_id);
 
     log.info(`[chat] Processing message from user=${finalUserId} agent=${finalAgentId} thread=${threadId}`);
 
@@ -86,15 +90,10 @@ export async function handleChat(
     // Format message with timestamp
     const messageContent = `[Timestamp: ${exactTime} (${userTimezone})]\n${message}`;
 
-    // Get recent conversation history
-    const history = getRecentMessages(threadId, 15);
-    const messages = [
-      ...history.map((row) => ({
-        role: row.role as "user" | "assistant" | "system",
-        content: row.content,
-      })),
-      { role: "user" as const, content: messageContent }
-    ];
+    // AgentLoop persists this user message, then compileContext loads the last
+    // 15 messages from conversations by threadId. Prepending history here is
+    // ineffective because AgentLoop.stream only consumes the latest user input.
+    const messages = [{ role: "user" as const, content: messageContent }];
 
     // Get provider config from DB
     const agent = db.query<any, [string]>(
@@ -124,6 +123,7 @@ export async function handleChat(
           maxSteps: 15,
           threadId,
           userId: finalUserId,
+          agentId: finalAgentId,
           channel,
           onStep: async (step) => {
             if (step.type === "text" && step.message) {
@@ -200,12 +200,12 @@ export async function handleChat(
 export async function handleGetChatHistory(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
   const url = new URL(req.url)
   const threadId = url.searchParams.get("sessionId") || url.searchParams.get("threadId") || "default"
-  const limit = parseInt(url.searchParams.get("limit") || "15")
+  const limit = parseInt(url.searchParams.get("limit") || String(DEFAULT_CHAT_HISTORY_LIMIT))
 
   const messages = getDb().query(`
     SELECT id, thread_id, channel, role, content, tool_calls_json, tool_call_id, reasoning_content, token_count, created_at, updated_at FROM conversations
     WHERE thread_id = ? AND role IN ('user', 'assistant')
-    ORDER BY created_at DESC
+    ORDER BY id DESC
     LIMIT ?
   `).all(threadId, limit) as Record<string, unknown>[]
 

package/packages/core/src/gateway/server.ts

@@ -373,7 +373,7 @@ export async function startGateway(config: Config): Promise<void> {
 
     log.info(` Content: ${messageContent.substring(0, 150)}${messageContent.length > 150 ? "..." : ""}`);
 
-    const { userId } = resolveContext({
+    const { userId, threadId: conversationThreadId } = resolveContext({
       channel: message.channel,
       channelUserId: message.sessionId,
     });
@@ -385,8 +385,8 @@ export async function startGateway(config: Config): Promise<void> {
       channelManager.startTyping(message.channel, message.sessionId),
     ]);
 
-    // unifiedSessionId = userId del onboarding → historial y thread LangGraph unificados
-    const unifiedSessionId = userId;
+    // conversationThreadId = conversations.thread_id canónico compartido por todos los canales
+    const unifiedSessionId = conversationThreadId;
     // routingSessionId = peerId del canal → para enviar respuestas de vuelta al canal correcto
     const routingSessionId = message.sessionId;
 
@@ -1940,7 +1940,7 @@ export async function startGateway(config: Config): Promise<void> {
               return;
             }
             try {
-              const { userId } = resolveContext({ channel: "webchat", channelUserId: sessionId });
+              const { userId, threadId: conversationThreadId } = resolveContext({ channel: "webchat", channelUserId: sessionId });
               const messages = [{ role: "user" as const, content: interactionMsg }];
               let streamedContent = "";
               const messageId = crypto.randomUUID();
@@ -1949,9 +1949,9 @@ export async function startGateway(config: Config): Promise<void> {
                 provider: dbProvider as any,
                 messages,
                 maxTokens: 4096,
-                tools: prepareTools(agent, sessionId),
+                tools: prepareTools(agent, conversationThreadId),
                 maxSteps: 15,
-                threadId: sessionId,
+                threadId: conversationThreadId,
                 userId,
                 onToken: async (token: string) => {
                   if (signal.aborted) return;
@@ -2015,7 +2015,7 @@ export async function startGateway(config: Config): Promise<void> {
                 return;
               }
               try {
-                const { userId } = resolveContext({ channel: "webchat", channelUserId: sessionId });
+                const { userId, threadId: conversationThreadId } = resolveContext({ channel: "webchat", channelUserId: sessionId });
                 const messages = [{ role: "user" as const, content: interactionMsg }];
                 let streamedContent = "";
                 const messageId = crypto.randomUUID();
@@ -2024,9 +2024,9 @@ export async function startGateway(config: Config): Promise<void> {
                   provider: dbProvider as any,
                   messages,
                   maxTokens: 4096,
-                  tools: prepareTools(agent, sessionId),
+                  tools: prepareTools(agent, conversationThreadId),
                   maxSteps: 15,
-                  threadId: sessionId,
+                  threadId: conversationThreadId,
                   userId,
                   onToken: async (token: string) => {
                     if (signal.aborted) return;
@@ -2157,14 +2157,14 @@ export async function startGateway(config: Config): Promise<void> {
               }
 
               try {
-                const unifiedSessionId = msg.sessionId;
-                const messages = [{ role: "user" as const, content: messageContent }];
-                log.info(`Generating response for session ${unifiedSessionId}...`);
-
-                const { userId } = resolveContext({
+                const { userId, threadId: conversationThreadId } = resolveContext({
                   channel: "webchat",
                   channelUserId: msg.sessionId,
                 });
+                const unifiedSessionId = conversationThreadId;
+                const routingSessionId = msg.sessionId;
+                const messages = [{ role: "user" as const, content: messageContent }];
+                log.info(`Generating response for session ${unifiedSessionId}...`);
 
                 // Streaming: send tokens as they arrive
                 let streamedContent = "";
@@ -2185,7 +2185,7 @@ export async function startGateway(config: Config): Promise<void> {
                     ws.send(JSON.stringify({
                       type: "message",
                       id: messageId,
-                      sessionId: unifiedSessionId,
+                      sessionId: routingSessionId,
                       content: token,
                       isChunk: true,
                       isStep: false,
@@ -2200,7 +2200,7 @@ export async function startGateway(config: Config): Promise<void> {
                       if (trimmedMessage) {
                         ws.send(JSON.stringify({
                           type: "progress",
-                          sessionId: unifiedSessionId,
+                          sessionId: routingSessionId,
                           content: trimmedMessage,
                         } as OutboundMessage));
                       }
@@ -2212,7 +2212,7 @@ export async function startGateway(config: Config): Promise<void> {
                       const narration = getNarration(step.toolName);
                       ws.send(JSON.stringify({
                         type: "progress",
-                        sessionId: unifiedSessionId,
+                        sessionId: routingSessionId,
                         content: narration,
                       } as OutboundMessage));
                       return;
@@ -2227,7 +2227,7 @@ export async function startGateway(config: Config): Promise<void> {
                           if (userMessage) {
                             ws.send(JSON.stringify({
                               type: "progress",
-                              sessionId: unifiedSessionId,
+                              sessionId: routingSessionId,
                               content: userMessage,
                             } as OutboundMessage));
                           }
@@ -2248,7 +2248,7 @@ export async function startGateway(config: Config): Promise<void> {
                 let ttsProviderUsed: string | null = null;
                 let ttsMimeType: string | null = null;
 
-                ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: unifiedSessionId } as OutboundMessage));
+                ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: routingSessionId } as OutboundMessage));
 
                 // Don't send text message if already streamed (content came via onToken)
                 const alreadyStreamed = streamedContent.length > 0;
@@ -2258,7 +2258,7 @@ export async function startGateway(config: Config): Promise<void> {
                     if (!voiceCfg.ttsProvider) {
                       ws.send(JSON.stringify({
                         type: "message",
-                        sessionId: unifiedSessionId,
+                        sessionId: routingSessionId,
                         content: `${content}\n\n🔊 Para recibir respuestas en audio, configura el proveedor TTS en Configuración > Canales > WebChat (ej: elevenlabs)`,
                         isStep: false,
                       } as OutboundMessage));
@@ -2273,7 +2273,7 @@ export async function startGateway(config: Config): Promise<void> {
                         log.info(`Audio generated: ${base64Audio.length} bytes, mimeType: ${audioOutput.mimeType}`);
                         ws.send(JSON.stringify({
                           type: "message",
-                          sessionId: unifiedSessionId,
+                          sessionId: routingSessionId,
                           content,
                           audio: base64Audio,
                           mimeType: audioOutput.mimeType,
@@ -2281,11 +2281,11 @@ export async function startGateway(config: Config): Promise<void> {
                         } as OutboundMessage));
                       } catch (ttsError) {
                         log.error(`TTS failed: ${(ttsError as Error).message}), sending text instead`);
-                        ws.send(JSON.stringify({ type: "message", sessionId: unifiedSessionId, content, isStep: false } as OutboundMessage));
+                        ws.send(JSON.stringify({ type: "message", sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
                       }
                     }
                   } else {
-                    ws.send(JSON.stringify({ type: "message", sessionId: unifiedSessionId, content, isStep: false } as OutboundMessage));
+                    ws.send(JSON.stringify({ type: "message", sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
                   }
                 } else if (alreadyStreamed && shouldSpeak && voiceCfg.ttsProvider) {
                   try {
@@ -2295,7 +2295,7 @@ export async function startGateway(config: Config): Promise<void> {
                     log.info(`Audio generated after streaming: ${base64Audio.length} bytes`);
                     ws.send(JSON.stringify({
                       type: "message",
-                      sessionId: unifiedSessionId,
+                      sessionId: routingSessionId,
                       content,
                       audio: base64Audio,
                       mimeType: audioOutput.mimeType,
@@ -2349,7 +2349,12 @@ export async function startGateway(config: Config): Promise<void> {
             }
 
             try {
-              const unifiedSessionId = msg.sessionId;
+              const { userId, threadId: conversationThreadId } = resolveContext({
+                channel: "webchat",
+                channelUserId: msg.sessionId,
+              });
+              const unifiedSessionId = conversationThreadId;
+              const routingSessionId = msg.sessionId;
 
               // Multimodal: process image/document if present
               let finalMessageContent = msg.content;
@@ -2418,11 +2423,6 @@ export async function startGateway(config: Config): Promise<void> {
 
               log.info(`Generating response for session ${unifiedSessionId} (multimodal: ${!!(msg.image || msg.document)})...`);
 
-              const { userId } = resolveContext({
-                channel: "webchat",
-                channelUserId: msg.sessionId,
-              });
-
               // Streaming: send tokens as they arrive
               let streamedContent = "";
               let messageId = crypto.randomUUID();
@@ -2443,7 +2443,7 @@ export async function startGateway(config: Config): Promise<void> {
                   ws.send(JSON.stringify({
                     type: "message",
                     id: messageId,
-                    sessionId: unifiedSessionId,
+                    sessionId: routingSessionId,
                     content: token,
                     isChunk: true,
                     isStep: false,
@@ -2458,7 +2458,7 @@ export async function startGateway(config: Config): Promise<void> {
                     if (trimmedMessage) {
                       ws.send(JSON.stringify({
                         type: "progress",
-                        sessionId: unifiedSessionId,
+                        sessionId: routingSessionId,
                         content: trimmedMessage,
                       } as OutboundMessage));
                     }
@@ -2470,7 +2470,7 @@ export async function startGateway(config: Config): Promise<void> {
                     const narration = getNarration(step.toolName);
                     ws.send(JSON.stringify({
                       type: "progress",
-                      sessionId: unifiedSessionId,
+                      sessionId: routingSessionId,
                       content: narration,
                     } as OutboundMessage));
                     return;
@@ -2485,7 +2485,7 @@ export async function startGateway(config: Config): Promise<void> {
                         if (userMessage) {
                           ws.send(JSON.stringify({
                             type: "progress",
-                            sessionId: unifiedSessionId,
+                            sessionId: routingSessionId,
                             content: userMessage,
                           } as OutboundMessage));
                         }
@@ -2506,7 +2506,7 @@ export async function startGateway(config: Config): Promise<void> {
               let ttsProviderUsed: string | null = null;
               let ttsMimeType: string | null = null;
 
-              ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: unifiedSessionId } as OutboundMessage));
+              ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: routingSessionId } as OutboundMessage));
 
               // Don't send text message if already streamed (content came via onToken)
               const alreadyStreamed = streamedContent.length > 0;
@@ -2516,7 +2516,7 @@ export async function startGateway(config: Config): Promise<void> {
                   if (!voiceConfig.ttsProvider) {
                     ws.send(JSON.stringify({
                       type: "message",
-                      sessionId: unifiedSessionId,
+                      sessionId: routingSessionId,
                       content: `${content}\n\n🔊 Para recibir respuestas en audio, configura el proveedor TTS en Configuración > Canales > WebChat (ej: elevenlabs)`,
                       isStep: false
                     } as OutboundMessage));
@@ -2530,7 +2530,7 @@ export async function startGateway(config: Config): Promise<void> {
                       const base64Audio = (audioOutput.data as Buffer).toString("base64");
                       ws.send(JSON.stringify({
                         type: "message",
-                        sessionId: unifiedSessionId,
+                        sessionId: routingSessionId,
                         content,
                         audio: base64Audio,
                         mimeType: audioOutput.mimeType,
@@ -2538,11 +2538,11 @@ export async function startGateway(config: Config): Promise<void> {
                       } as OutboundMessage));
                     } catch (ttsError) {
                       log.error(`TTS failed: ${(ttsError as Error).message}), sending text instead`);
-                      ws.send(JSON.stringify({ type: "message", sessionId: unifiedSessionId, content, isStep: false } as OutboundMessage));
+                      ws.send(JSON.stringify({ type: "message", sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
                     }
                   }
                 } else {
-                  ws.send(JSON.stringify({ type: "message", sessionId: unifiedSessionId, content, isStep: false } as OutboundMessage));
+                  ws.send(JSON.stringify({ type: "message", sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
                 }
               } else if (alreadyStreamed && shouldSpeak && voiceConfig.ttsProvider) {
                 try {
@@ -2552,7 +2552,7 @@ export async function startGateway(config: Config): Promise<void> {
                   log.info(`Audio generated after streaming: ${base64Audio.length} bytes`);
                   ws.send(JSON.stringify({
                     type: "message",
-                    sessionId: unifiedSessionId,
+                    sessionId: routingSessionId,
                     content,
                     audio: base64Audio,
                     mimeType: audioOutput.mimeType,
@@ -2563,15 +2563,14 @@ export async function startGateway(config: Config): Promise<void> {
                 }
               }
             } catch (error) {
-              const unifiedSessionId = msg.sessionId;
               // Detener typing aunque falle — nunca dejar el spinner infinito
-              ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: unifiedSessionId } as OutboundMessage));
+              ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: msg.sessionId } as OutboundMessage));
               ws.send(JSON.stringify({
                 type: "error",
-                sessionId: unifiedSessionId,
+                sessionId: msg.sessionId,
                 error: (error as Error).message,
               } as OutboundMessage));
-              log.error(`Error for session ${unifiedSessionId}: ${(error as Error).message}`);
+              log.error(`Error for session ${msg.sessionId}: ${(error as Error).message}`);
             }
           });
 
@@ -2741,4 +2740,4 @@ export async function startGateway(config: Config): Promise<void> {
       log.error(`Failed to reload configuration: ${(error as Error).message}`);
     }
   });
-}
+}