pi-automem-bridge 0.2.2 → 0.2.3

package/README.md

@@ -10,7 +10,7 @@
 pi install npm:pi-automem-bridge
 ```
 
-[![npm version](https://badge.fury.io/js/pi-automem-bridge.svg)](https://badge.fury.io/js/pi-automem-bridge)
+[![npm version](https://img.shields.io/npm/v/pi-automem-bridge)](https://www.npmjs.com/package/pi-automem-bridge)
 [![npm downloads](https://img.shields.io/npm/dw/pi-automem-bridge)](https://www.npmjs.com/package/pi-automem-bridge)
 
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/L2J320X82M)
@@ -135,6 +135,8 @@ You don't type these — pi does, in plain conversation. Tell it *"remember that
 | `automem_link_memories` | Create a typed relationship between two existing memories. |
 | `automem_correct_memory` | Store a correction and link old → new with a provenance relationship (EVOLVED_INTO or CONTRADICTS). |
 
+Policy blocks, missing approval in non-interactive contexts, and invalid update requests surface as pi tool errors. User-cancelled confirmations and duplicate detection are normal control-flow results, so the agent can stop or choose the next write path deliberately.
+
 ---
 
 ## Write policy

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-automem-bridge",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Automatic long-term memory recall and policy-gated writes for pi agents via AutoMem MCP",
   "keywords": [
     "pi-package",

package/src/tools/memory-tools.ts

@@ -68,11 +68,10 @@ export function registerMemoryTools(pi: ExtensionAPI) {
         config,
       ).catch(() => ({ text: "Similar recall failed.", matches: [] }));
 
-      return {
-        content: [{ type: "text" as const, text: formatProposal(decision.action, decision.reasons, decision.normalized, similarText, similarMatches) }],
-        details: { action: decision.action, reasons: decision.reasons, findings: decision.findings, candidate: decision.normalized, similarMatches },
-        isError: decision.action === "block",
-      };
+      return {
+        content: [{ type: "text" as const, text: formatProposal(decision.action, decision.reasons, decision.normalized, similarText, similarMatches) }],
+        details: { action: decision.action, reasons: decision.reasons, findings: decision.findings, candidate: decision.normalized, similarMatches },
+      };
     },
   });
 
@@ -87,15 +86,11 @@ export function registerMemoryTools(pi: ExtensionAPI) {
       const config = loadConfig();
       setAutoMemMcpServerName(config.mcpServerName);
       const candidate = toCandidate(params);
-      const decision = evaluateWritePolicy(candidate, config);
-
-      if (decision.action === "block") {
-        return {
-          content: [{ type: "text" as const, text: "Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n") }],
-          details: { action: decision.action, reasons: decision.reasons, findings: decision.findings },
-          isError: true,
-        };
-      }
+      const decision = evaluateWritePolicy(candidate, config);
+
+      if (decision.action === "block") {
+        throw new Error("Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n"));
+      }
 
       const needsConfirmation = decision.action !== "auto";
       if (needsConfirmation && !params.approvedByUser) {
@@ -104,14 +99,10 @@ export function registerMemoryTools(pi: ExtensionAPI) {
           if (!ok) {
             return { content: [{ type: "text" as const, text: "AutoMem memory write cancelled." }], details: { cancelled: true } };
           }
-        } else {
-          return {
-            content: [{ type: "text" as const, text: "Confirmation required before storing this memory. Re-run with approvedByUser=true only after explicit user approval." }],
-            details: { action: decision.action, reasons: decision.reasons, candidate: decision.normalized },
-            isError: true,
-          };
-        }
-      }
+        } else {
+          throw new Error("Confirmation required before storing this memory. Re-run with approvedByUser=true only after explicit user approval.");
+        }
+      }
 
       // ── UPDATE path ──────────────────────────────────────────────────────
       if (params.updateMemoryId) {
@@ -158,11 +149,10 @@ export function registerMemoryTools(pi: ExtensionAPI) {
               "  2. Store anyway (new memory): call automem_commit_memory with dedupeQuery=\"\" to skip dedupe",
               "  3. Cancel: do nothing if this is not worth storing separately",
             ].join("\n"),
-          }],
-          details: { duplicateDetected: true, existingMemoryId: top.id, existingContent: top.content, candidate: decision.normalized, allSimilar: similarMatches },
-          isError: false,
-        };
-      }
+          }],
+          details: { duplicateDetected: true, existingMemoryId: top.id, existingContent: top.content, candidate: decision.normalized, allSimilar: similarMatches },
+        };
+      }
 
       // ── STORE path ───────────────────────────────────────────────────────
       const result = await automemStore(
@@ -193,12 +183,9 @@ export function registerMemoryTools(pi: ExtensionAPI) {
     promptSnippet: "Use after automem_commit_memory returns DUPLICATE_DETECTED, or when correcting a known memory. Requires the existing memory ID.",
     parameters: UpdateParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx: any) {
-      if (!params.memoryId) {
-        return {
-          content: [{ type: "text" as const, text: "memoryId is required for automem_update_memory." }],
-          isError: true,
-        };
-      }
+      if (!params.memoryId) {
+        throw new Error("memoryId is required for automem_update_memory.");
+      }
 
       if (!params.approvedByUser) {
         if (ctx && ctx.ui && typeof ctx.ui.confirm === "function") {
@@ -212,13 +199,10 @@ export function registerMemoryTools(pi: ExtensionAPI) {
           if (!ok) {
             return { content: [{ type: "text" as const, text: "AutoMem memory update cancelled." }], details: { cancelled: true } };
           }
-        } else {
-          return {
-            content: [{ type: "text" as const, text: "Confirmation required before updating this memory. Re-run with approvedByUser=true only after explicit user approval." }],
-            isError: true,
-          };
-        }
-      }
+        } else {
+          throw new Error("Confirmation required before updating this memory. Re-run with approvedByUser=true only after explicit user approval.");
+        }
+      }
 
       const result = await automemUpdate(params.memoryId, {
         content: params.content,

package/src/tools/relationship-tools.ts

@@ -31,14 +31,11 @@ export function registerRelationshipTools(pi: ExtensionAPI) {
     parameters: LinkParams,
     async execute(_toolCallId: string, params: any) {
       const config = loadConfig();
-      setAutoMemMcpServerName(config.mcpServerName);
-
-      if (!params.approvedByUser) {
-        return {
-          content: [{ type: "text" as const, text: "Confirmation required before linking memories. Re-run with approvedByUser=true only after explicit user approval.\n\nWould link:\n  " + params.memoryId1 + " → " + params.relationship + " → " + params.memoryId2 }],
-          isError: true,
-        };
-      }
+      setAutoMemMcpServerName(config.mcpServerName);
+
+      if (!params.approvedByUser) {
+        throw new Error("Confirmation required before linking memories. Re-run with approvedByUser=true only after explicit user approval.\n\nWould link:\n  " + params.memoryId1 + " -> " + params.relationship + " -> " + params.memoryId2);
+      }
 
       const strength = typeof params.strength === "number" ? params.strength : 0.5;
       const result = await automemAssociate(params.memoryId1, params.memoryId2, params.relationship, strength);
@@ -66,21 +63,14 @@ export function registerRelationshipTools(pi: ExtensionAPI) {
         tags: Array.isArray(params.tags) ? params.tags : [],
         importance: params.importance,
       };
-      const decision = evaluateWritePolicy(candidate, config);
-      if (decision.action === "block") {
-        return {
-          content: [{ type: "text" as const, text: "Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n") }],
-          details: { action: decision.action, reasons: decision.reasons, findings: decision.findings },
-          isError: true,
-        };
-      }
-
-      if (!params.approvedByUser) {
-        return {
-          content: [{ type: "text" as const, text: "Confirmation required before correcting memory. Re-run with approvedByUser=true only after explicit user approval.\n\nWould correct memory " + params.memoryId + " with:\n  " + params.correction }],
-          isError: true,
-        };
-      }
+      const decision = evaluateWritePolicy(candidate, config);
+      if (decision.action === "block") {
+        throw new Error("Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n"));
+      }
+
+      if (!params.approvedByUser) {
+        throw new Error("Confirmation required before correcting memory. Re-run with approvedByUser=true only after explicit user approval.\n\nWould correct memory " + params.memoryId + " with:\n  " + params.correction);
+      }
 
       const rel = params.relationship === "CONTRADICTS" ? "CONTRADICTS" : "EVOLVED_INTO";
       // Store the normalized candidate so corrections get the same alwaysTag,