@dexto/server 1.3.0 → 1.5.0

package/dist/hono/routes/llm.js

@@ -1,15 +1,19 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { DextoRuntimeError, ErrorScope, ErrorType } from "@dexto/core";
 import {
   LLM_REGISTRY,
   LLM_PROVIDERS,
-  LLM_ROUTERS,
   SUPPORTED_FILE_TYPES,
-  getSupportedRoutersForProvider,
   supportsBaseURL,
-  isRouterSupportedForModel,
   LLMUpdatesSchema
 } from "@dexto/core";
-import { getProviderKeyStatus, saveProviderApiKey } from "@dexto/agent-management";
+import {
+  getProviderKeyStatus,
+  loadCustomModels,
+  saveCustomModel,
+  deleteCustomModel,
+  CustomModelSchema
+} from "@dexto/agent-management";
 import {
   ProviderCatalogSchema,
   ModelFlatSchema,
@@ -25,17 +29,12 @@ const CatalogQuerySchema = z.object({
   hasKey: z.union([z.literal("true"), z.literal("false"), z.literal("1"), z.literal("0")]).optional().transform(
     (raw) => raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : void 0
   ).describe("Filter by API key presence (true or false)"),
-  router: z.enum(LLM_ROUTERS).optional().describe("Filter by router type (vercel or in-built)"),
   fileType: z.enum(SUPPORTED_FILE_TYPES).optional().describe("Filter by supported file type (audio, pdf, or image)"),
   defaultOnly: z.union([z.literal("true"), z.literal("false"), z.literal("1"), z.literal("0")]).optional().transform(
     (raw) => raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : void 0
   ).describe("Include only default models (true or false)"),
   mode: z.enum(["grouped", "flat"]).default("grouped").describe("Response format mode (grouped by provider or flat list)")
 }).describe("Query parameters for filtering and formatting the LLM catalog");
-const SaveKeySchema = z.object({
-  provider: z.enum(LLM_PROVIDERS).describe("LLM provider identifier (e.g., openai, anthropic)"),
-  apiKey: z.string().min(1, "API key is required").describe("API key for the provider (writeOnly - never returned in responses)").openapi({ writeOnly: true })
-}).describe("Request body for saving a provider API key");
 const SwitchLLMBodySchema = LLMUpdatesSchema.and(
   z.object({
     sessionId: z.string().optional().describe("Session identifier for session-specific LLM configuration")
@@ -57,8 +56,7 @@ function createLlmRouter(getAgent) {
           "application/json": {
             schema: z.object({
               config: LLMConfigResponseSchema.partial({
-                maxIterations: true,
-                router: true
+                maxIterations: true
               }).extend({
                 displayName: z.string().optional().describe("Human-readable model display name")
               })
@@ -99,28 +97,6 @@ function createLlmRouter(getAgent) {
       }
     }
   });
-  const saveKeyRoute = createRoute({
-    method: "post",
-    path: "/llm/key",
-    summary: "Save Provider API Key",
-    description: "Stores an API key for a provider in .env and makes it available immediately",
-    tags: ["llm"],
-    request: { body: { content: { "application/json": { schema: SaveKeySchema } } } },
-    responses: {
-      200: {
-        description: "API key saved",
-        content: {
-          "application/json": {
-            schema: z.object({
-              ok: z.literal(true).describe("Operation success indicator"),
-              provider: z.enum(LLM_PROVIDERS).describe("Provider for which the key was saved"),
-              envVar: z.string().describe("Environment variable name where key was stored")
-            }).strict().describe("API key save response")
-          }
-        }
-      }
-    }
-  });
   const switchRoute = createRoute({
     method: "post",
     path: "/llm/switch",
@@ -152,8 +128,86 @@ function createLlmRouter(getAgent) {
       }
     }
   });
-  return app.openapi(currentRoute, (ctx) => {
-    const agent = getAgent();
+  const listCustomModelsRoute = createRoute({
+    method: "get",
+    path: "/llm/custom-models",
+    summary: "List Custom Models",
+    description: "Returns all saved custom openai-compatible model configurations",
+    tags: ["llm"],
+    responses: {
+      200: {
+        description: "List of custom models",
+        content: {
+          "application/json": {
+            schema: z.object({
+              models: z.array(CustomModelSchema).describe("List of custom models")
+            })
+          }
+        }
+      }
+    }
+  });
+  const createCustomModelRoute = createRoute({
+    method: "post",
+    path: "/llm/custom-models",
+    summary: "Create Custom Model",
+    description: "Saves a new custom openai-compatible model configuration",
+    tags: ["llm"],
+    request: {
+      body: { content: { "application/json": { schema: CustomModelSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Custom model saved",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Success indicator"),
+              model: CustomModelSchema
+            })
+          }
+        }
+      }
+    }
+  });
+  const deleteCustomModelRoute = createRoute({
+    method: "delete",
+    path: "/llm/custom-models/{name}",
+    summary: "Delete Custom Model",
+    description: "Deletes a custom model by name",
+    tags: ["llm"],
+    request: {
+      params: z.object({
+        name: z.string().min(1).describe("Model name to delete")
+      })
+    },
+    responses: {
+      200: {
+        description: "Custom model deleted",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(true).describe("Success indicator"),
+              deleted: z.string().describe("Name of the deleted model")
+            })
+          }
+        }
+      },
+      404: {
+        description: "Custom model not found",
+        content: {
+          "application/json": {
+            schema: z.object({
+              ok: z.literal(false).describe("Failure indicator"),
+              error: z.string().describe("Error message")
+            })
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(currentRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
     const currentConfig = sessionId ? agent.getEffectiveConfig(sessionId).llm : agent.getCurrentLLMConfig();
     let displayName;
@@ -162,6 +216,13 @@ function createLlmRouter(getAgent) {
         (m) => m.name.toLowerCase() === String(currentConfig.model).toLowerCase()
       );
       displayName = model?.displayName || void 0;
+      if (!displayName) {
+        const customModels = await loadCustomModels();
+        const customModel = customModels.find(
+          (cm) => cm.name.toLowerCase() === String(currentConfig.model).toLowerCase()
+        );
+        displayName = customModel?.displayName || void 0;
+      }
     } catch {
     }
     const { apiKey, ...configWithoutKey } = currentConfig;
@@ -183,7 +244,6 @@ function createLlmRouter(getAgent) {
         name: displayName,
         hasApiKey: keyStatus.hasApiKey,
         primaryEnvVar: keyStatus.envVar,
-        supportedRouters: getSupportedRoutersForProvider(provider),
         supportsBaseURL: supportsBaseURL(provider),
         models: info.models,
         supportedFileTypes: info.supportedFileTypes
@@ -213,23 +273,6 @@ function createLlmRouter(getAgent) {
       }
       filtered = byKey;
     }
-    if (queryParams.router) {
-      const byRouter = {};
-      for (const [id, catalog] of Object.entries(filtered)) {
-        if (!catalog.supportedRouters.includes(queryParams.router)) continue;
-        const models = catalog.models.filter(
-          (model) => isRouterSupportedForModel(
-            id,
-            model.name,
-            queryParams.router
-          )
-        );
-        if (models.length > 0) {
-          byRouter[id] = { ...catalog, models };
-        }
-      }
-      filtered = byRouter;
-    }
     if (queryParams.fileType) {
       const byFileType = {};
       for (const [id, catalog] of Object.entries(filtered)) {
@@ -263,12 +306,8 @@ function createLlmRouter(getAgent) {
       return ctx.json({ models: flat });
     }
     return ctx.json({ providers: filtered });
-  }).openapi(saveKeyRoute, async (ctx) => {
-    const { provider, apiKey } = ctx.req.valid("json");
-    const meta = await saveProviderApiKey(provider, apiKey, process.cwd());
-    return ctx.json({ ok: true, provider, envVar: meta.envVar });
   }).openapi(switchRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const raw = ctx.req.valid("json");
     const { sessionId, ...llmUpdates } = raw;
     const config = await agent.switchLLM(llmUpdates, sessionId);
@@ -280,6 +319,27 @@ function createLlmRouter(getAgent) {
       },
       sessionId
     });
+  }).openapi(listCustomModelsRoute, async (ctx) => {
+    const models = await loadCustomModels();
+    return ctx.json({ models });
+  }).openapi(createCustomModelRoute, async (ctx) => {
+    const model = ctx.req.valid("json");
+    await saveCustomModel(model);
+    return ctx.json({ ok: true, model });
+  }).openapi(deleteCustomModelRoute, async (ctx) => {
+    const { name: encodedName } = ctx.req.valid("param");
+    const name = decodeURIComponent(encodedName);
+    const deleted = await deleteCustomModel(name);
+    if (!deleted) {
+      throw new DextoRuntimeError(
+        "custom_model_not_found",
+        ErrorScope.LLM,
+        ErrorType.NOT_FOUND,
+        `Custom model '${name}' not found`,
+        { modelName: name }
+      );
+    }
+    return ctx.json({ ok: true, deleted: name }, 200);
   });
 }
 export {

package/dist/hono/routes/mcp.cjs

@@ -40,7 +40,7 @@ const ServerStatusResponseSchema = import_zod_openapi.z.object({
 const ServerInfoSchema = import_zod_openapi.z.object({
   id: import_zod_openapi.z.string().describe("Server identifier"),
   name: import_zod_openapi.z.string().describe("Server name"),
-  status: import_zod_openapi.z.enum(["connected", "error", "disconnected"]).describe("Server status")
+  status: import_zod_openapi.z.enum(import_core.MCP_CONNECTION_STATUSES).describe("Server status")
 }).strict().describe("MCP server information");
 const ServersListResponseSchema = import_zod_openapi.z.object({
   servers: import_zod_openapi.z.array(ServerInfoSchema).describe("Array of server information")
@@ -228,10 +228,13 @@ function createMcpRouter(getAgent) {
     }
   });
   return app.openapi(addServerRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { name, config, persistToAgent } = ctx.req.valid("json");
-    await agent.connectMcpServer(name, config);
-    import_core.logger.info(`Successfully connected to new server '${name}' via API request.`);
+    await agent.addMcpServer(name, config);
+    const isConnected = config.enabled !== false;
+    import_core.logger.info(
+      isConnected ? `Successfully connected to new server '${name}' via API request.` : `Registered server '${name}' (disabled) via API request.`
+    );
     if (persistToAgent === true) {
       try {
         const currentConfig = agent.getEffectiveConfig();
@@ -262,9 +265,10 @@ function createMcpRouter(getAgent) {
         );
       }
     }
-    return ctx.json({ status: "connected", name }, 200);
+    const status = isConnected ? "connected" : "registered";
+    return ctx.json({ status, name }, 200);
   }).openapi(listServersRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const clientsMap = agent.getMcpClients();
     const failedConnections = agent.getMcpFailedConnections();
     const servers = [];
@@ -276,7 +280,7 @@ function createMcpRouter(getAgent) {
     }
     return ctx.json({ servers });
   }).openapi(toolsRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
@@ -291,7 +295,7 @@ function createMcpRouter(getAgent) {
     }));
     return ctx.json({ tools });
   }).openapi(deleteServerRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const clientExists = agent.getMcpClients().has(serverId) || agent.getMcpFailedConnections()[serverId];
     if (!clientExists) {
@@ -300,7 +304,7 @@ function createMcpRouter(getAgent) {
     await agent.removeMcpServer(serverId);
     return ctx.json({ status: "disconnected", id: serverId });
   }).openapi(restartServerRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     import_core.logger.info(`Received request to POST /api/mcp/servers/${serverId}/restart`);
     const clientExists = agent.getMcpClients().has(serverId);
@@ -311,7 +315,7 @@ function createMcpRouter(getAgent) {
     await agent.restartMcpServer(serverId);
     return ctx.json({ status: "restarted", id: serverId });
   }).openapi(execToolRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId, toolName } = ctx.req.valid("param");
     const body = ctx.req.valid("json");
     const client = agent.getMcpClients().get(serverId);
@@ -330,7 +334,7 @@ function createMcpRouter(getAgent) {
       return ctx.json({ success: false, error: errorMessage }, 200);
     }
   }).openapi(listResourcesRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
@@ -339,7 +343,7 @@ function createMcpRouter(getAgent) {
     const resources = await agent.listResourcesForServer(serverId);
     return ctx.json({ success: true, resources });
   }).openapi(getResourceContentRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId, resourceId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {

package/dist/hono/routes/mcp.d.ts

@@ -1,6 +1,6 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
-export declare function createMcpRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { GetAgentFn } from '../index.js';
+export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/mcp/servers": {
         $post: {
             input: {
@@ -9,6 +9,7 @@ export declare function createMcpRouter(getAgent: () => DextoAgent): OpenAPIHono
                         type: "stdio";
                         command: string;
                         timeout?: number | undefined;
+                        enabled?: boolean | undefined;
                         args?: string[] | undefined;
                         env?: Record<string, string> | undefined;
                         connectionMode?: "strict" | "lenient" | undefined;
@@ -16,12 +17,14 @@ export declare function createMcpRouter(getAgent: () => DextoAgent): OpenAPIHono
                         type: "sse";
                         url: string;
                         timeout?: number | undefined;
+                        enabled?: boolean | undefined;
                         connectionMode?: "strict" | "lenient" | undefined;
                         headers?: Record<string, string> | undefined;
                     } | {
                         type: "http";
                         url: string;
                         timeout?: number | undefined;
+                        enabled?: boolean | undefined;
                         connectionMode?: "strict" | "lenient" | undefined;
                         headers?: Record<string, string> | undefined;
                     };
@@ -200,10 +203,10 @@ export declare function createMcpRouter(getAgent: () => DextoAgent): OpenAPIHono
                     source: "mcp" | "internal";
                     description?: string | undefined;
                     mimeType?: string | undefined;
-                    name?: string | undefined;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | undefined;
+                    name?: string | undefined;
                     serverName?: string | undefined;
                     size?: number | undefined;
                     lastModified?: string | undefined;

package/dist/hono/routes/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA0I9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4SzD"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAIhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAuI9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkTnD"}

package/dist/hono/routes/mcp.js

@@ -1,5 +1,5 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { logger, McpServerConfigSchema } from "@dexto/core";
+import { logger, McpServerConfigSchema, MCP_CONNECTION_STATUSES } from "@dexto/core";
 import { updateAgentConfigFile } from "@dexto/agent-management";
 import { ResourceSchema } from "../schemas/responses.js";
 const McpServerRequestSchema = z.object({
@@ -17,7 +17,7 @@ const ServerStatusResponseSchema = z.object({
 const ServerInfoSchema = z.object({
   id: z.string().describe("Server identifier"),
   name: z.string().describe("Server name"),
-  status: z.enum(["connected", "error", "disconnected"]).describe("Server status")
+  status: z.enum(MCP_CONNECTION_STATUSES).describe("Server status")
 }).strict().describe("MCP server information");
 const ServersListResponseSchema = z.object({
   servers: z.array(ServerInfoSchema).describe("Array of server information")
@@ -205,10 +205,13 @@ function createMcpRouter(getAgent) {
     }
   });
   return app.openapi(addServerRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { name, config, persistToAgent } = ctx.req.valid("json");
-    await agent.connectMcpServer(name, config);
-    logger.info(`Successfully connected to new server '${name}' via API request.`);
+    await agent.addMcpServer(name, config);
+    const isConnected = config.enabled !== false;
+    logger.info(
+      isConnected ? `Successfully connected to new server '${name}' via API request.` : `Registered server '${name}' (disabled) via API request.`
+    );
     if (persistToAgent === true) {
       try {
         const currentConfig = agent.getEffectiveConfig();
@@ -239,9 +242,10 @@ function createMcpRouter(getAgent) {
         );
       }
     }
-    return ctx.json({ status: "connected", name }, 200);
+    const status = isConnected ? "connected" : "registered";
+    return ctx.json({ status, name }, 200);
   }).openapi(listServersRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const clientsMap = agent.getMcpClients();
     const failedConnections = agent.getMcpFailedConnections();
     const servers = [];
@@ -253,7 +257,7 @@ function createMcpRouter(getAgent) {
     }
     return ctx.json({ servers });
   }).openapi(toolsRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
@@ -268,7 +272,7 @@ function createMcpRouter(getAgent) {
     }));
     return ctx.json({ tools });
   }).openapi(deleteServerRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const clientExists = agent.getMcpClients().has(serverId) || agent.getMcpFailedConnections()[serverId];
     if (!clientExists) {
@@ -277,7 +281,7 @@ function createMcpRouter(getAgent) {
     await agent.removeMcpServer(serverId);
     return ctx.json({ status: "disconnected", id: serverId });
   }).openapi(restartServerRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     logger.info(`Received request to POST /api/mcp/servers/${serverId}/restart`);
     const clientExists = agent.getMcpClients().has(serverId);
@@ -288,7 +292,7 @@ function createMcpRouter(getAgent) {
     await agent.restartMcpServer(serverId);
     return ctx.json({ status: "restarted", id: serverId });
   }).openapi(execToolRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId, toolName } = ctx.req.valid("param");
     const body = ctx.req.valid("json");
     const client = agent.getMcpClients().get(serverId);
@@ -307,7 +311,7 @@ function createMcpRouter(getAgent) {
       return ctx.json({ success: false, error: errorMessage }, 200);
     }
   }).openapi(listResourcesRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {
@@ -316,7 +320,7 @@ function createMcpRouter(getAgent) {
     const resources = await agent.listResourcesForServer(serverId);
     return ctx.json({ success: true, resources });
   }).openapi(getResourceContentRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { serverId, resourceId } = ctx.req.valid("param");
     const client = agent.getMcpClients().get(serverId);
     if (!client) {

package/dist/hono/routes/memory.cjs

@@ -150,7 +150,7 @@ function createMemoryRouter(getAgent) {
     if (input.metadata !== void 0) {
       createInput.metadata = input.metadata;
     }
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.create(createInput);
     return ctx.json({ ok: true, memory }, 201);
   }).openapi(listRoute, async (ctx) => {
@@ -161,12 +161,12 @@ function createMemoryRouter(getAgent) {
     if (query.pinned !== void 0) options.pinned = query.pinned;
     if (query.limit !== void 0) options.limit = query.limit;
     if (query.offset !== void 0) options.offset = query.offset;
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memories = await agent.memoryManager.list(options);
     return ctx.json({ ok: true, memories });
   }).openapi(getRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.get(id);
     return ctx.json({ ok: true, memory });
   }).openapi(updateRoute, async (ctx) => {
@@ -176,12 +176,12 @@ function createMemoryRouter(getAgent) {
     if (updatesRaw.content !== void 0) updates.content = updatesRaw.content;
     if (updatesRaw.metadata !== void 0) updates.metadata = updatesRaw.metadata;
     if (updatesRaw.tags !== void 0) updates.tags = updatesRaw.tags;
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.update(id, updates);
     return ctx.json({ ok: true, memory });
   }).openapi(deleteRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     await agent.memoryManager.delete(id);
     return ctx.json({ ok: true, message: "Memory deleted successfully" });
   });

package/dist/hono/routes/memory.d.ts

@@ -1,6 +1,8 @@
 import { OpenAPIHono, z } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
-export declare function createMemoryRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/memory": {
         $post: {
             input: {
@@ -99,11 +101,11 @@ export declare function createMemoryRouter(getAgent: () => DextoAgent): OpenAPIH
                 };
             } & {
                 json: {
+                    content?: string | undefined;
                     metadata?: z.objectInputType<{
                         source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
                         pinned: z.ZodOptional<z.ZodBoolean>;
                     }, z.ZodTypeAny, "passthrough"> | undefined;
-                    content?: string | undefined;
                     tags?: string[] | undefined;
                 };
             };
@@ -143,4 +145,5 @@ export declare function createMemoryRouter(getAgent: () => DextoAgent): OpenAPIH
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=memory.d.ts.map

package/dist/hono/routes/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAe,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA6D9C,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwK5D"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAe,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA2DrE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwKtD"}

package/dist/hono/routes/memory.js

@@ -127,7 +127,7 @@ function createMemoryRouter(getAgent) {
     if (input.metadata !== void 0) {
       createInput.metadata = input.metadata;
     }
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.create(createInput);
     return ctx.json({ ok: true, memory }, 201);
   }).openapi(listRoute, async (ctx) => {
@@ -138,12 +138,12 @@ function createMemoryRouter(getAgent) {
     if (query.pinned !== void 0) options.pinned = query.pinned;
     if (query.limit !== void 0) options.limit = query.limit;
     if (query.offset !== void 0) options.offset = query.offset;
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memories = await agent.memoryManager.list(options);
     return ctx.json({ ok: true, memories });
   }).openapi(getRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.get(id);
     return ctx.json({ ok: true, memory });
   }).openapi(updateRoute, async (ctx) => {
@@ -153,12 +153,12 @@ function createMemoryRouter(getAgent) {
     if (updatesRaw.content !== void 0) updates.content = updatesRaw.content;
     if (updatesRaw.metadata !== void 0) updates.metadata = updatesRaw.metadata;
     if (updatesRaw.tags !== void 0) updates.tags = updatesRaw.tags;
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const memory = await agent.memoryManager.update(id, updates);
     return ctx.json({ ok: true, memory });
   }).openapi(deleteRoute, async (ctx) => {
     const { id } = ctx.req.valid("param");
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     await agent.memoryManager.delete(id);
     return ctx.json({ ok: true, message: "Memory deleted successfully" });
   });