Merge pull request #114 from ssdeanx/develop

Develop

Author: ssdeanx

app/api/chat/r.ts

@@ -30,9 +30,10 @@ export async function POST(req: Request) {
     const body: ChatRequestBody = await req.json()
 
     // Get available agents dynamically from mastra
-    const agentsMap = await mastra.getAgents()
+    const agentsMap = await mastra.listAgents()
+    
     const availableAgents = Object.keys(agentsMap)
-
+    const agent = await mastra.getAgent()
     // Prefer explicit top-level agentId, then nested data.agentId (network-style),
     // otherwise fall back to the first available agent
     const agentId = body.agentId ?? body.data?.agentId ?? availableAgents[0]
@@ -76,7 +77,7 @@ export async function POST(req: Request) {
 }
 
 export async function GET() {
-    const agentsMap = await mastra.getAgents()
+    const agentsMap = await mastra.listAgents()
     const availableAgents = Object.keys(agentsMap)
     return Response.json({
         agents: availableAgents,

app/api/chat/route.ts

@@ -1,52 +1,94 @@
 import { mastra } from '../../../src/mastra'
-import { RequestContext } from '@mastra/core/request-context'
+import {
+    RequestContext,
+    MASTRA_RESOURCE_ID_KEY,
+    MASTRA_THREAD_ID_KEY,
+} from '@mastra/core/request-context'
 import { toAISdkStream } from '@mastra/ai-sdk'
 import { createUIMessageStream, createUIMessageStreamResponse } from 'ai'
+import type { UIMessage } from 'ai'
 
 export async function POST(req: Request) {
-    const { messages, data, id } = await req.json()
+    const body = await req.json()
+    const { messages, data, id } = body
 
-    const agentId: string =
+    // Agent selection logic
+    const agentId =
         (typeof data?.agentId === 'string' && data.agentId.length > 0
             ? data.agentId
             : undefined) ??
         (typeof id === 'string' && id.length > 0 ? id : undefined) ??
         'weatherAgent'
 
-    const myAgent = mastra.getAgent(agentId)
+    const agent = mastra.getAgent(agentId)
 
+    if (!agent) {
+        return Response.json(
+            { error: `Agent "${agentId}" not found` },
+            { status: 404 }
+        )
+    }
+
+    // Extract multi-tenancy IDs
+    const threadId = body.threadId ?? data?.threadId
+    const resourceId = body.resourceId ?? data?.resourceId
+
+    // Create RequestContext for multi-tenancy isolation
     const requestContext = new RequestContext()
+    if (resourceId) requestContext.set(MASTRA_RESOURCE_ID_KEY, resourceId)
+    if (threadId) requestContext.set(MASTRA_THREAD_ID_KEY, threadId)
 
-    if (data) {
+    // Merge other data into context if present
+    if (data && typeof data === 'object') {
         for (const [key, value] of Object.entries(data)) {
-            requestContext.set(key, value)
+            if (
+                key !== 'agentId' &&
+                key !== 'threadId' &&
+                key !== 'resourceId'
+            ) {
+                requestContext.set(key, value)
+            }
         }
     }
 
-    const stream = await myAgent.stream(messages, { requestContext })
+    // Prepare stream options
+    const streamOptions = {
+        threadId,
+        resourceId,
+        memory: body.memory ?? data?.memory,
+        requestContext,
+    }
+
+    const stream = await agent.stream(messages, streamOptions)
 
     const uiStream = createUIMessageStream({
-        originalMessages: messages,
+        originalMessages: messages as UIMessage[],
         execute: async ({ writer }) => {
-            const aiStream = toAISdkStream(stream, { from: 'agent' }) as any
+            const aiStream = toAISdkStream(stream, {
+                from: 'agent',
+                sendReasoning: true,
+                sendSources: true,
+            })
 
-            if (typeof aiStream[Symbol.asyncIterator] === 'function') {
-                for await (const part of aiStream as AsyncIterable<any>) {
-                    await writer.write(part)
-                }
-            } else if (typeof aiStream.getReader === 'function') {
-                const reader = aiStream.getReader()
+            // Support both ReadableStream and AsyncIterable (robust bridge)
+            if (
+                aiStream &&
+                typeof (aiStream as any).getReader === 'function'
+            ) {
+                const reader = (aiStream as ReadableStream<any>).getReader()
                 try {
                     while (true) {
                         const { value, done } = await reader.read()
-                        if (done) {
-                            break
-                        }
+                        if (done) break
                         await writer.write(value)
                     }
                 } finally {
                     reader.releaseLock?.()
                 }
+            } else if (aiStream && Symbol.asyncIterator in aiStream) {
+                for await (const part of aiStream as AsyncIterable<any>) {
+                    await writer.write(part)
+                }
             }
         },
     })

app/api/mastra/logs/[runId]/route.ts

@@ -0,0 +1,28 @@
+import { MastraClient } from '@mastra/client-js'
+
+const mastraClient = new MastraClient({
+    baseUrl: process.env.NEXT_PUBLIC_MASTRA_API_URL || 'http://localhost:4111',
+})
+
+export async function GET(
+    request: Request,
+    { params }: { params: Promise<{ runId: string }> }
+): Promise<Response> {
+    const { runId } = await params
+    const { searchParams } = new URL(request.url)
+    const transportId = searchParams.get('transportId') || ''
+
+    try {
+        const logs = await mastraClient.getLogForRun({
+            runId,
+            transportId,
+        })
+        return Response.json(logs)
+    } catch (error) {
+        console.error('Error fetching run logs:', error)
+        return Response.json(
+            { error: 'Failed to fetch run logs', details: String(error) },
+            { status: 500 }
+        )
+    }
+}

app/api/mastra/logs/route.ts

@@ -0,0 +1,30 @@
+import { MastraClient } from '@mastra/client-js'
+
+const mastraClient = new MastraClient({
+    baseUrl: process.env.NEXT_PUBLIC_MASTRA_API_URL || 'http://localhost:4111',
+})
+
+export async function GET(request: Request): Promise<Response> {
+    const { searchParams } = new URL(request.url)
+    const action = searchParams.get('action')
+
+    try {
+        if (action === 'transports') {
+            const transports = await mastraClient.listLogTransports()
+            return Response.json({ transports })
+        }
+
+        const transportId = searchParams.get('transportId') || undefined
+        const logs = await mastraClient.listLogs({
+            transportId: transportId ?? '',
+        })
+
+        return Response.json({ logs })
+    } catch (error) {
+        console.error('Error fetching logs:', error)
+        return Response.json(
+            { error: 'Failed to fetch logs', details: String(error) },
+            { status: 500 }
+        )
+    }
+}

app/api/mastra/memory/status/route.ts

@@ -0,0 +1,28 @@
+import { MastraClient } from '@mastra/client-js'
+
+const mastraClient = new MastraClient({
+    baseUrl: process.env.NEXT_PUBLIC_MASTRA_API_URL || 'http://localhost:4111',
+})
+
+export async function GET(request: Request): Promise<Response> {
+    const { searchParams } = new URL(request.url)
+    const agentId = searchParams.get('agentId')
+
+    if (!agentId) {
+        return Response.json(
+            { error: 'agentId query parameter is required' },
+            { status: 400 }
+        )
+    }
+
+    try {
+        const status = await mastraClient.getMemoryStatus(agentId)
+        return Response.json(status)
+    } catch (error) {
+        console.error('Error fetching memory status:', error)
+        return Response.json(
+            { error: 'Failed to fetch memory status', details: String(error) },
+            { status: 500 }
+        )
+    }
+}

app/api/mastra/memory/working-memory/route.ts

@@ -0,0 +1,75 @@
+import { MastraClient } from '@mastra/client-js'
+
+const mastraClient = new MastraClient({
+    baseUrl: process.env.NEXT_PUBLIC_MASTRA_API_URL || 'http://localhost:4111',
+})
+
+export async function GET(request: Request): Promise<Response> {
+    const { searchParams } = new URL(request.url)
+    const agentId = searchParams.get('agentId')
+    const threadId = searchParams.get('threadId')
+    const resourceId = searchParams.get('resourceId') || undefined
+
+    if (!agentId || !threadId) {
+        return Response.json(
+            { error: 'agentId and threadId query parameters are required' },
+            { status: 400 }
+        )
+    }
+
+    try {
+        const workingMemory = await mastraClient.getWorkingMemory({
+            agentId,
+            threadId,
+            resourceId,
+        })
+        return Response.json(workingMemory)
+    } catch (error) {
+        console.error('Error fetching working memory:', error)
+        return Response.json(
+            {
+                error: 'Failed to fetch working memory',
+                details: String(error),
+            },
+            { status: 500 }
+        )
+    }
+}
+
+export async function PUT(request: Request): Promise<Response> {
+    const body = await request.json()
+    const { agentId, threadId, workingMemory, resourceId } = body as {
+        agentId: string
+        threadId: string
+        workingMemory: string
+        resourceId?: string
+    }
+
+    if (!agentId || !threadId || workingMemory === undefined) {
+        return Response.json(
+            {
+                error: 'agentId, threadId, and workingMemory are required in the request body',
+            },
+            { status: 400 }
+        )
+    }
+
+    try {
+        const result = await mastraClient.updateWorkingMemory({
+            agentId,
+            threadId,
+            workingMemory,
+            resourceId,
+        })
+        return Response.json(result)
+    } catch (error) {
+        console.error('Error updating working memory:', error)
+        return Response.json(
+            {
+                error: 'Failed to update working memory',
+                details: String(error),
+            },
+            { status: 500 }
+        )
+    }
+}

app/api/mastra/threads/[threadId]/clone/route.ts

@@ -0,0 +1,58 @@
+import { MastraClient } from '@mastra/client-js'
+
+const mastraClient = new MastraClient({
+    baseUrl: process.env.NEXT_PUBLIC_MASTRA_API_URL || 'http://localhost:4111',
+})
+
+export async function POST(
+    request: Request,
+    { params }: { params: Promise<{ threadId: string }> }
+): Promise<Response> {
+    const { threadId } = await params
+    const body = await request.json()
+    const { newThreadId, title, metadata, options } = body as {
+        newThreadId?: string
+        title?: string
+        metadata?: Record<string, unknown>
+        options?: {
+            messageLimit?: number
+            messageFilter?: {
+                startDate?: string
+                endDate?: string
+            }
+        }
+    }
+
+    try {
+        const thread = mastraClient.getMemoryThread({ threadId })
+
+        const cloneOptions: Record<string, unknown> = {}
+        if (newThreadId) cloneOptions.newThreadId = newThreadId
+        if (title) cloneOptions.title = title
+        if (metadata) cloneOptions.metadata = metadata
+        if (options) {
+            const opts: Record<string, unknown> = {}
+            if (options.messageLimit) opts.messageLimit = options.messageLimit
+            if (options.messageFilter) {
+                opts.messageFilter = {
+                    startDate: options.messageFilter.startDate
+                        ? new Date(options.messageFilter.startDate)
+                        : undefined,
+                    endDate: options.messageFilter.endDate
+                        ? new Date(options.messageFilter.endDate)
+                        : undefined,
+                }
+            }
+            cloneOptions.options = opts
+        }
+
+        const result = await thread.clone(cloneOptions)
+        return Response.json(result)
+    } catch (error) {
+        console.error('Error cloning thread:', error)
+        return Response.json(
+            { error: 'Failed to clone thread', details: String(error) },
+            { status: 500 }
+        )
+    }
+}