wave-agent-sdk 0.16.8 → 0.16.10

package/src/tools/cronListTool.ts

@@ -7,7 +7,6 @@ const CRON_LIST_PROMPT = `List all cron jobs scheduled via CronCreate in this se
 
 export const cronListTool: ToolPlugin = {
   name: CRON_LIST_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/enterWorktreeTool.ts

@@ -48,7 +48,6 @@ export const ENTER_WORKTREE_TOOL_PROMPT = `Use this tool ONLY when the user expl
 
 export const enterWorktreeTool: ToolPlugin = {
   name: ENTER_WORKTREE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/exitWorktreeTool.ts

@@ -47,7 +47,6 @@ If called outside an EnterWorktree session, the tool is a **no-op**: it reports
 
 export const exitWorktreeTool: ToolPlugin = {
   name: EXIT_WORKTREE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/taskManagementTools.ts

@@ -9,7 +9,6 @@ import {
 
 export const taskCreateTool: ToolPlugin = {
   name: TASK_CREATE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {
@@ -144,7 +143,6 @@ NOTE that you should not use this tool if there is only one trivial task to do.
 
 export const taskGetTool: ToolPlugin = {
   name: TASK_GET_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {
@@ -204,7 +202,6 @@ Returns full task details:
 
 export const taskUpdateTool: ToolPlugin = {
   name: TASK_UPDATE_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {
@@ -559,7 +556,6 @@ Set up task dependencies:
 
 export const taskListTool: ToolPlugin = {
   name: TASK_LIST_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/tools/types.ts

@@ -31,21 +31,6 @@ export interface ToolPlugin {
     workdir?: string;
     isSubagent?: boolean;
   }) => string;
-  /**
-   * When true, this tool is deferred — it's not sent to the API until the model
-   * discovers it via ToolSearch. MCP tools are always deferred.
-   */
-  shouldDefer?: boolean;
-  /**
-   * When true, this tool is never deferred — its full schema always appears in
-   * the initial prompt even when tool search is enabled.
-   */
-  alwaysLoad?: boolean;
-  /**
-   * When true, this is an MCP tool (auto-set by McpManager). MCP tools are
-   * always deferred unless they have alwaysLoad: true.
-   */
-  isMcp?: boolean;
 }
 
 export interface ToolResult {

package/src/tools/webFetchTool.ts

@@ -103,7 +103,6 @@ const GITHUB_URL_ERROR =
 
 export const webFetchTool: ToolPlugin = {
   name: WEB_FETCH_TOOL_NAME,
-  shouldDefer: true,
   config: {
     type: "function",
     function: {

package/src/types/configuration.ts

@@ -44,6 +44,8 @@ export interface WaveConfiguration {
   autoMemoryEnabled?: boolean;
   /** Frequency of auto-memory extraction turns */
   autoMemoryFrequency?: number;
+  /** Persisted model selection (from /model command) */
+  model?: string;
   /** Model-specific configuration overrides */
   models?: Record<string, Partial<ModelConfig>>;
   /** Scoped marketplace declarations */
@@ -138,3 +140,24 @@ interface Logger {
   info: (...args: unknown[]) => void;
   debug: (...args: unknown[]) => void;
 }
+
+export interface RemoteSettingsResponse {
+  uuid: string;
+  checksum: string;
+  settings: WaveConfiguration;
+}
+
+export interface RemoteSettingsCache {
+  uuid: string;
+  checksum: string;
+  settings: WaveConfiguration;
+  fetchedAt: string;
+}
+
+export interface RemoteSettingsFetchResult {
+  success: boolean;
+  settings?: WaveConfiguration | null;
+  checksum?: string;
+  error?: string;
+  notConfigured?: boolean;
+}

package/src/types/mcp.ts

@@ -26,7 +26,14 @@ export interface McpTool {
 export interface McpServerStatus {
   name: string;
   config: McpServerConfig;
-  status: "disconnected" | "connected" | "connecting" | "error";
+  /** Pre-resolution URL with template variables (e.g. ${WAVE_SSO_TOKEN}) preserved for safe display */
+  originalUrl?: string;
+  status:
+    | "disconnected"
+    | "connected"
+    | "connecting"
+    | "reconnecting"
+    | "error";
   tools?: McpTool[];
   toolCount?: number;
   capabilities?: string[];

package/src/utils/containerSetup.ts

@@ -39,6 +39,7 @@ import type {
 
 import { logger } from "./globalLogger.js";
 import { authService } from "../services/authService.js";
+import { remoteSettingsService } from "../services/remoteSettingsService.js";
 
 export interface AgentContainerSetupOptions {
   options: AgentOptions;
@@ -170,6 +171,15 @@ export function setupAgentContainer(
     }
   });
 
+  // Wire up auth change callback to refresh/clear remote settings
+  authService.onAuthChange((event) => {
+    if (event === "login") {
+      remoteSettingsService.refresh();
+    } else if (event === "logout") {
+      remoteSettingsService.clear();
+    }
+  });
+
   const lspManager = options.lspManager || new LspManager(container);
   container.register("LspManager", lspManager);
 

package/src/utils/mcpUtils.ts

@@ -91,7 +91,6 @@ export function createMcpToolPlugin(
   return {
     name: prefixedName,
     config: mcpToolToOpenAITool(mcpTool, serverName),
-    isMcp: true, // MCP tools are always deferred
     async execute(
       args: Record<string, unknown>,
       context?: ToolContext,

package/src/utils/openaiClient.ts

@@ -176,8 +176,11 @@ export class OpenAIClient {
       error.status = response.status;
       error.body = errorBody;
 
-      if (response.status === 429 && attempt < maxRetries) {
-        logger.warn("OpenAI API 429 Too Many Requests, retrying...", {
+      const retryableStatus =
+        response.status === 429 ||
+        (response.status >= 500 && response.status !== 501);
+      if (retryableStatus && attempt < maxRetries) {
+        logger.warn("OpenAI API error, retrying...", {
           attempt: attempt + 1,
           status: response.status,
         });

package/dist/tools/toolSearchTool.d.ts

@@ -1,15 +0,0 @@
-/**
- * ToolSearchTool - Discovers deferred tool schemas on demand.
- *
- * When tool deferral is enabled, deferred tools are not sent to the API.
- * The model must call this tool to discover a deferred tool's full schema
- * before it can invoke it.
- *
- * Query formats:
- * - "select:ToolName" — direct selection by name (comma-separated for multiple)
- * - "notebook jupyter" — keyword search, up to max_results best matches
- * - "+slack send" — require "slack" in the name, rank by remaining terms
- */
-import { ToolPlugin } from "./types.js";
-export declare const toolSearchTool: ToolPlugin;
-//# sourceMappingURL=toolSearchTool.d.ts.map

package/dist/tools/toolSearchTool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toolSearchTool.d.ts","sourceRoot":"","sources":["../../src/tools/toolSearchTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AA4GjE,eAAO,MAAM,cAAc,EAAE,UAuH5B,CAAC"}

package/dist/tools/toolSearchTool.js

@@ -1,200 +0,0 @@
-/**
- * ToolSearchTool - Discovers deferred tool schemas on demand.
- *
- * When tool deferral is enabled, deferred tools are not sent to the API.
- * The model must call this tool to discover a deferred tool's full schema
- * before it can invoke it.
- *
- * Query formats:
- * - "select:ToolName" — direct selection by name (comma-separated for multiple)
- * - "notebook jupyter" — keyword search, up to max_results best matches
- * - "+slack send" — require "slack" in the name, rank by remaining terms
- */
-import { isDeferredTool, TOOL_SEARCH_TOOL_NAME, } from "../utils/isDeferredTool.js";
-function formatSchema(tool) {
-    const desc = tool.config.function.description || "";
-    const params = JSON.stringify(tool.config.function.parameters || {}, null, 2);
-    return `${tool.name}: ${desc}\nParameters: ${params}`;
-}
-/**
- * Parse tool name into searchable parts (handles CamelCase and underscores).
- */
-function parseToolName(name) {
-    return name
-        .replace(/([a-z])([A-Z])/g, "$1 $2") // CamelCase to spaces
-        .replace(/_/g, " ")
-        .toLowerCase()
-        .split(/\s+/)
-        .filter(Boolean);
-}
-/**
- * Keyword search over deferred tools by name and description.
- * Matches Claude Code's scoring: required terms (+prefix) must all match,
- * optional terms contribute to ranking.
- */
-function keywordSearch(query, deferredTools, maxResults) {
-    const queryLower = query.toLowerCase().trim();
-    const queryTerms = queryLower.split(/\s+/).filter(Boolean);
-    // Exact match fast path
-    const exact = deferredTools.find((t) => t.name.toLowerCase() === queryLower);
-    if (exact)
-        return [exact];
-    // Partition into required (+prefixed) and optional terms
-    const requiredTerms = [];
-    const optionalTerms = [];
-    for (const term of queryTerms) {
-        if (term.startsWith("+") && term.length > 1) {
-            requiredTerms.push(term.slice(1));
-        }
-        else {
-            optionalTerms.push(term);
-        }
-    }
-    const allScoringTerms = requiredTerms.length > 0
-        ? [...requiredTerms, ...optionalTerms]
-        : queryTerms;
-    // Pre-filter to tools matching ALL required terms
-    let candidateTools = deferredTools;
-    if (requiredTerms.length > 0) {
-        candidateTools = deferredTools.filter((tool) => {
-            const parts = parseToolName(tool.name);
-            const desc = (tool.config.function.description || "").toLowerCase();
-            return requiredTerms.every((term) => parts.includes(term) ||
-                parts.some((p) => p.includes(term)) ||
-                desc.includes(term));
-        });
-    }
-    // Score each tool
-    const scored = candidateTools
-        .map((tool) => {
-        const parts = parseToolName(tool.name);
-        const desc = (tool.config.function.description || "").toLowerCase();
-        let score = 0;
-        for (const term of allScoringTerms) {
-            // Exact part match (high weight)
-            if (parts.includes(term)) {
-                score += tool.isMcp ? 12 : 10;
-            }
-            else if (parts.some((p) => p.includes(term))) {
-                score += tool.isMcp ? 6 : 5;
-            }
-            // Full name fallback
-            if (tool.name.toLowerCase().includes(term) && score === 0) {
-                score += 3;
-            }
-            // Description match
-            if (desc.includes(term)) {
-                score += 2;
-            }
-        }
-        return { tool, score };
-    })
-        .filter((s) => s.score > 0)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, maxResults)
-        .map((s) => s.tool);
-    return scored;
-}
-export const toolSearchTool = {
-    name: TOOL_SEARCH_TOOL_NAME,
-    config: {
-        type: "function",
-        function: {
-            name: TOOL_SEARCH_TOOL_NAME,
-            description: `Fetches full schema definitions for deferred tools so they can be called.
-
-Deferred tools appear by name and description in <available-deferred-tools> messages. The full parameter schema is NOT loaded yet — use this tool to fetch it before invoking a deferred tool. This tool takes a query, matches it against the deferred tool list, and returns the matched tools' complete JSONSchema definitions inside a <functions> block. Once a tool's schema appears in that result, it is callable exactly like any tool defined at the top of the prompt.
-
-Result format: each matched tool appears as one <function>{"description": "...", "name": "...", "parameters": {...}}`,
-            parameters: {
-                type: "object",
-                properties: {
-                    query: {
-                        type: "string",
-                        description: 'Search query for finding deferred tools. Supports: "select:ToolName" for direct lookup, or keyword search like "notebook jupyter". Use "+term" to require a term (e.g. "+slack send").',
-                    },
-                    max_results: {
-                        type: "number",
-                        description: "Maximum number of results to return for keyword search (default: 5).",
-                    },
-                },
-                required: ["query"],
-                additionalProperties: false,
-            },
-        },
-    },
-    shouldDefer: false, // Always available
-    execute: async (args, context) => {
-        const { query, max_results = 5 } = args;
-        if (!query) {
-            return {
-                success: false,
-                content: "",
-                error: "Missing required 'query' parameter",
-            };
-        }
-        if (!context.toolManager) {
-            return {
-                success: false,
-                content: "",
-                error: "ToolManager not available in context",
-            };
-        }
-        const allTools = context.toolManager.list();
-        const deferredTools = allTools.filter(isDeferredTool);
-        // Handle select: prefix
-        const selectMatch = query.match(/^select:(.+)$/i);
-        if (selectMatch) {
-            const requested = selectMatch[1]
-                .split(",")
-                .map((s) => s.trim())
-                .filter(Boolean);
-            const found = [];
-            const missing = [];
-            for (const toolName of requested) {
-                const tool = deferredTools.find((t) => t.name === toolName) ??
-                    allTools.find((t) => t.name === toolName);
-                if (tool) {
-                    if (!found.some((f) => f.name === tool.name))
-                        found.push(tool);
-                }
-                else {
-                    missing.push(toolName);
-                }
-            }
-            if (found.length === 0) {
-                return {
-                    success: false,
-                    content: "",
-                    error: `No matching deferred tools found for: ${missing.join(", ")}`,
-                };
-            }
-            const result = found.map(formatSchema).join("\n\n---\n\n");
-            const shortResult = `Discovered tools: ${found.map((t) => t.name).join(", ")}`;
-            return {
-                success: true,
-                content: result,
-                shortResult,
-            };
-        }
-        // Keyword search
-        const matches = keywordSearch(query, deferredTools, max_results);
-        if (matches.length === 0) {
-            return {
-                success: false,
-                content: "",
-                error: `No matching deferred tools found for query: "${query}". Available deferred tools: ${getDeferredToolNamesList(deferredTools)}`,
-            };
-        }
-        const result = matches.map(formatSchema).join("\n\n---\n\n");
-        const shortResult = `Found ${matches.length} tools: ${matches.map((t) => t.name).join(", ")}`;
-        return {
-            success: true,
-            content: result,
-            shortResult,
-        };
-    },
-};
-function getDeferredToolNamesList(tools) {
-    return tools.map((t) => t.name).join(", ");
-}

package/dist/utils/isDeferredTool.d.ts

@@ -1,19 +0,0 @@
-/**
- * Determines if a tool should be deferred (not sent to the API until discovered).
- *
- * A tool is deferred if:
- * - It has shouldDefer: true
- * - It is an MCP tool (isMcp: true)
- *
- * A tool is NEVER deferred if:
- * - It has alwaysLoad: true
- * - It is the ToolSearch tool itself (must always be available)
- */
-import type { ToolPlugin } from "../tools/types.js";
-export declare const TOOL_SEARCH_TOOL_NAME = "ToolSearch";
-export declare function isDeferredTool(tool: ToolPlugin): boolean;
-/**
- * Get the list of deferred tool names from a tools array.
- */
-export declare function getDeferredToolNames(tools: ToolPlugin[]): string[];
-//# sourceMappingURL=isDeferredTool.d.ts.map

package/dist/utils/isDeferredTool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isDeferredTool.d.ts","sourceRoot":"","sources":["../../src/utils/isDeferredTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,eAAO,MAAM,qBAAqB,eAAe,CAAC;AAElD,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAYxD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,EAAE,CAElE"}

package/dist/utils/isDeferredTool.js

@@ -1,31 +0,0 @@
-/**
- * Determines if a tool should be deferred (not sent to the API until discovered).
- *
- * A tool is deferred if:
- * - It has shouldDefer: true
- * - It is an MCP tool (isMcp: true)
- *
- * A tool is NEVER deferred if:
- * - It has alwaysLoad: true
- * - It is the ToolSearch tool itself (must always be available)
- */
-export const TOOL_SEARCH_TOOL_NAME = "ToolSearch";
-export function isDeferredTool(tool) {
-    // Never defer if explicitly marked as alwaysLoad
-    if (tool.alwaysLoad === true)
-        return false;
-    // Never defer ToolSearch itself — the model needs it to discover other tools
-    if (tool.name === TOOL_SEARCH_TOOL_NAME)
-        return false;
-    // MCP tools are always deferred (workflow-specific, potentially many)
-    if (tool.isMcp === true)
-        return true;
-    // Defer if marked with shouldDefer flag
-    return tool.shouldDefer === true;
-}
-/**
- * Get the list of deferred tool names from a tools array.
- */
-export function getDeferredToolNames(tools) {
-    return tools.filter(isDeferredTool).map((t) => t.name);
-}