@superjackfruitlabs/salaam 0.0.3 → 0.0.5

package/src/acp-outcome.ts

@@ -312,6 +312,123 @@ export function acpFailure(
     ...(kind === 'unknown' ? {} : { retryable: false }),
   };
 }
+/** ACP tool kind for an approval, so a client's modes can tell edits apart:
+ * AgentPod's accept-edits approves only kind "edit"; full-auto approves all; ask none. */
+export function permissionKind(operationKind: string): 'edit' | 'execute' | 'other' {
+  if (operationKind === 'workspace') return 'edit';
+  if (operationKind === 'harness') return 'execute';
+  return 'other';
+}
+/** An operator MCP catalog read is a read; a server's `fetch` tool is a fetch; others stay other. */
+function operatorMcpKind(action: string, tool: unknown): string {
+  if (action === 'catalog') return 'read';
+  return action === 'call' && tool === 'fetch' ? 'fetch' : 'other';
+}
+
+function toolArgs(input: unknown): Record<string, unknown> {
+  try {
+    const value = typeof input === 'string' ? JSON.parse(input) : input;
+    if (value && typeof value === 'object' && !Array.isArray(value))
+      return value as Record<string, unknown>;
+  } catch {}
+  return {};
+}
+
+const label = (v: unknown) => (typeof v === 'string' && /^[\w.-]{1,128}$/.test(v) ? v : undefined);
+
+/** One line of what a tool acted on, for a card title: no control characters, at most `max`. */
+function shown(v: unknown, max: number): string | undefined {
+  if (typeof v !== 'string') return undefined;
+  const t = v
+    .replace(/[\u0000-\u001f\u007f]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!t) return undefined;
+  return t.length > max ? t.slice(0, max - 1) + '…' : t;
+}
+/** A URL as host and path only: never its login, query or fragment (they may carry a secret). */
+function shownUrl(v: unknown): string | undefined {
+  if (typeof v !== 'string') return undefined;
+  try {
+    const u = new URL(v);
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') return undefined;
+    return u.host + (u.pathname === '/' ? '' : u.pathname);
+  } catch {
+    return undefined;
+  }
+}
+const titled = (verb: string, what: string | undefined) => {
+  if (!what) return verb;
+  const t = `${verb}: ${what}`;
+  return t.length > 80 ? t.slice(0, 79) + '…' : t;
+};
+
+/**
+ * The ACP title for a tool call, the way a board agent's card reads: the tool and what it acted on
+ * ("fetch: host/path", "write: runs/r/answer.md"). Every operator MCP call goes through one wrapper
+ * tool, so it is titled by the MCP tool itself. Only plain identifiers, URL host and path, paths,
+ * queries and commands are echoed, clipped to one line of 80 characters.
+ */
+/** A clipped input no longer parses: read the leading plain string fields it still carries. */
+function clippedArgs(input: unknown): Record<string, unknown> {
+  if (typeof input !== 'string') return {};
+  const out: Record<string, unknown> = {};
+  for (const key of [
+    'action',
+    'path',
+    'query',
+    'pattern',
+    'command',
+    'server',
+    'tool',
+    'item_id',
+  ]) {
+    const m = new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.){0,512})"`).exec(input);
+    if (m) {
+      try {
+        out[key] = JSON.parse(`"${m[1]}"`);
+      } catch {}
+    }
+  }
+  // A clipped patch is a long one, so a write: a delete (content null) is short and never clipped.
+  return out;
+}
+
+export function toolTitle(name: string, input: unknown): string {
+  const parsed = toolArgs(input);
+  const args = Object.keys(parsed).length ? parsed : clippedArgs(input);
+  const action = typeof args.action === 'string' ? args.action : '';
+  if (name === 'salaam_operator_mcp') {
+    const server = label(args.server);
+    const tool = label(args.tool);
+    if (action === 'call' && server && tool) {
+      const a = toolArgs(args.arguments);
+      return titled(tool, shownUrl(a.url) ?? shown(a.query ?? a.path ?? a.pattern, 80));
+    }
+    if (action === 'catalog') return titled('MCP catalog', server);
+    if (action === 'call') return titled('MCP call', server ?? tool);
+    return action ? titled('MCP request', label(action)) : 'MCP request (no input)';
+  }
+  if (name === 'salaam_board') {
+    if (action === 'card') return 'read this card';
+    if (action === 'attempts') return 'read this card’s runs';
+    if (action === 'library_search') return titled('library_search', shown(args.query, 80));
+    if (action === 'library_get') return titled('library_get', shown(args.item_id, 32));
+    return name;
+  }
+  if (['salaam_station', 'salaam_files', 'salaam_repository'].includes(name)) {
+    if (action === 'patch')
+      return titled(args.content === null ? 'delete' : 'write', shown(args.path, 80));
+    if (action === 'inspect' && args.path === undefined) return 'inspect workspace';
+    if (action === 'check') return titled('check', shown(args.command, 80));
+    if (['read', 'list', 'inspect', 'diff'].includes(action))
+      return titled(action, shown(args.path, 80));
+    if (action === 'search') return titled('search', shown(args.query ?? args.pattern, 80));
+    if (action) return action;
+  }
+  return name;
+}
+
 export function toolMetadata(
   name: string,
   input: unknown,
@@ -324,27 +441,35 @@ export function toolMetadata(
   } catch {}
   const action = String(args.action ?? '');
   const kind =
-    name === 'salaam_command' || (name === 'salaam_station' && action === 'check')
-      ? ['start', 'cancel', 'check'].includes(action)
-        ? 'execute'
-        : ['status', 'logs'].includes(action)
-          ? 'read'
-          : 'other'
-      : ['salaam_files', 'salaam_station'].includes(name) && action === 'patch'
-        ? args.content === null
-          ? 'delete'
-          : 'edit'
-        : ['salaam_files', 'salaam_repository', 'salaam_station'].includes(name) &&
-            ['search', 'list'].includes(action)
-          ? 'search'
-          : ['salaam_files', 'salaam_repository', 'salaam_station'].includes(name) &&
-              ['read', 'inspect', ...(name === 'salaam_repository' ? ['diff'] : [])].includes(
-                action,
-              )
-            ? 'read'
-            : ['salaam_history', 'inspect_child', 'consume_child_result'].includes(name)
+    name === 'salaam_board'
+      ? 'read'
+      : name === 'salaam_local' && ['edit', 'command'].includes(action)
+        ? action === 'edit'
+          ? 'edit'
+          : 'execute'
+        : name === 'salaam_command' || (name === 'salaam_station' && action === 'check')
+          ? ['start', 'cancel', 'check'].includes(action)
+            ? 'execute'
+            : ['status', 'logs'].includes(action)
               ? 'read'
-              : 'other';
+              : 'other'
+          : ['salaam_files', 'salaam_station'].includes(name) && action === 'patch'
+            ? args.content === null
+              ? 'delete'
+              : 'edit'
+            : ['salaam_files', 'salaam_repository', 'salaam_station'].includes(name) &&
+                ['search', 'list'].includes(action)
+              ? 'search'
+              : ['salaam_files', 'salaam_repository', 'salaam_station'].includes(name) &&
+                  ['read', 'inspect', ...(name === 'salaam_repository' ? ['diff'] : [])].includes(
+                    action,
+                  )
+                ? 'read'
+                : ['salaam_history', 'inspect_child', 'consume_child_result'].includes(name)
+                  ? 'read'
+                  : name === 'salaam_operator_mcp'
+                    ? operatorMcpKind(action, args.tool)
+                    : 'other';
   const locations: { path: string; line?: number }[] = [];
   if (
     ['salaam_files', 'salaam_station'].includes(name) &&
@@ -361,3 +486,32 @@ export function toolMetadata(
   }
   return { kind, locations };
 }
+
+/** A durable task's steps as the ACP `plan` session update: the whole list, replaced on every
+ * change (https://agentclientprotocol.com/protocol/agent-plan). ACP has only pending,
+ * in_progress and completed, so a step that stopped says so in its text instead. */
+export function planUpdate(
+  task: { steps: { title: string; state: string }[] } | null | undefined,
+): {
+  sessionUpdate: 'plan';
+  entries: { content: string; priority: 'medium'; status: string }[];
+} | null {
+  if (!task?.steps.length) return null;
+  return {
+    sessionUpdate: 'plan',
+    entries: task.steps.map((step) => {
+      const status =
+        step.state === 'completed'
+          ? 'completed'
+          : step.state === 'running' || step.state === 'awaiting_review'
+            ? 'in_progress'
+            : 'pending';
+      const stopped = ['cancelled', 'failed', 'interrupted'].includes(step.state);
+      return {
+        content: stopped ? `${step.title} (${step.state})` : step.title,
+        priority: 'medium' as const,
+        status,
+      };
+    }),
+  };
+}