wave-agent-sdk 0.18.5 → 0.18.7

package/src/managers/aiManager.ts

@@ -3,6 +3,7 @@ import * as aiService from "../services/aiService.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { parseTaskNotificationXml } from "../utils/notificationXml.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
+import { estimateTokens } from "../utils/tokenEstimate.js";
 import {
   getTaskReminderTurnCounts,
   maybeInjectTaskReminder,
@@ -606,7 +607,7 @@ export class AIManager {
     );
     let usedTokens = 0;
     for (const file of recentFiles) {
-      const fileTokens = Math.ceil(file.content.length / 4);
+      const fileTokens = estimateTokens(file.content);
       if (usedTokens + fileTokens > POST_COMPACT_MAX_TOKENS_PER_FILE) continue;
       if (fileTokens > 0) usedTokens += fileTokens;
       contextParts.push(`\n\n## ${file.path}\n\`\`\`\n${file.content}\n\`\`\``);
@@ -639,7 +640,7 @@ export class AIManager {
               skillContent.slice(0, maxSkillChars) + "\n\n...[truncated]...";
           }
 
-          const skillTokens = Math.ceil(skillContent.length / 4);
+          const skillTokens = estimateTokens(skillContent);
           if (skillsUsedTokens + skillTokens > POST_COMPACT_SKILLS_TOKEN_BUDGET)
             break;
           skillsUsedTokens += skillTokens;
@@ -813,6 +814,7 @@ export class AIManager {
       let turnDepth = turnOffset;
 
       inner: while (true) {
+        let llmSpan: import("@opentelemetry/api").Span | undefined;
         try {
           // Save session in each iteration to ensure message persistence
           await this.messageManager.saveSession();
@@ -949,15 +951,21 @@ export class AIManager {
             };
           }
 
-          startLLMRequestSpan(model || this.getModelConfig().model || "");
+          llmSpan = startLLMRequestSpan(
+            model || this.getModelConfig().model || "",
+          );
 
           const result = await aiService.callAgent(callAgentOptions);
 
           // End LLM span with usage data
-          endLLMRequestSpan({
+          endLLMRequestSpan(llmSpan, {
             model: model || this.getModelConfig().model || "",
             success: true,
             hasToolCall: !!(result.tool_calls && result.tool_calls.length > 0),
+            inputTokens: result.usage?.prompt_tokens,
+            outputTokens: result.usage?.completion_tokens,
+            cacheReadTokens: result.usage?.cache_read_input_tokens,
+            cacheCreationTokens: result.usage?.cache_creation_input_tokens,
           });
 
           const createdByStreaming = assistantMessageCreated;
@@ -1238,7 +1246,7 @@ export class AIManager {
           break inner;
         } catch (error) {
           // End LLM span with error
-          endLLMRequestSpan({
+          endLLMRequestSpan(llmSpan, {
             model: model || this.getModelConfig().model || "",
             success: false,
             error: error instanceof Error ? error.message : String(error),
@@ -1271,7 +1279,103 @@ export class AIManager {
         // Set loading to false first
         this.setIsLoading(false);
 
-        // Inject pending notifications from background tasks
+        // Clear temporary rules
+        this.permissionManager?.clearTemporaryRules();
+
+        // Clear abort controllers
+        this.abortController = null;
+        this.toolAbortController = null;
+
+        // Execute Stop/SubagentStop hooks only if the operation was not aborted
+        const isCurrentlyAborted =
+          abortController.signal.aborted || toolAbortController.signal.aborted;
+
+        if (!isCurrentlyAborted) {
+          // Record committed snapshots to message history for the final turn
+          if (this.reversionManager) {
+            const snapshots =
+              this.reversionManager.getAndClearCommittedSnapshots();
+            if (snapshots.length > 0) {
+              this.messageManager.addFileHistoryBlock(snapshots);
+            }
+          }
+
+          // Goal evaluation — supersedes Stop hooks when active
+          const goalManager = this.container.has("GoalManager")
+            ? this.container.get<import("./goalManager.js").GoalManager>(
+                "GoalManager",
+              )
+            : undefined;
+
+          let goalContinuing = false;
+
+          if (goalManager?.isGoalActive() && !this.subagentType) {
+            // 1. Increment turn count and check circuit breakers
+            goalManager.incrementTurnCount();
+            const circuitBreaker = goalManager.checkCircuitBreakers();
+
+            if (circuitBreaker) {
+              goalManager.clearGoal();
+              logger?.info(`[Goal] ${circuitBreaker}`);
+              this.messageManager.addUserMessage({
+                content: `<system-reminder>${circuitBreaker}</system-reminder>`,
+                isMeta: true,
+              });
+              // Fall through to normal Stop hooks on the final turn
+            } else {
+              // 2. Evaluate goal
+              const evaluation = await goalManager.evaluateGoal(
+                abortController.signal,
+              );
+
+              if (evaluation.isMet) {
+                goalManager.clearGoal();
+                logger?.info(`[Goal] Goal achieved: ${evaluation.reason}`);
+                this.messageManager.addUserMessage({
+                  content: `<system-reminder>Goal achieved: ${evaluation.reason}</system-reminder>`,
+                  isMeta: true,
+                });
+                // Fall through to normal Stop hooks on the final turn
+              } else {
+                const goal = goalManager.getGoal()!;
+                goal.lastReason = evaluation.reason;
+                logger?.info(`[Goal] Not yet met: ${evaluation.reason}`);
+                this.messageManager.addUserMessage({
+                  content: `<system-reminder>Goal not yet met: ${evaluation.reason}. Continue working toward: ${goal.condition}</system-reminder>`,
+                  isMeta: true,
+                });
+                // Keep loading state active to prevent UI flicker
+                this.setIsLoading(true);
+                goalContinuing = true;
+                // Restart outer loop to continue goal pursuit
+                shouldRestart = true;
+                turnOffset = 0;
+              }
+            }
+          }
+
+          // Skip Stop hooks when goal evaluator is continuing the conversation
+          if (goalContinuing) {
+            // Goal evaluator supersedes Stop hooks
+          } else {
+            const shouldContinue = await this.executeStopHooks();
+
+            // If Stop/SubagentStop hooks indicate we should continue (due to blocking errors),
+            // restart the AI conversation cycle
+            if (shouldContinue) {
+              logger?.info(
+                `${this.subagentType ? "SubagentStop" : "Stop"} hooks indicate issues need fixing, continuing conversation...`,
+              );
+
+              // Restart the conversation to let AI fix the issues
+              shouldRestart = true;
+              turnOffset = 0;
+            }
+          }
+        }
+
+        // Inject pending notifications from background tasks (after Stop hooks,
+        // aligned with Claude Code which fires Stop hooks unconditionally)
         const notificationQueue = this.container.has("NotificationQueue")
           ? this.container.get<NotificationQueue>("NotificationQueue")
           : undefined;
@@ -1292,102 +1396,6 @@ export class AIManager {
           // Restart outer loop to process the notifications
           shouldRestart = true;
           turnOffset = 0;
-        } else {
-          // Clear temporary rules
-          this.permissionManager?.clearTemporaryRules();
-
-          // Clear abort controllers
-          this.abortController = null;
-          this.toolAbortController = null;
-
-          // Execute Stop/SubagentStop hooks only if the operation was not aborted
-          const isCurrentlyAborted =
-            abortController.signal.aborted ||
-            toolAbortController.signal.aborted;
-
-          if (!isCurrentlyAborted) {
-            // Record committed snapshots to message history for the final turn
-            if (this.reversionManager) {
-              const snapshots =
-                this.reversionManager.getAndClearCommittedSnapshots();
-              if (snapshots.length > 0) {
-                this.messageManager.addFileHistoryBlock(snapshots);
-              }
-            }
-
-            // Goal evaluation — supersedes Stop hooks when active
-            const goalManager = this.container.has("GoalManager")
-              ? this.container.get<import("./goalManager.js").GoalManager>(
-                  "GoalManager",
-                )
-              : undefined;
-
-            let goalContinuing = false;
-
-            if (goalManager?.isGoalActive() && !this.subagentType) {
-              // 1. Increment turn count and check circuit breakers
-              goalManager.incrementTurnCount();
-              const circuitBreaker = goalManager.checkCircuitBreakers();
-
-              if (circuitBreaker) {
-                goalManager.clearGoal();
-                logger?.info(`[Goal] ${circuitBreaker}`);
-                this.messageManager.addUserMessage({
-                  content: `<system-reminder>${circuitBreaker}</system-reminder>`,
-                  isMeta: true,
-                });
-                // Fall through to normal Stop hooks on the final turn
-              } else {
-                // 2. Evaluate goal
-                const evaluation = await goalManager.evaluateGoal(
-                  abortController.signal,
-                );
-
-                if (evaluation.isMet) {
-                  goalManager.clearGoal();
-                  logger?.info(`[Goal] Goal achieved: ${evaluation.reason}`);
-                  this.messageManager.addUserMessage({
-                    content: `<system-reminder>Goal achieved: ${evaluation.reason}</system-reminder>`,
-                    isMeta: true,
-                  });
-                  // Fall through to normal Stop hooks on the final turn
-                } else {
-                  const goal = goalManager.getGoal()!;
-                  goal.lastReason = evaluation.reason;
-                  logger?.info(`[Goal] Not yet met: ${evaluation.reason}`);
-                  this.messageManager.addUserMessage({
-                    content: `<system-reminder>Goal not yet met: ${evaluation.reason}. Continue working toward: ${goal.condition}</system-reminder>`,
-                    isMeta: true,
-                  });
-                  // Keep loading state active to prevent UI flicker
-                  this.setIsLoading(true);
-                  goalContinuing = true;
-                  // Restart outer loop to continue goal pursuit
-                  shouldRestart = true;
-                  turnOffset = 0;
-                }
-              }
-            }
-
-            // Skip Stop hooks when goal evaluator is continuing the conversation
-            if (goalContinuing) {
-              // Goal evaluator supersedes Stop hooks
-            } else {
-              const shouldContinue = await this.executeStopHooks();
-
-              // If Stop/SubagentStop hooks indicate we should continue (due to blocking errors),
-              // restart the AI conversation cycle
-              if (shouldContinue) {
-                logger?.info(
-                  `${this.subagentType ? "SubagentStop" : "Stop"} hooks indicate issues need fixing, continuing conversation...`,
-                );
-
-                // Restart the conversation to let AI fix the issues
-                shouldRestart = true;
-                turnOffset = 0;
-              }
-            }
-          }
         }
       }
 
@@ -1653,6 +1661,7 @@ export class AIManager {
         shortResult: toolResult.shortResult,
         isManuallyBackgrounded: toolResult.isManuallyBackgrounded,
         startLineNumber: toolResult.startLineNumber,
+        images: toolResult.images,
         timestamp: Date.now(),
       });
 

package/src/managers/cronManager.ts

@@ -15,6 +15,7 @@ import {
   releaseSchedulerLock,
   registerSchedulerLockCleanup,
 } from "../utils/cronTasksLock.js";
+import { ensureWaveRuntimeFilesExcluded } from "../utils/gitUtils.js";
 
 export class CronManager {
   private jobs = new Map<string, CronJob>();
@@ -100,6 +101,7 @@ export class CronManager {
   }
 
   private tryLock(workdir: string): void {
+    ensureWaveRuntimeFilesExcluded(workdir);
     tryAcquireSchedulerLock({ dir: workdir, sessionId: this.sessionId })
       .then((acquired) => {
         if (acquired) {

package/src/managers/liveConfigManager.ts

@@ -17,7 +17,6 @@ import type { HookManager } from "./hookManager.js";
 import type { PermissionManager } from "./permissionManager.js";
 import { isValidHookEvent } from "../types/hooks.js";
 import { ConfigurationService } from "../services/configurationService.js";
-import { ensureGlobalGitIgnore } from "../utils/fileUtils.js";
 import { Container } from "../utils/container.js";
 
 import type {
@@ -97,9 +96,6 @@ export class LiveConfigManager {
       if (projectPaths) {
         for (const projectPath of projectPaths) {
           if (existsSync(projectPath)) {
-            if (projectPath.endsWith("settings.local.json")) {
-              await ensureGlobalGitIgnore("**/.wave/settings.local.json");
-            }
             await this.fileWatcher.watchFile(projectPath, (event) =>
               this.handleFileChange(event, "project"),
             );
@@ -364,14 +360,6 @@ export class LiveConfigManager {
 
       // Handle file creation or modification
       if (event.type === "change" || event.type === "create") {
-        if (
-          source === "project" &&
-          event.path.endsWith("settings.local.json") &&
-          event.type === "create"
-        ) {
-          await ensureGlobalGitIgnore("**/.wave/settings.local.json");
-        }
-
         // Add small delay to ensure file write is complete
         await new Promise((resolve) => setTimeout(resolve, 50));
 

package/src/managers/mcpManager.ts

@@ -848,9 +848,16 @@ export class McpManager {
         textContent.push(String(result.content));
       }
 
+      const textContentStr =
+        textContent.length > 0
+          ? textContent.join("\n")
+          : images.length > 0
+            ? `Tool returned ${images.length} image(s).`
+            : "No content";
+
       return {
         success: true,
-        content: textContent.length > 0 ? textContent.join("\n") : "No content",
+        content: textContentStr,
         images: images.length > 0 ? images : undefined,
         serverName,
       };

package/src/managers/messageManager.ts

@@ -31,6 +31,7 @@ import type { MemoryRuleManager } from "./MemoryRuleManager.js";
 import type { MemoryRule } from "../types/memoryRule.js";
 import type { MemoryService } from "../services/memory.js";
 import { pathEncoder } from "../utils/pathEncoder.js";
+import { estimateTokens } from "../utils/tokenEstimate.js";
 import { READ_TOOL_NAME } from "../constants/tools.js";
 
 import { Container } from "../utils/container.js";
@@ -1063,7 +1064,7 @@ export class MessageManager {
   /**
    * Get recent file read contents, sorted by timestamp (newest first).
    * @param maxFiles - Maximum number of files to return
-   * @param maxTokensPerFile - Maximum tokens per file (~4 chars/token)
+   * @param maxTokensPerFile - Maximum tokens per file (CJK-aware estimation)
    * @returns Array of { path, content } sorted by recency
    */
   public getRecentFileReads(
@@ -1076,10 +1077,14 @@ export class MessageManager {
 
     const result: Array<{ path: string; content: string }> = [];
     for (const [path, { content }] of sorted) {
-      const truncated =
-        content.length > maxTokensPerFile * 4
-          ? content.slice(0, maxTokensPerFile * 4)
-          : content;
+      const tokenCount = estimateTokens(content);
+      let truncated = content;
+      if (tokenCount > maxTokensPerFile) {
+        // Truncate proportionally to fit within the token budget
+        const ratio = maxTokensPerFile / tokenCount;
+        const cutIndex = Math.floor(content.length * ratio);
+        truncated = content.slice(0, cutIndex);
+      }
       result.push({ path, content: truncated });
     }
     return result;

package/src/managers/toolManager.ts

@@ -279,6 +279,7 @@ class ToolManager {
         endToolSpan({
           success: result.success,
           durationMs: Date.now() - toolStartTime,
+          output: result.content,
         });
         return result;
       } catch (error) {
@@ -303,6 +304,7 @@ class ToolManager {
         endToolSpan({
           success: result.success,
           durationMs: Date.now() - toolStartTime,
+          output: result.content,
         });
         return result;
       } catch (error) {

package/src/services/configurationService.ts

@@ -47,6 +47,7 @@ import {
   mergeRemoteSettings,
 } from "./remoteSettingsService.js";
 import { createAuthAwareFetch } from "./authService.js";
+import { ensureWaveRuntimeFilesExcluded } from "../utils/gitUtils.js";
 
 /**
  * Default ConfigurationService implementation
@@ -791,6 +792,7 @@ export class ConfigurationService {
 
     // Ensure .wave directory exists
     const waveDir = path.join(workdir, ".wave");
+    ensureWaveRuntimeFilesExcluded(workdir);
     if (!existsSync(waveDir)) {
       await fs.mkdir(waveDir, { recursive: true });
     }

package/src/telemetry/sessionTracing.ts

@@ -2,7 +2,12 @@
  * Session Tracing -- OpenTelemetry Span Management
  *
  * Provides span creation/ending APIs for interactions, LLM requests, and tool
- * executions with AsyncLocalStorage context propagation and stale span cleanup.
+ * executions. Uses two independent AsyncLocalStorage contexts:
+ * - interactionContext: holds the interaction span for the entire turn
+ * - toolContext: holds the current tool span (cleared on end)
+ *
+ * LLM request spans do not enter any ALS; they are passed explicitly to
+ * endLLMRequestSpan, aligning with Claude Code's approach.
  */
 
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -16,12 +21,8 @@ import type { LLMRequestMetadata, ToolMetadata } from "../types/telemetry.js";
 
 // -- AsyncLocalStorage for context propagation --
 
-const spanContext = new AsyncLocalStorage<Span>();
-
-// -- LIFO stacks for nested span tracking --
-
-const llmSpans: Span[] = [];
-const toolSpans: Span[] = [];
+const interactionContext = new AsyncLocalStorage<Span | undefined>();
+const toolContext = new AsyncLocalStorage<Span | undefined>();
 
 // -- Tracer accessor --
 
@@ -32,37 +33,19 @@ function getTracer() {
   return otelApi.trace.getTracer("wave");
 }
 
-// -- Helper: create child span with parent context --
-
-function startChildSpan(
-  name: string,
-  attributes: Record<string, string | number>,
-): Span | undefined {
-  const tracer = getTracer();
-  if (!tracer) return undefined;
-
-  const parent = spanContext.getStore();
-  let span: Span;
-  if (parent) {
-    const otelApi = getOTELApi()!;
-    const ctx = otelApi.trace.setSpan(otelApi.context.active(), parent);
-    span = tracer.startSpan(name, { attributes }, ctx);
-  } else {
-    span = tracer.startSpan(name, { attributes });
-  }
-  spanContext.enterWith(span);
-  return span;
-}
-
 // -- Public API --
 
 /**
  * Creates an interaction span for a user turn.
+ * The span is stored in interactionContext for the duration of the turn.
  */
 export function startInteractionSpan(
   userPrompt: string,
   sequence: number,
 ): Span | undefined {
+  const tracer = getTracer();
+  if (!tracer) return undefined;
+
   const config = getCurrentConfig();
   const attributes: Record<string, string | number> = {
     "span.type": "interaction",
@@ -72,25 +55,33 @@ export function startInteractionSpan(
   if (config?.logUserPrompts) {
     attributes.user_prompt = userPrompt;
   }
-  return startChildSpan("interaction", attributes);
+
+  const span = tracer.startSpan("interaction", { attributes });
+  interactionContext.enterWith(span);
+  return span;
 }
 
 /**
- * Ends the current active interaction span.
+ * Ends the current interaction span and clears the context.
  */
 export function endInteractionSpan(): void {
-  const span = spanContext.getStore();
+  const span = interactionContext.getStore();
   if (!span) return;
   span.end();
+  interactionContext.enterWith(undefined);
 }
 
 /**
- * Creates an LLM request span as a child of the current active span.
+ * 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.
  */
 export function startLLMRequestSpan(
   model: string,
   options?: { context?: string },
 ): Span | undefined {
+  const tracer = getTracer();
+  if (!tracer) return undefined;
+
   const attributes: Record<string, string> = {
     "span.type": "llm_request",
     model,
@@ -99,18 +90,26 @@ export function startLLMRequestSpan(
     attributes["llm_request.context"] = options.context;
   }
 
-  const span = startChildSpan("llm.request", attributes);
-  if (span) {
-    llmSpans.push(span);
+  const parent = interactionContext.getStore();
+  let span: Span;
+  if (parent) {
+    const otelApi = getOTELApi()!;
+    const ctx = otelApi.trace.setSpan(otelApi.context.active(), parent);
+    span = tracer.startSpan("llm.request", { attributes }, ctx);
+  } else {
+    span = tracer.startSpan("llm.request", { attributes });
   }
   return span;
 }
 
 /**
- * Ends the most recent LLM request span with response metadata.
+ * Ends an LLM request span with response metadata.
+ * The span is passed explicitly — no ALS is read or modified.
  */
-export function endLLMRequestSpan(metadata: LLMRequestMetadata): void {
-  const span = llmSpans.pop();
+export function endLLMRequestSpan(
+  span: Span | undefined,
+  metadata: LLMRequestMetadata,
+): void {
   if (!span) return;
 
   if (metadata.inputTokens != null)
@@ -129,19 +128,19 @@ export function endLLMRequestSpan(metadata: LLMRequestMetadata): void {
     span.setAttribute("has_tool_call", metadata.hasToolCall);
 
   span.end();
-
-  if (llmSpans.length > 0) {
-    spanContext.enterWith(llmSpans[llmSpans.length - 1]);
-  }
 }
 
 /**
- * Creates a tool execution span as a child of the current active span.
+ * Creates a tool execution span as a child of the interaction span.
+ * Enters toolContext with the new span.
  */
 export function startToolSpan(
   toolName: string,
   input?: unknown,
 ): Span | undefined {
+  const tracer = getTracer();
+  if (!tracer) return undefined;
+
   const config = getCurrentConfig();
   const attributes: Record<string, string | number> = {
     "span.type": "tool",
@@ -155,42 +154,40 @@ export function startToolSpan(
     attributes.tool_input = inputStr;
   }
 
-  const span = startChildSpan(`tool.${toolName}`, attributes);
-  if (span) {
-    toolSpans.push(span);
+  const parent = interactionContext.getStore();
+  let span: Span;
+  if (parent) {
+    const otelApi = getOTELApi()!;
+    const ctx = otelApi.trace.setSpan(otelApi.context.active(), parent);
+    span = tracer.startSpan(`tool.${toolName}`, { attributes }, ctx);
+  } else {
+    span = tracer.startSpan(`tool.${toolName}`, { attributes });
   }
+  toolContext.enterWith(span);
   return span;
 }
 
 /**
- * Ends a tool span with execution metadata.
+ * Ends the current tool span with execution metadata.
+ * Reads the span from toolContext, then clears it.
  */
 export function endToolSpan(metadata: ToolMetadata): void {
-  const span = toolSpans.pop();
+  const span = toolContext.getStore();
   if (!span) return;
 
   span.setAttribute("success", metadata.success);
   if (metadata.error) span.setAttribute("error", metadata.error);
   span.setAttribute("duration_ms", metadata.durationMs);
 
-  span.end();
-
-  if (toolSpans.length > 0) {
-    spanContext.enterWith(toolSpans[toolSpans.length - 1]);
+  const config = getCurrentConfig();
+  if (config?.logToolContent && metadata.output) {
+    let outputStr = metadata.output;
+    if (outputStr.length > 1000) {
+      outputStr = outputStr.substring(0, 1000);
+    }
+    span.setAttribute("tool_output", outputStr);
   }
-}
 
-/**
- * Returns the current active span from ALS context.
- */
-export function getActiveInteractionSpan(): Span | undefined {
-  return spanContext.getStore();
-}
-
-/**
- * Executes `fn` with `span` as the active context via ALS.
- * Useful for parallel tool calls that each need their own span context.
- */
-export function withSpanContext<T>(span: Span, fn: () => T): T {
-  return spanContext.run(span, fn);
+  span.end();
+  toolContext.enterWith(undefined);
 }