@dexto/server 1.5.8 → 1.6.1

package/dist/hono/routes/sessions.js

@@ -256,7 +256,8 @@ function createSessionsRouter(getAgent) {
             createdAt: metadata?.createdAt || null,
             lastActivity: metadata?.lastActivity || null,
             messageCount: metadata?.messageCount || 0,
-            title: metadata?.title || null
+            title: metadata?.title || null,
+            workspaceId: metadata?.workspaceId || null
           };
         } catch {
           return {
@@ -264,7 +265,8 @@ function createSessionsRouter(getAgent) {
             createdAt: null,
             lastActivity: null,
             messageCount: 0,
-            title: null
+            title: null,
+            workspaceId: null
           };
         }
       })
@@ -282,7 +284,8 @@ function createSessionsRouter(getAgent) {
           createdAt: metadata?.createdAt || Date.now(),
           lastActivity: metadata?.lastActivity || Date.now(),
           messageCount: metadata?.messageCount || 0,
-          title: metadata?.title || null
+          title: metadata?.title || null,
+          workspaceId: metadata?.workspaceId || null
         }
       },
       201
@@ -299,6 +302,7 @@ function createSessionsRouter(getAgent) {
         lastActivity: metadata?.lastActivity || null,
         messageCount: metadata?.messageCount || 0,
         title: metadata?.title || null,
+        workspaceId: metadata?.workspaceId || null,
         history: history.length
       }
     });
@@ -364,6 +368,7 @@ function createSessionsRouter(getAgent) {
           lastActivity: metadata?.lastActivity || null,
           messageCount: metadata?.messageCount || 0,
           title: metadata?.title || null,
+          workspaceId: metadata?.workspaceId || null,
           isBusy
         }
       },
@@ -381,7 +386,8 @@ function createSessionsRouter(getAgent) {
         createdAt: metadata?.createdAt || null,
         lastActivity: metadata?.lastActivity || null,
         messageCount: metadata?.messageCount || 0,
-        title: metadata?.title || title
+        title: metadata?.title || title,
+        workspaceId: metadata?.workspaceId || null
       }
     });
   }).openapi(generateTitleRoute, async (ctx) => {

package/dist/hono/routes/tools.cjs

@@ -37,15 +37,15 @@ 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"),
-  source: import_zod_openapi.z.enum(["internal", "custom", "mcp"]).describe("Source of the tool (internal, custom, or mcp)"),
+  source: import_zod_openapi.z.enum(["local", "mcp"]).describe("Source of the tool (local or mcp)"),
   serverName: import_zod_openapi.z.string().optional().describe("MCP server name (if source is mcp)"),
-  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 AllToolsResponseSchema = import_zod_openapi.z.object({
   tools: import_zod_openapi.z.array(ToolInfoSchema).describe("Array of all available tools"),
   totalCount: import_zod_openapi.z.number().describe("Total number of tools"),
-  internalCount: import_zod_openapi.z.number().describe("Number of internal tools"),
-  customCount: import_zod_openapi.z.number().describe("Number of custom tools"),
+  localCount: import_zod_openapi.z.number().describe("Number of local tools"),
   mcpCount: import_zod_openapi.z.number().describe("Number of MCP tools")
 }).strict().describe("All available tools from all sources");
 function createToolsRouter(getAgent) {
@@ -54,7 +54,7 @@ function createToolsRouter(getAgent) {
     method: "get",
     path: "/tools",
     summary: "List All Tools",
-    description: "Retrieves all available tools from all sources (internal, custom, and MCP servers)",
+    description: "Retrieves all available tools from all sources (local and MCP)",
     tags: ["tools"],
     responses: {
       200: {
@@ -68,8 +68,7 @@ function createToolsRouter(getAgent) {
     const allTools = await agent.getAllTools();
     const mcpToolsWithServerInfo = agent.getAllMcpToolsWithServerInfo();
     const toolList = [];
-    let internalCount = 0;
-    let customCount = 0;
+    let localCount = 0;
     let mcpCount = 0;
     for (const [toolName, toolInfo] of Object.entries(allTools)) {
       let source;
@@ -85,15 +84,9 @@ function createToolsRouter(getAgent) {
           source = "mcp";
           mcpCount++;
         }
-      } else if (toolName.startsWith("internal--")) {
-        source = "internal";
-        internalCount++;
-      } else if (toolName.startsWith("custom--")) {
-        source = "custom";
-        customCount++;
       } else {
-        source = "internal";
-        internalCount++;
+        source = "local";
+        localCount++;
       }
       toolList.push({
         id: toolName,
@@ -101,11 +94,12 @@ function createToolsRouter(getAgent) {
         description: toolInfo.description || "No description available",
         source,
         serverName,
-        inputSchema: toolInfo.parameters
+        inputSchema: toolInfo.parameters,
+        _meta: toolInfo._meta
       });
     }
     toolList.sort((a, b) => {
-      const sourceOrder = { internal: 0, custom: 1, mcp: 2 };
+      const sourceOrder = { local: 0, mcp: 1 };
       if (a.source !== b.source) {
         return sourceOrder[a.source] - sourceOrder[b.source];
       }
@@ -114,8 +108,7 @@ function createToolsRouter(getAgent) {
     return ctx.json({
       tools: toolList,
       totalCount: toolList.length,
-      internalCount,
-      customCount,
+      localCount,
       mcpCount
     });
   });

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

@@ -11,7 +11,7 @@ export declare function createToolsRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                     description: string;
                     id: string;
                     name: string;
-                    source: "custom" | "mcp" | "internal";
+                    source: "local" | "mcp";
                     serverName?: string | undefined;
                     inputSchema?: {
                         [x: string]: import("hono/utils/types").JSONValue;
@@ -27,10 +27,12 @@ export declare function createToolsRouter(getAgent: GetAgentFn): OpenAPIHono<imp
                         } | undefined;
                         required?: string[] | undefined;
                     } | undefined;
+                    _meta?: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | undefined;
                 }[];
                 totalCount: number;
-                internalCount: number;
-                customCount: number;
+                localCount: number;
                 mcpCount: number;
             };
             outputFormat: "json";

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

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0FrD"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAsDrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkFrD"}

package/dist/hono/routes/tools.js

@@ -14,15 +14,15 @@ const ToolInfoSchema = z.object({
   id: z.string().describe("Tool identifier"),
   name: z.string().describe("Tool name"),
   description: z.string().describe("Tool description"),
-  source: z.enum(["internal", "custom", "mcp"]).describe("Source of the tool (internal, custom, or mcp)"),
+  source: z.enum(["local", "mcp"]).describe("Source of the tool (local or mcp)"),
   serverName: z.string().optional().describe("MCP server name (if source is mcp)"),
-  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 AllToolsResponseSchema = z.object({
   tools: z.array(ToolInfoSchema).describe("Array of all available tools"),
   totalCount: z.number().describe("Total number of tools"),
-  internalCount: z.number().describe("Number of internal tools"),
-  customCount: z.number().describe("Number of custom tools"),
+  localCount: z.number().describe("Number of local tools"),
   mcpCount: z.number().describe("Number of MCP tools")
 }).strict().describe("All available tools from all sources");
 function createToolsRouter(getAgent) {
@@ -31,7 +31,7 @@ function createToolsRouter(getAgent) {
     method: "get",
     path: "/tools",
     summary: "List All Tools",
-    description: "Retrieves all available tools from all sources (internal, custom, and MCP servers)",
+    description: "Retrieves all available tools from all sources (local and MCP)",
     tags: ["tools"],
     responses: {
       200: {
@@ -45,8 +45,7 @@ function createToolsRouter(getAgent) {
     const allTools = await agent.getAllTools();
     const mcpToolsWithServerInfo = agent.getAllMcpToolsWithServerInfo();
     const toolList = [];
-    let internalCount = 0;
-    let customCount = 0;
+    let localCount = 0;
     let mcpCount = 0;
     for (const [toolName, toolInfo] of Object.entries(allTools)) {
       let source;
@@ -62,15 +61,9 @@ function createToolsRouter(getAgent) {
           source = "mcp";
           mcpCount++;
         }
-      } else if (toolName.startsWith("internal--")) {
-        source = "internal";
-        internalCount++;
-      } else if (toolName.startsWith("custom--")) {
-        source = "custom";
-        customCount++;
       } else {
-        source = "internal";
-        internalCount++;
+        source = "local";
+        localCount++;
       }
       toolList.push({
         id: toolName,
@@ -78,11 +71,12 @@ function createToolsRouter(getAgent) {
         description: toolInfo.description || "No description available",
         source,
         serverName,
-        inputSchema: toolInfo.parameters
+        inputSchema: toolInfo.parameters,
+        _meta: toolInfo._meta
       });
     }
     toolList.sort((a, b) => {
-      const sourceOrder = { internal: 0, custom: 1, mcp: 2 };
+      const sourceOrder = { local: 0, mcp: 1 };
       if (a.source !== b.source) {
         return sourceOrder[a.source] - sourceOrder[b.source];
       }
@@ -91,8 +85,7 @@ function createToolsRouter(getAgent) {
     return ctx.json({
       tools: toolList,
       totalCount: toolList.length,
-      internalCount,
-      customCount,
+      localCount,
       mcpCount
     });
   });

package/dist/hono/routes/workspaces.cjs

@@ -0,0 +1,136 @@
+"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 workspaces_exports = {};
+__export(workspaces_exports, {
+  createWorkspacesRouter: () => createWorkspacesRouter
+});
+module.exports = __toCommonJS(workspaces_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_responses = require("../schemas/responses.js");
+const SetWorkspaceSchema = import_zod_openapi.z.object({
+  path: import_zod_openapi.z.string().min(1).describe("Absolute workspace root path"),
+  name: import_zod_openapi.z.string().optional().describe("Optional workspace display name")
+}).strict().describe("Request body for setting the active workspace");
+function createWorkspacesRouter(getAgent) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const listRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/workspaces",
+    summary: "List Workspaces",
+    description: "Retrieves all known workspaces",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "List of workspaces",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              workspaces: import_zod_openapi.z.array(import_responses.WorkspaceSchema).describe("Workspace list")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const getActiveRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/workspaces/active",
+    summary: "Get Active Workspace",
+    description: "Returns the active workspace, if any",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "Active workspace",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              workspace: import_responses.WorkspaceSchema.nullable().describe(
+                "Active workspace or null if none is set"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const setActiveRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/workspaces/active",
+    summary: "Set Active Workspace",
+    description: "Sets the active workspace for this runtime",
+    tags: ["workspaces"],
+    request: { body: { content: { "application/json": { schema: SetWorkspaceSchema } } } },
+    responses: {
+      200: {
+        description: "Active workspace updated",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              workspace: import_responses.WorkspaceSchema.describe("Updated active workspace")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const clearActiveRoute = (0, import_zod_openapi.createRoute)({
+    method: "delete",
+    path: "/workspaces/active",
+    summary: "Clear Active Workspace",
+    description: "Clears the active workspace for this runtime",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "Active workspace cleared",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              workspace: import_responses.WorkspaceSchema.nullable().describe(
+                "Active workspace or null if none is set"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const workspaces = await agent.listWorkspaces();
+    return ctx.json({ workspaces });
+  }).openapi(getActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const workspace = await agent.getWorkspace();
+    return ctx.json({ workspace: workspace ?? null });
+  }).openapi(setActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const input = ctx.req.valid("json");
+    const workspaceInput = input.name === void 0 ? { path: input.path } : { path: input.path, name: input.name };
+    const workspace = await agent.setWorkspace(workspaceInput);
+    return ctx.json({ workspace });
+  }).openapi(clearActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    await agent.clearWorkspace();
+    return ctx.json({ workspace: null });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWorkspacesRouter
+});

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

@@ -0,0 +1,77 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { GetAgentFn } from '../index.js';
+export declare function createWorkspacesRouter(getAgent: GetAgentFn): OpenAPIHono<import("hono").Env, {
+    "/workspaces": {
+        $get: {
+            input: {};
+            output: {
+                workspaces: {
+                    path: string;
+                    id: string;
+                    createdAt: number;
+                    lastActiveAt: number;
+                    name?: string | null | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/workspaces/active": {
+        $get: {
+            input: {};
+            output: {
+                workspace: {
+                    path: string;
+                    id: string;
+                    createdAt: number;
+                    lastActiveAt: number;
+                    name?: string | null | undefined;
+                } | null;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/workspaces/active": {
+        $post: {
+            input: {
+                json: {
+                    path: string;
+                    name?: string | undefined;
+                };
+            };
+            output: {
+                workspace: {
+                    path: string;
+                    id: string;
+                    createdAt: number;
+                    lastActiveAt: number;
+                    name?: string | null | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/workspaces/active": {
+        $delete: {
+            input: {};
+            output: {
+                workspace: {
+                    path: string;
+                    id: string;
+                    createdAt: number;
+                    lastActiveAt: number;
+                    name?: string | null | undefined;
+                } | null;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=workspaces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/workspaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAU9C,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0H1D"}

package/dist/hono/routes/workspaces.js

@@ -0,0 +1,112 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { WorkspaceSchema } from "../schemas/responses.js";
+const SetWorkspaceSchema = z.object({
+  path: z.string().min(1).describe("Absolute workspace root path"),
+  name: z.string().optional().describe("Optional workspace display name")
+}).strict().describe("Request body for setting the active workspace");
+function createWorkspacesRouter(getAgent) {
+  const app = new OpenAPIHono();
+  const listRoute = createRoute({
+    method: "get",
+    path: "/workspaces",
+    summary: "List Workspaces",
+    description: "Retrieves all known workspaces",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "List of workspaces",
+        content: {
+          "application/json": {
+            schema: z.object({
+              workspaces: z.array(WorkspaceSchema).describe("Workspace list")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const getActiveRoute = createRoute({
+    method: "get",
+    path: "/workspaces/active",
+    summary: "Get Active Workspace",
+    description: "Returns the active workspace, if any",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "Active workspace",
+        content: {
+          "application/json": {
+            schema: z.object({
+              workspace: WorkspaceSchema.nullable().describe(
+                "Active workspace or null if none is set"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const setActiveRoute = createRoute({
+    method: "post",
+    path: "/workspaces/active",
+    summary: "Set Active Workspace",
+    description: "Sets the active workspace for this runtime",
+    tags: ["workspaces"],
+    request: { body: { content: { "application/json": { schema: SetWorkspaceSchema } } } },
+    responses: {
+      200: {
+        description: "Active workspace updated",
+        content: {
+          "application/json": {
+            schema: z.object({
+              workspace: WorkspaceSchema.describe("Updated active workspace")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const clearActiveRoute = createRoute({
+    method: "delete",
+    path: "/workspaces/active",
+    summary: "Clear Active Workspace",
+    description: "Clears the active workspace for this runtime",
+    tags: ["workspaces"],
+    responses: {
+      200: {
+        description: "Active workspace cleared",
+        content: {
+          "application/json": {
+            schema: z.object({
+              workspace: WorkspaceSchema.nullable().describe(
+                "Active workspace or null if none is set"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  return app.openapi(listRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const workspaces = await agent.listWorkspaces();
+    return ctx.json({ workspaces });
+  }).openapi(getActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const workspace = await agent.getWorkspace();
+    return ctx.json({ workspace: workspace ?? null });
+  }).openapi(setActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    const input = ctx.req.valid("json");
+    const workspaceInput = input.name === void 0 ? { path: input.path } : { path: input.path, name: input.name };
+    const workspace = await agent.setWorkspace(workspaceInput);
+    return ctx.json({ workspace });
+  }).openapi(clearActiveRoute, async (ctx) => {
+    const agent = await getAgent(ctx);
+    await agent.clearWorkspace();
+    return ctx.json({ workspace: null });
+  });
+}
+export {
+  createWorkspacesRouter
+};