@dexto/server 1.2.6 → 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

@@ -10,10 +10,9 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             };
             output: {
                 config: {
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
                     model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
                     maxIterations?: number | undefined;
-                    router?: "vercel" | "in-built" | undefined;
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
                     maxOutputTokens?: 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;
@@ -43,18 +41,16 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             output: {
                 providers: {
                     openai?: {
-                        hasApiKey: boolean;
                         name: string;
+                        hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
-                            maxInputTokens: number;
                             name: string;
+                            maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -67,18 +63,16 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         }[];
                     } | undefined;
                     "openai-compatible"?: {
-                        hasApiKey: boolean;
                         name: string;
+                        hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
-                            maxInputTokens: number;
                             name: string;
+                            maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -91,18 +85,16 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         }[];
                     } | undefined;
                     anthropic?: {
-                        hasApiKey: boolean;
                         name: string;
+                        hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
-                            maxInputTokens: number;
                             name: string;
+                            maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -115,18 +107,16 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         }[];
                     } | undefined;
                     google?: {
-                        hasApiKey: boolean;
                         name: string;
+                        hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
-                            maxInputTokens: number;
                             name: string;
+                            maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -139,18 +129,16 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         }[];
                     } | undefined;
                     groq?: {
-                        hasApiKey: boolean;
                         name: string;
+                        hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
-                            maxInputTokens: number;
                             name: string;
+                            maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -163,18 +151,16 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         }[];
                     } | undefined;
                     xai?: {
-                        hasApiKey: boolean;
                         name: string;
+                        hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
-                            maxInputTokens: number;
                             name: string;
+                            maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -187,18 +173,16 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                         }[];
                     } | undefined;
                     cohere?: {
-                        hasApiKey: boolean;
                         name: string;
+                        hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
-                        supportedRouters: ("vercel" | "in-built")[];
                         primaryEnvVar: string;
                         supportsBaseURL: boolean;
                         models: {
-                            maxInputTokens: number;
                             name: string;
+                            maxInputTokens: number;
                             supportedFileTypes: ("image" | "audio" | "pdf")[];
                             default?: boolean | undefined;
-                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
                             displayName?: string | undefined;
                             pricing?: {
                                 inputPerM: number;
@@ -213,12 +197,11 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
                 };
             } | {
                 models: {
+                    name: string;
                     provider: string;
                     maxInputTokens: number;
-                    name: string;
                     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;
@@ -273,10 +255,9 @@ export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono
             };
             output: {
                 config: {
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
                     model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
                     maxIterations: number;
-                    router: "vercel" | "in-built";
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
                     maxOutputTokens?: 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"}