wave-agent-sdk 0.18.7 → 0.19.1

package/src/services/session.ts

@@ -28,8 +28,6 @@ import { getMessageContent } from "../utils/messageOperations.js";
 
 export interface SessionData {
   id: string;
-  rootSessionId?: string;
-  parentSessionId?: string;
   messages: Message[];
   metadata: {
     workdir: string;
@@ -40,8 +38,6 @@ export interface SessionData {
 
 export interface SessionMetadata {
   id: string;
-  rootSessionId?: string;
-  parentSessionId?: string;
   sessionType: "main" | "subagent";
   subagentType?: string;
   workdir: string;
@@ -51,17 +47,6 @@ export interface SessionMetadata {
   firstMessage?: string;
 }
 
-export interface SessionIndex {
-  sessions: Record<
-    string,
-    Omit<SessionMetadata, "id" | "lastActiveAt" | "createdAt"> & {
-      lastActiveAt: string;
-      createdAt: string;
-    }
-  >;
-  lastUpdated: string;
-}
-
 /**
  * Generate a new session ID using Node.js native crypto.randomUUID()
  * @returns UUID string for session identification
@@ -82,40 +67,6 @@ export function generateSubagentFilename(sessionId: string): string {
 // Constants
 export const SESSION_DIR = join(homedir(), ".wave", "projects");
 const MAX_SESSION_AGE_DAYS = 14;
-const SESSION_INDEX_FILENAME = "sessions-index.json";
-
-/**
- * Update the session index for a project directory
- */
-async function updateSessionIndex(
-  projectDirPath: string,
-  metadata: SessionMetadata,
-): Promise<void> {
-  const indexPath = join(projectDirPath, SESSION_INDEX_FILENAME);
-  let index: SessionIndex = {
-    sessions: {},
-    lastUpdated: new Date().toISOString(),
-  };
-
-  try {
-    const content = await fs.readFile(indexPath, "utf8");
-    index = JSON.parse(content);
-  } catch {
-    // Index doesn't exist or is invalid, start fresh
-  }
-
-  const { id, ...rest } = metadata;
-  index.sessions[id] = {
-    ...rest,
-    createdAt: metadata.createdAt.toISOString(),
-    lastActiveAt: metadata.lastActiveAt.toISOString(),
-    firstMessage: metadata.firstMessage || index.sessions[id]?.firstMessage,
-    parentSessionId: metadata.parentSessionId,
-  };
-  index.lastUpdated = new Date().toISOString();
-
-  await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
-}
 
 /**
  * Ensure session directory exists
@@ -201,8 +152,6 @@ export async function appendMessages(
   newMessages: Message[],
   workdir: string,
   sessionType: "main" | "subagent" = "main",
-  rootSessionId?: string,
-  parentSessionId?: string,
 ): Promise<void> {
   // Do not save session files in test environment
   if (process.env.NODE_ENV === "test") {
@@ -235,50 +184,6 @@ export async function appendMessages(
   await jsonlHandler.append(filePath, newMessages, {
     atomic: false,
   });
-
-  // Update index
-  const encoder = new PathEncoder();
-  const projectDir = await encoder.getProjectDirectory(workdir, SESSION_DIR);
-  const lastMessage = newMessages[newMessages.length - 1];
-
-  // Get first message content and createdAt from existing index
-  let firstMessage: string | undefined;
-  let createdAt: Date | undefined;
-  try {
-    const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
-    const content = await fs.readFile(indexPath, "utf8");
-    const index = JSON.parse(content) as SessionIndex;
-    if (!index.sessions[sessionId]?.firstMessage) {
-      firstMessage =
-        (await getFirstMessageContent(sessionId, workdir)) || undefined;
-    }
-    if (index.sessions[sessionId]?.createdAt) {
-      createdAt = new Date(index.sessions[sessionId].createdAt);
-    }
-  } catch {
-    // If index doesn't exist, this might be the first message
-    firstMessage =
-      (await getFirstMessageContent(sessionId, workdir)) || undefined;
-  }
-
-  // Derive createdAt from session ID if not in index
-  if (!createdAt) {
-    createdAt = new Date();
-  }
-
-  await updateSessionIndex(projectDir.encodedPath, {
-    id: sessionId,
-    rootSessionId,
-    parentSessionId,
-    sessionType,
-    workdir,
-    createdAt,
-    lastActiveAt: new Date(lastMessage.timestamp),
-    latestTotalTokens: lastMessage.usage
-      ? extractLatestTotalTokens([lastMessage])
-      : 0,
-    firstMessage,
-  });
 }
 
 /**
@@ -314,34 +219,25 @@ export async function loadSessionFromJsonl(
       throw error;
     }
 
-    const messages = await jsonlHandler.read(filePath);
+    const allMessages = await jsonlHandler.read(filePath);
+
+    // Find the last compact boundary — only return messages from there forward
+    let lastCompactIndex = -1;
+    for (let i = allMessages.length - 1; i >= 0; i--) {
+      if (allMessages[i].blocks?.some((b) => b.type === "compact")) {
+        lastCompactIndex = i;
+        break;
+      }
+    }
+    const messages =
+      lastCompactIndex >= 0 ? allMessages.slice(lastCompactIndex) : allMessages;
 
     // Extract metadata from messages
     const lastMessage =
       messages.length > 0 ? messages[messages.length - 1] : null;
 
-    // Try to get rootSessionId and parentSessionId from index
-    let rootSessionId: string | undefined;
-    let parentSessionId: string | undefined;
-    try {
-      const encoder = new PathEncoder();
-      const projectDir = await encoder.getProjectDirectory(
-        workdir,
-        SESSION_DIR,
-      );
-      const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
-      const indexContent = await fs.readFile(indexPath, "utf8");
-      const index = JSON.parse(indexContent) as SessionIndex;
-      rootSessionId = index.sessions[sessionId]?.rootSessionId;
-      parentSessionId = index.sessions[sessionId]?.parentSessionId;
-    } catch {
-      // Ignore index errors
-    }
-
     const sessionData: SessionData = {
       id: sessionId,
-      rootSessionId: rootSessionId || sessionId,
-      parentSessionId,
       messages,
       metadata: {
         workdir,
@@ -435,33 +331,9 @@ export async function listSessionsFromJsonl(
 
     const projectDir = await encoder.getProjectDirectory(workdir, baseDir);
 
-    // Try to read from index first
-    const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
     const sevenDaysAgo = new Date();
     sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
 
-    try {
-      const indexContent = await fs.readFile(indexPath, "utf8");
-      const index = JSON.parse(indexContent) as SessionIndex;
-      const sessions: SessionMetadata[] = Object.entries(index.sessions)
-        .filter(([, meta]) => {
-          const lastActiveAt = new Date(meta.lastActiveAt);
-          return meta.sessionType === "main" && lastActiveAt >= sevenDaysAgo;
-        })
-        .map(([id, meta]) => ({
-          id,
-          ...meta,
-          createdAt: new Date(meta.createdAt),
-          lastActiveAt: new Date(meta.lastActiveAt),
-        }));
-
-      return sessions.sort(
-        (a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime(),
-      );
-    } catch {
-      // Fallback to manual listing if index fails
-    }
-
     let files: string[];
     try {
       files = await fs.readdir(projectDir.encodedPath);
@@ -521,7 +393,7 @@ export async function listSessionsFromJsonl(
         const sessionMeta: SessionMetadata = {
           id: sessionId,
           sessionType: "main",
-          subagentType: undefined, // No longer stored in metadata
+          subagentType: undefined,
           workdir: projectDir.originalPath,
           createdAt: new Date(),
           lastActiveAt,
@@ -530,7 +402,7 @@ export async function listSessionsFromJsonl(
             : 0,
         };
 
-        // Try to get first message content for the fallback/rebuild case
+        // Try to get first message content for display
         try {
           const firstContent = await getFirstMessageContent(sessionId, workdir);
           if (firstContent) {
@@ -548,30 +420,9 @@ export async function listSessionsFromJsonl(
     }
 
     // Sort by last active time (most recently active first)
-    const sortedSessions = sessions.sort(
+    return sessions.sort(
       (a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime(),
     );
-
-    // Rebuild index if we had to fall back
-    try {
-      const index: SessionIndex = {
-        sessions: {},
-        lastUpdated: new Date().toISOString(),
-      };
-      for (const session of sessions) {
-        const { id, ...rest } = session;
-        index.sessions[id] = {
-          ...rest,
-          createdAt: session.createdAt.toISOString(),
-          lastActiveAt: session.lastActiveAt.toISOString(),
-        };
-      }
-      await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
-    } catch (error) {
-      logger.warn(`Failed to rebuild session index for ${workdir}:`, error);
-    }
-
-    return sortedSessions;
   } catch (error) {
     throw new Error(`Failed to list sessions: ${error}`);
   }
@@ -607,28 +458,52 @@ export async function listAllSessions(): Promise<SessionMetadata[]> {
           continue;
         }
 
-        // Try to read from index first
-        const indexPath = join(projectPath, SESSION_INDEX_FILENAME);
-        try {
-          const indexContent = await fs.readFile(indexPath, "utf8");
-          const index = JSON.parse(indexContent) as SessionIndex;
-          for (const [id, meta] of Object.entries(index.sessions)) {
-            const lastActiveAt = new Date(meta.lastActiveAt);
-            if (meta.sessionType === "main" && lastActiveAt >= sevenDaysAgo) {
-              allSessions.push({
-                id,
-                ...meta,
-                createdAt: new Date(meta.createdAt),
-                lastActiveAt,
-              });
+        // Scan .jsonl files in the project directory
+        const files = await fs.readdir(projectPath);
+
+        for (const file of files) {
+          if (!file.endsWith(".jsonl") || file.startsWith("subagent-")) {
+            continue;
+          }
+
+          try {
+            const filePath = join(projectPath, file);
+            const uuidMatch = file.match(
+              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
+            );
+            if (!uuidMatch) continue;
+
+            const sessionId = uuidMatch[1];
+            const jsonlHandler = new JsonlHandler();
+            const lastMessage = await jsonlHandler.getLastMessage(filePath);
+
+            let lastActiveAt: Date;
+            if (lastMessage) {
+              lastActiveAt = new Date(lastMessage.timestamp);
+            } else {
+              const stats = await fs.stat(filePath);
+              lastActiveAt = stats.mtime;
             }
+
+            if (lastActiveAt < sevenDaysAgo) continue;
+
+            allSessions.push({
+              id: sessionId,
+              sessionType: "main" as const,
+              subagentType: undefined,
+              workdir: projectDirName,
+              createdAt: new Date(),
+              lastActiveAt,
+              latestTotalTokens: lastMessage?.usage
+                ? extractLatestTotalTokens([lastMessage])
+                : 0,
+            });
+          } catch {
+            continue;
           }
-        } catch {
-          // If index fails, we skip this project directory
-          // In the future, we could scan for .jsonl files here
         }
       } catch {
-        // Skip if stat fails
+        // Skip if stat/readdir fails
       }
     }
 
@@ -677,38 +552,6 @@ export async function cleanupExpiredSessionsFromJsonl(
         if (fileAge > maxAge) {
           await fs.unlink(filePath);
           deletedCount++;
-
-          // Remove from index if it exists
-          try {
-            const indexPath = join(
-              projectDir.encodedPath,
-              SESSION_INDEX_FILENAME,
-            );
-            const indexContent = await fs.readFile(indexPath, "utf8");
-            const index = JSON.parse(indexContent) as SessionIndex;
-            const uuidMatch = file.match(
-              /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
-            );
-            const subagentMatch = file.match(
-              /^subagent-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/,
-            );
-            const sessionId = uuidMatch
-              ? uuidMatch[1]
-              : subagentMatch
-                ? subagentMatch[1]
-                : null;
-
-            if (sessionId && index.sessions[sessionId]) {
-              delete index.sessions[sessionId];
-              await fs.writeFile(
-                indexPath,
-                JSON.stringify(index, null, 2),
-                "utf8",
-              );
-            }
-          } catch {
-            // Ignore index update errors during cleanup
-          }
         }
       } catch {
         // Skip failed operations and continue processing other files
@@ -897,21 +740,6 @@ export async function deleteSession(
       throw error;
     }
   }
-
-  // Also remove from index
-  try {
-    const encoder = new PathEncoder();
-    const projectDir = await encoder.getProjectDirectory(workdir, SESSION_DIR);
-    const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
-    const indexContent = await fs.readFile(indexPath, "utf8");
-    const index = JSON.parse(indexContent) as SessionIndex;
-    if (index.sessions[sessionId]) {
-      delete index.sessions[sessionId];
-      await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
-    }
-  } catch {
-    // Ignore index errors
-  }
 }
 
 /**
@@ -995,7 +823,9 @@ export async function handleSessionRestoration(
 }
 
 /**
- * Load the full message thread by following parentSessionId links
+ * Load the full message thread for a session.
+ * With append-only compaction, all messages are in a single file.
+ * Returns the active messages (post-compact boundary).
  * @param currentSessionId - The ID of the current session
  * @param workdir - Working directory for the session
  * @returns Promise that resolves to an array of all messages in the thread
@@ -1004,36 +834,7 @@ export async function loadFullMessageThread(
   currentSessionId: string,
   workdir: string,
 ): Promise<{ messages: Message[]; sessionIds: string[] }> {
-  const sessionIds: string[] = [];
-  let currentId: string | undefined = currentSessionId;
-  const allMessages: Message[] = [];
-
-  while (currentId) {
-    const sessionData = await loadSessionFromJsonl(currentId, workdir);
-    if (!sessionData) break;
-
-    sessionIds.unshift(currentId);
-    // Add messages from this session to the beginning of the list
-    // But skip the "compact" block if it's not the first session in our traversal (which is the latest)
-    // Actually, we should probably keep all messages and let the UI/logic handle it.
-    // But wait, if we are concatenating, the "compact" block in session N summarizes session N-1.
-    // So if we have session N-1 and session N, we should probably skip the compact block in session N.
-
-    const messages = sessionData.messages;
-    if (allMessages.length > 0) {
-      // If we already have messages (from "later" sessions),
-      // we are now adding messages from an "earlier" session.
-      // The later session's first message might be a "compact" block.
-      if (allMessages[0].blocks.some((b) => b.type === "compact")) {
-        // Remove the compact block from the later session's messages
-        // because we are now providing the actual messages it summarized.
-        allMessages.shift();
-      }
-    }
-
-    allMessages.unshift(...messages);
-    currentId = sessionData.parentSessionId;
-  }
-
-  return { messages: allMessages, sessionIds };
+  const sessionData = await loadSessionFromJsonl(currentSessionId, workdir);
+  if (!sessionData) return { messages: [], sessionIds: [] };
+  return { messages: sessionData.messages, sessionIds: [currentSessionId] };
 }

package/src/telemetry/sessionTracing.ts

@@ -11,19 +11,55 @@
  */
 
 import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
 import type { Span } from "@opentelemetry/api";
 import {
   getOTELApi,
   isInitialized,
   getCurrentConfig,
 } from "./instrumentation.js";
-import type { LLMRequestMetadata, ToolMetadata } from "../types/telemetry.js";
+import { logOTelEvent } from "./events.js";
+import type {
+  LLMRequestMetadata,
+  LLMRequestInput,
+  ToolMetadata,
+} from "../types/telemetry.js";
+
+// -- Constants --
+
+/** Max content length for span attributes (60KB, aligning with Claude Code) */
+const MAX_CONTENT_LENGTH = 60000;
 
 // -- AsyncLocalStorage for context propagation --
 
 const interactionContext = new AsyncLocalStorage<Span | undefined>();
 const toolContext = new AsyncLocalStorage<Span | undefined>();
 
+// -- Incremental tracking state (module-level, per session) --
+
+/** Number of messages already reported in new_context; only deltas are sent */
+let lastReportedMessageCount = 0;
+/** Set of system prompt hashes already emitted via logOTelEvent */
+const seenSystemPromptHashes = new Set<string>();
+/** Set of tool schema hashes already emitted via logOTelEvent */
+const seenToolSchemaHashes = new Set<string>();
+
+// -- Helpers --
+
+/** Computes SHA-256 hash of content, returns first 12 hex characters */
+function hashContent(content: string): string {
+  return createHash("sha256").update(content).digest("hex").substring(0, 12);
+}
+
+/** Truncates content to MAX_CONTENT_LENGTH, returns [truncated, originalLength] */
+function truncateContent(content: string): [string, number] {
+  const originalLength = content.length;
+  if (originalLength > MAX_CONTENT_LENGTH) {
+    return [content.substring(0, MAX_CONTENT_LENGTH), originalLength];
+  }
+  return [content, originalLength];
+}
+
 // -- Tracer accessor --
 
 function getTracer() {
@@ -71,18 +107,33 @@ export function endInteractionSpan(): void {
   interactionContext.enterWith(undefined);
 }
 
+/**
+ * Resets incremental tracing state. Should be called after compaction to
+ * prevent incorrect delta calculations.
+ */
+export function resetTracingState(): void {
+  lastReportedMessageCount = 0;
+  seenSystemPromptHashes.clear();
+  seenToolSchemaHashes.clear();
+}
+
 /**
  * Creates an LLM request span as a child of the interaction span.
  * Does NOT enter any ALS — the span must be passed explicitly to endLLMRequestSpan.
+ *
+ * When logToolContent is enabled, captures:
+ * - system_prompt_hash / system_prompt_preview / system_prompt_length
+ * - new_context (incremental messages delta)
+ * - tools (JSON array of {name, hash}) / tools_count
  */
 export function startLLMRequestSpan(
   model: string,
-  options?: { context?: string },
+  options?: LLMRequestInput,
 ): Span | undefined {
   const tracer = getTracer();
   if (!tracer) return undefined;
 
-  const attributes: Record<string, string> = {
+  const attributes: Record<string, string | number | boolean> = {
     "span.type": "llm_request",
     model,
   };
@@ -90,6 +141,91 @@ export function startLLMRequestSpan(
     attributes["llm_request.context"] = options.context;
   }
 
+  const config = getCurrentConfig();
+
+  // Content capture gated by logToolContent
+  if (config?.logToolContent) {
+    // System prompt: hash + preview + length
+    if (options?.systemPrompt) {
+      const hash = hashContent(options.systemPrompt);
+      attributes.system_prompt_hash = hash;
+      attributes.system_prompt_length = options.systemPrompt.length;
+      const preview =
+        options.systemPrompt.length > 500
+          ? options.systemPrompt.substring(0, 500)
+          : options.systemPrompt;
+      attributes.system_prompt_preview = preview;
+
+      // Emit full system prompt via event only once per hash
+      if (!seenSystemPromptHashes.has(hash)) {
+        seenSystemPromptHashes.add(hash);
+        logOTelEvent("system_prompt", {
+          system_prompt_hash: hash,
+          system_prompt: options.systemPrompt,
+        }).catch(() => {});
+      }
+    }
+
+    // Incremental input messages: only send new messages since last report
+    if (options?.inputMessages && options.inputMessages.length > 0) {
+      const totalCount = options.inputMessages.length;
+      const deltaCount = totalCount - lastReportedMessageCount;
+      if (deltaCount > 0) {
+        const newMessages = options.inputMessages.slice(
+          lastReportedMessageCount,
+        );
+        const newContextStr = JSON.stringify(newMessages);
+        const [truncated, originalLength] = truncateContent(newContextStr);
+        attributes.new_context = truncated;
+        attributes.new_context_message_count = deltaCount;
+        if (originalLength > MAX_CONTENT_LENGTH) {
+          attributes.new_context_truncated = true;
+          attributes.new_context_original_length = originalLength;
+        }
+      }
+      lastReportedMessageCount = totalCount;
+    }
+
+    // Tool schemas: hash per tool + count
+    if (options?.toolsSchema) {
+      try {
+        const tools = JSON.parse(options.toolsSchema);
+        if (Array.isArray(tools)) {
+          const toolHashes = tools.map(
+            (tool: { function?: { name?: string } }) => {
+              const name = tool.function?.name || "unknown";
+              const toolStr = JSON.stringify(tool);
+              const hash = hashContent(toolStr);
+              return { name, hash };
+            },
+          );
+          attributes.tools = JSON.stringify(toolHashes);
+          attributes.tools_count = toolHashes.length;
+
+          // Emit full tool schema via event only once per hash
+          for (const { name, hash } of toolHashes) {
+            if (!seenToolSchemaHashes.has(hash)) {
+              seenToolSchemaHashes.add(hash);
+              const fullTool = tools.find(
+                (t: { function?: { name?: string } }) =>
+                  t.function?.name === name,
+              );
+              if (fullTool) {
+                logOTelEvent("tool_schema", {
+                  tool_name: name,
+                  tool_hash: hash,
+                  tool_schema: JSON.stringify(fullTool),
+                }).catch(() => {});
+              }
+            }
+          }
+        }
+      } catch {
+        // toolsSchema is not valid JSON — skip
+      }
+    }
+  }
+
   const parent = interactionContext.getStore();
   let span: Span;
   if (parent) {
@@ -105,6 +241,8 @@ export function startLLMRequestSpan(
 /**
  * Ends an LLM request span with response metadata.
  * The span is passed explicitly — no ALS is read or modified.
+ *
+ * When logToolContent is enabled, captures response.model_output.
  */
 export function endLLMRequestSpan(
   span: Span | undefined,
@@ -127,6 +265,20 @@ export function endLLMRequestSpan(
   if (metadata.hasToolCall != null)
     span.setAttribute("has_tool_call", metadata.hasToolCall);
 
+  // Content capture gated by logToolContent
+  const config = getCurrentConfig();
+  if (config?.logToolContent && metadata.modelOutput) {
+    const [truncated, originalLength] = truncateContent(metadata.modelOutput);
+    span.setAttribute("response.model_output", truncated);
+    if (originalLength > MAX_CONTENT_LENGTH) {
+      span.setAttribute("response.model_output_truncated", true);
+      span.setAttribute(
+        "response.model_output_original_length",
+        originalLength,
+      );
+    }
+  }
+
   span.end();
 }
 
@@ -142,16 +294,18 @@ export function startToolSpan(
   if (!tracer) return undefined;
 
   const config = getCurrentConfig();
-  const attributes: Record<string, string | number> = {
+  const attributes: Record<string, string | number | boolean> = {
     "span.type": "tool",
     tool_name: toolName,
   };
   if (config?.logToolContent && input !== undefined) {
-    let inputStr = typeof input === "string" ? input : JSON.stringify(input);
-    if (inputStr.length > 1000) {
-      inputStr = inputStr.substring(0, 1000);
+    const inputStr = typeof input === "string" ? input : JSON.stringify(input);
+    const [truncated, originalLength] = truncateContent(inputStr);
+    attributes.tool_input = truncated;
+    if (originalLength > MAX_CONTENT_LENGTH) {
+      attributes.tool_input_truncated = true;
+      attributes.tool_input_original_length = originalLength;
     }
-    attributes.tool_input = inputStr;
   }
 
   const parent = interactionContext.getStore();
@@ -181,11 +335,12 @@ export function endToolSpan(metadata: ToolMetadata): void {
 
   const config = getCurrentConfig();
   if (config?.logToolContent && metadata.output) {
-    let outputStr = metadata.output;
-    if (outputStr.length > 1000) {
-      outputStr = outputStr.substring(0, 1000);
+    const [truncated, originalLength] = truncateContent(metadata.output);
+    span.setAttribute("tool_output", truncated);
+    if (originalLength > MAX_CONTENT_LENGTH) {
+      span.setAttribute("tool_output_truncated", true);
+      span.setAttribute("tool_output_original_length", originalLength);
     }
-    span.setAttribute("tool_output", outputStr);
   }
 
   span.end();