@joshski/dust 0.1.90 → 0.1.91

package/dist/bucket/tool-execution-protocol.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Tool execution protocol types for the WebSocket messages between
+ * dust clients and dustbucket servers.
+ *
+ * These types define the wire format. Both sides must agree on this protocol.
+ * Import from '@joshski/dust/types' for downstream implementations.
+ */
+/**
+ * Client-to-server message requesting tool execution.
+ *
+ * Sent over the bucket WebSocket when an agent invokes `dust bucket tool <name>`.
+ * The `tool` field identifies the server-defined tool by name.
+ * The `arguments` field contains named parameters matching the tool definition.
+ * The `repositoryId` identifies the repository context (numeric server-side ID).
+ */
+export interface ToolExecutionRequestMessage {
+    type: 'tool-execution-request';
+    requestId: string;
+    tool: string;
+    repositoryId: number;
+    arguments: Record<string, unknown>;
+}
+export interface ToolExecutionSuccessResult {
+    type: 'success';
+    data: unknown;
+}
+export interface ToolExecutionToolNotFoundResult {
+    type: 'tool-not-found';
+    message: string;
+}
+export interface ToolExecutionErrorResult {
+    type: 'error';
+    message: string;
+}
+export type ToolExecutionResult = ToolExecutionSuccessResult | ToolExecutionToolNotFoundResult | ToolExecutionErrorResult;
+/**
+ * Server-to-client message with the result of a tool execution request.
+ *
+ * The `requestId` correlates this response to the original request.
+ * The `result` is a discriminated union on the `type` field.
+ */
+export interface ToolExecutionResultMessage {
+    type: 'tool-execution-result';
+    requestId: string;
+    result: ToolExecutionResult;
+}
+export declare function isToolExecutionResultMessage(payload: unknown): payload is ToolExecutionResultMessage;
+export declare function isToolExecutionRequestMessage(payload: unknown): payload is ToolExecutionRequestMessage;

package/dist/dust.js

@@ -500,7 +500,7 @@ async function loadSettings(cwd, fileSystem) {
 }
 
 // lib/version.ts
-var DUST_VERSION = "0.1.90";
+var DUST_VERSION = "0.1.91";
 
 // lib/session.ts
 var DUST_UNATTENDED = "DUST_UNATTENDED";
@@ -4570,8 +4570,11 @@ function formatToolsSection(tools) {
     return "";
   }
   const lines = [];
+  lines.push("");
   lines.push("## Available Tools");
   lines.push("");
+  lines.push("Use these tools where it makes sense in the execution of this task:");
+  lines.push("");
   for (const tool of tools) {
     lines.push(formatTool(tool));
     lines.push("");
@@ -5440,6 +5443,18 @@ var SGR_MOUSE_RE2 = new RegExp(String.raw`^\x1b\[<(\d+);\d+;\d+[Mm]$`);
 function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
+function isValidResultType(value) {
+  return value === "success" || value === "tool-not-found" || value === "error";
+}
+function isValidResult(value) {
+  if (!isRecord3(value))
+    return false;
+  if (!isValidResultType(value.type))
+    return false;
+  if (value.type === "success")
+    return true;
+  return typeof value.message === "string";
+}
 function isToolExecutionResultMessage(payload) {
   if (!isRecord3(payload))
     return false;
@@ -5448,16 +5463,7 @@ function isToolExecutionResultMessage(payload) {
   if (typeof payload.requestId !== "string" || payload.requestId.length === 0) {
     return false;
   }
-  if (payload.status !== "success" && payload.status !== "tool-not-found" && payload.status !== "error") {
-    return false;
-  }
-  if (payload.output !== undefined && typeof payload.output !== "string") {
-    return false;
-  }
-  if (payload.error !== undefined && typeof payload.error !== "string") {
-    return false;
-  }
-  return true;
+  return isValidResult(payload.result);
 }
 
 // lib/cli/commands/bucket.ts
@@ -6147,12 +6153,23 @@ async function bucketWorker(dependencies, bucketDeps = createDefaultBucketDepend
       });
     }
     const requestId = crypto.randomUUID();
+    const toolDef = state.tools.find((t) => t.name === request.toolName);
+    const namedArgs = {};
+    if (toolDef) {
+      for (let i = 0;i < toolDef.parameters.length && i < request.arguments.length; i++) {
+        namedArgs[toolDef.parameters[i].name] = request.arguments[i];
+      }
+    } else {
+      for (let i = 0;i < request.arguments.length; i++) {
+        namedArgs[`arg${i}`] = request.arguments[i];
+      }
+    }
     const message = {
       type: "tool-execution-request",
       requestId,
-      toolName: request.toolName,
-      arguments: request.arguments,
-      repositoryId: request.repositoryId
+      tool: request.toolName,
+      repositoryId: Number(request.repositoryId),
+      arguments: namedArgs
     };
     log10(`forwarding tool execution: ${request.toolName} requestId=${requestId}`);
     return new Promise((resolve, reject) => {
@@ -6198,14 +6215,30 @@ async function bucketWorker(dependencies, bucketDeps = createDefaultBucketDepend
           log10(`received tool execution result for unknown requestId=${message.requestId}`);
           return;
         }
-        log10(`received tool execution result: requestId=${message.requestId} status=${message.status}`);
+        const resultType = message.result.type;
+        log10(`received tool execution result: requestId=${message.requestId} status=${resultType}`);
         clearTimeout(pending.timeoutId);
         pendingToolExecutions.delete(message.requestId);
-        pending.resolve({
-          status: message.status,
-          output: message.output,
-          error: message.error
-        });
+        switch (message.result.type) {
+          case "success":
+            pending.resolve({
+              status: "success",
+              output: typeof message.result.data === "string" ? message.result.data : JSON.stringify(message.result.data)
+            });
+            break;
+          case "tool-not-found":
+            pending.resolve({
+              status: "tool-not-found",
+              error: message.result.message
+            });
+            break;
+          case "error":
+            pending.resolve({
+              status: "error",
+              error: message.result.message
+            });
+            break;
+        }
       }, forwardToolExecution);
       if (!useTUI) {
         context.stdout("   Press q or Ctrl+C to exit");
@@ -6895,14 +6928,22 @@ function validateLinks(filePath, content, fileSystem) {
     while (match) {
       const linkTarget = match[2];
       if (!linkTarget.startsWith("http://") && !linkTarget.startsWith("https://") && !linkTarget.startsWith("#")) {
-        const targetPath = linkTarget.split("#")[0];
-        const resolvedPath = resolve(fileDir, targetPath);
-        if (!fileSystem.exists(resolvedPath)) {
+        if (linkTarget.startsWith("/")) {
           violations.push({
             file: filePath,
-            message: `Broken link: "${linkTarget}"`,
+            message: `Absolute link not allowed: "${linkTarget}" (use a relative path instead)`,
             line: i + 1
           });
+        } else {
+          const targetPath = linkTarget.split("#")[0];
+          const resolvedPath = resolve(fileDir, targetPath);
+          if (!fileSystem.exists(resolvedPath)) {
+            violations.push({
+              file: filePath,
+              message: `Broken link: "${linkTarget}"`,
+              line: i + 1
+            });
+          }
         }
       }
       match = linkPattern.exec(line);

package/dist/types.d.ts

@@ -10,3 +10,5 @@ export type { ArtifactType, TaskGraph, TaskGraphNode } from './artifacts/index';
 export type { Task } from './artifacts/tasks';
 export type { CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, IdeaInProgress, OpenQuestionResponse, ParsedCaptureIdeaTask, WorkflowTaskMatch, WorkflowTaskType, } from './artifacts/workflow-tasks';
 export type { Repository } from './bucket/repository';
+export type { ToolExecutionErrorResult, ToolExecutionRequestMessage, ToolExecutionResult, ToolExecutionResultMessage, ToolExecutionSuccessResult, ToolExecutionToolNotFoundResult, } from './bucket/tool-execution-protocol';
+export { isToolExecutionRequestMessage, isToolExecutionResultMessage, } from './bucket/tool-execution-protocol';

package/dist/validation.js

@@ -451,14 +451,22 @@ function validateLinks(filePath, content, fileSystem) {
     while (match) {
       const linkTarget = match[2];
       if (!linkTarget.startsWith("http://") && !linkTarget.startsWith("https://") && !linkTarget.startsWith("#")) {
-        const targetPath = linkTarget.split("#")[0];
-        const resolvedPath = resolve(fileDir, targetPath);
-        if (!fileSystem.exists(resolvedPath)) {
+        if (linkTarget.startsWith("/")) {
           violations.push({
             file: filePath,
-            message: `Broken link: "${linkTarget}"`,
+            message: `Absolute link not allowed: "${linkTarget}" (use a relative path instead)`,
             line: i + 1
           });
+        } else {
+          const targetPath = linkTarget.split("#")[0];
+          const resolvedPath = resolve(fileDir, targetPath);
+          if (!fileSystem.exists(resolvedPath)) {
+            violations.push({
+              file: filePath,
+              message: `Broken link: "${linkTarget}"`,
+              line: i + 1
+            });
+          }
         }
       }
       match = linkPattern.exec(line);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {