@dexto/server 1.2.6 → 1.3.0

package/dist/hono/routes/messages.cjs

@@ -29,11 +29,11 @@ const MessageBodySchema = import_zod_openapi.z.object({
   message: import_zod_openapi.z.string().optional().describe("The user message text"),
   sessionId: import_zod_openapi.z.string().min(1, "Session ID is required").describe("The session to use for this message"),
   imageData: import_zod_openapi.z.object({
-    base64: import_zod_openapi.z.string().describe("Base64-encoded image data"),
+    image: import_zod_openapi.z.string().describe("Base64-encoded image data"),
     mimeType: import_zod_openapi.z.string().describe("The MIME type of the image (e.g., image/png)")
   }).optional().describe("Optional image data to include with the message"),
   fileData: import_zod_openapi.z.object({
-    base64: import_zod_openapi.z.string().describe("Base64-encoded file data"),
+    data: import_zod_openapi.z.string().describe("Base64-encoded file data"),
     mimeType: import_zod_openapi.z.string().describe("The MIME type of the file (e.g., application/pdf)"),
     filename: import_zod_openapi.z.string().optional().describe("The filename")
   }).optional().describe("Optional file data to include with the message")
@@ -174,9 +174,9 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     const agent = getAgent();
     agent.logger.info("Received message via POST /api/message");
     const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
+    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
     const fileDataInput = fileData ? {
-      data: fileData.base64,
+      data: fileData.data,
       mimeType: fileData.mimeType,
       ...fileData.filename && { filename: fileData.filename }
     } : void 0;
@@ -193,9 +193,9 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     const agent = getAgent();
     agent.logger.info("Received message via POST /api/message-sync");
     const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
+    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
     const fileDataInput = fileData ? {
-      data: fileData.base64,
+      data: fileData.data,
       mimeType: fileData.mimeType,
       ...fileData.filename && { filename: fileData.filename }
     } : void 0;
@@ -228,9 +228,9 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     const agent = getAgent();
     const body = ctx.req.valid("json");
     const { message = "", sessionId, imageData, fileData } = body;
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
+    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
     const fileDataInput = fileData ? {
-      data: fileData.base64,
+      data: fileData.data,
       mimeType: fileData.mimeType,
       ...fileData.filename && { filename: fileData.filename }
     } : void 0;
@@ -277,7 +277,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               data: JSON.stringify(approvalEvent.data)
             });
           }
-          const eventData = event.type === "llm:error" && event.error instanceof Error ? {
+          const eventData = event.name === "llm:error" && event.error instanceof Error ? {
             ...event,
             error: {
               message: event.error.message,
@@ -286,7 +286,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
             }
           } : event;
           await stream.writeSSE({
-            event: event.type,
+            event: event.name,
             data: JSON.stringify(eventData)
           });
         }

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

@@ -9,12 +9,12 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     sessionId: string;
                     message?: string | undefined;
                     imageData?: {
+                        image: string;
                         mimeType: string;
-                        base64: string;
                     } | undefined;
                     fileData?: {
                         mimeType: string;
-                        base64: string;
+                        data: string;
                         filename?: string | undefined;
                     } | undefined;
                 };
@@ -31,12 +31,12 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     sessionId: string;
                     message?: string | undefined;
                     imageData?: {
+                        image: string;
                         mimeType: string;
-                        base64: string;
                     } | undefined;
                     fileData?: {
                         mimeType: string;
-                        base64: string;
+                        data: string;
                         filename?: string | undefined;
                     } | undefined;
                 };
@@ -54,12 +54,12 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     sessionId: string;
                     message?: string | undefined;
                     imageData?: {
+                        image: string;
                         mimeType: string;
-                        base64: string;
                     } | undefined;
                     fileData?: {
                         mimeType: string;
-                        base64: string;
+                        data: string;
                         filename?: string | undefined;
                     } | undefined;
                 };
@@ -73,12 +73,12 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     sessionId: string;
                     message?: string | undefined;
                     imageData?: {
+                        image: string;
                         mimeType: string;
-                        base64: string;
                     } | undefined;
                     fileData?: {
                         mimeType: string;
-                        base64: string;
+                        data: string;
                         filename?: string | undefined;
                     } | undefined;
                 };
@@ -86,9 +86,6 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
             output: {
                 sessionId: string;
                 response: string;
-                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
-                model?: string | undefined;
-                router?: "vercel" | "in-built" | undefined;
                 reasoning?: string | undefined;
                 tokenUsage?: {
                     inputTokens?: number | undefined;
@@ -96,6 +93,9 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     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;
             };
             outputFormat: "json";
             status: 200;
@@ -125,12 +125,12 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     sessionId: string;
                     message?: string | undefined;
                     imageData?: {
+                        image: string;
                         mimeType: string;
-                        base64: string;
                     } | undefined;
                     fileData?: {
                         mimeType: string;
-                        base64: string;
+                        data: string;
                         filename?: string | undefined;
                     } | undefined;
                 };
@@ -144,12 +144,12 @@ export declare function createMessagesRouter(getAgent: () => DextoAgent, approva
                     sessionId: string;
                     message?: string | undefined;
                     imageData?: {
+                        image: string;
                         mimeType: string;
-                        base64: string;
                     } | undefined;
                     fileData?: {
                         mimeType: string;
-                        base64: string;
+                        data: string;
                         filename?: string | undefined;
                     } | undefined;
                 };

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

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AA4ClF,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,MAAM,UAAU,EAC1B,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmW5C"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AA4ClF,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,MAAM,UAAU,EAC1B,mBAAmB,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoW5C"}

package/dist/hono/routes/messages.js

@@ -6,11 +6,11 @@ const MessageBodySchema = z.object({
   message: z.string().optional().describe("The user message text"),
   sessionId: z.string().min(1, "Session ID is required").describe("The session to use for this message"),
   imageData: z.object({
-    base64: z.string().describe("Base64-encoded image data"),
+    image: z.string().describe("Base64-encoded image data"),
     mimeType: z.string().describe("The MIME type of the image (e.g., image/png)")
   }).optional().describe("Optional image data to include with the message"),
   fileData: z.object({
-    base64: z.string().describe("Base64-encoded file data"),
+    data: z.string().describe("Base64-encoded file data"),
     mimeType: z.string().describe("The MIME type of the file (e.g., application/pdf)"),
     filename: z.string().optional().describe("The filename")
   }).optional().describe("Optional file data to include with the message")
@@ -151,9 +151,9 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     const agent = getAgent();
     agent.logger.info("Received message via POST /api/message");
     const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
+    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
     const fileDataInput = fileData ? {
-      data: fileData.base64,
+      data: fileData.data,
       mimeType: fileData.mimeType,
       ...fileData.filename && { filename: fileData.filename }
     } : void 0;
@@ -170,9 +170,9 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     const agent = getAgent();
     agent.logger.info("Received message via POST /api/message-sync");
     const { message, sessionId, imageData, fileData } = ctx.req.valid("json");
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
+    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
     const fileDataInput = fileData ? {
-      data: fileData.base64,
+      data: fileData.data,
       mimeType: fileData.mimeType,
       ...fileData.filename && { filename: fileData.filename }
     } : void 0;
@@ -205,9 +205,9 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
     const agent = getAgent();
     const body = ctx.req.valid("json");
     const { message = "", sessionId, imageData, fileData } = body;
-    const imageDataInput = imageData ? { image: imageData.base64, mimeType: imageData.mimeType } : void 0;
+    const imageDataInput = imageData ? { image: imageData.image, mimeType: imageData.mimeType } : void 0;
     const fileDataInput = fileData ? {
-      data: fileData.base64,
+      data: fileData.data,
       mimeType: fileData.mimeType,
       ...fileData.filename && { filename: fileData.filename }
     } : void 0;
@@ -254,7 +254,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
               data: JSON.stringify(approvalEvent.data)
             });
           }
-          const eventData = event.type === "llm:error" && event.error instanceof Error ? {
+          const eventData = event.name === "llm:error" && event.error instanceof Error ? {
             ...event,
             error: {
               message: event.error.message,
@@ -263,7 +263,7 @@ function createMessagesRouter(getAgent, approvalCoordinator) {
             }
           } : event;
           await stream.writeSSE({
-            event: event.type,
+            event: event.name,
             data: JSON.stringify(eventData)
           });
         }

package/dist/hono/routes/prompts.cjs

@@ -37,7 +37,7 @@ const CustomPromptRequestSchema = import_zod_openapi.z.object({
     }).strict()
   ).optional().describe("Array of argument definitions"),
   resource: import_zod_openapi.z.object({
-    base64: import_zod_openapi.z.string().min(1, "Resource data is required").describe("Base64-encoded resource data"),
+    data: import_zod_openapi.z.string().min(1, "Resource data is required").describe("Base64-encoded resource data"),
     mimeType: import_zod_openapi.z.string().min(1, "Resource MIME type is required").describe("MIME type of the resource (e.g., text/plain, application/pdf)"),
     filename: import_zod_openapi.z.string().optional().describe("Resource filename")
   }).strict().optional().describe("Attach a resource to this prompt")
@@ -182,7 +182,7 @@ function createPromptsRouter(getAgent) {
       ...promptArguments && promptArguments.length > 0 ? { arguments: promptArguments } : {},
       ...payload.resource ? {
         resource: {
-          base64: payload.resource.base64,
+          data: payload.resource.data,
           mimeType: payload.resource.mimeType,
           ...payload.resource.filename ? { filename: payload.resource.filename } : {}
         }

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

@@ -40,7 +40,7 @@ export declare function createPromptsRouter(getAgent: () => DextoAgent): OpenAPI
                     }[] | undefined;
                     resource?: {
                         mimeType: string;
-                        base64: string;
+                        data: string;
                         filename?: string | undefined;
                     } | undefined;
                 };

package/dist/hono/routes/prompts.js

@@ -14,7 +14,7 @@ const CustomPromptRequestSchema = z.object({
     }).strict()
   ).optional().describe("Array of argument definitions"),
   resource: z.object({
-    base64: z.string().min(1, "Resource data is required").describe("Base64-encoded resource data"),
+    data: z.string().min(1, "Resource data is required").describe("Base64-encoded resource data"),
     mimeType: z.string().min(1, "Resource MIME type is required").describe("MIME type of the resource (e.g., text/plain, application/pdf)"),
     filename: z.string().optional().describe("Resource filename")
   }).strict().optional().describe("Attach a resource to this prompt")
@@ -159,7 +159,7 @@ function createPromptsRouter(getAgent) {
       ...promptArguments && promptArguments.length > 0 ? { arguments: promptArguments } : {},
       ...payload.resource ? {
         resource: {
-          base64: payload.resource.base64,
+          data: payload.resource.data,
           mimeType: payload.resource.mimeType,
           ...payload.resource.filename ? { filename: payload.resource.filename } : {}
         }

package/dist/hono/routes/search.cjs

@@ -45,18 +45,7 @@ function createSearchRouter(getAgent) {
     responses: {
       200: {
         description: "Message search results",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              results: import_zod_openapi.z.array(import_responses.SearchResultSchema).describe("Array of search results"),
-              total: import_zod_openapi.z.number().int().nonnegative().describe("Total number of results available"),
-              hasMore: import_zod_openapi.z.boolean().describe(
-                "Whether there are more results beyond the current page"
-              ),
-              query: import_zod_openapi.z.string().describe("Query that was searched")
-            }).strict().describe("Message search response")
-          }
-        }
+        content: { "application/json": { schema: import_responses.MessageSearchResponseSchema } }
       }
     }
   });
@@ -70,18 +59,7 @@ function createSearchRouter(getAgent) {
     responses: {
       200: {
         description: "Session search results",
-        content: {
-          "application/json": {
-            schema: import_zod_openapi.z.object({
-              results: import_zod_openapi.z.array(import_responses.SessionSearchResultSchema).describe("Array of session search results"),
-              total: import_zod_openapi.z.number().int().nonnegative().describe("Total number of sessions with matches"),
-              hasMore: import_zod_openapi.z.boolean().describe(
-                "Always false - session search returns all matching sessions without pagination"
-              ),
-              query: import_zod_openapi.z.string().describe("Query that was searched")
-            }).strict().describe("Session search response")
-          }
-        }
+        content: { "application/json": { schema: import_responses.SessionSearchResponseSchema } }
       }
     }
   });

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

@@ -21,18 +21,16 @@ 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;
                         })[] | 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 +40,9 @@ 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;
+                        router?: "vercel" | "in-built" | undefined;
                         toolCalls?: {
                             function: {
                                 name: string;
@@ -84,18 +85,16 @@ 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;
                             })[] | 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 +104,9 @@ 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;
+                            router?: "vercel" | "in-built" | undefined;
                             toolCalls?: {
                                 function: {
                                     name: string;

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.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"}