@mastra/deployer 0.10.7-alpha.1 → 0.10.7-alpha.3

package/dist/server/index.cjs

@@ -32,6 +32,7 @@ var zod = require('zod');
 var telemetry = require('@mastra/server/handlers/telemetry');
 var tools = require('@mastra/server/handlers/tools');
 var vector = require('@mastra/server/handlers/vector');
+var vNextNetwork = require('@mastra/server/handlers/vNextNetwork');
 var voice = require('@mastra/server/handlers/voice');
 var workflows = require('@mastra/server/handlers/workflows');
 
@@ -263,14 +264,14 @@ var Response2 = class _Response {
 });
 Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-function writeFromReadableStream(stream4, writable) {
-  if (stream4.locked) {
+function writeFromReadableStream(stream5, writable) {
+  if (stream5.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
-    stream4.cancel();
+    stream5.cancel();
     return;
   }
-  const reader = stream4.getReader();
+  const reader = stream5.getReader();
   writable.on("close", cancel);
   writable.on("error", cancel);
   reader.read().then(flow, cancel);
@@ -505,18 +506,18 @@ var ENCODINGS = {
   gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream4) => {
+var createStreamBody = (stream5) => {
   const body = new ReadableStream({
     start(controller) {
-      stream4.on("data", (chunk) => {
+      stream5.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream4.on("end", () => {
+      stream5.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream4.destroy();
+      stream5.destroy();
     }
   });
   return body;
@@ -612,10 +613,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream4 = fs.createReadStream(path, { start, end });
+    const stream5 = fs.createReadStream(path, { start, end });
     c2.header("Content-Length", chunksize.toString());
     c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c2.body(createStreamBody(stream4), 206);
+    return c2.body(createStreamBody(stream5), 206);
   };
 };
 var RENDER_TYPE = {
@@ -736,7 +737,7 @@ var middleware = (options) => async (c2) => {
   );
 };
 
-// ../../node_modules/.pnpm/hono-openapi@0.4.8_hono@4.7.11_openapi-types@12.1.3_zod@3.25.57/node_modules/hono-openapi/utils.js
+// ../../node_modules/.pnpm/hono-openapi@0.4.8_hono@4.8.1_openapi-types@12.1.3_zod@3.25.67/node_modules/hono-openapi/utils.js
 var e = Symbol("openapi");
 var n = ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
 var s2 = (e2) => e2.charAt(0).toUpperCase() + e2.slice(1);
@@ -911,15 +912,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "tasks/sendSubscribe") {
     return streaming.stream(
       c2,
-      async (stream4) => {
+      async (stream5) => {
         try {
-          stream4.onAbort(() => {
+          stream5.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream4.write(JSON.stringify(chunk) + "");
+            await stream5.write(JSON.stringify(chunk) + "");
           }
         } catch (err) {
           logger2.error("Error in tasks/sendSubscribe stream: " + err?.message);
@@ -999,7 +1000,8 @@ async function generateHandler(c2) {
       mastra,
       agentId,
       runtimeContext,
-      body
+      body,
+      abortSignal: c2.req.raw.signal
     });
     return c2.json(result);
   } catch (error) {
@@ -1016,7 +1018,8 @@ async function streamGenerateHandler(c2) {
       mastra,
       agentId,
       runtimeContext,
-      body
+      body,
+      abortSignal: c2.req.raw.signal
     });
     return streamResponse;
   } catch (error) {
@@ -1250,7 +1253,7 @@ var authorizationMiddleware = async (c2, next) => {
 // src/server/handlers/client.ts
 var clients = /* @__PURE__ */ new Set();
 function handleClientsRefresh(c2) {
-  const stream4 = new ReadableStream({
+  const stream5 = new ReadableStream({
     start(controller) {
       clients.add(controller);
       controller.enqueue("data: connected\n\n");
@@ -1259,7 +1262,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream4, {
+  return new Response(stream5, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1366,20 +1369,20 @@ function watchLegacyWorkflowHandler(c2) {
     }
     return streaming.stream(
       c2,
-      async (stream4) => {
+      async (stream5) => {
         try {
           const result = await legacyWorkflows.watchLegacyWorkflowHandler({
             mastra,
             workflowId,
             runId
           });
-          stream4.onAbort(() => {
+          stream5.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream4.write(chunk.toString() + "");
+            await stream5.write(chunk.toString() + "");
           }
         } catch (err) {
           console.log(err);
@@ -3577,9 +3580,11 @@ async function getMemoryStatusHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
+    const networkId = c2.req.query("networkId");
     const result = await memory.getMemoryStatusHandler({
       mastra,
-      agentId
+      agentId,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3591,10 +3596,12 @@ async function getThreadsHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const resourceId = c2.req.query("resourceid");
+    const networkId = c2.req.query("networkId");
     const result = await memory.getThreadsHandler({
       mastra,
       agentId,
-      resourceId
+      resourceId,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3606,10 +3613,12 @@ async function getThreadByIdHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
+    const networkId = c2.req.query("networkId");
     const result = await memory.getThreadByIdHandler({
       mastra,
       agentId,
-      threadId
+      threadId,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3620,11 +3629,13 @@ async function saveMessagesHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
+    const networkId = c2.req.query("networkId");
     const body = await c2.req.json();
     const result = await memory.saveMessagesHandler({
       mastra,
       agentId,
-      body
+      body,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3635,11 +3646,13 @@ async function createThreadHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
+    const networkId = c2.req.query("networkId");
     const body = await c2.req.json();
     const result = await memory.createThreadHandler({
       mastra,
       agentId,
-      body
+      body,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3651,12 +3664,14 @@ async function updateThreadHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
+    const networkId = c2.req.query("networkId");
     const body = await c2.req.json();
     const result = await memory.updateThreadHandler({
       mastra,
       agentId,
       threadId,
-      body
+      body,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3668,10 +3683,12 @@ async function deleteThreadHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
+    const networkId = c2.req.query("networkId");
     const result = await memory.deleteThreadHandler({
       mastra,
       agentId,
-      threadId
+      threadId,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3682,6 +3699,7 @@ async function getMessagesHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
+    const networkId = c2.req.query("networkId");
     const threadId = c2.req.param("threadId");
     const rawLimit = c2.req.query("limit");
     let limit = void 0;
@@ -3695,6 +3713,7 @@ async function getMessagesHandler(c2) {
       mastra,
       agentId,
       threadId,
+      networkId,
       limit
     });
     return c2.json(result);
@@ -4075,6 +4094,106 @@ async function deleteIndex(c2) {
     return handleError(error, "Error deleting index");
   }
 }
+async function getVNextNetworksHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const networks = await vNextNetwork.getVNextNetworksHandler({
+      mastra,
+      runtimeContext
+    });
+    return c2.json(networks);
+  } catch (error) {
+    return handleError(error, "Error getting networks");
+  }
+}
+async function getVNextNetworkByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const networkId = c2.req.param("networkId");
+    const runtimeContext = c2.get("runtimeContext");
+    const network = await vNextNetwork.getVNextNetworkByIdHandler({
+      mastra,
+      networkId,
+      runtimeContext
+    });
+    return c2.json(network);
+  } catch (error) {
+    return handleError(error, "Error getting network by ID");
+  }
+}
+async function generateVNextNetworkHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const networkId = c2.req.param("networkId");
+    const body = await c2.req.json();
+    const result = await vNextNetwork.generateVNextNetworkHandler({
+      mastra,
+      runtimeContext,
+      networkId,
+      body
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error generating from network");
+  }
+}
+async function streamGenerateVNextNetworkHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const logger2 = mastra.getLogger();
+    const networkId = c2.req.param("networkId");
+    const body = await c2.req.json();
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream5) => {
+        try {
+          const result = await vNextNetwork.streamGenerateVNextNetworkHandler({
+            mastra,
+            runtimeContext,
+            networkId,
+            body
+          });
+          const reader = result.stream.getReader();
+          stream5.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          mastra.getLogger().error("Error in watch stream: " + (err?.message ?? "Unknown error"));
+        }
+      },
+      async (err) => {
+        logger2.error("Error in watch stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming from network");
+  }
+}
+async function loopVNextNetworkHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const networkId = c2.req.param("networkId");
+    const body = await c2.req.json();
+    const result = await vNextNetwork.loopVNextNetworkHandler({
+      mastra,
+      runtimeContext,
+      networkId,
+      body
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error looping from network");
+  }
+}
 async function getSpeakersHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -4189,8 +4308,9 @@ async function createWorkflowRunHandler(c2) {
 async function startAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
-    const { inputData, runtimeContext } = await c2.req.json();
+    const { inputData } = await c2.req.json();
     const runId = c2.req.query("runId");
     const result = await workflows.startAsyncWorkflowHandler({
       mastra,
@@ -4207,8 +4327,9 @@ async function startAsyncWorkflowHandler(c2) {
 async function startWorkflowRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
-    const { inputData, runtimeContext } = await c2.req.json();
+    const { inputData } = await c2.req.json();
     const runId = c2.req.query("runId");
     await workflows.startWorkflowRunHandler({
       mastra,
@@ -4231,9 +4352,10 @@ function watchWorkflowHandler(c2) {
     if (!runId) {
       throw new httpException.HTTPException(400, { message: "runId required to watch workflow" });
     }
+    c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream4) => {
+      async (stream5) => {
         try {
           const result = await workflows.watchWorkflowHandler({
             mastra,
@@ -4241,12 +4363,12 @@ function watchWorkflowHandler(c2) {
             runId
           });
           const reader = result.getReader();
-          stream4.onAbort(() => {
+          stream5.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream4.write(JSON.stringify(chunkResult.value) + "");
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           mastra.getLogger().error("Error in watch stream: " + (err?.message ?? "Unknown error"));
@@ -4263,13 +4385,15 @@ function watchWorkflowHandler(c2) {
 async function streamWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
     const logger2 = mastra.getLogger();
     const workflowId = c2.req.param("workflowId");
-    const { inputData, runtimeContext } = await c2.req.json();
+    const { inputData } = await c2.req.json();
     const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream4) => {
+      async (stream5) => {
         try {
           const result = await workflows.streamWorkflowHandler({
             mastra,
@@ -4279,12 +4403,12 @@ async function streamWorkflowHandler(c2) {
             runtimeContext
           });
           const reader = result.stream.getReader();
-          stream4.onAbort(() => {
+          stream5.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream4.write(JSON.stringify(chunkResult.value) + "");
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           console.log(err);
@@ -4301,9 +4425,10 @@ async function streamWorkflowHandler(c2) {
 async function resumeAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
     const runId = c2.req.query("runId");
-    const { step, resumeData, runtimeContext } = await c2.req.json();
+    const { step, resumeData } = await c2.req.json();
     if (!runId) {
       throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
     }
@@ -4322,9 +4447,10 @@ async function resumeAsyncWorkflowHandler(c2) {
 async function resumeWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
     const runId = c2.req.query("runId");
-    const { step, resumeData, runtimeContext } = await c2.req.json();
+    const { step, resumeData } = await c2.req.json();
     if (!runId) {
       throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
     }
@@ -4799,6 +4925,185 @@ ${err.stack.split("\n").slice(1).join("\n")}
     }),
     getAgentsHandler
   );
+  app.get(
+    "/api/networks/v-next",
+    w({
+      description: "Get all available v-next networks",
+      tags: ["vNextNetworks"],
+      responses: {
+        200: {
+          description: "List of all v-next networks"
+        }
+      }
+    }),
+    getVNextNetworksHandler
+  );
+  app.get(
+    "/api/networks/v-next/:networkId",
+    w({
+      description: "Get v-next network by ID",
+      tags: ["vNextNetworks"],
+      parameters: [
+        {
+          name: "networkId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "v-next Network details"
+        },
+        404: {
+          description: "v-next Network not found"
+        }
+      }
+    }),
+    getVNextNetworkByIdHandler
+  );
+  app.post(
+    "/api/networks/v-next/:networkId/generate",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Generate a response from a v-next network",
+      tags: ["vNextNetworks"],
+      parameters: [
+        {
+          name: "networkId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                message: {
+                  type: "string",
+                  description: "Message for the v-next network"
+                },
+                threadId: {
+                  type: "string",
+                  description: "Thread Id of the conversation"
+                },
+                resourceId: {
+                  type: "string",
+                  description: "Resource Id of the conversation"
+                }
+              },
+              required: ["message"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Generated response"
+        },
+        404: {
+          description: "v-next Network not found"
+        }
+      }
+    }),
+    generateVNextNetworkHandler
+  );
+  app.post(
+    "/api/networks/v-next/:networkId/loop",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Loop a v-next network",
+      tags: ["vNextNetworks"],
+      parameters: [
+        {
+          name: "networkId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                message: {
+                  type: "string",
+                  description: "Message for the v-next network"
+                }
+              },
+              required: ["message"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Looped response"
+        },
+        404: {
+          description: "v-next Network not found"
+        }
+      }
+    }),
+    loopVNextNetworkHandler
+  );
+  app.post(
+    "/api/networks/v-next/:networkId/stream",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Generate a response from a v-next network",
+      tags: ["vNextNetworks"],
+      parameters: [
+        {
+          name: "networkId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                message: {
+                  type: "string",
+                  description: "Message for the v-next network"
+                },
+                threadId: {
+                  type: "string",
+                  description: "Thread Id of the conversation"
+                },
+                resourceId: {
+                  type: "string",
+                  description: "Resource Id of the conversation"
+                }
+              },
+              required: ["message"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Generated response"
+        },
+        404: {
+          description: "v-next Network not found"
+        }
+      }
+    }),
+    streamGenerateVNextNetworkHandler
+  );
   app.get(
     "/api/networks",
     w({
@@ -6077,6 +6382,263 @@ ${err.stack.split("\n").slice(1).join("\n")}
     }),
     executeMcpServerToolHandler
   );
+  app.get(
+    "/api/memory/network/status",
+    w({
+      description: "Get network memory status",
+      tags: ["networkMemory"],
+      parameters: [
+        {
+          name: "networkId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Memory status"
+        }
+      }
+    }),
+    getMemoryStatusHandler
+  );
+  app.get(
+    "/api/memory/network/threads",
+    w({
+      description: "Get all threads",
+      tags: ["networkMemory"],
+      parameters: [
+        {
+          name: "resourceid",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "networkId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of all threads"
+        }
+      }
+    }),
+    getThreadsHandler
+  );
+  app.get(
+    "/api/memory/network/threads/:threadId",
+    w({
+      description: "Get thread by ID",
+      tags: ["networkMemory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "networkId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Thread details"
+        },
+        404: {
+          description: "Thread not found"
+        }
+      }
+    }),
+    getThreadByIdHandler
+  );
+  app.get(
+    "/api/memory/network/threads/:threadId/messages",
+    w({
+      description: "Get messages for a thread",
+      tags: ["networkMemory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "networkId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "limit",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+          description: "Limit the number of messages to retrieve (default: 40)"
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of messages"
+        }
+      }
+    }),
+    getMessagesHandler
+  );
+  app.post(
+    "/api/memory/network/threads",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Create a new thread",
+      tags: ["networkMemory"],
+      parameters: [
+        {
+          name: "networkId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                metadata: { type: "object" },
+                resourceId: { type: "string" },
+                threadId: { type: "string" }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Created thread"
+        }
+      }
+    }),
+    createThreadHandler
+  );
+  app.patch(
+    "/api/memory/network/threads/:threadId",
+    w({
+      description: "Update a thread",
+      tags: ["networkMemory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "networkId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: { type: "object" }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Updated thread"
+        },
+        404: {
+          description: "Thread not found"
+        }
+      }
+    }),
+    updateThreadHandler
+  );
+  app.delete(
+    "/api/memory/network/threads/:threadId",
+    w({
+      description: "Delete a thread",
+      tags: ["networkMemory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "networkId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Thread deleted"
+        },
+        404: {
+          description: "Thread not found"
+        }
+      }
+    }),
+    deleteThreadHandler
+  );
+  app.post(
+    "/api/memory/network/save-messages",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Save messages",
+      tags: ["networkMemory"],
+      parameters: [
+        {
+          name: "networkId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: {
+                  type: "array",
+                  items: { type: "object" }
+                }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Messages saved"
+        }
+      }
+    }),
+    saveMessagesHandler
+  );
   app.get(
     "/api/memory/status",
     w({