wave-agent-sdk 1.0.7 → 1.0.8

package/dist/utils/bashParser.d.ts

@@ -46,6 +46,12 @@ export interface ToolRule {
     depth: number;
     scopeFlags?: string[];
 }
+/**
+ * Global scope flags for git that only change the target repository or
+ * configuration, not the subcommand being run. Shared by TOOL_RULES (smart
+ * prefix extraction) and stripGitScopePrefix (rule matching).
+ */
+export declare const GIT_SCOPE_FLAGS: string[];
 export declare const TOOL_RULES: Record<string, ToolRule>;
 /**
  * Registry of dangerous subcommands for specific tools.
@@ -71,6 +77,14 @@ export declare function hasProcessSubstitution(command: string): boolean;
  * sed -i modifies files in place and must NOT be auto-allowed. FR-019.5.
  */
 export declare function hasSedInPlace(command: string): boolean;
+/**
+ * Removes leading git global scope flags (e.g. `git -C <path>`, `git -c <key>=<value>`,
+ * `git --git-dir <path>`) from a command string, so that `git -C /tmp/foo status` is
+ * classified the same as `git status`. Only the leading sequence before the git
+ * subcommand is stripped; the remainder is re-joined with single spaces.
+ * Returns the input unchanged when nothing is stripped.
+ */
+export declare function stripGitScopePrefix(command: string): string;
 /**
  * Extracts a "smart prefix" from a bash command based on common developer tools.
  * Returns null if the command is blacklisted or cannot be safely prefix-matched.

package/dist/utils/bashParser.js

@@ -500,6 +500,18 @@ export const READ_ONLY_COMMANDS = [
     "bc",
     "sleep",
 ];
+/**
+ * Global scope flags for git that only change the target repository or
+ * configuration, not the subcommand being run. Shared by TOOL_RULES (smart
+ * prefix extraction) and stripGitScopePrefix (rule matching).
+ */
+export const GIT_SCOPE_FLAGS = [
+    "-C",
+    "-c",
+    "--directory",
+    "--work-tree",
+    "--git-dir",
+];
 export const TOOL_RULES = {
     // Node/JS
     npm: { depth: 2, scopeFlags: ["--prefix", "-C", "--registry"] },
@@ -517,7 +529,7 @@ export const TOOL_RULES = {
     // Git
     git: {
         depth: 2,
-        scopeFlags: ["-C", "-c", "--directory", "--work-tree", "--git-dir"],
+        scopeFlags: GIT_SCOPE_FLAGS,
     },
     // Python
     python: { depth: 2 },
@@ -670,6 +682,38 @@ export function hasSedInPlace(command) {
         return false;
     return tokens.some((token) => /^-i(\..*)?$/.test(token));
 }
+/**
+ * Removes leading git global scope flags (e.g. `git -C <path>`, `git -c <key>=<value>`,
+ * `git --git-dir <path>`) from a command string, so that `git -C /tmp/foo status` is
+ * classified the same as `git status`. Only the leading sequence before the git
+ * subcommand is stripped; the remainder is re-joined with single spaces.
+ * Returns the input unchanged when nothing is stripped.
+ */
+export function stripGitScopePrefix(command) {
+    const trimmed = command.trim();
+    if (!/^git(?:\s|$)/.test(trimmed))
+        return command;
+    const tokens = trimmed.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    if (tokens.length === 0 || tokens[0] !== "git")
+        return command;
+    let i = 1;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        const eqIndex = token.indexOf("=");
+        const flag = eqIndex > 0 ? token.slice(0, eqIndex) : token;
+        if (!GIT_SCOPE_FLAGS.includes(flag))
+            break;
+        if (eqIndex > 0) {
+            i++; // --flag=value form carries its own value
+        }
+        else {
+            i += 2; // skip the flag and its argument
+        }
+    }
+    if (i === 1)
+        return command;
+    return ["git", ...tokens.slice(i)].join(" ");
+}
 /**
  * Extracts a "smart prefix" from a bash command based on common developer tools.
  * Returns null if the command is blacklisted or cannot be safely prefix-matched.

package/dist/utils/convertMessagesForAPI.js

@@ -158,14 +158,38 @@ export function convertMessagesForAPI(messages, options) {
                     tool_calls = undefined;
                 }
             }
-            // Construct assistant message - only add if there is meaningful content or tool calls
+            // Construct assistant message - only add if there is meaningful content,
+            // tool calls, or reasoning content. Reasoning-only messages (a truncated
+            // turn that produced nothing but thinking) must be preserved so the next
+            // round can continue from the previous reasoning instead of starting
+            // over (aligned with Claude Code's thinking trajectory preservation).
             const hasContent = content && content.trim().length > 0;
             const hasToolCalls = tool_calls && tool_calls.length > 0;
-            if (hasContent || hasToolCalls) {
+            const hasReasoning = reasoning_content && reasoning_content.trim().length > 0;
+            if (hasContent || hasToolCalls || hasReasoning) {
+                // OpenAI-compatible upstreams reject assistant messages where neither
+                // content nor tool_calls is set — a reasoning_content-only message
+                // gets stripped and returns 400 "content or tool_calls must be set"
+                // (this is fine for Claude Code, whose thinking blocks ARE content).
+                // When a turn produced only thinking (interrupted/truncated
+                // mid-reasoning), the thinking stays on its native reasoning_content
+                // field (the channel reasoning models natively continue from), and
+                // content carries an explanatory note so the request stays valid and
+                // the model knows the thinking was cut off and auto-preserved.
+                // Tool calls are meaningful content of their own — a reasoning +
+                // tool-call turn is not truncated, so no note is injected.
+                const fallbackContent = hasContent
+                    ? content
+                    : hasReasoning && !hasToolCalls
+                        ? "[Note: The reasoning above was cut off before completion. It was auto-preserved from an interrupted or truncated turn — continue from where it left off, or disregard it if no longer relevant.]"
+                        : undefined;
                 const assistantMessage = {
                     role: "assistant",
-                    content: hasContent ? content : undefined,
+                    content: fallbackContent,
                     tool_calls,
+                    // Sent whenever reasoning exists: alongside real text it is the
+                    // turn's own thinking; in the fallback case it carries the
+                    // preserved thinking itself (content only holds the note).
                     ...(reasoning_content ? { reasoning_content } : {}),
                     ...(message.additionalFields ? { ...message.additionalFields } : {}),
                 };
@@ -196,12 +220,25 @@ export function convertMessagesForAPI(messages, options) {
                             type: "text",
                             text: "[User shared an image, but the current model does not support image recognition]",
                         });
+                        // Append source path metadata for local-file images so the main
+                        // model can delegate recognition to a vision subagent (which
+                        // reads the path with the Read tool). Inline dataURLs are
+                        // skipped — only persisted paths are delegatable.
+                        block.imageUrls.forEach((imageUrl) => {
+                            if (!imageUrl.startsWith("data:image/")) {
+                                contentParts.push({
+                                    type: "text",
+                                    text: `[Image source: ${imageUrl}]`,
+                                });
+                            }
+                        });
                     }
                     else {
                         block.imageUrls.forEach((imageUrl) => {
                             // Check if it's already base64, convert if not
+                            const isDataUrl = imageUrl.startsWith("data:image/");
                             let finalImageUrl = imageUrl;
-                            if (!imageUrl.startsWith("data:image/")) {
+                            if (!isDataUrl) {
                                 // If it's a file path, it needs to be converted to base64
                                 try {
                                     finalImageUrl = convertImageToBase64(imageUrl);
@@ -219,6 +256,16 @@ export function convertMessagesForAPI(messages, options) {
                                     detail: "auto",
                                 },
                             });
+                            // Aligned with Claude Code: when the image comes from a local
+                            // file (not an inline dataURL), append its source path as text
+                            // metadata so the model can reference the file with tools
+                            // (e.g. a vision-model subagent reading the image).
+                            if (!isDataUrl) {
+                                contentParts.push({
+                                    type: "text",
+                                    text: `[Image source: ${imageUrl}]`,
+                                });
+                            }
                         });
                     }
                 }

package/dist/utils/messageOperations.d.ts

@@ -40,7 +40,9 @@ export interface UpdateToolBlockParams {
     }>;
     compactParams?: string;
     parametersChunk?: string;
-    isManuallyBackgrounded?: boolean;
+    backgroundTaskId?: string;
+    backgroundedByUser?: boolean;
+    assistantAutoBackgrounded?: boolean;
     timestamp?: number;
 }
 export type AgentToolBlockUpdateParams = Omit<UpdateToolBlockParams, "messages">;
@@ -86,7 +88,7 @@ export declare const addToolBlockToMessageInMessages: (messages: Message[], mess
     messages: Message[];
     toolBlockId: string;
 };
-export declare const updateToolBlockInMessage: ({ messages, id, messageId, parameters, result, success, error, stage, name, shortResult, startLineNumber, images, compactParams, parametersChunk, isManuallyBackgrounded, }: UpdateToolBlockParams) => {
+export declare const updateToolBlockInMessage: ({ messages, id, messageId, parameters, result, success, error, stage, name, shortResult, startLineNumber, images, compactParams, parametersChunk, backgroundTaskId, backgroundedByUser, assistantAutoBackgrounded, }: UpdateToolBlockParams) => {
     messages: Message[];
     messageId?: string;
 };

package/dist/utils/messageOperations.js

@@ -158,7 +158,7 @@ export const addToolBlockToMessageInMessages = (messages, messageId, params) =>
     return { messages: newMessages, toolBlockId };
 };
 // Update Tool Block of the last assistant or user message
-export const updateToolBlockInMessage = ({ messages, id, messageId, parameters, result, success, error, stage, name, shortResult, startLineNumber, images, compactParams, parametersChunk, isManuallyBackgrounded, }) => {
+export const updateToolBlockInMessage = ({ messages, id, messageId, parameters, result, success, error, stage, name, shortResult, startLineNumber, images, compactParams, parametersChunk, backgroundTaskId, backgroundedByUser, assistantAutoBackgrounded, }) => {
     const newMessages = [...messages];
     // If messageId is provided, target that specific message
     if (messageId) {
@@ -170,6 +170,9 @@ export const updateToolBlockInMessage = ({ messages, id, messageId, parameters,
                 if (toolBlock.type === "tool") {
                     if (parameters !== undefined)
                         toolBlock.parameters = parameters;
+                    else if (parametersChunk !== undefined)
+                        toolBlock.parameters =
+                            (toolBlock.parameters || "") + parametersChunk;
                     if (result !== undefined)
                         toolBlock.result = result;
                     if (shortResult !== undefined)
@@ -188,8 +191,12 @@ export const updateToolBlockInMessage = ({ messages, id, messageId, parameters,
                         toolBlock.compactParams = compactParams;
                     if (parametersChunk !== undefined)
                         toolBlock.parametersChunk = parametersChunk;
-                    if (isManuallyBackgrounded !== undefined)
-                        toolBlock.isManuallyBackgrounded = isManuallyBackgrounded;
+                    if (backgroundTaskId !== undefined)
+                        toolBlock.backgroundTaskId = backgroundTaskId;
+                    if (backgroundedByUser !== undefined)
+                        toolBlock.backgroundedByUser = backgroundedByUser;
+                    if (assistantAutoBackgrounded !== undefined)
+                        toolBlock.assistantAutoBackgrounded = assistantAutoBackgrounded;
                 }
             }
         }
@@ -204,6 +211,9 @@ export const updateToolBlockInMessage = ({ messages, id, messageId, parameters,
                 if (toolBlock.type === "tool") {
                     if (parameters !== undefined)
                         toolBlock.parameters = parameters;
+                    else if (parametersChunk !== undefined)
+                        toolBlock.parameters =
+                            (toolBlock.parameters || "") + parametersChunk;
                     if (result !== undefined)
                         toolBlock.result = result;
                     if (shortResult !== undefined)
@@ -222,8 +232,12 @@ export const updateToolBlockInMessage = ({ messages, id, messageId, parameters,
                         toolBlock.compactParams = compactParams;
                     if (parametersChunk !== undefined)
                         toolBlock.parametersChunk = parametersChunk;
-                    if (isManuallyBackgrounded !== undefined)
-                        toolBlock.isManuallyBackgrounded = isManuallyBackgrounded;
+                    if (backgroundTaskId !== undefined)
+                        toolBlock.backgroundTaskId = backgroundTaskId;
+                    if (backgroundedByUser !== undefined)
+                        toolBlock.backgroundedByUser = backgroundedByUser;
+                    if (assistantAutoBackgrounded !== undefined)
+                        toolBlock.assistantAutoBackgrounded = assistantAutoBackgrounded;
                 }
                 const foundMessageId = newMessages[i].id;
                 return { messages: newMessages, messageId: foundMessageId };
@@ -233,7 +247,7 @@ export const updateToolBlockInMessage = ({ messages, id, messageId, parameters,
                 // This handles cases where we're streaming tool parameters before execution
                 newMessages[i].blocks.push({
                     type: "tool",
-                    parameters: parameters,
+                    parameters: parameters !== undefined ? parameters : (parametersChunk ?? ""),
                     result: result || "",
                     shortResult: shortResult,
                     startLineNumber: startLineNumber,
@@ -245,7 +259,9 @@ export const updateToolBlockInMessage = ({ messages, id, messageId, parameters,
                     stage: stage ?? "start",
                     compactParams: compactParams,
                     parametersChunk: parametersChunk,
-                    isManuallyBackgrounded: isManuallyBackgrounded,
+                    backgroundTaskId: backgroundTaskId,
+                    backgroundedByUser: backgroundedByUser,
+                    assistantAutoBackgrounded: assistantAutoBackgrounded,
                 });
                 const foundMessageId = newMessages[i].id;
                 return { messages: newMessages, messageId: foundMessageId };

package/dist/utils/subagentParser.d.ts

@@ -17,9 +17,12 @@ export interface SubagentConfiguration {
 export declare function parseAgentFile(filePath: string, scope: "plugin", pluginRoot: string): SubagentConfiguration;
 /**
  * Load all subagent configurations from project and user directories, plus built-in subagents
+ * @param workdir - Working directory to scan for project-level subagents
+ * @param env - Merged environment (settings.json env over OS env). Defaults to process.env.
+ *              Used for conditional registration of builtin subagents (e.g. WAVE_VISION_MODEL).
  */
-export declare function loadSubagentConfigurations(workdir: string): Promise<SubagentConfiguration[]>;
+export declare function loadSubagentConfigurations(workdir: string, env?: Record<string, string>): Promise<SubagentConfiguration[]>;
 /**
  * Find subagent by exact name match
  */
-export declare function findSubagentByName(name: string, workdir: string): Promise<SubagentConfiguration | null>;
+export declare function findSubagentByName(name: string, workdir: string, env?: Record<string, string>): Promise<SubagentConfiguration | null>;

package/dist/utils/subagentParser.js

@@ -158,15 +158,25 @@ function scanSubagentDirectory(dirPath, scope) {
 }
 /**
  * Load all subagent configurations from project and user directories, plus built-in subagents
+ * @param workdir - Working directory to scan for project-level subagents
+ * @param env - Merged environment (settings.json env over OS env). Defaults to process.env.
+ *              Used for conditional registration of builtin subagents (e.g. WAVE_VISION_MODEL).
  */
-export async function loadSubagentConfigurations(workdir) {
+export async function loadSubagentConfigurations(workdir, env = process.env) {
     const projectWaveDir = join(workdir, ".wave", "agents");
     const projectClaudeDir = join(workdir, ".claude", "agents");
     const userWaveDir = join(process.env.HOME || "~", ".wave", "agents");
     const userClaudeDir = join(process.env.HOME || "~", ".claude", "agents");
     const builtinDir = getBuiltinSubagentsDir();
     // Load configurations from all sources
-    const builtinConfigs = scanSubagentDirectory(builtinDir, "builtin");
+    let builtinConfigs = scanSubagentDirectory(builtinDir, "builtin");
+    // Conditional registration: builtin subagents whose frontmatter requires the
+    // WAVE_VISION_MODEL env var (`model: visionModel`) are only loaded when it is
+    // set — otherwise the main model would delegate image recognition to a
+    // subagent that resolves to a non-vision model.
+    if (!env.WAVE_VISION_MODEL) {
+        builtinConfigs = builtinConfigs.filter((config) => config.model !== "visionModel");
+    }
     const userClaudeConfigs = scanSubagentDirectory(userClaudeDir, "user");
     const userWaveConfigs = scanSubagentDirectory(userWaveDir, "user");
     const projectClaudeConfigs = scanSubagentDirectory(projectClaudeDir, "project");
@@ -193,7 +203,7 @@ export async function loadSubagentConfigurations(workdir) {
 /**
  * Find subagent by exact name match
  */
-export async function findSubagentByName(name, workdir) {
-    const configurations = await loadSubagentConfigurations(workdir);
+export async function findSubagentByName(name, workdir, env) {
+    const configurations = await loadSubagentConfigurations(workdir, env);
     return configurations.find((config) => config.name === name) || null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -55,6 +55,7 @@
     "fuzzysort": "^3.1.0",
     "glob": "^13.0.0",
     "lru-cache": "^11.3.5",
+    "marked": "^17.0.2",
     "minimatch": "^10.0.3",
     "openai": "^5.12.2",
     "turndown": "^7.2.2"