@dexto/server 1.2.5 → 1.3.0

package/dist/hono/routes/search.js

@@ -1,5 +1,5 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { SearchResultSchema, SessionSearchResultSchema } from "../schemas/responses.js";
+import { MessageSearchResponseSchema, SessionSearchResponseSchema } from "../schemas/responses.js";
 const MessageSearchQuery = z.object({
   q: z.string().min(1, "Search query is required").describe("Search query string"),
   limit: z.coerce.number().min(1).max(100).optional().describe("Maximum number of results to return (default: 20)"),
@@ -22,18 +22,7 @@ function createSearchRouter(getAgent) {
     responses: {
       200: {
         description: "Message search results",
-        content: {
-          "application/json": {
-            schema: z.object({
-              results: z.array(SearchResultSchema).describe("Array of search results"),
-              total: z.number().int().nonnegative().describe("Total number of results available"),
-              hasMore: z.boolean().describe(
-                "Whether there are more results beyond the current page"
-              ),
-              query: z.string().describe("Query that was searched")
-            }).strict().describe("Message search response")
-          }
-        }
+        content: { "application/json": { schema: MessageSearchResponseSchema } }
       }
     }
   });
@@ -47,18 +36,7 @@ function createSearchRouter(getAgent) {
     responses: {
       200: {
         description: "Session search results",
-        content: {
-          "application/json": {
-            schema: z.object({
-              results: z.array(SessionSearchResultSchema).describe("Array of session search results"),
-              total: z.number().int().nonnegative().describe("Total number of sessions with matches"),
-              hasMore: z.boolean().describe(
-                "Always false - session search returns all matching sessions without pagination"
-              ),
-              query: z.string().describe("Query that was searched")
-            }).strict().describe("Session search response")
-          }
-        }
+        content: { "application/json": { schema: SessionSearchResponseSchema } }
       }
     }
   });

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

@@ -75,18 +75,16 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         text: string;
                     } | {
                         type: "image";
-                        image?: import("hono/utils/types").JSONValue;
+                        image: string;
                         mimeType?: string | undefined;
                     } | {
                         type: "file";
                         mimeType: string;
-                        data?: import("hono/utils/types").JSONValue;
+                        data: string;
                         filename?: string | undefined;
                     })[] | null;
                     role: "system" | "user" | "assistant" | "tool";
-                    provider?: string | undefined;
-                    model?: string | undefined;
-                    router?: string | undefined;
+                    id?: string | undefined;
                     name?: string | undefined;
                     timestamp?: number | undefined;
                     reasoning?: string | undefined;
@@ -96,6 +94,9 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         reasoningTokens?: number | undefined;
                         totalTokens?: number | undefined;
                     } | undefined;
+                    model?: string | undefined;
+                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                    router?: "vercel" | "in-built" | undefined;
                     toolCalls?: {
                         function: {
                             name: string;

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

@@ -1 +1 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAS9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6Y9D"}
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAS9C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgZ9D"}

package/dist/hono/routes/static.cjs

@@ -0,0 +1,77 @@
+"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 static_exports = {};
+__export(static_exports, {
+  createSpaFallbackHandler: () => createSpaFallbackHandler,
+  createStaticRouter: () => createStaticRouter
+});
+module.exports = __toCommonJS(static_exports);
+var import_hono = require("hono");
+var import_serve_static = require("@hono/node-server/serve-static");
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+function createStaticRouter(webRoot) {
+  const app = new import_hono.Hono();
+  app.use("/assets/*", (0, import_serve_static.serveStatic)({ root: webRoot }));
+  app.use("/logos/*", (0, import_serve_static.serveStatic)({ root: webRoot }));
+  app.use("/favicon.ico", (0, import_serve_static.serveStatic)({ root: webRoot }));
+  return app;
+}
+function buildInjectionScript(config) {
+  const scripts = [];
+  if (config.analytics) {
+    const safeJson = JSON.stringify(config.analytics).replace(/</g, "\\u003c");
+    scripts.push(`window.__DEXTO_ANALYTICS__ = ${safeJson};`);
+  }
+  if (scripts.length === 0) return "";
+  return `<script>${scripts.join("\n")}</script>`;
+}
+function createSpaFallbackHandler(webRoot, runtimeConfig) {
+  const injectionScript = runtimeConfig ? buildInjectionScript(runtimeConfig) : "";
+  return async (c) => {
+    const path = c.req.path;
+    if (/\.[a-zA-Z0-9]+$/.test(path)) {
+      return c.json({ error: "Not Found", path }, 404);
+    }
+    try {
+      let html = await (0, import_promises.readFile)((0, import_node_path.join)(webRoot, "index.html"), "utf-8");
+      if (injectionScript) {
+        html = html.replace("</head>", `${injectionScript}</head>`);
+      }
+      return c.html(html);
+    } catch {
+      return c.html(
+        `<!DOCTYPE html>
+<html>
+<head><title>Dexto API Server</title></head>
+<body>
+<h1>Dexto API Server</h1>
+<p>WebUI is not available. API endpoints are accessible at <code>/api/*</code></p>
+</body>
+</html>`,
+        200
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSpaFallbackHandler,
+  createStaticRouter
+});

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

@@ -0,0 +1,41 @@
+import { Hono } from 'hono';
+import type { NotFoundHandler } from 'hono';
+/**
+ * Runtime configuration injected into WebUI via window globals.
+ * This replaces the Next.js SSR injection that was lost in the Vite migration.
+ *
+ * TODO: This injection only works in production mode where Hono serves index.html.
+ * In dev mode (`pnpm dev`), Vite serves index.html directly, bypassing this injection.
+ * To support dev mode analytics, add a `/api/config/analytics` endpoint that the
+ * WebUI can fetch as a fallback when `window.__DEXTO_ANALYTICS__` is undefined.
+ */
+export interface WebUIRuntimeConfig {
+    analytics?: {
+        distinctId: string;
+        posthogKey: string;
+        posthogHost: string;
+        appVersion: string;
+    } | null;
+}
+/**
+ * Create a static file router for serving WebUI assets.
+ *
+ * Serves static files from the specified webRoot directory.
+ * Note: SPA fallback is handled separately via createSpaFallbackHandler.
+ *
+ * @param webRoot - Absolute path to the directory containing WebUI build output
+ */
+export declare function createStaticRouter(webRoot: string): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+/**
+ * Create a notFound handler for SPA fallback.
+ *
+ * This handler serves index.html for client-side routes (paths without file extensions).
+ * For paths with file extensions (like /openapi.json), it returns a standard 404.
+ *
+ * This should be registered as app.notFound() to run after all routes fail to match.
+ *
+ * @param webRoot - Absolute path to the directory containing WebUI build output
+ * @param runtimeConfig - Optional runtime configuration to inject into the HTML
+ */
+export declare function createSpaFallbackHandler(webRoot: string, runtimeConfig?: WebUIRuntimeConfig): NotFoundHandler;
+//# sourceMappingURL=static.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/static.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAK5C;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IAC/B,SAAS,CAAC,EAAE;QACR,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;KACtB,GAAG,IAAI,CAAC;CACZ;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,8EAajD;AAmBD;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACpC,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,kBAAkB,GACnC,eAAe,CAuCjB"}

package/dist/hono/routes/static.js

@@ -0,0 +1,52 @@
+import { Hono } from "hono";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+function createStaticRouter(webRoot) {
+  const app = new Hono();
+  app.use("/assets/*", serveStatic({ root: webRoot }));
+  app.use("/logos/*", serveStatic({ root: webRoot }));
+  app.use("/favicon.ico", serveStatic({ root: webRoot }));
+  return app;
+}
+function buildInjectionScript(config) {
+  const scripts = [];
+  if (config.analytics) {
+    const safeJson = JSON.stringify(config.analytics).replace(/</g, "\\u003c");
+    scripts.push(`window.__DEXTO_ANALYTICS__ = ${safeJson};`);
+  }
+  if (scripts.length === 0) return "";
+  return `<script>${scripts.join("\n")}</script>`;
+}
+function createSpaFallbackHandler(webRoot, runtimeConfig) {
+  const injectionScript = runtimeConfig ? buildInjectionScript(runtimeConfig) : "";
+  return async (c) => {
+    const path = c.req.path;
+    if (/\.[a-zA-Z0-9]+$/.test(path)) {
+      return c.json({ error: "Not Found", path }, 404);
+    }
+    try {
+      let html = await readFile(join(webRoot, "index.html"), "utf-8");
+      if (injectionScript) {
+        html = html.replace("</head>", `${injectionScript}</head>`);
+      }
+      return c.html(html);
+    } catch {
+      return c.html(
+        `<!DOCTYPE html>
+<html>
+<head><title>Dexto API Server</title></head>
+<body>
+<h1>Dexto API Server</h1>
+<p>WebUI is not available. API endpoints are accessible at <code>/api/*</code></p>
+</body>
+</html>`,
+        200
+      );
+    }
+  };
+}
+export {
+  createSpaFallbackHandler,
+  createStaticRouter
+};

package/dist/hono/schemas/responses.cjs

@@ -21,9 +21,12 @@ __export(responses_exports, {
   AgentCardSchema: () => import_core4.AgentCardSchema,
   AgentRegistryEntrySchema: () => AgentRegistryEntrySchema,
   CatalogModelInfoSchema: () => CatalogModelInfoSchema,
+  ContentPartSchema: () => ContentPartSchema,
   DeleteResponseSchema: () => DeleteResponseSchema,
   ErrorResponseSchema: () => ErrorResponseSchema,
+  FilePartSchema: () => FilePartSchema,
   HttpServerConfigSchema: () => import_core5.HttpServerConfigSchema,
+  ImagePartSchema: () => ImagePartSchema,
   InternalMessageSchema: () => InternalMessageSchema,
   InternalResourceConfigSchema: () => import_core7.InternalResourceConfigSchema,
   LLMConfigBaseSchema: () => import_core3.LLMConfigBaseSchema,
@@ -31,6 +34,7 @@ __export(responses_exports, {
   LLMConfigSchema: () => LLMConfigSchema,
   McpServerConfigSchema: () => import_core5.McpServerConfigSchema,
   MemorySchema: () => import_core2.MemorySchema,
+  MessageSearchResponseSchema: () => MessageSearchResponseSchema,
   ModelFlatSchema: () => ModelFlatSchema,
   OkResponseSchema: () => OkResponseSchema,
   PromptArgumentSchema: () => PromptArgumentSchema,
@@ -41,11 +45,14 @@ __export(responses_exports, {
   ResourceSchema: () => ResourceSchema,
   SearchResultSchema: () => SearchResultSchema,
   SessionMetadataSchema: () => SessionMetadataSchema,
+  SessionSearchResponseSchema: () => SessionSearchResponseSchema,
   SessionSearchResultSchema: () => SessionSearchResultSchema,
   SseServerConfigSchema: () => import_core5.SseServerConfigSchema,
   StatusResponseSchema: () => StatusResponseSchema,
   StdioServerConfigSchema: () => import_core5.StdioServerConfigSchema,
+  TextPartSchema: () => TextPartSchema,
   TokenUsageSchema: () => TokenUsageSchema,
+  ToolCallSchema: () => ToolCallSchema,
   ToolConfirmationConfigSchema: () => import_core6.ToolConfirmationConfigSchema,
   ToolSchema: () => ToolSchema,
   WebhookSchema: () => WebhookSchema
@@ -59,35 +66,18 @@ var import_core4 = require("@dexto/core");
 var import_core5 = require("@dexto/core");
 var import_core6 = require("@dexto/core");
 var import_core7 = require("@dexto/core");
-const LLMConfigResponseSchema = import_core.LLMConfigBaseSchema.omit({ apiKey: true }).extend({
-  hasApiKey: import_zod.z.boolean().optional().describe("Whether an API key is configured")
-}).describe("LLM configuration (apiKey omitted for security)");
-const LLMConfigSchema = import_core.LLMConfigBaseSchema.describe("LLM configuration with API key");
-const BinaryDataSchema = import_zod.z.custom(
-  (val) => {
-    return typeof val === "string" || val instanceof Buffer || val instanceof Uint8Array || val instanceof URL;
-  },
-  { message: "Must be string, Buffer, Uint8Array, or URL" }
-);
-const SessionMetadataSchema = import_zod.z.object({
-  id: import_zod.z.string().describe("Unique session identifier"),
-  createdAt: import_zod.z.number().int().positive().nullable().describe("Creation timestamp (Unix ms, null if unavailable)"),
-  lastActivity: import_zod.z.number().int().positive().nullable().describe("Last activity timestamp (Unix ms, null if unavailable)"),
-  messageCount: import_zod.z.number().int().nonnegative().describe("Total number of messages in session"),
-  title: import_zod.z.string().optional().nullable().describe("Optional session title")
-}).strict().describe("Session metadata");
 const TextPartSchema = import_zod.z.object({
   type: import_zod.z.literal("text").describe("Part type: text"),
   text: import_zod.z.string().describe("Text content")
 }).strict().describe("Text content part");
 const ImagePartSchema = import_zod.z.object({
   type: import_zod.z.literal("image").describe("Part type: image"),
-  image: BinaryDataSchema.describe("Image data (string, binary, or URL)"),
+  image: import_zod.z.string().describe("Base64-encoded image data"),
   mimeType: import_zod.z.string().optional().describe("MIME type of the image")
 }).strict().describe("Image content part");
 const FilePartSchema = import_zod.z.object({
   type: import_zod.z.literal("file").describe("Part type: file"),
-  data: BinaryDataSchema.describe("File data (string, binary, or URL)"),
+  data: import_zod.z.string().describe("Base64-encoded file data"),
   mimeType: import_zod.z.string().describe("MIME type of the file"),
   filename: import_zod.z.string().optional().describe("Optional filename")
 }).strict().describe("File content part");
@@ -107,18 +97,30 @@ const TokenUsageSchema = import_zod.z.object({
   totalTokens: import_zod.z.number().int().nonnegative().optional().describe("Total tokens used")
 }).strict().describe("Token usage accounting");
 const InternalMessageSchema = import_zod.z.object({
+  id: import_zod.z.string().uuid().optional().describe("Unique message identifier (UUID)"),
   role: import_zod.z.enum(["system", "user", "assistant", "tool"]).describe("Role of the message sender"),
   timestamp: import_zod.z.number().int().positive().optional().describe("Creation timestamp (Unix ms)"),
   content: import_zod.z.union([import_zod.z.string(), import_zod.z.null(), import_zod.z.array(ContentPartSchema)]).describe("Message content (string, null, or array of parts)"),
   reasoning: import_zod.z.string().optional().describe("Optional model reasoning text"),
   tokenUsage: TokenUsageSchema.optional().describe("Optional token usage accounting"),
   model: import_zod.z.string().optional().describe("Model identifier for assistant messages"),
-  provider: import_zod.z.string().optional().describe("Provider identifier for assistant messages"),
-  router: import_zod.z.string().optional().describe("Router metadata for assistant messages"),
+  provider: import_zod.z.enum(import_core.LLM_PROVIDERS).optional().describe("Provider identifier for assistant messages"),
+  router: import_zod.z.enum(import_core.LLM_ROUTERS).optional().describe("Router metadata for assistant messages"),
   toolCalls: import_zod.z.array(ToolCallSchema).optional().describe("Tool calls made by the assistant"),
   toolCallId: import_zod.z.string().optional().describe("ID of the tool call this message responds to"),
   name: import_zod.z.string().optional().describe("Name of the tool that produced this result")
 }).strict().describe("Internal message representation");
+const LLMConfigResponseSchema = import_core.LLMConfigBaseSchema.omit({ apiKey: true }).extend({
+  hasApiKey: import_zod.z.boolean().optional().describe("Whether an API key is configured")
+}).describe("LLM configuration (apiKey omitted for security)");
+const LLMConfigSchema = import_core.LLMConfigBaseSchema.describe("LLM configuration with API key");
+const SessionMetadataSchema = import_zod.z.object({
+  id: import_zod.z.string().describe("Unique session identifier"),
+  createdAt: import_zod.z.number().int().positive().nullable().describe("Creation timestamp (Unix ms, null if unavailable)"),
+  lastActivity: import_zod.z.number().int().positive().nullable().describe("Last activity timestamp (Unix ms, null if unavailable)"),
+  messageCount: import_zod.z.number().int().nonnegative().describe("Total number of messages in session"),
+  title: import_zod.z.string().optional().nullable().describe("Optional session title")
+}).strict().describe("Session metadata");
 const SearchResultSchema = import_zod.z.object({
   sessionId: import_zod.z.string().describe("Session ID where the message was found"),
   message: InternalMessageSchema.describe("The message that matched the search"),
@@ -136,6 +138,20 @@ const SessionSearchResultSchema = import_zod.z.object({
     messageCount: import_zod.z.number().int().nonnegative().describe("Total messages in session")
   }).strict().describe("Session metadata")
 }).strict().describe("Result of a session search");
+const MessageSearchResponseSchema = import_zod.z.object({
+  results: import_zod.z.array(SearchResultSchema).describe("Array of search results"),
+  total: import_zod.z.number().int().nonnegative().describe("Total number of results available"),
+  hasMore: import_zod.z.boolean().describe("Whether there are more results beyond the current page"),
+  query: import_zod.z.string().describe("Query that was searched")
+}).strict().describe("Message search response");
+const SessionSearchResponseSchema = import_zod.z.object({
+  results: import_zod.z.array(SessionSearchResultSchema).describe("Array of session search results"),
+  total: import_zod.z.number().int().nonnegative().describe("Total number of sessions with matches"),
+  hasMore: import_zod.z.boolean().describe(
+    "Always false - session search returns all matching sessions without pagination"
+  ),
+  query: import_zod.z.string().describe("Query that was searched")
+}).strict().describe("Session search response");
 const WebhookSchema = import_zod.z.object({
   id: import_zod.z.string().describe("Unique webhook identifier"),
   url: import_zod.z.string().url().describe("Webhook URL to send events to"),
@@ -210,7 +226,7 @@ const PromptInfoSchema = import_zod.z.object({
   title: import_zod.z.string().optional().describe("Prompt title"),
   description: import_zod.z.string().optional().describe("Prompt description"),
   arguments: import_zod.z.array(PromptArgumentSchema).optional().describe("Array of argument definitions"),
-  source: import_zod.z.enum(["mcp", "file", "starter", "custom"]).describe("Source of the prompt"),
+  source: import_zod.z.enum(["mcp", "config", "custom"]).describe("Source of the prompt"),
   metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Additional metadata")
 }).strict().describe("Enhanced prompt information");
 const PromptSchema = import_zod.z.object({
@@ -245,9 +261,12 @@ const DeleteResponseSchema = import_zod.z.object({
   AgentCardSchema,
   AgentRegistryEntrySchema,
   CatalogModelInfoSchema,
+  ContentPartSchema,
   DeleteResponseSchema,
   ErrorResponseSchema,
+  FilePartSchema,
   HttpServerConfigSchema,
+  ImagePartSchema,
   InternalMessageSchema,
   InternalResourceConfigSchema,
   LLMConfigBaseSchema,
@@ -255,6 +274,7 @@ const DeleteResponseSchema = import_zod.z.object({
   LLMConfigSchema,
   McpServerConfigSchema,
   MemorySchema,
+  MessageSearchResponseSchema,
   ModelFlatSchema,
   OkResponseSchema,
   PromptArgumentSchema,
@@ -265,11 +285,14 @@ const DeleteResponseSchema = import_zod.z.object({
   ResourceSchema,
   SearchResultSchema,
   SessionMetadataSchema,
+  SessionSearchResponseSchema,
   SessionSearchResultSchema,
   SseServerConfigSchema,
   StatusResponseSchema,
   StdioServerConfigSchema,
+  TextPartSchema,
   TokenUsageSchema,
+  ToolCallSchema,
   ToolConfirmationConfigSchema,
   ToolSchema,
   WebhookSchema