@inkeep/agents-manage-ui 0.14.16 → 0.16.0

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

@@ -236,7 +236,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
         toolSelection: ['tool1', 'tool2'],
-        headers: {},
+        headers: null,
       });
     });
 
@@ -282,7 +282,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
         toolSelection: null,
-        headers: {},
+        headers: null,
       });
     });
 
@@ -326,7 +326,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
         toolSelection: [],
-        headers: {},
+        headers: null,
       });
     });
 
@@ -413,7 +413,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
         toolSelection: null, // null means all tools are selected
-        headers: {},
+        headers: null,
       });
     });
   });

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

@@ -6,6 +6,7 @@ import {
   agentNodeSourceHandleId,
   agentNodeTargetHandleId,
   externalAgentNodeTargetHandleId,
+  functionToolNodeHandleId,
   mcpNodeHandleId,
   NodeType,
 } from '@/components/graph/configuration/node-types';
@@ -200,32 +201,65 @@ export function deserializeGraphData(data: FullGraphDefinition): TransformResult
     nodes.push(agentNode);
   }
 
-  // Note: Tools are now project-scoped and not included in graph data
-  // Tool visualization will need to be handled at the project level
+  // Create tool nodes from canUse items (using tools and functions lookups)
   for (const agentId of agentIds) {
     const agent = data.agents[agentId];
     // Check if agent has canUse property (internal agents)
     if ('canUse' in agent && agent.canUse && agent.canUse.length > 0) {
-      // 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;
+
+        // Look up the tool to get its details
+        const tool = data.tools?.[toolId];
+        const toolType = tool?.config?.type || 'mcp'; // Default to MCP if not found
+
+        // Create the appropriate node type
+        const nodeType = toolType === 'function' ? NodeType.FunctionTool : NodeType.MCP;
+
+        // Populate node data with tool details from lookup
+        const nodeData: any = {
+          toolId,
+          agentId,
+          relationshipId,
+          // Add tool details from lookup for proper display
+          name: tool?.name,
+          description: tool?.description,
+          imageUrl: (tool as any)?.imageUrl,
+        };
+
+        // For function tools, add function details from functions lookup
+        if (toolType === 'function') {
+          const functionId = (tool as any)?.functionId;
+          if (functionId) {
+            const func = data.functions?.[functionId];
+            if (func) {
+              nodeData.inputSchema = func.inputSchema;
+              nodeData.code = func.executeCode;
+              nodeData.dependencies = func.dependencies;
+            }
+          }
+        }
+
         const toolNode: Node = {
           id: toolNodeId,
-          type: NodeType.MCP,
+          type: nodeType,
           position: { x: 0, y: 0 },
-          data: { toolId, agentId, relationshipId },
+          data: nodeData,
         };
         nodes.push(toolNode);
 
+        // Use the appropriate handle ID based on tool type
+        const targetHandle = toolType === 'function' ? functionToolNodeHandleId : mcpNodeHandleId;
+
         const agentToToolEdge: Edge = {
           id: `edge-${toolNodeId}-${agentId}`,
           type: EdgeType.Default,
           source: agentId,
           sourceHandle: agentNodeSourceHandleId,
           target: toolNodeId,
-          targetHandle: mcpNodeHandleId,
+          targetHandle,
         };
         edges.push(agentToToolEdge);
       }

package/src/features/graph/domain/graph-initializer-helpers.ts

@@ -3,9 +3,9 @@ import type { FullGraphDefinition } from '@/lib/types/graph-full';
 import { formatJsonField } from '@/lib/utils';
 
 export type ExtendedFullGraphDefinition = FullGraphDefinition & {
-  contextConfig?: Partial<Pick<ContextConfig, 'id' | 'name' | 'description'>> & {
+  contextConfig?: Partial<Pick<ContextConfig, 'id'>> & {
     contextVariables?: Record<string, any>;
-    requestContextSchema?: Record<string, any>;
+    headersSchema?: Record<string, any>;
   };
 };
 
@@ -54,10 +54,8 @@ export function extractGraphMetadata(
       : undefined,
     contextConfig: {
       id: graph?.contextConfig?.id ?? '',
-      name: graph?.contextConfig?.name ?? '',
-      description: graph?.contextConfig?.description ?? '',
       contextVariables: formatJsonField(graph?.contextConfig?.contextVariables) || '',
-      requestContextSchema: formatJsonField(graph?.contextConfig?.requestContextSchema) || '',
+      headersSchema: formatJsonField(graph?.contextConfig?.headersSchema) || '',
     },
   };
 }

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

@@ -115,11 +115,11 @@ export function serializeGraphData(
 
       const stopWhen = (node.data as any).stopWhen;
 
-      // Build canUse array from edges connecting this agent to MCP nodes
+      // Build canUse array from edges connecting this agent to tool nodes (MCP and Function)
       const canUse: Array<{
         toolId: string;
         toolSelection?: string[] | null;
-        headers?: Record<string, string>;
+        headers?: Record<string, string> | null;
         agentToolRelationId?: string;
       }> = [];
 
@@ -165,7 +165,7 @@ export function serializeGraphData(
             }
 
             const tempHeaders = (mcpNode.data as any).tempHeaders;
-            let toolHeaders: Record<string, string> = {};
+            let toolHeaders: Record<string, string> | null = null;
 
             if (tempHeaders !== undefined) {
               if (
@@ -195,6 +195,35 @@ export function serializeGraphData(
         }
       }
 
+      // Find edges from this agent to Function Tool nodes
+      const agentToFunctionToolEdges = edges.filter(
+        (edge) =>
+          edge.source === node.id &&
+          nodes.some((n) => n.id === edge.target && n.type === NodeType.FunctionTool)
+      );
+
+      for (const edge of agentToFunctionToolEdges) {
+        const functionToolNode = nodes.find((n) => n.id === edge.target);
+
+        if (functionToolNode && functionToolNode.type === NodeType.FunctionTool) {
+          const nodeData = functionToolNode.data as any;
+          const toolId = nodeData.toolId;
+
+          if (toolId) {
+            // Get the relationshipId if it exists
+            const relationshipId = nodeData.relationshipId;
+
+            // Function tools use the same simple structure as MCP tools
+            canUse.push({
+              toolId,
+              toolSelection: null, // Function tools don't have tool selection
+              headers: null, // Function tools don't have headers
+              ...(relationshipId && { agentToolRelationId: relationshipId }),
+            });
+          }
+        }
+      }
+
       const agent: ExtendedAgent = {
         id: agentId,
         name: node.data.name as string,
@@ -295,20 +324,18 @@ export function serializeGraphData(
 
   const parsedContextVariables = safeJsonParse(metadata?.contextConfig?.contextVariables);
 
-  const parsedRequestContextSchema = safeJsonParse(metadata?.contextConfig?.requestContextSchema);
+  const parsedHeadersSchema = safeJsonParse(metadata?.contextConfig?.headersSchema);
 
   const hasContextConfig =
     metadata?.contextConfig &&
-    ((metadata.contextConfig.name && metadata.contextConfig.name.trim() !== '') ||
-      (metadata.contextConfig.description && metadata.contextConfig.description.trim() !== '') ||
-      (parsedContextVariables &&
-        typeof parsedContextVariables === 'object' &&
-        parsedContextVariables !== null &&
-        Object.keys(parsedContextVariables).length > 0) ||
-      (parsedRequestContextSchema &&
-        typeof parsedRequestContextSchema === 'object' &&
-        parsedRequestContextSchema !== null &&
-        Object.keys(parsedRequestContextSchema).length > 0));
+    ((parsedContextVariables &&
+      typeof parsedContextVariables === 'object' &&
+      parsedContextVariables !== null &&
+      Object.keys(parsedContextVariables).length > 0) ||
+      (parsedHeadersSchema &&
+        typeof parsedHeadersSchema === 'object' &&
+        parsedHeadersSchema !== null &&
+        Object.keys(parsedHeadersSchema).length > 0));
 
   const dataComponents: Record<string, DataComponent> = {};
   if (dataComponentLookup) {
@@ -387,9 +414,7 @@ export function serializeGraphData(
     (result as any).contextConfigId = contextConfigId;
     (result as any).contextConfig = {
       id: contextConfigId,
-      name: metadata.contextConfig.name || '',
-      description: metadata.contextConfig.description || '',
-      requestContextSchema: parsedRequestContextSchema,
+      headersSchema: parsedHeadersSchema,
       contextVariables: parsedContextVariables,
     };
   }
@@ -419,6 +444,40 @@ export function validateSerializedData(data: FullGraphDefinition): string[] {
       }
     }
 
+    // Validate function tools for internal agents (check canUse array for function tools)
+    if ('canUse' in agent && agent.canUse) {
+      for (const canUseItem of agent.canUse) {
+        const toolId = canUseItem.toolId;
+        const toolType = (canUseItem as any).toolType;
+
+        // Only validate function tools
+        if (toolType === 'function') {
+          const functionTool = (canUseItem as any).functionTool;
+
+          if (!functionTool) {
+            errors.push(
+              `Function tool '${toolId}' referenced by agent '${agentId}' is missing function tool data`
+            );
+            continue;
+          }
+
+          // Validate required fields for function tools
+          if (!functionTool.name || String(functionTool.name).trim() === '') {
+            errors.push(`Function tool '${toolId}' is missing required field: name`);
+          }
+          if (!functionTool.description || String(functionTool.description).trim() === '') {
+            errors.push(`Function tool '${toolId}' is missing required field: description`);
+          }
+          if (!functionTool.executeCode || String(functionTool.executeCode).trim() === '') {
+            errors.push(`Function tool '${toolId}' is missing required field: executeCode`);
+          }
+          if (!functionTool.inputSchema || Object.keys(functionTool.inputSchema).length === 0) {
+            errors.push(`Function tool '${toolId}' is missing required field: inputSchema`);
+          }
+        }
+      }
+    }
+
     // Only validate relationships for internal agents (external agents don't have these properties)
     if ('canTransferTo' in agent) {
       for (const targetId of agent.canTransferTo ?? []) {

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

@@ -76,10 +76,8 @@ export const graphStore = create<GraphState>()(
       name: '',
       description: '',
       contextConfig: {
-        name: '',
-        description: '',
         contextVariables: '',
-        requestContextSchema: '',
+        headersSchema: '',
       },
       models: undefined,
       stopWhen: undefined,

package/src/lib/__tests__/context-suggestions.test.ts

@@ -4,7 +4,7 @@ import { getContextSuggestions } from '../context-suggestions';
 
 describe('getContextSuggestions', () => {
   const mockContextSchema = {
-    requestContextSchema: {
+    headersSchema: {
       type: 'object',
       properties: {
         user_id: { type: 'string' },
@@ -38,9 +38,9 @@ describe('getContextSuggestions', () => {
   it('should return all expected suggestions', () => {
     const suggestions = getContextSuggestions(mockContextSchema);
     expect(suggestions).toStrictEqual([
-      'requestContext.auth_token',
-      'requestContext.org_name',
-      'requestContext.user_id',
+      'headers.auth_token',
+      'headers.org_name',
+      'headers.user_id',
       'userName',
       'userName.name',
       'userName.preferences',
@@ -187,11 +187,11 @@ describe('getContextSuggestions', () => {
             responseSchema: z.toJSONSchema(settingsSchema),
           },
         },
-        requestContextSchema: z.toJSONSchema(z.object({ apiKey: z.string() })),
+        headersSchema: z.toJSONSchema(z.object({ apiKey: z.string() })),
       });
       expect(suggestions).toMatchInlineSnapshot(`
         [
-          "requestContext.apiKey",
+          "headers.apiKey",
           "settings",
           "settings.locale",
           "settings.theme",

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

@@ -18,11 +18,8 @@ import { makeManagementApiRequest } from './api-config';
 import { validateProjectId, validateTenantId } from './resource-validation';
 
 // Re-export types from core package for convenience
-// Note: ArtifactComponentApiSelect might have nullable props, but UI expects non-nullable
-export type ArtifactComponent = Omit<ArtifactComponentApiSelect, 'summaryProps' | 'fullProps'> & {
-  summaryProps: Record<string, any>; // Ensure summaryProps is non-nullable for UI compatibility
-  fullProps: Record<string, any>; // Ensure fullProps is non-nullable for UI compatibility
-};
+// Props can be null/undefined for optional artifact components
+export type ArtifactComponent = ArtifactComponentApiSelect;
 
 /**
  * Fetch all artifacts for a tenant
@@ -38,15 +35,8 @@ export async function fetchArtifactComponents(
     `tenants/${tenantId}/projects/${projectId}/artifact-components`
   );
 
-  // Transform the response to ensure props are non-nullable
-  return {
-    ...response,
-    data: response.data.map((item) => ({
-      ...item,
-      summaryProps: item.summaryProps || {},
-      fullProps: item.fullProps || {},
-    })),
-  };
+  // Return the response as-is, preserving null/undefined props
+  return response;
 }
 
 /**
@@ -64,12 +54,8 @@ export async function fetchArtifactComponent(
     `tenants/${tenantId}/projects/${projectId}/artifact-components/${artifactComponentId}`
   );
 
-  // Transform the response to ensure props are non-nullable
-  return {
-    ...response.data,
-    summaryProps: response.data.summaryProps || {},
-    fullProps: response.data.fullProps || {},
-  };
+  // Return the response as-is, preserving null/undefined props
+  return response.data;
 }
 
 /**
@@ -91,12 +77,8 @@ export async function createArtifactComponent(
     }
   );
 
-  // Transform the response to ensure props are non-nullable
-  return {
-    ...response.data,
-    summaryProps: response.data.summaryProps || {},
-    fullProps: response.data.fullProps || {},
-  };
+  // Return the response as-is, preserving null/undefined props
+  return response.data;
 }
 
 /**
@@ -118,12 +100,8 @@ export async function updateArtifactComponent(
     }
   );
 
-  // Transform the response to ensure props are non-nullable
-  return {
-    ...response.data,
-    summaryProps: response.data.summaryProps || {},
-    fullProps: response.data.fullProps || {},
-  };
+  // Return the response as-is, preserving null/undefined props
+  return response.data;
 }
 
 /**

package/src/lib/api/tools.ts

@@ -45,7 +45,8 @@ export async function fetchMCPTools(
     `tenants/${tenantId}/projects/${projectId}/tools?${params}`
   );
 
-  return response.data;
+  // Filter to only return MCP tools (config.type === 'mcp')
+  return response.data.filter((tool) => tool.config?.type === 'mcp');
 }
 
 /**

package/src/lib/context-suggestions.ts

@@ -3,7 +3,7 @@
  */
 
 export interface ContextSchema {
-  requestContextSchema?: Record<string, any>;
+  headersSchema?: Record<string, any>;
   contextVariables?: Record<
     string,
     {
@@ -73,11 +73,11 @@ function extractPathsFromSchema(
 export function getContextSuggestions(contextSchema: ContextSchema): string[] {
   const suggestions: string[] = [];
 
-  // Add requestContext properties (but not the top-level object)
-  if (contextSchema.requestContextSchema?.properties) {
-    const requestContextPaths = extractPathsFromSchema(contextSchema.requestContextSchema);
-    for (const path of requestContextPaths) {
-      suggestions.push(`requestContext.${path}`);
+  // Add headers properties (but not the top-level object)
+  if (contextSchema.headersSchema?.properties) {
+    const headersPaths = extractPathsFromSchema(contextSchema.headersSchema);
+    for (const path of headersPaths) {
+      suggestions.push(`headers.${path}`);
     }
   }
 

package/src/lib/json-schema-validation.ts

@@ -284,9 +284,9 @@ export function validateDataAgainstSchema(data: any, schema: any): ValidationRes
 }
 
 /**
- * Helper function to create a basic LLM-compatible schema template
+ * Helper function to create a basic schema template
  */
-export function createLlmSchemaTemplate(): string {
+export function createSchemaTemplate(): string {
   const template = {
     type: 'object',
     properties: {

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

@@ -7,31 +7,52 @@ import { z } from 'zod';
  * them with agent-builder specific utilities and types.
  */
 
-// Import and re-export client-safe schemas from @inkeep/agents-core client exports
-export {
-  // Types
-  type AgentApiInsert as AgentApi,
-  AgentApiInsertSchema as AgentApiSchema,
-  AgentGraphApiInsertSchema as AgentGraphApiSchema,
-  type AgentGraphInsert as AgentGraphApi,
+// Import core types and schemas
+import {
+  type AgentApiInsert,
+  AgentApiInsertSchema,
+  AgentGraphApiInsertSchema,
+  type AgentGraphInsert,
   ErrorResponseSchema,
   type ExternalAgentDefinition,
-  type FullGraphDefinition,
-  type InternalAgentDefinition,
-  // Core schemas
+  type FunctionApiInsert,
+  type FullGraphDefinition as CoreFullGraphDefinition,
   FullGraphDefinitionSchema,
+  type InternalAgentDefinition,
   ListResponseSchema,
-  // Response schemas
   SingleResponseSchema,
-  // Parameter schemas
   TenantParamsSchema,
-  ToolApiInsertSchema as ToolApiSchema,
-  type ToolInsert as ToolApi,
+  type ToolApiInsert,
+  ToolApiInsertSchema,
+  type ToolInsert,
 } from '@inkeep/agents-core/client-exports';
-
-import { type FullGraphDefinition, TenantParamsSchema } from '@inkeep/agents-core/client-exports';
 import type { SingleResponse } from './response';
 
+// Extend FullGraphDefinition with UI-specific lookup maps
+export type FullGraphDefinition = CoreFullGraphDefinition & {
+  tools?: Record<string, ToolApiInsert>;
+  functions?: Record<string, FunctionApiInsert>;
+};
+
+// Re-export core types with aliases
+export type AgentApi = AgentApiInsert;
+export type AgentGraphApi = AgentGraphInsert;
+export type ToolApi = ToolInsert;
+export const AgentApiSchema = AgentApiInsertSchema;
+export const AgentGraphApiSchema = AgentGraphApiInsertSchema;
+export const ToolApiSchema = ToolApiInsertSchema;
+
+// Re-export types and schemas
+export {
+  ErrorResponseSchema,
+  type ExternalAgentDefinition,
+  FullGraphDefinitionSchema,
+  type InternalAgentDefinition,
+  ListResponseSchema,
+  SingleResponseSchema,
+  TenantParamsSchema,
+};
+
 // Agent-builder specific parameter schema
 export const GraphIdParamsSchema = TenantParamsSchema.extend({
   graphId: z.string(),

package/src/lib/utils/graph-error-parser.ts

@@ -184,7 +184,7 @@ function getFieldDisplayName(field: string): string {
     delegateSourceToTarget: 'Delegate (Source to Target)',
     contextConfig: 'Context Configuration',
     contextVariables: 'Context Variables',
-    requestContextSchema: 'Request Context Schema',
+    headersSchema: 'Headers Schema',
   };
 
   return (

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

@@ -55,7 +55,7 @@ function detectOrphanedToolsInGraph(
 
     const activeTools = getActiveTools({
       availableTools: toolData.availableTools,
-      activeTools: toolData.config?.mcp?.activeTools,
+      activeTools: (toolData.config as any)?.mcp?.activeTools,
     });
 
     const selectedTools = getCurrentSelectedToolsForNode(node, agentToolConfigLookup, []);

package/.next/standalone/agents-manage-ui/.next/server/chunks/1288.js

@@ -1 +0,0 @@
-"use strict";exports.id=1288,exports.ids=[1288],exports.modules={41288:(a,b,c)=>{c.d(b,{createArchitectureServices:()=>d.S});var d=c(48167);c(66913)}};