wave-agent-sdk 1.0.0 → 1.0.1

package/src/managers/messageManager.ts

@@ -37,7 +37,6 @@ import { READ_TOOL_NAME } from "../constants/tools.js";
 import { Container } from "../utils/container.js";
 
 export interface MessageManagerCallbacks {
-  onMessagesChange?: (messages: Message[]) => void;
   onSessionIdChange?: (sessionId: string) => void;
   onLatestTotalTokensChange?: (latestTotalTokens: number) => void;
   onUsagesChange?: (usages: Usage[]) => void;
@@ -64,9 +63,17 @@ export interface MessageManagerCallbacks {
   onCompactBlockAdded?: (content: string) => void;
   onCompactionStateChange?: (isCompacting: boolean) => void;
   // Bang callback
-  onAddBangMessage?: (command: string) => void;
-  onUpdateBangMessage?: (command: string, output: string) => void;
-  onCompleteBangMessage?: (command: string, exitCode: number) => void;
+  onAddBangMessage?: (command: string, messageId: string) => void;
+  onUpdateBangMessage?: (
+    command: string,
+    output: string,
+    messageId: string,
+  ) => void;
+  onCompleteBangMessage?: (
+    command: string,
+    exitCode: number,
+    messageId: string,
+  ) => void;
   onInfoBlockAdded?: (content: string) => void;
   // Rewind callbacks
   onShowRewind?: () => void;
@@ -322,8 +329,6 @@ export class MessageManager {
       this.extractFileReadsFromMessage(messages[messages.length - 1]);
       this.extractSkillInvocationsFromMessage(messages[messages.length - 1]);
     }
-
-    this.callbacks.onMessagesChange?.([...messages]);
   }
 
   /**
@@ -339,6 +344,20 @@ export class MessageManager {
         return;
       }
 
+      // CC-aligned lazy materialization: when the session file has not been
+      // materialized yet (no saved messages) and every unsaved message is a
+      // meta message (isMeta: true, e.g. SessionStart hook context), skip
+      // persistence. Persisting meta-only sessions would create "0 tokens /
+      // No content" ghost entries in the resume list. The meta messages stay
+      // in memory and are flushed together with the first real user/assistant
+      // message (matches CC's pendingEntries buffering).
+      if (
+        this.savedMessageCount === 0 &&
+        unsavedMessages.every((m) => m.isMeta)
+      ) {
+        return;
+      }
+
       // Create session if needed (only when we have messages to save)
       if (this.savedMessageCount === 0) {
         // This is the first time saving messages, so create the session
@@ -622,7 +641,9 @@ export class MessageManager {
       command,
     });
     this.setMessages(updatedMessages);
-    this.callbacks.onAddBangMessage?.(command);
+    // The bang message is appended as the last message
+    const messageId = this.messages[this.messages.length - 1]?.id ?? "";
+    this.callbacks.onAddBangMessage?.(command, messageId);
   }
 
   public updateBangMessage(command: string, output: string): void {
@@ -632,7 +653,8 @@ export class MessageManager {
       output,
     });
     this.setMessages(updatedMessages);
-    this.callbacks.onUpdateBangMessage?.(command, output);
+    const messageId = this.findBangMessageId(command) ?? "";
+    this.callbacks.onUpdateBangMessage?.(command, output, messageId);
   }
 
   public completeBangMessage(
@@ -647,7 +669,25 @@ export class MessageManager {
       output,
     });
     this.setMessages(updatedMessages);
-    this.callbacks.onCompleteBangMessage?.(command, exitCode);
+    const messageId = this.findBangMessageId(command) ?? "";
+    this.callbacks.onCompleteBangMessage?.(command, exitCode, messageId);
+  }
+
+  /**
+   * Find the message ID of the most recent message containing a bang block
+   * for the given command. Bang callbacks do not carry a block ID, so the
+   * message is located by matching the command against bang blocks.
+   */
+  private findBangMessageId(command: string): string | undefined {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      const message = this.messages[i];
+      if (message.role !== "user") continue;
+      const hasBangBlock = message.blocks?.some(
+        (block) => block.type === "bang" && block.command === command,
+      );
+      if (hasBangBlock) return message.id;
+    }
+    return undefined;
   }
 
   public addNotificationMessage(
@@ -700,7 +740,6 @@ export class MessageManager {
   /**
    * Finalize a streaming block of the given type by setting its stage to "end".
    * Fires the corresponding incremental callback with chunk="" to signal finalization.
-   * Does NOT call onMessagesChange — the caller is responsible for that.
    * Returns true if a block was finalized.
    */
   private finalizeStreamingBlock(
@@ -807,8 +846,6 @@ export class MessageManager {
     });
 
     // Note: Subagent-specific callbacks are now handled by SubagentManager
-
-    this.callbacks.onMessagesChange?.([...this.messages]); // Still need to notify of changes
   }
 
   /**
@@ -871,8 +908,6 @@ export class MessageManager {
       accumulated: newAccumulatedReasoning,
       stage: "streaming",
     });
-
-    this.callbacks.onMessagesChange?.([...this.messages]); // Still need to notify of changes
   }
 
   /**
@@ -885,15 +920,8 @@ export class MessageManager {
     const lastMessage = this.messages[this.messages.length - 1];
     if (lastMessage.role !== "assistant") return;
 
-    const textFinalized = this.finalizeStreamingBlock(lastMessage, "text");
-    const reasoningFinalized = this.finalizeStreamingBlock(
-      lastMessage,
-      "reasoning",
-    );
-
-    if (textFinalized || reasoningFinalized) {
-      this.callbacks.onMessagesChange?.([...this.messages]);
-    }
+    this.finalizeStreamingBlock(lastMessage, "text");
+    this.finalizeStreamingBlock(lastMessage, "reasoning");
   }
 
   /**

package/src/managers/subagentManager.ts

@@ -790,6 +790,7 @@ export class SubagentManager {
   private createSubagentCallbacks(subagentId: string) {
     return {
       onUserMessageAdded: (params: UserMessageParams) => {
+        this.refreshSubagentState(subagentId);
         // Forward user message events to parent via SubagentManager callbacks
         if (this.callbacks?.onSubagentUserMessageAdded) {
           this.callbacks.onSubagentUserMessageAdded(subagentId, params);
@@ -797,6 +798,7 @@ export class SubagentManager {
       },
 
       onAssistantMessageAdded: (messageId: string) => {
+        this.refreshSubagentState(subagentId);
         // Forward assistant message events to parent via SubagentManager callbacks
         if (this.callbacks?.onSubagentAssistantMessageAdded) {
           this.callbacks.onSubagentAssistantMessageAdded(subagentId, messageId);
@@ -809,6 +811,7 @@ export class SubagentManager {
         accumulated: string;
         stage: "streaming" | "end";
       }) => {
+        this.refreshSubagentState(subagentId);
         // Forward assistant content updates to parent via SubagentManager callbacks
         if (this.callbacks?.onSubagentAssistantContentUpdated) {
           this.callbacks.onSubagentAssistantContentUpdated({
@@ -823,6 +826,7 @@ export class SubagentManager {
         accumulated: string;
         stage: "streaming" | "end";
       }) => {
+        this.refreshSubagentState(subagentId);
         // Forward assistant reasoning updates to parent via SubagentManager callbacks
         if (this.callbacks?.onSubagentAssistantReasoningUpdated) {
           this.callbacks.onSubagentAssistantReasoningUpdated({
@@ -833,6 +837,7 @@ export class SubagentManager {
       },
 
       onToolBlockUpdated: (params: ToolBlockUpdateCallbackParams) => {
+        this.refreshSubagentState(subagentId);
         const instance = this.instances.get(subagentId);
         if (instance) {
           // Log tool execution to file only when finalized
@@ -852,31 +857,6 @@ export class SubagentManager {
         }
       },
 
-      // These callbacks will be handled by the parent agent
-      onMessagesChange: (messages: Message[]) => {
-        const instance = this.instances.get(subagentId);
-        if (instance) {
-          instance.messages = messages;
-          // Compute usedTools from messages (last 2 tool blocks)
-          const toolBlocks = messages.flatMap(
-            (m) => m.blocks?.filter((b) => b.type === "tool") ?? [],
-          );
-          const last2 = toolBlocks.slice(-2);
-          instance.usedTools = last2.map((tb) => ({
-            name: tb.name ?? "",
-            parameters: tb.parameters ?? "",
-            compactParams: tb.compactParams,
-            stage: tb.stage,
-          }));
-          // Trigger the onUpdate callback if provided
-          instance.onUpdate?.();
-          // Forward subagent message changes to parent via callbacks
-          if (this.callbacks?.onSubagentMessagesChange) {
-            this.callbacks.onSubagentMessagesChange(subagentId, messages);
-          }
-        }
-      },
-
       onLatestTotalTokensChange: (tokens: number) => {
         const instance = this.instances.get(subagentId);
         if (instance) {
@@ -890,6 +870,7 @@ export class SubagentManager {
       },
 
       onErrorBlockAdded: (error: string) => {
+        this.refreshSubagentState(subagentId);
         const instance = this.instances.get(subagentId);
         if (instance?.logStream) {
           instance.logStream.write(
@@ -899,4 +880,34 @@ export class SubagentManager {
       },
     };
   }
+
+  /**
+   * Pull the latest messages from the subagent instance's MessageManager and
+   * refresh the instance's cached messages, usedTools, onUpdate and the
+   * onSubagentMessagesChange forwarding. Triggered by incremental callbacks.
+   */
+  private refreshSubagentState(subagentId: string): void {
+    const instance = this.instances.get(subagentId);
+    if (!instance) return;
+
+    const messages = instance.messageManager.getMessages();
+    instance.messages = messages;
+    // Compute usedTools from messages (last 2 tool blocks)
+    const toolBlocks = messages.flatMap(
+      (m) => m.blocks?.filter((b) => b.type === "tool") ?? [],
+    );
+    const last2 = toolBlocks.slice(-2);
+    instance.usedTools = last2.map((tb) => ({
+      name: tb.name ?? "",
+      parameters: tb.parameters ?? "",
+      compactParams: tb.compactParams,
+      stage: tb.stage,
+    }));
+    // Trigger the onUpdate callback if provided
+    instance.onUpdate?.();
+    // Forward subagent message changes to parent via callbacks
+    if (this.callbacks?.onSubagentMessagesChange) {
+      this.callbacks.onSubagentMessagesChange(subagentId, messages);
+    }
+  }
 }

package/src/prompts/index.ts

@@ -346,10 +346,6 @@ export function formatCompactSummary(summary: string): string {
 }
 
 export const WEB_CONTENT_SYSTEM_PROMPT = `You are a helpful assistant that extracts information from web content. The content is provided in Markdown format.`;
-export const BTW_SYSTEM_PROMPT = `You are a helpful assistant. Answer the user's side question based on the conversation history. 
-Do NOT say things like "Let me try...", "I'll now...", "Let me check...", or promise to take any action. 
-If you don't know the answer, say so - do not offer to look it up or investigate. 
-Simply answer the question with the information you have.`;
 
 export function buildSystemPrompt(
   basePrompt: string | undefined,

package/src/services/aiService.ts

@@ -25,10 +25,8 @@ import * as path from "path";
 
 import {
   WEB_CONTENT_SYSTEM_PROMPT,
-  BTW_SYSTEM_PROMPT,
   type SystemPromptBlock,
 } from "../prompts/index.js";
-import { GOAL_EVALUATION_SYSTEM_PROMPT } from "../constants/goalPrompts.js";
 
 /**
  * Interface for debug data saved during 400 errors
@@ -148,6 +146,18 @@ function getModelConfig(
   return config;
 }
 
+/**
+ * Effective disable-thinking params for a model config. No default: these
+ * params are only sent when the user explicitly configures
+ * `models[X].disableThinkingOptions` (an empty object clears them), so a
+ * gateway that doesn't understand the params is never hit with them.
+ */
+function effectiveDisableThinkingOptions(
+  modelConfig: ModelConfig,
+): Record<string, unknown> | undefined {
+  return modelConfig.disableThinkingOptions;
+}
+
 export interface CallAgentOptions {
   // Resolved configuration
   gatewayConfig: GatewayConfig;
@@ -184,6 +194,10 @@ export interface CallAgentOptions {
     stage?: "start" | "streaming" | "running" | "end";
   }) => void;
   onReasoningUpdate?: (content: string) => void;
+
+  // Disable-thinking params for fast-model subagent calls (merged into the
+  // request; never used in the agent loop).
+  disableThinkingOptions?: Record<string, unknown>;
 }
 
 export interface CallAgentResult {
@@ -238,6 +252,7 @@ export async function callAgent(
     onContentUpdate,
     onToolUpdate,
     onReasoningUpdate,
+    disableThinkingOptions,
   } = options;
 
   // Validate model config at call time
@@ -321,6 +336,7 @@ export async function callAgent(
     const openaiModelConfig = getModelConfig(model || modelConfig.model, {
       max_tokens: resolvedMaxTokens,
       ...(modelConfig.options || {}),
+      ...(disableThinkingOptions ?? {}),
     });
 
     // Determine if streaming is needed
@@ -842,10 +858,17 @@ export async function processWebContent(
     ? modelConfig.fastModelOptions || {}
     : modelConfig.options || {};
 
+  // Disable-thinking params only apply to the fast-model override path;
+  // the agent-model path is untouched.
+  const disableThinking = options.model
+    ? effectiveDisableThinkingOptions(modelConfig)
+    : undefined;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 4096,
     ...activeExtraParams,
+    ...(disableThinking || {}),
   });
 
   try {
@@ -894,204 +917,3 @@ export async function processWebContent(
   }
 }
 
-export interface BtwOptions {
-  // Resolved configuration
-  gatewayConfig: GatewayConfig;
-  modelConfig: ModelConfig;
-
-  // Parameters
-  messages: ChatCompletionMessageParam[];
-  question: string;
-  abortSignal?: AbortSignal;
-  model?: string;
-}
-
-export interface BtwResult {
-  content: string;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
-
-export async function btw(options: BtwOptions): Promise<BtwResult> {
-  const { gatewayConfig, modelConfig, messages, question, abortSignal } =
-    options;
-
-  // Validate model config at call time
-  validateModelConfig(modelConfig);
-
-  // Apply global 1 QPS rate limit
-  if (
-    process.env.NODE_ENV !== "test" ||
-    modelConfig.model === "rate-limit-test"
-  ) {
-    await acquireSlot(abortSignal);
-  }
-
-  // Create OpenAI client with injected configuration
-  const openai = new OpenAIClient({
-    apiKey: gatewayConfig.apiKey,
-    baseURL: gatewayConfig.baseURL,
-    defaultHeaders: gatewayConfig.defaultHeaders,
-    fetchOptions: gatewayConfig.fetchOptions,
-    fetch: gatewayConfig.fetch,
-  });
-
-  const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
-    temperature: 0.1,
-    max_tokens: 4096,
-    ...(modelConfig.options || {}),
-  });
-
-  try {
-    const response = await openai.chat.completions.create(
-      {
-        ...openaiModelConfig,
-        messages: [
-          {
-            role: "system",
-            content: BTW_SYSTEM_PROMPT,
-          },
-          ...messages,
-          {
-            role: "user",
-            content: question,
-          },
-        ],
-      },
-      {
-        signal: abortSignal,
-      },
-    );
-
-    const result = response.choices[0]?.message?.content?.trim();
-    if (!result) {
-      throw new Error(
-        "Failed to process side question: Empty response from AI",
-      );
-    }
-    const usage = response.usage
-      ? {
-          prompt_tokens: response.usage.prompt_tokens,
-          completion_tokens: response.usage.completion_tokens,
-          total_tokens: response.usage.total_tokens,
-        }
-      : undefined;
-
-    return {
-      content: result,
-      usage,
-    };
-  } catch (error) {
-    if ((error as Error).name === "AbortError") {
-      logger.info("Side question request was aborted");
-      throw new Error("Side question request was aborted");
-    }
-    logger.error("Failed to process side question:", error);
-    throw error;
-  }
-}
-
-export interface EvaluateGoalOptions {
-  gatewayConfig: GatewayConfig;
-  modelConfig: ModelConfig;
-  model: string;
-  goalCondition: string;
-  messages: ChatCompletionMessageParam[];
-  abortSignal?: AbortSignal;
-}
-
-export interface EvaluateGoalResult {
-  content: string;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
-
-export async function evaluateGoal(
-  options: EvaluateGoalOptions,
-): Promise<EvaluateGoalResult> {
-  const {
-    gatewayConfig,
-    modelConfig,
-    model,
-    goalCondition,
-    messages,
-    abortSignal,
-  } = options;
-
-  // Create OpenAI client with injected configuration (no rate limiter — bypasses 1 QPS)
-  const openai = new OpenAIClient({
-    apiKey: gatewayConfig.apiKey,
-    baseURL: gatewayConfig.baseURL,
-    defaultHeaders: gatewayConfig.defaultHeaders,
-    fetchOptions: gatewayConfig.fetchOptions,
-    fetch: gatewayConfig.fetch,
-  });
-
-  const openaiModelConfig = getModelConfig(model, {
-    temperature: 0,
-    max_tokens: 200,
-    ...(modelConfig.fastModelOptions || {}),
-  });
-
-  // Strip images from messages to reduce token usage (same as compact)
-  const cleanedMessages = messages.map((msg) => {
-    if (Array.isArray(msg.content)) {
-      const textParts = msg.content.filter(
-        (part) => part.type === "text",
-      ) as import("openai/resources.js").ChatCompletionContentPartText[];
-      const text = textParts.map((p) => p.text).join("\n");
-      return { ...msg, content: text || "(empty message)" };
-    }
-    return msg;
-  });
-
-  try {
-    const response = await openai.chat.completions.create(
-      {
-        ...openaiModelConfig,
-        messages: [
-          {
-            role: "system",
-            content: GOAL_EVALUATION_SYSTEM_PROMPT,
-          },
-          ...cleanedMessages,
-          {
-            role: "user",
-            content: `Goal condition: ${goalCondition}\n\nHas this goal been achieved based on the conversation above?`,
-          },
-        ],
-      },
-      {
-        signal: abortSignal,
-      },
-    );
-
-    const result = response.choices[0]?.message?.content?.trim();
-    if (!result) {
-      throw new Error("Goal evaluation returned empty response");
-    }
-
-    const usage = response.usage
-      ? {
-          prompt_tokens: response.usage.prompt_tokens,
-          completion_tokens: response.usage.completion_tokens,
-          total_tokens: response.usage.total_tokens,
-        }
-      : undefined;
-
-    return { content: result, usage };
-  } catch (error) {
-    if ((error as Error).name === "AbortError") {
-      logger.info("Goal evaluation was aborted");
-      throw new Error("Goal evaluation was aborted");
-    }
-    logger.error("Goal evaluation failed:", error);
-    throw error;
-  }
-}