@inkeep/agents-manage-ui 0.18.0 → 0.19.0

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 };