@mastra/deployer 0.14.0-alpha.2 → 0.14.0-alpha.4

package/dist/server/index.cjs

@@ -1251,6 +1251,56 @@ var AllowedProviderKeys = {
 };
 
 // src/server/handlers/routes/agents/handlers.ts
+var vNextBodyOptions = {
+  messages: {
+    type: "array",
+    items: { type: "object" }
+  },
+  threadId: { type: "string" },
+  resourceId: { type: "string", description: "The resource ID for the conversation" },
+  runId: { type: "string" },
+  output: { type: "object" },
+  instructions: { type: "string", description: "Optional instructions to override the agent's default instructions" },
+  context: {
+    type: "array",
+    items: { type: "object" },
+    description: "Additional context messages to include"
+  },
+  memory: {
+    type: "object",
+    properties: {
+      threadId: { type: "string" },
+      resourceId: { type: "string", description: "The resource ID for the conversation" },
+      options: { type: "object", description: "Memory configuration options" }
+    },
+    description: "Memory options for the conversation"
+  },
+  savePerStep: { type: "boolean", description: "Whether to save messages incrementally on step finish" },
+  format: { type: "string", enum: ["mastra", "aisdk"], description: "Response format" },
+  toolChoice: {
+    oneOf: [
+      { type: "string", enum: ["auto", "none", "required"] },
+      { type: "object", properties: { type: { type: "string" }, toolName: { type: "string" } } }
+    ],
+    description: "Controls how tools are selected during generation"
+  },
+  modelSettings: {
+    type: "object",
+    properties: {
+      maxTokens: { type: "number", description: "Maximum number of tokens to generate" },
+      temperature: { type: "number", minimum: 0, maximum: 1, description: "Temperature setting for randomness (0-1)" },
+      topP: { type: "number", minimum: 0, maximum: 1, description: "Nucleus sampling (0-1)" },
+      topK: { type: "number", description: "Only sample from the top K options for each subsequent token" },
+      presencePenalty: { type: "number", minimum: -1, maximum: 1, description: "Presence penalty (-1 to 1)" },
+      frequencyPenalty: { type: "number", minimum: -1, maximum: 1, description: "Frequency penalty (-1 to 1)" },
+      stopSequences: { type: "array", items: { type: "string" }, description: "Stop sequences for text generation" },
+      seed: { type: "number", description: "Seed for deterministic results" },
+      maxRetries: { type: "number", description: "Maximum number of retries" },
+      headers: { type: "object", description: "Additional HTTP headers" }
+    },
+    description: "Model settings for generation"
+  }
+};
 async function getAgentsHandler(c2) {
   const serializedAgents = await agents.getAgentsHandler({
     mastra: c2.get("mastra"),
@@ -1311,6 +1361,24 @@ async function generateHandler(c2) {
     return handleError(error, "Error generating from agent");
   }
 }
+async function generateVNextHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const runtimeContext = c2.get("runtimeContext");
+    const body = await c2.req.json();
+    const result = await agents.generateVNextHandler({
+      mastra,
+      agentId,
+      runtimeContext,
+      body,
+      abortSignal: c2.req.raw.signal
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error generating vnext from agent");
+  }
+}
 async function streamGenerateHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -1341,21 +1409,24 @@ async function streamVNextGenerateHandler(c2) {
       c2,
       async (stream6) => {
         try {
-          const result = agents.streamVNextGenerateHandler({
+          const streamResponse = await agents.streamVNextGenerateHandler({
             mastra,
             agentId,
             runtimeContext,
             body,
             abortSignal: c2.req.raw.signal
           });
-          const reader = result.getReader();
+          const reader = streamResponse.fullStream.getReader();
           stream6.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream6.write(`data: ${JSON.stringify(chunkResult.value)}
+
+`);
           }
+          await stream6.write("data: [DONE]\n\n");
         } catch (err) {
           logger2.error("Error in streamVNext generate: " + (err?.message ?? "Unknown error"));
         }
@@ -1369,6 +1440,24 @@ async function streamVNextGenerateHandler(c2) {
     return handleError(error, "Error streaming from agent");
   }
 }
+async function streamVNextUIMessageHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const runtimeContext = c2.get("runtimeContext");
+    const body = await c2.req.json();
+    const streamResponse = await agents.streamVNextUIMessageHandler({
+      mastra,
+      agentId,
+      runtimeContext,
+      body,
+      abortSignal: c2.req.raw.signal
+    });
+    return streamResponse;
+  } catch (error) {
+    return handleError(error, "Error streaming ui message from agent");
+  }
+}
 async function setAgentInstructionsHandler(c2) {
   try {
     const isPlayground = c2.get("playground") === true;
@@ -1411,6 +1500,18 @@ async function updateAgentModelHandler(c2) {
     return handleError(error, "Error updating agent model");
   }
 }
+async function deprecatedStreamVNextHandler(c2) {
+  return c2.json(
+    {
+      error: "This endpoint is deprecated",
+      message: "The /streamVNext endpoint has been deprecated. Please use an alternative streaming endpoint.",
+      deprecated_endpoint: "/api/agents/:agentId/streamVNext",
+      replacement_endpoint: "/api/agents/:agentId/stream/vnext"
+    },
+    410
+    // 410 Gone status code for deprecated endpoints
+  );
+}
 async function getModelProvidersHandler(c2) {
   const isPlayground = c2.get("playground") === true;
   if (!isPlayground) {
@@ -1802,6 +1903,80 @@ function agentsRouter(bodyLimitOptions) {
     }),
     generateHandler
   );
+  router.post(
+    "/:agentId/generate/vnext",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Generate a response from an agent",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: vNextBodyOptions,
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Generated response"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    generateVNextHandler
+  );
+  router.post(
+    "/:agentId/stream/vnext",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Generate a response from an agent",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: vNextBodyOptions,
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Generated response"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    streamVNextGenerateHandler
+  );
   router.post(
     "/:agentId/stream",
     bodyLimit.bodyLimit(bodyLimitOptions),
@@ -1857,8 +2032,9 @@ function agentsRouter(bodyLimitOptions) {
     "/:agentId/streamVNext",
     bodyLimit.bodyLimit(bodyLimitOptions),
     w({
-      description: "Stream a response from an agent using the VNext streaming API",
+      description: "[DEPRECATED] This endpoint is deprecated. Please use /stream instead.",
       tags: ["agents"],
+      deprecated: true,
       parameters: [
         {
           name: "agentId",
@@ -1907,6 +2083,53 @@ function agentsRouter(bodyLimitOptions) {
           }
         }
       },
+      responses: {
+        410: {
+          description: "Endpoint deprecated",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  error: { type: "string" },
+                  message: { type: "string" },
+                  deprecated_endpoint: { type: "string" },
+                  replacement_endpoint: { type: "string" }
+                }
+              }
+            }
+          }
+        }
+      }
+    }),
+    deprecatedStreamVNextHandler
+  );
+  router.post(
+    "/:agentId/stream/vnext/ui",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Stream a response from an agent",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: vNextBodyOptions,
+              required: ["messages"]
+            }
+          }
+        }
+      },
       responses: {
         200: {
           description: "Streamed response"
@@ -1916,7 +2139,7 @@ function agentsRouter(bodyLimitOptions) {
         }
       }
     }),
-    streamVNextGenerateHandler
+    streamVNextUIMessageHandler
   );
   router.post(
     "/:agentId/model",