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

package/dist/server/index.js

@@ -30,6 +30,7 @@ import { z } from 'zod';
 import { getTelemetryHandler as getTelemetryHandler$1, storeTelemetryHandler as storeTelemetryHandler$1 } from '@mastra/server/handlers/telemetry';
 import { executeAgentToolHandler as executeAgentToolHandler$1, getToolsHandler as getToolsHandler$1, getToolByIdHandler as getToolByIdHandler$1, executeToolHandler as executeToolHandler$1 } from '@mastra/server/handlers/tools';
 import { upsertVectors as upsertVectors$1, createIndex as createIndex$1, queryVectors as queryVectors$1, listIndexes as listIndexes$1, describeIndex as describeIndex$1, deleteIndex as deleteIndex$1 } from '@mastra/server/handlers/vector';
+import { getVNextNetworksHandler as getVNextNetworksHandler$1, getVNextNetworkByIdHandler as getVNextNetworkByIdHandler$1, generateVNextNetworkHandler as generateVNextNetworkHandler$1, loopVNextNetworkHandler as loopVNextNetworkHandler$1, streamGenerateVNextNetworkHandler as streamGenerateVNextNetworkHandler$1 } from '@mastra/server/handlers/vNextNetwork';
 import { getSpeakersHandler as getSpeakersHandler$1, generateSpeechHandler, getListenerHandler as getListenerHandler$1, transcribeSpeechHandler } from '@mastra/server/handlers/voice';
 import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, getWorkflowRunExecutionResultHandler as getWorkflowRunExecutionResultHandler$1, getWorkflowRunByIdHandler as getWorkflowRunByIdHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, streamWorkflowHandler as streamWorkflowHandler$1, createWorkflowRunHandler as createWorkflowRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1 } from '@mastra/server/handlers/workflows';
 
@@ -256,14 +257,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);
@@ -498,18 +499,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;
@@ -605,10 +606,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream4 = createReadStream(path, { start, end });
+    const stream5 = 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 = {
@@ -729,7 +730,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);
@@ -904,15 +905,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "tasks/sendSubscribe") {
     return 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);
@@ -992,7 +993,8 @@ async function generateHandler(c2) {
       mastra,
       agentId,
       runtimeContext,
-      body
+      body,
+      abortSignal: c2.req.raw.signal
     });
     return c2.json(result);
   } catch (error) {
@@ -1009,7 +1011,8 @@ async function streamGenerateHandler(c2) {
       mastra,
       agentId,
       runtimeContext,
-      body
+      body,
+      abortSignal: c2.req.raw.signal
     });
     return streamResponse;
   } catch (error) {
@@ -1243,7 +1246,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");
@@ -1252,7 +1255,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream4, {
+  return new Response(stream5, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1359,20 +1362,20 @@ function watchLegacyWorkflowHandler(c2) {
     }
     return stream(
       c2,
-      async (stream4) => {
+      async (stream5) => {
         try {
           const result = await watchLegacyWorkflowHandler$1({
             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);
@@ -3570,9 +3573,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 getMemoryStatusHandler$1({
       mastra,
-      agentId
+      agentId,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3584,10 +3589,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 getThreadsHandler$1({
       mastra,
       agentId,
-      resourceId
+      resourceId,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3599,10 +3606,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 getThreadByIdHandler$1({
       mastra,
       agentId,
-      threadId
+      threadId,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3613,11 +3622,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 saveMessagesHandler$1({
       mastra,
       agentId,
-      body
+      body,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3628,11 +3639,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 createThreadHandler$1({
       mastra,
       agentId,
-      body
+      body,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3644,12 +3657,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 updateThreadHandler$1({
       mastra,
       agentId,
       threadId,
-      body
+      body,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3661,10 +3676,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 deleteThreadHandler$1({
       mastra,
       agentId,
-      threadId
+      threadId,
+      networkId
     });
     return c2.json(result);
   } catch (error) {
@@ -3675,6 +3692,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;
@@ -3688,6 +3706,7 @@ async function getMessagesHandler(c2) {
       mastra,
       agentId,
       threadId,
+      networkId,
       limit
     });
     return c2.json(result);
@@ -4068,6 +4087,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 getVNextNetworksHandler$1({
+      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 getVNextNetworkByIdHandler$1({
+      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 generateVNextNetworkHandler$1({
+      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 stream(
+      c2,
+      async (stream5) => {
+        try {
+          const result = await streamGenerateVNextNetworkHandler$1({
+            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 loopVNextNetworkHandler$1({
+      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");
@@ -4182,8 +4301,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 startAsyncWorkflowHandler$1({
       mastra,
@@ -4200,8 +4320,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 startWorkflowRunHandler$1({
       mastra,
@@ -4224,9 +4345,10 @@ function watchWorkflowHandler(c2) {
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to watch workflow" });
     }
+    c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream4) => {
+      async (stream5) => {
         try {
           const result = await watchWorkflowHandler$1({
             mastra,
@@ -4234,12 +4356,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"));
@@ -4256,13 +4378,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 stream(
       c2,
-      async (stream4) => {
+      async (stream5) => {
         try {
           const result = await streamWorkflowHandler$1({
             mastra,
@@ -4272,12 +4396,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);
@@ -4294,9 +4418,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(400, { message: "runId required to resume workflow" });
     }
@@ -4315,9 +4440,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(400, { message: "runId required to resume workflow" });
     }
@@ -4792,6 +4918,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(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(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(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({
@@ -6070,6 +6375,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(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(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({