@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/assistant.ts

@@ -1,490 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { agentInstanceManager, getStoreLattice } from "@axiom-lattice/core";
-import type {
-  Assistant,
-  CreateAssistantRequest,
-} from "@axiom-lattice/protocols";
-import { AgentType } from "@axiom-lattice/protocols";
-import type { A2ARemoteAgentConfig } from "@axiom-lattice/protocols";
-import { randomUUID } from "crypto";
-import type { AgentConfig } from "@axiom-lattice/core";
-import { agentLatticeManager, eventBus } from "@axiom-lattice/core";
-import { localA2AService } from "../services/local-a2a";
-import { normalizeA2AAgentCardUrl } from "../utils/a2a-url";
-import {
-  getAgentCardPort,
-  validateLocalRuntimeCommand,
-  validateLocalRuntimePort,
-} from "../utils/local-a2a-runtime";
-
-/**
- * Assistant Controller
- * Handles assistant-related CRUD operations
- * Merges code-configured agents (from @axiom-lattice/core) with in-memory stored assistants
- * GET operations return both code-configured and stored assistants
- * CUD operations only work on stored assistants
- */
-
-/**
- * Get tenant ID from authenticated user context
- * Falls back to request headers for backward compatibility
- */
-function getTenantId(request: FastifyRequest): string {
-  // First try to get from authenticated user context
-  const userTenantId = (request as any).user?.tenantId;
-  if (userTenantId) {
-    return userTenantId;
-  }
-
-  // Fallback to request headers for backward compatibility
-  return (request.headers["x-tenant-id"] as string) || "default";
-}
-
-function getUserId(request: FastifyRequest): string | undefined {
-  const userId = (request as any).user?.id;
-  if (userId) return userId;
-  return (request.headers["x-user-id"] as string) || undefined;
-}
-
-/**
- * Convert AgentConfig to Assistant format
- */
-function convertAgentConfigToAssistant(config: AgentConfig): Assistant {
-  return {
-    id: config.key,
-    tenantId: "default", // Code-configured agents belong to default tenant
-    name: config.name,
-    description: config.description,
-    graphDefinition: config, // Store the full config as graphDefinition
-    createdAt: new Date(0), // Code-configured agents have no creation date
-    updatedAt: new Date(0), // Code-configured agents have no update date
-  };
-}
-
-/**
- * Assistant list response interface
- */
-interface AssistantListResponse {
-  success: boolean;
-  message: string;
-  data: {
-    records: Assistant[];
-    total: number;
-  };
-}
-
-/**
- * Assistant response interface
- */
-interface AssistantResponse {
-  success: boolean;
-  message: string;
-  data?: Assistant;
-}
-
-/**
- * Assistant update request body interface
- */
-interface AssistantUpdateBody {
-  name?: string;
-  description?: string;
-  graphDefinition?: any;
-}
-
-/**
- * Get list of all assistants
- * Merges code-configured agents with stored assistants
- */
-export async function getAssistantList(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<AssistantListResponse> {
-  const tenantId = getTenantId(request);
-
-  // Get code-configured agents for the tenant
-  const agentConfigs = await agentLatticeManager.getAllAgentConfigsByTenant(tenantId);
-  const codeConfiguredAssistants = agentConfigs.map(
-    convertAgentConfigToAssistant
-  );
-
-  // Get stored assistants for the tenant
-  const storeLattice = getStoreLattice("default", "assistant");
-  const assistantStore = storeLattice.store;
-  const storedAssistants = await assistantStore.getAllAssistants(tenantId);
-
-  // Merge both sources, stored assistants take precedence if ID conflicts
-  const assistantMap = new Map<string, Assistant>();
-
-  // First add code-configured agents
-  codeConfiguredAssistants.forEach((assistant) => {
-    assistantMap.set(assistant.id, assistant);
-  });
-
-  // Then add stored assistants (overwrite if ID exists)
-  storedAssistants.forEach((assistant) => {
-    assistantMap.set(assistant.id, assistant);
-  });
-
-  const allAssistants = Array.from(assistantMap.values());
-
-  // Filter: exclude personal assistants owned by other users
-  const userId = getUserId(request);
-  const filtered = allAssistants.filter((a) => {
-    if (!a.ownerUserId) return true;
-    return a.ownerUserId === userId;
-  });
-
-  return {
-    success: true,
-    message: "Successfully retrieved assistant list",
-    data: {
-      records: filtered,
-      total: filtered.length,
-    },
-  };
-}
-
-/**
- * Get a single assistant by ID
- * Checks both code-configured agents and stored assistants
- */
-export async function getAssistant(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply
-): Promise<AssistantResponse> {
-  const { id } = request.params;
-  const tenantId = getTenantId(request);
-
-  // First check stored assistants
-  const storeLattice = getStoreLattice("default", "assistant");
-  const assistantStore = storeLattice.store;
-  let assistant = await assistantStore.getAssistantById(tenantId, id);
-
-  // If not found in store, check code-configured agents for the tenant
-  if (!assistant) {
-    const agentConfig = await agentLatticeManager.getAgentConfigWithTenant(tenantId, id);
-    if (agentConfig) {
-      assistant = convertAgentConfigToAssistant(agentConfig);
-    }
-  }
-
-  if (!assistant) {
-    return reply.status(404).send({
-      success: false,
-      message: "Assistant not found",
-    });
-  }
-
-  return {
-    success: true,
-    message: "Successfully retrieved assistant",
-    data: assistant,
-  };
-}
-
-/**
- * Upsert assistant - create if not exists in store, update if exists
- */
-async function upsertAssistant(
-  tenantId: string,
-  id: string,
-  data: CreateAssistantRequest | AssistantUpdateBody,
-  reply: FastifyReply,
-  requireFields: boolean = false
-): Promise<AssistantResponse> {
-  const storeLattice = getStoreLattice("default", "assistant");
-  const assistantStore = storeLattice.store;
-
-  const exists = await assistantStore.hasAssistant(tenantId, id);
-
-  let assistant: Assistant | null;
-  if (exists) {
-    assistant = await assistantStore.updateAssistant(tenantId, id, data);
-    if (!assistant) {
-      return reply.status(500).send({
-        success: false,
-        message: "Failed to update assistant",
-      });
-    }
-    eventBus.publish("assistant:updated", { id: assistant.id, name: assistant.name, tenantId });
-    return {
-      success: true,
-      message: "Updated assistant",
-      data: assistant,
-    };
-  }
-
-  if (requireFields) {
-    const createData = data as CreateAssistantRequest;
-    if (!createData.name || !createData.graphDefinition) {
-      return reply.status(400).send({
-        success: false,
-        message: "name and graphDefinition are required",
-      });
-    }
-  }
-
-  assistant = await assistantStore.createAssistant(tenantId, id, data as CreateAssistantRequest);
-  eventBus.publish("assistant:created", { id: assistant.id, name: assistant.name, tenantId });
-  return reply.status(201).send({
-    success: true,
-    message: "Created assistant",
-    data: assistant,
-  });
-}
-
-/**
- * Create a new assistant
- */
-export async function createAssistant(
-  request: FastifyRequest<{ Body: CreateAssistantRequest & { id?: string } }>,
-  reply: FastifyReply
-): Promise<AssistantResponse> {
-  const tenantId = getTenantId(request);
-  const data = request.body;
-
-  if (!data.name || !data.graphDefinition) {
-    return reply.status(400).send({
-      success: false,
-      message: "name and graphDefinition are required",
-    });
-  }
-
-  const id = data.id ?? randomUUID();
-
-  // A2A_REMOTE: validate agentCardUrl, check localRuntime conflicts
-  if (
-    data.graphDefinition &&
-    (data.graphDefinition as AgentConfig).type === AgentType.A2A_REMOTE
-  ) {
-    const a2aConfig = data.graphDefinition as A2ARemoteAgentConfig;
-    const warnings: string[] = [];
-    const isLocalManaged = !!a2aConfig.localRuntime;
-    a2aConfig.agentCardUrl = normalizeA2AAgentCardUrl(
-      a2aConfig.agentCardUrl,
-      isLocalManaged ? "http://" : "https://",
-    );
-
-    if (a2aConfig.localRuntime) {
-      const commandValidation = validateLocalRuntimeCommand(
-        a2aConfig.localRuntime,
-      );
-      if (!commandValidation.ok) {
-        return reply.status(400).send({
-          success: false,
-          message: commandValidation.error,
-        });
-      }
-      a2aConfig.localRuntime.command.executable =
-        a2aConfig.localRuntime.command.executable.trim();
-
-      a2aConfig.localRuntime.agentCardUrl = normalizeA2AAgentCardUrl(
-        a2aConfig.localRuntime.agentCardUrl || a2aConfig.agentCardUrl,
-        "http://",
-      );
-      a2aConfig.agentCardUrl = a2aConfig.localRuntime.agentCardUrl;
-
-      const portValidation = validateLocalRuntimePort(
-        a2aConfig.localRuntime,
-        a2aConfig.agentCardUrl,
-      );
-      if (!portValidation.ok) {
-        return reply.status(400).send({
-          success: false,
-          message: portValidation.error,
-        });
-      }
-    }
-
-    if (a2aConfig.localRuntime) {
-      const existingAssistants = await getStoreLattice("default", "assistant").store.getAllAssistants(tenantId);
-      const targetPort = getAgentCardPort(a2aConfig.localRuntime.agentCardUrl);
-      const duplicate = existingAssistants.find((a) => {
-        if (a.id === id) return false;
-        const gd = a.graphDefinition && typeof a.graphDefinition === "object"
-          ? a.graphDefinition
-          : undefined;
-        if (!gd || (gd as { type?: unknown }).type !== AgentType.A2A_REMOTE) return false;
-        const lr = (gd as A2ARemoteAgentConfig).localRuntime;
-        if (!lr) return false;
-        const existingAgentCardUrl = normalizeA2AAgentCardUrl(lr.agentCardUrl, "http://");
-        const existingPort = getAgentCardPort(existingAgentCardUrl);
-        if (targetPort !== null && existingPort !== null) {
-          return existingPort === targetPort;
-        }
-        return existingAgentCardUrl === a2aConfig.localRuntime!.agentCardUrl;
-      });
-      if (duplicate) {
-        const conflictDetail = targetPort === null
-          ? `agentCardUrl "${a2aConfig.localRuntime.agentCardUrl}"`
-          : `port ${targetPort}`;
-        return reply.status(409).send({
-          success: false,
-          message: `A local managed A2A assistant using ${conflictDetail} already exists: "${duplicate.name}". Each local managed A2A assistant needs a unique port.`,
-        });
-      }
-    }
-
-    // Validate agentCardUrl reachability (non-blocking)
-    try {
-      const resp = await fetch(a2aConfig.agentCardUrl, {
-        signal: AbortSignal.timeout(5000),
-      });
-      if (!resp.ok) {
-        warnings.push(`agentCardUrl returned HTTP ${resp.status}`);
-      }
-    } catch {
-      warnings.push(`agentCardUrl is not reachable: ${a2aConfig.agentCardUrl}`);
-    }
-
-    if (warnings.length > 0) {
-      console.warn(`[createAssistant] A2A warnings for ${a2aConfig.agentCardUrl}:`, warnings);
-    }
-  }
-
-  return upsertAssistant(tenantId, id, data, reply, true);
-}
-
-/**
- * Update an existing assistant by ID
- */
-export async function updateAssistant(
-  request: FastifyRequest<{
-    Params: { id: string };
-    Body: AssistantUpdateBody;
-  }>,
-  reply: FastifyReply
-): Promise<AssistantResponse> {
-  const tenantId = getTenantId(request);
-  const { id } = request.params;
-  const updates = request.body;
-
-  return upsertAssistant(tenantId, id, updates, reply, false);
-}
-
-/**
- * Delete an assistant by ID
- * For stored assistants: deletes from store
- * For local A2A agents: stops provider, unregisters from lattice, then deletes from store
- * For code-configured assistants: only deletes from store if exists (code registration remains)
- */
-export async function deleteAssistant(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; message: string }> {
-  const tenantId = getTenantId(request);
-  const { id } = request.params;
-
-  const storeLattice = getStoreLattice("default", "assistant");
-  const assistantStore = storeLattice.store;
-
-  const storedAssistant = await assistantStore.getAssistantById(tenantId, id);
-  const graphDefinition = storedAssistant?.graphDefinition;
-  const hasLocalRuntime =
-    graphDefinition && typeof graphDefinition === "object"
-      ? !!(graphDefinition as A2ARemoteAgentConfig).localRuntime
-      : false;
-
-  if (storedAssistant && hasLocalRuntime) {
-    localA2AService.removeState(id);
-    const deleted = await assistantStore.deleteAssistant(tenantId, id);
-    if (!deleted) {
-      return reply.status(500).send({
-        success: false,
-        message: "Failed to delete assistant",
-      });
-    }
-    eventBus.publish("assistant:deleted", { id, tenantId });
-    return {
-      success: true,
-      message: "Deleted local A2A assistant",
-    };
-  }
-
-  const agentConfig = await agentLatticeManager.getAgentConfigWithTenant(tenantId, id);
-  const isCodeConfigured = !!agentConfig;
-
-  if (isCodeConfigured) {
-    if (!storedAssistant) {
-      return reply.status(404).send({
-        success: false,
-        message: "Assistant not found (code-configured assistants cannot be deleted from code, only from store)",
-      });
-    }
-    await assistantStore.deleteAssistant(tenantId, id);
-    eventBus.publish("assistant:deleted", { id, tenantId });
-    return {
-      success: true,
-      message: "Deleted assistant from store (code-configured registration remains)",
-    };
-  }
-
-  if (!storedAssistant) {
-    return reply.status(404).send({
-      success: false,
-      message: "Assistant not found",
-    });
-  }
-
-  const deleted = await assistantStore.deleteAssistant(tenantId, id);
-
-  if (!deleted) {
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to delete assistant",
-    });
-  }
-
-  eventBus.publish("assistant:deleted", { id, tenantId });
-
-  // Clean up UserTenantLink metadata if this was a personal assistant
-  const userId = getUserId(request);
-  if (userId) {
-    try {
-      const linkStore = getStoreLattice("default", "userTenantLink").store;
-      const link = await linkStore.getLink(userId, tenantId);
-      const meta = (link?.metadata || {}) as Record<string, unknown>;
-      if (meta.personalAssistantId === id) {
-        delete meta.personalAssistantId;
-        delete meta.personalProjectId;
-        delete meta.personalWorkspaceId;
-        await linkStore.updateLink(userId, tenantId, { metadata: meta } as any);
-      }
-    } catch { /* best effort */ }
-  }
-
-  return {
-    success: true,
-    message: "Successfully deleted assistant",
-  };
-}
-
-/**
- * Get agent graph visualization
- */
-export const getAgentGraph = async (
-  request: FastifyRequest<{
-    Params: { assistantId: string };
-  }>,
-  reply: FastifyReply
-) => {
-  try {
-    const { assistantId } = request.params;
-    const tenant_id = getTenantId(request);
-
-    const agent = agentInstanceManager.getAgent({ assistant_id: assistantId, tenant_id, thread_id: '' })
-
-    // Call drawing service to get image data
-    const imageData = await agent.get_draw_graph()
-
-    // Set response header and return image data
-    reply.header("Content-Type", "application/json").send({
-      image: imageData,
-    });
-  } catch (error: any) {
-    reply.status(500).send({
-      success: false,
-      error: error.message || "Failed to get agent graph",
-    });
-  }
-};