@dexto/server 1.5.7 → 1.6.0

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

@@ -1,16 +1,14 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-export declare function createDiscoveryRouter(): OpenAPIHono<import("hono").Env, {
+import type { Context } from 'hono';
+export type GetAgentConfigPathFn = (ctx: Context) => string | undefined | Promise<string | undefined>;
+export declare function createDiscoveryRouter(getAgentConfigPath: GetAgentConfigPathFn): OpenAPIHono<import("hono").Env, {
     "/discovery": {
         $get: {
             input: {};
             output: {
-                internalTools: {
-                    description: string;
-                    name: string;
-                }[];
-                customTools: {
+                blob: {
                     type: string;
-                    category: "customTools" | "compaction" | "blob" | "database";
+                    category: "blob" | "tools" | "compaction" | "database";
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         description?: string | undefined;
@@ -19,31 +17,35 @@ export declare function createDiscoveryRouter(): OpenAPIHono<import("hono").Env,
                 }[];
                 compaction: {
                     type: string;
-                    category: "customTools" | "compaction" | "blob" | "database";
+                    category: "blob" | "tools" | "compaction" | "database";
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         description?: string | undefined;
                         displayName?: string | undefined;
                     } | undefined;
                 }[];
-                blob: {
+                database: {
                     type: string;
-                    category: "customTools" | "compaction" | "blob" | "database";
+                    category: "blob" | "tools" | "compaction" | "database";
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         description?: string | undefined;
                         displayName?: string | undefined;
                     } | undefined;
                 }[];
-                database: {
+                toolFactories: {
                     type: string;
-                    category: "customTools" | "compaction" | "blob" | "database";
+                    category: "blob" | "tools" | "compaction" | "database";
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                         description?: string | undefined;
                         displayName?: string | undefined;
                     } | undefined;
                 }[];
+                builtinTools: {
+                    description: string;
+                    name: string;
+                }[];
             };
             outputFormat: "json";
             status: 200;

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

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAyChE,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsBpC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAMpC,MAAM,MAAM,oBAAoB,GAAG,CAC/B,GAAG,EAAE,OAAO,KACX,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AAgJtD,wBAAgB,qBAAqB,CAAC,kBAAkB,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqB7E"}

package/dist/hono/routes/discovery.js

@@ -1,42 +1,109 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { listAllProviders } from "@dexto/core";
-const DiscoveredProviderSchema = z.object({
-  type: z.string().describe("Provider type identifier"),
-  category: z.enum(["blob", "database", "compaction", "customTools"]).describe("Provider category"),
+import { loadImage } from "@dexto/agent-config";
+import { loadAgentConfig } from "@dexto/agent-management";
+import imageLocal from "@dexto/image-local";
+const DiscoveredFactorySchema = z.object({
+  type: z.string().describe("Factory type identifier"),
+  category: z.enum(["blob", "database", "compaction", "tools"]).describe("Factory category"),
   metadata: z.object({
     displayName: z.string().optional().describe("Human-readable display name"),
-    description: z.string().optional().describe("Provider description")
-  }).passthrough().optional().describe("Optional metadata about the provider")
-}).describe("Information about a registered provider");
-const InternalToolSchema = z.object({
-  name: z.string().describe('Internal tool name identifier (e.g., "search_history", "ask_user")'),
+    description: z.string().optional().describe("Factory description")
+  }).passthrough().optional().describe("Optional metadata about the factory")
+}).describe("Information about a registered factory");
+const ToolSchema = z.object({
+  name: z.string().describe('Built-in tool name identifier (e.g., "search_history", "ask_user")'),
   description: z.string().describe("Human-readable description of what the tool does")
-}).describe("Information about an internal tool");
+}).describe("Information about a built-in tool");
 const DiscoveryResponseSchema = z.object({
-  blob: z.array(DiscoveredProviderSchema).describe("Blob storage providers"),
-  database: z.array(DiscoveredProviderSchema).describe("Database providers"),
-  compaction: z.array(DiscoveredProviderSchema).describe("Compaction strategy providers"),
-  customTools: z.array(DiscoveredProviderSchema).describe("Custom tool providers"),
-  internalTools: z.array(InternalToolSchema).describe("Internal tools available for configuration")
-}).describe("Discovery response with providers grouped by category");
-function createDiscoveryRouter() {
+  blob: z.array(DiscoveredFactorySchema).describe("Blob storage factories"),
+  database: z.array(DiscoveredFactorySchema).describe("Database factories"),
+  compaction: z.array(DiscoveredFactorySchema).describe("Compaction strategy factories"),
+  toolFactories: z.array(DiscoveredFactorySchema).describe("Tool factories"),
+  builtinTools: z.array(ToolSchema).describe("Built-in tools available for configuration")
+}).describe("Discovery response with factories grouped by category");
+function toMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return void 0;
+  }
+  const record = metadata;
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      result[key] = value;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+async function resolveImage(options) {
+  const { ctx, getAgentConfigPath } = options;
+  const configPath = await getAgentConfigPath(ctx);
+  if (!configPath) {
+    return imageLocal;
+  }
+  const rawConfig = await loadAgentConfig(configPath);
+  const imageName = (typeof rawConfig.image === "string" && rawConfig.image.length > 0 ? rawConfig.image : void 0) ?? process.env.DEXTO_IMAGE ?? "@dexto/image-local";
+  if (imageName === "@dexto/image-local") {
+    return imageLocal;
+  }
+  try {
+    return await loadImage(imageName);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to load image module '${imageName}'. Ensure it is installed and that the host called setImageImporter(). Original error: ${message}`
+    );
+  }
+}
+async function listDiscoveryFactories(options) {
+  const image = await resolveImage(options);
+  const blob = Object.entries(image.storage.blob).map(([type, factory]) => ({
+    type,
+    category: "blob",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const database = Object.entries(image.storage.database).map(([type, factory]) => ({
+    type,
+    category: "database",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const compaction = Object.entries(image.compaction).map(([type, factory]) => ({
+    type,
+    category: "compaction",
+    metadata: toMetadata(factory.metadata)
+  }));
+  const toolFactories = Object.entries(image.tools);
+  const builtinFactory = toolFactories.find(([type]) => type === "builtin-tools")?.[1];
+  const builtinTools = builtinFactory ? builtinFactory.create(builtinFactory.configSchema.parse({ type: "builtin-tools" })).map((tool) => ({
+    name: tool.id,
+    description: tool.description
+  })) : [];
+  const toolFactoriesList = toolFactories.filter(([type]) => type !== "builtin-tools").map(([type, factory]) => ({
+    type,
+    category: "tools",
+    metadata: toMetadata(factory.metadata)
+  }));
+  return { blob, database, compaction, toolFactories: toolFactoriesList, builtinTools };
+}
+function createDiscoveryRouter(getAgentConfigPath) {
   const app = new OpenAPIHono();
   const discoveryRoute = createRoute({
     method: "get",
     path: "/discovery",
-    summary: "Discover Available Providers and Tools",
-    description: "Returns all registered providers (blob storage, database, compaction, custom tools) and available internal tools. Useful for building UIs that need to display configurable options.",
+    summary: "Discover Available Factories and Tools",
+    description: "Returns all available factories (storage, compaction, tools) for the currently active image.",
     tags: ["discovery"],
     responses: {
       200: {
-        description: "Available providers grouped by category",
+        description: "Available factories grouped by category",
         content: { "application/json": { schema: DiscoveryResponseSchema } }
       }
     }
   });
   return app.openapi(discoveryRoute, async (ctx) => {
-    const providers = listAllProviders();
-    return ctx.json(providers);
+    return ctx.json(await listDiscoveryFactories({ ctx, getAgentConfigPath }));
   });
 }
 export {

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" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto";
+                    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" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto";
+                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" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto";
+                    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" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto";
+                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")
@@ -224,7 +230,7 @@ function createLlmRouter(getAgent) {
     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, openrouter) by resolving to the underlying 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({
@@ -267,7 +273,7 @@ function createLlmRouter(getAgent) {
     } catch {
     }
     const { apiKey, ...configWithoutKey } = currentConfig;
-    const viaDexto = (0, import_agent_management.isDextoAuthEnabled)() && currentConfig.provider === "dexto";
+    const viaDexto = (0, import_agent_management.isDextoAuthEnabled)() && currentConfig.provider === "dexto-nova";
     return ctx.json({
       config: {
         ...configWithoutKey,
@@ -280,15 +286,23 @@ function createLlmRouter(getAgent) {
     });
   }).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" && !(0, import_agent_management.isDextoAuthEnabled)()) {
+      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 = (0, import_core2.getAllModelsForProvider)(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,

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" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto";
+                    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;
@@ -38,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;
@@ -398,7 +400,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                             } | undefined;
                         }[];
                     } | undefined;
-                    dexto?: {
+                    "dexto-nova"?: {
                         name: string;
                         hasApiKey: boolean;
                         supportedFileTypes: ("image" | "audio" | "pdf")[];
@@ -449,7 +451,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             input: {
                 json: {
                     model?: string | undefined;
-                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto" | 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;
@@ -465,7 +467,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             output: {
                 config: {
                     model: string;
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto";
+                    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;
@@ -488,7 +490,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             output: {
                 models: {
                     name: string;
-                    provider: "dexto" | "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;
@@ -508,7 +510,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             input: {
                 json: {
                     name: string;
-                    provider?: "dexto" | "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;
@@ -521,7 +523,7 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             output: {
                 model: {
                     name: string;
-                    provider: "dexto" | "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;
@@ -557,8 +559,8 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                 };
             };
             output: {
-                ok: false;
                 error: string;
+                ok: false;
             };
             outputFormat: "json";
             status: 404;
@@ -570,12 +572,12 @@ export declare function createLlmRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             input: {
                 query: {
                     model: string;
-                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto";
+                    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";
+                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";

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;AAsB9C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4cnD"}
+{"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

@@ -6,6 +6,7 @@ import {
   SUPPORTED_FILE_TYPES,
   supportsBaseURL,
   getAllModelsForProvider,
+  getCuratedModelsForProvider,
   getSupportedFileTypesForModel,
   LLMUpdatesSchema
 } from "@dexto/core";
@@ -24,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)"),
@@ -37,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")
@@ -220,7 +227,7 @@ function createLlmRouter(getAgent) {
     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, openrouter) by resolving to the underlying 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({
@@ -263,7 +270,7 @@ function createLlmRouter(getAgent) {
     } catch {
     }
     const { apiKey, ...configWithoutKey } = currentConfig;
-    const viaDexto = isDextoAuthEnabled() && currentConfig.provider === "dexto";
+    const viaDexto = isDextoAuthEnabled() && currentConfig.provider === "dexto-nova";
     return ctx.json({
       config: {
         ...configWithoutKey,
@@ -276,15 +283,23 @@ function createLlmRouter(getAgent) {
     });
   }).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" && !isDextoAuthEnabled()) {
+      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 = getAllModelsForProvider(provider);
+      const models = (() => {
+        if (!includeModels) return [];
+        if (scope === "all") {
+          return getAllModelsForProvider(provider);
+        }
+        return getCuratedModelsForProvider(provider);
+      })();
       providers[provider] = {
         name: displayName,
         hasApiKey: keyStatus.hasApiKey,