@inkeep/agents-manage-ui 0.8.7 → 0.9.0

package/src/components/graph/nodes/mcp-node.tsx

@@ -11,7 +11,8 @@ import { Handle } from './handle';
 export function MCPNode(props: NodeProps & { data: MCPNodeData }) {
   const { data, selected } = props;
   const toolLookup = useGraphStore((state) => state.toolLookup);
-  const selectedToolsLookup = useGraphStore((state) => state.selectedToolsLookup);
+  const agentToolConfigLookup = useGraphStore((state) => state.agentToolConfigLookup);
+  const edges = useGraphStore((state) => state.edges);
 
   const name = data.name || `Tool: ${data.toolId}`;
   const imageUrl = data.imageUrl;
@@ -25,7 +26,7 @@ export function MCPNode(props: NodeProps & { data: MCPNodeData }) {
     activeTools: toolData?.config?.mcp?.activeTools,
   });
 
-  const selectedTools = getCurrentSelectedToolsForNode(props, selectedToolsLookup);
+  const selectedTools = getCurrentSelectedToolsForNode(props, agentToolConfigLookup, edges);
 
   // Format the tool display
   const getToolDisplay = () => {

package/src/components/graph/playground/custom-headers-dialog.tsx

@@ -85,7 +85,7 @@ function CustomHeadersDialog({ customHeaders, setCustomHeaders }: CustomHeadersD
   return (
     <Dialog open={isOpen} onOpenChange={setIsOpen}>
       <DialogTrigger asChild>
-        <Button variant="outline">
+        <Button variant="ghost" size="sm" className="h-6">
           {numHeaders > 0 ? <Pencil className="w-4 h-4" /> : <Plus className="w-4 h-4" />}
           Custom Headers
           {numHeaders > 0 && <Badge variant="code">{numHeaders}</Badge>}

package/src/components/graph/playground/playground.tsx

@@ -1,4 +1,4 @@
-import { ArrowLeft } from 'lucide-react';
+import { Bug, X } from 'lucide-react';
 import { nanoid } from 'nanoid';
 import { useState } from 'react';
 import { TimelineWrapper } from '@/components/traces/timeline/timeline-wrapper';
@@ -13,16 +13,19 @@ interface PlaygroundProps {
   projectId: string;
   tenantId: string;
   setShowPlayground: (show: boolean) => void;
+  closeSidePane: () => void;
 }
 
 export const Playground = ({
   graphId,
   projectId,
   tenantId,
+  closeSidePane,
   setShowPlayground,
 }: PlaygroundProps) => {
   const [conversationId, setConversationId] = useState<string>(nanoid());
   const [customHeaders, setCustomHeaders] = useState<Record<string, string>>({});
+  const [showTraces, setShowTraces] = useState<boolean>(false);
   const {
     chatActivities,
     isPolling,
@@ -36,13 +39,36 @@ export const Playground = ({
   });
 
   return (
-    <div className="bg-background h-full w-full z-10 flex flex-col">
+    <div
+      className={`bg-background z-10 flex flex-col border-l ${showTraces ? 'w-full' : 'w-1/3 min-w-96'}`}
+    >
       <div className="flex min-h-0 items-center justify-between py-2 px-4 border-b flex-shrink-0">
-        <Button variant="ghost" size="sm" className="h-6" onClick={() => setShowPlayground(false)}>
-          <ArrowLeft className="h-4 w-4" />
-          <span>Back to graph</span>
-        </Button>
         <CustomHeadersDialog customHeaders={customHeaders} setCustomHeaders={setCustomHeaders} />
+        <div className="flex items-center gap-2">
+          <Button
+            variant="ghost"
+            size="sm"
+            className="h-6"
+            onClick={() => {
+              setShowTraces(!showTraces);
+              if (!showTraces) {
+                closeSidePane();
+              }
+            }}
+          >
+            <Bug className="h-4 w-4" />
+            {showTraces ? 'Hide debug' : 'Debug'}
+          </Button>
+
+          <Button
+            variant="ghost"
+            size="sm"
+            className="h-6"
+            onClick={() => setShowPlayground(false)}
+          >
+            <X className="h-4 w-4" />
+          </Button>
+        </div>
       </div>
       <div className="flex-1 min-h-0 w-full">
         <ResizablePanelGroup direction="horizontal">
@@ -59,17 +85,22 @@ export const Playground = ({
               key={JSON.stringify(customHeaders)}
             />
           </ResizablePanel>
-          <ResizableHandle />
-          <TimelineWrapper
-            isPolling={isPolling}
-            conversation={chatActivities}
-            enableAutoScroll={true}
-            error={error}
-            retryConnection={retryConnection}
-            refreshOnce={refreshOnce}
-            showConversationTracesLink={true}
-            conversationId={conversationId}
-          />
+
+          {showTraces && (
+            <>
+              <ResizableHandle />
+              <TimelineWrapper
+                isPolling={isPolling}
+                conversation={chatActivities}
+                enableAutoScroll={true}
+                error={error}
+                retryConnection={retryConnection}
+                refreshOnce={refreshOnce}
+                showConversationTracesLink={true}
+                conversationId={conversationId}
+              />
+            </>
+          )}
         </ResizablePanelGroup>
       </div>
     </div>

package/src/components/graph/sidepane/nodes/mcp-node-editor.tsx

@@ -12,7 +12,10 @@ import { Label } from '@/components/ui/label';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { useGraphStore } from '@/features/graph/state/use-graph-store';
 import { getToolTypeAndName } from '@/lib/utils/mcp-utils';
-import { getCurrentSelectedToolsForNode } from '@/lib/utils/orphaned-tools-detector';
+import {
+  getCurrentHeadersForNode,
+  getCurrentSelectedToolsForNode,
+} from '@/lib/utils/orphaned-tools-detector';
 import type { MCPNodeData } from '../../configuration/node-types';
 import type { AgentToolConfigLookup } from '../../graph';
 
@@ -32,35 +35,24 @@ export function MCPServerNodeEditor({
   }>();
   const markUnsaved = useGraphStore((state) => state.markUnsaved);
 
-  // Get current headers for this tool from all agents
-  const getCurrentHeaders = useCallback((): Record<string, string> => {
-    // First check if we have temporary headers stored on the node
-    if ((selectedNode.data as any).tempHeaders !== undefined) {
-      return (selectedNode.data as any).tempHeaders;
-    }
+  // Only use toolLookup - single source of truth
+  const toolLookup = useGraphStore((state) => state.toolLookup);
+  const edges = useGraphStore((state) => state.edges);
 
-    // Otherwise, get from the database/initial state - find any agent that has headers for this tool
-    for (const agentId in agentToolConfigLookup) {
-      const toolConfig = agentToolConfigLookup[agentId]?.[selectedNode.data.toolId];
-      if (toolConfig?.headers) {
-        return toolConfig.headers;
-      }
-    }
-    return {};
-  }, [agentToolConfigLookup, selectedNode.data]);
+  const getCurrentHeaders = useCallback((): Record<string, string> => {
+    return getCurrentHeadersForNode(selectedNode, agentToolConfigLookup, edges);
+  }, [selectedNode, agentToolConfigLookup, edges]);
 
   // Local state for headers input (allows invalid JSON while typing)
   const [headersInputValue, setHeadersInputValue] = useState('{}');
 
-  // Sync input value when external headers change
+  // Sync input value when node changes (but not on every data change)
+  // biome-ignore lint/correctness/useExhaustiveDependencies: intentionally omit getCurrentHeaders to prevent reset loops
   useEffect(() => {
     const newHeaders = getCurrentHeaders();
     setHeadersInputValue(JSON.stringify(newHeaders, null, 2));
-  }, [getCurrentHeaders]);
+  }, [selectedNode.id]);
 
-  // Only use toolLookup - single source of truth
-  const toolLookup = useGraphStore((state) => state.toolLookup);
-  const selectedToolsLookup = useGraphStore((state) => state.selectedToolsLookup);
   const toolData = toolLookup[selectedNode.data.toolId];
 
   const availableTools = toolData?.availableTools;
@@ -80,7 +72,7 @@ export function MCPServerNodeEditor({
       </div>
     );
   }
-  const selectedTools = getCurrentSelectedToolsForNode(selectedNode, selectedToolsLookup);
+  const selectedTools = getCurrentSelectedToolsForNode(selectedNode, agentToolConfigLookup, edges);
 
   // Find orphaned tools - tools that are selected but no longer available in activeTools
   const orphanedTools =

package/src/components/graph/sidepane/nodes/mcp-selector/mcp-selector.tsx

@@ -57,7 +57,7 @@ export function MCPSelector({ selectedNode }: { selectedNode: Node }) {
   const handleSelect = (mcp: MCPTool) => {
     updateNode(selectedNode.id, {
       type: NodeType.MCP,
-      data: { toolId: mcp.id },
+      data: { toolId: mcp.id, agentId: null, relationshipId: null },
     });
   };
 

package/src/features/graph/domain/deserialize.ts

@@ -206,59 +206,28 @@ export function deserializeGraphData(data: FullGraphDefinition): TransformResult
     const agent = data.agents[agentId];
     // Check if agent has canUse property (internal agents)
     if ('canUse' in agent && agent.canUse && agent.canUse.length > 0) {
-      // Only create tool nodes if tools data is available in graph (backward compatibility)
-      const toolsData = (data as any).tools;
-      if (toolsData) {
-        for (const canUseItem of agent.canUse) {
-          const toolId = canUseItem.toolId;
-          const tool = toolsData[toolId];
-          if (!tool) {
-            // eslint-disable-next-line no-console
-            console.warn(`Tool with ID ${toolId} not found in tools object`);
-            continue;
-          }
-          const toolNodeId = nanoid();
-          const toolNode: Node = {
-            id: toolNodeId,
-            type: NodeType.MCP,
-            position: { x: 0, y: 0 },
-            data: { toolId: tool.id },
-          };
-          nodes.push(toolNode);
-
-          const agentToToolEdge: Edge = {
-            id: `edge-${toolNodeId}-${agentId}`,
-            type: EdgeType.Default,
-            source: agentId,
-            sourceHandle: agentNodeSourceHandleId,
-            target: toolNodeId,
-            targetHandle: mcpNodeHandleId,
-          };
-          edges.push(agentToToolEdge);
-        }
-      } else {
-        // Tools are project-scoped - just store the tool ID
-        for (const canUseItem of agent.canUse) {
-          const toolId = canUseItem.toolId;
-          const toolNodeId = nanoid();
-          const toolNode: Node = {
-            id: toolNodeId,
-            type: NodeType.MCP,
-            position: { x: 0, y: 0 },
-            data: { toolId },
-          };
-          nodes.push(toolNode);
-
-          const agentToToolEdge: Edge = {
-            id: `edge-${toolNodeId}-${agentId}`,
-            type: EdgeType.Default,
-            source: agentId,
-            sourceHandle: agentNodeSourceHandleId,
-            target: toolNodeId,
-            targetHandle: mcpNodeHandleId,
-          };
-          edges.push(agentToToolEdge);
-        }
+      // Tools are project-scoped - create nodes from canUse items
+      for (const canUseItem of agent.canUse) {
+        const toolId = canUseItem.toolId;
+        const toolNodeId = nanoid();
+        const relationshipId = canUseItem.agentToolRelationId;
+        const toolNode: Node = {
+          id: toolNodeId,
+          type: NodeType.MCP,
+          position: { x: 0, y: 0 },
+          data: { toolId, agentId, relationshipId },
+        };
+        nodes.push(toolNode);
+
+        const agentToToolEdge: Edge = {
+          id: `edge-${toolNodeId}-${agentId}`,
+          type: EdgeType.Default,
+          source: agentId,
+          sourceHandle: agentNodeSourceHandleId,
+          target: toolNodeId,
+          targetHandle: mcpNodeHandleId,
+        };
+        edges.push(agentToToolEdge);
       }
     }
   }

package/src/features/graph/domain/serialize.ts

@@ -120,6 +120,7 @@ export function serializeGraphData(
         toolId: string;
         toolSelection?: string[] | null;
         headers?: Record<string, string>;
+        agentToolRelationId?: string;
       }> = [];
 
       // Find edges from this agent to MCP nodes
@@ -140,6 +141,9 @@ export function serializeGraphData(
             const tempSelectedTools = (mcpNode.data as any).tempSelectedTools;
             let toolSelection: string[] | null = null;
 
+            // Get the relationshipId from the MCP node first
+            const relationshipId = (mcpNode.data as any).relationshipId;
+
             if (tempSelectedTools !== undefined) {
               // User has made changes to tool selection in the UI
               if (Array.isArray(tempSelectedTools)) {
@@ -149,9 +153,11 @@ export function serializeGraphData(
               }
             } else {
               // No changes made to tool selection - preserve existing selection
-              if (agentToolConfigLookup?.[agentId]?.[toolId]?.toolSelection) {
-                // Get existing selection from saved data
-                toolSelection = agentToolConfigLookup[agentId][toolId].toolSelection;
+              const existingConfig = relationshipId
+                ? agentToolConfigLookup?.[agentId]?.[relationshipId]
+                : null;
+              if (existingConfig?.toolSelection) {
+                toolSelection = existingConfig.toolSelection;
               } else {
                 // Default to all tools selected when no existing data found
                 toolSelection = null;
@@ -171,9 +177,11 @@ export function serializeGraphData(
               }
             } else {
               // No changes made to headers - preserve existing headers
-              if (agentToolConfigLookup?.[agentId]?.[toolId]?.headers) {
-                // Get existing headers from saved data
-                toolHeaders = agentToolConfigLookup[agentId][toolId].headers;
+              const existingConfig = relationshipId
+                ? agentToolConfigLookup?.[agentId]?.[relationshipId]
+                : null;
+              if (existingConfig?.headers) {
+                toolHeaders = existingConfig.headers;
               }
             }
 
@@ -181,6 +189,7 @@ export function serializeGraphData(
               toolId,
               toolSelection,
               headers: toolHeaders,
+              ...(relationshipId && { agentToolRelationId: relationshipId }),
             });
           }
         }

package/src/features/graph/state/use-graph-store.ts

@@ -3,6 +3,8 @@ import { addEdge, applyEdgeChanges, applyNodeChanges } from '@xyflow/react';
 import { create } from 'zustand';
 import { devtools } from 'zustand/middleware';
 import type { GraphMetadata } from '@/components/graph/configuration/graph-types';
+import { mcpNodeHandleId, NodeType } from '@/components/graph/configuration/node-types';
+import type { AgentToolConfigLookup } from '@/components/graph/graph';
 import type { ArtifactComponent } from '@/lib/api/artifact-components';
 import type { DataComponent } from '@/lib/api/data-components';
 import type { MCPTool } from '@/lib/types/tools';
@@ -17,7 +19,7 @@ type GraphStateData = {
   dataComponentLookup: Record<string, DataComponent>;
   artifactComponentLookup: Record<string, ArtifactComponent>;
   toolLookup: Record<string, MCPTool>;
-  selectedToolsLookup: Record<string, Record<string, string[]>>;
+  agentToolConfigLookup: AgentToolConfigLookup;
   dirty: boolean;
   history: HistoryEntry[];
   future: HistoryEntry[];
@@ -33,12 +35,12 @@ type GraphState = GraphStateData & {
     dataComponentLookup?: Record<string, DataComponent>,
     artifactComponentLookup?: Record<string, ArtifactComponent>,
     toolLookup?: Record<string, MCPTool>,
-    selectedToolsLookup?: Record<string, Record<string, string[]>>
+    agentToolConfigLookup?: AgentToolConfigLookup
   ): void;
   setDataComponentLookup(dataComponentLookup: Record<string, DataComponent>): void;
   setArtifactComponentLookup(artifactComponentLookup: Record<string, ArtifactComponent>): void;
   setToolLookup(toolLookup: Record<string, MCPTool>): void;
-  setSelectedToolsLookup(selectedToolsLookup: Record<string, Record<string, string[]>>): void;
+  setAgentToolConfigLookup(agentToolConfigLookup: AgentToolConfigLookup): void;
   setNodes(updater: (prev: Node[]) => Node[]): void;
   setEdges(updater: (prev: Edge[]) => Edge[]): void;
   onNodesChange(changes: NodeChange[]): void;
@@ -82,7 +84,7 @@ export const useGraphStore = create<GraphState>()(
     dataComponentLookup: {},
     artifactComponentLookup: {},
     toolLookup: {},
-    selectedToolsLookup: {},
+    agentToolConfigLookup: {},
     dirty: false,
     history: [],
     future: [],
@@ -95,7 +97,7 @@ export const useGraphStore = create<GraphState>()(
       dataComponentLookup = {},
       artifactComponentLookup = {},
       toolLookup = {},
-      selectedToolsLookup = {}
+      agentToolConfigLookup = {}
     ) {
       set({
         nodes,
@@ -104,7 +106,7 @@ export const useGraphStore = create<GraphState>()(
         dataComponentLookup,
         artifactComponentLookup,
         toolLookup,
-        selectedToolsLookup,
+        agentToolConfigLookup,
         dirty: false,
         history: [],
         future: [],
@@ -121,8 +123,8 @@ export const useGraphStore = create<GraphState>()(
     setToolLookup(toolLookup) {
       set({ toolLookup });
     },
-    setSelectedToolsLookup(selectedToolsLookup) {
-      set({ selectedToolsLookup });
+    setAgentToolConfigLookup(agentToolConfigLookup) {
+      set({ agentToolConfigLookup });
     },
     setNodes(updater) {
       set((state) => ({ nodes: updater(state.nodes) }));
@@ -158,11 +160,33 @@ export const useGraphStore = create<GraphState>()(
         (change) => change.type === 'remove' || change.type === 'add' || change.type === 'replace'
       );
 
-      set((state) => ({
-        history: [...state.history, { nodes: state.nodes, edges: state.edges }],
-        edges: applyEdgeChanges(changes, state.edges),
-        dirty: hasModifyingChange ? true : state.dirty,
-      }));
+      set((state) => {
+        // Check for edge removals that disconnect agent from MCP node
+        const removeChanges = changes.filter((change) => change.type === 'remove');
+        let updatedNodes = state.nodes;
+
+        for (const removeChange of removeChanges) {
+          const edgeToRemove = state.edges.find((e) => e.id === removeChange.id);
+          if (edgeToRemove && edgeToRemove.targetHandle === mcpNodeHandleId) {
+            // Find the target MCP node and clear its agentId
+            const mcpNode = state.nodes.find((n) => n.id === edgeToRemove.target);
+            if (mcpNode && mcpNode.type === NodeType.MCP) {
+              updatedNodes = updatedNodes.map((n) =>
+                n.id === mcpNode.id
+                  ? { ...n, data: { ...n.data, agentId: null, relationshipId: null } }
+                  : n
+              );
+            }
+          }
+        }
+
+        return {
+          history: [...state.history, { nodes: state.nodes, edges: state.edges }],
+          nodes: updatedNodes,
+          edges: applyEdgeChanges(changes, state.edges),
+          dirty: hasModifyingChange ? true : state.dirty,
+        };
+      });
     },
     onConnect(connection) {
       set((state) => ({ edges: addEdge(connection as any, state.edges) }));

package/src/lib/utils/orphaned-tools-detector.ts

@@ -1,16 +1,16 @@
-import type { Node } from '@xyflow/react';
+import type { Edge, Node } from '@xyflow/react';
 import { getActiveTools } from '@/app/utils/active-tools';
 import type { MCPNodeData } from '@/components/graph/configuration/node-types';
 import { NodeType } from '@/components/graph/configuration/node-types';
 import type { MCPTool } from '@/lib/types/tools';
 
-export interface OrphanedToolsInfo {
+interface OrphanedToolsInfo {
   nodeId: string;
   nodeName: string;
   orphanedTools: string[];
 }
 
-export interface OrphanedToolsDetectionResult {
+interface OrphanedToolsDetectionResult {
   hasOrphanedTools: boolean;
   orphanedToolsByNode: OrphanedToolsInfo[];
   totalOrphanedCount: number;
@@ -22,62 +22,26 @@ export interface OrphanedToolsDetectionResult {
  */
 export function detectOrphanedToolsAndGetWarning(
   nodes: Node[],
-  selectedToolsLookup: Record<string, Record<string, string[]>>,
+  agentToolConfigLookup: Record<
+    string,
+    Record<string, { toolId: string; toolSelection?: string[] }>
+  >,
   toolLookup: Record<string, MCPTool>
 ): string | null {
-  const result = detectOrphanedToolsInGraph(nodes, selectedToolsLookup, toolLookup);
+  const result = detectOrphanedToolsInGraph(nodes, agentToolConfigLookup, toolLookup);
   return result.hasOrphanedTools ? createOrphanedToolsWarningMessage(result) : null;
 }
 
-/**
- * Extract shared logic for getting selected tools for a node
- * This replaces the duplicated logic between detector and MCP node editor
- */
-export function getCurrentSelectedToolsForNode(
-  node: { data: MCPNodeData },
-  selectedToolsLookup: Record<string, Record<string, string[]>>
-): string[] | null {
-  // First check if we have temporary selections stored on the node (from recent clicks)
-  if ((node.data as any).tempSelectedTools !== undefined) {
-    return (node.data as any).tempSelectedTools;
-  }
-
-  // Otherwise, get from the database/initial state
-  const allSelectedTools = new Set<string>();
-  let hasAnyData = false;
-  let hasEmptyArray = false;
-  let hasNullValue = false;
-
-  Object.values(selectedToolsLookup).forEach((agentTools) => {
-    const toolsForThisMCP = agentTools[node.data.toolId];
-    if (toolsForThisMCP !== undefined) {
-      hasAnyData = true;
-      if (Array.isArray(toolsForThisMCP) && toolsForThisMCP.length === 0) {
-        hasEmptyArray = true;
-      } else if (toolsForThisMCP === null) {
-        hasNullValue = true;
-      } else if (Array.isArray(toolsForThisMCP)) {
-        toolsForThisMCP.forEach((tool) => {
-          allSelectedTools.add(tool);
-        });
-      }
-    }
-  });
-
-  if (hasNullValue) return null;
-  if (hasEmptyArray) return [];
-  if (!hasAnyData) return null;
-
-  return Array.from(allSelectedTools);
-}
-
 /**
  * Detects orphaned tools across all MCP nodes in the graph
  * Orphaned tools are tools that were selected but are no longer available in the MCP server
  */
-export function detectOrphanedToolsInGraph(
+function detectOrphanedToolsInGraph(
   nodes: Node[],
-  selectedToolsLookup: Record<string, Record<string, string[]>>,
+  agentToolConfigLookup: Record<
+    string,
+    Record<string, { toolId: string; toolSelection?: string[] }>
+  >,
   toolLookup: Record<string, MCPTool>
 ): OrphanedToolsDetectionResult {
   const orphanedToolsByNode: OrphanedToolsInfo[] = [];
@@ -94,7 +58,7 @@ export function detectOrphanedToolsInGraph(
       activeTools: toolData.config?.mcp?.activeTools,
     });
 
-    const selectedTools = getCurrentSelectedToolsForNode(node, selectedToolsLookup);
+    const selectedTools = getCurrentSelectedToolsForNode(node, agentToolConfigLookup, []);
 
     // Find orphaned tools for this node
     const orphanedTools =
@@ -143,3 +107,65 @@ export function createOrphanedToolsWarningMessage(result: OrphanedToolsDetection
 
   return `${nodeCount} MCP servers have a total of ${toolCount} selected tools that are no longer available. These orphaned tools will not be available at runtime. Please update your tool selections.`;
 }
+
+/**
+ * Enhanced lookup for selected tools - uses relationshipId for true isolation
+ */
+export function getCurrentSelectedToolsForNode(
+  node: { data: MCPNodeData; id: string },
+  agentToolConfigLookup: Record<
+    string,
+    Record<string, { toolId: string; toolSelection?: string[] | null }>
+  >,
+  _edges: Edge[]
+): string[] | null {
+  // First check if we have temporary selections stored on the node (from recent clicks)
+  if ((node.data as any).tempSelectedTools !== undefined) {
+    return (node.data as any).tempSelectedTools;
+  }
+
+  // If node has relationshipId, find config by relationshipId
+  const relationshipId = (node.data as any).relationshipId;
+  if (relationshipId) {
+    for (const toolsMap of Object.values(agentToolConfigLookup)) {
+      const config = toolsMap[relationshipId];
+      if (config) {
+        return config.toolSelection || null;
+      }
+    }
+  }
+
+  // No relationshipId found, return null (show all tools selected)
+  return null;
+}
+
+/**
+ * Enhanced lookup for headers - uses relationshipId
+ */
+export function getCurrentHeadersForNode(
+  node: { data: MCPNodeData; id: string },
+  agentToolConfigLookup: Record<
+    string,
+    Record<string, { toolId: string; headers?: Record<string, string> }>
+  >,
+  _edges: Edge[]
+): Record<string, string> {
+  // First check if we have temporary headers stored on the node (from recent edits)
+  if ((node.data as any).tempHeaders !== undefined) {
+    return (node.data as any).tempHeaders;
+  }
+
+  // If node has relationshipId, find config by relationshipId
+  const relationshipId = (node.data as any).relationshipId;
+  if (relationshipId) {
+    for (const toolsMap of Object.values(agentToolConfigLookup)) {
+      const config = toolsMap[relationshipId];
+      if (config) {
+        return config.headers || {};
+      }
+    }
+  }
+
+  // No relationshipId found, return empty headers
+  return {};
+}