@dexto/server 1.3.0 → 1.5.0

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

@@ -23,6 +23,7 @@ __export(llm_exports, {
 module.exports = __toCommonJS(llm_exports);
 var import_zod_openapi = require("@hono/zod-openapi");
 var import_core = require("@dexto/core");
+var import_core2 = require("@dexto/core");
 var import_agent_management = require("@dexto/agent-management");
 var import_responses = require("../schemas/responses.js");
 const CurrentQuerySchema = import_zod_openapi.z.object({
@@ -35,18 +36,13 @@ const CatalogQuerySchema = import_zod_openapi.z.object({
   hasKey: import_zod_openapi.z.union([import_zod_openapi.z.literal("true"), import_zod_openapi.z.literal("false"), import_zod_openapi.z.literal("1"), import_zod_openapi.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: import_zod_openapi.z.enum(import_core.LLM_ROUTERS).optional().describe("Filter by router type (vercel or in-built)"),
-  fileType: import_zod_openapi.z.enum(import_core.SUPPORTED_FILE_TYPES).optional().describe("Filter by supported file type (audio, pdf, or image)"),
+  fileType: import_zod_openapi.z.enum(import_core2.SUPPORTED_FILE_TYPES).optional().describe("Filter by supported file type (audio, pdf, or image)"),
   defaultOnly: import_zod_openapi.z.union([import_zod_openapi.z.literal("true"), import_zod_openapi.z.literal("false"), import_zod_openapi.z.literal("1"), import_zod_openapi.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: 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_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");
-const SwitchLLMBodySchema = import_core.LLMUpdatesSchema.and(
+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")
   })
@@ -67,8 +63,7 @@ function createLlmRouter(getAgent) {
           "application/json": {
             schema: import_zod_openapi.z.object({
               config: import_responses.LLMConfigResponseSchema.partial({
-                maxIterations: true,
-                router: true
+                maxIterations: true
               }).extend({
                 displayName: import_zod_openapi.z.string().optional().describe("Human-readable model display name")
               })
@@ -92,7 +87,7 @@ function createLlmRouter(getAgent) {
           "application/json": {
             schema: import_zod_openapi.z.union([
               import_zod_openapi.z.object({
-                providers: import_zod_openapi.z.record(import_zod_openapi.z.enum(import_core.LLM_PROVIDERS), import_responses.ProviderCatalogSchema).describe(
+                providers: import_zod_openapi.z.record(import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS), import_responses.ProviderCatalogSchema).describe(
                   "Providers grouped by ID with their models and capabilities"
                 )
               }).strict().describe("Grouped catalog response (mode=grouped)"),
@@ -109,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_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")
-          }
-        }
-      }
-    }
-  });
   const switchRoute = (0, import_zod_openapi.createRoute)({
     method: "post",
     path: "/llm/switch",
@@ -162,16 +135,101 @@ function createLlmRouter(getAgent) {
       }
     }
   });
-  return app.openapi(currentRoute, (ctx) => {
-    const agent = getAgent();
+  const listCustomModelsRoute = (0, import_zod_openapi.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: import_zod_openapi.z.object({
+              models: import_zod_openapi.z.array(import_agent_management.CustomModelSchema).describe("List of custom models")
+            })
+          }
+        }
+      }
+    }
+  });
+  const createCustomModelRoute = (0, import_zod_openapi.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: import_agent_management.CustomModelSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Custom model saved",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
+              model: import_agent_management.CustomModelSchema
+            })
+          }
+        }
+      }
+    }
+  });
+  const deleteCustomModelRoute = (0, import_zod_openapi.createRoute)({
+    method: "delete",
+    path: "/llm/custom-models/{name}",
+    summary: "Delete Custom Model",
+    description: "Deletes a custom model by name",
+    tags: ["llm"],
+    request: {
+      params: import_zod_openapi.z.object({
+        name: import_zod_openapi.z.string().min(1).describe("Model name to delete")
+      })
+    },
+    responses: {
+      200: {
+        description: "Custom model deleted",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              ok: import_zod_openapi.z.literal(true).describe("Success indicator"),
+              deleted: import_zod_openapi.z.string().describe("Name of the deleted model")
+            })
+          }
+        }
+      },
+      404: {
+        description: "Custom model not found",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              ok: import_zod_openapi.z.literal(false).describe("Failure indicator"),
+              error: import_zod_openapi.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;
     try {
-      const model = import_core.LLM_REGISTRY[currentConfig.provider]?.models.find(
+      const model = import_core2.LLM_REGISTRY[currentConfig.provider]?.models.find(
         (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;
@@ -185,16 +243,15 @@ function createLlmRouter(getAgent) {
   }).openapi(catalogRoute, (ctx) => {
     const queryParams = ctx.req.valid("query");
     const providers = {};
-    for (const provider of import_core.LLM_PROVIDERS) {
-      const info = import_core.LLM_REGISTRY[provider];
+    for (const provider of import_core2.LLM_PROVIDERS) {
+      const info = import_core2.LLM_REGISTRY[provider];
       const displayName = provider.charAt(0).toUpperCase() + provider.slice(1);
       const keyStatus = (0, import_agent_management.getProviderKeyStatus)(provider);
       providers[provider] = {
         name: displayName,
         hasApiKey: keyStatus.hasApiKey,
         primaryEnvVar: keyStatus.envVar,
-        supportedRouters: (0, import_core.getSupportedRoutersForProvider)(provider),
-        supportsBaseURL: (0, import_core.supportsBaseURL)(provider),
+        supportsBaseURL: (0, import_core2.supportsBaseURL)(provider),
         models: info.models,
         supportedFileTypes: info.supportedFileTypes
       };
@@ -203,7 +260,7 @@ function createLlmRouter(getAgent) {
     if (queryParams.provider && queryParams.provider.length > 0) {
       const allowed = new Set(
         queryParams.provider.filter(
-          (p) => import_core.LLM_PROVIDERS.includes(p)
+          (p) => import_core2.LLM_PROVIDERS.includes(p)
         )
       );
       const filteredByProvider = {};
@@ -223,23 +280,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) => (0, import_core.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)) {
@@ -273,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);
@@ -290,6 +326,27 @@ function createLlmRouter(getAgent) {
       },
       sessionId
     });
+  }).openapi(listCustomModelsRoute, async (ctx) => {
+    const models = await (0, import_agent_management.loadCustomModels)();
+    return ctx.json({ models });
+  }).openapi(createCustomModelRoute, async (ctx) => {
+    const model = ctx.req.valid("json");
+    await (0, import_agent_management.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 (0, import_agent_management.deleteCustomModel)(name);
+    if (!deleted) {
+      throw new import_core.DextoRuntimeError(
+        "custom_model_not_found",
+        import_core.ErrorScope.LLM,
+        import_core.ErrorType.NOT_FOUND,
+        `Custom model '${name}' not found`,
+        { modelName: name }
+      );
+    }
+    return ctx.json({ ok: true, deleted: name }, 200);
   });
 }
 // Annotate the CommonJS export names for ESM import in node: