wave-agent-sdk 0.18.7 → 0.19.0

package/dist/services/session.js

@@ -41,34 +41,6 @@ export function generateSubagentFilename(sessionId) {
 // 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, metadata) {
-    const indexPath = join(projectDirPath, SESSION_INDEX_FILENAME);
-    let index = {
-        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
  */
@@ -129,7 +101,7 @@ export async function createSession(sessionId, workdir, sessionType = "main") {
  * @param workdir - Working directory for the session
  * @param sessionType - Type of session ("main" or "subagent", defaults to "main")
  */
-export async function appendMessages(sessionId, newMessages, workdir, sessionType = "main", rootSessionId, parentSessionId) {
+export async function appendMessages(sessionId, newMessages, workdir, sessionType = "main") {
     // Do not save session files in test environment
     if (process.env.NODE_ENV === "test") {
         return;
@@ -151,47 +123,6 @@ export async function appendMessages(sessionId, newMessages, workdir, sessionTyp
     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;
-    let createdAt;
-    try {
-        const indexPath = join(projectDir.encodedPath, SESSION_INDEX_FILENAME);
-        const content = await fs.readFile(indexPath, "utf8");
-        const index = JSON.parse(content);
-        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,
-    });
 }
 /**
  * Load session data from JSONL file (new approach)
@@ -216,28 +147,20 @@ export async function loadSessionFromJsonl(sessionId, workdir, sessionType = "ma
             }
             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;
-        let parentSessionId;
-        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);
-            rootSessionId = index.sessions[sessionId]?.rootSessionId;
-            parentSessionId = index.sessions[sessionId]?.parentSessionId;
-        }
-        catch {
-            // Ignore index errors
-        }
         const sessionData = {
             id: sessionId,
-            rootSessionId: rootSessionId || sessionId,
-            parentSessionId,
             messages,
             metadata: {
                 workdir,
@@ -311,29 +234,8 @@ export async function listSessionsFromJsonl(workdir) {
         const encoder = new PathEncoder();
         const baseDir = SESSION_DIR;
         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);
-            const sessions = 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;
         try {
             files = await fs.readdir(projectDir.encodedPath);
@@ -382,7 +284,7 @@ export async function listSessionsFromJsonl(workdir) {
                 const sessionMeta = {
                     id: sessionId,
                     sessionType: "main",
-                    subagentType: undefined, // No longer stored in metadata
+                    subagentType: undefined,
                     workdir: projectDir.originalPath,
                     createdAt: new Date(),
                     lastActiveAt,
@@ -390,7 +292,7 @@ export async function listSessionsFromJsonl(workdir) {
                         ? extractLatestTotalTokens([lastMessage])
                         : 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) {
@@ -408,27 +310,7 @@ export async function listSessionsFromJsonl(workdir) {
             }
         }
         // Sort by last active time (most recently active first)
-        const sortedSessions = sessions.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
-        // Rebuild index if we had to fall back
-        try {
-            const index = {
-                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;
+        return sessions.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
     }
     catch (error) {
         throw new Error(`Failed to list sessions: ${error}`);
@@ -462,30 +344,49 @@ export async function listAllSessions() {
                 if (!stat.isDirectory()) {
                     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);
-                    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;
+                        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",
+                            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
             }
         }
         return allSessions.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
@@ -523,26 +424,6 @@ export async function cleanupExpiredSessionsFromJsonl(workdir) {
                 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);
-                        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 {
@@ -697,21 +578,6 @@ export async function deleteSession(sessionId, workdir, sessionType = "main") {
             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);
-        if (index.sessions[sessionId]) {
-            delete index.sessions[sessionId];
-            await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf8");
-        }
-    }
-    catch {
-        // Ignore index errors
-    }
 }
 /**
  * Truncate content to a maximum length, adding ellipsis if truncated.
@@ -778,38 +644,16 @@ export async function handleSessionRestoration(restoreSessionId, continueLastSes
     }
 }
 /**
- * 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
  */
 export async function loadFullMessageThread(currentSessionId, workdir) {
-    const sessionIds = [];
-    let currentId = currentSessionId;
-    const allMessages = [];
-    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/dist/telemetry/sessionTracing.d.ts

@@ -10,7 +10,7 @@
  * endLLMRequestSpan, aligning with Claude Code's approach.
  */
 import type { Span } from "@opentelemetry/api";
-import type { LLMRequestMetadata, ToolMetadata } from "../types/telemetry.js";
+import type { LLMRequestMetadata, LLMRequestInput, ToolMetadata } from "../types/telemetry.js";
 /**
  * Creates an interaction span for a user turn.
  * The span is stored in interactionContext for the duration of the turn.
@@ -20,16 +20,26 @@ export declare function startInteractionSpan(userPrompt: string, sequence: numbe
  * Ends the current interaction span and clears the context.
  */
 export declare function endInteractionSpan(): void;
+/**
+ * Resets incremental tracing state. Should be called after compaction to
+ * prevent incorrect delta calculations.
+ */
+export declare function resetTracingState(): void;
 /**
  * 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 declare function startLLMRequestSpan(model: string, options?: {
-    context?: string;
-}): Span | undefined;
+export declare function startLLMRequestSpan(model: string, options?: LLMRequestInput): Span | undefined;
 /**
  * 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 declare function endLLMRequestSpan(span: Span | undefined, metadata: LLMRequestMetadata): void;
 /**

package/dist/telemetry/sessionTracing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessionTracing.d.ts","sourceRoot":"","sources":["../../src/telemetry/sessionTracing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAM/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAkB9E;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,IAAI,GAAG,SAAS,CAiBlB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAKzC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7B,IAAI,GAAG,SAAS,CAsBlB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,QAAQ,EAAE,kBAAkB,GAC3B,IAAI,CAmBN;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,OAAO,GACd,IAAI,GAAG,SAAS,CA4BlB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAmBxD"}
+{"version":3,"file":"sessionTracing.d.ts","sourceRoot":"","sources":["../../src/telemetry/sessionTracing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAO/C,OAAO,KAAK,EACV,kBAAkB,EAClB,eAAe,EACf,YAAY,EACb,MAAM,uBAAuB,CAAC;AAgD/B;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,IAAI,GAAG,SAAS,CAiBlB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAKzC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAIxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,IAAI,GAAG,SAAS,CA2GlB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,QAAQ,EAAE,kBAAkB,GAC3B,IAAI,CAiCN;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,OAAO,GACd,IAAI,GAAG,SAAS,CA8BlB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAoBxD"}

package/dist/telemetry/sessionTracing.js

@@ -10,10 +10,35 @@
  * endLLMRequestSpan, aligning with Claude Code's approach.
  */
 import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
 import { getOTELApi, isInitialized, getCurrentConfig, } from "./instrumentation.js";
+import { logOTelEvent } from "./events.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();
 const toolContext = new AsyncLocalStorage();
+// -- 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();
+/** Set of tool schema hashes already emitted via logOTelEvent */
+const seenToolSchemaHashes = new Set();
+// -- Helpers --
+/** Computes SHA-256 hash of content, returns first 12 hex characters */
+function hashContent(content) {
+    return createHash("sha256").update(content).digest("hex").substring(0, 12);
+}
+/** Truncates content to MAX_CONTENT_LENGTH, returns [truncated, originalLength] */
+function truncateContent(content) {
+    const originalLength = content.length;
+    if (originalLength > MAX_CONTENT_LENGTH) {
+        return [content.substring(0, MAX_CONTENT_LENGTH), originalLength];
+    }
+    return [content, originalLength];
+}
 // -- Tracer accessor --
 function getTracer() {
     if (!isInitialized())
@@ -55,9 +80,23 @@ export function endInteractionSpan() {
     span.end();
     interactionContext.enterWith(undefined);
 }
+/**
+ * Resets incremental tracing state. Should be called after compaction to
+ * prevent incorrect delta calculations.
+ */
+export function resetTracingState() {
+    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, options) {
     const tracer = getTracer();
@@ -70,6 +109,78 @@ export function startLLMRequestSpan(model, options) {
     if (options?.context) {
         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) => {
+                        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) => 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;
     if (parent) {
@@ -85,6 +196,8 @@ export function startLLMRequestSpan(model, options) {
 /**
  * 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, metadata) {
     if (!span)
@@ -106,6 +219,16 @@ export function endLLMRequestSpan(span, metadata) {
         span.setAttribute("error", metadata.error);
     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();
 }
 /**
@@ -122,11 +245,13 @@ export function startToolSpan(toolName, input) {
         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();
     let span;
@@ -155,11 +280,12 @@ export function endToolSpan(metadata) {
     span.setAttribute("duration_ms", metadata.durationMs);
     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();
     toolContext.enterWith(undefined);

package/dist/tools/bashTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bashTool.d.ts","sourceRoot":"","sources":["../../src/tools/bashTool.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAuBtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA2iBtB,CAAC"}
+{"version":3,"file":"bashTool.d.ts","sourceRoot":"","sources":["../../src/tools/bashTool.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AA0CtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA8iBtB,CAAC"}

package/dist/tools/bashTool.js

@@ -10,6 +10,21 @@ import { processToolResult } from "../utils/toolResultStorage.js";
 import { BASH_MAX_OUTPUT_CHARS } from "../constants/toolLimits.js";
 import { BASH_TOOL_NAME, GLOB_TOOL_NAME, GREP_TOOL_NAME, READ_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, } from "../constants/tools.js";
 const BASH_DEFAULT_TIMEOUT_MS = 120000;
+/**
+ * Wrap a user command so we can append CWD tracking (`&& pwd -P`) without the
+ * appended part being affected by trailing here-docs, unbalanced quotes, or
+ * multi-line syntax in the user command.
+ *
+ * The command is single-quoted (with embedded single quotes escaped via the
+ * classic `'"'"'` sequence) and run through `eval`. Because the entire user
+ * command becomes a single literal argument to `eval`, any here-doc inside it
+ * only opens/closes during eval's own second parse pass and cannot leak out to
+ * clobber the trailing `&& pwd -P`. Works on sh/dash/bash and Git Bash.
+ */
+function wrapCommandForCwdTracking(command, cwdFileForBash) {
+    const escaped = command.replace(/'/g, `'"'"'`);
+    return `eval '${escaped}' && pwd -P >| ${cwdFileForBash}`;
+}
 // Commands that should not be auto-backgrounded on timeout (e.g. sleep should just be killed)
 const DISALLOWED_AUTO_BACKGROUND_COMMANDS = ["sleep"];
 function isAutobackgroundingAllowed(command) {
@@ -213,7 +228,7 @@ The working directory persists between commands. Try to maintain your current wo
             // Create a temporary file to store the CWD
             const tempCwdFile = path.join(os.tmpdir(), `wave_cwd_${Date.now()}_${Math.random().toString(36).substring(2, 11)}.tmp`);
             const tempCwdFileForBash = toPosixPath(tempCwdFile);
-            const wrappedCommand = `${command} && pwd -P >| ${tempCwdFileForBash}`;
+            const wrappedCommand = wrapCommandForCwdTracking(command, tempCwdFileForBash);
             const child = spawn(wrappedCommand, {
                 shell: shellPath || true,
                 stdio: "pipe",

package/dist/types/config.d.ts

@@ -11,12 +11,19 @@ export interface GatewayConfig {
     fetchOptions?: OpenAI["fetchOptions"];
     fetch?: OpenAI["fetch"];
 }
+export interface ModelCapabilities {
+    /** Whether the model supports image/vision input. Default: true. */
+    vision?: boolean;
+    /** Whether the model supports prompt caching (ephemeral cache_control markers). Default: false. */
+    promptCaching?: boolean;
+}
 export interface ModelConfig {
     model?: string;
     fastModel?: string;
     maxTokens?: number;
     permissionMode?: PermissionMode;
     fastModelConfig?: Record<string, unknown>;
+    capabilities?: ModelCapabilities;
     [key: string]: unknown;
 }
 //# sourceMappingURL=config.d.ts.map