@dexto/server 1.4.0 → 1.5.1

package/dist/hono/routes/discovery.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var discovery_exports = {};
+__export(discovery_exports, {
+  createDiscoveryRouter: () => createDiscoveryRouter
+});
+module.exports = __toCommonJS(discovery_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+const DiscoveredProviderSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.string().describe("Provider type identifier"),
+  category: import_zod_openapi.z.enum(["blob", "database", "compaction", "customTools"]).describe("Provider category"),
+  metadata: import_zod_openapi.z.object({
+    displayName: import_zod_openapi.z.string().optional().describe("Human-readable display name"),
+    description: import_zod_openapi.z.string().optional().describe("Provider description")
+  }).passthrough().optional().describe("Optional metadata about the provider")
+}).describe("Information about a registered provider");
+const InternalToolSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe('Internal tool name identifier (e.g., "search_history", "ask_user")'),
+  description: import_zod_openapi.z.string().describe("Human-readable description of what the tool does")
+}).describe("Information about an internal tool");
+const DiscoveryResponseSchema = import_zod_openapi.z.object({
+  blob: import_zod_openapi.z.array(DiscoveredProviderSchema).describe("Blob storage providers"),
+  database: import_zod_openapi.z.array(DiscoveredProviderSchema).describe("Database providers"),
+  compaction: import_zod_openapi.z.array(DiscoveredProviderSchema).describe("Compaction strategy providers"),
+  customTools: import_zod_openapi.z.array(DiscoveredProviderSchema).describe("Custom tool providers"),
+  internalTools: import_zod_openapi.z.array(InternalToolSchema).describe("Internal tools available for configuration")
+}).describe("Discovery response with providers grouped by category");
+function createDiscoveryRouter() {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const discoveryRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/discovery",
+    summary: "Discover Available Providers and Tools",
+    description: "Returns all registered providers (blob storage, database, compaction, custom tools) and available internal tools. Useful for building UIs that need to display configurable options.",
+    tags: ["discovery"],
+    responses: {
+      200: {
+        description: "Available providers grouped by category",
+        content: { "application/json": { schema: DiscoveryResponseSchema } }
+      }
+    }
+  });
+  return app.openapi(discoveryRoute, async (ctx) => {
+    const providers = (0, import_core.listAllProviders)();
+    return ctx.json(providers);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDiscoveryRouter
+});

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

@@ -0,0 +1,53 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+export declare function createDiscoveryRouter(): OpenAPIHono<import("hono").Env, {
+    "/discovery": {
+        $get: {
+            input: {};
+            output: {
+                internalTools: {
+                    description: string;
+                    name: string;
+                }[];
+                customTools: {
+                    type: string;
+                    category: "customTools" | "compaction" | "blob" | "database";
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        description?: string | undefined;
+                        displayName?: string | undefined;
+                    } | undefined;
+                }[];
+                compaction: {
+                    type: string;
+                    category: "customTools" | "compaction" | "blob" | "database";
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        description?: string | undefined;
+                        displayName?: string | undefined;
+                    } | undefined;
+                }[];
+                blob: {
+                    type: string;
+                    category: "customTools" | "compaction" | "blob" | "database";
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        description?: string | undefined;
+                        displayName?: string | undefined;
+                    } | undefined;
+                }[];
+                database: {
+                    type: string;
+                    category: "customTools" | "compaction" | "blob" | "database";
+                    metadata?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        description?: string | undefined;
+                        displayName?: string | undefined;
+                    } | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=discovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAyChE,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsBpC"}

package/dist/hono/routes/discovery.js

@@ -0,0 +1,44 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { listAllProviders } from "@dexto/core";
+const DiscoveredProviderSchema = z.object({
+  type: z.string().describe("Provider type identifier"),
+  category: z.enum(["blob", "database", "compaction", "customTools"]).describe("Provider category"),
+  metadata: z.object({
+    displayName: z.string().optional().describe("Human-readable display name"),
+    description: z.string().optional().describe("Provider description")
+  }).passthrough().optional().describe("Optional metadata about the provider")
+}).describe("Information about a registered provider");
+const InternalToolSchema = z.object({
+  name: z.string().describe('Internal tool name identifier (e.g., "search_history", "ask_user")'),
+  description: z.string().describe("Human-readable description of what the tool does")
+}).describe("Information about an internal tool");
+const DiscoveryResponseSchema = z.object({
+  blob: z.array(DiscoveredProviderSchema).describe("Blob storage providers"),
+  database: z.array(DiscoveredProviderSchema).describe("Database providers"),
+  compaction: z.array(DiscoveredProviderSchema).describe("Compaction strategy providers"),
+  customTools: z.array(DiscoveredProviderSchema).describe("Custom tool providers"),
+  internalTools: z.array(InternalToolSchema).describe("Internal tools available for configuration")
+}).describe("Discovery response with providers grouped by category");
+function createDiscoveryRouter() {
+  const app = new OpenAPIHono();
+  const discoveryRoute = createRoute({
+    method: "get",
+    path: "/discovery",
+    summary: "Discover Available Providers and Tools",
+    description: "Returns all registered providers (blob storage, database, compaction, custom tools) and available internal tools. Useful for building UIs that need to display configurable options.",
+    tags: ["discovery"],
+    responses: {
+      200: {
+        description: "Available providers grouped by category",
+        content: { "application/json": { schema: DiscoveryResponseSchema } }
+      }
+    }
+  });
+  return app.openapi(discoveryRoute, async (ctx) => {
+    const providers = listAllProviders();
+    return ctx.json(providers);
+  });
+}
+export {
+  createDiscoveryRouter
+};

package/dist/hono/routes/greeting.cjs

@@ -47,8 +47,8 @@ function createGreetingRouter(getAgent) {
       }
     }
   });
-  return app.openapi(greetingRoute, (ctx) => {
-    const agent = getAgent();
+  return app.openapi(greetingRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
     const cfg = agent.getEffectiveConfig(sessionId);
     return ctx.json({ greeting: cfg.greeting });

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

@@ -1,6 +1,6 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
-export declare function createGreetingRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+import type { GetAgentFn } from '../index.js';
+export declare function createGreetingRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/greeting": {
         $get: {
             input: {

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

@@ -1 +1 @@
-{"version":3,"file":"greeting.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/greeting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAW9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;QAmC9D"}
+{"version":3,"file":"greeting.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/greeting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAW9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;QAmCxD"}

package/dist/hono/routes/greeting.js

@@ -24,8 +24,8 @@ function createGreetingRouter(getAgent) {
       }
     }
   });
-  return app.openapi(greetingRoute, (ctx) => {
-    const agent = getAgent();
+  return app.openapi(greetingRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
     const cfg = agent.getEffectiveConfig(sessionId);
     return ctx.json({ greeting: cfg.greeting });

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

@@ -1,10 +1,10 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { DextoAgent } from '@dexto/core';
+import type { GetAgentFn } from '../index.js';
 /**
  * NOTE: If we introduce a transport-agnostic handler layer later, the logic in this module can move
  * into that layer. For now we keep the implementation inline for simplicity.
  */
-export declare function createHealthRouter(_getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+export declare function createHealthRouter(_getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
     "/": {
         $get: {
             input: {};

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

@@ -1 +1 @@
-{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/health.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,UAAU;;;;;;;;;QAiB7D"}
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/health.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,UAAU;;;;;;;;;QAiBvD"}

package/dist/hono/routes/key.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var key_exports = {};
+__export(key_exports, {
+  createKeyRouter: () => createKeyRouter
+});
+module.exports = __toCommonJS(key_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = require("@dexto/core");
+var import_agent_management = require("@dexto/agent-management");
+function maskApiKey(key) {
+  if (!key) return "";
+  if (key.length < 12) {
+    return key.slice(0, 4) + "..." + key.slice(-4);
+  }
+  return key.slice(0, 7) + "..." + key.slice(-4);
+}
+const GetKeyParamsSchema = import_zod_openapi.z.object({
+  provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).describe("LLM provider identifier")
+}).describe("Path parameters for API key operations");
+const SaveKeySchema = import_zod_openapi.z.object({
+  provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).describe("LLM provider identifier (e.g., openai, anthropic)"),
+  apiKey: import_zod_openapi.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");
+function createKeyRouter() {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const getKeyRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/llm/key/{provider}",
+    summary: "Get Provider API Key Status",
+    description: "Retrieves the API key status for a provider. Returns a masked key value (e.g., sk-proj...xyz4) for UI display purposes.",
+    tags: ["llm"],
+    request: { params: GetKeyParamsSchema },
+    responses: {
+      200: {
+        description: "API key status and value",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).describe("Provider identifier"),
+              envVar: import_zod_openapi.z.string().describe("Environment variable name"),
+              hasKey: import_zod_openapi.z.boolean().describe("Whether API key is configured"),
+              keyValue: import_zod_openapi.z.string().optional().describe(
+                "Masked API key value if configured (e.g., sk-proj...xyz4)"
+              )
+            }).strict().describe("API key status response")
+          }
+        }
+      }
+    }
+  });
+  const saveKeyRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+              ok: import_zod_openapi.z.literal(true).describe("Operation success indicator"),
+              provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).describe("Provider for which the key was saved"),
+              envVar: import_zod_openapi.z.string().describe("Environment variable name where key was stored")
+            }).strict().describe("API key save response")
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(getKeyRoute, (ctx) => {
+    const { provider } = ctx.req.valid("param");
+    const keyStatus = (0, import_agent_management.getProviderKeyStatus)(provider);
+    const apiKey = (0, import_agent_management.resolveApiKeyForProvider)(provider);
+    const maskedKey = apiKey ? maskApiKey(apiKey) : void 0;
+    return ctx.json({
+      provider,
+      envVar: keyStatus.envVar,
+      hasKey: keyStatus.hasApiKey,
+      ...maskedKey && { keyValue: maskedKey }
+    });
+  }).openapi(saveKeyRoute, async (ctx) => {
+    const { provider, apiKey } = ctx.req.valid("json");
+    const meta = await (0, import_agent_management.saveProviderApiKey)(provider, apiKey);
+    return ctx.json({ ok: true, provider, envVar: meta.envVar });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createKeyRouter
+});

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

@@ -0,0 +1,48 @@
+/**
+ * API Key Management Routes
+ *
+ * Endpoints for managing LLM provider API keys.
+ *
+ * TODO: For hosted deployments, these endpoints should integrate with a secure
+ * key management service (e.g., AWS Secrets Manager, HashiCorp Vault) rather
+ * than storing keys in local .env files.
+ */
+import { OpenAPIHono } from '@hono/zod-openapi';
+export declare function createKeyRouter(): OpenAPIHono<import("hono").Env, {
+    "/llm/key/:provider": {
+        $get: {
+            input: {
+                param: {
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                };
+            };
+            output: {
+                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                hasKey: boolean;
+                envVar: string;
+                keyValue?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/key": {
+        $post: {
+            input: {
+                json: {
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    apiKey: string;
+                };
+            };
+            output: {
+                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                ok: true;
+                envVar: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/key.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAuChE,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsF9B"}

package/dist/hono/routes/key.js

@@ -0,0 +1,90 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { LLM_PROVIDERS } from "@dexto/core";
+import {
+  getProviderKeyStatus,
+  saveProviderApiKey,
+  resolveApiKeyForProvider
+} from "@dexto/agent-management";
+function maskApiKey(key) {
+  if (!key) return "";
+  if (key.length < 12) {
+    return key.slice(0, 4) + "..." + key.slice(-4);
+  }
+  return key.slice(0, 7) + "..." + key.slice(-4);
+}
+const GetKeyParamsSchema = z.object({
+  provider: z.enum(LLM_PROVIDERS).describe("LLM provider identifier")
+}).describe("Path parameters for API key operations");
+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");
+function createKeyRouter() {
+  const app = new OpenAPIHono();
+  const getKeyRoute = createRoute({
+    method: "get",
+    path: "/llm/key/{provider}",
+    summary: "Get Provider API Key Status",
+    description: "Retrieves the API key status for a provider. Returns a masked key value (e.g., sk-proj...xyz4) for UI display purposes.",
+    tags: ["llm"],
+    request: { params: GetKeyParamsSchema },
+    responses: {
+      200: {
+        description: "API key status and value",
+        content: {
+          "application/json": {
+            schema: z.object({
+              provider: z.enum(LLM_PROVIDERS).describe("Provider identifier"),
+              envVar: z.string().describe("Environment variable name"),
+              hasKey: z.boolean().describe("Whether API key is configured"),
+              keyValue: z.string().optional().describe(
+                "Masked API key value if configured (e.g., sk-proj...xyz4)"
+              )
+            }).strict().describe("API key status response")
+          }
+        }
+      }
+    }
+  });
+  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")
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(getKeyRoute, (ctx) => {
+    const { provider } = ctx.req.valid("param");
+    const keyStatus = getProviderKeyStatus(provider);
+    const apiKey = resolveApiKeyForProvider(provider);
+    const maskedKey = apiKey ? maskApiKey(apiKey) : void 0;
+    return ctx.json({
+      provider,
+      envVar: keyStatus.envVar,
+      hasKey: keyStatus.hasApiKey,
+      ...maskedKey && { keyValue: maskedKey }
+    });
+  }).openapi(saveKeyRoute, async (ctx) => {
+    const { provider, apiKey } = ctx.req.valid("json");
+    const meta = await saveProviderApiKey(provider, apiKey);
+    return ctx.json({ ok: true, provider, envVar: meta.envVar });
+  });
+}
+export {
+  createKeyRouter
+};

package/dist/hono/routes/llm.cjs

@@ -42,10 +42,6 @@ const CatalogQuerySchema = import_zod_openapi.z.object({
   ).describe("Include only default models (true or false)"),
   mode: import_zod_openapi.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 = import_zod_openapi.z.object({
-  provider: import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS).describe("LLM provider identifier (e.g., openai, anthropic)"),
-  apiKey: import_zod_openapi.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 = import_core2.LLMUpdatesSchema.and(
   import_zod_openapi.z.object({
     sessionId: import_zod_openapi.z.string().optional().describe("Session identifier for session-specific LLM configuration")
@@ -108,28 +104,6 @@ function createLlmRouter(getAgent) {
       }
     }
   });
-  const saveKeyRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
-              ok: import_zod_openapi.z.literal(true).describe("Operation success indicator"),
-              provider: import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS).describe("Provider for which the key was saved"),
-              envVar: import_zod_openapi.z.string().describe("Environment variable name where key was stored")
-            }).strict().describe("API key save response")
-          }
-        }
-      }
-    }
-  });
   const switchRoute = (0, import_zod_openapi.createRoute)({
     method: "post",
     path: "/llm/switch",
@@ -239,8 +213,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;
@@ -249,6 +223,13 @@ function createLlmRouter(getAgent) {
         (m) => m.name.toLowerCase() === String(currentConfig.model).toLowerCase()
       );
       displayName = model?.displayName || void 0;
+      if (!displayName) {
+        const customModels = await (0, import_agent_management.loadCustomModels)();
+        const customModel = customModels.find(
+          (cm) => cm.name.toLowerCase() === String(currentConfig.model).toLowerCase()
+        );
+        displayName = customModel?.displayName || void 0;
+      }
     } catch {
     }
     const { apiKey, ...configWithoutKey } = currentConfig;
@@ -332,12 +313,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 (0, import_agent_management.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);
@@ -357,7 +334,8 @@ function createLlmRouter(getAgent) {
     await (0, import_agent_management.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 (0, import_agent_management.deleteCustomModel)(name);
     if (!deleted) {
       throw new import_core.DextoRuntimeError(