@inkeep/agents-manage-ui 0.18.1 → 0.19.0

package/src/hooks/use-ai-calls-query-state.ts

@@ -9,7 +9,7 @@ export type TimeRange = (typeof timeRanges)[number];
  * Provides type-safe query parameter management for:
  * - Time range selection (24h, 7d, 15d, custom)
  * - Custom date range (start/end dates)
- * - Graph filtering
+ * - Agent filtering
  * - Model filtering
  */
 export function useAICallsQueryState() {
@@ -22,7 +22,7 @@ export function useAICallsQueryState() {
     customEndDate: parseAsString.withDefault(''),
 
     // Filtering options
-    selectedGraph: parseAsString.withDefault('all'),
+    selectedAgent: parseAsString.withDefault('all'),
     selectedModel: parseAsString.withDefault('all'),
   });
 
@@ -31,7 +31,7 @@ export function useAICallsQueryState() {
     timeRange: queryState.timeRange,
     customStartDate: queryState.customStartDate,
     customEndDate: queryState.customEndDate,
-    selectedGraph: queryState.selectedGraph,
+    selectedAgent: queryState.selectedAgent,
     selectedModel: queryState.selectedModel,
 
     // State setters
@@ -41,11 +41,11 @@ export function useAICallsQueryState() {
     setTimeRange: (timeRange: TimeRange) => setQueryState({ timeRange }),
     setCustomDateRange: (start: string, end: string) =>
       setQueryState({ customStartDate: start, customEndDate: end }),
-    setGraphFilter: (graph: string) => setQueryState({ selectedGraph: graph }),
+    setAgentFilter: (agent: string) => setQueryState({ selectedAgent: agent }),
     setModelFilter: (model: string) => setQueryState({ selectedModel: model }),
     clearFilters: () =>
       setQueryState({
-        selectedGraph: 'all',
+        selectedAgent: 'all',
         selectedModel: 'all',
         timeRange: '15d',
         customStartDate: '',

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

@@ -30,7 +30,7 @@ export function useAutoPrefillIdZustand({
     currentIdValue.current = idValue;
   }, [onIdChange, idValue]);
 
-  // Reset manual edit tracking when switching between graphs
+  // Reset manual edit tracking when switching between agent
   useEffect(() => {
     if (isEditing) {
       hasManuallyEditedId.current = false;

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

@@ -1,7 +1,7 @@
 import { useReactFlow } from '@xyflow/react';
 import { useCallback, useRef } from 'react';
-import { useGraphActions } from '@/features/graph/state/use-graph-store';
-import type { ErrorHelpers } from './use-graph-errors';
+import { useAgentActions } from '@/features/agent/state/use-agent-store';
+import type { ErrorHelpers } from './use-agent-errors';
 
 interface UseNodeEditorOptions {
   selectedNodeId: string;
@@ -10,7 +10,7 @@ interface UseNodeEditorOptions {
 
 export function useNodeEditor({ selectedNodeId, errorHelpers }: UseNodeEditorOptions) {
   const { updateNodeData } = useReactFlow();
-  const { markUnsaved } = useGraphActions();
+  const { markUnsaved } = useAgentActions();
 
   // Focus management for error fields
   const fieldRefs = useRef<Record<string, HTMLElement>>({});

package/src/hooks/use-side-pane.ts

@@ -1,6 +1,6 @@
 import { parseAsString, parseAsStringLiteral, useQueryStates } from 'nuqs';
 
-const paneType = ['graph', 'node', 'edge'] as const;
+const paneType = ['agent', 'node', 'edge'] as const;
 
 export function useSidePane() {
   const [queryState, setQueryState] = useQueryStates({
@@ -15,6 +15,6 @@ export function useSidePane() {
     edgeId: queryState.edgeId,
     isOpen: Boolean(queryState.pane),
     setQueryState,
-    openGraphPane: () => setQueryState({ pane: 'graph', nodeId: null, edgeId: null }),
+    openAgentPane: () => setQueryState({ pane: 'agent', nodeId: null, edgeId: null }),
   };
 }

package/src/hooks/use-traces.ts

@@ -38,7 +38,7 @@ export interface UseConversationStatsOptions {
     pageSize?: number;
   };
   searchQuery?: string;
-  graphId?: string;
+  agentId?: string;
 }
 
 export function useConversationStats(
@@ -77,7 +77,7 @@ export function useConversationStats(
           options?.projectId,
           paginationParams,
           options?.searchQuery,
-          options?.graphId
+          options?.agentId
         );
 
         if (paginationEnabled && typeof result === 'object' && 'data' in result) {
@@ -105,7 +105,7 @@ export function useConversationStats(
       options?.filters,
       options?.projectId,
       options?.searchQuery,
-      options?.graphId,
+      options?.agentId,
       paginationEnabled,
       pageSize,
       currentPage,
@@ -187,7 +187,7 @@ export function useAggregateStats(options?: {
   endTime?: number;
   filters?: SpanFilterOptions;
   projectId?: string;
-  graphId?: string;
+  agentId?: string;
 }) {
   const [aggregateStats, setAggregateStats] = useState({
     totalToolCalls: 0,
@@ -213,7 +213,7 @@ export function useAggregateStats(options?: {
         currentEndTime,
         options?.filters,
         options?.projectId,
-        options?.graphId
+        options?.agentId
       );
 
       setAggregateStats(stats);
@@ -229,7 +229,7 @@ export function useAggregateStats(options?: {
     options?.endTime,
     options?.filters,
     options?.projectId,
-    options?.graphId,
+    options?.agentId,
   ]);
 
   useEffect(() => {

package/src/lib/README.md

@@ -28,13 +28,13 @@ import {
 } from '@/lib';
 ```
 
-### Create a new graph
+### Create a new agent
 
 ```typescript
 const result = await createFullGraphAction('tenant-123', {
-  id: 'my-graph',
-  name: 'My Customer Service Graph',
-  description: 'A graph for customer service operations',
+  id: 'my-agent',
+  name: 'My Customer Service Agent',
+  description: 'A agent for customer service operations',
   defaultSubAgentId: 'support-agent',
   agents: {
     'support-agent': {
@@ -55,55 +55,55 @@ const result = await createFullGraphAction('tenant-123', {
 });
 
 if (result.success) {
-  console.log('Graph created:', result.data);
+  console.log('Agent created:', result.data);
 } else {
   console.error('Error:', result.error);
 }
 ```
 
-### Get an existing graph
+### Get an existing agent
 
 ```typescript
-const result = await getFullGraphAction('tenant-123', 'my-graph');
+const result = await getFullGraphAction('tenant-123', 'my-agent');
 
 if (result.success) {
-  console.log('Graph retrieved:', result.data);
+  console.log('Agent retrieved:', result.data);
 } else {
   console.error('Error:', result.error);
 }
 ```
 
-### Update a graph
+### Update an agent
 
 ```typescript
 const updatedGraph = {
-  id: 'my-graph',
-  name: 'Updated Customer Service Graph',
+  id: 'my-agent',
+  name: 'Updated Customer Service Agent',
   // ... other properties
 };
 
-const result = await updateFullGraphAction('tenant-123', 'my-graph', updatedGraph);
+const result = await updateFullGraphAction('tenant-123', 'my-agent', updatedGraph);
 
 if (result.success) {
-  console.log('Graph updated:', result.data);
+  console.log('Agent updated:', result.data);
 } else {
   console.error('Error:', result.error);
 }
 ```
 
-### Delete a graph
+### Delete an agent
 
 ```typescript
-const result = await deleteFullGraphAction('tenant-123', 'my-graph');
+const result = await deleteFullGraphAction('tenant-123', 'my-agent');
 
 if (result.success) {
-  console.log('Graph deleted successfully');
+  console.log('Agent deleted successfully');
 } else {
   console.error('Error:', result.error);
 }
 ```
 
-### Validate graph data
+### Validate agent data
 
 Use this for form validation before submitting:
 
@@ -138,9 +138,9 @@ type ActionResult<T = void> = {
 
 The API may return the following error codes:
 
-- `not_found`: Graph not found
+- `not_found`: Agent not found
 - `bad_request`: Invalid request data
 - `internal_server_error`: Server error
-- `conflict`: Graph already exists (on create)
+- `conflict`: Agent already exists (on create)
 - `validation_error`: Client-side validation failed
 - `unknown_error`: Unexpected error occurred

package/src/lib/actions/{graph-full.ts → agent-full.ts}

@@ -1,26 +1,26 @@
 'use server';
 
 /**
- * Server Actions for Graph Full Operations
+ * Server Actions for Agent Full Operations
  *
- * These server actions wrap the GraphFull REST API endpoints and provide
+ * These server actions wrap the AgentFull REST API endpoints and provide
  * type-safe functions that can be called from React components.
  */
 
 import { revalidatePath } from 'next/cache';
 import {
   ApiError,
-  createFullGraph as apiCreateFullGraph,
-  deleteFullGraph as apiDeleteFullGraph,
-  fetchGraphs as apiFetchGraphs,
-  getFullGraph as apiGetFullGraph,
-  updateFullGraph as apiUpdateFullGraph,
-} from '../api/graph-full-client';
+  createFullAgent as apiCreateFullAgent,
+  deleteFullAgent as apiDeleteFullAgent,
+  fetchAgents as apiFetchAgents,
+  getFullAgent as apiGetFullAgent,
+  updateFullAgent as apiUpdateFullAgent,
+} from '../api/agent-full-client';
 import {
-  type FullGraphDefinition,
-  FullGraphDefinitionSchema,
-  type Graph,
-} from '../types/graph-full';
+  type FullAgentDefinition,
+  FullAgentDefinitionSchema,
+  type Agent,
+} from '../types/agent-full';
 
 /**
  * Result type for server actions - follows a consistent pattern
@@ -36,12 +36,12 @@ export type ActionResult<T = void> =
       code?: string;
     };
 
-export async function getAllGraphsAction(
+export async function getAllAgentsAction(
   tenantId: string,
   projectId: string
-): Promise<ActionResult<Graph[]>> {
+): Promise<ActionResult<Agent[]>> {
   try {
-    const response = await apiFetchGraphs(tenantId, projectId);
+    const response = await apiFetchAgents(tenantId, projectId);
     return {
       success: true,
       data: response.data,
@@ -49,26 +49,26 @@ export async function getAllGraphsAction(
   } catch (error) {
     return {
       success: false,
-      error: error instanceof Error ? error.message : 'Failed to fetch graphs',
+      error: error instanceof Error ? error.message : 'Failed to fetch agent',
       code: 'unknown_error',
     };
   }
 }
 
 /**
- * Create a new full graph
+ * Create a new full agent
  */
-export async function createFullGraphAction(
+export async function createFullAgentAction(
   tenantId: string,
   projectId: string,
-  graphData: FullGraphDefinition
-): Promise<ActionResult<FullGraphDefinition>> {
+  agentData: FullAgentDefinition
+): Promise<ActionResult<FullAgentDefinition>> {
   try {
-    const response = await apiCreateFullGraph(tenantId, projectId, graphData);
+    const response = await apiCreateFullAgent(tenantId, projectId, agentData);
 
     // Revalidate relevant pages
-    revalidatePath(`/${tenantId}/projects/${projectId}/graphs`);
-    revalidatePath(`/${tenantId}/projects/${projectId}/graphs/${response.data.id}`);
+    revalidatePath(`/${tenantId}/projects/${projectId}/agents`);
+    revalidatePath(`/${tenantId}/projects/${projectId}/agents/${response.data.id}`);
 
     return {
       success: true,
@@ -85,22 +85,22 @@ export async function createFullGraphAction(
 
     return {
       success: false,
-      error: error instanceof Error ? error.message : 'Failed to create graph',
+      error: error instanceof Error ? error.message : 'Failed to create agent',
       code: 'validation_error',
     };
   }
 }
 
 /**
- * Get a full graph by ID
+ * Get a full agent by ID
  */
-export async function getFullGraphAction(
+export async function getFullAgentAction(
   tenantId: string,
   projectId: string,
-  graphId: string
-): Promise<ActionResult<FullGraphDefinition>> {
+  agentId: string
+): Promise<ActionResult<FullAgentDefinition>> {
   try {
-    const response = await apiGetFullGraph(tenantId, projectId, graphId);
+    const response = await apiGetFullAgent(tenantId, projectId, agentId);
 
     return {
       success: true,
@@ -117,36 +117,36 @@ export async function getFullGraphAction(
 
     return {
       success: false,
-      error: error instanceof Error ? error.message : 'Failed to get graph',
+      error: error instanceof Error ? error.message : 'Failed to get agent',
       code: 'unknown_error',
     };
   }
 }
 
 /**
- * Update or create a full graph (upsert)
+ * Update or create a full agent (upsert)
  */
-export async function updateFullGraphAction(
+export async function updateFullAgentAction(
   tenantId: string,
   projectId: string,
-  graphId: string,
-  graphData: FullGraphDefinition
-): Promise<ActionResult<FullGraphDefinition>> {
+  agentId: string,
+  agentData: FullAgentDefinition
+): Promise<ActionResult<FullAgentDefinition>> {
   try {
-    // Ensure the graph ID matches
-    if (graphId !== graphData.id) {
+    // Ensure the agent ID matches
+    if (agentId !== agentData.id) {
       return {
         success: false,
-        error: `Graph ID mismatch: expected ${graphId}, got ${graphData.id}`,
+        error: `Agent ID mismatch: expected ${agentId}, got ${agentData.id}`,
         code: 'bad_request',
       };
     }
 
-    const response = await apiUpdateFullGraph(tenantId, projectId, graphId, graphData);
+    const response = await apiUpdateFullAgent(tenantId, projectId, agentId, agentData);
 
     // Revalidate relevant pages
-    revalidatePath(`/${tenantId}/projects/${projectId}/graphs`);
-    revalidatePath(`/${tenantId}/projects/${projectId}/graphs/${graphId}`);
+    revalidatePath(`/${tenantId}/projects/${projectId}/agents`);
+    revalidatePath(`/${tenantId}/projects/${projectId}/agents/${agentId}`);
 
     return {
       success: true,
@@ -163,25 +163,25 @@ export async function updateFullGraphAction(
 
     return {
       success: false,
-      error: error instanceof Error ? error.message : 'Failed to update graph',
+      error: error instanceof Error ? error.message : 'Failed to update agent',
       code: 'validation_error',
     };
   }
 }
 
 /**
- * Delete a full graph
+ * Delete a full agent
  */
-export async function deleteFullGraphAction(
+export async function deleteFullAgentAction(
   tenantId: string,
   projectId: string,
-  graphId: string
+  agentId: string
 ): Promise<ActionResult<void>> {
   try {
-    await apiDeleteFullGraph(tenantId, projectId, graphId);
+    await apiDeleteFullAgent(tenantId, projectId, agentId);
 
     // Revalidate relevant pages
-    revalidatePath(`/${tenantId}/projects/${projectId}/graphs`);
+    revalidatePath(`/${tenantId}/projects/${projectId}/agents`);
 
     return {
       success: true,
@@ -198,19 +198,19 @@ export async function deleteFullGraphAction(
 
     return {
       success: false,
-      error: error instanceof Error ? error.message : 'Failed to delete graph',
+      error: error instanceof Error ? error.message : 'Failed to delete agent',
       code: 'unknown_error',
     };
   }
 }
 
 /**
- * Validate graph data without making an API call
+ * Validate agent data without making an API call
  * Useful for form validation on the client side
  */
-export async function validateGraphData(data: unknown): Promise<ActionResult<FullGraphDefinition>> {
+export async function validateAgentData(data: unknown): Promise<ActionResult<FullAgentDefinition>> {
   try {
-    const validatedData = FullGraphDefinitionSchema.parse(data);
+    const validatedData = FullAgentDefinitionSchema.parse(data);
     return {
       success: true,
       data: validatedData,

package/src/lib/api/agent-full-client.ts

@@ -0,0 +1,109 @@
+/**
+ * API Client for Agent Full Operations
+ *
+ * This module provides HTTP client functions to communicate with the
+ * inkeep-chat backend AgentFull REST API endpoints.
+ */
+
+import { ApiError } from '../types/errors';
+import type {
+  CreateAgentResponse,
+  FullAgentDefinition,
+  GetAgentResponse,
+  Agent,
+  UpdateAgentResponse,
+} from '../types/agent-full';
+import type { ListResponse } from '../types/response';
+import { makeManagementApiRequest } from './api-config';
+import { validateProjectId, validateTenantId } from './resource-validation';
+
+export async function fetchAgents(
+  tenantId: string,
+  projectId: string
+): Promise<ListResponse<Agent>> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  return makeManagementApiRequest<ListResponse<Agent>>(
+    `tenants/${tenantId}/projects/${projectId}/agents`
+  );
+}
+
+/**
+ * Create a new full agent
+ */
+export async function createFullAgent(
+  tenantId: string,
+  projectId: string,
+  agentData: FullAgentDefinition
+): Promise<CreateAgentResponse> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  return makeManagementApiRequest<CreateAgentResponse>(
+    `tenants/${tenantId}/projects/${projectId}/agent`,
+    {
+      method: 'POST',
+      body: JSON.stringify(agentData),
+    }
+  );
+}
+
+/**
+ * Get a full agent by ID
+ */
+export async function getFullAgent(
+  tenantId: string,
+  projectId: string,
+  agentId: string
+): Promise<GetAgentResponse> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  return makeManagementApiRequest<GetAgentResponse>(
+    `tenants/${tenantId}/projects/${projectId}/agent/${agentId}`,
+    {
+      method: 'GET',
+    }
+  );
+}
+
+/**
+ * Update or create a full agent (upsert)
+ */
+export async function updateFullAgent(
+  tenantId: string,
+  projectId: string,
+  agentId: string,
+  agentData: FullAgentDefinition
+): Promise<UpdateAgentResponse> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  return makeManagementApiRequest<UpdateAgentResponse>(
+    `tenants/${tenantId}/projects/${projectId}/agent/${agentId}`,
+    {
+      method: 'PUT',
+      body: JSON.stringify(agentData),
+    }
+  );
+}
+
+/**
+ * Delete a full agent
+ */
+export async function deleteFullAgent(
+  tenantId: string,
+  projectId: string,
+  agentId: string
+): Promise<void> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  await makeManagementApiRequest(`tenants/${tenantId}/projects/${projectId}/agent/${agentId}`, {
+    method: 'DELETE',
+  });
+}
+
+// Export the error class for use in server actions
+export { ApiError };