@dexto/server 1.4.0 → 1.5.0

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

@@ -1,6 +1,8 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import type { DextoAgent } from '@dexto/core';
-export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+type GetAgentFn = (ctx: Context) => DextoAgent | Promise<DextoAgent>;
+export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/llm/current": {
         $get: {
             input: {
@@ -11,7 +13,7 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             output: {
                 config: {
                     model: string;
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
                     maxIterations?: number | undefined;
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
@@ -194,6 +196,160 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                             } | undefined;
                         }[];
                     } | undefined;
+                    openrouter?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
+                    litellm?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
+                    glama?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
+                    vertex?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
+                    bedrock?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
+                    local?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
+                    ollama?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
                 };
             } | {
                 models: {
@@ -217,31 +373,13 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             status: 200;
         };
     };
-} & {
-    "/llm/key": {
-        $post: {
-            input: {
-                json: {
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-                    apiKey: string;
-                };
-            };
-            output: {
-                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-                ok: true;
-                envVar: string;
-            };
-            outputFormat: "json";
-            status: 200;
-        };
-    };
 } & {
     "/llm/switch": {
         $post: {
             input: {
                 json: {
                     model?: string | undefined;
-                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
                     apiKey?: string | undefined;
                     maxIterations?: number | undefined;
                     baseURL?: string | undefined;
@@ -256,7 +394,7 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             output: {
                 config: {
                     model: string;
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
                     maxIterations: number;
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
@@ -278,7 +416,10 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             output: {
                 models: {
                     name: string;
-                    baseURL: string;
+                    provider: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    apiKey?: string | undefined | undefined;
+                    baseURL?: string | undefined | undefined;
+                    filePath?: string | undefined | undefined;
                     displayName?: string | undefined | undefined;
                     maxInputTokens?: number | undefined | undefined;
                     maxOutputTokens?: number | undefined | undefined;
@@ -294,7 +435,10 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             input: {
                 json: {
                     name: string;
-                    baseURL: string;
+                    provider?: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
+                    apiKey?: string | undefined;
+                    baseURL?: string | undefined;
+                    filePath?: string | undefined;
                     displayName?: string | undefined;
                     maxInputTokens?: number | undefined;
                     maxOutputTokens?: number | undefined;
@@ -303,7 +447,10 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             output: {
                 model: {
                     name: string;
-                    baseURL: string;
+                    provider: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    apiKey?: string | undefined | undefined;
+                    baseURL?: string | undefined | undefined;
+                    filePath?: string | undefined | undefined;
                     displayName?: string | undefined | undefined;
                     maxInputTokens?: number | undefined | undefined;
                     maxOutputTokens?: number | undefined | undefined;
@@ -343,4 +490,5 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
         };
     };
 }, "/">;
+export {};
 //# sourceMappingURL=llm.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/llm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAoG9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2YzD"}
+{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/llm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAkB9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAOpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAgErE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoXnD"}

package/dist/hono/routes/llm.js

@@ -9,7 +9,6 @@ import {
 } from "@dexto/core";
 import {
   getProviderKeyStatus,
-  saveProviderApiKey,
   loadCustomModels,
   saveCustomModel,
   deleteCustomModel,
@@ -36,10 +35,6 @@ const CatalogQuerySchema = z.object({
   ).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")
@@ -102,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",
@@ -233,8 +206,8 @@ function createLlmRouter(getAgent) {
       }
     }
   });
-  return app.openapi(currentRoute, (ctx) => {
-    const agent = getAgent();
+  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;
@@ -243,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;
@@ -326,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);
@@ -351,7 +327,8 @@ function createLlmRouter(getAgent) {
     await saveCustomModel(model);
     return ctx.json({ ok: true, model });
   }).openapi(deleteCustomModelRoute, async (ctx) => {
-    const { name } = ctx.req.valid("param");
+    const { name: encodedName } = ctx.req.valid("param");
+    const name = decodeURIComponent(encodedName);
     const deleted = await deleteCustomModel(name);
     if (!deleted) {
       throw new DextoRuntimeError(

package/dist/hono/routes/mcp.cjs

@@ -228,7 +228,7 @@ 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.addMcpServer(name, config);
     const isConnected = config.enabled !== false;
@@ -268,7 +268,7 @@ function createMcpRouter(getAgent) {
     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 = [];
@@ -280,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) {
@@ -295,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) {
@@ -304,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);
@@ -315,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);
@@ -334,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) {
@@ -343,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: {

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkTzD"}
+{"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

@@ -205,7 +205,7 @@ 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.addMcpServer(name, config);
     const isConnected = config.enabled !== false;
@@ -245,7 +245,7 @@ function createMcpRouter(getAgent) {
     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 = [];
@@ -257,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) {
@@ -272,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) {
@@ -281,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);
@@ -292,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);
@@ -311,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) {
@@ -320,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: {
@@ -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" });
   });

package/dist/hono/routes/messages.cjs

@@ -184,7 +184,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     }
   });
   return app.openapi(messageRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message");
     const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
@@ -195,7 +195,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     });
     return ctx.json({ accepted: true, sessionId }, 202);
   }).openapi(messageSyncRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received message via POST /api/message-sync");
     const { content, sessionId } = ctx.req.valid("json");
     agent.logger.info(`Message for session: ${sessionId}`);
@@ -210,13 +210,13 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
       provider: llmConfig.provider
     });
   }).openapi(resetRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     agent.logger.info("Received request via POST /api/reset");
     const { sessionId } = ctx.req.valid("json");
     await agent.resetConversation(sessionId);
     return ctx.json({ status: "reset initiated", sessionId });
   }).openapi(messageStreamRoute, async (ctx) => {
-    const agent = getAgent();
+    const agent = await getAgent(ctx);
     const { content, sessionId } = ctx.req.valid("json");
     const isBusy = await agent.isSessionBusy(sessionId);
     if (isBusy) {