@inkeep/agents-manage-ui 0.24.2 → 0.25.0

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

@@ -10,11 +10,7 @@ import {
   mcpNodeHandleId,
   NodeType,
 } from '@/components/agent/configuration/node-types';
-import type {
-  ExternalAgentDefinition,
-  FullAgentDefinition,
-  InternalAgentDefinition,
-} from '@/lib/types/agent-full';
+import type { FullAgentDefinition } from '@/lib/types/agent-full';
 import { formatJsonField } from '@/lib/utils';
 
 interface TransformResult {
@@ -104,91 +100,78 @@ export function applyDagreLayout(nodes: Node[], edges: Edge[]): Node[] {
 export function deserializeAgentData(data: FullAgentDefinition): TransformResult {
   const nodes: Node[] = [];
   const edges: Edge[] = [];
+  const createdExternalAgentNodes = new Set<string>();
 
   const subAgentIds: string[] = Object.keys(data.subAgents);
   for (const subAgentId of subAgentIds) {
-    const agent = data.subAgents[subAgentId];
+    const subAgent = data.subAgents[subAgentId];
     const isDefault = subAgentId === data.defaultSubAgentId;
-    const isExternal = agent.type === 'external';
-
-    const nodeType = isExternal ? NodeType.ExternalAgent : NodeType.SubAgent;
-    const agentNodeData = isExternal
-      ? {
-          id: agent.id,
-          name: agent.name,
-          description: agent.description,
-          baseUrl: (agent as ExternalAgentDefinition).baseUrl,
-          headers: formatJsonField(agent.headers) || '{}',
-          type: agent.type,
-          credentialReferenceId: agent.credentialReferenceId,
-        }
-      : (() => {
-          const internalAgent = agent as InternalAgentDefinition;
-          return {
-            id: agent.id,
-            name: agent.name,
-            isDefault,
-            prompt: internalAgent.prompt,
-            description: agent.description,
-            dataComponents: internalAgent.dataComponents,
-            artifactComponents: internalAgent.artifactComponents,
-            models: internalAgent.models
-              ? {
-                  base: internalAgent.models.base
-                    ? {
-                        model: internalAgent.models.base.model ?? '',
-                        providerOptions: internalAgent.models.base.providerOptions
-                          ? formatJsonField(internalAgent.models.base.providerOptions)
-                          : undefined,
-                      }
-                    : undefined,
-                  structuredOutput: internalAgent.models.structuredOutput
-                    ? {
-                        model: internalAgent.models.structuredOutput.model ?? '',
-                        providerOptions: internalAgent.models.structuredOutput.providerOptions
-                          ? formatJsonField(internalAgent.models.structuredOutput.providerOptions)
-                          : undefined,
-                      }
-                    : undefined,
-                  summarizer: internalAgent.models.summarizer
-                    ? {
-                        model: internalAgent.models.summarizer.model ?? '',
-                        providerOptions: internalAgent.models.summarizer.providerOptions
-                          ? formatJsonField(internalAgent.models.summarizer.providerOptions)
-                          : undefined,
-                      }
-                    : undefined,
+
+    const nodeType = NodeType.SubAgent;
+    const agentNodeData = (() => {
+      return {
+        id: subAgent.id,
+        name: subAgent.name,
+        isDefault,
+        prompt: subAgent.prompt,
+        description: subAgent.description,
+        dataComponents: subAgent.dataComponents,
+        artifactComponents: subAgent.artifactComponents,
+        models: subAgent.models
+          ? {
+              base: subAgent.models.base
+                ? {
+                    model: subAgent.models.base.model ?? '',
+                    providerOptions: subAgent.models.base.providerOptions
+                      ? formatJsonField(subAgent.models.base.providerOptions)
+                      : undefined,
+                  }
+                : undefined,
+              structuredOutput: subAgent.models.structuredOutput
+                ? {
+                    model: subAgent.models.structuredOutput.model ?? '',
+                    providerOptions: subAgent.models.structuredOutput.providerOptions
+                      ? formatJsonField(subAgent.models.structuredOutput.providerOptions)
+                      : undefined,
+                  }
+                : undefined,
+              summarizer: subAgent.models.summarizer
+                ? {
+                    model: subAgent.models.summarizer.model ?? '',
+                    providerOptions: subAgent.models.summarizer.providerOptions
+                      ? formatJsonField(subAgent.models.summarizer.providerOptions)
+                      : undefined,
+                  }
+                : undefined,
+            }
+          : undefined,
+        stopWhen: subAgent.stopWhen ? { stepCountIs: subAgent.stopWhen.stepCountIs } : undefined,
+        type: subAgent.type,
+        tools: subAgent.canUse ? subAgent.canUse.map((item) => item.toolId) : [],
+        selectedTools: subAgent.canUse
+          ? subAgent.canUse.reduce(
+              (acc, item) => {
+                if (item.toolSelection) {
+                  acc[item.toolId] = item.toolSelection;
                 }
-              : undefined,
-            stopWhen: internalAgent.stopWhen
-              ? { stepCountIs: internalAgent.stopWhen.stepCountIs }
-              : undefined,
-            type: agent.type,
-            tools: internalAgent.canUse ? internalAgent.canUse.map((item) => item.toolId) : [],
-            selectedTools: internalAgent.canUse
-              ? internalAgent.canUse.reduce(
-                  (acc, item) => {
-                    if (item.toolSelection) {
-                      acc[item.toolId] = item.toolSelection;
-                    }
-                    return acc;
-                  },
-                  {} as Record<string, string[]>
-                )
-              : undefined,
-            headers: internalAgent.canUse
-              ? internalAgent.canUse.reduce(
-                  (acc, item) => {
-                    if (item.headers) {
-                      acc[item.toolId] = item.headers;
-                    }
-                    return acc;
-                  },
-                  {} as Record<string, Record<string, string>>
-                )
-              : undefined,
-          };
-        })();
+                return acc;
+              },
+              {} as Record<string, string[]>
+            )
+          : undefined,
+        headers: subAgent.canUse
+          ? subAgent.canUse.reduce(
+              (acc, item) => {
+                if (item.headers) {
+                  acc[item.toolId] = item.headers;
+                }
+                return acc;
+              },
+              {} as Record<string, Record<string, string>>
+            )
+          : undefined,
+      };
+    })();
 
     const agentNode: Node = {
       id: subAgentId,
@@ -296,30 +279,26 @@ export function deserializeAgentData(data: FullAgentDefinition): TransformResult
               false;
             const sourceCanDelegateToTarget =
               ('canDelegateTo' in sourceAgent &&
-                sourceAgent.canDelegateTo?.includes(targetSubAgentId)) ||
+                sourceAgent.canDelegateTo?.some((item) =>
+                  typeof item === 'string' ? item === targetSubAgentId : false
+                )) ||
               false;
             const targetCanDelegateToSource =
               ('canDelegateTo' in targetAgent &&
-                targetAgent.canDelegateTo?.includes(sourceSubAgentId)) ||
+                targetAgent.canDelegateTo?.some((item) =>
+                  typeof item === 'string' ? item === sourceSubAgentId : false
+                )) ||
               false;
 
-            const isTargetExternal = targetAgent.type === 'external';
-
             const edge = {
               id: isSelfReference
                 ? `edge-self-${sourceSubAgentId}`
                 : `edge-${targetSubAgentId}-${sourceSubAgentId}`,
-              type: isSelfReference
-                ? EdgeType.SelfLoop
-                : isTargetExternal
-                  ? EdgeType.A2AExternal
-                  : EdgeType.A2A,
+              type: isSelfReference ? EdgeType.SelfLoop : EdgeType.A2A,
               source: sourceSubAgentId,
               sourceHandle: agentNodeSourceHandleId,
               target: targetSubAgentId,
-              targetHandle: isTargetExternal
-                ? externalAgentNodeTargetHandleId
-                : agentNodeTargetHandleId,
+              targetHandle: agentNodeTargetHandleId,
               selected: false,
               data: {
                 relationships: {
@@ -337,8 +316,66 @@ export function deserializeAgentData(data: FullAgentDefinition): TransformResult
     }
 
     if ('canDelegateTo' in sourceAgent && sourceAgent.canDelegateTo) {
-      for (const targetSubAgentId of sourceAgent.canDelegateTo) {
-        if (data.subAgents[targetSubAgentId]) {
+      for (const targetSubAgent of sourceAgent.canDelegateTo) {
+        let targetSubAgentId: string;
+        let isTargetExternal: boolean;
+        let headers: Record<string, string> | undefined;
+        let relationshipId: string | undefined;
+
+        if (typeof targetSubAgent === 'object' && 'externalAgentId' in targetSubAgent) {
+          targetSubAgentId = targetSubAgent.externalAgentId;
+          isTargetExternal = true;
+          headers = targetSubAgent.headers ?? undefined;
+          relationshipId = targetSubAgent.subAgentExternalAgentRelationId;
+
+          // Create external agent node if it doesn't exist
+          if (!createdExternalAgentNodes.has(targetSubAgentId)) {
+            const externalAgent = data.externalAgents?.[targetSubAgentId];
+            if (externalAgent) {
+              const externalAgentNode: Node = {
+                id: targetSubAgentId,
+                type: NodeType.ExternalAgent,
+                position: { x: 0, y: 0 },
+                data: {
+                  id: externalAgent.id,
+                  name: externalAgent.name,
+                  description: externalAgent.description || '',
+                  baseUrl: externalAgent.baseUrl,
+                  credentialReferenceId: externalAgent.credentialReferenceId,
+                  relationshipId,
+                  tempHeaders: headers,
+                },
+              };
+              nodes.push(externalAgentNode);
+              createdExternalAgentNodes.add(targetSubAgentId);
+            }
+          }
+
+          // Create edge from source agent to external agent
+          const edge: Edge = {
+            id: `edge-${sourceSubAgentId}-${targetSubAgentId}`,
+            type: EdgeType.A2AExternal,
+            source: sourceSubAgentId,
+            sourceHandle: agentNodeSourceHandleId,
+            target: targetSubAgentId,
+            targetHandle: externalAgentNodeTargetHandleId,
+            selected: false,
+            data: {
+              relationships: {
+                transferTargetToSource: false,
+                transferSourceToTarget: false,
+                delegateTargetToSource: false,
+                delegateSourceToTarget: true,
+              },
+            },
+          };
+          edges.push(edge);
+        } else {
+          targetSubAgentId = targetSubAgent;
+          isTargetExternal = false;
+        }
+
+        if (!isTargetExternal && data.subAgents[targetSubAgentId]) {
           // Special handling for self-referencing edges
           const isSelfReference = sourceSubAgentId === targetSubAgentId;
           const pairKey = isSelfReference
@@ -359,30 +396,26 @@ export function deserializeAgentData(data: FullAgentDefinition): TransformResult
               false;
             const sourceCanDelegateToTarget =
               ('canDelegateTo' in sourceAgent &&
-                sourceAgent.canDelegateTo?.includes(targetSubAgentId)) ||
+                sourceAgent.canDelegateTo?.some((item) =>
+                  typeof item === 'string' ? item === targetSubAgentId : false
+                )) ||
               false;
             const targetCanDelegateToSource =
               ('canDelegateTo' in targetAgent &&
-                targetAgent.canDelegateTo?.includes(sourceSubAgentId)) ||
+                targetAgent.canDelegateTo?.some((item) =>
+                  typeof item === 'string' ? item === sourceSubAgentId : false
+                )) ||
               false;
 
-            const isTargetExternal = targetAgent.type === 'external';
-
             const edge = {
               id: isSelfReference
                 ? `edge-self-${sourceSubAgentId}`
                 : `edge-${targetSubAgentId}-${sourceSubAgentId}`,
-              type: isSelfReference
-                ? EdgeType.SelfLoop
-                : isTargetExternal
-                  ? EdgeType.A2AExternal
-                  : EdgeType.A2A,
+              type: isSelfReference ? EdgeType.SelfLoop : EdgeType.A2A,
               source: sourceSubAgentId,
               sourceHandle: agentNodeSourceHandleId,
               target: targetSubAgentId,
-              targetHandle: isTargetExternal
-                ? externalAgentNodeTargetHandleId
-                : agentNodeTargetHandleId,
+              targetHandle: agentNodeTargetHandleId,
               selected: false,
               data: {
                 relationships: {

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

@@ -1,6 +1,8 @@
-import { generateId } from '@/lib/utils/id-utils';
 import type { Edge, Node } from '@xyflow/react';
-import type { AgentToolConfigLookup } from '@/components/agent/agent';
+import type {
+  AgentToolConfigLookup,
+  SubAgentExternalAgentConfigLookup,
+} from '@/components/agent/agent';
 import type { AgentMetadata } from '@/components/agent/configuration/agent-types';
 import type { A2AEdgeData } from '@/components/agent/configuration/edge-types';
 import { EdgeType } from '@/components/agent/configuration/edge-types';
@@ -8,35 +10,16 @@ import { NodeType } from '@/components/agent/configuration/node-types';
 import type { ArtifactComponent } from '@/lib/api/artifact-components';
 import type { DataComponent } from '@/lib/api/data-components';
 import type { FullAgentDefinition, InternalAgentDefinition } from '@/lib/types/agent-full';
+import type { ExternalAgent } from '@/lib/types/external-agents';
+import { generateId } from '@/lib/utils/id-utils';
 
-// Use the exported InternalAgentDefinition from core
-type InternalAgent = InternalAgentDefinition;
-
-type ExternalAgent = {
-  id: string;
-  name: string;
-  description: string;
-  baseUrl: string;
-  headers?: Record<string, string> | null;
-  type: 'external';
-  credentialReferenceId?: string | null;
+export type ExtendedAgent = InternalAgentDefinition & {
+  dataComponents: string[];
+  artifactComponents: string[];
+  models?: AgentMetadata['models'];
+  type: 'internal';
 };
 
-export type ExtendedAgent =
-  | (InternalAgent & {
-      dataComponents: string[];
-      artifactComponents: string[];
-      models?: AgentMetadata['models'];
-      type: 'internal';
-    })
-  | ExternalAgent;
-
-function isInternalAgent(
-  agent: ExtendedAgent | FullAgentDefinition['subAgents'][string]
-): agent is InternalAgent {
-  return agent.type === 'internal' && 'canUse' in agent;
-}
-
 // Note: Tools are now project-scoped, not part of FullAgentDefinition
 
 /**
@@ -92,9 +75,11 @@ export function serializeAgentData(
   metadata?: AgentMetadata,
   dataComponentLookup?: Record<string, DataComponent>,
   artifactComponentLookup?: Record<string, ArtifactComponent>,
-  agentToolConfigLookup?: AgentToolConfigLookup
+  agentToolConfigLookup?: AgentToolConfigLookup,
+  subAgentExternalAgentConfigLookup?: SubAgentExternalAgentConfigLookup
 ): FullAgentDefinition {
   const subAgents: Record<string, ExtendedAgent> = {};
+  const externalAgents: Record<string, ExternalAgent> = {};
   const functionTools: Record<string, any> = {};
   const functions: Record<string, any> = {};
   // Note: Tools are now project-scoped and not included in agent serialization
@@ -265,27 +250,26 @@ export function serializeAgentData(
 
       subAgents[subAgentId] = agent;
     } else if (node.type === NodeType.ExternalAgent) {
-      const subAgentId = (node.data.id as string) || node.id;
+      const externalAgentId = (node.data.id as string) || node.id;
 
-      // Parse headers from JSON string to object
-      const parsedHeaders = safeJsonParse(node.data.headers as string);
-
-      const agent: ExternalAgent = {
-        id: subAgentId,
+      const externalAgent: ExternalAgent & {
+        tempHeaders: Record<string, string> | null;
+        relationshipId: string | null;
+      } = {
+        id: externalAgentId,
         name: node.data.name as string,
         description: (node.data.description as string) || '',
         baseUrl: node.data.baseUrl as string,
-        headers: parsedHeaders || null,
-        type: 'external',
+        createdAt: node.data.createdAt as string,
+        updatedAt: node.data.updatedAt as string,
         credentialReferenceId: (node.data.credentialReferenceId as string) || null,
+        tempHeaders: (node.data as any).tempHeaders || null,
+        relationshipId: (node.data.relationshipId as string) || null,
       };
 
-      if (node.data.isDefault) {
-        defaultSubAgentId = subAgentId;
-      }
-
-      subAgents[subAgentId] = agent;
+      externalAgents[externalAgentId] = externalAgent;
     }
+    // External agent nodes are skipped - they are project-scoped resources
   }
 
   for (const edge of edges) {
@@ -294,35 +278,115 @@ export function serializeAgentData(
       edge.type === EdgeType.A2AExternal ||
       edge.type === EdgeType.SelfLoop
     ) {
-      // edge.source and edge.target are the ids of the nodes (since we allow editing the agent ids we need to use node ids since those are stable)
-      // we need to find the agents based on the node ids and then update the agents canTransferTo and canDelegateTo with the agent ids not the node ids
-
       const sourceAgentNode = nodes.find((node) => node.id === edge.source);
       const targetAgentNode = nodes.find((node) => node.id === edge.target);
 
       const sourceSubAgentId = (sourceAgentNode?.data.id || sourceAgentNode?.id) as string;
       const targetSubAgentId = (targetAgentNode?.data.id || targetAgentNode?.id) as string;
       const sourceAgent: ExtendedAgent = subAgents[sourceSubAgentId];
-      const targetAgent: ExtendedAgent = subAgents[targetSubAgentId];
-
-      if (sourceAgent && targetAgent && (edge.data as any)?.relationships) {
-        const relationships = (edge.data as any).relationships as A2AEdgeData['relationships'];
-
-        // Helper function to safely add relationship to internal agent
-        const addRelationship = (
-          agent: ExtendedAgent,
-          relationshipType: 'canTransferTo' | 'canDelegateTo',
-          targetId: string
-        ) => {
-          if (isInternalAgent(agent)) {
-            if (!agent[relationshipType]) agent[relationshipType] = [];
-            const subAgentRelationships = agent[relationshipType];
-            if (subAgentRelationships && !subAgentRelationships.includes(targetId)) {
-              subAgentRelationships.push(targetId);
+
+      const targetAgent: ExtendedAgent | undefined = subAgents[targetSubAgentId];
+      const targetExternalAgent: ExternalAgent | undefined = externalAgents[targetSubAgentId];
+      const isTargetExternal = targetExternalAgent !== undefined;
+
+      if (!sourceAgent || !(edge.data as any)?.relationships) {
+        continue;
+      }
+
+      const relationships = (edge.data as any).relationships as A2AEdgeData['relationships'];
+
+      // Helper function to add relationship
+      const addRelationship = (
+        agent: ExtendedAgent,
+        relationshipType: 'canTransferTo' | 'canDelegateTo',
+        targetId: string,
+        isExternal: boolean = false,
+        headers?: Record<string, string>,
+        relationshipId?: string
+      ) => {
+        if (relationshipType === 'canDelegateTo') {
+          if (!agent.canDelegateTo) {
+            agent.canDelegateTo = [];
+          }
+
+          // External agents always use object format
+          if (isExternal) {
+            const existingIndex = agent.canDelegateTo.findIndex(
+              (item) =>
+                typeof item === 'object' &&
+                item.externalAgentId === targetId &&
+                item.subAgentExternalAgentRelationId === relationshipId
+            );
+
+            const relationshipData: any = {
+              externalAgentId: targetId,
+              headers: headers ?? null,
+            };
+
+            // Only include relationshipId if it's not null (schema expects optional, not nullable)
+            if (relationshipId) {
+              relationshipData.subAgentExternalAgentRelationId = relationshipId;
+            }
+
+            if (existingIndex !== -1) {
+              // Update existing relationship
+              agent.canDelegateTo[existingIndex] = relationshipData;
+            } else {
+              // Add new relationship
+              agent.canDelegateTo.push(relationshipData);
+            }
+          } else {
+            // Internal agents use string format
+            if (!agent.canDelegateTo.includes(targetId)) {
+              agent.canDelegateTo.push(targetId);
+            }
+          }
+        } else {
+          if (!agent.canTransferTo) agent.canTransferTo = [];
+          if (!agent.canTransferTo.includes(targetId)) {
+            agent.canTransferTo.push(targetId);
+          }
+        }
+      };
+
+      // Handle edges to external agents (only delegation is allowed)
+      if (isTargetExternal) {
+        if (relationships.delegateSourceToTarget) {
+          const tempHeaders = (targetExternalAgent as any).tempHeaders;
+          let externalAgentHeaders: Record<string, string> | undefined;
+          const relationshipId = (targetExternalAgent as any).relationshipId;
+
+          if (tempHeaders !== undefined) {
+            if (
+              typeof tempHeaders === 'object' &&
+              tempHeaders !== null &&
+              !Array.isArray(tempHeaders)
+            ) {
+              externalAgentHeaders = tempHeaders;
+            }
+          } else {
+            const existingConfig = relationshipId
+              ? subAgentExternalAgentConfigLookup?.[sourceSubAgentId]?.[relationshipId]
+              : null;
+            if (existingConfig?.headers) {
+              externalAgentHeaders = existingConfig.headers;
             }
           }
-        };
 
+          addRelationship(
+            sourceAgent,
+            'canDelegateTo',
+            targetSubAgentId,
+            true, // isExternal
+            externalAgentHeaders,
+            relationshipId
+          );
+        }
+        continue;
+      }
+
+      // Handle edges between internal agents
+      if (targetAgent) {
         // Process transfer relationships
         if (relationships.transferSourceToTarget) {
           addRelationship(sourceAgent, 'canTransferTo', targetSubAgentId);
@@ -477,8 +541,8 @@ export function validateSerializedData(
   }
 
   for (const [subAgentId, agent] of Object.entries(data.subAgents)) {
-    // Only validate tools for internal agents (external agents don't have tools)
-    if (isInternalAgent(agent) && agent.canUse) {
+    // All subAgents are internal agents (external agents are project-scoped)
+    if (agent.canUse) {
       // Skip tool validation if tools data is not available (project-scoped)
       const toolsData = (data as any).tools;
       if (toolsData) {
@@ -496,7 +560,7 @@ export function validateSerializedData(
       }
     }
 
-    if (isInternalAgent(agent) && agent.canUse) {
+    if (agent.canUse) {
       for (const canUseItem of agent.canUse) {
         const toolId = canUseItem.toolId;
         const toolType = (canUseItem as any).toolType;
@@ -561,19 +625,20 @@ export function validateSerializedData(
       }
     }
 
-    // Only validate relationships for internal agents (external agents don't have these properties)
-    if (isInternalAgent(agent)) {
-      for (const targetId of agent.canTransferTo ?? []) {
-        if (!data.subAgents[targetId]) {
-          errors.push({
-            message: `Transfer target '${targetId}' not found in agents.`,
-            field: 'canTransferTo',
-            code: 'invalid_reference',
-            path: ['agents', subAgentId, 'canTransferTo'],
-          });
-        }
+    // Validate relationships (all subAgents are internal agents)
+    for (const targetId of agent.canTransferTo ?? []) {
+      if (!data.subAgents[targetId]) {
+        errors.push({
+          message: `Transfer target '${targetId}' not found in agents.`,
+          field: 'canTransferTo',
+          code: 'invalid_reference',
+          path: ['agents', subAgentId, 'canTransferTo'],
+        });
       }
-      for (const targetId of agent.canDelegateTo ?? []) {
+    }
+    for (const targetId of agent.canDelegateTo ?? []) {
+      // String = internal subAgent
+      if (typeof targetId === 'string') {
         if (!data.subAgents[targetId]) {
           errors.push({
             message: `Delegate target '${targetId}' not found in agents.`,