@atbash/atbash-langgraph 0.0.10 → 0.0.12

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as _langchain_core_messages from '@langchain/core/messages';
 import * as _langchain_langgraph from '@langchain/langgraph';
 import { StateGraph } from '@langchain/langgraph';
-import { Atbash } from '@atbash/sdk';
+import { Atbash, MemoryGuardManager } from '@atbash/sdk';
 import * as _langchain_core_tools from '@langchain/core/tools';
 import { z } from 'zod';
 
@@ -16,6 +16,7 @@ type AtbashState = typeof AtbashStateAnnotation.State;
 
 interface GuardNodeOptions {
     client: Atbash;
+    guardManager?: MemoryGuardManager;
 }
 declare function createGuardNode(opts: GuardNodeOptions): (state: AtbashState) => Promise<Partial<AtbashState>>;
 

package/dist/index.js

@@ -33,11 +33,63 @@ function createGuardNode(opts) {
         atbashReason: "No tool calls detected"
       };
     }
-    const actionText = toolCalls.map((toolCall) => `${toolCall.name}(${JSON.stringify(toolCall.args)})`).join("; ");
+    const memoryHandledIds = /* @__PURE__ */ new Set();
+    if (opts.guardManager) {
+      for (const tc of toolCalls) {
+        let memDecision;
+        try {
+          memDecision = await opts.guardManager.handleBeforeToolCall(
+            { toolName: tc.name, args: tc.args },
+            {}
+          );
+        } catch (err) {
+          const reason = err instanceof Error ? err.message : String(err);
+          return {
+            messages: toolCalls.map(
+              (toolCall) => new ToolMessage({
+                tool_call_id: toolCall.id,
+                content: toolCall.id === tc.id ? `Memory guard error: ${reason}` : "Blocked \u2014 memory safety check failed for another tool call"
+              })
+            ),
+            atbashVerdict: "BLOCK",
+            atbashReason: `Memory guard error: ${reason}`,
+            atbashToolCallId: null,
+            atbashConfidence: null
+          };
+        }
+        if (memDecision !== null) {
+          if (memDecision.block) {
+            return {
+              messages: toolCalls.map(
+                (toolCall) => new ToolMessage({
+                  tool_call_id: toolCall.id,
+                  content: toolCall.id === tc.id ? `Memory write blocked by Atbash: ${memDecision.blockReason ?? ""}` : "Blocked \u2014 another tool call was blocked by memory safety"
+                })
+              ),
+              atbashVerdict: "BLOCK",
+              atbashReason: memDecision.blockReason ?? "memory write blocked",
+              atbashToolCallId: null,
+              atbashConfidence: null
+            };
+          }
+          memoryHandledIds.add(tc.id);
+        }
+      }
+    }
+    const auditCalls = toolCalls.filter((tc) => !memoryHandledIds.has(tc.id));
+    if (auditCalls.length === 0) {
+      return {
+        atbashVerdict: "ALLOW",
+        atbashReason: "Memory operations validated by guard",
+        atbashToolCallId: null,
+        atbashConfidence: null
+      };
+    }
+    const actionText = auditCalls.map((toolCall) => `${toolCall.name}(${JSON.stringify(toolCall.args)})`).join("; ");
     try {
       const decision = await opts.client.auditToolCall({
-        toolName: toolCalls.map((t) => t.name).join(",") || "langgraph_batch",
-        args: toolCalls,
+        toolName: auditCalls.map((t) => t.name).join(",") || "langgraph_batch",
+        args: auditCalls,
         context: `LangGraph agent attempting: ${actionText}`
       });
       if (decision.verdict === "BLOCK" || decision.verdict === "ERROR") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atbash/atbash-langgraph",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Atbash safety guard and audit nodes for LangGraph workflows",
   "type": "module",
   "main": "dist/index.js",