mastra 0.1.57-alpha.90 → 0.1.57-unstable.100

package/dist/src/templates/worker.js

@@ -0,0 +1,719 @@
+import { AutoRouter } from 'itty-router';
+import { join } from 'path';
+const { mastra } = await import(join(process.cwd(), 'mastra.mjs'));
+const router = AutoRouter();
+const validateBody = async (body) => {
+    const errorResponse = Object.entries(body).reduce((acc, [key, value]) => {
+        if (!value) {
+            acc[key] = `${key} is required`;
+        }
+        return acc;
+    }, {});
+    if (Object.keys(errorResponse).length > 0) {
+        return { ok: false, errorResponse };
+    }
+    return { ok: true };
+};
+router.get('/', () => {
+    return new Response('Hello to the Mastra API!', {
+        headers: { 'Content-Type': 'text/plain' },
+    });
+});
+router.get('/agent/:agentId', ({ params }) => {
+    try {
+        const agentId = decodeURIComponent(params.agentId);
+        const agent = mastra.getAgent(agentId);
+        return new Response(JSON.stringify({
+            agentId: agent.name,
+            enabledTools: agent.enabledTools,
+        }), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting agent', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error getting agent' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/agent/:agentId/text', async ({ params, json }) => {
+    try {
+        const agentId = decodeURIComponent(params.agentId);
+        const agent = mastra.getAgent(agentId);
+        const body = await json();
+        const messages = body.messages;
+        const { ok, errorResponse } = await validateBody({ messages });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        if (!Array.isArray(messages)) {
+            return new Response(JSON.stringify({ error: { messages: 'Messages should be an array' } }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const result = await agent.text({ messages });
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error texting from agent', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error texting from agent' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/agent/:agentId/stream', async ({ params, json }) => {
+    try {
+        const agentId = decodeURIComponent(params.agentId);
+        const agent = mastra.getAgent(agentId);
+        const body = await json();
+        const messages = body.messages;
+        const { ok, errorResponse } = await validateBody({ messages });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        if (!Array.isArray(messages)) {
+            return new Response(JSON.stringify({ error: { messages: 'Messages should be an array' } }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const streamResult = await agent.stream({
+            messages,
+        });
+        return streamResult.toDataStreamResponse({
+            headers: {
+                'Content-Type': 'text/x-unknown',
+                'content-encoding': 'identity',
+                'transfer-encoding': 'chunked',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error streaming from agent', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error streaming from agent' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/agent/:agentId/text-object', async ({ params, json }) => {
+    try {
+        const agentId = decodeURIComponent(params.agentId);
+        const agent = mastra.getAgent(agentId);
+        const body = await json();
+        const messages = body.messages;
+        const structuredOutput = body.structuredOutput;
+        const { ok, errorResponse } = await validateBody({
+            messages,
+            structuredOutput,
+        });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        if (!Array.isArray(messages)) {
+            return new Response(JSON.stringify({ error: { messages: 'Messages should be an array' } }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const result = await agent.textObject({ messages, structuredOutput });
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting structured output from agent', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error getting structured output from agent' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/agent/:agentId/stream-object', async ({ params, json }) => {
+    try {
+        const agentId = decodeURIComponent(params.agentId);
+        const agent = mastra.getAgent(agentId);
+        const body = await json();
+        const messages = body.messages;
+        const structuredOutput = body.structuredOutput;
+        const { ok, errorResponse } = await validateBody({
+            messages,
+            structuredOutput,
+        });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        if (!Array.isArray(messages)) {
+            return new Response(JSON.stringify({ error: { messages: 'Messages should be an array' } }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const streamResult = await agent.streamObject({
+            messages,
+            structuredOutput,
+        });
+        return streamResult.toTextStreamResponse({
+            headers: {
+                'Content-Type': 'text/x-unknown',
+                'content-encoding': 'identity',
+                'transfer-encoding': 'chunked',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error streaming structured output from agent', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error streaming structured output from agent' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/workflows/:workflowId/execute', async ({ params, json }) => {
+    try {
+        const workflowId = decodeURIComponent(params.workflowId);
+        const workflow = mastra.workflows.get(workflowId);
+        const body = await json();
+        console.log('body', body);
+        const result = await workflow.execute(body);
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error executing workflow', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error executing workflow' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.get('/memory/threads/get-by-resourceid/:resourceid', async ({ params }) => {
+    try {
+        const resourceid = decodeURIComponent(params.resourceid);
+        const memory = mastra.memory;
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const threads = await memory.getThreadsByResourceId({ resourceid });
+        return new Response(JSON.stringify(threads), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting threads from memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error getting threads from memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.get('/memory/threads/:threadId', async ({ params }) => {
+    try {
+        const threadId = decodeURIComponent(params.threadId);
+        const memory = mastra.memory;
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const thread = await memory.getThreadById({ threadId });
+        if (!thread) {
+            return new Response(JSON.stringify({ error: 'Thread not found' }), {
+                status: 404,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        return new Response(JSON.stringify(thread), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting thread from memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error getting thread from memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/memory/threads', async ({ json }) => {
+    try {
+        const memory = mastra.memory;
+        const { title, metadata, resourceid, threadId } = await json();
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const { ok, errorResponse } = await validateBody({ resourceid });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const result = await memory.createThread({ resourceid, title, metadata, threadId });
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error saving thread to memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error saving thread to memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.patch('/memory/threads/:threadId', async ({ params, json }) => {
+    try {
+        const threadId = decodeURIComponent(params.threadId);
+        const memory = mastra.memory;
+        const { title, metadata, resourceid } = await json();
+        const updatedAt = new Date();
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const thread = await memory.getThreadById({ threadId });
+        if (!thread) {
+            return new Response(JSON.stringify({ error: 'Thread not found' }), {
+                status: 404,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        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 new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error saving thread to memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error saving thread to memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.delete('/memory/threads/:threadId', async ({ params }) => {
+    try {
+        const threadId = decodeURIComponent(params.threadId);
+        const memory = mastra.memory;
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const thread = await memory.getThreadById({ threadId });
+        if (!thread) {
+            return new Response(JSON.stringify({ error: 'Thread not found' }), {
+                status: 404,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        await memory.deleteThread(threadId);
+        return new Response(JSON.stringify({ result: 'Thread deleted' }), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error deleting thread from memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error deleting thread from memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.get('/memory/threads/:threadId/messages', async ({ params }) => {
+    try {
+        const threadId = decodeURIComponent(params.threadId);
+        const memory = mastra.memory;
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const thread = await memory.getThreadById({ threadId });
+        if (!thread) {
+            return new Response(JSON.stringify({ error: 'Thread not found' }), {
+                status: 404,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const result = await memory.getMessages({ threadId });
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting messages from memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error getting messages from memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.get('/memory/threads/:threadId/context-window', async ({ params, query }) => {
+    try {
+        const threadId = decodeURIComponent(params.threadId);
+        const { startDate, endDate, format } = query;
+        const memory = mastra.memory;
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const thread = await memory.getThreadById({ threadId });
+        if (!thread) {
+            return new Response(JSON.stringify({ error: 'Thread not found' }), {
+                status: 404,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const result = await memory.getContextWindow({ threadId, startDate, endDate, format });
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting context window from memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error getting context window from memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/memory/save-messages', async ({ json }) => {
+    try {
+        const memory = mastra.memory;
+        const messages = await json();
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const { ok, errorResponse } = await validateBody({ messages });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        if (!Array.isArray(messages)) {
+            return new Response(JSON.stringify({ error: { messages: 'Messages should be an array' } }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const processMessages = messages.map(message => {
+            return {
+                ...message,
+                id: memory.generateId(),
+                createdAt: message.createdAt ? new Date(message.createdAt) : new Date(),
+            };
+        });
+        const result = await memory.saveMessages({ messages: processMessages });
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error saving messages to memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error saving messages to memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/memory/threads/:threadId/tool-result', async ({ params, json }) => {
+    try {
+        const threadId = decodeURIComponent(params.threadId);
+        const memory = mastra.memory;
+        const { toolName, toolArgs } = await json();
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const { ok, errorResponse } = await validateBody({ toolName, toolArgs });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const thread = await memory.getThreadById({ threadId });
+        if (!thread) {
+            return new Response(JSON.stringify({ error: 'Thread not found' }), {
+                status: 404,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const result = await memory.getToolResult({ threadId, toolName, toolArgs });
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting tool result from memory', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error getting tool result from memory' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+router.post('/memory/validate-tool-call-args', async ({ json }) => {
+    try {
+        const memory = mastra.memory;
+        const { hashedArgs } = await json();
+        if (!memory) {
+            return new Response(JSON.stringify({ error: 'Memory is not initialized' }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const { ok, errorResponse } = await validateBody({ hashedArgs });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const result = await memory.validateToolCallArgs({ hashedArgs });
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error validating tool call args', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error validating tool call args' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+/**
+ * POST /syncs/{syncId}/execute
+ * @summary Execute a sync operation
+ * @tags Sync
+ * @param {string} syncId.path.required - Sync identifier
+ * @param {object} request.body.required - Sync parameters
+ * @param {string} request.body.runId - Run identifier
+ * @param {object} request.body.params - Sync parameters
+ * @return {object} 200 - Sync execution result
+ * @return {Error} 400 - Validation error
+ * @return {Error} 500 - Server error
+ */
+router.post('/syncs/:syncId/execute', async ({ params, json }) => {
+    try {
+        const syncId = decodeURIComponent(params.syncId);
+        const { runId, params: syncParams } = await json();
+        const { ok, errorResponse } = await validateBody({ params: syncParams });
+        if (!ok) {
+            return new Response(JSON.stringify({ error: errorResponse }), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        const result = await mastra.sync(syncId, syncParams, runId);
+        return new Response(JSON.stringify(result), {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error executing sync', apiError);
+        return new Response(JSON.stringify({ error: apiError.message || 'Error executing sync' }), {
+            status: apiError.status || 500,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+});
+// 404 handler
+router.all('*', () => new Response('Not Found', { status: 404 }));
+export default {
+    async fetch(request, env, ctx) {
+        Object.entries(env || {}).forEach(([key, value]) => {
+            process.env[key] = value;
+        });
+        return router.fetch(request, env, ctx);
+    },
+};