@axiom-lattice/gateway 2.1.49 → 2.1.51

package/dist/index.mjs

@@ -208,10 +208,12 @@ var createRun = async (request, reply) => {
     const {
       assistant_id,
       thread_id,
+      message_id,
       command,
       streaming,
       background,
       custom_run_config,
+      mode,
       ...input
     } = request.body;
     const tenant_id = request.headers["x-tenant-id"];
@@ -242,11 +244,12 @@ var createRun = async (request, reply) => {
         "Access-Control-Allow-Origin": "*"
       });
       try {
+        const messageInput = message_id ? { ...input, id: message_id } : input;
         const result = await agent.addMessage({
-          input,
+          input: messageInput,
           command,
           custom_run_config
-        });
+        }, mode);
         const stream = agent.chunkStream(result.messageId, [MessageChunkTypes.MESSAGE_COMPLETED]);
         for await (const chunk of stream) {
           const success = reply.raw.write(`data: ${JSON.stringify(chunk)}
@@ -562,9 +565,20 @@ function getTenantId2(request) {
 async function getThreadList(request, reply) {
   const tenantId = getTenantId2(request);
   const { assistantId } = request.params;
+  const metadataFilter = {};
+  if (request.query.workspaceId) {
+    metadataFilter.workspaceId = request.query.workspaceId;
+  }
+  if (request.query.projectId) {
+    metadataFilter.projectId = request.query.projectId;
+  }
   const storeLattice = getStoreLattice2("default", "thread");
   const threadStore = storeLattice.store;
-  const threads = await threadStore.getThreadsByAssistantId(tenantId, assistantId);
+  const threads = await threadStore.getThreadsByAssistantId(
+    tenantId,
+    assistantId,
+    Object.keys(metadataFilter).length > 0 ? metadataFilter : void 0
+  );
   return {
     success: true,
     message: "Successfully retrieved thread list",
@@ -597,9 +611,23 @@ async function createThread(request, reply) {
   const { assistantId } = request.params;
   const data = request.body;
   const threadId = randomUUID2();
+  const workspaceId = request.headers["x-workspace-id"];
+  const projectId = request.headers["x-project-id"];
+  const enrichedMetadata = {
+    ...data.metadata,
+    tenantId
+  };
+  if (workspaceId) {
+    enrichedMetadata.workspaceId = workspaceId;
+  }
+  if (projectId) {
+    enrichedMetadata.projectId = projectId;
+  }
   const storeLattice = getStoreLattice2("default", "thread");
   const threadStore = storeLattice.store;
-  const newThread = await threadStore.createThread(tenantId, assistantId, threadId, data);
+  const newThread = await threadStore.createThread(tenantId, assistantId, threadId, {
+    metadata: enrichedMetadata
+  });
   return reply.status(201).send({
     success: true,
     message: "Successfully created thread",
@@ -2068,6 +2096,53 @@ var getHealthSchema = {
   }
 };
 
+// src/controllers/thread_status.ts
+import { agentInstanceManager as agentInstanceManager4 } from "@axiom-lattice/core";
+async function removePendingMessageHandler(request, reply) {
+  try {
+    const { assistant_id, thread_id, message_id } = request.params;
+    const tenant_id = request.headers["x-tenant-id"];
+    const workspace_id = request.headers["x-workspace-id"];
+    const project_id = request.headers["x-project-id"];
+    if (!tenant_id) {
+      return reply.code(400).send({ error: "Missing x-tenant-id header" });
+    }
+    if (!assistant_id) {
+      return reply.code(400).send({ error: "Missing assistant_id parameter" });
+    }
+    const agent = agentInstanceManager4.getAgent({
+      assistant_id,
+      thread_id,
+      tenant_id,
+      workspace_id,
+      project_id
+    });
+    if (!agent) {
+      return reply.code(404).send({
+        error: "Thread not found",
+        threadId: thread_id
+      });
+    }
+    const success = await agent.removePendingMessage(message_id);
+    if (!success) {
+      return reply.code(404).send({
+        error: "Message not found",
+        messageId: message_id
+      });
+    }
+    return reply.send({
+      success: true,
+      messageId: message_id
+    });
+  } catch (error) {
+    console.error("Error removing pending message:", error);
+    return reply.code(500).send({
+      error: "Internal server error",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+
 // src/controllers/sandbox.ts
 import { Readable } from "stream";
 
@@ -4682,6 +4757,57 @@ var AuthController = class {
     }
     return btoa(JSON.stringify(payload));
   }
+  async changePassword(request, reply) {
+    const userId = request.user?.id;
+    const { currentPassword, newPassword } = request.body;
+    if (!userId) {
+      return reply.status(401).send({
+        success: false,
+        error: "Unauthorized"
+      });
+    }
+    try {
+      const user = await this.userStore.getUserById(userId);
+      if (!user) {
+        return reply.status(404).send({
+          success: false,
+          error: "User not found"
+        });
+      }
+      const isValidPassword = await this.verifyPassword(
+        currentPassword,
+        user.metadata?.passwordHash || ""
+      );
+      if (!isValidPassword) {
+        return reply.status(401).send({
+          success: false,
+          error: "Current password is incorrect"
+        });
+      }
+      if (newPassword.length < 6) {
+        return reply.status(400).send({
+          success: false,
+          error: "New password must be at least 6 characters"
+        });
+      }
+      await this.userStore.updateUser(userId, {
+        metadata: {
+          ...user.metadata,
+          passwordHash: await this.hashPassword(newPassword)
+        }
+      });
+      return reply.send({
+        success: true,
+        message: "Password changed successfully"
+      });
+    } catch (error) {
+      console.error("Change password error:", error);
+      return reply.status(500).send({
+        success: false,
+        error: "Failed to change password"
+      });
+    }
+  }
 };
 function registerAuthRoutes(app2, config) {
   const controller = new AuthController(config);
@@ -4720,6 +4846,11 @@ function registerAuthRoutes(app2, config) {
   app2.post("/api/auth/approve", { preHandler: authHook }, (req, res) => controller.approveUser(req, res));
   app2.get("/api/auth/pending", { preHandler: authHook }, (req, res) => controller.listPendingUsers(req, res));
   app2.post("/api/auth/assign-tenant", { preHandler: authHook }, (req, res) => controller.assignTenant(req, res));
+  app2.post(
+    "/api/auth/change-password",
+    { preHandler: authHook },
+    (req, res) => controller.changePassword(req, res)
+  );
 }
 
 // src/routes/index.ts
@@ -4856,6 +4987,10 @@ var registerLatticeRoutes = (app2) => {
     autoApproveUsers: process.env.AUTO_APPROVE_USERS !== "false",
     allowTenantRegistration: process.env.ALLOW_TENANT_REGISTRATION !== "false"
   });
+  app2.delete(
+    "/api/assistants/:assistant_id/threads/:thread_id/pending-messages/:message_id",
+    removePendingMessageHandler
+  );
 };
 
 // src/swagger.ts
@@ -4921,7 +5056,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-import { eventBus as eventBus2, AGENT_TASK_EVENT, agentInstanceManager as agentInstanceManager4, QueueMode } from "@axiom-lattice/core";
+import { eventBus as eventBus2, AGENT_TASK_EVENT, agentInstanceManager as agentInstanceManager5, QueueMode as QueueMode2 } from "@axiom-lattice/core";
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -4936,8 +5071,8 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = agentInstanceManager4.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
-    await agent.addMessage({ input, command }, QueueMode.STEER);
+    const agent = agentInstanceManager5.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    await agent.addMessage({ input, command, custom_run_config: runConfig }, QueueMode2.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
         eventBus2.publish(callback_event, {
@@ -5155,7 +5290,7 @@ import {
   sandboxLatticeManager as sandboxLatticeManager2,
   sqlDatabaseManager as sqlDatabaseManager2,
   getStoreLattice as getStoreLattice12,
-  agentInstanceManager as agentInstanceManager5
+  agentInstanceManager as agentInstanceManager6
 } from "@axiom-lattice/core";
 import {
   LoggerType
@@ -5185,6 +5320,18 @@ var app = fastify({
   bodyLimit: Number(process.env.BODY_LIMIT) || 50 * 1024 * 1024
   // Default 50MB, configurable via BODY_LIMIT env var
 });
+app.addContentTypeParser("application/json", { parseAs: "string" }, function(request, body, done) {
+  if (request.method === "DELETE" || !body || body.length === 0) {
+    done(null, {});
+    return;
+  }
+  try {
+    const json = JSON.parse(body);
+    done(null, json);
+  } catch (err) {
+    done(err, void 0);
+  }
+});
 app.addHook("onRequest", (request, reply, done) => {
   const getHeaderValue = (header) => {
     if (Array.isArray(header)) {
@@ -5201,11 +5348,6 @@ app.addHook("onRequest", (request, reply, done) => {
   }
   done();
 });
-app.addHook("onRequest", async (request, reply) => {
-  if (request.method === "DELETE" && request.headers["content-type"]) {
-    delete request.headers["content-type"];
-  }
-});
 app.addHook("onResponse", (request, reply, done) => {
   const getHeaderValue = (header) => {
     if (Array.isArray(header)) {
@@ -5309,7 +5451,7 @@ var start = async (config) => {
     }
     try {
       logger.info("Starting agent instance recovery...");
-      const restoreStats = await agentInstanceManager5.restore();
+      const restoreStats = await agentInstanceManager6.restore();
       logger.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
     } catch (error) {
       logger.error("Agent recovery failed", { error });