wave-agent-sdk 0.11.7 → 0.12.0

package/src/managers/liveConfigManager.ts

@@ -29,6 +29,7 @@ import { logger } from "../utils/globalLogger.js";
 
 export interface LiveConfigManagerOptions {
   workdir: string;
+  onReload?: (config: WaveConfiguration) => void;
 }
 
 export class LiveConfigManager {
@@ -48,7 +49,7 @@ export class LiveConfigManager {
 
   constructor(
     private container: Container,
-    options: LiveConfigManagerOptions,
+    private options: LiveConfigManagerOptions,
   ) {
     this.workdir = options.workdir;
     this.fileWatcher = new FileWatcherService(logger);
@@ -272,6 +273,9 @@ export class LiveConfigManager {
         );
       }
 
+      // Trigger reload callback
+      this.options.onReload?.(this.currentConfiguration);
+
       return this.currentConfiguration;
     } catch (error) {
       const errorMessage = `Configuration reload failed with exception: ${(error as Error).message}`;

package/src/managers/messageManager.ts

@@ -7,9 +7,13 @@ import {
   addBangMessage,
   updateBangInMessage,
   completeBangInMessage,
+  addSlashMessageToMessages,
+  updateSlashBlockInMessage,
   removeLastUserMessage,
   addToolBlockToMessageInMessages,
   UserMessageParams,
+  AddSlashParams,
+  UpdateSlashParams,
   type AgentToolBlockUpdateParams,
   generateMessageId,
 } from "../utils/messageOperations.js";
@@ -50,6 +54,13 @@ export interface MessageManagerCallbacks {
   onAddBangMessage?: (command: string) => void;
   onUpdateBangMessage?: (command: string, output: string) => void;
   onCompleteBangMessage?: (command: string, exitCode: number) => void;
+  // Slash callback
+  onAddSlashMessage?: (
+    params: import("../utils/messageOperations.js").AddSlashParams,
+  ) => void;
+  onUpdateSlashBlock?: (
+    params: import("../utils/messageOperations.js").UpdateSlashParams,
+  ) => void;
   onInfoBlockAdded?: (content: string) => void;
   // Rewind callbacks
   onShowRewind?: () => void;
@@ -583,6 +594,35 @@ export class MessageManager {
     this.callbacks.onCompleteBangMessage?.(command, exitCode);
   }
 
+  // Slash related message operations
+  public addSlashMessage(params: Omit<AddSlashParams, "messages">): string {
+    const id = params.id || generateMessageId();
+    const updatedMessages = addSlashMessageToMessages({
+      messages: this.messages,
+      ...params,
+      id,
+    });
+    this.setMessages(updatedMessages);
+    this.callbacks.onAddSlashMessage?.({
+      messages: updatedMessages,
+      ...params,
+      id,
+    });
+    return id;
+  }
+
+  public updateSlashBlock(params: Omit<UpdateSlashParams, "messages">): void {
+    const updatedMessages = updateSlashBlockInMessage({
+      messages: this.messages,
+      ...params,
+    });
+    this.setMessages(updatedMessages);
+    this.callbacks.onUpdateSlashBlock?.({
+      messages: updatedMessages,
+      ...params,
+    });
+  }
+
   /**
    * Rebuild usage array from messages containing usage metadata
    * Called during session restoration to reconstruct usage tracking

package/src/managers/slashCommandManager.ts

@@ -171,18 +171,21 @@ export class SlashCommandManager {
               args,
             });
 
-            const originalInput = args
-              ? `/${skill.name} ${args}`
-              : `/${skill.name}`;
-
-            // 2. Add user message immediately
-            const messageId = this.messageManager.addUserMessage({
-              content: originalInput,
-              customCommandContent: prepared.content,
+            // 2. Add slash message immediately
+            const messageId = this.messageManager.addSlashMessage({
+              command: skill.name,
+              args,
+              content: prepared.content,
             });
 
             if (!prepared.skill) {
               // If skill not found or invalid, we're done (error message already in prepared.content)
+              this.messageManager.updateSlashBlock({
+                command: skill.name,
+                messageId,
+                stage: "error",
+                error: prepared.content,
+              });
               return;
             }
 
@@ -200,20 +203,6 @@ export class SlashCommandManager {
                 );
               }
 
-              // Add a ToolBlock to the initial command message for progress tracking
-              const toolBlockId = this.messageManager.addToolBlockToMessage(
-                messageId,
-                {
-                  name: subagentType,
-                  parameters: JSON.stringify({
-                    description: skill.description,
-                    prompt: prepared.content,
-                    subagent_type: subagentType,
-                  }),
-                  stage: "running",
-                },
-              );
-
               try {
                 const instance = await this.subagentManager.createInstance(
                   config,
@@ -225,7 +214,7 @@ export class SlashCommandManager {
                   },
                   false,
                   () => {
-                    // Update the tool block with progress
+                    // Update the slash block with progress
                     const subagent = this.subagentManager.getInstance(
                       instance.subagentId,
                     );
@@ -248,8 +237,8 @@ export class SlashCommandManager {
 
                       shortResult += summary;
 
-                      this.messageManager.updateToolBlock({
-                        id: toolBlockId,
+                      this.messageManager.updateSlashBlock({
+                        command: skill.name,
                         messageId,
                         shortResult,
                       });
@@ -264,25 +253,25 @@ export class SlashCommandManager {
                     signal,
                   );
 
-                  // Update the ToolBlock with final result
-                  this.messageManager.updateToolBlock({
-                    id: toolBlockId,
+                  // Update the SlashBlock with final result
+                  this.messageManager.updateSlashBlock({
+                    command: skill.name,
                     messageId,
                     result,
-                    success: true,
-                    stage: "end",
+                    stage: "success",
                   });
                 } finally {
                   this.subagentManager.cleanupInstance(instance.subagentId);
                 }
               } catch (error) {
-                // Update the ToolBlock with error
-                this.messageManager.updateToolBlock({
-                  id: toolBlockId,
+                // Update the SlashBlock with error
+                const isAborted =
+                  error instanceof Error && error.name === "AbortError";
+                this.messageManager.updateSlashBlock({
+                  command: skill.name,
                   messageId,
-                  success: false,
+                  stage: isAborted ? "aborted" : "error",
                   error: error instanceof Error ? error.message : String(error),
-                  stage: "end",
                 });
                 throw error; // Re-throw to be caught by outer catch for logging/error block
               }
@@ -296,8 +285,11 @@ export class SlashCommandManager {
             });
 
             // 4. Update the message with final content
-            this.messageManager.updateUserMessage(messageId, {
-              customCommandContent: result.content,
+            this.messageManager.updateSlashBlock({
+              command: skill.name,
+              messageId,
+              content: result.content,
+              stage: "success",
             });
 
             // 5. Trigger AI response
@@ -498,13 +490,11 @@ export class SlashCommandManager {
     args?: string,
   ): Promise<void> {
     try {
-      // Add custom command message immediately to show the command being executed
-      const originalInput = args
-        ? `/${commandName} ${args}`
-        : `/${commandName}`;
-      const messageId = this.messageManager.addUserMessage({
-        content: originalInput,
-        customCommandContent: content, // Initial content with bash placeholders
+      // Add slash command message immediately to show the command being executed
+      const messageId = this.messageManager.addSlashMessage({
+        command: commandName,
+        args,
+        content, // Initial content with bash placeholders
       });
 
       // Parse bash commands from the content
@@ -521,8 +511,11 @@ export class SlashCommandManager {
       }
 
       // Update the message with final content
-      this.messageManager.updateUserMessage(messageId, {
-        customCommandContent: finalContent,
+      this.messageManager.updateSlashBlock({
+        command: commandName,
+        messageId,
+        content: finalContent,
+        stage: "success",
       });
 
       // Execute the AI conversation with custom configuration

package/src/managers/toolManager.ts

@@ -284,6 +284,7 @@ class ToolManager {
     availableSubagents?: SubagentConfiguration[];
     availableSkills?: SkillMetadata[];
     workdir?: string;
+    isSubagent?: boolean;
   }): ChatCompletionFunctionTool[] {
     const permissionManager =
       this.container.get<PermissionManager>("PermissionManager");

package/src/services/aiService.ts

@@ -135,10 +135,12 @@ function getModelConfig(
     ...baseConfig,
   };
 
-  // Configuration rules for specific models
-  if (modelName.includes("gpt-5")) {
-    // gpt-5 models should not have temperature field
-    delete config.temperature;
+  // Handle parameter exclusion: if a parameter is explicitly set to null, remove it.
+  // This allows users to "unset" default parameters like temperature for models that don't support them.
+  for (const key in config) {
+    if (config[key as keyof OpenAIModelConfig] === null) {
+      delete config[key as keyof OpenAIModelConfig];
+    }
   }
 
   return config;
@@ -261,9 +263,21 @@ export async function callAgent(
     }
 
     // Get model configuration - use injected modelConfig with optional override
+    const {
+      model: _model,
+      fastModel: _fastModel,
+      maxTokens: _maxTokens,
+      permissionMode: _permissionMode,
+      ...extraParams
+    } = modelConfig;
+    void _model;
+    void _fastModel;
+    void _maxTokens;
+    void _permissionMode;
+
     const openaiModelConfig = getModelConfig(model || modelConfig.model, {
-      temperature: 0,
       max_tokens: resolvedMaxTokens,
+      ...extraParams,
     });
 
     // Determine if streaming is needed
@@ -780,9 +794,22 @@ export async function compressMessages(
   });
 
   // Get model configuration - use injected agent model
+  const {
+    model: _model,
+    fastModel: _fastModel,
+    maxTokens: _maxTokens,
+    permissionMode: _permissionMode,
+    ...extraParams
+  } = modelConfig;
+  void _model;
+  void _fastModel;
+  void _maxTokens;
+  void _permissionMode;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 8192,
+    ...extraParams,
   });
 
   try {
@@ -878,9 +905,22 @@ export async function processWebContent(
   });
 
   // Get model configuration - use injected agent model
+  const {
+    model: _model,
+    fastModel: _fastModel,
+    maxTokens: _maxTokens,
+    permissionMode: _permissionMode,
+    ...extraParams
+  } = modelConfig;
+  void _model;
+  void _fastModel;
+  void _maxTokens;
+  void _permissionMode;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 4096,
+    ...extraParams,
   });
 
   try {
@@ -972,9 +1012,22 @@ export async function btw(options: BtwOptions): Promise<BtwResult> {
   });
 
   // Get model configuration - use injected agent model
+  const {
+    model: _model,
+    fastModel: _fastModel,
+    maxTokens: _maxTokens,
+    permissionMode: _permissionMode,
+    ...extraParams
+  } = modelConfig;
+  void _model;
+  void _fastModel;
+  void _maxTokens;
+  void _permissionMode;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 4096,
+    ...extraParams,
   });
 
   try {

package/src/services/configurationService.ts

@@ -275,6 +275,23 @@ export class ConfigurationService {
       result.errors.push("autoMemoryEnabled configuration must be a boolean");
     }
 
+    // Validate models if present
+    if (config.models !== undefined) {
+      if (typeof config.models !== "object" || config.models === null) {
+        result.isValid = false;
+        result.errors.push("models configuration must be an object");
+      } else {
+        for (const [modelName, modelConfig] of Object.entries(config.models)) {
+          if (typeof modelConfig !== "object" || modelConfig === null) {
+            result.isValid = false;
+            result.errors.push(
+              `Configuration for model '${modelName}' must be an object`,
+            );
+          }
+        }
+      }
+    }
+
     return result;
   }
 
@@ -461,12 +478,25 @@ export class ConfigurationService {
     // Resolve max output tokens
     const resolvedMaxTokens = this.resolveMaxOutputTokens(maxTokens);
 
-    return {
+    const baseConfig: ModelConfig = {
       model: resolvedAgentModel,
       fastModel: resolvedFastModel,
       maxTokens: resolvedMaxTokens,
       permissionMode: permissionMode ?? this.options.permissionMode,
     };
+
+    // Merge model-specific settings from configuration
+    const modelSpecificConfig =
+      this.currentConfiguration?.models?.[resolvedAgentModel];
+
+    if (modelSpecificConfig) {
+      return {
+        ...baseConfig,
+        ...modelSpecificConfig,
+      };
+    }
+
+    return baseConfig;
   }
 
   /**
@@ -578,6 +608,40 @@ export class ConfigurationService {
     return DEFAULT_WAVE_MAX_OUTPUT_TOKENS;
   }
 
+  /**
+   * Set the active model in the session
+   */
+  setModel(model: string): void {
+    this.options.model = model;
+  }
+
+  /**
+   * Get all configured models from settings.json and defaults
+   */
+  getConfiguredModels(): string[] {
+    const DEFAULT_AGENT_MODEL = "gemini-3-flash";
+    const models = new Set<string>();
+
+    // Add default model
+    models.add(DEFAULT_AGENT_MODEL);
+
+    // Add current model from options or environment
+    const currentModel =
+      this.options.model || this.env.WAVE_MODEL || process.env.WAVE_MODEL;
+    if (currentModel) {
+      models.add(currentModel);
+    }
+
+    // Add models from merged configuration
+    if (this.currentConfiguration?.models) {
+      Object.keys(this.currentConfiguration.models).forEach((model) => {
+        models.add(model);
+      });
+    }
+
+    return Array.from(models);
+  }
+
   /**
    * Resolve all configuration file paths
    */
@@ -874,6 +938,7 @@ export function loadWaveConfigFromFile(
         config.autoMemoryEnabled !== undefined
           ? config.autoMemoryEnabled
           : undefined,
+      models: config.models || undefined,
     };
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -1001,6 +1066,17 @@ export function loadMergedWaveConfig(
     if (config.autoMemoryEnabled !== undefined) {
       mergedConfig.autoMemoryEnabled = config.autoMemoryEnabled;
     }
+
+    // Merge models
+    if (config.models) {
+      if (!mergedConfig.models) mergedConfig.models = {};
+      for (const [modelName, modelConfig] of Object.entries(config.models)) {
+        if (!mergedConfig.models[modelName]) {
+          mergedConfig.models[modelName] = {};
+        }
+        Object.assign(mergedConfig.models[modelName], modelConfig);
+      }
+    }
   }
 
   return {
@@ -1024,5 +1100,9 @@ export function loadMergedWaveConfig(
         : undefined,
     language: mergedConfig.language,
     autoMemoryEnabled: mergedConfig.autoMemoryEnabled,
+    models:
+      mergedConfig.models && Object.keys(mergedConfig.models).length > 0
+        ? mergedConfig.models
+        : undefined,
   };
 }

package/src/tools/skillTool.ts

@@ -38,10 +38,20 @@ export const skillTool: ToolPlugin = {
     },
   },
 
-  prompt: (args?: { availableSkills?: SkillMetadata[] }) => {
-    const availableSkills = args?.availableSkills?.filter(
+  prompt: (args?: {
+    availableSkills?: SkillMetadata[];
+    isSubagent?: boolean;
+  }) => {
+    let availableSkills = args?.availableSkills?.filter(
       (skill) => !skill.disableModelInvocation,
     );
+
+    if (args?.isSubagent) {
+      availableSkills = availableSkills?.filter(
+        (skill) => skill.context !== "fork",
+      );
+    }
+
     if (!availableSkills || availableSkills.length === 0) {
       return `${SKILL_TOOL_DESCRIPTION} No skills are currently available.`;
     }

package/src/tools/types.ts

@@ -29,6 +29,7 @@ export interface ToolPlugin {
     availableSubagents?: SubagentConfiguration[];
     availableSkills?: SkillMetadata[];
     workdir?: string;
+    isSubagent?: boolean;
   }) => string;
 }
 

package/src/types/agent.ts

@@ -77,6 +77,7 @@ export interface AgentOptions {
    * These rules follow the standard permission rule syntax: `ToolName` or `ToolName(pattern)`.
    */
   disallowedTools?: string[];
+  [key: string]: unknown;
 }
 
 export interface AgentCallbacks
@@ -92,4 +93,6 @@ export interface AgentCallbacks
     tokens: number,
   ) => void;
   onBackgroundCurrentTask?: () => void;
+  onModelChange?: (model: string) => void;
+  onConfiguredModelsChange?: (models: string[]) => void;
 }

package/src/types/config.ts

@@ -19,4 +19,5 @@ export interface ModelConfig {
   fastModel: string;
   maxTokens?: number;
   permissionMode?: PermissionMode;
+  [key: string]: unknown;
 }

package/src/types/configuration.ts

@@ -8,6 +8,7 @@
 
 import type { HookEvent, HookEventConfig } from "./hooks.js";
 import type { PermissionMode } from "./permissions.js";
+import type { ModelConfig } from "./config.js";
 
 export type Scope = "user" | "project" | "local";
 
@@ -34,6 +35,8 @@ export interface WaveConfiguration {
   language?: string;
   /** Whether auto-memory is enabled */
   autoMemoryEnabled?: boolean;
+  /** Model-specific configuration overrides */
+  models?: Record<string, Partial<ModelConfig>>;
 }
 
 /**

package/src/types/messaging.ts

@@ -25,6 +25,7 @@ export type MessageBlock =
   | ToolBlock
   | ImageBlock
   | BangBlock
+  | SlashBlock
   | CompressBlock
   | ReasoningBlock
   | FileHistoryBlock;
@@ -32,10 +33,20 @@ export type MessageBlock =
 export interface TextBlock {
   type: "text";
   content: string;
-  customCommandContent?: string;
   source?: MessageSource;
 }
 
+export interface SlashBlock {
+  type: "slash";
+  command: string;
+  args?: string;
+  content?: string; // The expanded prompt (template + args + bash output)
+  result?: string; // The final output (e.g., from a forked skill)
+  stage: "running" | "success" | "error" | "aborted";
+  error?: string;
+  shortResult?: string; // Progress summary (e.g., "3 tools | 1,234 tokens")
+}
+
 export interface ErrorBlock {
   type: "error";
   content: string;

package/src/utils/configValidator.ts

@@ -5,6 +5,7 @@
 
 import {
   GatewayConfig,
+  ModelConfig,
   ConfigurationError,
   CONFIG_ERRORS,
 } from "../types/index.js";
@@ -89,11 +90,11 @@ export class ConfigValidator {
 
   /**
    * Validates model configuration (basic validation)
-   * @param model - Agent model string
-   * @param fastModel - Fast model string
+   * @param config - Model configuration object
    * @throws ConfigurationError if invalid
    */
-  static validateModelConfig(model: string, fastModel: string): void {
+  static validateModelConfig(config: ModelConfig): void {
+    const { model, fastModel } = config;
     if (!model || typeof model !== "string" || model.trim() === "") {
       throw new ConfigurationError(
         "Agent model must be a non-empty string.",
@@ -123,5 +124,6 @@ export class ConfigValidator {
 export const configValidator = {
   validateGatewayConfig: ConfigValidator.validateGatewayConfig,
   validateMaxInputTokens: ConfigValidator.validateMaxInputTokens,
-  validateModelConfig: ConfigValidator.validateModelConfig,
+  validateModelConfig: (config: ModelConfig) =>
+    ConfigValidator.validateModelConfig(config),
 };

package/src/utils/containerSetup.ts

@@ -246,7 +246,13 @@ export function setupAgentContainer(
   });
   container.register("CanUseToolCallback", canUseToolWithPermissionRequest);
 
-  const liveConfigManager = new LiveConfigManager(container, { workdir });
+  const liveConfigManager = new LiveConfigManager(container, {
+    workdir,
+    onReload: () => {
+      const models = configurationService.getConfiguredModels();
+      callbacks.onConfiguredModelsChange?.(models);
+    },
+  });
   container.register("LiveConfigManager", liveConfigManager);
 
   const subagentManager = new SubagentManager(container, {

package/src/utils/convertMessagesForAPI.ts

@@ -193,10 +193,26 @@ export function convertMessagesForAPI(
         ) {
           contentParts.push({
             type: "text",
-            text: block.customCommandContent || block.content,
+            text: block.content,
           });
         }
 
+        // Handle SlashBlock
+        if (block.type === "slash") {
+          if (block.content && block.content.trim().length > 0) {
+            contentParts.push({
+              type: "text",
+              text: block.content,
+            });
+          }
+          if (block.result && block.result.trim().length > 0) {
+            contentParts.push({
+              type: "text",
+              text: `<local-command-stdout>\n${stripAnsiColors(block.result)}\n</local-command-stdout>`,
+            });
+          }
+        }
+
         // If there is an image, add image content
         if (
           block.type === "image" &&