@dexto/server 1.5.7 → 1.6.0

package/dist/hono/routes/mcp.cjs

@@ -29,7 +29,11 @@ const McpServerRequestSchema = import_zod_openapi.z.object({
   name: import_zod_openapi.z.string().min(1, "Server name is required").describe("A unique name for the server"),
   config: import_core.McpServerConfigSchema.describe("The server configuration object"),
   persistToAgent: import_zod_openapi.z.boolean().optional().describe("If true, saves the server to agent configuration file")
-}).describe("Request body for adding or updating an MCP server");
+}).strict().describe("Request body for adding or updating an MCP server");
+const McpServerUpdateSchema = import_zod_openapi.z.object({
+  config: import_core.McpServerConfigSchema.describe("The updated server configuration object"),
+  persistToAgent: import_zod_openapi.z.boolean().optional().describe("If true, saves the server to agent configuration file")
+}).strict().describe("Request body for updating an MCP server");
 const ExecuteToolBodySchema = import_zod_openapi.z.record(import_zod_openapi.z.unknown()).describe(
   "Tool execution parameters as JSON object. The specific fields depend on the tool being executed and are defined by the tool's inputSchema."
 );
@@ -60,7 +64,8 @@ const ToolInfoSchema = import_zod_openapi.z.object({
   id: import_zod_openapi.z.string().describe("Tool identifier"),
   name: import_zod_openapi.z.string().describe("Tool name"),
   description: import_zod_openapi.z.string().describe("Tool description"),
-  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters")
+  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters"),
+  _meta: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional tool metadata (e.g., MCP Apps UI resource info)")
 }).strict().describe("Tool information");
 const ToolsListResponseSchema = import_zod_openapi.z.object({
   tools: import_zod_openapi.z.array(ToolInfoSchema).describe("Array of available tools")
@@ -78,6 +83,10 @@ const ToolExecutionResponseSchema = import_zod_openapi.z.object({
   data: import_zod_openapi.z.any().optional().describe("Tool execution result data"),
   error: import_zod_openapi.z.string().optional().describe("Error message if execution failed")
 }).strict().describe("Tool execution response");
+const ServerConfigResponseSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe("Server name"),
+  config: import_core.McpServerConfigSchema.describe("Server configuration")
+}).strict().describe("MCP server configuration response");
 const ResourcesListResponseSchema = import_zod_openapi.z.object({
   success: import_zod_openapi.z.boolean().describe("Success indicator"),
   resources: import_zod_openapi.z.array(import_responses.ResourceSchema).describe("Array of available resources")
@@ -89,7 +98,7 @@ const ResourceContentResponseSchema = import_zod_openapi.z.object({
   success: import_zod_openapi.z.boolean().describe("Success indicator"),
   data: ResourceContentSchema.describe("Resource content")
 }).strict().describe("Resource content response");
-function createMcpRouter(getAgent) {
+function createMcpRouter(getAgent, getAgentConfigPath) {
   const app = new import_zod_openapi.OpenAPIHono();
   const addServerRoute = (0, import_zod_openapi.createRoute)({
     method: "post",
@@ -118,6 +127,41 @@ function createMcpRouter(getAgent) {
       }
     }
   });
+  const getServerConfigRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/mcp/servers/{serverId}/config",
+    summary: "Get MCP Server Config",
+    description: "Retrieves the configuration for a specific MCP server",
+    tags: ["mcp"],
+    request: {
+      params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") })
+    },
+    responses: {
+      200: {
+        description: "Server configuration",
+        content: { "application/json": { schema: ServerConfigResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const updateServerRoute = (0, import_zod_openapi.createRoute)({
+    method: "put",
+    path: "/mcp/servers/{serverId}",
+    summary: "Update MCP Server",
+    description: "Updates configuration for an existing MCP server",
+    tags: ["mcp"],
+    request: {
+      params: import_zod_openapi.z.object({ serverId: import_zod_openapi.z.string().describe("The ID of the MCP server") }),
+      body: { content: { "application/json": { schema: McpServerUpdateSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Server updated",
+        content: { "application/json": { schema: ServerStatusResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
   const toolsRoute = (0, import_zod_openapi.createRoute)({
     method: "get",
     path: "/mcp/servers/{serverId}/tools",
@@ -237,6 +281,10 @@ function createMcpRouter(getAgent) {
     );
     if (persistToAgent === true) {
       try {
+        const agentPath = await getAgentConfigPath(ctx);
+        if (!agentPath) {
+          throw import_core.AgentError.noConfigPath();
+        }
         const currentConfig = agent.getEffectiveConfig();
         const updates = {
           mcpServers: {
@@ -244,16 +292,7 @@ function createMcpRouter(getAgent) {
             [name]: config
           }
         };
-        const newConfig = await (0, import_agent_management.updateAgentConfigFile)(
-          agent.getAgentFilePath(),
-          updates
-        );
-        const reloadResult = await agent.reload(newConfig);
-        if (reloadResult.restarted) {
-          import_core.logger.info(
-            `Agent restarted to apply changes: ${reloadResult.changesApplied.join(", ")}`
-          );
-        }
+        await (0, import_agent_management.updateAgentConfigFile)(agentPath, updates);
         import_core.logger.info(`Saved server '${name}' to agent configuration file`);
       } catch (saveError) {
         const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
@@ -279,6 +318,48 @@ function createMcpRouter(getAgent) {
       servers.push({ id: name, name, status: "error" });
     }
     return ctx.json({ servers });
+  }).openapi(getServerConfigRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { serverId } = ctx.req.valid("param");
+    const config = agent.getMcpServerConfig(serverId);
+    if (!config) {
+      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+    }
+    return ctx.json({ name: serverId, config }, 200);
+  }).openapi(updateServerRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { serverId } = ctx.req.valid("param");
+    const { config, persistToAgent } = ctx.req.valid("json");
+    const existingConfig = agent.getMcpServerConfig(serverId);
+    if (!existingConfig) {
+      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+    }
+    await agent.updateMcpServer(serverId, config);
+    if (persistToAgent === true) {
+      try {
+        const agentPath = await getAgentConfigPath(ctx);
+        if (!agentPath) {
+          throw import_core.AgentError.noConfigPath();
+        }
+        const currentConfig = agent.getEffectiveConfig();
+        const updates = {
+          mcpServers: {
+            ...currentConfig.mcpServers || {},
+            [serverId]: config
+          }
+        };
+        await (0, import_agent_management.updateAgentConfigFile)(agentPath, updates);
+        import_core.logger.info(`Saved server '${serverId}' to agent configuration file`);
+      } catch (saveError) {
+        const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
+        import_core.logger.warn(
+          `Failed to persist MCP server '${serverId}' update: ${errorMessage}`,
+          { error: saveError }
+        );
+      }
+    }
+    const status = config.enabled === false ? "registered" : "connected";
+    return ctx.json({ status, name: serverId }, 200);
   }).openapi(toolsRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
@@ -291,7 +372,8 @@ function createMcpRouter(getAgent) {
       id: toolName,
       name: toolName,
       description: toolDef.description || "",
-      inputSchema: toolDef.parameters
+      inputSchema: toolDef.parameters,
+      _meta: toolDef._meta
     }));
     return ctx.json({ tools });
   }).openapi(deleteServerRoute, async (ctx) => {

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

@@ -1,6 +1,6 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
-import type { GetAgentFn } from '../index.js';
-export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
+import type { GetAgentConfigPathFn, GetAgentFn } from '../index.js';
+export declare function createMcpRouter(getAgent: GetAgentFn, getAgentConfigPath: GetAgentConfigPathFn): OpenAPIHono<import("hono").Env, {
     "/mcp/servers": {
         $post: {
             input: {
@@ -55,6 +55,138 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
             status: 200;
         };
     };
+} & {
+    "/mcp/servers/:serverId/config": {
+        $get: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {
+                config: {
+                    timeout: number;
+                    type: "stdio";
+                    enabled: boolean;
+                    command: string;
+                    args: string[];
+                    env: {
+                        [x: string]: string;
+                    };
+                    connectionMode: "strict" | "lenient";
+                } | {
+                    timeout: number;
+                    type: "sse";
+                    enabled: boolean;
+                    connectionMode: "strict" | "lenient";
+                    url: string;
+                    headers: {
+                        [x: string]: string;
+                    };
+                } | {
+                    timeout: number;
+                    type: "http";
+                    enabled: boolean;
+                    connectionMode: "strict" | "lenient";
+                    url: string;
+                    headers: {
+                        [x: string]: string;
+                    };
+                };
+                name: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId": {
+        $put: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            } & {
+                json: {
+                    config: {
+                        type: "stdio";
+                        command: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        args?: string[] | undefined;
+                        env?: Record<string, string> | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                    } | {
+                        type: "sse";
+                        url: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    } | {
+                        type: "http";
+                        url: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    };
+                    persistToAgent?: boolean | undefined;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            } & {
+                json: {
+                    config: {
+                        type: "stdio";
+                        command: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        args?: string[] | undefined;
+                        env?: Record<string, string> | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                    } | {
+                        type: "sse";
+                        url: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    } | {
+                        type: "http";
+                        url: string;
+                        timeout?: number | undefined;
+                        enabled?: boolean | undefined;
+                        connectionMode?: "strict" | "lenient" | undefined;
+                        headers?: Record<string, string> | undefined;
+                    };
+                    persistToAgent?: boolean | undefined;
+                };
+            };
+            output: {
+                status: string;
+                name: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
 } & {
     "/mcp/servers/:serverId/tools": {
         $get: {
@@ -91,6 +223,9 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                         } | undefined;
                         required?: string[] | undefined;
                     } | undefined;
+                    _meta?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
                 }[];
             };
             outputFormat: "json";
@@ -197,7 +332,6 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                 };
             };
             output: {
-                success: boolean;
                 resources: {
                     uri: string;
                     source: "mcp" | "internal";
@@ -211,6 +345,7 @@ export declare function createMcpRouter(getAgent: GetAgentFn): OpenAPIHono<impor
                     size?: number | undefined;
                     lastModified?: string | undefined;
                 }[];
+                success: boolean;
             };
             outputFormat: "json";
             status: 200;

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

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAIhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAuI9C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkTnD"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAIhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA+JpE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,kBAAkB,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAuY7F"}

package/dist/hono/routes/mcp.js

@@ -1,12 +1,16 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { logger, McpServerConfigSchema, MCP_CONNECTION_STATUSES } from "@dexto/core";
+import { AgentError, logger, McpServerConfigSchema, MCP_CONNECTION_STATUSES } from "@dexto/core";
 import { updateAgentConfigFile } from "@dexto/agent-management";
 import { ResourceSchema } from "../schemas/responses.js";
 const McpServerRequestSchema = z.object({
   name: z.string().min(1, "Server name is required").describe("A unique name for the server"),
   config: McpServerConfigSchema.describe("The server configuration object"),
   persistToAgent: z.boolean().optional().describe("If true, saves the server to agent configuration file")
-}).describe("Request body for adding or updating an MCP server");
+}).strict().describe("Request body for adding or updating an MCP server");
+const McpServerUpdateSchema = z.object({
+  config: McpServerConfigSchema.describe("The updated server configuration object"),
+  persistToAgent: z.boolean().optional().describe("If true, saves the server to agent configuration file")
+}).strict().describe("Request body for updating an MCP server");
 const ExecuteToolBodySchema = z.record(z.unknown()).describe(
   "Tool execution parameters as JSON object. The specific fields depend on the tool being executed and are defined by the tool's inputSchema."
 );
@@ -37,7 +41,8 @@ const ToolInfoSchema = z.object({
   id: z.string().describe("Tool identifier"),
   name: z.string().describe("Tool name"),
   description: z.string().describe("Tool description"),
-  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters")
+  inputSchema: ToolInputSchema.optional().describe("JSON Schema for tool input parameters"),
+  _meta: z.record(z.unknown()).optional().describe("Optional tool metadata (e.g., MCP Apps UI resource info)")
 }).strict().describe("Tool information");
 const ToolsListResponseSchema = z.object({
   tools: z.array(ToolInfoSchema).describe("Array of available tools")
@@ -55,6 +60,10 @@ const ToolExecutionResponseSchema = z.object({
   data: z.any().optional().describe("Tool execution result data"),
   error: z.string().optional().describe("Error message if execution failed")
 }).strict().describe("Tool execution response");
+const ServerConfigResponseSchema = z.object({
+  name: z.string().describe("Server name"),
+  config: McpServerConfigSchema.describe("Server configuration")
+}).strict().describe("MCP server configuration response");
 const ResourcesListResponseSchema = z.object({
   success: z.boolean().describe("Success indicator"),
   resources: z.array(ResourceSchema).describe("Array of available resources")
@@ -66,7 +75,7 @@ const ResourceContentResponseSchema = z.object({
   success: z.boolean().describe("Success indicator"),
   data: ResourceContentSchema.describe("Resource content")
 }).strict().describe("Resource content response");
-function createMcpRouter(getAgent) {
+function createMcpRouter(getAgent, getAgentConfigPath) {
   const app = new OpenAPIHono();
   const addServerRoute = createRoute({
     method: "post",
@@ -95,6 +104,41 @@ function createMcpRouter(getAgent) {
       }
     }
   });
+  const getServerConfigRoute = createRoute({
+    method: "get",
+    path: "/mcp/servers/{serverId}/config",
+    summary: "Get MCP Server Config",
+    description: "Retrieves the configuration for a specific MCP server",
+    tags: ["mcp"],
+    request: {
+      params: z.object({ serverId: z.string().describe("The ID of the MCP server") })
+    },
+    responses: {
+      200: {
+        description: "Server configuration",
+        content: { "application/json": { schema: ServerConfigResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const updateServerRoute = createRoute({
+    method: "put",
+    path: "/mcp/servers/{serverId}",
+    summary: "Update MCP Server",
+    description: "Updates configuration for an existing MCP server",
+    tags: ["mcp"],
+    request: {
+      params: z.object({ serverId: z.string().describe("The ID of the MCP server") }),
+      body: { content: { "application/json": { schema: McpServerUpdateSchema } } }
+    },
+    responses: {
+      200: {
+        description: "Server updated",
+        content: { "application/json": { schema: ServerStatusResponseSchema } }
+      },
+      404: { description: "Not found" }
+    }
+  });
   const toolsRoute = createRoute({
     method: "get",
     path: "/mcp/servers/{serverId}/tools",
@@ -214,6 +258,10 @@ function createMcpRouter(getAgent) {
     );
     if (persistToAgent === true) {
       try {
+        const agentPath = await getAgentConfigPath(ctx);
+        if (!agentPath) {
+          throw AgentError.noConfigPath();
+        }
         const currentConfig = agent.getEffectiveConfig();
         const updates = {
           mcpServers: {
@@ -221,16 +269,7 @@ function createMcpRouter(getAgent) {
             [name]: config
           }
         };
-        const newConfig = await updateAgentConfigFile(
-          agent.getAgentFilePath(),
-          updates
-        );
-        const reloadResult = await agent.reload(newConfig);
-        if (reloadResult.restarted) {
-          logger.info(
-            `Agent restarted to apply changes: ${reloadResult.changesApplied.join(", ")}`
-          );
-        }
+        await updateAgentConfigFile(agentPath, updates);
         logger.info(`Saved server '${name}' to agent configuration file`);
       } catch (saveError) {
         const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
@@ -256,6 +295,48 @@ function createMcpRouter(getAgent) {
       servers.push({ id: name, name, status: "error" });
     }
     return ctx.json({ servers });
+  }).openapi(getServerConfigRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { serverId } = ctx.req.valid("param");
+    const config = agent.getMcpServerConfig(serverId);
+    if (!config) {
+      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+    }
+    return ctx.json({ name: serverId, config }, 200);
+  }).openapi(updateServerRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const { serverId } = ctx.req.valid("param");
+    const { config, persistToAgent } = ctx.req.valid("json");
+    const existingConfig = agent.getMcpServerConfig(serverId);
+    if (!existingConfig) {
+      return ctx.json({ error: `Server '${serverId}' not found.` }, 404);
+    }
+    await agent.updateMcpServer(serverId, config);
+    if (persistToAgent === true) {
+      try {
+        const agentPath = await getAgentConfigPath(ctx);
+        if (!agentPath) {
+          throw AgentError.noConfigPath();
+        }
+        const currentConfig = agent.getEffectiveConfig();
+        const updates = {
+          mcpServers: {
+            ...currentConfig.mcpServers || {},
+            [serverId]: config
+          }
+        };
+        await updateAgentConfigFile(agentPath, updates);
+        logger.info(`Saved server '${serverId}' to agent configuration file`);
+      } catch (saveError) {
+        const errorMessage = saveError instanceof Error ? saveError.message : String(saveError);
+        logger.warn(
+          `Failed to persist MCP server '${serverId}' update: ${errorMessage}`,
+          { error: saveError }
+        );
+      }
+    }
+    const status = config.enabled === false ? "registered" : "connected";
+    return ctx.json({ status, name: serverId }, 200);
   }).openapi(toolsRoute, async (ctx) => {
     const agent = await getAgent(ctx);
     const { serverId } = ctx.req.valid("param");
@@ -268,7 +349,8 @@ function createMcpRouter(getAgent) {
       id: toolName,
       name: toolName,
       description: toolDef.description || "",
-      inputSchema: toolDef.parameters
+      inputSchema: toolDef.parameters,
+      _meta: toolDef._meta
     }));
     return ctx.json({ tools });
   }).openapi(deleteServerRoute, async (ctx) => {

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

@@ -19,8 +19,8 @@ export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<im
                 ok: true;
                 memory: {
                     content: string;
-                    createdAt: number;
                     id: string;
+                    createdAt: number;
                     updatedAt: number;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
@@ -49,8 +49,8 @@ export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<im
             output: {
                 memories: {
                     content: string;
-                    createdAt: number;
                     id: string;
+                    createdAt: number;
                     updatedAt: number;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
@@ -77,8 +77,8 @@ export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<im
                 ok: true;
                 memory: {
                     content: string;
-                    createdAt: number;
                     id: string;
+                    createdAt: number;
                     updatedAt: number;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
@@ -113,8 +113,8 @@ export declare function createMemoryRouter(getAgent: GetAgentFn): OpenAPIHono<im
                 ok: true;
                 memory: {
                     content: string;
-                    createdAt: number;
                     id: string;
+                    createdAt: number;
                     updatedAt: number;
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;

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

@@ -106,7 +106,7 @@ export declare function createMessagesRouter(getAgent: GetAgentFn, approvalCoord
                     totalTokens?: number | undefined;
                 } | undefined;
                 model?: string | undefined;
-                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto" | undefined;
+                provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "minimax" | "glm" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama" | "dexto-nova" | undefined;
             };
             outputFormat: "json";
             status: 200;

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

@@ -15,7 +15,7 @@ export declare function createModelsRouter(): OpenAPIHono<import("hono").Env, {
                     displayName: string;
                     filePath: string;
                     sizeBytes: number;
-                    source?: "manual" | "huggingface" | undefined;
+                    source?: "huggingface" | "manual" | undefined;
                     contextLength?: number | undefined;
                 }[];
             };

package/dist/hono/routes/queue.cjs

@@ -27,7 +27,8 @@ const QueuedMessageSchema = import_zod_openapi.z.object({
   id: import_zod_openapi.z.string().describe("Unique identifier for the queued message"),
   content: import_zod_openapi.z.array(import_responses.ContentPartSchema).describe("Message content parts"),
   queuedAt: import_zod_openapi.z.number().describe("Unix timestamp when message was queued"),
-  metadata: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional metadata")
+  metadata: import_zod_openapi.z.record(import_zod_openapi.z.unknown()).optional().describe("Optional metadata"),
+  kind: import_zod_openapi.z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).strict().describe("A message waiting in the queue");
 const TextPartSchema = import_zod_openapi.z.object({
   type: import_zod_openapi.z.literal("text").describe("Content type identifier"),
@@ -46,7 +47,8 @@ const FilePartSchema = import_zod_openapi.z.object({
 }).describe("File content part");
 const QueueContentPartSchema = import_zod_openapi.z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Content part - text, image, or file");
 const QueueMessageBodySchema = import_zod_openapi.z.object({
-  content: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(QueueContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal")
+  content: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(QueueContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal"),
+  kind: import_zod_openapi.z.enum(["default", "background"]).optional().describe("Optional queued message kind")
 }).describe("Request body for queueing a message");
 function createQueueRouter(getAgent) {
   const app = new import_zod_openapi.OpenAPIHono();
@@ -172,7 +174,11 @@ function createQueueRouter(getAgent) {
     const { sessionId } = ctx.req.valid("param");
     const { content: rawContent } = ctx.req.valid("json");
     const content = typeof rawContent === "string" ? [{ type: "text", text: rawContent }] : rawContent;
-    const result = await agent.queueMessage(sessionId, { content });
+    const { kind } = ctx.req.valid("json");
+    const result = await agent.queueMessage(sessionId, {
+      content,
+      ...kind !== void 0 && { kind }
+    });
     return ctx.json(
       {
         queued: result.queued,

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

@@ -52,6 +52,7 @@ export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                     metadata?: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | undefined;
+                    kind?: "default" | "background" | undefined;
                 }[];
                 count: number;
             };
@@ -81,6 +82,7 @@ export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                         data: string;
                         filename?: string | undefined;
                     })[];
+                    kind?: "default" | "background" | undefined;
                 };
             };
             output: {};
@@ -106,6 +108,7 @@ export declare function createQueueRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                         data: string;
                         filename?: string | undefined;
                     })[];
+                    kind?: "default" | "background" | undefined;
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAqDrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoLrD"}
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAuDrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwLrD"}