@mastra/deployer 0.0.0-commonjs-20250227130920

package/src/server/handlers/prompt.ts

@@ -0,0 +1,128 @@
+import type { Mastra } from '@mastra/core';
+import { Agent } from '@mastra/core/agent';
+import type { Context } from 'hono';
+import { z } from 'zod';
+
+import { handleError } from './error';
+
+export async function generateSystemPromptHandler(c: Context) {
+  try {
+    // Check if this is a playground request
+    const agentId = c.req.param('agentId');
+    const isPlayground = c.get('playground') === true;
+    if (!isPlayground) {
+      return c.json({ error: 'This API is only available in the playground environment' }, 403);
+    }
+
+    const { instructions, comment } = await c.req.json();
+
+    if (!instructions) {
+      return c.json({ error: 'Missing instructions in request body' }, 400);
+    }
+
+    const mastra: Mastra<any> = c.get('mastra');
+    const agent = mastra.getAgent(agentId);
+
+    if (!agent) {
+      return c.json({ error: 'Agent not found' }, 404);
+    }
+
+    let evalSummary = '';
+
+    try {
+      // Get both test and live evals
+      const testEvals = (await mastra.storage?.getEvalsByAgentName?.(agent.name, 'test')) || [];
+      const liveEvals = (await mastra.storage?.getEvalsByAgentName?.(agent.name, 'live')) || [];
+      // Format eval results for the prompt
+      const evalsMapped = [...testEvals, ...liveEvals].filter(
+        ({ instructions: evalInstructions }) => evalInstructions === instructions,
+      );
+
+      evalSummary = evalsMapped
+        .map(
+          ({ input, output, result }) => `
+          Input: ${input}\n
+          Output: ${output}\n
+          Result: ${JSON.stringify(result)}
+
+        `,
+        )
+        .join('');
+    } catch (error) {
+      mastra.getLogger().error(`Error fetching evals`, { error });
+    }
+
+    const ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS = `
+            You are an expert system prompt engineer, specialized in analyzing and enhancing instructions to create clear, effective, and comprehensive system prompts. Your goal is to help users transform their basic instructions into well-structured system prompts that will guide AI behavior effectively.
+            Follow these steps to analyze and enhance the instructions:
+            1. ANALYSIS PHASE
+            - Identify the core purpose and goals
+            - Extract key constraints and requirements
+            - Recognize domain-specific terminology and concepts
+            - Note any implicit assumptions that should be made explicit
+            2. PROMPT STRUCTURE
+            Create a system prompt with these components:
+            a) ROLE DEFINITION
+                - Clear statement of the AI's role and purpose
+                - Key responsibilities and scope
+                - Primary stakeholders and users
+            b) CORE CAPABILITIES
+                - Main functions and abilities
+                - Specific domain knowledge required
+                - Tools and resources available
+            c) BEHAVIORAL GUIDELINES
+                - Communication style and tone
+                - Decision-making framework
+                - Error handling approach
+                - Ethical considerations
+            d) CONSTRAINTS & BOUNDARIES
+                - Explicit limitations
+                - Out-of-scope activities
+                - Security and privacy considerations
+            e) SUCCESS CRITERIA
+                - Quality standards
+                - Expected outcomes
+                - Performance metrics
+            3. QUALITY CHECKS
+            Ensure the prompt is:
+            - Clear and unambiguous
+            - Comprehensive yet concise
+            - Properly scoped
+            - Technically accurate
+            - Ethically sound
+            4. OUTPUT FORMAT
+            Return a structured response with:
+            - Enhanced system prompt
+            - Analysis of key components
+            - Identified goals and constraints
+            - Core domain concepts
+            Remember: A good system prompt should be specific enough to guide behavior but flexible enough to handle edge cases. 
+            Focus on creating prompts that are clear, actionable, and aligned with the intended use case.
+        `;
+
+    const systemPromptAgent = new Agent({
+      name: 'system-prompt-enhancer',
+      instructions: ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS,
+      model: agent.llm?.getModel(),
+    });
+
+    const result = await systemPromptAgent.generate(
+      `
+            We need to improve the system prompt. 
+            Current: ${instructions}
+            ${comment ? `User feedback: ${comment}` : ''}
+            ${evalSummary ? `\nEvaluation Results:\n${evalSummary}` : ''}
+        `,
+      {
+        output: z.object({
+          new_prompt: z.string(),
+          explanation: z.string(),
+        }),
+      },
+    );
+
+    return c.json(result?.object || {});
+  } catch (error) {
+    return handleError(error, 'Error generating system prompt');
+  }
+}

package/src/server/handlers/root.ts

@@ -0,0 +1,6 @@
+import type { Context } from 'hono';
+
+// Root handler
+export async function rootHandler(c: Context) {
+  return c.text('Hello to the Mastra API!');
+}

package/src/server/handlers/telemetry.ts

@@ -0,0 +1,48 @@
+import type { MastraStorage } from '@mastra/core/storage';
+import type { Telemetry } from '@mastra/core/telemetry';
+import type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+
+export async function getTelemetryHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const telemetry: Telemetry = mastra.telemetry;
+    const storage: MastraStorage = mastra.storage;
+
+    const { name, scope, page, perPage } = c.req.query();
+    const attribute = c.req.queries('attribute');
+
+    if (!telemetry) {
+      throw new HTTPException(400, { message: 'Telemetry is not initialized' });
+    }
+
+    if (!storage) {
+      throw new HTTPException(400, { message: 'Storage is not initialized' });
+    }
+
+    // Parse attribute query parameter if present
+    const attributes = attribute
+      ? Object.fromEntries(
+          (Array.isArray(attribute) ? attribute : [attribute]).map(attr => {
+            const [key, value] = attr.split(':');
+            return [key, value];
+          }),
+        )
+      : undefined;
+
+    const traces = await storage.getTraces({
+      name,
+      scope,
+      page: Number(page ?? 0),
+      perPage: Number(perPage ?? 100),
+      attributes,
+    });
+
+    return c.json({ traces });
+  } catch (error) {
+    return handleError(error, 'Error saving messages');
+  }
+}

package/src/server/handlers/tools.ts

@@ -0,0 +1,114 @@
+import type { Context } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { stringify } from 'superjson';
+import zodToJsonSchema from 'zod-to-json-schema';
+
+import { handleError } from './error';
+
+// Tool handlers
+export async function getToolsHandler(c: Context) {
+  try {
+    const tools = c.get('tools');
+
+    if (!tools) {
+      return c.json({});
+    }
+
+    const serializedTools = Object.entries(tools).reduce(
+      (acc, [id, _tool]) => {
+        const tool = _tool as any;
+        acc[id] = {
+          ...tool,
+          inputSchema: tool.inputSchema ? stringify(zodToJsonSchema(tool.inputSchema)) : undefined,
+          outputSchema: tool.outputSchema ? stringify(zodToJsonSchema(tool.outputSchema)) : undefined,
+        };
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+
+    return c.json(serializedTools);
+  } catch (error) {
+    return handleError(error, 'Error getting tools');
+  }
+}
+
+export async function getToolByIdHandler(c: Context) {
+  try {
+    const tools = c.get('tools');
+    const toolId = c.req.param('toolId');
+    const tool = Object.values(tools || {}).find((tool: any) => tool.id === toolId) as any;
+
+    if (!tool) {
+      throw new HTTPException(404, { message: 'Tool not found' });
+    }
+
+    const serializedTool = {
+      ...tool,
+      inputSchema: tool.inputSchema ? stringify(zodToJsonSchema(tool.inputSchema)) : undefined,
+      outputSchema: tool.outputSchema ? stringify(zodToJsonSchema(tool.outputSchema)) : undefined,
+    };
+
+    return c.json(serializedTool);
+  } catch (error) {
+    return handleError(error, 'Error getting tool');
+  }
+}
+
+export function executeToolHandler(tools: Record<string, any>) {
+  return async (c: Context) => {
+    try {
+      const toolId = decodeURIComponent(c.req.param('toolId'));
+      const tool = Object.values(tools || {}).find((tool: any) => tool.id === toolId) as any;
+
+      if (!tool) {
+        return c.json({ error: 'Tool not found' }, 404);
+      }
+
+      if (!tool?.execute) {
+        return c.json({ error: 'Tool is not executable' }, 400);
+      }
+
+      const { data } = await c.req.json();
+      const mastra = c.get('mastra');
+      const result = await tool.execute({
+        context: data,
+        mastra,
+        runId: mastra.runId,
+      });
+
+      return c.json(result);
+    } catch (error) {
+      return handleError(error, 'Error executing tool');
+    }
+  };
+}
+
+export async function executeAgentToolHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const toolId = c.req.param('toolId');
+    const agent = mastra.getAgent(agentId);
+    const tool = Object.values(agent?.tools || {}).find((tool: any) => tool.id === toolId) as any;
+
+    if (!tool) {
+      throw new HTTPException(404, { message: 'Tool not found' });
+    }
+
+    if (!tool?.execute) {
+      return c.json({ error: 'Tool is not executable' }, 400);
+    }
+
+    const { data } = await c.req.json();
+    const result = await tool.execute({
+      context: data,
+      mastra,
+      runId: agentId,
+    });
+
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error executing tool');
+  }
+}

package/src/server/handlers/utils.ts

@@ -0,0 +1,15 @@
+import { HTTPException } from 'hono/http-exception';
+
+// Validation helper
+export function validateBody(body: Record<string, unknown>) {
+  const errorResponse = Object.entries(body).reduce<Record<string, string>>((acc, [key, value]) => {
+    if (!value) {
+      acc[key] = `${key} is required`;
+    }
+    return acc;
+  }, {});
+
+  if (Object.keys(errorResponse).length > 0) {
+    throw new HTTPException(400, { message: JSON.stringify(errorResponse) });
+  }
+}

package/src/server/handlers/vector.ts

@@ -0,0 +1,149 @@
+import type { MastraVector, QueryResult, IndexStats } from '@mastra/core/vector';
+import type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+
+interface UpsertRequest {
+  indexName: string;
+  vectors: number[][];
+  metadata?: Record<string, any>[];
+  ids?: string[];
+}
+
+interface CreateIndexRequest {
+  indexName: string;
+  dimension: number;
+  metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+
+interface QueryRequest {
+  indexName: string;
+  queryVector: number[];
+  topK?: number;
+  filter?: Record<string, any>;
+  includeVector?: boolean;
+}
+
+export const getVector = (c: Context, vectorName: string): MastraVector => {
+  const vector = c.get('mastra').getVector(vectorName);
+  if (!vector) {
+    throw new HTTPException(404, { message: `Vector store ${vectorName} not found` });
+  }
+  return vector;
+};
+
+// Upsert vectors
+export async function upsertVectors(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const { indexName, vectors, metadata, ids } = await c.req.json<UpsertRequest>();
+
+    if (!indexName || !vectors || !Array.isArray(vectors)) {
+      throw new HTTPException(400, { message: 'Invalid request body. indexName and vectors array are required.' });
+    }
+
+    const vector = getVector(c, vectorName);
+    const result = await vector.upsert(indexName, vectors, metadata, ids);
+    return c.json({ ids: result });
+  } catch (error) {
+    return handleError(error, 'Error upserting vectors');
+  }
+}
+
+// Create index
+export async function createIndex(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const { indexName, dimension, metric } = await c.req.json<CreateIndexRequest>();
+
+    if (!indexName || typeof dimension !== 'number' || dimension <= 0) {
+      throw new HTTPException(400, {
+        message: 'Invalid request body. indexName and positive dimension number are required.',
+      });
+    }
+
+    if (metric && !['cosine', 'euclidean', 'dotproduct'].includes(metric)) {
+      throw new HTTPException(400, { message: 'Invalid metric. Must be one of: cosine, euclidean, dotproduct' });
+    }
+
+    const vector = getVector(c, vectorName);
+    await vector.createIndex(indexName, dimension, metric);
+    return c.json({ success: true });
+  } catch (error) {
+    return handleError(error, 'Error creating index');
+  }
+}
+
+// Query vectors
+export async function queryVectors(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = await c.req.json<QueryRequest>();
+
+    if (!indexName || !queryVector || !Array.isArray(queryVector)) {
+      throw new HTTPException(400, { message: 'Invalid request body. indexName and queryVector array are required.' });
+    }
+
+    const vector = getVector(c, vectorName);
+    const results: QueryResult[] = await vector.query(indexName, queryVector, topK, filter, includeVector);
+    return c.json({ results });
+  } catch (error) {
+    return handleError(error, 'Error querying vectors');
+  }
+}
+
+// List indexes
+export async function listIndexes(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const vector = getVector(c, vectorName);
+
+    const indexes = await vector.listIndexes();
+    return c.json({ indexes: indexes.filter(Boolean) });
+  } catch (error) {
+    return handleError(error, 'Error listing indexes');
+  }
+}
+
+// Describe index
+export async function describeIndex(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const indexName = c.req.param('indexName');
+
+    if (!indexName) {
+      throw new HTTPException(400, { message: 'Index name is required' });
+    }
+
+    const vector = getVector(c, vectorName);
+    const stats: IndexStats = await vector.describeIndex(indexName);
+
+    return c.json({
+      dimension: stats.dimension,
+      count: stats.count,
+      metric: stats.metric?.toLowerCase(),
+    });
+  } catch (error) {
+    return handleError(error, 'Error describing index');
+  }
+}
+
+// Delete index
+export async function deleteIndex(c: Context) {
+  try {
+    const vectorName = c.req.param('vectorName');
+    const indexName = c.req.param('indexName');
+
+    if (!indexName) {
+      throw new HTTPException(400, { message: 'Index name is required' });
+    }
+
+    const vector = getVector(c, vectorName);
+    await vector.deleteIndex(indexName);
+    return c.json({ success: true });
+  } catch (error) {
+    return handleError(error, 'Error deleting index');
+  }
+}

package/src/server/handlers/workflows.ts

@@ -0,0 +1,119 @@
+import type { Mastra } from '@mastra/core';
+import type { Context } from 'hono';
+import { streamText } from 'hono/streaming';
+import { stringify } from 'superjson';
+import zodToJsonSchema from 'zod-to-json-schema';
+
+
+import { handleError } from './error';
+
+export async function getWorkflowsHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const workflows = mastra.getWorkflows({ serialized: true });
+    return c.json(workflows);
+  } catch (error) {
+    return handleError(error, 'Error getting workflows');
+  }
+}
+
+export async function getWorkflowByIdHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const workflowId = c.req.param('workflowId');
+    const workflow = mastra.getWorkflow(workflowId);
+
+    const triggerSchema = workflow?.triggerSchema;
+    const stepGraph = workflow.stepGraph;
+    const stepSubscriberGraph = workflow.stepSubscriberGraph;
+    const serializedSteps = Object.entries(workflow.steps).reduce<any>((acc, [key, step]) => {
+      const _step = step as any;
+      acc[key] = {
+        ..._step,
+        inputSchema: _step.inputSchema ? stringify(zodToJsonSchema(_step.inputSchema)) : undefined,
+        outputSchema: _step.outputSchema ? stringify(zodToJsonSchema(_step.outputSchema)) : undefined,
+      };
+      return acc;
+    }, {});
+
+    return c.json({
+      name: workflow.name,
+      triggerSchema: triggerSchema ? stringify(zodToJsonSchema(triggerSchema)) : undefined,
+      steps: serializedSteps,
+      stepGraph,
+      stepSubscriberGraph,
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting workflow');
+  }
+}
+
+export async function executeWorkflowHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const workflowId = c.req.param('workflowId');
+    const workflow = mastra.getWorkflow(workflowId);
+    const body = await c.req.json();
+
+    const { start } = workflow.createRun();
+
+    const result = await start({
+      triggerData: body,
+    });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error executing workflow');
+  }
+}
+
+export async function watchWorkflowHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const logger = mastra.getLogger();
+    const workflowId = c.req.param('workflowId');
+    const workflow = mastra.getWorkflow(workflowId);
+
+    return streamText(
+      c,
+      async stream => {
+        // NOTE: looks like the UI is closing the watch request, so as long as that is the case
+        // this promise doesn't need to be resolved or rejected
+        return new Promise((_resolve, _reject) => {
+          let unwatch: () => void = workflow.watch(({ activePaths, context }) => {
+            void stream.write(JSON.stringify({ activePaths, context }) + '\x1E');
+          });
+
+          stream.onAbort(() => {
+            unwatch?.();
+          });
+        });
+      },
+      async (err, stream) => {
+        logger.error('Error in watch stream: ' + err?.message);
+        stream.abort();
+        await stream.close();
+      },
+    );
+  } catch (error) {
+    return handleError(error, 'Error watching workflow');
+  }
+}
+
+export async function resumeWorkflowHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const workflowId = c.req.param('workflowId');
+    const workflow = mastra.getWorkflow(workflowId);
+    const { stepId, runId, context } = await c.req.json();
+
+    const result = await workflow.resume({
+      stepId,
+      runId,
+      context,
+    });
+
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error resuming workflow step');
+  }
+}