@axiom-lattice/gateway 2.1.24 → 2.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.24",
+  "version": "2.1.26",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -36,9 +36,9 @@
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.19",
-    "@axiom-lattice/protocols": "2.1.11",
-    "@axiom-lattice/queue-redis": "1.0.10"
+    "@axiom-lattice/core": "2.1.21",
+    "@axiom-lattice/queue-redis": "1.0.11",
+    "@axiom-lattice/protocols": "2.1.12"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/controllers/assistant.ts

@@ -6,7 +6,7 @@ import type {
   CreateAssistantRequest,
 } from "@axiom-lattice/protocols";
 import { randomUUID } from "crypto";
-import { AgentConfig, getAllAgentConfigs } from "@axiom-lattice/core";
+import { AgentConfig, getAllAgentConfigs, eventBus } from "@axiom-lattice/core";
 
 /**
  * Assistant Controller
@@ -142,48 +142,78 @@ export async function getAssistant(
   };
 }
 
+/**
+ * Upsert assistant - create if not exists in store, update if exists
+ */
+async function upsertAssistant(
+  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(id);
+
+  let assistant: Assistant | null;
+  if (exists) {
+    assistant = await assistantStore.updateAssistant(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 });
+    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(id, data as CreateAssistantRequest);
+  eventBus.publish("assistant:created", { id: assistant.id, name: assistant.name });
+  return reply.status(201).send({
+    success: true,
+    message: "Created assistant",
+    data: assistant,
+  });
+}
+
 /**
  * Create a new assistant
  */
 export async function createAssistant(
-  request: FastifyRequest<{ Body: CreateAssistantRequest }>,
+  request: FastifyRequest<{ Body: CreateAssistantRequest & { id?: string } }>,
   reply: FastifyReply
 ): Promise<AssistantResponse> {
   const data = request.body;
 
-  // Validate required fields
-  if (!data.name) {
+  if (!data.name || !data.graphDefinition) {
     return reply.status(400).send({
       success: false,
-      message: "name is required",
+      message: "name and graphDefinition are required",
     });
   }
 
-  if (!data.graphDefinition) {
-    return reply.status(400).send({
-      success: false,
-      message: "graphDefinition is required",
-    });
-  }
-
-  // Generate ID if not provided
-  const id = randomUUID();
-
-  // Create assistant
-  const storeLattice = getStoreLattice("default", "assistant");
-  const assistantStore = storeLattice.store;
-  const newAssistant = await assistantStore.createAssistant(id, data);
-
-  return reply.status(201).send({
-    success: true,
-    message: "Successfully created assistant",
-    data: newAssistant,
-  });
+  const id = data.id ?? randomUUID();
+  return upsertAssistant(id, data, reply, true);
 }
 
 /**
  * Update an existing assistant by ID
- * Only works on stored assistants, not code-configured ones
  */
 export async function updateAssistant(
   request: FastifyRequest<{
@@ -195,50 +225,13 @@ export async function updateAssistant(
   const { id } = request.params;
   const updates = request.body;
 
-  // Check if it's a code-configured agent
-  const agentConfigs = await getAllAgentConfigs();
-  const isCodeConfigured = agentConfigs.some((config) => config.key === id);
-
-  if (isCodeConfigured) {
-    return reply.status(403).send({
-      success: false,
-      message:
-        "Cannot update code-configured assistant. Only stored assistants can be updated.",
-    });
-  }
-
-  const storeLattice = getStoreLattice("default", "assistant");
-  const assistantStore = storeLattice.store;
-
-  // Check if assistant exists in store
-  const exists = await assistantStore.hasAssistant(id);
-  if (!exists) {
-    return reply.status(404).send({
-      success: false,
-      message: "Assistant not found",
-    });
-  }
-
-  // Update assistant
-  const updatedAssistant = await assistantStore.updateAssistant(id, updates);
-
-  if (!updatedAssistant) {
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to update assistant",
-    });
-  }
-
-  return {
-    success: true,
-    message: "Successfully updated assistant",
-    data: updatedAssistant,
-  };
+  return upsertAssistant(id, updates, reply, false);
 }
 
 /**
  * Delete an assistant by ID
- * Only works on stored assistants, not code-configured ones
+ * For stored assistants: 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 } }>,
@@ -246,22 +239,28 @@ export async function deleteAssistant(
 ): Promise<{ success: boolean; message: string }> {
   const { id } = request.params;
 
-  // Check if it's a code-configured agent
+  const storeLattice = getStoreLattice("default", "assistant");
+  const assistantStore = storeLattice.store;
+
   const agentConfigs = await getAllAgentConfigs();
   const isCodeConfigured = agentConfigs.some((config) => config.key === id);
 
   if (isCodeConfigured) {
-    return reply.status(403).send({
-      success: false,
-      message:
-        "Cannot delete code-configured assistant. Only stored assistants can be deleted.",
-    });
+    const exists = await assistantStore.hasAssistant(id);
+    if (!exists) {
+      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(id);
+    eventBus.publish("assistant:deleted", { id });
+    return {
+      success: true,
+      message: "Deleted assistant from store (code-configured registration remains)",
+    };
   }
 
-  const storeLattice = getStoreLattice("default", "assistant");
-  const assistantStore = storeLattice.store;
-
-  // Check if assistant exists in store
   const exists = await assistantStore.hasAssistant(id);
   if (!exists) {
     return reply.status(404).send({
@@ -270,7 +269,6 @@ export async function deleteAssistant(
     });
   }
 
-  // Delete the assistant
   const deleted = await assistantStore.deleteAssistant(id);
 
   if (!deleted) {
@@ -280,6 +278,8 @@ export async function deleteAssistant(
     });
   }
 
+  eventBus.publish("assistant:deleted", { id });
+
   return {
     success: true,
     message: "Successfully deleted assistant",

package/src/controllers/sandbox.ts

@@ -54,12 +54,11 @@ export function registerSandboxProxyRoutes(app: FastifyInstance): void {
       console.log("[Sandbox Upload] Route matched:", request.url);
       const { assistantId, threadId } = request.params;
 
-      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
-      if (!sandboxConfig) {
+      const isolatedLevel = sandboxService.getFilesystemIsolatedLevel(assistantId);
+      if (!isolatedLevel) {
         return reply.status(500).send({ error: "Assistant sandbox config not found" });
       }
 
-      const { isolatedLevel } = sandboxConfig;
       const sandboxName = sandboxService.computeSandboxName(
         assistantId,
         threadId,
@@ -122,12 +121,11 @@ export function registerSandboxProxyRoutes(app: FastifyInstance): void {
         return reply.status(400).send({ error: "Query parameter 'path' is required" });
       }
 
-      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
-      if (!sandboxConfig) {
-        return reply.status(404).send({ error: "Assistant sandbox config not found" });
+      const isolatedLevel = sandboxService.getFilesystemIsolatedLevel(assistantId);
+      if (!isolatedLevel) {
+        return reply.status(500).send({ error: "Assistant filesystem isolated level not found" });
       }
 
-      const { isolatedLevel } = sandboxConfig;
       const sandboxName = sandboxService.computeSandboxName(
         assistantId,
         threadId,

package/src/services/sandbox_service.ts

@@ -1,5 +1,5 @@
 import { getAgentConfig, getAgentLattice, getSandBoxManager, normalizeSandboxName, sandboxLatticeManager } from "@axiom-lattice/core";
-import { ConnectedSandboxConfig } from "@axiom-lattice/protocols";
+import { ConnectedSandboxConfig, SandboxMiddlewareConfig } from "@axiom-lattice/protocols";
 
 
 const ERROR_HTML = `<!DOCTYPE html>
@@ -114,14 +114,19 @@ const ERROR_HTML = `<!DOCTYPE html>
 
 export class SandboxService {
 
-  getSandboxConfig(assistantId: string): ConnectedSandboxConfig | null {
+  getFilesystemIsolatedLevel(assistantId: string): "agent" | "thread" | "global" | null {
     const agentConfig = getAgentConfig(assistantId);
     if (!agentConfig) {
       return null;
     }
 
     const agentLattice = getAgentLattice(assistantId);
-    return agentLattice?.config?.connectedSandbox || null;
+    const filesystemConfig = agentLattice?.config?.middleware?.find(m => m.type === "filesystem");
+    if (!filesystemConfig) {
+      return null;
+    }
+
+    return filesystemConfig.config?.isolatedLevel || null;
   }
 
   computeSandboxName(