@dexto/server 1.2.5

package/dist/hono/routes/llm.cjs

@@ -0,0 +1,298 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var llm_exports = {};
+__export(llm_exports, {
+  createLlmRouter: () => createLlmRouter
+});
+module.exports = __toCommonJS(llm_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_core = 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({
+  sessionId: import_zod_openapi.z.string().optional().describe("Session identifier to retrieve session-specific LLM configuration")
+}).describe("Query parameters for getting current LLM configuration");
+const CatalogQuerySchema = import_zod_openapi.z.object({
+  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"),
+  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)"),
+  defaultOnly: import_zod_openapi.z.union([import_zod_openapi.z.literal("true"), import_zod_openapi.z.literal("false"), import_zod_openapi.z.literal("1"), import_zod_openapi.z.literal("0")]).optional().transform(
+    (raw) => raw === "true" || raw === "1" ? true : raw === "false" || raw === "0" ? false : void 0
+  ).describe("Include only default models (true or false)"),
+  mode: import_zod_openapi.z.enum(["grouped", "flat"]).default("grouped").describe("Response format mode (grouped by provider or flat list)")
+}).describe("Query parameters for filtering and formatting the LLM catalog");
+const SaveKeySchema = import_zod_openapi.z.object({
+  provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).describe("LLM provider identifier (e.g., openai, anthropic)"),
+  apiKey: import_zod_openapi.z.string().min(1, "API key is required").describe("API key for the provider (writeOnly - never returned in responses)").openapi({ writeOnly: true })
+}).describe("Request body for saving a provider API key");
+const SwitchLLMBodySchema = import_core.LLMUpdatesSchema.and(
+  import_zod_openapi.z.object({
+    sessionId: import_zod_openapi.z.string().optional().describe("Session identifier for session-specific LLM configuration")
+  })
+).describe("LLM switch request body with optional session ID and LLM fields");
+function createLlmRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const currentRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/llm/current",
+    summary: "Get Current LLM Config",
+    description: "Retrieves the current LLM configuration for the agent or a specific session",
+    tags: ["llm"],
+    request: { query: CurrentQuerySchema },
+    responses: {
+      200: {
+        description: "Current LLM config",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              config: import_responses.LLMConfigResponseSchema.partial({
+                maxIterations: true,
+                router: true
+              }).extend({
+                displayName: import_zod_openapi.z.string().optional().describe("Human-readable model display name")
+              })
+            }).describe("Response containing current LLM configuration")
+          }
+        }
+      }
+    }
+  });
+  const catalogRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/llm/catalog",
+    summary: "LLM Catalog",
+    description: "Providers, models, capabilities, and API key status",
+    tags: ["llm"],
+    request: { query: CatalogQuerySchema },
+    responses: {
+      200: {
+        description: "LLM catalog",
+        content: {
+          "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 grouped by ID with their models and capabilities"
+                )
+              }).strict().describe("Grouped catalog response (mode=grouped)"),
+              import_zod_openapi.z.object({
+                models: import_zod_openapi.z.array(import_responses.ModelFlatSchema).describe(
+                  "Flat list of all models with provider information"
+                )
+              }).strict().describe("Flat catalog response (mode=flat)")
+            ]).describe(
+              "LLM catalog in grouped or flat format based on mode query parameter"
+            )
+          }
+        }
+      }
+    }
+  });
+  const saveKeyRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/llm/key",
+    summary: "Save Provider API Key",
+    description: "Stores an API key for a provider in .env and makes it available immediately",
+    tags: ["llm"],
+    request: { body: { content: { "application/json": { schema: SaveKeySchema } } } },
+    responses: {
+      200: {
+        description: "API key saved",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              ok: import_zod_openapi.z.literal(true).describe("Operation success indicator"),
+              provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).describe("Provider for which the key was saved"),
+              envVar: import_zod_openapi.z.string().describe("Environment variable name where key was stored")
+            }).strict().describe("API key save response")
+          }
+        }
+      }
+    }
+  });
+  const switchRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/llm/switch",
+    summary: "Switch LLM",
+    description: "Switches the LLM configuration for the agent or a specific session",
+    tags: ["llm"],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: SwitchLLMBodySchema
+          }
+        }
+      }
+    },
+    responses: {
+      200: {
+        description: "LLM switch result",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              config: import_responses.LLMConfigResponseSchema.describe(
+                "New LLM configuration with all defaults applied (apiKey omitted)"
+              ),
+              sessionId: import_zod_openapi.z.string().optional().describe("Session ID if session-specific switch")
+            }).describe("LLM switch result")
+          }
+        }
+      }
+    }
+  });
+  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(
+        (m) => m.name.toLowerCase() === String(currentConfig.model).toLowerCase()
+      );
+      displayName = model?.displayName || void 0;
+    } catch {
+    }
+    const { apiKey, ...configWithoutKey } = currentConfig;
+    return ctx.json({
+      config: {
+        ...configWithoutKey,
+        hasApiKey: !!apiKey,
+        ...displayName && { displayName }
+      }
+    });
+  }).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];
+      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),
+        models: info.models,
+        supportedFileTypes: info.supportedFileTypes
+      };
+    }
+    let filtered = { ...providers };
+    if (queryParams.provider && queryParams.provider.length > 0) {
+      const allowed = new Set(
+        queryParams.provider.filter(
+          (p) => import_core.LLM_PROVIDERS.includes(p)
+        )
+      );
+      const filteredByProvider = {};
+      for (const [id, catalog] of Object.entries(filtered)) {
+        if (allowed.has(id)) {
+          filteredByProvider[id] = catalog;
+        }
+      }
+      filtered = filteredByProvider;
+    }
+    if (typeof queryParams.hasKey === "boolean") {
+      const byKey = {};
+      for (const [id, catalog] of Object.entries(filtered)) {
+        if (catalog.hasApiKey === queryParams.hasKey) {
+          byKey[id] = catalog;
+        }
+      }
+      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)) {
+        const models = catalog.models.filter((model) => {
+          const modelTypes = Array.isArray(model.supportedFileTypes) && model.supportedFileTypes.length > 0 ? model.supportedFileTypes : catalog.supportedFileTypes || [];
+          return modelTypes.includes(queryParams.fileType);
+        });
+        if (models.length > 0) {
+          byFileType[id] = { ...catalog, models };
+        }
+      }
+      filtered = byFileType;
+    }
+    if (queryParams.defaultOnly) {
+      const byDefault = {};
+      for (const [id, catalog] of Object.entries(filtered)) {
+        const models = catalog.models.filter((model) => model.default === true);
+        if (models.length > 0) {
+          byDefault[id] = { ...catalog, models };
+        }
+      }
+      filtered = byDefault;
+    }
+    if (queryParams.mode === "flat") {
+      const flat = [];
+      for (const [id, catalog] of Object.entries(filtered)) {
+        for (const model of catalog.models) {
+          flat.push({ provider: id, ...model });
+        }
+      }
+      return ctx.json({ models: flat });
+    }
+    return ctx.json({ providers: filtered });
+  }).openapi(saveKeyRoute, async (ctx) => {
+    const { provider, apiKey } = ctx.req.valid("json");
+    const meta = await (0, import_agent_management.saveProviderApiKey)(provider, apiKey, process.cwd());
+    return ctx.json({ ok: true, provider, envVar: meta.envVar });
+  }).openapi(switchRoute, async (ctx) => {
+    const agent = getAgent();
+    const raw = ctx.req.valid("json");
+    const { sessionId, ...llmUpdates } = raw;
+    const config = await agent.switchLLM(llmUpdates, sessionId);
+    const { apiKey, ...configWithoutKey } = config;
+    return ctx.json({
+      config: {
+        ...configWithoutKey,
+        hasApiKey: !!apiKey
+      },
+      sessionId
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLlmRouter
+});

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

@@ -0,0 +1,294 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+export declare function createLlmRouter(getAgent: () => DextoAgent): OpenAPIHono<import("hono").Env, {
+    "/llm/current": {
+        $get: {
+            input: {
+                query: {
+                    sessionId?: string | undefined;
+                };
+            };
+            output: {
+                config: {
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                    model: string;
+                    maxIterations?: number | undefined;
+                    router?: "vercel" | "in-built" | undefined;
+                    baseURL?: string | undefined;
+                    maxInputTokens?: number | undefined;
+                    maxOutputTokens?: number | undefined;
+                    temperature?: number | undefined;
+                    allowedMediaTypes?: string[] | undefined;
+                    hasApiKey?: boolean | undefined;
+                    displayName?: string | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/catalog": {
+        $get: {
+            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;
+                    mode?: "flat" | "grouped" | undefined;
+                };
+            };
+            output: {
+                providers: {
+                    openai?: {
+                        hasApiKey: boolean;
+                        name: string;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        supportedRouters: ("vercel" | "in-built")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            maxInputTokens: number;
+                            name: string;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            supportedRouters?: ("vercel" | "in-built")[] | 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;
+                    "openai-compatible"?: {
+                        hasApiKey: boolean;
+                        name: string;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        supportedRouters: ("vercel" | "in-built")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            maxInputTokens: number;
+                            name: string;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            supportedRouters?: ("vercel" | "in-built")[] | 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;
+                    anthropic?: {
+                        hasApiKey: boolean;
+                        name: string;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        supportedRouters: ("vercel" | "in-built")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            maxInputTokens: number;
+                            name: string;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            supportedRouters?: ("vercel" | "in-built")[] | 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;
+                    google?: {
+                        hasApiKey: boolean;
+                        name: string;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        supportedRouters: ("vercel" | "in-built")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            maxInputTokens: number;
+                            name: string;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            supportedRouters?: ("vercel" | "in-built")[] | 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;
+                    groq?: {
+                        hasApiKey: boolean;
+                        name: string;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        supportedRouters: ("vercel" | "in-built")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            maxInputTokens: number;
+                            name: string;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            supportedRouters?: ("vercel" | "in-built")[] | 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;
+                    xai?: {
+                        hasApiKey: boolean;
+                        name: string;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        supportedRouters: ("vercel" | "in-built")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            maxInputTokens: number;
+                            name: string;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            supportedRouters?: ("vercel" | "in-built")[] | 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;
+                    cohere?: {
+                        hasApiKey: boolean;
+                        name: string;
+                        supportedFileTypes: ("image" | "audio" | "pdf")[];
+                        supportedRouters: ("vercel" | "in-built")[];
+                        primaryEnvVar: string;
+                        supportsBaseURL: boolean;
+                        models: {
+                            maxInputTokens: number;
+                            name: string;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            supportedRouters?: ("vercel" | "in-built")[] | 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: {
+                    provider: string;
+                    maxInputTokens: number;
+                    name: string;
+                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                    default?: boolean | undefined;
+                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                    displayName?: string | undefined;
+                    pricing?: {
+                        inputPerM: number;
+                        outputPerM: number;
+                        cacheReadPerM?: number | undefined;
+                        cacheWritePerM?: number | undefined;
+                        currency?: "USD" | undefined;
+                        unit?: "per_million_tokens" | undefined;
+                    } | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/key": {
+        $post: {
+            input: {
+                json: {
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                    apiKey: string;
+                };
+            };
+            output: {
+                provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                ok: true;
+                envVar: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/llm/switch": {
+        $post: {
+            input: {
+                json: {
+                    apiKey?: string | undefined;
+                    model?: string | undefined;
+                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                    router?: "vercel" | "in-built" | undefined;
+                    maxIterations?: number | undefined;
+                    baseURL?: string | undefined;
+                    maxInputTokens?: number | undefined;
+                    maxOutputTokens?: number | undefined;
+                    temperature?: number | undefined;
+                    allowedMediaTypes?: string[] | undefined;
+                } & {
+                    sessionId?: string | undefined;
+                };
+            };
+            output: {
+                config: {
+                    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                    model: string;
+                    maxIterations: number;
+                    router: "vercel" | "in-built";
+                    baseURL?: string | undefined;
+                    maxInputTokens?: number | undefined;
+                    maxOutputTokens?: number | undefined;
+                    temperature?: number | undefined;
+                    allowedMediaTypes?: string[] | undefined;
+                    hasApiKey?: boolean | undefined;
+                };
+                sessionId?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=llm.d.ts.map

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

@@ -0,0 +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"}