wave-agent-sdk 0.16.8 → 0.16.10

package/src/prompts/index.ts

@@ -18,9 +18,7 @@ import {
   READ_TOOL_NAME,
   GLOB_TOOL_NAME,
   GREP_TOOL_NAME,
-  TOOL_SEARCH_TOOL_NAME,
 } from "../constants/tools.js";
-import { isDeferredTool } from "../utils/isDeferredTool.js";
 
 export const BASE_SYSTEM_PROMPT = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.`;
 
@@ -260,17 +258,6 @@ export function buildSystemPrompt(
     prompt += `\n\n${TOOL_POLICY}`;
   }
 
-  // List available deferred tool names with descriptions so the model knows they exist
-  // and can decide which ones to discover via ToolSearch
-  const deferredTools = tools.filter(isDeferredTool);
-  if (deferredTools.length > 0) {
-    const lines = deferredTools.map((t) => {
-      const desc = t.config.function?.description;
-      return desc ? `${t.name} - ${desc}` : t.name;
-    });
-    prompt += `\n\n<available-deferred-tools>\n${lines.join("\n")}\nThese tools are NOT loaded yet — call ${TOOL_SEARCH_TOOL_NAME} first to discover their schemas before invoking them.</available-deferred-tools>`;
-  }
-
   prompt += `\n\n${OUTPUT_EFFICIENCY_PROMPT}`;
   prompt += `\n\n${TONE_AND_STYLE_PROMPT}`;
 

package/src/services/authService.ts

@@ -15,12 +15,16 @@ import {
 } from "fs";
 import * as path from "path";
 import * as os from "os";
+import { randomBytes } from "crypto";
 import { createServer, Server } from "http";
 import { URL } from "url";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import type { AuthConfig, AuthUser } from "../types/auth.js";
 
+/** Persistent anonymous ID for telemetry fallback when SSO is not authenticated. */
+let _anonymousId: string | undefined;
+
 const execFileAsync = promisify(execFile);
 
 export class AuthService {
@@ -312,3 +316,55 @@ export class AuthService {
 }
 
 export const authService = AuthService.getInstance();
+
+/**
+ * Get or create a persistent anonymous ID for telemetry.
+ *
+ * Stored in ~/.wave/config.json as { anonymousId: "..." }.
+ * Generated once on first run (32-byte random hex) and reused thereafter.
+ * Falls back to an in-memory ID if file I/O fails.
+ */
+export function getOrCreateAnonymousId(): string {
+  if (_anonymousId) return _anonymousId;
+
+  try {
+    const configPath = path.join(os.homedir(), ".wave", "config.json");
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content) as { anonymousId?: string };
+      if (config.anonymousId) {
+        _anonymousId = config.anonymousId;
+        return _anonymousId;
+      }
+    }
+
+    // Generate and persist
+    _anonymousId = randomBytes(32).toString("hex");
+    const waveDir = path.dirname(configPath);
+    if (!existsSync(waveDir)) {
+      mkdirSync(waveDir, { recursive: true });
+    }
+    const existing = existsSync(configPath)
+      ? (JSON.parse(readFileSync(configPath, "utf-8")) as Record<
+          string,
+          unknown
+        >)
+      : {};
+    writeFileSync(
+      configPath,
+      JSON.stringify({ ...existing, anonymousId: _anonymousId }, null, 2),
+      "utf-8",
+    );
+    chmodSync(configPath, 0o600);
+  } catch {
+    // File I/O failed — use in-memory fallback
+    _anonymousId = randomBytes(32).toString("hex");
+  }
+
+  return _anonymousId;
+}
+
+/** @internal — reset anonymous ID cache for testing only */
+export function __resetAnonymousIdForTesting(): void {
+  _anonymousId = undefined;
+}

package/src/services/configurationService.ts

@@ -44,6 +44,10 @@ import {
 } from "../utils/constants.js";
 import { ClientOptions } from "openai";
 import { parseCustomHeaders } from "../utils/stringUtils.js";
+import {
+  getRemoteSettingsSync,
+  mergeRemoteSettings,
+} from "./remoteSettingsService.js";
 
 /**
  * Default ConfigurationService implementation
@@ -101,19 +105,25 @@ export class ConfigurationService {
         };
       }
 
+      // Merge remote settings (highest priority: Remote > Local > Project > User)
+      const remoteSettings = getRemoteSettingsSync();
+      const finalConfig = remoteSettings
+        ? mergeRemoteSettings(mergedConfig, remoteSettings)
+        : mergedConfig;
+
       // Success case
-      this.currentConfiguration = mergedConfig;
+      this.currentConfiguration = finalConfig;
 
       // Set environment variables from merged config and inject system variables
       const env = {
-        ...(mergedConfig.env || {}),
+        ...(finalConfig.env || {}),
         WAVE_PROJECT_DIR: workdir,
       };
       this.setEnvironmentVars(env);
-      mergedConfig.env = env;
+      finalConfig.env = env;
 
       return {
-        configuration: mergedConfig,
+        configuration: finalConfig,
         success: true,
         sourcePath: "merged configuration",
         warnings: validation.warnings,
@@ -461,8 +471,7 @@ export class ConfigurationService {
     }
 
     // Resolve custom headers from environment: env (settings.json) > process.env
-    const envCustomHeaders =
-      process.env.WAVE_CUSTOM_HEADERS || process.env.WAVE_CUSTOM_HEADERS || "";
+    const envCustomHeaders = process.env.WAVE_CUSTOM_HEADERS || "";
     const parsedEnvHeaders = parseCustomHeaders(envCustomHeaders);
 
     // Merge headers: env headers < options < override
@@ -497,19 +506,16 @@ export class ConfigurationService {
     maxTokens?: number,
     permissionMode?: PermissionMode,
   ): ModelConfig {
-    // Resolve agent model: override > options > env (settings.json) > process.env
+    // Resolve agent model: override > options > process.env (includes settings.json env)
     const resolvedAgentModel =
       model ||
       this.options.model ||
       process.env.WAVE_MODEL ||
-      process.env.WAVE_MODEL;
+      this.currentConfiguration?.model;
 
-    // Resolve fast model: override > options > env (settings.json) > process.env
+    // Resolve fast model: override > options > process.env (includes settings.json env)
     const resolvedFastModel =
-      fastModel ||
-      this.options.fastModel ||
-      process.env.WAVE_FAST_MODEL ||
-      process.env.WAVE_FAST_MODEL;
+      fastModel || this.options.fastModel || process.env.WAVE_FAST_MODEL;
 
     // Validate required fields
     if (!resolvedAgentModel) {
@@ -572,8 +578,7 @@ export class ConfigurationService {
     }
 
     // Try env (settings.json) first, then process.env
-    const envMaxInputTokens =
-      process.env.WAVE_MAX_INPUT_TOKENS || process.env.WAVE_MAX_INPUT_TOKENS;
+    const envMaxInputTokens = process.env.WAVE_MAX_INPUT_TOKENS;
     if (envMaxInputTokens) {
       const parsed = parseInt(envMaxInputTokens, 10);
       if (!isNaN(parsed)) {
@@ -677,8 +682,7 @@ export class ConfigurationService {
     }
 
     // Try env (settings.json) first, then process.env
-    const envMaxOutputTokens =
-      process.env.WAVE_MAX_OUTPUT_TOKENS || process.env.WAVE_MAX_OUTPUT_TOKENS;
+    const envMaxOutputTokens = process.env.WAVE_MAX_OUTPUT_TOKENS;
     if (envMaxOutputTokens) {
       const parsed = parseInt(envMaxOutputTokens, 10);
       if (!isNaN(parsed) && parsed > 0) {
@@ -695,6 +699,28 @@ export class ConfigurationService {
    */
   setModel(model: string): void {
     this.options.model = model;
+    this.persistModelToSettings(model);
+  }
+
+  private async persistModelToSettings(model: string): Promise<void> {
+    const configPath = getUserConfigPaths()[0]; // ~/.wave/settings.json
+    const configDir = path.dirname(configPath);
+    if (!existsSync(configDir)) {
+      await fs.mkdir(configDir, { recursive: true });
+    }
+
+    let config: WaveConfiguration = {};
+    if (existsSync(configPath)) {
+      try {
+        const content = await fs.readFile(configPath, "utf-8");
+        config = JSON.parse(content);
+      } catch {
+        // Start fresh if corrupted
+      }
+    }
+
+    config.model = model;
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
   }
 
   /**
@@ -704,12 +730,16 @@ export class ConfigurationService {
     const models = new Set<string>();
 
     // Add current model from options or environment
-    const currentModel =
-      this.options.model || process.env.WAVE_MODEL || process.env.WAVE_MODEL;
+    const currentModel = this.options.model || process.env.WAVE_MODEL;
     if (currentModel) {
       models.add(currentModel);
     }
 
+    // Persisted model from settings (includes remote-merged)
+    if (this.currentConfiguration?.model) {
+      models.add(this.currentConfiguration.model);
+    }
+
     // Add models from merged configuration
     if (this.currentConfiguration?.models) {
       Object.keys(this.currentConfiguration.models).forEach((model) => {
@@ -1139,6 +1169,7 @@ export function loadWaveConfigFromFile(
       permissions: config.permissions || undefined,
       enabledPlugins: config.enabledPlugins || undefined,
       language: config.language || undefined,
+      model: config.model || undefined,
       autoMemoryEnabled:
         config.autoMemoryEnabled !== undefined
           ? config.autoMemoryEnabled
@@ -1268,6 +1299,11 @@ export function loadMergedWaveConfig(
       mergedConfig.language = config.language;
     }
 
+    // Merge model (last one wins)
+    if (config.model !== undefined) {
+      mergedConfig.model = config.model;
+    }
+
     // Merge autoMemoryEnabled (last one wins)
     if (config.autoMemoryEnabled !== undefined) {
       mergedConfig.autoMemoryEnabled = config.autoMemoryEnabled;
@@ -1316,6 +1352,7 @@ export function loadMergedWaveConfig(
         ? mergedConfig.enabledPlugins
         : undefined,
     language: mergedConfig.language,
+    model: mergedConfig.model,
     autoMemoryEnabled: mergedConfig.autoMemoryEnabled,
     marketplaces:
       mergedConfig.marketplaces &&

package/src/services/initializationService.ts

@@ -22,6 +22,7 @@ import type { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import type { LiveConfigManager } from "../managers/liveConfigManager.js";
 import type { TaskManager } from "./taskManager.js";
 import type { PermissionManager } from "../managers/permissionManager.js";
+import { remoteSettingsService } from "./remoteSettingsService.js";
 
 export interface InitializationContext {
   skillManager: SkillManager;
@@ -288,6 +289,18 @@ export class InitializationService {
       // Don't throw error to prevent app startup failure - continue without live reload
     }
 
+    // Initialize remote settings (fetch server-managed config)
+    try {
+      const phaseStart = performance.now();
+      await remoteSettingsService.initialize();
+      logger?.debug(
+        `Initialization Phase [Remote Settings] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
+    } catch (error) {
+      logger?.error("Failed to initialize remote settings:", error);
+      // Don't throw error to prevent app startup failure - continue without remote settings
+    }
+
     // Memory is lazy-cached on first getCombinedMemoryContent call
     // No explicit loading needed during initialization
 

package/src/services/pluginLoader.ts

@@ -14,7 +14,6 @@ import {
   parseAgentFile,
   type SubagentConfiguration,
 } from "../utils/subagentParser.js";
-import { resolveMcpConfig } from "../managers/mcpManager.js";
 import { logger } from "../utils/globalLogger.js";
 
 export class PluginLoader {
@@ -143,7 +142,8 @@ export class PluginLoader {
     const mcpPath = path.join(pluginPath, ".mcp.json");
     try {
       const content = await fs.readFile(mcpPath, "utf-8");
-      return resolveMcpConfig(JSON.parse(content)) as McpConfig;
+      // Return raw config — let McpManager resolve templates and capture originalUrl
+      return JSON.parse(content) as McpConfig;
     } catch {
       return undefined;
     }

package/src/services/remoteSettingsService.ts

@@ -0,0 +1,314 @@
+import * as fs from "node:fs";
+import { homedir } from "node:os";
+import * as path from "node:path";
+
+import { authService } from "./authService.js";
+import type {
+  RemoteSettingsCache,
+  RemoteSettingsFetchResult,
+  RemoteSettingsResponse,
+} from "../types/configuration.js";
+import type { WaveConfiguration } from "../types/configuration.js";
+import type { HookEvent, HookEventConfig } from "../types/hooks.js";
+import { logger } from "../utils/globalLogger.js";
+
+const CACHE_FILE = path.join(homedir(), ".wave", "remote-settings.json");
+const POLLING_INTERVAL_MS = 60 * 60 * 1000; // 60 minutes
+const FETCH_TIMEOUT_MS = 10_000;
+
+let _cachedSettings: RemoteSettingsCache | null = null;
+let _pollingTimer: ReturnType<typeof setInterval> | null = null;
+
+function loadCacheFromDisk(): void {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) {
+      return;
+    }
+    const raw = fs.readFileSync(CACHE_FILE, "utf-8");
+    const parsed: RemoteSettingsCache = JSON.parse(raw);
+    _cachedSettings = parsed;
+    logger.debug("remoteSettings: loaded cache from disk", {
+      checksum: parsed.checksum,
+    });
+  } catch (err) {
+    logger.debug("remoteSettings: failed to load cache from disk", { err });
+  }
+}
+
+function writeCacheToDisk(): void {
+  if (!_cachedSettings) {
+    return;
+  }
+  try {
+    const dir = path.dirname(CACHE_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(_cachedSettings, null, 2), {
+      mode: 0o600,
+    });
+    logger.debug("remoteSettings: wrote cache to disk", {
+      checksum: _cachedSettings.checksum,
+    });
+  } catch (err) {
+    logger.debug("remoteSettings: failed to write cache to disk", { err });
+  }
+}
+
+function removeCacheFromDisk(): void {
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      fs.unlinkSync(CACHE_FILE);
+    }
+  } catch (err) {
+    logger.debug("remoteSettings: failed to remove cache file", { err });
+  }
+}
+
+async function fetchRemoteSettings(): Promise<RemoteSettingsFetchResult> {
+  if (!authService.isSSOAuthenticated()) {
+    logger.debug("remoteSettings: skipping fetch — not SSO authenticated");
+    return { success: false, error: "Not SSO authenticated" };
+  }
+
+  const token = authService.getSSOToken();
+  const serverUrl = authService.getServerUrl();
+  if (!token || !serverUrl) {
+    return { success: false, error: "Missing SSO token or server URL" };
+  }
+
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+  };
+  if (_cachedSettings?.checksum) {
+    headers["If-None-Match"] = _cachedSettings.checksum;
+  }
+
+  try {
+    const response = await fetch(`${serverUrl}/api/wave/settings`, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+
+    if (response.status === 304) {
+      logger.debug("remoteSettings: 304 unchanged", {
+        checksum: _cachedSettings?.checksum,
+      });
+      return {
+        success: true,
+        settings: _cachedSettings!.settings,
+        checksum: _cachedSettings!.checksum,
+      };
+    }
+
+    if (response.status === 404) {
+      logger.debug("remoteSettings: 404 not configured — clearing stale cache");
+      _cachedSettings = null;
+      removeCacheFromDisk();
+      return { success: true, notConfigured: true, settings: null };
+    }
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      logger.debug("remoteSettings: fetch failed", {
+        status: response.status,
+        body: body.slice(0, 200),
+      });
+      return {
+        success: false,
+        error: `HTTP ${response.status}`,
+        settings: _cachedSettings?.settings ?? null,
+      };
+    }
+
+    const data = (await response.json()) as RemoteSettingsResponse;
+    _cachedSettings = {
+      uuid: data.uuid,
+      checksum: data.checksum,
+      settings: data.settings,
+      fetchedAt: new Date().toISOString(),
+    };
+    writeCacheToDisk();
+    logger.debug("remoteSettings: fetched new settings", {
+      checksum: data.checksum,
+    });
+    return {
+      success: true,
+      settings: data.settings,
+      checksum: data.checksum,
+    };
+  } catch (err) {
+    logger.debug("remoteSettings: network error, using cache", { err });
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      settings: _cachedSettings?.settings ?? null,
+    };
+  }
+}
+
+function startPolling(): void {
+  if (_pollingTimer) {
+    return;
+  }
+  _pollingTimer = setInterval(async () => {
+    try {
+      await fetchRemoteSettings();
+    } catch (err) {
+      logger.debug("remoteSettings: polling fetch error", { err });
+    }
+  }, POLLING_INTERVAL_MS);
+  _pollingTimer.unref();
+}
+
+export function initialize(): void {
+  loadCacheFromDisk();
+  // Fire-and-forget the initial fetch, then start background polling
+  fetchRemoteSettings()
+    .then(() => startPolling())
+    .catch((err) => {
+      logger.debug("remoteSettings: initial fetch failed", { err });
+      startPolling();
+    });
+}
+
+export function getRemoteSettingsSync(): WaveConfiguration | null {
+  return _cachedSettings?.settings ?? null;
+}
+
+export async function refresh(): Promise<RemoteSettingsFetchResult> {
+  // Clear in-memory so we force a fresh fetch
+  _cachedSettings = null;
+  removeCacheFromDisk();
+  return fetchRemoteSettings();
+}
+
+export function clear(): void {
+  _cachedSettings = null;
+  removeCacheFromDisk();
+  if (_pollingTimer) {
+    clearInterval(_pollingTimer);
+    _pollingTimer = null;
+  }
+}
+
+export function shutdown(): void {
+  if (_pollingTimer) {
+    clearInterval(_pollingTimer);
+    _pollingTimer = null;
+  }
+}
+
+function dedupe(arr: string[]): string[] {
+  return [...new Set(arr)];
+}
+
+function mergeHooks(
+  local: Partial<Record<HookEvent, HookEventConfig[]>> | undefined,
+  remote: Partial<Record<HookEvent, HookEventConfig[]>> | undefined,
+): Partial<Record<HookEvent, HookEventConfig[]>> | undefined {
+  if (!remote && !local) {
+    return undefined;
+  }
+  if (!remote) {
+    return local;
+  }
+  if (!local) {
+    return remote;
+  }
+  const merged: Partial<Record<HookEvent, HookEventConfig[]>> = { ...local };
+  for (const [event, remoteHooks] of Object.entries(remote)) {
+    const localHooks = merged[event as HookEvent] ?? [];
+    // Concatenate + dedupe by JSON serialization
+    const combined = [...localHooks, ...(remoteHooks ?? [])];
+    const seen = new Set<string>();
+    merged[event as HookEvent] = combined.filter((h) => {
+      const key = JSON.stringify(h);
+      if (seen.has(key)) {
+        return false;
+      }
+      seen.add(key);
+      return true;
+    });
+  }
+  return merged;
+}
+
+export function mergeRemoteSettings(
+  localMerged: WaveConfiguration,
+  remote: WaveConfiguration,
+): WaveConfiguration {
+  const result: WaveConfiguration = { ...localMerged };
+
+  // env: merge by key, remote wins per-key
+  if (remote.env || localMerged.env) {
+    result.env = { ...localMerged.env, ...remote.env };
+  }
+
+  // permissions
+  if (remote.permissions || localMerged.permissions) {
+    const lp = localMerged.permissions ?? {};
+    const rp = remote.permissions ?? {};
+    result.permissions = {
+      // allow: concatenate + dedupe
+      allow:
+        lp.allow || rp.allow
+          ? dedupe([...(lp.allow ?? []), ...(rp.allow ?? [])])
+          : undefined,
+      // deny: concatenate + dedupe
+      deny:
+        lp.deny || rp.deny
+          ? dedupe([...(lp.deny ?? []), ...(rp.deny ?? [])])
+          : undefined,
+      // permissionMode: remote wins (scalar)
+      permissionMode: rp.permissionMode ?? lp.permissionMode,
+      // additionalDirectories: concatenate + dedupe
+      additionalDirectories:
+        lp.additionalDirectories || rp.additionalDirectories
+          ? dedupe([
+              ...(lp.additionalDirectories ?? []),
+              ...(rp.additionalDirectories ?? []),
+            ])
+          : undefined,
+    };
+    // Clean up undefined keys
+    if (!result.permissions.allow) delete result.permissions.allow;
+    if (!result.permissions.deny) delete result.permissions.deny;
+    if (!result.permissions.permissionMode)
+      delete result.permissions.permissionMode;
+    if (!result.permissions.additionalDirectories)
+      delete result.permissions.additionalDirectories;
+  }
+
+  // hooks: concatenate per-event
+  result.hooks = mergeHooks(localMerged.hooks, remote.hooks);
+
+  // Scalar / last-write-wins fields: remote wins
+  if (remote.language !== undefined) result.language = remote.language;
+  if (remote.model !== undefined) result.model = remote.model;
+  if (remote.autoMemoryEnabled !== undefined)
+    result.autoMemoryEnabled = remote.autoMemoryEnabled;
+  if (remote.autoMemoryFrequency !== undefined)
+    result.autoMemoryFrequency = remote.autoMemoryFrequency;
+  if (remote.models !== undefined) result.models = remote.models;
+  if (remote.marketplaces !== undefined)
+    result.marketplaces = remote.marketplaces;
+  if (remote.enabledPlugins !== undefined)
+    result.enabledPlugins = remote.enabledPlugins;
+
+  return result;
+}
+
+/**
+ * Singleton object for consumers that prefer a namespace-style import.
+ * Usage: import { remoteSettingsService } from "./remoteSettingsService.js"
+ */
+export const remoteSettingsService = {
+  initialize,
+  getRemoteSettingsSync,
+  refresh,
+  clear,
+  shutdown,
+  mergeRemoteSettings,
+} as const;

package/src/telemetry/instrumentation.ts

@@ -18,7 +18,10 @@ import type {
   LogRecordExporter,
   ReadableLogRecord,
 } from "@opentelemetry/sdk-logs";
-import { AuthService } from "../services/authService.js";
+import {
+  AuthService,
+  getOrCreateAnonymousId,
+} from "../services/authService.js";
 
 // Lazy-loaded OTEL modules — only imported when telemetry is initialized
 let sdkNode: typeof import("@opentelemetry/sdk-node") | undefined;
@@ -471,8 +474,11 @@ export function isInitialized(): boolean {
 export { JsonlSpanExporter, JsonlLogExporter };
 
 /**
- * Get telemetry attributes based on the authenticated SSO user.
- * Returns user.id and user.email when SSO authenticated, empty object otherwise.
+ * Get telemetry attributes for the current session.
+ *
+ * Priority:
+ * 1. SSO authenticated → server-provided user.id + user.email
+ * 2. Not authenticated → persistent anonymous ID from ~/.wave/config.json
  */
 export function getTelemetryAttributes(): Record<string, string> {
   try {
@@ -487,5 +493,7 @@ export function getTelemetryAttributes(): Record<string, string> {
   } catch {
     // AuthService not available or not authenticated
   }
-  return {};
+
+  // Fallback to anonymous ID
+  return { "user.id": getOrCreateAnonymousId() };
 }

package/src/tools/buildTool.ts

@@ -24,8 +24,6 @@ export interface ToolDef {
     params: Record<string, unknown>,
     context: ToolContext,
   ) => string;
-  shouldDefer?: boolean;
-  alwaysLoad?: boolean;
   additionalProperties?: boolean;
 }
 
@@ -59,7 +57,5 @@ export function buildTool(def: ToolDef): ToolPlugin {
     execute: def.execute,
     prompt: promptFn,
     formatCompactParams: def.formatCompactParams,
-    shouldDefer: def.shouldDefer ?? false,
-    alwaysLoad: def.alwaysLoad ?? false,
   };
 }

package/src/tools/cronCreateTool.ts

@@ -48,7 +48,6 @@ Returns a job ID you can pass to CronDelete.`;
 
 export const cronCreateTool: ToolPlugin = {
   name: CRON_CREATE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/cronDeleteTool.ts

@@ -7,7 +7,6 @@ const CRON_DELETE_PROMPT = `Cancel a cron job previously scheduled with CronCrea
 
 export const cronDeleteTool: ToolPlugin = {
   name: CRON_DELETE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {