@inkeep/agents-manage-ui 0.24.2 → 0.25.0

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-node-editor.ts

@@ -9,9 +9,13 @@ interface UseNodeEditorOptions {
 }
 
 export function useNodeEditor({ selectedNodeId, errorHelpers }: UseNodeEditorOptions) {
-  const { updateNodeData, setNodes } = 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) =>
@@ -144,6 +148,7 @@ export function useNodeEditor({ selectedNodeId, errorHelpers }: UseNodeEditorOpt
     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/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/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;
 

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

@@ -0,0 +1,121 @@
+'use server';
+
+import type { ExternalAgentApiInsert, ExternalAgentApiSelect } from '@inkeep/agents-core';
+
+import type { ListResponse, SingleResponse } from '../types/response';
+// Default configuration
+import { makeManagementApiRequest } from './api-config';
+import { validateProjectId, validateTenantId } from './resource-validation';
+
+// Use Omit to make id optional for creation
+type CreateExternalAgentRequest = Omit<ExternalAgentApiInsert, 'id'> & {
+  id?: string; // Make id optional for creation
+};
+
+export type ExternalAgent = ExternalAgentApiSelect;
+
+/**
+ * List all external agents for the current project
+ */
+export async function fetchExternalAgents(
+  tenantId: string,
+  projectId: string,
+  page = 1,
+  pageSize = 50
+): Promise<ExternalAgent[]> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  const params = new URLSearchParams({
+    page: page.toString(),
+    limit: pageSize.toString(),
+  });
+
+  const response = await makeManagementApiRequest<ListResponse<ExternalAgent>>(
+    `tenants/${tenantId}/projects/${projectId}/external-agents?${params}`
+  );
+
+  return response.data;
+}
+
+/**
+ * Get a single external agent by ID
+ */
+export async function fetchExternalAgent(
+  tenantId: string,
+  projectId: string,
+  id: string
+): Promise<ExternalAgent> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  const response = await makeManagementApiRequest<SingleResponse<ExternalAgent>>(
+    `tenants/${tenantId}/projects/${projectId}/external-agents/${id}`
+  );
+
+  return response.data;
+}
+
+/**
+ * Create a new external agent
+ */
+export async function createExternalAgent(
+  tenantId: string,
+  projectId: string,
+  data: CreateExternalAgentRequest
+): Promise<ExternalAgent> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  const response = await makeManagementApiRequest<SingleResponse<ExternalAgent>>(
+    `tenants/${tenantId}/projects/${projectId}/external-agents`,
+    {
+      method: 'POST',
+      body: JSON.stringify(data),
+    }
+  );
+
+  return response.data;
+}
+
+/**
+ * Update an existing external agent
+ */
+export async function updateExternalAgent(
+  tenantId: string,
+  projectId: string,
+  id: string,
+  data: Partial<CreateExternalAgentRequest>
+): Promise<ExternalAgent> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  const response = await makeManagementApiRequest<SingleResponse<ExternalAgent>>(
+    `tenants/${tenantId}/projects/${projectId}/external-agents/${id}`,
+    {
+      method: 'PUT',
+      body: JSON.stringify(data),
+    }
+  );
+
+  return response.data;
+}
+
+/**
+ * Delete an external agent
+ */
+export async function deleteExternalAgent(
+  tenantId: string,
+  projectId: string,
+  id: string
+): Promise<void> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  await makeManagementApiRequest<void>(
+    `tenants/${tenantId}/projects/${projectId}/external-agents/${id}`,
+    {
+      method: 'DELETE',
+    }
+  );
+}

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

@@ -9,12 +9,13 @@ import { z } from 'zod';
 
 // Import core types and schemas
 import {
-  type AgentApiInsert,
-  AgentApiInsertSchema,
   AgentAgentApiInsertSchema,
   type AgentAgentInsert,
+  type AgentApiInsert,
+  AgentApiInsertSchema,
   type FullAgentDefinition as CoreFullAgentDefinition,
   ErrorResponseSchema,
+  type ExternalAgentApiInsert,
   type ExternalAgentDefinition,
   FullAgentDefinitionSchema,
   type FunctionApiInsert,
@@ -31,6 +32,7 @@ import type { SingleResponse } from './response';
 // Extend FullAgentDefinition with UI-specific lookup maps
 export type FullAgentDefinition = CoreFullAgentDefinition & {
   tools?: Record<string, ToolApiInsert>;
+  externalAgents?: Record<string, ExternalAgentApiInsert>;
   functionTools?: Record<string, any>; // Function tools are agent-scoped
   functions?: Record<string, FunctionApiInsert>;
 };

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

@@ -0,0 +1,2 @@
+// Export the core ExternalAgent types for convenience
+export type { ExternalAgentApiSelect as ExternalAgent } from '@inkeep/agents-core';

package/src/lib/utils/external-agent-utils.ts

@@ -0,0 +1,33 @@
+import type { Edge } from '@xyflow/react';
+import type { ExternalAgentNodeData } from '@/components/agent/configuration/node-types';
+
+/**
+ * Enhanced lookup for headers - uses relationshipId
+ */
+export function getCurrentHeadersForExternalAgentNode(
+  node: { data: ExternalAgentNodeData; id: string },
+  subAgentExternalAgentConfigLookup: Record<
+    string,
+    Record<string, { externalAgentId: 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 externalAgentMap of Object.values(subAgentExternalAgentConfigLookup)) {
+      const config = externalAgentMap[relationshipId];
+      if (config) {
+        return config.headers ?? {};
+      }
+    }
+  }
+
+  // No relationshipId found, return empty headers
+  return {};
+}