@dexto/server 1.5.6 → 1.5.8

package/dist/hono/routes/dexto-auth.js

@@ -0,0 +1,52 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import {
+  isDextoAuthEnabled,
+  isDextoAuthenticated,
+  canUseDextoProvider
+} from "@dexto/agent-management";
+function createDextoAuthRouter(_getAgent) {
+  const app = new OpenAPIHono();
+  const statusRoute = createRoute({
+    method: "get",
+    path: "/dexto-auth/status",
+    summary: "Dexto Auth Status",
+    description: "Returns dexto authentication status. Used by Web UI to check if user can use dexto features.",
+    tags: ["auth"],
+    responses: {
+      200: {
+        description: "Dexto auth status",
+        content: {
+          "application/json": {
+            schema: z.object({
+              enabled: z.boolean().describe("Whether dexto auth feature is enabled"),
+              authenticated: z.boolean().describe("Whether user is authenticated with dexto"),
+              canUse: z.boolean().describe(
+                "Whether user can use dexto (authenticated AND has API key)"
+              )
+            })
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(statusRoute, async (c) => {
+    const enabled = isDextoAuthEnabled();
+    if (!enabled) {
+      return c.json({
+        enabled: false,
+        authenticated: false,
+        canUse: false
+      });
+    }
+    const authenticated = await isDextoAuthenticated();
+    const canUse = await canUseDextoProvider();
+    return c.json({
+      enabled,
+      authenticated,
+      canUse
+    });
+  });
+}
+export {
+  createDextoAuthRouter
+};

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

@@ -13,11 +13,11 @@ export declare function createKeyRouter(): OpenAPIHono<import("hono").Env, {
         $get: {
             input: {
                 param: {
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
                 };
             };
             output: {
-                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
                 hasKey: boolean;
                 envVar: string;
                 keyValue?: string | undefined;
@@ -31,12 +31,12 @@ export declare function createKeyRouter(): OpenAPIHono<import("hono").Env, {
         $post: {
             input: {
                 json: {
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
                     apiKey: string;
                 };
             };
             output: {
-                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
                 ok: true;
                 envVar: string;
             };

package/dist/hono/routes/llm.cjs

@@ -28,11 +28,17 @@ var import_agent_management = require("@dexto/agent-management");
 var import_responses = require("../schemas/responses.js");
 const CurrentQuerySchema = import_zod_openapi.z.object({
   sessionId: import_zod_openapi.z.string().optional().describe("Session identifier to retrieve session-specific LLM configuration")
-}).describe("Query parameters for getting current LLM configuration");
+}).strict().describe("Query parameters for getting current LLM configuration");
 const CatalogQuerySchema = import_zod_openapi.z.object({
+  scope: import_zod_openapi.z.enum(["curated", "all"]).default("all").describe(
+    "Catalog scope: 'curated' returns a small, UI-friendly set of models; 'all' returns the full registry (can be large)"
+  ),
   provider: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(import_zod_openapi.z.string())]).optional().transform(
     (value) => Array.isArray(value) ? value : value ? value.split(",") : void 0
   ).describe("Comma-separated list of LLM providers to filter by"),
+  includeModels: 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 models list in the response (true or false)"),
   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)"),
@@ -41,7 +47,7 @@ const CatalogQuerySchema = import_zod_openapi.z.object({
     (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");
+}).strict().describe("Query parameters for filtering and formatting the LLM catalog");
 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")
@@ -66,7 +72,14 @@ function createLlmRouter(getAgent) {
                 maxIterations: true
               }).extend({
                 displayName: import_zod_openapi.z.string().optional().describe("Human-readable model display name")
-              })
+              }),
+              routing: import_zod_openapi.z.object({
+                viaDexto: import_zod_openapi.z.boolean().describe(
+                  "Whether requests route through Dexto gateway"
+                )
+              }).describe(
+                "Routing information for the current LLM configuration"
+              )
             }).describe("Response containing current LLM configuration")
           }
         }
@@ -213,6 +226,33 @@ function createLlmRouter(getAgent) {
       }
     }
   });
+  const capabilitiesRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/llm/capabilities",
+    summary: "Get Model Capabilities",
+    description: "Returns the capabilities (supported file types) for a specific provider/model combination. Handles gateway providers (dexto-nova, openrouter) by resolving to the underlying model capabilities.",
+    tags: ["llm"],
+    request: {
+      query: import_zod_openapi.z.object({
+        provider: import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS).describe("LLM provider name"),
+        model: import_zod_openapi.z.string().min(1).describe("Model name (supports both native and OpenRouter format)")
+      })
+    },
+    responses: {
+      200: {
+        description: "Model capabilities",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              provider: import_zod_openapi.z.enum(import_core2.LLM_PROVIDERS).describe("Provider name"),
+              model: import_zod_openapi.z.string().describe("Model name as provided"),
+              supportedFileTypes: import_zod_openapi.z.array(import_zod_openapi.z.enum(import_core2.SUPPORTED_FILE_TYPES)).describe("File types supported by this model")
+            })
+          }
+        }
+      }
+    }
+  });
   return app.openapi(currentRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
@@ -233,26 +273,42 @@ function createLlmRouter(getAgent) {
     } catch {
     }
     const { apiKey, ...configWithoutKey } = currentConfig;
+    const viaDexto = (0, import_agent_management.isDextoAuthEnabled)() && currentConfig.provider === "dexto-nova";
     return ctx.json({
       config: {
         ...configWithoutKey,
         hasApiKey: !!apiKey,
         ...displayName && { displayName }
+      },
+      routing: {
+        viaDexto
       }
     });
   }).openapi(catalogRoute, (ctx) => {
     const queryParams = ctx.req.valid("query");
+    const includeModels = queryParams.includeModels ?? true;
+    const scope = queryParams.scope ?? "all";
     const providers = {};
     for (const provider of import_core2.LLM_PROVIDERS) {
+      if (provider === "dexto-nova" && !(0, import_agent_management.isDextoAuthEnabled)()) {
+        continue;
+      }
       const info = import_core2.LLM_REGISTRY[provider];
-      const displayName = provider.charAt(0).toUpperCase() + provider.slice(1);
+      const displayName = provider === "dexto-nova" ? "Dexto Nova" : provider.charAt(0).toUpperCase() + provider.slice(1);
       const keyStatus = (0, import_agent_management.getProviderKeyStatus)(provider);
+      const models = (() => {
+        if (!includeModels) return [];
+        if (scope === "all") {
+          return (0, import_core2.getAllModelsForProvider)(provider);
+        }
+        return (0, import_core2.getCuratedModelsForProvider)(provider);
+      })();
       providers[provider] = {
         name: displayName,
         hasApiKey: keyStatus.hasApiKey,
         primaryEnvVar: keyStatus.envVar,
         supportsBaseURL: (0, import_core2.supportsBaseURL)(provider),
-        models: info.models,
+        models,
         supportedFileTypes: info.supportedFileTypes
       };
     }
@@ -347,6 +403,20 @@ function createLlmRouter(getAgent) {
       );
     }
     return ctx.json({ ok: true, deleted: name }, 200);
+  }).openapi(capabilitiesRoute, (ctx) => {
+    const { provider, model } = ctx.req.valid("query");
+    let supportedFileTypes;
+    try {
+      supportedFileTypes = (0, import_core2.getSupportedFileTypesForModel)(provider, model);
+    } catch {
+      const providerInfo = import_core2.LLM_REGISTRY[provider];
+      supportedFileTypes = providerInfo?.supportedFileTypes ?? [];
+    }
+    return ctx.json({
+      provider,
+      model,
+      supportedFileTypes
+    });
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -13,7 +13,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             output: {
                 config: {
                     model: string;
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
                     maxIterations?: number | undefined;
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
@@ -24,6 +24,9 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                     hasApiKey?: boolean | undefined;
                     displayName?: string | undefined;
                 };
+                routing: {
+                    viaDexto: boolean;
+                };
             };
             outputFormat: "json";
             status: 200;
@@ -35,6 +38,8 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             input: {
                 query: {
                     provider?: string | string[] | undefined;
+                    scope?: "curated" | "all" | undefined;
+                    includeModels?: "0" | "1" | "true" | "false" | undefined;
                     hasKey?: "0" | "1" | "true" | "false" | undefined;
                     fileType?: "image" | "audio" | "pdf" | undefined;
                     defaultOnly?: "0" | "1" | "true" | "false" | undefined;
@@ -197,6 +202,50 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                             } | undefined;
                         }[];
                     } | undefined;
+                    minimax?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
+                    glm?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
                     openrouter?: {
                         name: string;
                         hasApiKey: boolean;
@@ -351,6 +400,28 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                             } | undefined;
                         }[];
                     } | undefined;
+                    "dexto-nova"?: {
+                        name: string;
+                        hasApiKey: boolean;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            name: string;
+                            maxInputTokens: number;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    } | undefined;
                 };
             } | {
                 models: {
@@ -380,15 +451,15 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             input: {
                 json: {
                     model?: string | undefined;
-                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
+                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
                     apiKey?: string | undefined;
+                    maxInputTokens?: number | undefined;
                     maxIterations?: number | undefined;
                     baseURL?: string | undefined;
-                    maxInputTokens?: number | undefined;
                     maxOutputTokens?: number | undefined;
                     temperature?: number | undefined;
                     allowedMediaTypes?: string[] | undefined;
-                    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+                    reasoningEffort?: "low" | "none" | "minimal" | "medium" | "high" | "xhigh" | undefined;
                 } & {
                     sessionId?: string | undefined;
                 };
@@ -396,7 +467,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             output: {
                 config: {
                     model: string;
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
                     maxIterations?: number | undefined;
                     baseURL?: string | undefined;
                     maxInputTokens?: number | undefined;
@@ -419,7 +490,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             output: {
                 models: {
                     name: string;
-                    provider: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    provider: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
                     apiKey?: string | undefined | undefined;
                     baseURL?: string | undefined | undefined;
                     reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined | undefined;
@@ -439,7 +510,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             input: {
                 json: {
                     name: string;
-                    provider?: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
+                    provider?: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
                     apiKey?: string | undefined;
                     baseURL?: string | undefined;
                     reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
@@ -452,7 +523,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             output: {
                 model: {
                     name: string;
-                    provider: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
+                    provider: "openai-compatible" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
                     apiKey?: string | undefined | undefined;
                     baseURL?: string | undefined | undefined;
                     reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined | undefined;
@@ -495,6 +566,24 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             status: 404;
         };
     };
+} & {
+    "/llm/capabilities": {
+        $get: {
+            input: {
+                query: {
+                    model: string;
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                };
+            };
+            output: {
+                model: string;
+                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova";
+                supportedFileTypes: ("image" | "audio" | "pdf")[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
 }, "/">;
 export {};
 //# sourceMappingURL=llm.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/llm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAkB9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAOpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAgErE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoXnD"}
+{"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;AAuB9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAOpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAmFrE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwdnD"}

package/dist/hono/routes/llm.js

@@ -5,6 +5,9 @@ import {
   LLM_PROVIDERS,
   SUPPORTED_FILE_TYPES,
   supportsBaseURL,
+  getAllModelsForProvider,
+  getCuratedModelsForProvider,
+  getSupportedFileTypesForModel,
   LLMUpdatesSchema
 } from "@dexto/core";
 import {
@@ -12,7 +15,8 @@ import {
   loadCustomModels,
   saveCustomModel,
   deleteCustomModel,
-  CustomModelSchema
+  CustomModelSchema,
+  isDextoAuthEnabled
 } from "@dexto/agent-management";
 import {
   ProviderCatalogSchema,
@@ -21,11 +25,17 @@ import {
 } from "../schemas/responses.js";
 const CurrentQuerySchema = z.object({
   sessionId: z.string().optional().describe("Session identifier to retrieve session-specific LLM configuration")
-}).describe("Query parameters for getting current LLM configuration");
+}).strict().describe("Query parameters for getting current LLM configuration");
 const CatalogQuerySchema = z.object({
+  scope: z.enum(["curated", "all"]).default("all").describe(
+    "Catalog scope: 'curated' returns a small, UI-friendly set of models; 'all' returns the full registry (can be large)"
+  ),
   provider: z.union([z.string(), z.array(z.string())]).optional().transform(
     (value) => Array.isArray(value) ? value : value ? value.split(",") : void 0
   ).describe("Comma-separated list of LLM providers to filter by"),
+  includeModels: 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("Include models list in the response (true or false)"),
   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)"),
@@ -34,7 +44,7 @@ const CatalogQuerySchema = z.object({
     (raw) => raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : void 0
   ).describe("Include only default models (true or false)"),
   mode: z.enum(["grouped", "flat"]).default("grouped").describe("Response format mode (grouped by provider or flat list)")
-}).describe("Query parameters for filtering and formatting the LLM catalog");
+}).strict().describe("Query parameters for filtering and formatting the LLM catalog");
 const SwitchLLMBodySchema = LLMUpdatesSchema.and(
   z.object({
     sessionId: z.string().optional().describe("Session identifier for session-specific LLM configuration")
@@ -59,7 +69,14 @@ function createLlmRouter(getAgent) {
                 maxIterations: true
               }).extend({
                 displayName: z.string().optional().describe("Human-readable model display name")
-              })
+              }),
+              routing: z.object({
+                viaDexto: z.boolean().describe(
+                  "Whether requests route through Dexto gateway"
+                )
+              }).describe(
+                "Routing information for the current LLM configuration"
+              )
             }).describe("Response containing current LLM configuration")
           }
         }
@@ -206,6 +223,33 @@ function createLlmRouter(getAgent) {
       }
     }
   });
+  const capabilitiesRoute = createRoute({
+    method: "get",
+    path: "/llm/capabilities",
+    summary: "Get Model Capabilities",
+    description: "Returns the capabilities (supported file types) for a specific provider/model combination. Handles gateway providers (dexto-nova, openrouter) by resolving to the underlying model capabilities.",
+    tags: ["llm"],
+    request: {
+      query: z.object({
+        provider: z.enum(LLM_PROVIDERS).describe("LLM provider name"),
+        model: z.string().min(1).describe("Model name (supports both native and OpenRouter format)")
+      })
+    },
+    responses: {
+      200: {
+        description: "Model capabilities",
+        content: {
+          "application/json": {
+            schema: z.object({
+              provider: z.enum(LLM_PROVIDERS).describe("Provider name"),
+              model: z.string().describe("Model name as provided"),
+              supportedFileTypes: z.array(z.enum(SUPPORTED_FILE_TYPES)).describe("File types supported by this model")
+            })
+          }
+        }
+      }
+    }
+  });
   return app.openapi(currentRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { sessionId } = ctx.req.valid("query");
@@ -226,26 +270,42 @@ function createLlmRouter(getAgent) {
     } catch {
     }
     const { apiKey, ...configWithoutKey } = currentConfig;
+    const viaDexto = isDextoAuthEnabled() && currentConfig.provider === "dexto-nova";
     return ctx.json({
       config: {
         ...configWithoutKey,
         hasApiKey: !!apiKey,
         ...displayName && { displayName }
+      },
+      routing: {
+        viaDexto
       }
     });
   }).openapi(catalogRoute, (ctx) => {
     const queryParams = ctx.req.valid("query");
+    const includeModels = queryParams.includeModels ?? true;
+    const scope = queryParams.scope ?? "all";
     const providers = {};
     for (const provider of LLM_PROVIDERS) {
+      if (provider === "dexto-nova" && !isDextoAuthEnabled()) {
+        continue;
+      }
       const info = LLM_REGISTRY[provider];
-      const displayName = provider.charAt(0).toUpperCase() + provider.slice(1);
+      const displayName = provider === "dexto-nova" ? "Dexto Nova" : provider.charAt(0).toUpperCase() + provider.slice(1);
       const keyStatus = getProviderKeyStatus(provider);
+      const models = (() => {
+        if (!includeModels) return [];
+        if (scope === "all") {
+          return getAllModelsForProvider(provider);
+        }
+        return getCuratedModelsForProvider(provider);
+      })();
       providers[provider] = {
         name: displayName,
         hasApiKey: keyStatus.hasApiKey,
         primaryEnvVar: keyStatus.envVar,
         supportsBaseURL: supportsBaseURL(provider),
-        models: info.models,
+        models,
         supportedFileTypes: info.supportedFileTypes
       };
     }
@@ -340,6 +400,20 @@ function createLlmRouter(getAgent) {
       );
     }
     return ctx.json({ ok: true, deleted: name }, 200);
+  }).openapi(capabilitiesRoute, (ctx) => {
+    const { provider, model } = ctx.req.valid("query");
+    let supportedFileTypes;
+    try {
+      supportedFileTypes = getSupportedFileTypesForModel(provider, model);
+    } catch {
+      const providerInfo = LLM_REGISTRY[provider];
+      supportedFileTypes = providerInfo?.supportedFileTypes ?? [];
+    }
+    return ctx.json({
+      provider,
+      model,
+      supportedFileTypes
+    });
   });
 }
 export {

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

@@ -46,7 +46,7 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             input: {};
             output: {
                 servers: {
-                    status: "error" | "connected" | "disconnected";
+                    status: "error" | "connected" | "disconnected" | "auth-required";
                     id: string;
                     name: string;
                 }[];

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

@@ -106,7 +106,7 @@ export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoord
                     totalTokens?: number | undefined;
                 } | undefined;
                 model?: string | undefined;
-                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | undefined;
+                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
             };
             outputFormat: "json";
             status: 200;

package/dist/hono/routes/queue.cjs

@@ -27,7 +27,8 @@ const QueuedMessageSchema = import_zod_openapi.z.object({
   id: import_zod_openapi.z.string().describe("Unique identifier for the queued message"),
   content: import_zod_openapi.z.array(import_responses.ContentPartSchema).describe("Message content parts"),
   queuedAt: import_zod_openapi.z.number().describe("Unix timestamp when message was queued"),
-  metadata: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional metadata")
+  metadata: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional metadata"),
+  kind: import_zod_openapi.z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).strict().describe("A message waiting in the queue");
 const TextPartSchema = import_zod_openapi.z.object({
   type: import_zod_openapi.z.literal("text").describe("Content type identifier"),
@@ -46,7 +47,8 @@ const FilePartSchema = import_zod_openapi.z.object({
 }).describe("File content part");
 const QueueContentPartSchema = import_zod_openapi.z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Content part - text, image, or file");
 const QueueMessageBodySchema = import_zod_openapi.z.object({
-  content: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(QueueContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal")
+  content: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(QueueContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal"),
+  kind: import_zod_openapi.z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).describe("Request body for queueing a message");
 function createQueueRouter(getAgent) {
   const app = new import_zod_openapi.OpenAPIHono();
@@ -172,7 +174,11 @@ function createQueueRouter(getAgent) {
     const { sessionId } = ctx.req.valid("param");
     const { content: rawContent } = ctx.req.valid("json");
     const content = typeof rawContent === "string" ? [{ type: "text", text: rawContent }] : rawContent;
-    const result = await agent.queueMessage(sessionId, { content });
+    const { kind } = ctx.req.valid("json");
+    const result = await agent.queueMessage(sessionId, {
+      content,
+      ...kind !== void 0 && { kind }
+    });
     return ctx.json(
       {
         queued: result.queued,