wave-agent-sdk 1.1.2 → 1.1.3

package/dist/managers/aiManager.js

@@ -3,7 +3,7 @@ import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { supportsVision } from "../utils/modelCapabilities.js";
 import { persistToolImages } from "../utils/toolImagePersistence.js";
 import { parseTaskNotificationXml, taskNotificationToXml, } from "../utils/notificationXml.js";
-import { calculateComprehensiveTotalTokens, estimateContextTokens, } from "../utils/tokenCalculation.js";
+import { estimateContextTokens } from "../utils/tokenCalculation.js";
 import { estimateTokens } from "../utils/tokenEstimate.js";
 import { getTaskReminderTurnCounts, maybeInjectTaskReminder, TASK_REMINDER_CONFIG, } from "../utils/taskReminder.js";
 import { createWriteStream, existsSync } from "node:fs";
@@ -370,16 +370,16 @@ export class AIManager {
         return "";
     }
     // Private method to update the displayed token statistics from a response.
-    // The comprehensive value (including cache tokens) is intentionally kept:
-    // it drives cost/usage display. Auto-compaction is NOT decided here — it
-    // happens pre-request via maybeAutoCompactBeforeRequest so that over-limit
-    // requests never go out (aligned with Claude Code's proactive autocompact).
+    // Uses only total_tokens — OpenAI-compatible usage already includes cache
+    // hits there, so adding cache fields would double-count and show an
+    // inflated context percentage. Same semantics as the auto-compaction
+    // threshold (maybeAutoCompactBeforeRequest), keeping display and
+    // compaction judgment consistent.
     updateLatestTotalTokens(usage) {
         if (!usage)
             return;
-        // Update token statistics - display comprehensive token usage including cache tokens
-        const comprehensiveTotalTokens = calculateComprehensiveTotalTokens(usage);
-        this.messageManager.setlatestTotalTokens(comprehensiveTotalTokens);
+        // Update token statistics - display total_tokens (cache fields excluded)
+        this.messageManager.setlatestTotalTokens(usage.total_tokens);
     }
     /**
      * Pre-request auto-compaction check (aligned with Claude Code's

package/dist/managers/liveConfigManager.d.ts

@@ -10,7 +10,7 @@ import { Container } from "../utils/container.js";
 import type { WaveConfiguration } from "../types/configuration.js";
 export interface LiveConfigManagerOptions {
     workdir: string;
-    onReload?: (config: WaveConfiguration) => void;
+    onReload?: (config: WaveConfiguration) => void | Promise<void>;
 }
 export declare class LiveConfigManager {
     private container;

package/dist/managers/liveConfigManager.js

@@ -177,8 +177,11 @@ export class LiveConfigManager {
                 this.permissionManager.updateDeniedRules(this.currentConfiguration.permissions?.deny || []);
                 this.permissionManager.updateAdditionalDirectories(this.currentConfiguration.permissions?.additionalDirectories || []);
             }
-            // Trigger reload callback
-            this.options.onReload?.(this.currentConfiguration);
+            // Trigger reload callback. Awaited so fire-and-forget work spawned by the
+            // callback (e.g. skill rediscovery) completes before the reload resolves —
+            // otherwise Agent.create() can return with a cleared skill map (see race
+            // where refreshSkills() clears skillMetadata before async discoverSkills).
+            await this.options.onReload?.(this.currentConfiguration);
             return this.currentConfiguration;
         }
         catch (error) {

package/dist/utils/containerSetup.js

@@ -221,15 +221,19 @@ export function setupAgentContainer(setupOptions) {
     container.register("CanUseToolCallback", canUseToolWithPermissionRequest);
     const liveConfigManager = new LiveConfigManager(container, {
         workdir,
-        onReload: () => {
+        onReload: async () => {
             const models = configurationService.getConfiguredModels();
             callbacks.onConfiguredModelsChange?.(models);
             // Re-evaluate feature-gated tools (e.g. Artifact behind
             // enableArtifact) so toggling the flag applies without a restart.
             toolManager.reloadFeatureGatedTools();
             // Same gate for the builtin /artifact skill: refresh emits "refreshed"
-            // so slash-command registration follows enableArtifact.
-            void skillManager.reloadFeatureGatedSkills().catch((error) => {
+            // so slash-command registration follows enableArtifact. Awaited (via the
+            // awaited onReload) so skills are re-populated before Agent.create()
+            // returns — reloadFeatureGatedSkills() clears the skill map before
+            // rediscovering asynchronously, which would otherwise expose an empty
+            // skill list to callers right after create().
+            await skillManager.reloadFeatureGatedSkills().catch((error) => {
                 logger.error("Failed to reload feature-gated skills:", error);
             });
         },

package/dist/utils/convertMessagesForAPI.js

@@ -299,7 +299,7 @@ export function convertMessagesForAPI(messages, options) {
                 if (block.type === "task_notification") {
                     contentParts.push({
                         type: "text",
-                        text: taskNotificationToXml(block),
+                        text: `A background agent completed a task:\n${taskNotificationToXml(block)}`,
                     });
                 }
             });

package/dist/utils/messageOperations.js

@@ -482,6 +482,7 @@ export const addNotificationMessageToMessages = ({ messages, taskId, taskType, s
         id: generateMessageId(),
         role: "user",
         blocks: [block],
+        isMeta: true,
         timestamp: new Date().toISOString(),
     };
     return [...messages, notificationMessage];

package/dist/utils/tokenCalculation.d.ts

@@ -1,24 +1,12 @@
 import type { Message, Usage } from "../types/index.js";
 /**
- * Calculate comprehensive total tokens including cache-related tokens
- *
- * This function computes the true total token cost by including:
- * - Base total_tokens (prompt + completion)
- * - Cache read tokens (cost savings indicator)
- * - Cache creation tokens (cache investment)
- *
- * For accurate cost tracking with Claude models that support cache control.
- *
- * @param usage - Usage statistics from AI operation
- * @returns Comprehensive total including all cache-related tokens
- */
-export declare function calculateComprehensiveTotalTokens(usage: Usage): number;
-/**
- * Extract the latest total tokens from the last message with usage data
- * Uses comprehensive calculation that includes cache tokens for accurate tracking
+ * Extract the latest total tokens from the last message with usage data.
+ * Uses only `total_tokens` — OpenAI-compatible usage already includes cache
+ * hits there, so adding cache fields would double-count (same semantics as
+ * the auto-compaction threshold; keeps UI usage display aligned with it).
  *
  * @param messages - Array of messages to search
- * @returns Comprehensive total tokens from the most recent usage data, or 0 if none found
+ * @returns Total tokens from the most recent usage data, or 0 if none found
  */
 export declare function extractLatestTotalTokens(messages: Array<{
     usage?: Usage;

package/dist/utils/tokenCalculation.js

@@ -1,36 +1,19 @@
 import { estimateTokens } from "./tokenEstimate.js";
 /**
- * Calculate comprehensive total tokens including cache-related tokens
- *
- * This function computes the true total token cost by including:
- * - Base total_tokens (prompt + completion)
- * - Cache read tokens (cost savings indicator)
- * - Cache creation tokens (cache investment)
- *
- * For accurate cost tracking with Claude models that support cache control.
- *
- * @param usage - Usage statistics from AI operation
- * @returns Comprehensive total including all cache-related tokens
- */
-export function calculateComprehensiveTotalTokens(usage) {
-    const baseTokens = usage.total_tokens;
-    const cacheReadTokens = usage.cache_read_input_tokens || 0;
-    const cacheCreateTokens = usage.cache_creation_input_tokens || 0;
-    return baseTokens + cacheReadTokens + cacheCreateTokens;
-}
-/**
- * Extract the latest total tokens from the last message with usage data
- * Uses comprehensive calculation that includes cache tokens for accurate tracking
+ * Extract the latest total tokens from the last message with usage data.
+ * Uses only `total_tokens` — OpenAI-compatible usage already includes cache
+ * hits there, so adding cache fields would double-count (same semantics as
+ * the auto-compaction threshold; keeps UI usage display aligned with it).
  *
  * @param messages - Array of messages to search
- * @returns Comprehensive total tokens from the most recent usage data, or 0 if none found
+ * @returns Total tokens from the most recent usage data, or 0 if none found
  */
 export function extractLatestTotalTokens(messages) {
     // Find the last message with usage data (iterate backwards for efficiency)
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
         if (message.usage) {
-            return calculateComprehensiveTotalTokens(message.usage);
+            return message.usage.total_tokens;
         }
     }
     return 0; // No usage data found

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",