@dexto/server 1.2.6 → 1.4.0

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

@@ -21,18 +21,29 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             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;
+                        } | {
+                            type: "ui-resource";
+                            mimeType: string;
+                            uri: string;
+                            content?: string | undefined;
+                            blob?: string | undefined;
+                            metadata?: {
+                                title?: string | undefined;
+                                preferredSize?: {
+                                    width: number;
+                                    height: number;
+                                } | undefined;
+                            } | 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;
@@ -42,6 +53,8 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             reasoningTokens?: number | undefined;
                             totalTokens?: number | undefined;
                         } | undefined;
+                        model?: string | undefined;
+                        provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
                         toolCalls?: {
                             function: {
                                 name: string;
@@ -51,6 +64,7 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                             id: string;
                         }[] | undefined;
                         toolCallId?: string | undefined;
+                        success?: boolean | undefined;
                     };
                     sessionId: string;
                     matchedText: string;
@@ -76,6 +90,11 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                 query: string;
                 results: {
                     sessionId: string;
+                    metadata: {
+                        createdAt: number;
+                        lastActivity: number;
+                        messageCount: number;
+                    };
                     matchCount: number;
                     firstMatch: {
                         message: {
@@ -84,18 +103,29 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 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;
+                            } | {
+                                type: "ui-resource";
+                                mimeType: string;
+                                uri: string;
+                                content?: string | undefined;
+                                blob?: string | undefined;
+                                metadata?: {
+                                    title?: string | undefined;
+                                    preferredSize?: {
+                                        width: number;
+                                        height: number;
+                                    } | undefined;
+                                } | 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;
@@ -105,6 +135,8 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 reasoningTokens?: number | undefined;
                                 totalTokens?: number | undefined;
                             } | undefined;
+                            model?: string | undefined;
+                            provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
                             toolCalls?: {
                                 function: {
                                     name: string;
@@ -114,17 +146,13 @@ export declare function createSearchRouter(getAgent: () => DextoAgent): OpenAPIH
                                 id: string;
                             }[] | undefined;
                             toolCallId?: string | undefined;
+                            success?: boolean | undefined;
                         };
                         sessionId: string;
                         matchedText: string;
                         context: string;
                         messageIndex: number;
                     };
-                    metadata: {
-                        createdAt: number;
-                        lastActivity: number;
-                        messageCount: number;
-                    };
                 }[];
                 total: number;
                 hasMore: boolean;

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

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

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.cjs

@@ -95,7 +95,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/history",
     summary: "Get Session History",
-    description: "Retrieves the conversation history for a session",
+    description: "Retrieves the conversation history for a session along with processing status",
     tags: ["sessions"],
     request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
     responses: {
@@ -104,7 +104,10 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: import_zod_openapi.z.object({
-              history: import_zod_openapi.z.array(import_responses.InternalMessageSchema).describe("Array of messages in conversation history")
+              history: import_zod_openapi.z.array(import_responses.InternalMessageSchema).describe("Array of messages in conversation history"),
+              isBusy: import_zod_openapi.z.boolean().describe(
+                "Whether the session is currently processing a message"
+              )
             }).strict()
           }
         }
@@ -136,9 +139,23 @@ function createSessionsRouter(getAgent) {
     method: "post",
     path: "/sessions/{sessionId}/cancel",
     summary: "Cancel Session Run",
-    description: "Cancels an in-flight agent run for the specified session",
+    description: "Cancels an in-flight agent run for the specified session. By default (soft cancel), only the current LLM call is cancelled and queued messages continue processing. Set clearQueue=true for hard cancel to also clear any queued messages.",
     tags: ["sessions"],
-    request: { params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }) },
+    request: {
+      params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") }),
+      body: {
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              clearQueue: import_zod_openapi.z.boolean().optional().default(false).describe(
+                "If true (hard cancel), clears queued messages. If false (soft cancel, default), queued messages continue processing."
+              )
+            }).strict()
+          }
+        },
+        required: false
+      }
+    },
     responses: {
       200: {
         description: "Cancel operation result",
@@ -146,7 +163,11 @@ function createSessionsRouter(getAgent) {
           "application/json": {
             schema: import_zod_openapi.z.object({
               cancelled: import_zod_openapi.z.boolean().describe("Whether a run was cancelled"),
-              sessionId: import_zod_openapi.z.string().describe("Session ID")
+              sessionId: import_zod_openapi.z.string().describe("Session ID"),
+              queueCleared: import_zod_openapi.z.boolean().describe("Whether queued messages were cleared"),
+              clearedCount: import_zod_openapi.z.number().describe(
+                "Number of queued messages cleared (0 if soft cancel)"
+              )
             }).strict()
           }
         }
@@ -157,7 +178,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/load",
     summary: "Load Session",
-    description: "Validates and retrieves session information. The client should track the active session.",
+    description: "Validates and retrieves session information including processing status. The client should track the active session.",
     tags: ["sessions"],
     request: {
       params: import_zod_openapi.z.object({ sessionId: import_zod_openapi.z.string().describe("Session identifier") })
@@ -168,7 +189,11 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: import_zod_openapi.z.object({
-              session: import_responses.SessionMetadataSchema.describe("Session metadata")
+              session: import_responses.SessionMetadataSchema.extend({
+                isBusy: import_zod_openapi.z.boolean().describe(
+                  "Whether the session is currently processing a message"
+                )
+              }).describe("Session metadata with processing status")
             }).strict()
           }
         }
@@ -303,8 +328,14 @@ function createSessionsRouter(getAgent) {
   }).openapi(historyRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.param();
-    const history = await agent.getSessionHistory(sessionId);
-    return ctx.json({ history });
+    const [history, isBusy] = await Promise.all([
+      agent.getSessionHistory(sessionId),
+      agent.isSessionBusy(sessionId)
+    ]);
+    return ctx.json({
+      history,
+      isBusy
+    });
   }).openapi(deleteRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.param();
@@ -313,11 +344,32 @@ function createSessionsRouter(getAgent) {
   }).openapi(cancelRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("param");
+    let clearQueue = false;
+    try {
+      const body = ctx.req.valid("json");
+      clearQueue = body?.clearQueue ?? false;
+    } catch {
+    }
+    let clearedCount = 0;
+    if (clearQueue) {
+      try {
+        clearedCount = await agent.clearMessageQueue(sessionId);
+        agent.logger.debug(
+          `Hard cancel: cleared ${clearedCount} queued message(s) for session: ${sessionId}`
+        );
+      } catch {
+      }
+    }
     const cancelled = await agent.cancel(sessionId);
     if (!cancelled) {
       agent.logger.debug(`No in-flight run to cancel for session: ${sessionId}`);
     }
-    return ctx.json({ cancelled, sessionId });
+    return ctx.json({
+      cancelled,
+      sessionId,
+      queueCleared: clearQueue,
+      clearedCount
+    });
   }).openapi(loadRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("param");
@@ -326,6 +378,7 @@ function createSessionsRouter(getAgent) {
       return ctx.json({ error: `Session not found: ${sessionId}` }, 404);
     }
     const metadata = await agent.getSessionMetadata(sessionId);
+    const isBusy = await agent.isSessionBusy(sessionId);
     return ctx.json(
       {
         session: {
@@ -333,7 +386,8 @@ function createSessionsRouter(getAgent) {
           createdAt: metadata?.createdAt || null,
           lastActivity: metadata?.lastActivity || null,
           messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null
+          title: metadata?.title || null,
+          isBusy
         }
       },
       200

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

@@ -75,18 +75,29 @@ 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;
+                    } | {
+                        type: "ui-resource";
+                        mimeType: string;
+                        uri: string;
+                        content?: string | undefined;
+                        blob?: string | undefined;
+                        metadata?: {
+                            title?: string | undefined;
+                            preferredSize?: {
+                                width: number;
+                                height: number;
+                            } | undefined;
+                        } | 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 +107,8 @@ 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;
                     toolCalls?: {
                         function: {
                             name: string;
@@ -105,7 +118,9 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                         id: string;
                     }[] | undefined;
                     toolCallId?: string | undefined;
+                    success?: boolean | undefined;
                 }[];
+                isBusy: boolean;
             };
             outputFormat: "json";
             status: 200;
@@ -134,10 +149,16 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                 param: {
                     sessionId: string;
                 };
+            } & {
+                json: {
+                    clearQueue?: boolean | undefined;
+                };
             };
             output: {
                 sessionId: string;
                 cancelled: boolean;
+                queueCleared: boolean;
+                clearedCount: number;
             };
             outputFormat: "json";
             status: 200;
@@ -157,6 +178,7 @@ export declare function createSessionsRouter(getAgent: () => DextoAgent): OpenAP
                     createdAt: number | null;
                     lastActivity: number | null;
                     messageCount: number;
+                    isBusy: boolean;
                     title?: string | null | undefined;
                 };
             };

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAie9D"}

package/dist/hono/routes/sessions.js

@@ -72,7 +72,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/history",
     summary: "Get Session History",
-    description: "Retrieves the conversation history for a session",
+    description: "Retrieves the conversation history for a session along with processing status",
     tags: ["sessions"],
     request: { params: z.object({ sessionId: z.string().describe("Session identifier") }) },
     responses: {
@@ -81,7 +81,10 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: z.object({
-              history: z.array(InternalMessageSchema).describe("Array of messages in conversation history")
+              history: z.array(InternalMessageSchema).describe("Array of messages in conversation history"),
+              isBusy: z.boolean().describe(
+                "Whether the session is currently processing a message"
+              )
             }).strict()
           }
         }
@@ -113,9 +116,23 @@ function createSessionsRouter(getAgent) {
     method: "post",
     path: "/sessions/{sessionId}/cancel",
     summary: "Cancel Session Run",
-    description: "Cancels an in-flight agent run for the specified session",
+    description: "Cancels an in-flight agent run for the specified session. By default (soft cancel), only the current LLM call is cancelled and queued messages continue processing. Set clearQueue=true for hard cancel to also clear any queued messages.",
     tags: ["sessions"],
-    request: { params: z.object({ sessionId: z.string().describe("Session identifier") }) },
+    request: {
+      params: z.object({ sessionId: z.string().describe("Session identifier") }),
+      body: {
+        content: {
+          "application/json": {
+            schema: z.object({
+              clearQueue: z.boolean().optional().default(false).describe(
+                "If true (hard cancel), clears queued messages. If false (soft cancel, default), queued messages continue processing."
+              )
+            }).strict()
+          }
+        },
+        required: false
+      }
+    },
     responses: {
       200: {
         description: "Cancel operation result",
@@ -123,7 +140,11 @@ function createSessionsRouter(getAgent) {
           "application/json": {
             schema: z.object({
               cancelled: z.boolean().describe("Whether a run was cancelled"),
-              sessionId: z.string().describe("Session ID")
+              sessionId: z.string().describe("Session ID"),
+              queueCleared: z.boolean().describe("Whether queued messages were cleared"),
+              clearedCount: z.number().describe(
+                "Number of queued messages cleared (0 if soft cancel)"
+              )
             }).strict()
           }
         }
@@ -134,7 +155,7 @@ function createSessionsRouter(getAgent) {
     method: "get",
     path: "/sessions/{sessionId}/load",
     summary: "Load Session",
-    description: "Validates and retrieves session information. The client should track the active session.",
+    description: "Validates and retrieves session information including processing status. The client should track the active session.",
     tags: ["sessions"],
     request: {
       params: z.object({ sessionId: z.string().describe("Session identifier") })
@@ -145,7 +166,11 @@ function createSessionsRouter(getAgent) {
         content: {
           "application/json": {
             schema: z.object({
-              session: SessionMetadataSchema.describe("Session metadata")
+              session: SessionMetadataSchema.extend({
+                isBusy: z.boolean().describe(
+                  "Whether the session is currently processing a message"
+                )
+              }).describe("Session metadata with processing status")
             }).strict()
           }
         }
@@ -280,8 +305,14 @@ function createSessionsRouter(getAgent) {
   }).openapi(historyRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.param();
-    const history = await agent.getSessionHistory(sessionId);
-    return ctx.json({ history });
+    const [history, isBusy] = await Promise.all([
+      agent.getSessionHistory(sessionId),
+      agent.isSessionBusy(sessionId)
+    ]);
+    return ctx.json({
+      history,
+      isBusy
+    });
   }).openapi(deleteRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.param();
@@ -290,11 +321,32 @@ function createSessionsRouter(getAgent) {
   }).openapi(cancelRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("param");
+    let clearQueue = false;
+    try {
+      const body = ctx.req.valid("json");
+      clearQueue = body?.clearQueue ?? false;
+    } catch {
+    }
+    let clearedCount = 0;
+    if (clearQueue) {
+      try {
+        clearedCount = await agent.clearMessageQueue(sessionId);
+        agent.logger.debug(
+          `Hard cancel: cleared ${clearedCount} queued message(s) for session: ${sessionId}`
+        );
+      } catch {
+      }
+    }
     const cancelled = await agent.cancel(sessionId);
     if (!cancelled) {
       agent.logger.debug(`No in-flight run to cancel for session: ${sessionId}`);
     }
-    return ctx.json({ cancelled, sessionId });
+    return ctx.json({
+      cancelled,
+      sessionId,
+      queueCleared: clearQueue,
+      clearedCount
+    });
   }).openapi(loadRoute, async (ctx) => {
     const agent = getAgent();
     const { sessionId } = ctx.req.valid("param");
@@ -303,6 +355,7 @@ function createSessionsRouter(getAgent) {
       return ctx.json({ error: `Session not found: ${sessionId}` }, 404);
     }
     const metadata = await agent.getSessionMetadata(sessionId);
+    const isBusy = await agent.isSessionBusy(sessionId);
     return ctx.json(
       {
         session: {
@@ -310,7 +363,8 @@ function createSessionsRouter(getAgent) {
           createdAt: metadata?.createdAt || null,
           lastActivity: metadata?.lastActivity || null,
           messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null
+          title: metadata?.title || null,
+          isBusy
         }
       },
       200

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
+});