@multiclawcli/core 0.6.3 → 0.7.0

package/dist/index.js

@@ -241,6 +241,36 @@ function isPermanent(err) {
   return err instanceof PermanentError;
 }
 
+// src/utils/toolSummary.ts
+var MAX_SUMMARY_COLUMNS = 120;
+function stringifySafe(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return "";
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+function firstLineTruncated(value) {
+  const text = stringifySafe(value);
+  const newline = text.indexOf("\n");
+  const firstLine = newline === -1 ? text : text.slice(0, newline);
+  if (firstLine.length <= MAX_SUMMARY_COLUMNS) return firstLine;
+  return `${firstLine.slice(0, MAX_SUMMARY_COLUMNS - 1)}\u2026`;
+}
+function hasToolArgs(input) {
+  if (input === void 0 || input === null) return false;
+  if (typeof input !== "object" || Array.isArray(input)) return true;
+  return Object.keys(input).length > 0;
+}
+function summarizeToolInput(input) {
+  return hasToolArgs(input) ? firstLineTruncated(input) : "";
+}
+function summarizeToolOutput(output) {
+  return firstLineTruncated(output);
+}
+
 // src/runtime/RuntimeBase.ts
 var RuntimeBase = class {
 };
@@ -305,16 +335,26 @@ var KIND_TO_TOOLS = {
   search: ["Grep", "Glob"],
   fetch: ["WebFetch"]
 };
+function matchesTool(pattern, name) {
+  if (!pattern.includes("*")) return pattern === name;
+  const source = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${source}$`).test(name);
+}
 function toolPermitted(params, tools) {
-  const allowed = new Set(tools.map((tool) => tool.toLowerCase()));
+  const allowed = tools.map((tool) => tool.toLowerCase());
   const name = params.toolCall.name ?? void 0;
-  return name !== void 0 ? allowed.has(name.toLowerCase()) : (KIND_TO_TOOLS[params.toolCall.kind ?? ""] ?? []).some(
-    (tool) => allowed.has(tool.toLowerCase())
-  );
+  if (name !== void 0) {
+    const candidate = name.toLowerCase();
+    return allowed.some((pattern) => matchesTool(pattern, candidate));
+  }
+  return (KIND_TO_TOOLS[params.toolCall.kind ?? ""] ?? []).some((tool) => {
+    const candidate = tool.toLowerCase();
+    return allowed.some((pattern) => matchesTool(pattern, candidate));
+  });
 }
 function decidePermission(params, tools, sessionId) {
   if (sessionId !== void 0 && params.sessionId !== sessionId) {
-    return { response: { outcome: { outcome: "cancelled" } } };
+    return { response: { outcome: { outcome: "cancelled" } }, approved: false };
   }
   const name = params.toolCall.name ?? void 0;
   const kind = params.toolCall.kind ?? void 0;
@@ -323,9 +363,10 @@ function decidePermission(params, tools, sessionId) {
     (o) => approved ? o.kind === "allow_once" : o.kind === "reject_once"
   );
   const response = option ? { outcome: { outcome: "selected", optionId: option.optionId } } : { outcome: { outcome: "cancelled" } };
-  if (approved) return { response };
+  if (approved) return { response, approved };
   return {
     response,
+    approved,
     rejected: {
       toolCallId: params.toolCall.toolCallId,
       name,
@@ -506,6 +547,8 @@ var AcpRuntime = class extends RuntimeBase {
       let closeResolve;
       let closeReject;
       let connection;
+      const argsSurfaced = /* @__PURE__ */ new Set();
+      const toolNames = /* @__PURE__ */ new Map();
       const killTree = (signal) => {
         if (child.pid !== void 0) {
           try {
@@ -640,15 +683,23 @@ var AcpRuntime = class extends RuntimeBase {
             }
             break;
           }
-          case "tool_call":
-            emit({
-              type: "tool_call",
-              id: update.toolCallId,
-              name: update.name ?? update.title,
-              input: update.rawInput
-            });
+          case "tool_call": {
+            const name = update.name ?? update.title;
+            toolNames.set(update.toolCallId, name);
+            if (hasToolArgs(update.rawInput)) argsSurfaced.add(update.toolCallId);
+            emit({ type: "tool_call", id: update.toolCallId, name, input: update.rawInput });
             break;
-          case "tool_call_update":
+          }
+          case "tool_call_update": {
+            if (!argsSurfaced.has(update.toolCallId) && hasToolArgs(update.rawInput)) {
+              argsSurfaced.add(update.toolCallId);
+              emit({
+                type: "tool_call",
+                id: update.toolCallId,
+                name: update.name ?? toolNames.get(update.toolCallId) ?? update.title ?? "",
+                input: update.rawInput
+              });
+            }
             emit({
               type: "tool_result",
               id: update.toolCallId,
@@ -656,6 +707,7 @@ var AcpRuntime = class extends RuntimeBase {
               isError: update.status === "failed"
             });
             break;
+          }
           case "plan":
             emit({ type: "plan", entries: update.entries.map((entry3) => entry3.content) });
             break;
@@ -690,22 +742,26 @@ var AcpRuntime = class extends RuntimeBase {
         if (state !== "running" || !turn || params.sessionId !== sessionId || context.signal.aborted)
           return cancelled;
         const mode = turn.options.permissionMode ?? "auto";
-        const { response, rejected } = decidePermission(params, options.tools, sessionId);
-        if (rejected) {
-          warn("Tool permission denied by the configured tools policy.");
-          emit({
-            type: "raw",
-            vendor: "acp",
-            payload: { type: "permission_rejected", ...rejected }
-          });
-          return response;
+        const { response, approved, rejected } = decidePermission(params, options.tools, sessionId);
+        if (approved) {
+          if (mode !== "deny") return response;
+          warn("Tool permission denied by the configured approval mode.");
+          return cancelled;
         }
-        if (mode === "auto") return response;
-        if (mode !== "ask" || !turn.options.onPermission) {
+        const askable = mode === "ask" && turn.options.onPermission !== void 0;
+        if (!askable) {
+          const label = rejected?.name ?? rejected?.kind ?? rejected?.toolCallId ?? "an unnamed tool";
           warn(
-            mode === "ask" ? "Tool permission cancelled: no approval handler is available." : "Tool permission denied by the configured approval mode."
+            mode === "ask" ? `Tool permission cancelled: no approval handler is available (${label}).` : `Tool permission denied by the configured tools policy: ${label}.`
           );
-          return cancelled;
+          if (rejected) {
+            emit({
+              type: "raw",
+              vendor: "acp",
+              payload: { type: "permission_rejected", ...rejected }
+            });
+          }
+          return mode === "deny" ? cancelled : response;
         }
         const signal = AbortSignal.any([turn.decisions.signal, context.signal]);
         const offered = new Set(params.options.map((option) => option.optionId));
@@ -736,7 +792,18 @@ var AcpRuntime = class extends RuntimeBase {
             aborted
           ]);
           if (signal.aborted || active !== turn || state !== "running") return cancelled;
-          return optionId !== void 0 && offered.has(optionId) ? { outcome: { outcome: "selected", optionId } } : cancelled;
+          const chosen = params.options.find((option) => option.optionId === optionId);
+          if (optionId === void 0 || chosen === void 0 || !offered.has(optionId)) {
+            return cancelled;
+          }
+          if (chosen.kind.startsWith("reject") && rejected) {
+            emit({
+              type: "raw",
+              vendor: "acp",
+              payload: { type: "permission_rejected", ...rejected, source: "user" }
+            });
+          }
+          return { outcome: { outcome: "selected", optionId } };
         } catch {
           return cancelled;
         } finally {
@@ -2366,31 +2433,6 @@ function withTimeout(factory, ms, label, signal, options) {
   });
 }
 
-// src/utils/toolSummary.ts
-var MAX_SUMMARY_COLUMNS = 120;
-function stringifySafe(value) {
-  if (typeof value === "string") return value;
-  if (value === void 0 || value === null) return "";
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return String(value);
-  }
-}
-function firstLineTruncated(value) {
-  const text = stringifySafe(value);
-  const newline = text.indexOf("\n");
-  const firstLine = newline === -1 ? text : text.slice(0, newline);
-  if (firstLine.length <= MAX_SUMMARY_COLUMNS) return firstLine;
-  return `${firstLine.slice(0, MAX_SUMMARY_COLUMNS - 1)}\u2026`;
-}
-function summarizeToolInput(input) {
-  return firstLineTruncated(input);
-}
-function summarizeToolOutput(output) {
-  return firstLineTruncated(output);
-}
-
 // src/orchestrator/AgentRunner.ts
 var AgentRunner = class {
   constructor(eventBus, contextManager, globalWorkDir, config, sessionManager) {
@@ -2451,6 +2493,16 @@ ${prompt}`;
             if (instruction) prompt += `
 
 ${instruction}`;
+            const toolRows = /* @__PURE__ */ new Set();
+            const toolNames = /* @__PURE__ */ new Map();
+            const printToolRow = (id, name, input) => {
+              if (toolRows.has(id)) return;
+              toolRows.add(id);
+              const summary = summarizeToolInput(input);
+              this.emitOutput(agent.id, `
+\u203A ${name}${summary ? ` ${summary}` : ""}
+`, "tool");
+            };
             const task = {
               agentId: agent.id,
               systemPrompt: agent.systemPrompt,
@@ -2492,17 +2544,13 @@ ${instruction}`;
                   return;
                 }
                 if (e.type === "tool_call") {
-                  const summary = summarizeToolInput(e.input);
-                  this.emitOutput(
-                    agent.id,
-                    `
-\u203A ${e.name}${summary ? ` ${summary}` : ""}
-`,
-                    "tool"
-                  );
+                  toolNames.set(e.id, e.name);
+                  if (summarizeToolInput(e.input)) printToolRow(e.id, e.name, e.input);
                   return;
                 }
                 if (e.type === "tool_result") {
+                  const name = toolNames.get(e.id);
+                  if (name !== void 0) printToolRow(e.id, name, void 0);
                   const summary = summarizeToolOutput(e.output);
                   this.emitOutput(
                     agent.id,

package/dist/types/runtime.d.ts

@@ -28,7 +28,14 @@ export type RuntimeEvent = (RuntimeEventBase & {
     type: "message";
     role: "agent" | "thought" | "user";
     text: string;
-}) | (RuntimeEventBase & {
+})
+/**
+ * A tool call. The same `id` may arrive more than once: providers announce a
+ * call before its arguments have streamed, so the first event can carry an
+ * empty `input` and a later one the completed arguments. Consumers should key
+ * on `id` and render a row once.
+ */
+ | (RuntimeEventBase & {
     type: "tool_call";
     id: string;
     name: string;

package/dist/utils/toolSummary.d.ts

@@ -7,6 +7,15 @@
  * truncated line and are deliberately total — a summary is diagnostics and must
  * never be the reason a run fails.
  */
+/**
+ * Whether a tool call was given any arguments.
+ *
+ * "No arguments yet" reaches us as `{}` (or missing) rather than as
+ * `undefined`: ACP announces a call before its input has finished streaming.
+ * Both mean the same thing to a reader — there is nothing to show yet — so the
+ * two are collapsed here instead of at every call site.
+ */
+export declare function hasToolArgs(input: unknown): boolean;
 /** One-line summary of a tool call's input. `input` is untrusted and may be circular. */
 export declare function summarizeToolInput(input: unknown): string;
 /** One-line summary of a tool result's output, which may be a string or a value. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiclawcli/core",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",