zubo 0.1.19 → 0.1.21

package/src/agent/loop.ts

@@ -1,9 +1,10 @@
 import type { LlmProvider, LlmMessage, LlmContentBlock, LlmResponse } from "../llm/provider";
 import { getAllToolDefs } from "../tools/registry";
 import { executeTool } from "../tools/executor";
-import { appendMessage } from "./session";
+import { appendMessage, loadSession } from "./session";
 import { assembleContext } from "./context";
 import { compactMessages } from "./compaction";
+import { maybeCompactSession } from "./summarizer";
 import { getDb } from "../db/connection";
 import { logger } from "../util/logger";
 
@@ -38,6 +39,14 @@ function resolveOptions(memoriesOrOptions: string | AgentLoopOptions): AgentLoop
     : memoriesOrOptions;
 }
 
+/** Detect simple greetings/chat that don't need tool definitions in context. */
+function looksConversational(text: string): boolean {
+  const t = text.trim().toLowerCase();
+  if (t.split(/\s+/).length > 8) return false; // longer messages likely need tools
+  const greetings = /^(h(ello|i|ey|owdy|ola)|yo|sup|good\s*(morning|afternoon|evening|night)|what'?s\s*up|gm|thanks|thank\s*you|ok(ay)?|bye|see\s*ya|cool|nice|wow|lol|haha)\b/;
+  return greetings.test(t);
+}
+
 async function prepareLoop(
   llm: LlmProvider,
   sessionId: string,
@@ -67,23 +76,21 @@ async function prepareLoop(
     ? (memories ? `${memories}\n\nKnown context:\n${kgContext}` : `Known context:\n${kgContext}`)
     : memories;
 
-  // Assemble context
+  // Assemble context (uses static import — no dynamic import overhead)
   const ctx = options.systemPromptOverride
-    ? { system: options.systemPromptOverride, messages: [] as LlmMessage[] }
+    ? { system: options.systemPromptOverride, messages: loadSession(sessionId, 50) }
     : assembleContext(sessionId, 50, fullMemories);
 
-  if (options.systemPromptOverride) {
-    const { loadSession } = await import("./session");
-    ctx.messages = loadSession(sessionId, 50);
-  }
-
   const messages = compactMessages(ctx.messages, llm.contextWindow);
 
-  // Filter tools
+  // Filter tools — skip for simple conversational messages to reduce context
+  // for small models. Tools are still available on subsequent rounds.
   let tools = getAllToolDefs();
   if (options.allowedTools) {
     const allowed = new Set(options.allowedTools);
     tools = tools.filter((t) => allowed.has(t.name));
+  } else if (looksConversational(userMessage)) {
+    tools = [];
   }
 
   return { system: ctx.system, messages, tools };
@@ -121,21 +128,25 @@ async function executeToolBlocks(
   onToolStart?: (name: string, id: string) => void,
   onToolEnd?: (name: string, id: string) => void
 ): Promise<{ results: LlmContentBlock[]; count: number }> {
-  const results: LlmContentBlock[] = [];
-  let count = 0;
+  // Signal all tool starts immediately
   for (const block of blocks) {
-    count++;
     onToolStart?.(block.name, block.id);
+  }
+
+  // Execute all tools in parallel
+  const resultPromises = blocks.map(async (block) => {
     const result = await executeTool(block.name, block.id, block.input, allowedTools);
-    results.push({
-      type: "tool_result",
+    onToolEnd?.(block.name, block.id);
+    return {
+      type: "tool_result" as const,
       tool_use_id: result.tool_use_id,
       content: result.content,
       is_error: result.is_error,
-    });
-    onToolEnd?.(block.name, block.id);
-  }
-  return { results, count };
+    };
+  });
+
+  const results: LlmContentBlock[] = await Promise.all(resultPromises);
+  return { results, count: blocks.length };
 }
 
 function persistToolRound(
@@ -169,6 +180,23 @@ function finishLoop(sessionId: string, reply: string): void {
 
 const MAX_ROUNDS_FALLBACK = "I've completed several tool operations. Let me know if you need anything else.";
 
+// --- Post-loop summarization ---
+
+const compactionInProgress = new Set<string>();
+
+function triggerPostLoopCompaction(llm: LlmProvider, sessionId: string): void {
+  if (compactionInProgress.has(sessionId)) return;
+  compactionInProgress.add(sessionId);
+
+  maybeCompactSession(llm, sessionId)
+    .catch((err) => {
+      logger.error("Post-loop compaction failed", { sessionId, error: String(err) });
+    })
+    .finally(() => {
+      compactionInProgress.delete(sessionId);
+    });
+}
+
 // --- Public API ---
 
 export async function agentLoop(
@@ -217,6 +245,7 @@ export async function agentLoop(
         .map((b) => b.text ?? "")
         .join("\n") || "";
       finishLoop(sessionId, reply);
+      triggerPostLoopCompaction(llm, sessionId);
       return { reply, toolCalls: totalToolCalls };
     }
 
@@ -227,6 +256,7 @@ export async function agentLoop(
   }
 
   finishLoop(sessionId, MAX_ROUNDS_FALLBACK);
+  triggerPostLoopCompaction(llm, sessionId);
   return { reply: MAX_ROUNDS_FALLBACK, toolCalls: totalToolCalls };
 }
 
@@ -309,6 +339,7 @@ export async function agentLoopStream(
           .join("\n") || roundText;
         fullReply += reply;
         finishLoop(sessionId, fullReply);
+        triggerPostLoopCompaction(llm, sessionId);
         callbacks.onDone({ reply: fullReply, toolCalls: totalToolCalls });
         return;
       }
@@ -325,6 +356,7 @@ export async function agentLoopStream(
     }
 
     finishLoop(sessionId, MAX_ROUNDS_FALLBACK);
+    triggerPostLoopCompaction(llm, sessionId);
     callbacks.onDone({ reply: MAX_ROUNDS_FALLBACK, toolCalls: totalToolCalls });
   } catch (err: any) {
     callbacks.onError(err);

package/src/agent/prompts.ts

@@ -5,6 +5,8 @@ const DEFAULT_PERSONALITY = `You are Zubo, a personal AI agent. You are friendly
 
 ## How you behave
 
+**Be natural.** You are a real conversational partner. When the user greets you, greet them back warmly. When they chat casually, chat back. Not everything requires a tool call or an action — sometimes the right response is just a friendly reply.
+
 **Act first.** When the user asks you to do something, do it immediately. Don't describe what you could do — use your tools and make it happen. Don't ask for permission to do what the user just asked you to do (e.g. if they say "check my mails", just call the gmail tool — don't ask "do you approve me reading your emails?"). If you need something from the user (an API key, a preference, a clarification), ask for it directly, and once you get it, act on it immediately.
 
 **Be concise.** Answer in the fewest words that fully address the question. No filler, no preamble. Long explanations only when explicitly asked.

package/src/agent/session.ts

@@ -1,12 +1,16 @@
 import { join } from "path";
+import { randomBytes } from "crypto";
 import { paths } from "../config/paths";
-import { existsSync, appendFileSync, readFileSync, statSync, openSync, readSync, closeSync } from "fs";
+import { existsSync, appendFileSync, readFileSync, writeFileSync, statSync, openSync, readSync, closeSync, renameSync } from "fs";
+import { tmpdir } from "os";
 import type { LlmMessage } from "../llm/provider";
 
 export interface SessionMessage {
   role: "user" | "assistant";
   content: any;
   timestamp: string;
+  __summary?: true;
+  __summarizedCount?: number;
 }
 
 function sessionPath(sessionId: string): string {
@@ -90,13 +94,76 @@ export function loadSession(
   if (!existsSync(path)) return [];
 
   const recent = readTailLines(path, maxTurns);
+  if (recent.length === 0) return [];
 
-  return recent.map((line) => {
+  const messages = recent.map((line) => {
     const msg: SessionMessage = JSON.parse(line);
     return { role: msg.role, content: msg.content };
   });
+
+  // If the tail-read missed a summary at line 0, prepend it.
+  // After summarization the file starts with a summary message — we must
+  // always include it or the whole point of summarization is lost.
+  const firstReturned = recent[0];
+  if (!firstReturned.includes('"__summary":true')) {
+    // We might have tail-read past the summary. Check line 0.
+    try {
+      const fd = openSync(path, "r");
+      try {
+        const buf = Buffer.alloc(4096);
+        const bytesRead = readSync(fd, buf, 0, 4096, 0);
+        const firstLine = buf.toString("utf-8", 0, bytesRead).split("\n")[0];
+        if (firstLine && firstLine.includes('"__summary":true')) {
+          const summaryMsg: SessionMessage = JSON.parse(firstLine);
+          messages.unshift({ role: summaryMsg.role, content: summaryMsg.content });
+        }
+      } finally {
+        closeSync(fd);
+      }
+    } catch {
+      // If reading line 0 fails, proceed without it
+    }
+  }
+
+  return messages;
 }
 
 export function sessionExists(sessionId: string): boolean {
   return existsSync(sessionPath(sessionId));
 }
+
+/**
+ * Read the entire session file (not tail-limited).
+ * Used by the summarizer to make decisions about compaction.
+ */
+export function loadSessionFull(sessionId: string): SessionMessage[] {
+  const path = sessionPath(sessionId);
+  if (!existsSync(path)) return [];
+
+  const raw = readFileSync(path, "utf-8").trim();
+  if (!raw) return [];
+
+  const messages: SessionMessage[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    try {
+      messages.push(JSON.parse(line) as SessionMessage);
+    } catch {
+      // Skip corrupted lines — don't crash summarization
+    }
+  }
+  return messages;
+}
+
+/**
+ * Atomically rewrite a session file with new messages.
+ * Writes to a temp file first, then renames (atomic on POSIX).
+ */
+export function rewriteSession(sessionId: string, messages: SessionMessage[]): void {
+  const path = sessionPath(sessionId);
+  const tmpPath = join(tmpdir(), `zubo-session-${sessionId}-${Date.now()}-${randomBytes(4).toString("hex")}.tmp`);
+
+  const data = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+  writeFileSync(tmpPath, data);
+  renameSync(tmpPath, path);
+}

package/src/agent/summarizer.ts

@@ -0,0 +1,223 @@
+import type { LlmProvider, LlmMessage, LlmContentBlock } from "../llm/provider";
+import type { SessionMessage } from "./session";
+import { loadSessionFull, rewriteSession } from "./session";
+import { estimateTokens } from "../util/tokens";
+import { logger } from "../util/logger";
+
+const MSG_OVERHEAD = 4;
+const MIN_MESSAGES_FOR_SUMMARY = 16;
+const KEEP_RECENT = 10;
+const THRESHOLD_RATIO = 0.6;
+
+const SUMMARY_MARKER = "Previous conversation summary:";
+
+// --- Token estimation ---
+
+function messageTokens(m: LlmMessage | SessionMessage): number {
+  const content = "content" in m ? m.content : "";
+  const text = typeof content === "string" ? content : JSON.stringify(content);
+  return estimateTokens(text) + MSG_OVERHEAD;
+}
+
+function totalTokens(messages: SessionMessage[]): number {
+  let sum = 0;
+  for (const m of messages) sum += messageTokens(m);
+  return sum;
+}
+
+// --- Public helpers ---
+
+export function needsSummarization(
+  messages: SessionMessage[],
+  contextWindow: number
+): boolean {
+  if (messages.length < MIN_MESSAGES_FOR_SUMMARY) return false;
+  const tokens = totalTokens(messages);
+  return tokens > contextWindow * THRESHOLD_RATIO;
+}
+
+export function partitionMessages(
+  messages: SessionMessage[]
+): { toSummarize: SessionMessage[]; toKeep: SessionMessage[] } {
+  if (messages.length <= KEEP_RECENT) {
+    return { toSummarize: [], toKeep: messages };
+  }
+  const splitAt = messages.length - KEEP_RECENT;
+  return {
+    toSummarize: messages.slice(0, splitAt),
+    toKeep: messages.slice(splitAt),
+  };
+}
+
+/**
+ * Convert messages to text-only format for the summarization prompt.
+ * Strips tool_use/tool_result blocks to brief placeholders.
+ */
+export function toTextOnlyMessages(
+  messages: SessionMessage[]
+): { role: string; text: string }[] {
+  const result: { role: string; text: string }[] = [];
+
+  for (const msg of messages) {
+    const content = msg.content;
+
+    if (typeof content === "string") {
+      if (content.trim()) result.push({ role: msg.role, text: content });
+      continue;
+    }
+
+    if (!Array.isArray(content)) continue;
+
+    const parts: string[] = [];
+    for (const block of content as LlmContentBlock[]) {
+      switch (block.type) {
+        case "text":
+          if (block.text?.trim()) parts.push(block.text);
+          break;
+        case "tool_use":
+          parts.push(`[Used tool: ${block.name ?? "unknown"}]`);
+          break;
+        case "tool_result": {
+          const raw = typeof block.content === "string" ? block.content : "";
+          const truncated =
+            raw.length > 200 ? raw.slice(0, 200) + "…" : raw;
+          if (block.is_error) {
+            parts.push(`[Tool error: ${truncated}]`);
+          } else if (truncated) {
+            parts.push(`[Tool result: ${truncated}]`);
+          }
+          break;
+        }
+      }
+    }
+
+    if (parts.length > 0) {
+      result.push({ role: msg.role, text: parts.join("\n") });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Determine summary token budget based on context window size.
+ */
+function summaryBudget(contextWindow: number): number {
+  if (contextWindow <= 16_000) return 400;
+  if (contextWindow <= 64_000) return 800;
+  return 1200;
+}
+
+/**
+ * Call the LLM to generate a summary of the conversation.
+ */
+export async function generateSummary(
+  llm: LlmProvider,
+  messages: SessionMessage[]
+): Promise<string | null> {
+  const textMessages = toTextOnlyMessages(messages);
+  if (textMessages.length === 0) return null;
+
+  const conversationText = textMessages
+    .map((m) => `${m.role}: ${m.text}`)
+    .join("\n\n");
+
+  const budget = summaryBudget(llm.contextWindow);
+
+  try {
+    const response = await llm.chat({
+      system:
+        "You are a conversation summarizer. Produce a concise summary of the conversation below. " +
+        "Preserve key facts, decisions, user preferences, and any important context the assistant would need " +
+        "to continue the conversation naturally. Do NOT include greetings or filler. Be factual and dense.",
+      messages: [
+        {
+          role: "user",
+          content: `Summarize this conversation in under ${budget} tokens:\n\n${conversationText}`,
+        },
+      ],
+      maxTokens: budget,
+    });
+
+    const summary = response.content
+      .filter((b) => b.type === "text")
+      .map((b) => b.text ?? "")
+      .join("\n")
+      .trim();
+
+    return summary || null;
+  } catch (err: any) {
+    logger.error("Summary generation failed", { error: err.message });
+    return null;
+  }
+}
+
+/**
+ * Orchestrator: check if session needs summarization, generate summary, rewrite session.
+ * Returns true if summarization was performed.
+ */
+export async function maybeCompactSession(
+  llm: LlmProvider,
+  sessionId: string
+): Promise<boolean> {
+  const messages = loadSessionFull(sessionId);
+  if (messages.length === 0) return false;
+
+  if (!needsSummarization(messages, llm.contextWindow)) {
+    return false;
+  }
+
+  logger.info("Session needs summarization", {
+    sessionId,
+    messageCount: messages.length,
+    estimatedTokens: totalTokens(messages),
+    contextWindow: llm.contextWindow,
+  });
+
+  const { toSummarize, toKeep } = partitionMessages(messages);
+  if (toSummarize.length === 0) return false;
+
+  const summary = await generateSummary(llm, toSummarize);
+  if (!summary) {
+    logger.warn("Summarization produced no output, skipping rewrite", {
+      sessionId,
+    });
+    return false;
+  }
+
+  const summaryMessage: SessionMessage = {
+    role: "user",
+    content: [{ type: "text", text: `${SUMMARY_MARKER}\n${summary}` }],
+    timestamp: new Date().toISOString(),
+    __summary: true,
+    __summarizedCount: toSummarize.length,
+  };
+
+  // Ensure no consecutive user messages (breaks Claude API).
+  // If first kept message is also user, insert a minimal assistant bridge.
+  let kept = toKeep;
+  if (kept.length > 0 && kept[0].role === "user") {
+    const bridge: SessionMessage = {
+      role: "assistant",
+      content: [{ type: "text", text: "(Continuing from summary.)" }],
+      timestamp: new Date().toISOString(),
+    };
+    kept = [bridge, ...kept];
+  }
+
+  // Re-read session to capture any messages appended during summarization
+  const freshMessages = loadSessionFull(sessionId);
+  const newMessagesSince = freshMessages.slice(messages.length);
+
+  const newMessages = [summaryMessage, ...kept, ...newMessagesSince];
+  rewriteSession(sessionId, newMessages);
+
+  logger.info("Session summarized successfully", {
+    sessionId,
+    summarizedMessages: toSummarize.length,
+    keptMessages: toKeep.length,
+    summaryLength: summary.length,
+  });
+
+  return true;
+}