@mastra/server 0.0.0-taofeeqInngest-20250603090617 → 0.0.0-transpile-packages-20250724123433

package/dist/{chunk-CMMOIUFC.cjs → chunk-RHSWAXKB.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunk57CJTIPW_cjs = require('./chunk-57CJTIPW.cjs');
-var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
-var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunkCCGRCYWJ_cjs = require('./chunk-CCGRCYWJ.cjs');
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
 var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
 var stream = require('stream');
 
@@ -17,19 +17,20 @@ chunk75ZPJI57_cjs.__export(voice_exports, {
 async function getSpeakersHandler({ mastra, agentId }) {
   try {
     if (!agentId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent ID is required" });
     }
     const agent = mastra.getAgent(agentId);
     if (!agent) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
     }
-    if (!agent.voice) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
     }
-    const speakers = await agent.voice.getSpeakers();
+    const speakers = await voice.getSpeakers();
     return speakers;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error getting speakers");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting speakers");
   }
 }
 async function generateSpeechHandler({
@@ -39,25 +40,26 @@ async function generateSpeechHandler({
 }) {
   try {
     if (!agentId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent ID is required" });
     }
-    chunk57CJTIPW_cjs.validateBody({
+    chunkCCGRCYWJ_cjs.validateBody({
       text: body?.text
     });
     const agent = mastra.getAgent(agentId);
     if (!agent) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
     }
-    if (!agent.voice) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
     }
-    const audioStream = await agent.voice.speak(body.text, { speaker: body.speakerId });
+    const audioStream = await voice.speak(body.text, { speaker: body.speakerId });
     if (!audioStream) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: "Failed to generate speech" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(500, { message: "Failed to generate speech" });
     }
     return audioStream;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error generating speech");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error generating speech");
   }
 }
 async function transcribeSpeechHandler({
@@ -67,43 +69,45 @@ async function transcribeSpeechHandler({
 }) {
   try {
     if (!agentId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent ID is required" });
     }
     if (!body?.audioData) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Audio data is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Audio data is required" });
     }
     const agent = mastra.getAgent(agentId);
     if (!agent) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
     }
-    if (!agent.voice) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
     }
     const audioStream = new stream.Readable();
     audioStream.push(body.audioData);
     audioStream.push(null);
-    const text = await agent.voice.listen(audioStream, body.options);
+    const text = await voice.listen(audioStream, body.options);
     return { text };
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error transcribing speech");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error transcribing speech");
   }
 }
 async function getListenerHandler({ mastra, agentId }) {
   try {
     if (!agentId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent ID is required" });
     }
     const agent = mastra.getAgent(agentId);
     if (!agent) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
     }
-    if (!agent.voice) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
     }
-    const listeners = await agent.voice.getListener();
+    const listeners = await voice.getListener();
     return listeners;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error getting listeners");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting listeners");
   }
 }
 

package/dist/{chunk-H5PTF3Y4.js → chunk-RSEO4XPX.js}

@@ -1,4 +1,4 @@
-import { HTTPException } from './chunk-NYN7KFXL.js';
+import { HTTPException } from './chunk-LCM566I4.js';
 
 // src/server/handlers/utils.ts
 function validateBody(body) {

package/dist/chunk-VULESSU5.js

@@ -0,0 +1,149 @@
+import { handleError } from './chunk-LF7P5PLR.js';
+import { __export } from './chunk-MLKGABMK.js';
+
+// src/server/handlers/scores.ts
+var scores_exports = {};
+__export(scores_exports, {
+  getScorerHandler: () => getScorerHandler,
+  getScorersHandler: () => getScorersHandler,
+  getScoresByEntityIdHandler: () => getScoresByEntityIdHandler,
+  getScoresByRunIdHandler: () => getScoresByRunIdHandler,
+  getScoresByScorerIdHandler: () => getScoresByScorerIdHandler,
+  saveScoreHandler: () => saveScoreHandler
+});
+async function getScorersFromSystem({
+  mastra,
+  runtimeContext
+}) {
+  const agents = mastra.getAgents();
+  const workflows = mastra.getWorkflows();
+  const scorersMap = /* @__PURE__ */ new Map();
+  for (const [agentId, agent] of Object.entries(agents)) {
+    const scorers = await agent.getScorers({
+      runtimeContext
+    }) || {};
+    if (Object.keys(scorers).length > 0) {
+      for (const [scorerId, scorer] of Object.entries(scorers)) {
+        if (scorersMap.has(scorerId)) {
+          scorersMap.get(scorerId)?.agentIds.push(agentId);
+        } else {
+          scorersMap.set(scorerId, {
+            workflowIds: [],
+            ...scorer,
+            agentIds: [agentId]
+          });
+        }
+      }
+    }
+  }
+  for (const [workflowId, workflow] of Object.entries(workflows)) {
+    const scorers = await workflow.getScorers({
+      runtimeContext
+    }) || {};
+    if (Object.keys(scorers).length > 0) {
+      for (const [scorerId, scorer] of Object.entries(scorers)) {
+        if (scorersMap.has(scorerId)) {
+          scorersMap.get(scorerId)?.workflowIds.push(workflowId);
+        } else {
+          scorersMap.set(scorerId, {
+            agentIds: [],
+            ...scorer,
+            workflowIds: [workflowId]
+          });
+        }
+      }
+    }
+  }
+  return Object.fromEntries(scorersMap.entries());
+}
+async function getScorersHandler({ mastra, runtimeContext }) {
+  const scorers = await getScorersFromSystem({
+    mastra,
+    runtimeContext
+  });
+  return scorers;
+}
+async function getScorerHandler({
+  mastra,
+  scorerId,
+  runtimeContext
+}) {
+  const scorers = await getScorersFromSystem({
+    mastra,
+    runtimeContext
+  });
+  const scorer = scorers[scorerId];
+  if (!scorer) {
+    return null;
+  }
+  return scorer;
+}
+async function getScoresByRunIdHandler({
+  mastra,
+  runId,
+  pagination
+}) {
+  try {
+    const scores = await mastra.getStorage()?.getScoresByRunId?.({
+      runId,
+      pagination
+    }) || [];
+    return scores;
+  } catch (error) {
+    return handleError(error, "Error getting scores by run id");
+  }
+}
+async function getScoresByScorerIdHandler({
+  mastra,
+  scorerId,
+  pagination,
+  entityId,
+  entityType
+}) {
+  try {
+    const scores = await mastra.getStorage()?.getScoresByScorerId?.({
+      scorerId,
+      pagination,
+      entityId,
+      entityType
+    }) || [];
+    return scores;
+  } catch (error) {
+    return handleError(error, "Error getting scores by scorer id");
+  }
+}
+async function getScoresByEntityIdHandler({
+  mastra,
+  entityId,
+  entityType,
+  pagination
+}) {
+  try {
+    let entityIdToUse = entityId;
+    if (entityType === "AGENT") {
+      const agent = mastra.getAgentById(entityId);
+      entityIdToUse = agent.id;
+    } else if (entityType === "WORKFLOW") {
+      const workflow = mastra.getWorkflowById(entityId);
+      entityIdToUse = workflow.id;
+    }
+    const scores = await mastra.getStorage()?.getScoresByEntityId?.({
+      entityId: entityIdToUse,
+      entityType,
+      pagination
+    }) || [];
+    return scores;
+  } catch (error) {
+    return handleError(error, "Error getting scores by entity id");
+  }
+}
+async function saveScoreHandler({ mastra, score }) {
+  try {
+    const scores = await mastra.getStorage()?.saveScore?.(score) || [];
+    return scores;
+  } catch (error) {
+    return handleError(error, "Error saving score");
+  }
+}
+
+export { getScorerHandler, getScorersHandler, getScoresByEntityIdHandler, getScoresByRunIdHandler, getScoresByScorerIdHandler, saveScoreHandler, scores_exports };

package/dist/{chunk-55DOQLP6.js → chunk-WNVFNNWN.js}

@@ -1,5 +1,5 @@
-import { handleError } from './chunk-M5ABIP7D.js';
-import { HTTPException } from './chunk-NYN7KFXL.js';
+import { handleError } from './chunk-LF7P5PLR.js';
+import { HTTPException } from './chunk-LCM566I4.js';
 import { __export } from './chunk-MLKGABMK.js';
 
 // src/server/handlers/vector.ts

package/dist/chunk-Z75RYULP.cjs

@@ -0,0 +1,333 @@
+'use strict';
+
+var chunkCCGRCYWJ_cjs = require('./chunk-CCGRCYWJ.cjs');
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
+var core = require('@mastra/core');
+
+// src/server/handlers/memory.ts
+var memory_exports = {};
+chunk75ZPJI57_cjs.__export(memory_exports, {
+  createThreadHandler: () => createThreadHandler,
+  deleteThreadHandler: () => deleteThreadHandler,
+  getMemoryStatusHandler: () => getMemoryStatusHandler,
+  getMessagesHandler: () => getMessagesHandler,
+  getMessagesPaginatedHandler: () => getMessagesPaginatedHandler,
+  getThreadByIdHandler: () => getThreadByIdHandler,
+  getThreadsHandler: () => getThreadsHandler,
+  getWorkingMemoryHandler: () => getWorkingMemoryHandler,
+  saveMessagesHandler: () => saveMessagesHandler,
+  updateThreadHandler: () => updateThreadHandler,
+  updateWorkingMemoryHandler: () => updateWorkingMemoryHandler
+});
+async function getMemoryFromContext({
+  mastra,
+  agentId,
+  networkId,
+  runtimeContext
+}) {
+  const agent = agentId ? mastra.getAgent(agentId) : null;
+  if (agentId && !agent) {
+    throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
+  }
+  const network = networkId ? mastra.vnext_getNetwork(networkId) : null;
+  if (networkId && !network) {
+    throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Network not found" });
+  }
+  if (agent) {
+    return agent?.getMemory() || mastra.getMemory();
+  }
+  if (network) {
+    return await network?.getMemory({ runtimeContext }) || mastra.getMemory();
+  }
+  return mastra.getMemory();
+}
+async function getMemoryStatusHandler({
+  mastra,
+  agentId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      return { result: false };
+    }
+    return { result: true };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting memory status");
+  }
+}
+async function getThreadsHandler({
+  mastra,
+  agentId,
+  resourceId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    chunkCCGRCYWJ_cjs.validateBody({ resourceId });
+    const threads = await memory.getThreadsByResourceId({ resourceId });
+    return threads;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting threads");
+  }
+}
+async function getThreadByIdHandler({
+  mastra,
+  agentId,
+  threadId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    return thread;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting thread");
+  }
+}
+async function saveMessagesHandler({
+  mastra,
+  agentId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    if (!body?.messages) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Messages are required" });
+    }
+    if (!Array.isArray(body.messages)) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Messages should be an array" });
+    }
+    const processedMessages = body.messages.map((message) => ({
+      ...message,
+      id: memory.generateId(),
+      createdAt: message.createdAt ? new Date(message.createdAt) : /* @__PURE__ */ new Date()
+    }));
+    const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
+    return result;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error saving messages");
+  }
+}
+async function createThreadHandler({
+  mastra,
+  agentId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    chunkCCGRCYWJ_cjs.validateBody({ resourceId: body?.resourceId });
+    const result = await memory.createThread({
+      resourceId: body?.resourceId,
+      title: body?.title,
+      metadata: body?.metadata,
+      threadId: body?.threadId
+    });
+    return result;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error saving thread to memory");
+  }
+}
+async function updateThreadHandler({
+  mastra,
+  agentId,
+  threadId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!body) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Body is required" });
+    }
+    const { title, metadata, resourceId } = body;
+    const updatedAt = /* @__PURE__ */ new Date();
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.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 result;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error updating thread");
+  }
+}
+async function deleteThreadHandler({
+  mastra,
+  agentId,
+  threadId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.deleteThread(threadId);
+    return { result: "Thread deleted" };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error deleting thread");
+  }
+}
+async function getMessagesPaginatedHandler({
+  mastra,
+  threadId,
+  resourceId,
+  selectBy,
+  format
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const storage = mastra.getStorage();
+    if (!storage) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Storage is not initialized" });
+    }
+    const thread = await storage.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    const result = await storage.getMessagesPaginated({ threadId, resourceId, selectBy, format });
+    return result;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting messages");
+  }
+}
+async function getMessagesHandler({
+  mastra,
+  agentId,
+  threadId,
+  limit,
+  networkId,
+  runtimeContext
+}) {
+  if (limit !== void 0 && (!Number.isInteger(limit) || limit <= 0)) {
+    throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Invalid limit: must be a positive integer" });
+  }
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    const result = await memory.query({
+      threadId,
+      ...limit && { selectBy: { last: limit } }
+    });
+    return { messages: result.messages, uiMessages: result.uiMessages };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting messages");
+  }
+}
+async function getWorkingMemoryHandler({
+  mastra,
+  agentId,
+  threadId,
+  resourceId,
+  networkId,
+  runtimeContext,
+  memoryConfig
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    const threadExists = !!thread;
+    const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
+    const workingMemoryTemplate = template?.format === "json" ? { ...template, content: JSON.stringify(core.generateEmptyFromSchema(template.content)) } : template;
+    const workingMemory = await memory.getWorkingMemory({ threadId, resourceId, memoryConfig });
+    const config = memory.getMergedThreadConfig(memoryConfig || {});
+    const source = config.workingMemory?.scope === "resource" && resourceId ? "resource" : "thread";
+    return { workingMemory, source, workingMemoryTemplate, threadExists };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting working memory");
+  }
+}
+async function updateWorkingMemoryHandler({
+  mastra,
+  agentId,
+  threadId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    const { resourceId, memoryConfig, workingMemory } = body;
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.updateWorkingMemory({ threadId, resourceId, workingMemory, memoryConfig });
+    return { success: true };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error updating working memory");
+  }
+}
+
+exports.createThreadHandler = createThreadHandler;
+exports.deleteThreadHandler = deleteThreadHandler;
+exports.getMemoryStatusHandler = getMemoryStatusHandler;
+exports.getMessagesHandler = getMessagesHandler;
+exports.getMessagesPaginatedHandler = getMessagesPaginatedHandler;
+exports.getThreadByIdHandler = getThreadByIdHandler;
+exports.getThreadsHandler = getThreadsHandler;
+exports.getWorkingMemoryHandler = getWorkingMemoryHandler;
+exports.memory_exports = memory_exports;
+exports.saveMessagesHandler = saveMessagesHandler;
+exports.updateThreadHandler = updateThreadHandler;
+exports.updateWorkingMemoryHandler = updateWorkingMemoryHandler;

package/dist/server/handlers/agents.cjs

@@ -1,30 +1,30 @@
 'use strict';
 
-var chunkA3KDUGS7_cjs = require('../../chunk-A3KDUGS7.cjs');
+var chunkLZ3VJXSO_cjs = require('../../chunk-LZ3VJXSO.cjs');
 
 
 
 Object.defineProperty(exports, "generateHandler", {
   enumerable: true,
-  get: function () { return chunkA3KDUGS7_cjs.generateHandler; }
+  get: function () { return chunkLZ3VJXSO_cjs.generateHandler; }
 });
 Object.defineProperty(exports, "getAgentByIdHandler", {
   enumerable: true,
-  get: function () { return chunkA3KDUGS7_cjs.getAgentByIdHandler; }
+  get: function () { return chunkLZ3VJXSO_cjs.getAgentByIdHandler; }
 });
 Object.defineProperty(exports, "getAgentsHandler", {
   enumerable: true,
-  get: function () { return chunkA3KDUGS7_cjs.getAgentsHandler; }
+  get: function () { return chunkLZ3VJXSO_cjs.getAgentsHandler; }
 });
 Object.defineProperty(exports, "getEvalsByAgentIdHandler", {
   enumerable: true,
-  get: function () { return chunkA3KDUGS7_cjs.getEvalsByAgentIdHandler; }
+  get: function () { return chunkLZ3VJXSO_cjs.getEvalsByAgentIdHandler; }
 });
 Object.defineProperty(exports, "getLiveEvalsByAgentIdHandler", {
   enumerable: true,
-  get: function () { return chunkA3KDUGS7_cjs.getLiveEvalsByAgentIdHandler; }
+  get: function () { return chunkLZ3VJXSO_cjs.getLiveEvalsByAgentIdHandler; }
 });
 Object.defineProperty(exports, "streamGenerateHandler", {
   enumerable: true,
-  get: function () { return chunkA3KDUGS7_cjs.streamGenerateHandler; }
+  get: function () { return chunkLZ3VJXSO_cjs.streamGenerateHandler; }
 });

package/dist/server/handlers/agents.js

@@ -1 +1 @@
-export { generateHandler, getAgentByIdHandler, getAgentsHandler, getEvalsByAgentIdHandler, getLiveEvalsByAgentIdHandler, streamGenerateHandler } from '../../chunk-J3PKLB3A.js';
+export { generateHandler, getAgentByIdHandler, getAgentsHandler, getEvalsByAgentIdHandler, getLiveEvalsByAgentIdHandler, streamGenerateHandler } from '../../chunk-BK4XT6EG.js';

package/dist/server/handlers/error.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunk64U3UDTH_cjs = require('../../chunk-64U3UDTH.cjs');
+var chunkPZQDCRPV_cjs = require('../../chunk-PZQDCRPV.cjs');
 
 
 
 Object.defineProperty(exports, "handleError", {
   enumerable: true,
-  get: function () { return chunk64U3UDTH_cjs.handleError; }
+  get: function () { return chunkPZQDCRPV_cjs.handleError; }
 });

package/dist/server/handlers/error.js

@@ -1 +1 @@
-export { handleError } from '../../chunk-M5ABIP7D.js';
+export { handleError } from '../../chunk-LF7P5PLR.js';