@mastra/server 1.0.4 → 1.1.0-alpha.1

package/dist/chunk-QWOQET2T.js

@@ -0,0 +1,689 @@
+import { listWorkspacesResponseSchema, workspaceInfoResponseSchema, workspaceIdPathParams, fsReadResponseSchema, fsReadQuerySchema, fsWriteResponseSchema, fsWriteBodySchema, fsListResponseSchema, fsListQuerySchema, fsDeleteResponseSchema, fsDeleteQuerySchema, fsMkdirResponseSchema, fsMkdirBodySchema, fsStatResponseSchema, fsStatQuerySchema, searchResponseSchema, searchQuerySchema, indexResponseSchema, indexBodySchema, listSkillsResponseSchema, getSkillResponseSchema, skillNamePathParams, listReferencesResponseSchema, skillReferenceResponseSchema, skillReferencePathParams, searchSkillsResponseSchema, searchSkillsQuerySchema } from './chunk-GDWZ2R7I.js';
+import { handleError } from './chunk-ONN5EA7E.js';
+import { createRoute } from './chunk-D5VCL56B.js';
+import { HTTPException } from './chunk-6QWQZI4Q.js';
+import { coreFeatures } from '@mastra/core/features';
+
+function requireWorkspaceV1Support() {
+  if (!coreFeatures.has("workspaces-v1")) {
+    throw new HTTPException(501, {
+      message: "Workspace v1 not supported by this version of @mastra/core. Please upgrade to a newer version."
+    });
+  }
+}
+async function getWorkspaceById(mastra, workspaceId) {
+  requireWorkspaceV1Support();
+  const globalWorkspace = mastra.getWorkspace?.();
+  if (!workspaceId) {
+    return globalWorkspace;
+  }
+  if (globalWorkspace?.id === workspaceId) {
+    return globalWorkspace;
+  }
+  const agents = mastra.listAgents?.() ?? {};
+  for (const agent of Object.values(agents)) {
+    if (agent.hasOwnWorkspace?.()) {
+      const agentWorkspace = await agent.getWorkspace?.();
+      if (agentWorkspace?.id === workspaceId) {
+        return agentWorkspace;
+      }
+    }
+  }
+  return void 0;
+}
+async function getSkillsById(mastra, workspaceId) {
+  const workspace = await getWorkspaceById(mastra, workspaceId);
+  return workspace?.skills;
+}
+var LIST_WORKSPACES_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces",
+  responseType: "json",
+  responseSchema: listWorkspacesResponseSchema,
+  summary: "List all workspaces",
+  description: "Returns all workspaces from both Mastra instance and agents",
+  tags: ["Workspace"],
+  handler: async ({ mastra }) => {
+    try {
+      requireWorkspaceV1Support();
+      const workspaces = [];
+      const seenIds = /* @__PURE__ */ new Set();
+      const globalWorkspace = mastra.getWorkspace?.();
+      if (globalWorkspace) {
+        seenIds.add(globalWorkspace.id);
+        workspaces.push({
+          id: globalWorkspace.id,
+          name: globalWorkspace.name,
+          status: globalWorkspace.status,
+          source: "mastra",
+          capabilities: {
+            hasFilesystem: !!globalWorkspace.fs,
+            hasSandbox: !!globalWorkspace.sandbox,
+            canBM25: globalWorkspace.canBM25,
+            canVector: globalWorkspace.canVector,
+            canHybrid: globalWorkspace.canHybrid,
+            hasSkills: !!globalWorkspace.skills
+          },
+          safety: {
+            readOnly: globalWorkspace.filesystem?.readOnly ?? false
+          }
+        });
+      }
+      const agents = mastra.listAgents?.() ?? {};
+      for (const [agentId, agent] of Object.entries(agents)) {
+        if (agent.hasOwnWorkspace?.()) {
+          try {
+            const agentWorkspace = await agent.getWorkspace?.();
+            if (agentWorkspace && !seenIds.has(agentWorkspace.id)) {
+              seenIds.add(agentWorkspace.id);
+              workspaces.push({
+                id: agentWorkspace.id,
+                name: agentWorkspace.name,
+                status: agentWorkspace.status,
+                source: "agent",
+                agentId,
+                agentName: agent.name,
+                capabilities: {
+                  hasFilesystem: !!agentWorkspace.fs,
+                  hasSandbox: !!agentWorkspace.sandbox,
+                  canBM25: agentWorkspace.canBM25,
+                  canVector: agentWorkspace.canVector,
+                  canHybrid: agentWorkspace.canHybrid,
+                  hasSkills: !!agentWorkspace.skills
+                },
+                safety: {
+                  readOnly: agentWorkspace.filesystem?.readOnly ?? false
+                }
+              });
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+      return { workspaces };
+    } catch (error) {
+      return handleError(error, "Error listing workspaces");
+    }
+  }
+});
+var GET_WORKSPACE_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  responseSchema: workspaceInfoResponseSchema,
+  summary: "Get workspace info",
+  description: "Returns information about a specific workspace and its capabilities",
+  tags: ["Workspace"],
+  handler: async ({ mastra, workspaceId }) => {
+    try {
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace) {
+        return {
+          isWorkspaceConfigured: false
+        };
+      }
+      return {
+        isWorkspaceConfigured: true,
+        id: workspace.id,
+        name: workspace.name,
+        status: workspace.status,
+        capabilities: {
+          hasFilesystem: !!workspace.fs,
+          hasSandbox: !!workspace.sandbox,
+          canBM25: workspace.canBM25,
+          canVector: workspace.canVector,
+          canHybrid: workspace.canHybrid,
+          hasSkills: !!workspace.skills
+        },
+        safety: {
+          readOnly: workspace.filesystem?.readOnly ?? false
+        }
+      };
+    } catch (error) {
+      return handleError(error, "Error getting workspace info");
+    }
+  }
+});
+var WORKSPACE_FS_READ_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/fs/read",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  queryParamSchema: fsReadQuerySchema,
+  responseSchema: fsReadResponseSchema,
+  summary: "Read file content",
+  description: "Returns the content of a file at the specified path",
+  tags: ["Workspace"],
+  handler: async ({ mastra, path, encoding, workspaceId }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!path) {
+        throw new HTTPException(400, { message: "Path is required" });
+      }
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace?.fs) {
+        throw new HTTPException(404, { message: "No workspace filesystem configured" });
+      }
+      const decodedPath = decodeURIComponent(path);
+      if (!await workspace.fs.exists(decodedPath)) {
+        throw new HTTPException(404, { message: `Path "${decodedPath}" not found` });
+      }
+      const content = await workspace.fs.readFile(decodedPath, {
+        encoding: encoding || "utf-8"
+      });
+      return {
+        path: decodedPath,
+        content: typeof content === "string" ? content : content.toString("utf-8"),
+        type: "file"
+      };
+    } catch (error) {
+      return handleError(error, "Error reading file");
+    }
+  }
+});
+var WORKSPACE_FS_WRITE_ROUTE = createRoute({
+  method: "POST",
+  path: "/workspaces/:workspaceId/fs/write",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  bodySchema: fsWriteBodySchema,
+  responseSchema: fsWriteResponseSchema,
+  summary: "Write file content",
+  description: "Writes content to a file at the specified path. Supports base64 encoding for binary files.",
+  tags: ["Workspace"],
+  handler: async ({ mastra, path, content, encoding, recursive, workspaceId }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!path || content === void 0) {
+        throw new HTTPException(400, { message: "Path and content are required" });
+      }
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace?.fs) {
+        throw new HTTPException(404, { message: "No workspace filesystem configured" });
+      }
+      if (workspace.filesystem?.readOnly) {
+        throw new HTTPException(403, { message: "Workspace is in read-only mode" });
+      }
+      const decodedPath = decodeURIComponent(path);
+      let fileContent = content;
+      if (encoding === "base64") {
+        fileContent = Buffer.from(content, "base64");
+      }
+      await workspace.fs.writeFile(decodedPath, fileContent, { recursive: recursive ?? true });
+      return {
+        success: true,
+        path: decodedPath
+      };
+    } catch (error) {
+      return handleError(error, "Error writing file");
+    }
+  }
+});
+var WORKSPACE_FS_LIST_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/fs/list",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  queryParamSchema: fsListQuerySchema,
+  responseSchema: fsListResponseSchema,
+  summary: "List directory contents",
+  description: "Returns a list of files and directories at the specified path",
+  tags: ["Workspace"],
+  handler: async ({ mastra, path, recursive, workspaceId }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!path) {
+        throw new HTTPException(400, { message: "Path is required" });
+      }
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace?.fs) {
+        return {
+          path: decodeURIComponent(path),
+          entries: [],
+          error: "No workspace filesystem configured"
+        };
+      }
+      const decodedPath = decodeURIComponent(path);
+      if (!await workspace.fs.exists(decodedPath)) {
+        throw new HTTPException(404, { message: `Path "${decodedPath}" not found` });
+      }
+      const entries = await workspace.fs.readdir(decodedPath, { recursive });
+      return {
+        path: decodedPath,
+        entries: entries.map((entry) => ({
+          name: entry.name,
+          type: entry.type,
+          size: entry.size
+        }))
+      };
+    } catch (error) {
+      return handleError(error, "Error listing directory");
+    }
+  }
+});
+var WORKSPACE_FS_DELETE_ROUTE = createRoute({
+  method: "DELETE",
+  path: "/workspaces/:workspaceId/fs/delete",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  queryParamSchema: fsDeleteQuerySchema,
+  responseSchema: fsDeleteResponseSchema,
+  summary: "Delete file or directory",
+  description: "Deletes a file or directory at the specified path",
+  tags: ["Workspace"],
+  handler: async ({ mastra, path, recursive, force, workspaceId }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!path) {
+        throw new HTTPException(400, { message: "Path is required" });
+      }
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace?.fs) {
+        throw new HTTPException(404, { message: "No workspace filesystem configured" });
+      }
+      if (workspace.filesystem?.readOnly) {
+        throw new HTTPException(403, { message: "Workspace is in read-only mode" });
+      }
+      const decodedPath = decodeURIComponent(path);
+      const exists = await workspace.fs.exists(decodedPath);
+      if (!exists && !force) {
+        throw new HTTPException(404, { message: `Path "${decodedPath}" not found` });
+      }
+      if (exists) {
+        try {
+          await workspace.fs.deleteFile(decodedPath, { force });
+        } catch {
+          await workspace.fs.rmdir(decodedPath, { recursive, force });
+        }
+      }
+      return {
+        success: true,
+        path: decodedPath
+      };
+    } catch (error) {
+      return handleError(error, "Error deleting path");
+    }
+  }
+});
+var WORKSPACE_FS_MKDIR_ROUTE = createRoute({
+  method: "POST",
+  path: "/workspaces/:workspaceId/fs/mkdir",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  bodySchema: fsMkdirBodySchema,
+  responseSchema: fsMkdirResponseSchema,
+  summary: "Create directory",
+  description: "Creates a directory at the specified path",
+  tags: ["Workspace"],
+  handler: async ({ mastra, path, recursive, workspaceId }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!path) {
+        throw new HTTPException(400, { message: "Path is required" });
+      }
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace?.fs) {
+        throw new HTTPException(404, { message: "No workspace filesystem configured" });
+      }
+      if (workspace.filesystem?.readOnly) {
+        throw new HTTPException(403, { message: "Workspace is in read-only mode" });
+      }
+      const decodedPath = decodeURIComponent(path);
+      await workspace.fs.mkdir(decodedPath, { recursive: recursive ?? true });
+      return {
+        success: true,
+        path: decodedPath
+      };
+    } catch (error) {
+      return handleError(error, "Error creating directory");
+    }
+  }
+});
+var WORKSPACE_FS_STAT_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/fs/stat",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  queryParamSchema: fsStatQuerySchema,
+  responseSchema: fsStatResponseSchema,
+  summary: "Get file/directory info",
+  description: "Returns metadata about a file or directory",
+  tags: ["Workspace"],
+  handler: async ({ mastra, path, workspaceId }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!path) {
+        throw new HTTPException(400, { message: "Path is required" });
+      }
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace?.fs) {
+        throw new HTTPException(404, { message: "No workspace filesystem configured" });
+      }
+      const decodedPath = decodeURIComponent(path);
+      if (!await workspace.fs.exists(decodedPath)) {
+        throw new HTTPException(404, { message: `Path "${decodedPath}" not found` });
+      }
+      const stat = await workspace.fs.stat(decodedPath);
+      return {
+        path: stat.path,
+        type: stat.type,
+        size: stat.size,
+        createdAt: stat.createdAt?.toISOString(),
+        modifiedAt: stat.modifiedAt?.toISOString(),
+        mimeType: stat.mimeType
+      };
+    } catch (error) {
+      return handleError(error, "Error getting file info");
+    }
+  }
+});
+var WORKSPACE_SEARCH_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/search",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  queryParamSchema: searchQuerySchema,
+  responseSchema: searchResponseSchema,
+  summary: "Search workspace content",
+  description: "Searches across indexed workspace content using BM25, vector, or hybrid search",
+  tags: ["Workspace"],
+  handler: async ({ mastra, query, topK, mode, minScore, workspaceId }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!query) {
+        throw new HTTPException(400, { message: "Search query is required" });
+      }
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace) {
+        return {
+          results: [],
+          query,
+          mode: mode || "bm25"
+        };
+      }
+      const canSearch = workspace.canBM25 || workspace.canVector;
+      if (!canSearch) {
+        return {
+          results: [],
+          query,
+          mode: mode || "bm25"
+        };
+      }
+      let searchMode = mode;
+      if (!searchMode) {
+        if (workspace.canHybrid) {
+          searchMode = "hybrid";
+        } else if (workspace.canVector) {
+          searchMode = "vector";
+        } else {
+          searchMode = "bm25";
+        }
+      }
+      const results = await workspace.search(query, {
+        topK: topK || 5,
+        mode: searchMode,
+        minScore
+      });
+      return {
+        results: results.map((r) => ({
+          id: r.id,
+          content: r.content,
+          score: r.score,
+          lineRange: r.lineRange,
+          scoreDetails: r.scoreDetails
+        })),
+        query,
+        mode: searchMode
+      };
+    } catch (error) {
+      return handleError(error, "Error searching workspace");
+    }
+  }
+});
+var WORKSPACE_INDEX_ROUTE = createRoute({
+  method: "POST",
+  path: "/workspaces/:workspaceId/index",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  bodySchema: indexBodySchema,
+  responseSchema: indexResponseSchema,
+  summary: "Index content for search",
+  description: "Indexes content for later search operations",
+  tags: ["Workspace"],
+  handler: async ({ mastra, path, content, metadata, workspaceId }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!path || content === void 0) {
+        throw new HTTPException(400, { message: "Path and content are required" });
+      }
+      const workspace = await getWorkspaceById(mastra, workspaceId);
+      if (!workspace) {
+        throw new HTTPException(404, { message: "No workspace configured" });
+      }
+      const canSearch = workspace.canBM25 || workspace.canVector;
+      if (!canSearch) {
+        throw new HTTPException(400, { message: "Workspace does not have search configured" });
+      }
+      await workspace.index(path, content, { metadata });
+      return {
+        success: true,
+        path
+      };
+    } catch (error) {
+      return handleError(error, "Error indexing content");
+    }
+  }
+});
+var WORKSPACE_LIST_SKILLS_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/skills",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  responseSchema: listSkillsResponseSchema,
+  summary: "List all skills",
+  description: "Returns a list of all discovered skills with their metadata",
+  tags: ["Workspace", "Skills"],
+  handler: async ({ mastra, workspaceId, requestContext }) => {
+    try {
+      requireWorkspaceV1Support();
+      const skills = await getSkillsById(mastra, workspaceId);
+      if (!skills) {
+        return { skills: [], isSkillsConfigured: false };
+      }
+      await skills.maybeRefresh({ requestContext });
+      const skillsList = await skills.list();
+      return {
+        skills: skillsList.map((skill) => ({
+          name: skill.name,
+          description: skill.description,
+          license: skill.license,
+          compatibility: skill.compatibility,
+          metadata: skill.metadata
+        })),
+        isSkillsConfigured: true
+      };
+    } catch (error) {
+      return handleError(error, "Error listing skills");
+    }
+  }
+});
+var WORKSPACE_GET_SKILL_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/skills/:skillName",
+  responseType: "json",
+  pathParamSchema: skillNamePathParams,
+  responseSchema: getSkillResponseSchema,
+  summary: "Get skill details",
+  description: "Returns the full details of a specific skill including instructions and file lists",
+  tags: ["Workspace", "Skills"],
+  handler: async ({ mastra, skillName, workspaceId, requestContext }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!skillName) {
+        throw new HTTPException(400, { message: "Skill name is required" });
+      }
+      const skills = await getSkillsById(mastra, workspaceId);
+      if (!skills) {
+        throw new HTTPException(404, { message: "No workspace with skills configured" });
+      }
+      await skills.maybeRefresh({ requestContext });
+      const skill = await skills.get(skillName);
+      if (!skill) {
+        throw new HTTPException(404, { message: `Skill "${skillName}" not found` });
+      }
+      return {
+        name: skill.name,
+        description: skill.description,
+        license: skill.license,
+        compatibility: skill.compatibility,
+        metadata: skill.metadata,
+        path: skill.path,
+        instructions: skill.instructions,
+        source: skill.source,
+        references: skill.references,
+        scripts: skill.scripts,
+        assets: skill.assets
+      };
+    } catch (error) {
+      return handleError(error, "Error getting skill");
+    }
+  }
+});
+var WORKSPACE_LIST_SKILL_REFERENCES_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/skills/:skillName/references",
+  responseType: "json",
+  pathParamSchema: skillNamePathParams,
+  responseSchema: listReferencesResponseSchema,
+  summary: "List skill references",
+  description: "Returns a list of all reference file paths for a skill",
+  tags: ["Workspace", "Skills"],
+  handler: async ({ mastra, skillName, workspaceId, requestContext }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!skillName) {
+        throw new HTTPException(400, { message: "Skill name is required" });
+      }
+      const skills = await getSkillsById(mastra, workspaceId);
+      if (!skills) {
+        throw new HTTPException(404, { message: "No workspace with skills configured" });
+      }
+      await skills.maybeRefresh({ requestContext });
+      const hasSkill = await skills.has(skillName);
+      if (!hasSkill) {
+        throw new HTTPException(404, { message: `Skill "${skillName}" not found` });
+      }
+      const references = await skills.listReferences(skillName);
+      return {
+        skillName,
+        references
+      };
+    } catch (error) {
+      return handleError(error, "Error listing skill references");
+    }
+  }
+});
+var WORKSPACE_GET_SKILL_REFERENCE_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/skills/:skillName/references/:referencePath",
+  responseType: "json",
+  pathParamSchema: skillReferencePathParams,
+  responseSchema: skillReferenceResponseSchema,
+  summary: "Get skill reference content",
+  description: "Returns the content of a specific reference file from a skill",
+  tags: ["Workspace", "Skills"],
+  handler: async ({ mastra, skillName, referencePath, workspaceId, requestContext }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!skillName || !referencePath) {
+        throw new HTTPException(400, { message: "Skill name and reference path are required" });
+      }
+      const skills = await getSkillsById(mastra, workspaceId);
+      if (!skills) {
+        throw new HTTPException(404, { message: "No workspace with skills configured" });
+      }
+      await skills.maybeRefresh({ requestContext });
+      const decodedPath = decodeURIComponent(referencePath);
+      const content = await skills.getReference(skillName, decodedPath);
+      if (content === null) {
+        throw new HTTPException(404, { message: `Reference "${decodedPath}" not found in skill "${skillName}"` });
+      }
+      return {
+        skillName,
+        referencePath: decodedPath,
+        content
+      };
+    } catch (error) {
+      return handleError(error, "Error getting skill reference");
+    }
+  }
+});
+var WORKSPACE_SEARCH_SKILLS_ROUTE = createRoute({
+  method: "GET",
+  path: "/workspaces/:workspaceId/skills/search",
+  responseType: "json",
+  pathParamSchema: workspaceIdPathParams,
+  queryParamSchema: searchSkillsQuerySchema,
+  responseSchema: searchSkillsResponseSchema,
+  summary: "Search skills",
+  description: "Searches across all skills content using BM25 keyword search",
+  tags: ["Workspace", "Skills"],
+  handler: async ({ mastra, query, topK, minScore, skillNames, includeReferences, workspaceId, requestContext }) => {
+    try {
+      requireWorkspaceV1Support();
+      if (!query) {
+        throw new HTTPException(400, { message: "Search query is required" });
+      }
+      const skills = await getSkillsById(mastra, workspaceId);
+      if (!skills) {
+        return {
+          results: [],
+          query
+        };
+      }
+      await skills.maybeRefresh({ requestContext });
+      const skillNamesList = skillNames ? skillNames.split(",").map((s) => s.trim()) : void 0;
+      const results = await skills.search(query, {
+        topK: topK || 5,
+        minScore,
+        skillNames: skillNamesList,
+        includeReferences: includeReferences ?? true
+      });
+      return {
+        results: results.map((r) => ({
+          skillName: r.skillName,
+          source: r.source,
+          content: r.content,
+          score: r.score,
+          lineRange: r.lineRange,
+          scoreDetails: r.scoreDetails
+        })),
+        query
+      };
+    } catch (error) {
+      return handleError(error, "Error searching skills");
+    }
+  }
+});
+var WORKSPACE_FS_ROUTES = [
+  WORKSPACE_FS_READ_ROUTE,
+  WORKSPACE_FS_WRITE_ROUTE,
+  WORKSPACE_FS_LIST_ROUTE,
+  WORKSPACE_FS_DELETE_ROUTE,
+  WORKSPACE_FS_MKDIR_ROUTE,
+  WORKSPACE_FS_STAT_ROUTE
+];
+var WORKSPACE_SEARCH_ROUTES = [WORKSPACE_SEARCH_ROUTE, WORKSPACE_INDEX_ROUTE];
+var WORKSPACE_SKILLS_ROUTES = [
+  WORKSPACE_SEARCH_SKILLS_ROUTE,
+  WORKSPACE_LIST_SKILLS_ROUTE,
+  WORKSPACE_GET_SKILL_ROUTE,
+  WORKSPACE_LIST_SKILL_REFERENCES_ROUTE,
+  WORKSPACE_GET_SKILL_REFERENCE_ROUTE
+];
+
+export { GET_WORKSPACE_ROUTE, LIST_WORKSPACES_ROUTE, WORKSPACE_FS_DELETE_ROUTE, WORKSPACE_FS_LIST_ROUTE, WORKSPACE_FS_MKDIR_ROUTE, WORKSPACE_FS_READ_ROUTE, WORKSPACE_FS_ROUTES, WORKSPACE_FS_STAT_ROUTE, WORKSPACE_FS_WRITE_ROUTE, WORKSPACE_GET_SKILL_REFERENCE_ROUTE, WORKSPACE_GET_SKILL_ROUTE, WORKSPACE_INDEX_ROUTE, WORKSPACE_LIST_SKILLS_ROUTE, WORKSPACE_LIST_SKILL_REFERENCES_ROUTE, WORKSPACE_SEARCH_ROUTE, WORKSPACE_SEARCH_ROUTES, WORKSPACE_SEARCH_SKILLS_ROUTE, WORKSPACE_SKILLS_ROUTES };
+//# sourceMappingURL=chunk-QWOQET2T.js.map
+//# sourceMappingURL=chunk-QWOQET2T.js.map