@ash-cloud/ash-ai 0.1.11 → 0.1.13

package/dist/index.cjs

@@ -227,8 +227,10 @@ var init_types = __esm({
       // error events
       FILE: "file",
       // file_push, file_pull, file_sync (file sync operations)
-      INPUT: "input"
+      INPUT: "input",
       // user_input (user prompts/messages)
+      WEBHOOK: "webhook"
+      // webhook_delivery, webhook_failure (outbound webhook events)
     };
   }
 });
@@ -6019,6 +6021,7 @@ var init_sandbox_file_watcher = __esm({
           type,
           relativePath,
           absolutePath,
+          basePath: this.watchPath,
           sessionId: this.sessionId,
           fileSize,
           timestamp: /* @__PURE__ */ new Date()
@@ -6227,6 +6230,7 @@ var init_sandbox_file_watcher = __esm({
               type: "add",
               relativePath: filePath,
               absolutePath: `${this.basePath}/${filePath}`,
+              basePath: this.basePath,
               sessionId: this.sessionId,
               fileSize: info.size,
               timestamp: /* @__PURE__ */ new Date()
@@ -6239,6 +6243,7 @@ var init_sandbox_file_watcher = __esm({
               type: "unlink",
               relativePath: filePath,
               absolutePath: `${this.basePath}/${filePath}`,
+              basePath: this.basePath,
               sessionId: this.sessionId,
               timestamp: /* @__PURE__ */ new Date()
             });
@@ -6428,24 +6433,72 @@ var init_sandbox_file_sync = __esm({
       removeWebhook() {
         this.webhookConfig = void 0;
       }
+      /**
+       * Extract hostname from URL for display (security - don't expose full URL)
+       */
+      extractHostname(url) {
+        try {
+          const urlObj = new URL(url);
+          return urlObj.hostname;
+        } catch {
+          return "unknown";
+        }
+      }
+      /**
+       * Persist webhook delivery event to the session timeline
+       */
+      async persistWebhookDelivery(sessionId, webhookType, result, filePath, operation) {
+        if (!this.eventStorage || !this.webhookConfig) return;
+        try {
+          const now = /* @__PURE__ */ new Date();
+          const sequenceNumber = await this.getNextSequenceNumber(sessionId);
+          const eventData = {
+            webhookType,
+            targetUrl: this.extractHostname(this.webhookConfig.url),
+            success: result.success,
+            statusCode: result.statusCode,
+            error: result.error,
+            durationMs: result.durationMs,
+            retryCount: result.retryCount > 0 ? result.retryCount : void 0,
+            filePath,
+            operation
+          };
+          const eventType = result.success ? "webhook_delivery" : "webhook_failure";
+          const sessionEvent = {
+            eventType,
+            category: exports.EventCategory.WEBHOOK,
+            startedAt: new Date(now.getTime() - result.durationMs),
+            endedAt: now,
+            durationMs: result.durationMs,
+            eventData,
+            sequenceNumber
+          };
+          await this.eventStorage.saveEvents(sessionId, [sessionEvent]);
+        } catch (error) {
+          console.error("[FILE_SYNC] Error saving webhook delivery event to storage:", error);
+        }
+      }
       /**
        * Send a webhook notification
        * @param payload - The webhook payload to send
+       * @param sessionId - Session ID for persisting delivery events
+       * @returns WebhookDeliveryResult with success/failure info
        */
-      async sendWebhook(payload) {
-        if (!this.webhookConfig) return;
+      async sendWebhook(payload, sessionId) {
+        if (!this.webhookConfig) return null;
         const config = this.webhookConfig;
         const eventType = payload.fileSyncEvent?.operation ?? "file_change";
         if (config.events && config.events.length > 0) {
           const shouldSend = config.events.some(
             (e) => e === eventType || e === "file_change" && payload.event === "file_change"
           );
-          if (!shouldSend) return;
+          if (!shouldSend) return null;
         }
         const body = JSON.stringify(payload);
         const timeoutMs = config.timeoutMs ?? 1e4;
         const retries = config.retries ?? 3;
         const isAsync = config.async !== false;
+        const startTime = Date.now();
         const headers = {
           "Content-Type": "application/json",
           "User-Agent": "Ash-FileSync/1.0",
@@ -6467,12 +6520,23 @@ var init_sandbox_file_sync = __esm({
               signal: controller.signal
             });
             clearTimeout(timeoutId);
+            const durationMs = Date.now() - startTime;
             if (!response.ok) {
-              throw new Error(`Webhook returned ${response.status}: ${response.statusText}`);
+              const error = `Webhook returned ${response.status}: ${response.statusText}`;
+              if (attempt < retries) {
+                const delay = Math.pow(2, attempt) * 1e3;
+                console.warn(`[FILE_SYNC] Webhook failed (attempt ${attempt + 1}/${retries}), retrying in ${delay}ms: ${error}`);
+                await new Promise((resolve3) => setTimeout(resolve3, delay));
+                return sendWithRetry(attempt + 1);
+              }
+              console.error(`[FILE_SYNC] Webhook failed after ${retries} attempts: ${error}`);
+              return { success: false, statusCode: response.status, error, durationMs, retryCount: attempt };
             }
             console.log(`[FILE_SYNC] Webhook sent successfully to ${config.url}`);
+            return { success: true, statusCode: response.status, durationMs, retryCount: attempt };
           } catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);
+            const durationMs = Date.now() - startTime;
             if (attempt < retries) {
               const delay = Math.pow(2, attempt) * 1e3;
               console.warn(`[FILE_SYNC] Webhook failed (attempt ${attempt + 1}/${retries}), retrying in ${delay}ms: ${errorMsg}`);
@@ -6480,15 +6544,27 @@ var init_sandbox_file_sync = __esm({
               return sendWithRetry(attempt + 1);
             }
             console.error(`[FILE_SYNC] Webhook failed after ${retries} attempts: ${errorMsg}`);
-            throw error;
+            return { success: false, error: errorMsg, durationMs, retryCount: attempt };
           }
         };
+        const webhookType = payload.event === "file_sync" ? "file_sync" : "file_change";
+        const filePath = payload.fileSyncEvent?.canonicalPath ?? payload.fileChangeEvent?.relativePath;
+        const operation = payload.fileSyncEvent?.operation ?? payload.fileChangeEvent?.type;
         if (isAsync) {
-          sendWithRetry(0).catch((error) => {
+          sendWithRetry(0).then(async (result) => {
+            if (sessionId) {
+              await this.persistWebhookDelivery(sessionId, webhookType, result, filePath, operation);
+            }
+          }).catch((error) => {
             console.error("[FILE_SYNC] Async webhook failed:", error);
           });
+          return null;
         } else {
-          await sendWithRetry(0);
+          const result = await sendWithRetry(0);
+          if (sessionId) {
+            await this.persistWebhookDelivery(sessionId, webhookType, result, filePath, operation);
+          }
+          return result;
         }
       }
       /**
@@ -6502,7 +6578,7 @@ var init_sandbox_file_sync = __esm({
           metadata: this.webhookConfig?.metadata,
           fileSyncEvent: event
         };
-        await this.sendWebhook(payload);
+        await this.sendWebhook(payload, sessionId);
       }
       /**
        * Send a file change event webhook (from watcher)
@@ -6515,7 +6591,7 @@ var init_sandbox_file_sync = __esm({
           metadata: this.webhookConfig?.metadata,
           fileChangeEvent: event
         };
-        await this.sendWebhook(payload);
+        await this.sendWebhook(payload, event.sessionId);
       }
       /**
        * Get the next sequence number for a session
@@ -6601,10 +6677,10 @@ var init_sandbox_file_sync = __esm({
             const isTextFile = diff !== void 0 || event.newContent && !event.newContent.slice(0, 8192).includes(0);
             const eventData = {
               operation: event.operation,
-              direction: event.direction,
-              source: "internal",
-              // File sync operations are internal
-              filePath: event.filePath,
+              source: event.source,
+              canonicalPath: event.canonicalPath,
+              basePath: event.basePath,
+              sandboxPath: event.sandboxPath,
               fileSize: event.fileSize,
               success: event.success,
               error: event.error,
@@ -6612,7 +6688,7 @@ var init_sandbox_file_sync = __esm({
               isTextFile,
               previousSize: event.previousContent?.length
             };
-            const eventType = `file_${event.operation}`;
+            const eventType = event.operation;
             const sessionEvent = {
               eventType,
               category: exports.EventCategory.FILE,
@@ -6635,6 +6711,13 @@ var init_sandbox_file_sync = __esm({
       setSandboxOperations(ops) {
         this.sandboxOps = ops;
       }
+      /**
+       * Get the effective base path for sandbox operations
+       * @param targetPath - Optional override for the base path
+       */
+      getBasePath(targetPath) {
+        return targetPath ?? this.sandboxBasePath;
+      }
       /**
        * Get the full sandbox path for a file
        * @param path - The relative file path
@@ -6642,18 +6725,36 @@ var init_sandbox_file_sync = __esm({
        */
       getSandboxPath(path15, targetPath) {
         const normalizedPath = path15.replace(/^\/+/, "");
-        const basePath = targetPath ?? this.sandboxBasePath;
+        const basePath = this.getBasePath(targetPath);
         if (basePath === ".") {
           return normalizedPath;
         }
         return `${basePath}/${normalizedPath}`;
       }
+      /**
+       * Build all path fields for a FileSyncEvent
+       * @param path - The canonical file path (used as S3 key)
+       * @param targetPath - Optional override for the base path
+       */
+      buildPathFields(path15, targetPath) {
+        const normalizedPath = path15.replace(/^\/+/, "");
+        const basePath = this.getBasePath(targetPath);
+        const sandboxPath = this.getSandboxPath(path15, targetPath);
+        return {
+          canonicalPath: normalizedPath,
+          // The logical path (S3 key)
+          basePath,
+          // The prefix used in sandbox
+          sandboxPath
+          // Full computed path in sandbox
+        };
+      }
       /**
        * Push a file: writes to S3, then to sandbox if running
        * @param sessionId - Session ID
        * @param path - File path (stored in S3 and used as relative path in sandbox)
        * @param content - File content
-       * @param options - Push options (e.g., targetPath to override sandbox location)
+       * @param options - Push options (e.g., targetPath, source)
        * @param previousContent - Optional previous content for diff computation
        */
       async pushFile(sessionId, path15, content, options, previousContent) {
@@ -6662,13 +6763,16 @@ var init_sandbox_file_sync = __esm({
           s3Written: false,
           sandboxWritten: false
         };
+        const source = options?.source ?? "client_api";
+        const uploadToStorageOp = source === "client_api" ? "client_uploaded_to_ash_storage" : "agent_sandbox_saved_to_ash_storage";
+        const pathFields = this.buildPathFields(path15, options?.targetPath);
         try {
           await this.fileStore.writeFile(sessionId, path15, content);
           result.s3Written = true;
           await this.emitFileEvent(sessionId, {
-            operation: "push",
-            direction: "to_s3",
-            filePath: path15,
+            operation: uploadToStorageOp,
+            source,
+            ...pathFields,
             fileSize: content.length,
             success: true,
             previousContent,
@@ -6679,9 +6783,9 @@ var init_sandbox_file_sync = __esm({
           result.error = `S3 write failed: ${errorMessage}`;
           console.error(`[FILE_SYNC] S3 write failed for session ${sessionId}, path ${path15}:`, error);
           await this.emitFileEvent(sessionId, {
-            operation: "push",
-            direction: "to_s3",
-            filePath: path15,
+            operation: uploadToStorageOp,
+            source,
+            ...pathFields,
             fileSize: content.length,
             success: false,
             error: errorMessage
@@ -6690,13 +6794,12 @@ var init_sandbox_file_sync = __esm({
         }
         if (this.sandboxOps?.isSandboxRunning(sessionId)) {
           try {
-            const sandboxPath = this.getSandboxPath(path15, options?.targetPath);
-            const writeResult = await this.sandboxOps.writeFile(sessionId, sandboxPath, content);
+            const writeResult = await this.sandboxOps.writeFile(sessionId, pathFields.sandboxPath, content);
             result.sandboxWritten = writeResult.success;
             await this.emitFileEvent(sessionId, {
-              operation: "push",
-              direction: "to_sandbox",
-              filePath: path15,
+              operation: "ash_storage_synced_to_agent_sandbox",
+              source,
+              ...pathFields,
               fileSize: content.length,
               success: writeResult.success,
               error: writeResult.error
@@ -6708,9 +6811,9 @@ var init_sandbox_file_sync = __esm({
             const errorMessage = extractErrorMessage(error);
             console.warn(`[FILE_SYNC] Sandbox write error for ${path15}: ${errorMessage}`);
             await this.emitFileEvent(sessionId, {
-              operation: "push",
-              direction: "to_sandbox",
-              filePath: path15,
+              operation: "ash_storage_synced_to_agent_sandbox",
+              source,
+              ...pathFields,
               fileSize: content.length,
               success: false,
               error: errorMessage
@@ -6738,8 +6841,12 @@ var init_sandbox_file_sync = __esm({
       /**
        * Pull a file from sandbox to S3
        * Reads from sandbox and writes to S3
+       *
+       * @param sessionId - Session ID
+       * @param path - File path (relative to sandbox)
+       * @param options - Pull options (e.g., targetPath to override sandbox location)
        */
-      async pullFile(sessionId, path15) {
+      async pullFile(sessionId, path15, options) {
         const result = {
           path: path15,
           content: null,
@@ -6749,15 +6856,15 @@ var init_sandbox_file_sync = __esm({
           result.error = "Sandbox is not running";
           return result;
         }
+        const pathFields = this.buildPathFields(path15, options?.targetPath);
         try {
-          const sandboxPath = this.getSandboxPath(path15);
-          const readResult = await this.sandboxOps.readFile(sessionId, sandboxPath);
+          const readResult = await this.sandboxOps.readFile(sessionId, pathFields.sandboxPath);
           if (!readResult.success || !readResult.content) {
             result.error = readResult.error ?? "File not found in sandbox";
             await this.emitFileEvent(sessionId, {
-              operation: "pull",
-              direction: "from_sandbox",
-              filePath: path15,
+              operation: "read_from_agent_sandbox",
+              source: "ash_file_sync",
+              ...pathFields,
               success: false,
               error: result.error
             });
@@ -6765,9 +6872,9 @@ var init_sandbox_file_sync = __esm({
           }
           result.content = readResult.content;
           await this.emitFileEvent(sessionId, {
-            operation: "pull",
-            direction: "from_sandbox",
-            filePath: path15,
+            operation: "read_from_agent_sandbox",
+            source: "ash_file_sync",
+            ...pathFields,
             fileSize: readResult.content.length,
             success: true,
             newContent: readResult.content
@@ -6776,9 +6883,9 @@ var init_sandbox_file_sync = __esm({
           const errorMessage = extractErrorMessage(error);
           result.error = `Sandbox read failed: ${errorMessage}`;
           await this.emitFileEvent(sessionId, {
-            operation: "pull",
-            direction: "from_sandbox",
-            filePath: path15,
+            operation: "read_from_agent_sandbox",
+            source: "ash_file_sync",
+            ...pathFields,
             success: false,
             error: errorMessage
           });
@@ -6788,9 +6895,9 @@ var init_sandbox_file_sync = __esm({
           await this.fileStore.writeFile(sessionId, path15, result.content);
           result.s3Written = true;
           await this.emitFileEvent(sessionId, {
-            operation: "pull",
-            direction: "to_s3",
-            filePath: path15,
+            operation: "agent_sandbox_saved_to_ash_storage",
+            source: "ash_file_sync",
+            ...pathFields,
             fileSize: result.content.length,
             success: true,
             newContent: result.content
@@ -6800,9 +6907,9 @@ var init_sandbox_file_sync = __esm({
           result.error = `S3 write failed: ${errorMessage}`;
           console.error(`[FILE_SYNC] S3 write failed in pullFile for session ${sessionId}, path ${path15}:`, error);
           await this.emitFileEvent(sessionId, {
-            operation: "pull",
-            direction: "to_s3",
-            filePath: path15,
+            operation: "agent_sandbox_saved_to_ash_storage",
+            source: "ash_file_sync",
+            ...pathFields,
             fileSize: result.content?.length,
             success: false,
             error: errorMessage
@@ -6844,43 +6951,43 @@ var init_sandbox_file_sync = __esm({
        */
       async deleteFile(sessionId, path15) {
         const result = { s3Deleted: false, sandboxDeleted: false };
+        const pathFields = this.buildPathFields(path15);
         try {
           await this.fileStore.deleteFile(sessionId, path15);
           result.s3Deleted = true;
           await this.emitFileEvent(sessionId, {
-            operation: "delete",
-            direction: "from_s3",
-            filePath: path15,
+            operation: "deleted_from_ash_storage",
+            source: "ash_file_sync",
+            ...pathFields,
             success: true
           });
         } catch (error) {
           const errorMessage = extractErrorMessage(error);
           console.warn(`[FILE_SYNC] S3 delete failed for ${path15}: ${errorMessage}`);
           await this.emitFileEvent(sessionId, {
-            operation: "delete",
-            direction: "from_s3",
-            filePath: path15,
+            operation: "deleted_from_ash_storage",
+            source: "ash_file_sync",
+            ...pathFields,
             success: false,
             error: errorMessage
           });
         }
         if (this.sandboxOps?.isSandboxRunning(sessionId)) {
           try {
-            const sandboxPath = this.getSandboxPath(path15);
-            console.log(`[FILE_SYNC] Would delete ${sandboxPath} from sandbox`);
+            console.log(`[FILE_SYNC] Would delete ${pathFields.sandboxPath} from sandbox`);
             result.sandboxDeleted = true;
             await this.emitFileEvent(sessionId, {
-              operation: "delete",
-              direction: "from_sandbox",
-              filePath: path15,
+              operation: "deleted_from_agent_sandbox",
+              source: "ash_file_sync",
+              ...pathFields,
               success: true
             });
           } catch (error) {
             const errorMessage = extractErrorMessage(error);
             await this.emitFileEvent(sessionId, {
-              operation: "delete",
-              direction: "from_sandbox",
-              filePath: path15,
+              operation: "deleted_from_agent_sandbox",
+              source: "ash_file_sync",
+              ...pathFields,
               success: false,
               error: errorMessage
             });
@@ -6900,36 +7007,36 @@ var init_sandbox_file_sync = __esm({
         }
         const files = await this.fileStore.listFiles(sessionId);
         for (const file of files) {
+          const pathFields = this.buildPathFields(file.path);
           try {
             const content = await this.fileStore.readFile(sessionId, file.path);
             if (!content) {
               result.errors.push({ path: file.path, error: "File not found in S3" });
               await this.emitFileEvent(sessionId, {
-                operation: "sync_to_sandbox",
-                direction: "from_s3",
-                filePath: file.path,
+                operation: "ash_storage_synced_to_agent_sandbox",
+                source: "ash_file_sync",
+                ...pathFields,
                 success: false,
-                error: "File not found in S3"
+                error: "File not found in Ash storage"
               });
               continue;
             }
-            const sandboxPath = this.getSandboxPath(file.path);
-            const writeResult = await this.sandboxOps.writeFile(sessionId, sandboxPath, content);
+            const writeResult = await this.sandboxOps.writeFile(sessionId, pathFields.sandboxPath, content);
             if (writeResult.success) {
               result.fileCount++;
               await this.emitFileEvent(sessionId, {
-                operation: "sync_to_sandbox",
-                direction: "to_sandbox",
-                filePath: file.path,
+                operation: "ash_storage_synced_to_agent_sandbox",
+                source: "ash_file_sync",
+                ...pathFields,
                 fileSize: content.length,
                 success: true
               });
             } else {
               result.errors.push({ path: file.path, error: writeResult.error ?? "Unknown error" });
               await this.emitFileEvent(sessionId, {
-                operation: "sync_to_sandbox",
-                direction: "to_sandbox",
-                filePath: file.path,
+                operation: "ash_storage_synced_to_agent_sandbox",
+                source: "ash_file_sync",
+                ...pathFields,
                 fileSize: content.length,
                 success: false,
                 error: writeResult.error
@@ -6942,9 +7049,9 @@ var init_sandbox_file_sync = __esm({
               error: errorMessage
             });
             await this.emitFileEvent(sessionId, {
-              operation: "sync_to_sandbox",
-              direction: "to_sandbox",
-              filePath: file.path,
+              operation: "ash_storage_synced_to_agent_sandbox",
+              source: "ash_file_sync",
+              ...pathFields,
               success: false,
               error: errorMessage
             });
@@ -6975,39 +7082,25 @@ var init_sandbox_file_sync = __esm({
             return result;
           }
         }
-        for (const filePath of filesToSync) {
+        for (const file of filesToSync) {
+          const pathFields = this.buildPathFields(file);
           try {
-            const pullResult = await this.pullFile(sessionId, filePath);
+            const pullResult = await this.pullFile(sessionId, file);
             if (pullResult.s3Written) {
               result.fileCount++;
-              await this.emitFileEvent(sessionId, {
-                operation: "sync_from_sandbox",
-                direction: "to_s3",
-                filePath,
-                fileSize: pullResult.content?.length,
-                success: true,
-                newContent: pullResult.content ?? void 0
-              });
             } else if (pullResult.error) {
-              result.errors.push({ path: filePath, error: pullResult.error });
-              await this.emitFileEvent(sessionId, {
-                operation: "sync_from_sandbox",
-                direction: "to_s3",
-                filePath,
-                success: false,
-                error: pullResult.error
-              });
+              result.errors.push({ path: file, error: pullResult.error });
             }
           } catch (error) {
             const errorMessage = extractErrorMessage(error);
             result.errors.push({
-              path: filePath,
+              path: file,
               error: errorMessage
             });
             await this.emitFileEvent(sessionId, {
-              operation: "sync_from_sandbox",
-              direction: "to_s3",
-              filePath,
+              operation: "agent_sandbox_saved_to_ash_storage",
+              source: "ash_file_sync",
+              ...pathFields,
               success: false,
               error: errorMessage
             });
@@ -7042,9 +7135,10 @@ var init_sandbox_file_sync = __esm({
        */
       async startWatching(sessionId, options) {
         const opts = { ...this.defaultWatchOptions, ...options };
+        const watchPath = opts.watchPaths?.[0] ?? ".";
         await this.stopWatching(sessionId);
         const handleFileChange = async (event) => {
-          console.log(`[FILE_SYNC] File change detected: ${event.type} ${event.relativePath}`);
+          console.log(`[FILE_SYNC] File change detected: ${event.type} ${event.relativePath} (watching from: ${watchPath})`);
           if (this.webhookConfig) {
             this.sendFileChangeWebhook(event);
           }
@@ -7057,7 +7151,7 @@ var init_sandbox_file_sync = __esm({
           }
           if (event.type === "add" || event.type === "change") {
             try {
-              const pullResult = await this.pullFile(sessionId, event.relativePath);
+              const pullResult = await this.pullFile(sessionId, event.relativePath, { targetPath: watchPath });
               if (pullResult.s3Written) {
                 console.log(`[FILE_SYNC] Auto-synced ${event.relativePath} to S3`);
               } else if (pullResult.error) {
@@ -7088,7 +7182,7 @@ var init_sandbox_file_sync = __esm({
           });
           await watcher.start();
           this.localWatchers.set(sessionId, watcher);
-          console.log(`[FILE_SYNC] Started local file watching for session ${sessionId}`);
+          console.log(`[FILE_SYNC] Started local file watching for session ${sessionId} at ${opts.localPath}`);
         } else {
           if (!this.sandboxOps) {
             throw new Error("Sandbox operations not configured. Call setSandboxOperations first.");
@@ -7096,7 +7190,8 @@ var init_sandbox_file_sync = __esm({
           const watcher = new exports.RemoteSandboxFileWatcher({
             sessionId,
             sandboxOps: this.sandboxOps,
-            basePath: this.sandboxBasePath,
+            basePath: watchPath,
+            // Use watchPath instead of sandboxBasePath
             pollIntervalMs: opts.pollIntervalMs ?? 2e3,
             ignored: opts.ignored ?? ["**/node_modules/**", "**/.git/**"],
             onFileChange: handleFileChange,
@@ -7106,7 +7201,7 @@ var init_sandbox_file_sync = __esm({
           });
           await watcher.start();
           this.remoteWatchers.set(sessionId, watcher);
-          console.log(`[FILE_SYNC] Started remote file watching for session ${sessionId}`);
+          console.log(`[FILE_SYNC] Started remote file watching for session ${sessionId} at path: ${watchPath}`);
         }
       }
       /**
@@ -7419,6 +7514,7 @@ WATCHER_EOF`;
                 type: data.type,
                 relativePath: data.path.replace(/^\.\//, ""),
                 absolutePath: data.path,
+                basePath: this.watchPath,
                 sessionId: this.sessionId,
                 timestamp: new Date(data.timestamp)
               });
@@ -16241,8 +16337,10 @@ var init_schema = __esm({
       // error events
       "file",
       // file_push, file_pull, file_sync (file sync operations)
-      "input"
+      "input",
       // user_input (user prompts/messages)
+      "webhook"
+      // webhook_delivery, webhook_failure (outbound webhook events)
     ]);
     sessions = pgCore.pgTable(
       "sessions",