@mastra/deployer 0.0.0-storage-20250225005900

package/src/server/handlers/agents.ts

@@ -0,0 +1,210 @@
+import type { Mastra } from '@mastra/core';
+import type { Context } from 'hono';
+import { stringify } from 'superjson';
+import zodToJsonSchema from 'zod-to-json-schema';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+import { validateBody } from './utils';
+
+// Agent handlers
+export async function getAgentsHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const agents = mastra.getAgents();
+
+    const serializedAgents = Object.entries(agents).reduce<any>((acc, [_id, _agent]) => {
+      const agent = _agent as any;
+      const serializedAgentTools = Object.entries(agent?.tools || {}).reduce<any>((acc, [key, tool]) => {
+        const _tool = tool as any;
+        acc[key] = {
+          ..._tool,
+          inputSchema: _tool.inputSchema ? stringify(zodToJsonSchema(_tool.inputSchema)) : undefined,
+          outputSchema: _tool.outputSchema ? stringify(zodToJsonSchema(_tool.outputSchema)) : undefined,
+        };
+        return acc;
+      }, {});
+      acc[_id] = {
+        name: agent.name,
+        instructions: agent.instructions,
+        tools: serializedAgentTools,
+        provider: agent.llm?.getProvider(),
+        modelId: agent.llm?.getModelId(),
+      };
+      return acc;
+    }, {});
+
+    return c.json(serializedAgents);
+  } catch (error) {
+    return handleError(error, 'Error getting agents');
+  }
+}
+
+export async function getAgentByIdHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+
+    if (!agent) {
+      throw new HTTPException(404, { message: 'Agent not found' });
+    }
+
+    const serializedAgentTools = Object.entries(agent?.tools || {}).reduce<any>((acc, [key, tool]) => {
+      const _tool = tool as any;
+      acc[key] = {
+        ..._tool,
+        inputSchema: _tool.inputSchema ? stringify(zodToJsonSchema(_tool.inputSchema)) : undefined,
+        outputSchema: _tool.outputSchema ? stringify(zodToJsonSchema(_tool.outputSchema)) : undefined,
+      };
+      return acc;
+    }, {});
+
+    return c.json({
+      name: agent.name,
+      instructions: agent.instructions,
+      tools: serializedAgentTools,
+      provider: agent.llm?.getProvider(),
+      modelId: agent.llm?.getModelId(),
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting agent');
+  }
+}
+
+export async function getEvalsByAgentIdHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+    const evals = (await mastra.storage?.getEvalsByAgentName?.(agent.name, 'test')) || [];
+    return c.json({
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals,
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting test evals');
+  }
+}
+
+export async function getLiveEvalsByAgentIdHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+    const evals = (await mastra.storage?.getEvalsByAgentName?.(agent.name, 'live')) || [];
+
+    return c.json({
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals,
+    });
+  } catch (error) {
+    return handleError(error, 'Error getting live evals');
+  }
+}
+
+export async function generateHandler(c: Context) {
+  try {
+    const mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+
+    if (!agent) {
+      throw new HTTPException(404, { message: 'Agent not found' });
+    }
+
+    const { messages, threadId, resourceid, resourceId, output, runId } = await c.req.json();
+    validateBody({ messages });
+
+    if (!Array.isArray(messages)) {
+      throw new HTTPException(400, { message: 'Messages should be an array' });
+    }
+
+    // Use resourceId if provided, fall back to resourceid (deprecated)
+    const finalResourceId = resourceId ?? resourceid;
+
+    const result = await agent.generate(messages, { threadId, resourceId: finalResourceId, output, runId });
+
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error generating from agent');
+  }
+}
+
+export async function streamGenerateHandler(c: Context): Promise<Response | undefined> {
+  try {
+    const mastra = c.get('mastra');
+    const agentId = c.req.param('agentId');
+    const agent = mastra.getAgent(agentId);
+
+    if (!agent) {
+      throw new HTTPException(404, { message: 'Agent not found' });
+    }
+
+    const { messages, threadId, resourceid, resourceId, output, runId } = await c.req.json();
+
+    validateBody({ messages });
+
+    if (!Array.isArray(messages)) {
+      throw new HTTPException(400, { message: 'Messages should be an array' });
+    }
+
+    // Use resourceId if provided, fall back to resourceid (deprecated)
+    const finalResourceId = resourceId ?? resourceid;
+
+    const streamResult = await agent.stream(messages, { threadId, resourceId: finalResourceId, output, runId });
+
+    const streamResponse = output
+      ? streamResult.toTextStreamResponse()
+      : streamResult.toDataStreamResponse({
+          sendUsage: true,
+          sendReasoning: true,
+          getErrorMessage: (error: any) => {
+            return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+          },
+        });
+
+    return streamResponse;
+  } catch (error) {
+    return handleError(error, 'Error streaming from agent');
+  }
+}
+
+export async function setAgentInstructionsHandler(c: Context) {
+  try {
+    // Check if this is a playground request
+    const isPlayground = c.get('playground') === true;
+    if (!isPlayground) {
+      return c.json({ error: 'This API is only available in the playground environment' }, 403);
+    }
+
+    const agentId = c.req.param('agentId');
+    const { instructions } = await c.req.json();
+
+    if (!agentId || !instructions) {
+      return c.json({ error: 'Missing required fields' }, 400);
+    }
+
+    const mastra: Mastra = c.get('mastra');
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      return c.json({ error: 'Agent not found' }, 404);
+    }
+
+    agent.__updateInstructions(instructions);
+
+    return c.json(
+      {
+        instructions,
+      },
+      200,
+    );
+  } catch (error) {
+    return handleError(error, 'Error setting agent instructions');
+  }
+}

package/src/server/handlers/client.ts

@@ -0,0 +1,36 @@
+import type { Context } from 'hono';
+
+const clients = new Set<ReadableStreamDefaultController>();
+
+export function handleClientsRefresh(c: Context): Response {
+  const stream = new ReadableStream({
+    start(controller) {
+      clients.add(controller);
+      controller.enqueue('data: connected\n\n');
+
+      c.req.raw.signal.addEventListener('abort', () => {
+        clients.delete(controller);
+      });
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+    },
+  });
+}
+
+export function handleTriggerClientsRefresh(c: Context) {
+  clients.forEach(controller => {
+    try {
+      controller.enqueue('data: refresh\n\n');
+    } catch {
+      clients.delete(controller);
+    }
+  });
+  return c.json({ success: true, clients: clients.size });
+}

package/src/server/handlers/error.ts

@@ -0,0 +1,29 @@
+import type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+
+import type { ApiError } from '../types';
+
+// Helper to handle errors consistently
+export function handleError(error: unknown, defaultMessage: string): Promise<Response> {
+  console.error(defaultMessage, error);
+  const apiError = error as ApiError;
+  throw new HTTPException((apiError.status || 500) as ContentfulStatusCode, {
+    message: apiError.message || defaultMessage,
+  });
+}
+
+// Error handlers
+export function notFoundHandler() {
+  throw new HTTPException(404, { message: 'Not Found' });
+}
+
+export function errorHandler(err: Error, c: Context): Response {
+  if (err instanceof HTTPException) {
+    return c.json({ error: err.message }, err.status);
+  }
+
+  console.error(err);
+  return c.json({ error: 'Internal Server Error' }, 500);
+}

package/src/server/handlers/logs.ts

@@ -0,0 +1,53 @@
+import type { Mastra } from '@mastra/core';
+import type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+
+export async function getLogsHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const transportId = c.req.query('transportId');
+
+    if (!transportId) {
+      throw new HTTPException(400, { message: 'transportId is required' });
+    }
+
+    const logs = await mastra.getLogs(transportId);
+    return c.json(logs);
+  } catch (error) {
+    return handleError(error, 'Error getting logs');
+  }
+}
+
+export async function getLogsByRunIdHandler(c: Context) {
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const runId = c.req.param('runId');
+    const transportId = c.req.query('transportId');
+
+    if (!transportId) {
+      throw new HTTPException(400, { message: 'transportId is required' });
+    }
+
+    const logs = await mastra.getLogsByRunId({ runId, transportId });
+    return c.json(logs);
+  } catch (error) {
+    return handleError(error, 'Error getting logs by run ID');
+  }
+}
+
+export async function getLogTransports(c: Context) {
+  console.log('here');
+  try {
+    const mastra: Mastra = c.get('mastra');
+    const logger = mastra.getLogger();
+    const transports = logger.transports;
+    return c.json({
+      transports: Object.keys(transports),
+    });
+  } catch (e) {
+    return handleError(e, 'Error getting log Transports ');
+  }
+}

package/src/server/handlers/memory.ts

@@ -0,0 +1,196 @@
+import type { MastraMemory } from '@mastra/core/memory';
+import type { Context } from 'hono';
+
+import { HTTPException } from 'hono/http-exception';
+
+import { handleError } from './error';
+import { validateBody } from './utils';
+
+function getMemoryFromContext(c: Context): MastraMemory | null | undefined {
+  const mastra = c.get('mastra');
+  const agentId = c.req.query('agentId');
+  const agent = agentId ? mastra.getAgent(agentId) : null;
+
+  if (agentId && !agent) {
+    throw new HTTPException(404, { message: 'Agent not found' });
+  }
+
+  const memory = agent?.getMemory?.() || mastra.memory;
+
+  return memory;
+}
+
+// Memory handlers
+export async function getMemoryStatusHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+
+    if (!memory) {
+      return c.json({ result: false });
+    }
+
+    return c.json({ result: true });
+  } catch (error) {
+    return handleError(error, 'Error getting memory status');
+  }
+}
+
+export async function getThreadsHandler(c: Context) {
+  try {
+    const { resourceid } = c.req.query();
+    const memory = getMemoryFromContext(c);
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    if (!resourceid) {
+      throw new HTTPException(400, { message: 'Resource ID is required' });
+    }
+
+    const threads = await memory.getThreadsByResourceId({ resourceId: resourceid });
+    return c.json(threads);
+  } catch (error) {
+    return handleError(error, 'Error getting threads');
+  }
+}
+
+export async function getThreadByIdHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+    const threadId = c.req.param('threadId');
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: 'Thread not found' });
+    }
+
+    return c.json(thread);
+  } catch (error) {
+    return handleError(error, 'Error getting thread');
+  }
+}
+
+export async function saveMessagesHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+    const { messages } = await c.req.json();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    validateBody({ messages });
+
+    if (!Array.isArray(messages)) {
+      throw new HTTPException(400, { message: 'Messages should be an array' });
+    }
+
+    const processedMessages = messages.map(message => ({
+      ...message,
+      id: memory.generateId(),
+      createdAt: message.createdAt ? new Date(message.createdAt) : new Date(),
+    }));
+
+    const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error saving messages');
+  }
+}
+
+export async function createThreadHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+    const { title, metadata, resourceid, threadId } = await c.req.json();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    validateBody({ resourceid });
+
+    const result = await memory.createThread({ resourceId: resourceid, title, metadata, threadId });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error saving thread to memory');
+  }
+}
+
+export async function updateThreadHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+    const threadId = c.req.param('threadId');
+    const { title, metadata, resourceid } = await c.req.json();
+    const updatedAt = new Date();
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: 'Thread not found' });
+    }
+
+    const updatedThread = {
+      ...thread,
+      title: title || thread.title,
+      metadata: metadata || thread.metadata,
+      resourceId: resourceid || thread.resourceId,
+      createdAt: thread.createdAt,
+      updatedAt,
+    };
+
+    const result = await memory.saveThread({ thread: updatedThread });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error updating thread');
+  }
+}
+
+export async function deleteThreadHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+    const threadId = c.req.param('threadId');
+
+    if (!memory) {
+      throw new HTTPException(400, { message: 'Memory is not initialized' });
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: 'Thread not found' });
+    }
+
+    await memory.deleteThread(threadId);
+    return c.json({ result: 'Thread deleted' });
+  } catch (error) {
+    return handleError(error, 'Error deleting thread');
+  }
+}
+
+export async function getMessagesHandler(c: Context) {
+  try {
+    const memory = getMemoryFromContext(c);
+    const threadId = c.req.param('threadId');
+
+    if (!memory) {
+      return c.json({ error: 'Memory is not initialized' }, 400);
+    }
+
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      return c.json({ error: 'Thread not found' }, 404);
+    }
+
+    const result = await memory.query({ threadId });
+    return c.json(result);
+  } catch (error) {
+    return handleError(error, 'Error getting messages');
+  }
+}

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!');
+}