@inkeep/agents-manage-ui 0.24.1 → 0.25.0

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

@@ -1,6 +1,8 @@
 import type { Edge, Node } from '@xyflow/react';
-import { nanoid } from 'nanoid';
-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';
-
-// 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;
+import type { ExternalAgent } from '@/lib/types/external-agents';
+import { generateId } from '@/lib/utils/id-utils';
+
+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;
-
-      // Parse headers from JSON string to object
-      const parsedHeaders = safeJsonParse(node.data.headers as string);
+      const externalAgentId = (node.data.id as string) || node.id;
 
-      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);
@@ -378,7 +442,7 @@ export function serializeAgentData(
   }
 
   const result: FullAgentDefinition = {
-    id: metadata?.id || nanoid(),
+    id: metadata?.id || generateId(),
     name: metadata?.name || 'Untitled Agent',
     description: metadata?.description || undefined,
     defaultSubAgentId,
@@ -432,7 +496,7 @@ export function serializeAgentData(
 
   // Add contextConfig if there's meaningful data
   if (hasContextConfig && metadata?.contextConfig) {
-    const contextConfigId = metadata.contextConfig.id || nanoid();
+    const contextConfigId = metadata.contextConfig.id || generateId();
     (result as any).contextConfigId = contextConfigId;
     (result as any).contextConfig = {
       id: contextConfigId,
@@ -458,9 +522,18 @@ export function validateSerializedData(
 ): StructuredValidationError[] {
   const errors: StructuredValidationError[] = [];
 
+  if (!data.defaultSubAgentId) {
+    errors.push({
+      message: 'Default sub agent ID is required, please select a default sub agent.',
+      field: 'defaultSubAgentId',
+      code: 'required',
+      path: ['defaultSubAgentId'],
+    });
+  }
+
   if (data.defaultSubAgentId && !data.subAgents[data.defaultSubAgentId]) {
     errors.push({
-      message: `Default agent ID '${data.defaultSubAgentId}' not found in agents.`,
+      message: `Default sub agent ID '${data.defaultSubAgentId}' not found in sub agents.`,
       field: 'defaultSubAgentId',
       code: 'invalid_reference',
       path: ['defaultSubAgentId'],
@@ -468,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) {
@@ -487,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;
@@ -552,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.`,

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

@@ -3,11 +3,15 @@ import { addEdge, applyEdgeChanges, applyNodeChanges } from '@xyflow/react';
 import { create } from 'zustand';
 import { devtools } from 'zustand/middleware';
 import { useShallow } from 'zustand/react/shallow';
-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 { mcpNodeHandleId, 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 { ExternalAgent } from '@/lib/types/external-agents';
 import type { MCPTool } from '@/lib/types/tools';
 import type { AgentErrorSummary } from '@/lib/utils/agent-error-parser';
 
@@ -20,7 +24,9 @@ type AgentStateData = {
   dataComponentLookup: Record<string, DataComponent>;
   artifactComponentLookup: Record<string, ArtifactComponent>;
   toolLookup: Record<string, MCPTool>;
+  externalAgentLookup: Record<string, ExternalAgent>;
   agentToolConfigLookup: AgentToolConfigLookup;
+  subAgentExternalAgentConfigLookup: SubAgentExternalAgentConfigLookup;
   dirty: boolean;
   history: HistoryEntry[];
   future: HistoryEntry[];
@@ -36,13 +42,19 @@ type AgentActions = {
     dataComponentLookup?: Record<string, DataComponent>,
     artifactComponentLookup?: Record<string, ArtifactComponent>,
     toolLookup?: Record<string, MCPTool>,
-    agentToolConfigLookup?: AgentToolConfigLookup
+    agentToolConfigLookup?: AgentToolConfigLookup,
+    externalAgentLookup?: Record<string, ExternalAgent>,
+    subAgentExternalAgentConfigLookup?: SubAgentExternalAgentConfigLookup
   ): void;
   reset(): void;
   setDataComponentLookup(dataComponentLookup: Record<string, DataComponent>): void;
   setArtifactComponentLookup(artifactComponentLookup: Record<string, ArtifactComponent>): void;
   setToolLookup(toolLookup: Record<string, MCPTool>): void;
   setAgentToolConfigLookup(agentToolConfigLookup: AgentToolConfigLookup): void;
+  setExternalAgentLookup(externalAgentLookup: Record<string, ExternalAgent>): void;
+  setSubAgentExternalAgentConfigLookup(
+    subAgentExternalAgentConfigLookup: SubAgentExternalAgentConfigLookup
+  ): void;
   setNodes(updater: (prev: Node[]) => Node[]): void;
   setEdges(updater: (prev: Edge[]) => Edge[]): void;
   onNodesChange(changes: NodeChange[]): void;
@@ -88,6 +100,8 @@ const initialAgentState: AgentStateData = {
   artifactComponentLookup: {},
   toolLookup: {},
   agentToolConfigLookup: {},
+  externalAgentLookup: {},
+  subAgentExternalAgentConfigLookup: {},
   dirty: false,
   history: [],
   future: [],
@@ -107,7 +121,9 @@ export const agentStore = create<AgentState>()(
         dataComponentLookup = {},
         artifactComponentLookup = {},
         toolLookup = {},
-        agentToolConfigLookup = {}
+        agentToolConfigLookup = {},
+        externalAgentLookup = {},
+        subAgentExternalAgentConfigLookup = {}
       ) {
         set({
           nodes,
@@ -117,6 +133,8 @@ export const agentStore = create<AgentState>()(
           artifactComponentLookup,
           toolLookup,
           agentToolConfigLookup,
+          externalAgentLookup,
+          subAgentExternalAgentConfigLookup,
           dirty: false,
           history: [],
           future: [],
@@ -139,6 +157,12 @@ export const agentStore = create<AgentState>()(
       setAgentToolConfigLookup(agentToolConfigLookup) {
         set({ agentToolConfigLookup });
       },
+      setExternalAgentLookup(externalAgentLookup) {
+        set({ externalAgentLookup });
+      },
+      setSubAgentExternalAgentConfigLookup(subAgentExternalAgentConfigLookup) {
+        set({ subAgentExternalAgentConfigLookup });
+      },
       setNodes(updater) {
         set((state) => ({ nodes: updater(state.nodes) }));
       },

package/src/hooks/use-auto-prefill-id-zustand.ts

@@ -1,5 +1,5 @@
 import { useEffect, useRef } from 'react';
-import { generateId } from '@/lib/utils/generate-id';
+import { generateIdFromName } from '@/lib/utils/generate-id';
 
 interface UseAutoPrefillIdZustandOptions {
   nameValue: string | undefined;
@@ -56,7 +56,7 @@ export function useAutoPrefillIdZustand({
   // Auto-prefill ID based on name field
   useEffect(() => {
     if (!isEditing && nameValue && !hasManuallyEditedId.current) {
-      const generatedId = generateId(nameValue);
+      const generatedId = generateIdFromName(nameValue);
 
       // Only update if the generated ID is different from current ID
       if (generatedId !== currentIdValue.current) {

package/src/hooks/use-auto-prefill-id.ts

@@ -1,6 +1,6 @@
 import { useEffect } from 'react';
 import { type FieldValues, type UseFormReturn, useWatch } from 'react-hook-form';
-import { generateId } from '@/lib/utils/generate-id';
+import { generateIdFromName } from '@/lib/utils/generate-id';
 
 interface UseAutoPrefillIdOptions<T extends FieldValues> {
   form: UseFormReturn<T>;
@@ -29,7 +29,7 @@ export function useAutoPrefillId<T extends FieldValues>({
   // biome-ignore lint/correctness/useExhaustiveDependencies: we don't want to re-run this effect when the isIdFieldModified changes since that means the user has manually edited the ID field
   useEffect(() => {
     if (!isEditing && nameValue && !isIdFieldModified) {
-      const generatedId = generateId(nameValue);
+      const generatedId = generateIdFromName(nameValue);
       form.setValue(idField as any, generatedId as any, {
         shouldValidate: true,
       });

package/src/hooks/use-node-editor.ts

@@ -9,9 +9,29 @@ interface UseNodeEditorOptions {
 }
 
 export function useNodeEditor({ selectedNodeId, errorHelpers }: UseNodeEditorOptions) {
-  const { updateNodeData } = useReactFlow();
+  const { updateNodeData, setNodes, deleteElements } = useReactFlow();
   const { markUnsaved } = useAgentActions();
 
+  const deleteNode = useCallback(() => {
+    deleteElements({ nodes: [{ id: selectedNodeId }] });
+  }, [selectedNodeId, deleteElements]);
+
+  const updateDefaultSubAgent = useCallback(
+    (isDefault: boolean) => {
+      setNodes((nodes) =>
+        nodes.map((node) => {
+          if (node.id === selectedNodeId) {
+            return { ...node, data: { ...node.data, isDefault }, deletable: !isDefault };
+          } else if (isDefault && node.data.isDefault) {
+            return { ...node, data: { ...node.data, isDefault: false }, deletable: true };
+          }
+          return node;
+        })
+      );
+    },
+    [selectedNodeId, setNodes]
+  );
+
   // Focus management for error fields
   const fieldRefs = useRef<Record<string, HTMLElement>>({});
 
@@ -127,6 +147,8 @@ export function useNodeEditor({ selectedNodeId, errorHelpers }: UseNodeEditorOpt
     updatePath,
     updateNestedPath,
     handleInputChange,
+    updateDefaultSubAgent,
+    deleteNode,
 
     // Error handling
     getFieldError,

package/src/lib/actions/agent-full.ts

@@ -17,9 +17,9 @@ import {
   updateFullAgent as apiUpdateFullAgent,
 } from '../api/agent-full-client';
 import {
+  type Agent,
   type FullAgentDefinition,
   FullAgentDefinitionSchema,
-  type Agent,
 } from '../types/agent-full';
 
 /**

package/src/lib/actions/artifact-components.ts

@@ -121,7 +121,6 @@ export async function deleteArtifactComponentAction(
   try {
     await deleteArtifactComponent(tenantId, projectId, artifactComponentId);
     revalidatePath(`/${tenantId}/projects/${projectId}/artifacts`);
-    revalidatePath(`/${tenantId}/projects/${projectId}/artifacts/${artifactComponentId}`);
     return {
       success: true,
     };

package/src/lib/actions/credentials.ts

@@ -20,7 +20,6 @@ export async function deleteCredentialAction(
   try {
     await deleteCredential(tenantId, projectId, credentialId);
     revalidatePath(`/${tenantId}/projects/${projectId}/credentials`);
-    revalidatePath(`/${tenantId}/projects/${projectId}/credentials/${credentialId}`);
     return {
       success: true,
     };

package/src/lib/actions/data-components.ts

@@ -122,7 +122,6 @@ export async function deleteDataComponentAction(
   try {
     await deleteDataComponent(tenantId, projectId, dataComponentId);
     revalidatePath(`/${tenantId}/projects/${projectId}/components`);
-    revalidatePath(`/${tenantId}/projects/${projectId}/components/${dataComponentId}`);
     return {
       success: true,
     };

package/src/lib/actions/external-agents.ts

@@ -0,0 +1,73 @@
+/**
+ * Server actions for external agent operations with path revalidation
+ */
+
+'use server';
+
+import { revalidatePath } from 'next/cache';
+import { deleteExternalAgent, fetchExternalAgents } from '../api/external-agents';
+import { ApiError } from '../types/errors';
+import type { ExternalAgent } from '../types/external-agents';
+import type { ActionResult } from './types';
+
+/**
+ * Fetch all external agents for a project
+ */
+export async function fetchExternalAgentsAction(
+  tenantId: string,
+  projectId: string
+): Promise<ActionResult<ExternalAgent[]>> {
+  try {
+    const externalAgents = await fetchExternalAgents(tenantId, projectId);
+    return {
+      success: true,
+      data: externalAgents,
+    };
+  } catch (error) {
+    if (error instanceof ApiError) {
+      return {
+        success: false,
+        error: error.message,
+        code: error.error.code,
+      };
+    }
+
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error occurred',
+      code: 'unknown_error',
+    };
+  }
+}
+
+/**
+ * Delete an external agent
+ */
+export async function deleteExternalAgentAction(
+  tenantId: string,
+  projectId: string,
+  externalAgentId: string
+): Promise<ActionResult<void>> {
+  try {
+    await deleteExternalAgent(tenantId, projectId, externalAgentId);
+    revalidatePath(`/${tenantId}/projects/${projectId}/external-agents`);
+    revalidatePath(`/${tenantId}/projects/${projectId}/external-agents/${externalAgentId}`);
+    return {
+      success: true,
+    };
+  } catch (error) {
+    if (error instanceof ApiError) {
+      return {
+        success: false,
+        error: error.message,
+        code: error.error.code,
+      };
+    }
+
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error occurred',
+      code: 'unknown_error',
+    };
+  }
+}

package/src/lib/actions/tools.ts

@@ -6,8 +6,8 @@
 
 import { revalidatePath } from 'next/cache';
 import { deleteMCPTool, fetchMCPTools } from '../api/tools';
-import type { MCPTool } from '../types/tools';
 import { ApiError } from '../types/errors';
+import type { MCPTool } from '../types/tools';
 import type { ActionResult } from './types';
 
 /**
@@ -46,12 +46,14 @@ export async function fetchToolsAction(
 export async function deleteToolAction(
   tenantId: string,
   projectId: string,
-  toolId: string
+  toolId: string,
+  shouldRevalidate = true
 ): Promise<ActionResult<void>> {
   try {
     await deleteMCPTool(tenantId, projectId, toolId);
-    revalidatePath(`/${tenantId}/projects/${projectId}/mcp-servers`);
-    revalidatePath(`/${tenantId}/projects/${projectId}/mcp-servers/${toolId}`);
+    if (shouldRevalidate) {
+      revalidatePath(`/${tenantId}/projects/${projectId}/mcp-servers`, 'page');
+    }
     return {
       success: true,
     };

package/src/lib/api/credentials.ts

@@ -3,6 +3,7 @@
 import type {
   CredentialReferenceApiInsert,
   CredentialReferenceApiSelect,
+  ExternalAgentApiSelect,
   McpTool,
 } from '@inkeep/agents-core';
 import type { ListResponse, SingleResponse } from '../types/response';
@@ -13,6 +14,7 @@ import { validateProjectId, validateTenantId } from './resource-validation';
 // Re-export types from core package for convenience
 export type Credential = CredentialReferenceApiSelect & {
   tools?: McpTool[];
+  externalAgents?: ExternalAgentApiSelect[];
 };
 export type CreateCredentialRequest = CredentialReferenceApiInsert;