@axiom-lattice/gateway 2.1.53 → 2.1.55

package/src/controllers/workspace.ts

@@ -8,11 +8,9 @@
 import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
 import * as fs from "fs/promises";
 import * as path from "path";
-import { Readable } from "stream";
 import { getStoreLattice } from "@axiom-lattice/core";
 import { SandboxFilesystem, FilesystemBackend } from "@axiom-lattice/core";
 import { getSandBoxManager } from "@axiom-lattice/core";
-import { sandboxService } from "../services/sandbox_service";
 import { v4 as uuidv4 } from "uuid";
 import type {
   CreateWorkspaceRequest,
@@ -264,12 +262,16 @@ export class WorkspaceController {
 
     if (workspace.storageType === "sandbox") {
       const sandboxManager = getSandBoxManager();
-      const sandboxName = "global";
-      const sandbox = await sandboxManager.createSandbox(sandboxName);
+      const sandbox = await sandboxManager.getSandboxFromConfig({
+        assistant_id: "",
+        thread_id: "",
+        tenantId,
+        workspaceId,
+        projectId,
+      });
       return {
         backend: new SandboxFilesystem({
           sandboxInstance: sandbox,
-          workingDirectory: `/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
         }), workspace
       };
     } else {
@@ -327,66 +329,28 @@ export class WorkspaceController {
 
     try {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId);
-      const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
+      const resolvedPath = filePath;
 
       if (workspace.storageType === "sandbox") {
         const sandboxManager = getSandBoxManager();
-        const sandbox = await sandboxManager.createSandbox("global");
-        const realPath = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId, resolvedPath);
+        const sandbox = await sandboxManager.getSandboxFromConfig({
+          assistant_id: "",
+          thread_id: "",
+          tenantId,
+          workspaceId,
+          projectId,
+        });
+        const realPath = resolvedPath;
         const filename = this.getFilenameFromPath(resolvedPath);
         const inferredContentType = this.getMimeType(filename);
 
-        const downloadResult = await sandbox.file.downloadFile({
-          path: realPath,
-        });
-
-        if (!downloadResult.ok) {
-          return reply.status(502).send({
-            success: false,
-            error: `Download error: ${JSON.stringify(downloadResult.error)}`,
-          });
-        }
-
-        const body = downloadResult.body as unknown as {
-          stream?: () => ReadableStream<Uint8Array>;
-          contentType?: string;
-          contentDisposition?: string;
-        };
-
-        if (typeof body?.stream === "function") {
-          const webStream = body.stream();
-          const nodeStream = Readable.fromWeb(webStream);
-          const contentType = body.contentType ?? inferredContentType;
-          const contentDisposition =
-            body.contentDisposition ?? `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`;
-          return reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(nodeStream);
+        try {
+          const buf = await sandbox.file.downloadFile({ file: realPath });
+          const contentDisposition = `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`;
+          return reply.status(200).type(inferredContentType).header("Content-Disposition", contentDisposition).send(buf);
+        } catch (err) {
+          return reply.status(502).send({ success: false, error: String(err) });
         }
-
-        const bodyUnknown = downloadResult.body as unknown;
-        let buf: Buffer;
-        let contentType = inferredContentType;
-        let contentDisposition = `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`;
-
-        if (bodyUnknown instanceof ArrayBuffer) {
-          buf = Buffer.from(bodyUnknown);
-        } else if (bodyUnknown instanceof Buffer) {
-          buf = bodyUnknown;
-        } else if (
-          bodyUnknown &&
-          typeof (bodyUnknown as { arrayBuffer?: () => Promise<ArrayBuffer> }).arrayBuffer === "function"
-        ) {
-          const res = bodyUnknown as { arrayBuffer: () => Promise<ArrayBuffer>; headers?: Headers };
-          buf = Buffer.from(await res.arrayBuffer());
-          if (res.headers?.get("content-type")) contentType = res.headers.get("content-type")!;
-          if (res.headers?.get("content-disposition")) contentDisposition = res.headers.get("content-disposition")!;
-        } else if (bodyUnknown && typeof (bodyUnknown as { blob?: () => Promise<Blob> }).blob === "function") {
-          const blob = await (bodyUnknown as { blob: () => Promise<Blob> }).blob();
-          buf = Buffer.from(await blob.arrayBuffer());
-        } else {
-          return reply.status(502).send({ success: false, error: "Unexpected download response format" });
-        }
-
-        return reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(buf);
       }
 
       const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
@@ -427,51 +391,33 @@ export class WorkspaceController {
 
     try {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId);
-      const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
+      const resolvedPath = filePath;
 
       if (workspace.storageType === "sandbox") {
         const sandboxManager = getSandBoxManager();
-        const sandbox = await sandboxManager.createSandbox("global");
-        const realPath = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId, resolvedPath);
+        const sandbox = await sandboxManager.getSandboxFromConfig({
+          assistant_id: "",
+          thread_id: "",
+          tenantId,
+          workspaceId,
+          projectId,
+        });
+        const realPath = resolvedPath;
         const filename = this.getFilenameFromPath(resolvedPath);
         const inferredContentType = this.getMimeType(filename);
 
-        const downloadResult = await sandbox.file.downloadFile({
-          path: realPath,
-        });
-
-        if (!downloadResult.ok) {
-          return reply.status(502).send({
-            success: false,
-            error: `View error: ${JSON.stringify(downloadResult.error)}`,
-          });
-        }
-
-        const body = downloadResult.body as unknown as {
-          stream?: () => ReadableStream<Uint8Array>;
-          contentType?: string;
-          contentDisposition?: string;
-        };
+        try {
+          const buf = await sandbox.file.downloadFile({ file: realPath });
+          let contentType = inferredContentType;
 
-        if (typeof body?.stream === "function") {
-          const webStream = body.stream();
-          const nodeStream = Readable.fromWeb(webStream);
-          const contentType = body.contentType ?? inferredContentType;
-          console.log(`[viewFile] Sandbox returned stream, contentType: ${contentType}, filename: ${filename}`);
-          
-          // Check if it's HTML and needs context injection
+          // Inject AI2APP context script for HTML files (sandbox storage)
           const isHtml = contentType?.toLowerCase().includes("text/html") || 
                          filename.toLowerCase().endsWith(".html") || 
                          filename.toLowerCase().endsWith(".htm");
-          
+          let outputBuf = buf;
           if (isHtml) {
-            console.log(`[viewFile] HTML stream detected, collecting for context injection`);
-            // Collect stream content
-            const chunks: Buffer[] = [];
-            for await (const chunk of nodeStream) {
-              chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-            }
-            let content = Buffer.concat(chunks).toString("utf-8");
+            console.log(`[viewFile] Injecting AI2APP context for sandbox HTML file: ${filename}, tenantId: ${tenantId}, contentType: ${contentType}`);
+            let content = buf.toString("utf-8");
             const contextScript = `<script>window.__AI2APP_CONTEXT__=${JSON.stringify({
               tenantId,
               workspaceId,
@@ -481,84 +427,25 @@ export class WorkspaceController {
             
             if (content.toLowerCase().includes("</head>")) {
               content = content.replace(/<\/head>/i, `${contextScript}</head>`);
-              console.log(`[viewFile] Context script injected before </head> (stream)`);
+              console.log(`[viewFile] Context script injected before </head>`);
             } else if (content.toLowerCase().includes("<html>")) {
               content = content.replace(/<html>/i, `<html>${contextScript}`);
-              console.log(`[viewFile] Context script injected after <html> (stream)`);
+              console.log(`[viewFile] Context script injected after <html>`);
             } else {
               content = contextScript + content;
-              console.log(`[viewFile] Context script prepended to content (stream)`);
+              console.log(`[viewFile] Context script prepended to content`);
             }
-            
-            return reply
-              .status(200)
-              .type(contentType)
-              .header("Content-Disposition", "inline")
-              .send(Buffer.from(content, "utf-8"));
+            outputBuf = Buffer.from(content, "utf-8");
           }
-          
-          // inline for viewing, not attachment for download
+
           return reply
             .status(200)
             .type(contentType)
             .header("Content-Disposition", "inline")
-            .send(nodeStream);
+            .send(outputBuf);
+        } catch (err) {
+          return reply.status(502).send({ success: false, error: String(err) });
         }
-
-        const bodyUnknown = downloadResult.body as unknown;
-        let buf: Buffer;
-        let contentType = inferredContentType;
-
-        if (bodyUnknown instanceof ArrayBuffer) {
-          buf = Buffer.from(bodyUnknown);
-        } else if (bodyUnknown instanceof Buffer) {
-          buf = bodyUnknown;
-        } else if (
-          bodyUnknown &&
-          typeof (bodyUnknown as { arrayBuffer?: () => Promise<ArrayBuffer> }).arrayBuffer === "function"
-        ) {
-          const res = bodyUnknown as { arrayBuffer: () => Promise<ArrayBuffer>; headers?: Headers };
-          buf = Buffer.from(await res.arrayBuffer());
-          if (res.headers?.get("content-type")) contentType = res.headers.get("content-type")!;
-        } else if (bodyUnknown && typeof (bodyUnknown as { blob?: () => Promise<Blob> }).blob === "function") {
-          const blob = await (bodyUnknown as { blob: () => Promise<Blob> }).blob();
-          buf = Buffer.from(await blob.arrayBuffer());
-        } else {
-          return reply.status(502).send({ success: false, error: "Unexpected view response format" });
-        }
-
-        // Inject AI2APP context script for HTML files (sandbox storage)
-        const isHtml = contentType?.toLowerCase().includes("text/html") || 
-                       filename.toLowerCase().endsWith(".html") || 
-                       filename.toLowerCase().endsWith(".htm");
-        if (isHtml) {
-          console.log(`[viewFile] Injecting AI2APP context for sandbox HTML file: ${filename}, tenantId: ${tenantId}, contentType: ${contentType}`);
-          let content = buf.toString("utf-8");
-          const contextScript = `<script>window.__AI2APP_CONTEXT__=${JSON.stringify({
-            tenantId,
-            workspaceId,
-            projectId,
-            timestamp: Date.now()
-          })};</script>`;
-          
-          if (content.toLowerCase().includes("</head>")) {
-            content = content.replace(/<\/head>/i, `${contextScript}</head>`);
-            console.log(`[viewFile] Context script injected before </head>`);
-          } else if (content.toLowerCase().includes("<html>")) {
-            content = content.replace(/<html>/i, `<html>${contextScript}`);
-            console.log(`[viewFile] Context script injected after <html>`);
-          } else {
-            content = contextScript + content;
-            console.log(`[viewFile] Context script prepended to content`);
-          }
-          buf = Buffer.from(content, "utf-8");
-        }
-
-        return reply
-          .status(200)
-          .type(contentType)
-          .header("Content-Disposition", "inline")
-          .send(buf);
       }
 
       const { backend } = await this.getBackend(tenantId, workspaceId, projectId);
@@ -686,7 +573,7 @@ export class WorkspaceController {
             ? pathEntry
             : undefined;
 
-      if (pathValue && !/^[a-zA-Z0-9_./-]+$/.test(pathValue)) {
+      if (pathValue && !/^[a-zA-Z0-9_./~\-]+$/.test(pathValue)) {
         return reply
           .status(400)
           .send({ success: false, error: "Invalid path parameter" });
@@ -694,29 +581,27 @@ export class WorkspaceController {
 
       if (workspace.storageType === "sandbox") {
         const sandboxManager = getSandBoxManager();
-        const sandboxName = "global";
-        const sandbox = await sandboxManager.createSandbox(sandboxName);
+        const sandbox = await sandboxManager.getSandboxFromConfig({
+          assistant_id: "",
+          thread_id: "",
+          tenantId,
+          workspaceId,
+          projectId,
+        });
 
-        const baseDir = path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId);
         const realPath = pathValue
-          ? path.join(baseDir, pathValue, filename)
-          : path.join(baseDir, filename);
-
-        const uploadResult = await sandbox.file.uploadFile({
-          file: buffer,
-          path: realPath,
-        }, { timeoutInSeconds: 300 });
-
-        if (!uploadResult.ok) {
-          return reply.status(502).send({
-            success: false,
-            error: `Upload error: ${JSON.stringify(uploadResult.error)}`,
-          });
+          ? path.posix.join(pathValue, filename)
+          : filename;
+
+        try {
+          await sandbox.file.uploadFile({ file: realPath, data: buffer });
+        } catch (err) {
+          return reply.status(500).send({ success: false, error: String(err) });
         }
 
-        const relativePath =
-          uploadResult.body?.data?.file_path?.replace(path.join("/home/gem/tenants", tenantId, "workspaces", workspaceId, projectId), "") ||
-          (pathValue ? `/${pathValue}/${filename}` : `/${filename}`);
+        const relativePath = pathValue
+          ? path.posix.join(pathValue, filename)
+          : `/${filename}`;
 
         const result = {
           path: relativePath,

package/src/index.ts

@@ -20,6 +20,8 @@ import {
   sqlDatabaseManager,
   getStoreLattice,
   agentInstanceManager,
+  createSandboxProvider,
+  type CreateSandboxProviderConfig,
 } from "@axiom-lattice/core";
 import type { DatabaseConfigStore } from "@axiom-lattice/protocols";
 import {
@@ -206,6 +208,30 @@ export interface LatticeGatewayConfig {
   loggerConfig?: Partial<GatewayLoggerConfig>; // Optional logger configuration to override defaults
 }
 
+function getConfiguredSandboxProvider(): ReturnType<typeof createSandboxProvider> {
+  const sandboxProviderType =
+    (process.env.SANDBOX_PROVIDER_TYPE as CreateSandboxProviderConfig["type"] | undefined) ||
+    "microsandbox";
+
+  return createSandboxProvider({
+    type: sandboxProviderType,
+    remoteBaseURL: process.env.SANDBOX_BASE_URL,
+    microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
+    e2bApiKey: process.env.E2B_API_KEY,
+    e2bTemplate: process.env.E2B_TEMPLATE,
+    e2bTimeoutMs: process.env.E2B_TIMEOUT_MS
+      ? parseInt(process.env.E2B_TIMEOUT_MS, 10)
+      : undefined,
+    daytonaApiKey: process.env.DAYTONA_API_KEY,
+    daytonaApiUrl: process.env.DAYTONA_API_URL,
+    daytonaTarget: process.env.DAYTONA_TARGET,
+    daytonaTimeout: process.env.DAYTONA_TIMEOUT
+      ? parseInt(process.env.DAYTONA_TIMEOUT, 10)
+      : undefined,
+    daytonaVolumeName: process.env.DAYTONA_VOLUME_NAME,
+  });
+}
+
 // Start server
 const start = async (config?: LatticeGatewayConfig) => {
   try {
@@ -240,11 +266,8 @@ const start = async (config?: LatticeGatewayConfig) => {
 
     // Register sandbox manager if not already registered
     if (!sandboxLatticeManager.hasLattice("default")) {
-      const sandboxBaseURL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
-      sandboxLatticeManager.registerLattice("default", {
-        baseURL: sandboxBaseURL,
-      });
-      logger.info(`Registered sandbox manager with baseURL: ${sandboxBaseURL}`);
+      sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+      logger.info("Registered sandbox manager from env configuration");
     }
 
     const target_port = config?.port || Number(process.env.PORT) || 4001;

package/src/routes/channel-installations.ts

@@ -0,0 +1,33 @@
+import { FastifyInstance } from "fastify";
+import * as channelInstallationController from "../controllers/channel-installations";
+
+/**
+ * Register channel installation management routes
+ */
+export function registerChannelInstallationRoutes(app: FastifyInstance): void {
+  // List all installations for current tenant
+  app.get<{
+    Querystring: { channel?: "lark" };
+  }>("/api/channel-installations", channelInstallationController.getChannelInstallationList);
+
+  // Get single installation by ID
+  app.get<{
+    Params: { installationId: string };
+  }>("/api/channel-installations/:installationId", channelInstallationController.getChannelInstallation);
+
+  // Create new installation
+  app.post<{
+    Body: any;
+  }>("/api/channel-installations", channelInstallationController.createChannelInstallation);
+
+  // Update installation
+  app.put<{
+    Params: { installationId: string };
+    Body: any;
+  }>("/api/channel-installations/:installationId", channelInstallationController.updateChannelInstallation);
+
+  // Delete installation
+  app.delete<{
+    Params: { installationId: string };
+  }>("/api/channel-installations/:installationId", channelInstallationController.deleteChannelInstallation);
+}

package/src/routes/index.ts

@@ -39,6 +39,8 @@ import { registerMcpServerConfigRoutes } from "../controllers/mcp-configs";
 import { registerUserRoutes } from "../controllers/users";
 import { registerTenantRoutes } from "../controllers/tenants";
 import { registerAuthRoutes } from "../controllers/auth";
+import { registerChannelRoutes } from "../channels/routes";
+import { registerChannelInstallationRoutes } from "./channel-installations";
 // import {
 //   getThreadStatusHandler,
 //   getAgentThreadsHandler,
@@ -343,6 +345,10 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
     allowTenantRegistration: process.env.ALLOW_TENANT_REGISTRATION !== "false",
   });
 
+  registerChannelRoutes(app);
+
+  registerChannelInstallationRoutes(app);
+
   // // Thread 状态查询路由
   // app.get("/api/threads/:thread_id/status", getThreadStatusHandler);
   // app.get("/api/assistants/:assistant_id/threads/status", getAgentThreadsHandler);

package/src/schemas/index.ts

@@ -829,9 +829,9 @@ export const getSandboxUrlSchema: FastifySchema = {
           properties: {
             sandboxUrl: { type: "string", description: "Sandbox URL" },
             sandboxName: { type: "string", description: "Sandbox name" },
-            isolatedLevel: {
+            vmIsolation: {
               type: "string",
-              enum: ["agent", "thread", "global"],
+              enum: ["agent", "project", "global"],
               description: "Sandbox isolation level",
             },
           },

package/src/services/sandbox_service.ts

@@ -93,7 +93,7 @@ const ERROR_HTML = `<!DOCTYPE html>
       </div>
       <div class="info-item">
         <span class="label">隔离级别</span>
-        <span class="value" id="isolatedLevel">-</span>
+        <span class="value" id="vmIsolation">-</span>
       </div>
       <div class="info-item">
         <span class="label">错误信息</span>
@@ -106,7 +106,7 @@ const ERROR_HTML = `<!DOCTYPE html>
     const params = new URLSearchParams(window.location.search);
     document.getElementById('assistantId').textContent = params.get('assistantId') || '-';
     document.getElementById('threadId').textContent = params.get('threadId') || '-';
-    document.getElementById('isolatedLevel').textContent = params.get('isolatedLevel') || '-';
+    document.getElementById('vmIsolation').textContent = params.get('vmIsolation') || '-';
     document.getElementById('errorMsg').textContent = params.get('error') || '未知错误';
   </script>
 </body>
@@ -114,7 +114,7 @@ const ERROR_HTML = `<!DOCTYPE html>
 
 export class SandboxService {
 
-  getFilesystemIsolatedLevel(tenantId: string, assistantId: string): "agent" | "thread" | "global" | null {
+  getFilesystemVmIsolation(tenantId: string, assistantId: string): "agent" | "project" | "global" | null {
     const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
     if (!agentLattice) {
       return null;
@@ -125,37 +125,37 @@ export class SandboxService {
       return null;
     }
 
-    // Type guard for SandboxMiddlewareConfig which has isolatedLevel
     const config = filesystemConfig.config as SandboxMiddlewareConfig;
-    return config?.isolatedLevel || null;
+    return config?.vmIsolation || null;
   }
 
   computeSandboxName(
     assistantId: string,
     threadId: string,
-    isolatedLevel: string
+    vmIsolation: string,
+    tenantId?: string,
+    workspaceId?: string,
+    projectId?: string,
   ): string {
-    let sandboxName: string;
-
-    switch (isolatedLevel) {
+    switch (vmIsolation) {
       case "agent":
-        sandboxName = assistantId;
-        break;
-      case "thread":
-        sandboxName = threadId;
-        break;
+        return normalizeSandboxName(`${tenantId ?? "default"}-${assistantId}`);
+      case "project":
+        return normalizeSandboxName(
+          `${tenantId ?? "default"}-${workspaceId ?? "default"}-${projectId ?? "default"}`
+        );
       case "global":
       default:
-        sandboxName = "global";
-        break;
+        return "global";
     }
+  }
 
-    return normalizeSandboxName(sandboxName);
+  private getBrowserSandboxBaseURL(): string {
+    return process.env.AGENT_INFRA_SANDBOX_BASE_URL || "http://localhost:8080";
   }
 
   getTargetUrl(sandboxName: string): string {
-    const sandboxManager = getSandBoxManager()
-    return `${sandboxManager.getBaseURL()}/sandbox/${sandboxName}`;
+    return `${this.getBrowserSandboxBaseURL()}/sandbox/${sandboxName}`;
   }
 
   async getVncHtml(sandboxName: string): Promise<string> {
@@ -208,14 +208,14 @@ export class SandboxService {
   generateErrorHtml(
     assistantId: string,
     threadId: string,
-    isolatedLevel: string,
+    vmIsolation: string,
     errorMessage: string
   ): string {
     const encodedError = encodeURIComponent(errorMessage);
     return ERROR_HTML
       .replace("{assistantId}", assistantId)
       .replace("{threadId}", threadId)
-      .replace("{isolatedLevel}", isolatedLevel)
+      .replace("{vmIsolation}", vmIsolation)
       .replace("{errorMessage}", errorMessage);
   }
 }

package/src/services/skill_service.ts

@@ -0,0 +1,97 @@
+/**
+ * SkillService
+ *
+ * Business logic layer for skill management.
+ * Wraps SandboxSkillStore from @axiom-lattice/core.
+ * Controllers should consume this service, not directly manipulate storage.
+ */
+
+import { SandboxSkillStore } from "@axiom-lattice/core";
+import type {
+  Skill,
+  SkillStoreContext,
+  CreateSkillRequest,
+} from "@axiom-lattice/protocols";
+import { FastifyRequest } from "fastify";
+
+function getTenantId(request: FastifyRequest): string {
+  return (request as any).user?.tenantId || (request.headers["x-tenant-id"] as string) || "default";
+}
+
+function getWorkspaceId(request: FastifyRequest): string | undefined {
+  return request.headers["x-workspace-id"] as string | undefined;
+}
+
+function getProjectId(request: FastifyRequest): string | undefined {
+  return request.headers["x-project-id"] as string | undefined;
+}
+
+function buildContext(request: FastifyRequest): SkillStoreContext {
+  return {
+    workspaceId: getWorkspaceId(request),
+    projectId: getProjectId(request),
+  };
+}
+
+export class SkillService {
+  private store: SandboxSkillStore;
+
+  constructor() {
+    this.store = new SandboxSkillStore();
+  }
+
+  async getAllSkills(request: FastifyRequest): Promise<Skill[]> {
+    const tenantId = getTenantId(request);
+    return this.store.getAllSkills(tenantId, buildContext(request));
+  }
+
+  async getSkillById(request: FastifyRequest, id: string): Promise<Skill | null> {
+    const tenantId = getTenantId(request);
+    return this.store.getSkillById(tenantId, id, buildContext(request));
+  }
+
+  async createSkill(
+    request: FastifyRequest,
+    id: string,
+    data: CreateSkillRequest
+  ): Promise<Skill> {
+    const tenantId = getTenantId(request);
+    return this.store.createSkill(tenantId, id, data, buildContext(request));
+  }
+
+  async updateSkill(
+    request: FastifyRequest,
+    id: string,
+    updates: Partial<CreateSkillRequest>
+  ): Promise<Skill | null> {
+    const tenantId = getTenantId(request);
+    return this.store.updateSkill(tenantId, id, updates, buildContext(request));
+  }
+
+  async deleteSkill(request: FastifyRequest, id: string): Promise<boolean> {
+    const tenantId = getTenantId(request);
+    return this.store.deleteSkill(tenantId, id, buildContext(request));
+  }
+
+  async searchByMetadata(
+    request: FastifyRequest,
+    key: string,
+    value: string
+  ): Promise<Skill[]> {
+    const tenantId = getTenantId(request);
+    return this.store.searchByMetadata(tenantId, key, value, buildContext(request));
+  }
+
+  async filterByCompatibility(
+    request: FastifyRequest,
+    compatibility: string
+  ): Promise<Skill[]> {
+    const tenantId = getTenantId(request);
+    return this.store.filterByCompatibility(tenantId, compatibility, buildContext(request));
+  }
+
+  async filterByLicense(request: FastifyRequest, license: string): Promise<Skill[]> {
+    const tenantId = getTenantId(request);
+    return this.store.filterByLicense(tenantId, license, buildContext(request));
+  }
+}