@dexto/server 1.3.0 → 1.4.0

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,17 @@ 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)"),
+  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_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 +67,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 +91,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)"),
@@ -123,7 +122,7 @@ function createLlmRouter(getAgent) {
           "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"),
+              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")
           }
@@ -162,13 +161,91 @@ function createLlmRouter(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, (ctx) => {
     const agent = getAgent();
     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;
@@ -185,16 +262,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 +279,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 +299,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)) {
@@ -290,6 +349,26 @@ 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 } = ctx.req.valid("param");
+    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:

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

@@ -12,7 +12,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                 config: {
                     model: string;
                     provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-                    router?: "vercel" | "in-built" | undefined;
                     maxIterations?: number | undefined;
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
@@ -33,7 +32,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             input: {
                 query: {
                     provider?: string | string[] | undefined;
-                    router?: "vercel" | "in-built" | undefined;
                     hasKey?: "0" | "1" | "true" | "false" | undefined;
                     fileType?: "image" | "audio" | "pdf" | undefined;
                     defaultOnly?: "0" | "1" | "true" | "false" | undefined;
@@ -46,7 +44,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         name: string;
                         hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
@@ -54,7 +51,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                             maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -70,7 +66,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         name: string;
                         hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
@@ -78,7 +73,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                             maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -94,7 +88,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         name: string;
                         hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
@@ -102,7 +95,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                             maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -118,7 +110,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         name: string;
                         hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
@@ -126,7 +117,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                             maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -142,7 +132,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         name: string;
                         hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
@@ -150,7 +139,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                             maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -166,7 +154,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         name: string;
                         hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
@@ -174,7 +161,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                             maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -190,7 +176,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         name: string;
                         hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
@@ -198,7 +183,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                             maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -218,7 +202,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                     maxInputTokens: number;
                     supportedFileTypes: ("image" | "audio" | "pdf")[];
                     default?: boolean | undefined;
-                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
                     displayName?: string | undefined;
                     pricing?: {
                         inputPerM: number;
@@ -257,10 +240,9 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
         $post: {
             input: {
                 json: {
-                    apiKey?: string | undefined;
                     model?: string | undefined;
                     provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                    router?: "vercel" | "in-built" | undefined;
+                    apiKey?: string | undefined;
                     maxIterations?: number | undefined;
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
@@ -275,7 +257,6 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                 config: {
                     model: string;
                     provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-                    router: "vercel" | "in-built";
                     maxIterations: number;
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
@@ -290,5 +271,76 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             status: 200;
         };
     };
+} & {
+    "/llm/custom-models": {
+        $get: {
+            input: {};
+            output: {
+                models: {
+                    name: string;
+                    baseURL: string;
+                    displayName?: string | undefined | undefined;
+                    maxInputTokens?: number | undefined | undefined;
+                    maxOutputTokens?: number | undefined | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/custom-models": {
+        $post: {
+            input: {
+                json: {
+                    name: string;
+                    baseURL: string;
+                    displayName?: string | undefined;
+                    maxInputTokens?: number | undefined;
+                    maxOutputTokens?: number | undefined;
+                };
+            };
+            output: {
+                model: {
+                    name: string;
+                    baseURL: string;
+                    displayName?: string | undefined | undefined;
+                    maxInputTokens?: number | undefined | undefined;
+                    maxOutputTokens?: number | undefined | undefined;
+                };
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/custom-models/:name": {
+        $delete: {
+            input: {
+                param: {
+                    name: string;
+                };
+            };
+            output: {
+                ok: true;
+                deleted: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    name: string;
+                };
+            };
+            output: {
+                ok: false;
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
 }, "/">;
 //# 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;AAmG9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyTzD"}
+{"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"}

package/dist/hono/routes/llm.js

@@ -1,15 +1,20 @@
 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,
+  saveProviderApiKey,
+  loadCustomModels,
+  saveCustomModel,
+  deleteCustomModel,
+  CustomModelSchema
+} from "@dexto/agent-management";
 import {
   ProviderCatalogSchema,
   ModelFlatSchema,
@@ -25,7 +30,6 @@ 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
@@ -57,8 +61,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")
               })
@@ -152,6 +155,84 @@ function createLlmRouter(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, (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("query");
@@ -183,7 +264,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 +293,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)) {
@@ -280,6 +343,26 @@ 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 } = ctx.req.valid("param");
+    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")
@@ -230,8 +230,11 @@ function createMcpRouter(getAgent) {
   return app.openapi(addServerRoute, async (ctx) => {
     const agent = getAgent();
     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,7 +265,8 @@ 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 clientsMap = agent.getMcpClients();