@dexto/server 1.2.5

package/dist/approval/manual-approval-handler.cjs

@@ -0,0 +1,100 @@
+"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 manual_approval_handler_exports = {};
+__export(manual_approval_handler_exports, {
+  createManualApprovalHandler: () => createManualApprovalHandler
+});
+module.exports = __toCommonJS(manual_approval_handler_exports);
+var import_core = require("@dexto/core");
+function createManualApprovalHandler(coordinator) {
+  const pendingApprovals = /* @__PURE__ */ new Map();
+  const handleApproval = (request) => {
+    return new Promise((resolve) => {
+      const effectiveTimeout = request.timeout;
+      const timer = setTimeout(() => {
+        cleanup();
+        pendingApprovals.delete(request.approvalId);
+        const timeoutResponse = {
+          approvalId: request.approvalId,
+          status: import_core.ApprovalStatus.CANCELLED,
+          sessionId: request.sessionId,
+          reason: import_core.DenialReason.TIMEOUT,
+          message: `Approval request timed out after ${effectiveTimeout}ms`,
+          timeoutMs: effectiveTimeout
+        };
+        coordinator.emitResponse(timeoutResponse);
+        resolve(timeoutResponse);
+      }, effectiveTimeout);
+      let cleanupListener = null;
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (cleanupListener) {
+          cleanupListener();
+          cleanupListener = null;
+        }
+      };
+      const listener = (res) => {
+        if (res.approvalId === request.approvalId) {
+          cleanup();
+          pendingApprovals.delete(request.approvalId);
+          resolve(res);
+        }
+      };
+      coordinator.on("approval:response", listener);
+      cleanupListener = () => coordinator.off("approval:response", listener);
+      pendingApprovals.set(request.approvalId, {
+        cleanup,
+        resolve,
+        request
+      });
+      coordinator.emitRequest(request);
+    });
+  };
+  const handler = Object.assign(handleApproval, {
+    cancel: (approvalId) => {
+      const pending = pendingApprovals.get(approvalId);
+      if (pending) {
+        pending.cleanup();
+        pendingApprovals.delete(approvalId);
+        const cancelResponse = {
+          approvalId,
+          status: import_core.ApprovalStatus.CANCELLED,
+          sessionId: pending.request.sessionId,
+          reason: import_core.DenialReason.SYSTEM_CANCELLED,
+          message: "Approval request was cancelled"
+        };
+        coordinator.emitResponse(cancelResponse);
+        pending.resolve(cancelResponse);
+      }
+    },
+    cancelAll: () => {
+      for (const [approvalId] of pendingApprovals) {
+        handler.cancel?.(approvalId);
+      }
+    },
+    getPending: () => {
+      return Array.from(pendingApprovals.keys());
+    }
+  });
+  return handler;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createManualApprovalHandler
+});

package/dist/approval/manual-approval-handler.d.ts

@@ -0,0 +1,32 @@
+import type { ApprovalHandler } from '@dexto/core';
+import type { ApprovalCoordinator } from './approval-coordinator.js';
+/**
+ * Creates a manual approval handler that uses ApprovalCoordinator for server communication.
+ *
+ * This handler emits `approval:request` and waits for `approval:response` via the coordinator,
+ * enabling SSE-based approval flows where:
+ * 1. Handler emits approval:request → Coordinator → SSE endpoint forwards to client
+ * 2. Client sends decision via POST /api/approvals/{approvalId}
+ * 3. API route emits approval:response → Coordinator → Handler resolves
+ *
+ * The returned handler implements the optional cancellation methods (cancel, cancelAll, getPending)
+ * for managing pending approval requests.
+ *
+ * Timeouts are handled per-request using the timeout value from ApprovalRequest, which
+ * is set by ApprovalManager based on the request type (tool confirmation vs elicitation).
+ *
+ * @param coordinator The approval coordinator for request/response communication
+ * @returns ApprovalHandler with cancellation support
+ *
+ * @example
+ * ```typescript
+ * const coordinator = new ApprovalCoordinator();
+ * const handler = createManualApprovalHandler(coordinator);
+ * agent.setApprovalHandler(handler);
+ *
+ * // Later, cancel a specific approval (if handler supports it)
+ * handler.cancel?.('approval-id-123');
+ * ```
+ */
+export declare function createManualApprovalHandler(coordinator: ApprovalCoordinator): ApprovalHandler;
+//# sourceMappingURL=manual-approval-handler.d.ts.map

package/dist/approval/manual-approval-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manual-approval-handler.d.ts","sourceRoot":"","sources":["../../src/approval/manual-approval-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAqC,MAAM,aAAa,CAAC;AAEtF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,mBAAmB,GAAG,eAAe,CAiH7F"}

package/dist/approval/manual-approval-handler.js

@@ -0,0 +1,76 @@
+import { ApprovalStatus, DenialReason } from "@dexto/core";
+function createManualApprovalHandler(coordinator) {
+  const pendingApprovals = /* @__PURE__ */ new Map();
+  const handleApproval = (request) => {
+    return new Promise((resolve) => {
+      const effectiveTimeout = request.timeout;
+      const timer = setTimeout(() => {
+        cleanup();
+        pendingApprovals.delete(request.approvalId);
+        const timeoutResponse = {
+          approvalId: request.approvalId,
+          status: ApprovalStatus.CANCELLED,
+          sessionId: request.sessionId,
+          reason: DenialReason.TIMEOUT,
+          message: `Approval request timed out after ${effectiveTimeout}ms`,
+          timeoutMs: effectiveTimeout
+        };
+        coordinator.emitResponse(timeoutResponse);
+        resolve(timeoutResponse);
+      }, effectiveTimeout);
+      let cleanupListener = null;
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (cleanupListener) {
+          cleanupListener();
+          cleanupListener = null;
+        }
+      };
+      const listener = (res) => {
+        if (res.approvalId === request.approvalId) {
+          cleanup();
+          pendingApprovals.delete(request.approvalId);
+          resolve(res);
+        }
+      };
+      coordinator.on("approval:response", listener);
+      cleanupListener = () => coordinator.off("approval:response", listener);
+      pendingApprovals.set(request.approvalId, {
+        cleanup,
+        resolve,
+        request
+      });
+      coordinator.emitRequest(request);
+    });
+  };
+  const handler = Object.assign(handleApproval, {
+    cancel: (approvalId) => {
+      const pending = pendingApprovals.get(approvalId);
+      if (pending) {
+        pending.cleanup();
+        pendingApprovals.delete(approvalId);
+        const cancelResponse = {
+          approvalId,
+          status: ApprovalStatus.CANCELLED,
+          sessionId: pending.request.sessionId,
+          reason: DenialReason.SYSTEM_CANCELLED,
+          message: "Approval request was cancelled"
+        };
+        coordinator.emitResponse(cancelResponse);
+        pending.resolve(cancelResponse);
+      }
+    },
+    cancelAll: () => {
+      for (const [approvalId] of pendingApprovals) {
+        handler.cancel?.(approvalId);
+      }
+    },
+    getPending: () => {
+      return Array.from(pendingApprovals.keys());
+    }
+  });
+  return handler;
+}
+export {
+  createManualApprovalHandler
+};

package/dist/events/a2a-sse-subscriber.cjs

@@ -0,0 +1,271 @@
+"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 a2a_sse_subscriber_exports = {};
+__export(a2a_sse_subscriber_exports, {
+  A2ASseEventSubscriber: () => A2ASseEventSubscriber
+});
+module.exports = __toCommonJS(a2a_sse_subscriber_exports);
+var import_events = require("events");
+var import_core2 = require("@dexto/core");
+class A2ASseEventSubscriber {
+  connections = /* @__PURE__ */ new Map();
+  eventBus;
+  globalAbortController;
+  /**
+   * Subscribe to agent event bus.
+   * Sets up global event listeners that broadcast to all SSE connections.
+   *
+   * @param eventBus Agent event bus to subscribe to
+   */
+  subscribe(eventBus) {
+    this.globalAbortController?.abort();
+    this.globalAbortController = new AbortController();
+    const { signal } = this.globalAbortController;
+    const MAX_SHARED_SIGNAL_LISTENERS = 20;
+    (0, import_events.setMaxListeners)(MAX_SHARED_SIGNAL_LISTENERS, signal);
+    this.eventBus = eventBus;
+    eventBus.on(
+      "llm:thinking",
+      (payload) => {
+        this.broadcastToTask(payload.sessionId, "task.thinking", {
+          taskId: payload.sessionId
+        });
+      },
+      { signal }
+    );
+    eventBus.on(
+      "llm:chunk",
+      (payload) => {
+        this.broadcastToTask(payload.sessionId, "task.chunk", {
+          taskId: payload.sessionId,
+          type: payload.chunkType,
+          content: payload.content,
+          isComplete: payload.isComplete
+        });
+      },
+      { signal }
+    );
+    eventBus.on(
+      "llm:tool-call",
+      (payload) => {
+        this.broadcastToTask(payload.sessionId, "task.toolCall", {
+          taskId: payload.sessionId,
+          toolName: payload.toolName,
+          args: payload.args,
+          callId: payload.callId
+        });
+      },
+      { signal }
+    );
+    eventBus.on(
+      "llm:tool-result",
+      (payload) => {
+        const data = {
+          taskId: payload.sessionId,
+          toolName: payload.toolName,
+          callId: payload.callId,
+          success: payload.success,
+          sanitized: payload.sanitized
+        };
+        if (payload.rawResult !== void 0) {
+          data.rawResult = payload.rawResult;
+        }
+        this.broadcastToTask(payload.sessionId, "task.toolResult", data);
+      },
+      { signal }
+    );
+    eventBus.on(
+      "llm:response",
+      (payload) => {
+        this.broadcastToTask(payload.sessionId, "task.message", {
+          taskId: payload.sessionId,
+          message: {
+            role: "agent",
+            content: [{ type: "text", text: payload.content }],
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          tokenUsage: payload.tokenUsage,
+          provider: payload.provider,
+          model: payload.model
+        });
+      },
+      { signal }
+    );
+    eventBus.on(
+      "llm:error",
+      (payload) => {
+        this.broadcastToTask(payload.sessionId, "task.error", {
+          taskId: payload.sessionId,
+          error: {
+            message: payload.error.message,
+            recoverable: payload.recoverable
+          }
+        });
+      },
+      { signal }
+    );
+    eventBus.on(
+      "session:reset",
+      (payload) => {
+        this.broadcastToTask(payload.sessionId, "task.reset", {
+          taskId: payload.sessionId
+        });
+      },
+      { signal }
+    );
+    import_core2.logger.debug("A2ASseEventSubscriber subscribed to agent events");
+  }
+  /**
+   * Create a new SSE stream for a specific task.
+   *
+   * Returns a ReadableStream that emits SSE events for the task.
+   *
+   * @param taskId Task/Session ID to stream events for
+   * @returns ReadableStream for SSE connection
+   */
+  createStream(taskId) {
+    const connectionId = `${taskId}-${Date.now()}`;
+    return new ReadableStream({
+      start: (controller) => {
+        const connection = {
+          taskId,
+          controller,
+          abortController: new AbortController(),
+          connectedAt: Date.now()
+        };
+        this.connections.set(connectionId, connection);
+        import_core2.logger.debug(`SSE connection opened for task ${taskId}`);
+        this.sendSSEEvent(controller, "connected", {
+          taskId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const keepaliveInterval = setInterval(() => {
+          try {
+            this.sendSSEComment(controller, "keepalive");
+          } catch (_error) {
+            clearInterval(keepaliveInterval);
+          }
+        }, 3e4);
+        connection.abortController.signal.addEventListener("abort", () => {
+          clearInterval(keepaliveInterval);
+        });
+      },
+      cancel: () => {
+        const connection = this.connections.get(connectionId);
+        if (connection) {
+          connection.abortController.abort();
+          this.connections.delete(connectionId);
+          import_core2.logger.debug(`SSE connection closed for task ${taskId}`);
+        }
+      }
+    });
+  }
+  /**
+   * Broadcast an event to a specific task's SSE connections.
+   *
+   * @param taskId Task ID to broadcast to
+   * @param eventName SSE event name
+   * @param data Event data
+   */
+  broadcastToTask(taskId, eventName, data) {
+    let sent = 0;
+    for (const [connectionId, connection] of this.connections.entries()) {
+      if (connection.taskId === taskId) {
+        try {
+          this.sendSSEEvent(connection.controller, eventName, data);
+          sent++;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          import_core2.logger.warn(`Failed to send SSE event to ${connectionId}: ${errorMessage}`);
+          connection.abortController.abort();
+          this.connections.delete(connectionId);
+        }
+      }
+    }
+    if (sent > 0) {
+      import_core2.logger.debug(`Broadcast ${eventName} to ${sent} SSE connection(s) for task ${taskId}`);
+    }
+  }
+  /**
+   * Send an SSE event to a specific controller.
+   *
+   * Format: event: name\ndata: json\n\n
+   *
+   * @param controller Stream controller
+   * @param eventName Event name
+   * @param data Event data
+   */
+  sendSSEEvent(controller, eventName, data) {
+    const event = `event: ${eventName}
+data: ${JSON.stringify(data)}
+
+`;
+    controller.enqueue(new TextEncoder().encode(event));
+  }
+  /**
+   * Send an SSE comment (for keepalive).
+   *
+   * Format: : comment\n
+   *
+   * @param controller Stream controller
+   * @param comment Comment text
+   */
+  sendSSEComment(controller, comment) {
+    const line = `: ${comment}
+`;
+    controller.enqueue(new TextEncoder().encode(line));
+  }
+  /**
+   * Close all connections and cleanup.
+   */
+  cleanup() {
+    import_core2.logger.debug(`Cleaning up ${this.connections.size} SSE connections`);
+    for (const [_connectionId, connection] of this.connections.entries()) {
+      connection.abortController.abort();
+      try {
+        connection.controller.close();
+      } catch (_error) {
+      }
+    }
+    this.connections.clear();
+    this.globalAbortController?.abort();
+  }
+  /**
+   * Get active connection count.
+   */
+  getConnectionCount() {
+    return this.connections.size;
+  }
+  /**
+   * Get connection count for a specific task.
+   */
+  getTaskConnectionCount(taskId) {
+    let count = 0;
+    for (const connection of this.connections.values()) {
+      if (connection.taskId === taskId) {
+        count++;
+      }
+    }
+    return count;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2ASseEventSubscriber
+});

package/dist/events/a2a-sse-subscriber.d.ts

@@ -0,0 +1,94 @@
+/**
+ * A2A SSE (Server-Sent Events) Event Subscriber
+ *
+ * Subscribes to agent events and streams them to SSE clients for A2A tasks.
+ * Uses standard SSE protocol (text/event-stream).
+ *
+ * Design:
+ * - Filters events by taskId/sessionId for targeted streaming
+ * - Uses standard SSE format: event: name\ndata: json\n\n
+ * - Supports multiple concurrent SSE connections
+ */
+import { AgentEventBus } from '@dexto/core';
+/**
+ * A2A SSE Event Subscriber
+ *
+ * Manages Server-Sent Events connections for A2A Protocol task streaming.
+ *
+ * Usage:
+ * ```typescript
+ * const sseSubscriber = new A2ASseEventSubscriber();
+ * sseSubscriber.subscribe(agent.agentEventBus);
+ *
+ * // In route handler
+ * const stream = sseSubscriber.createStream(taskId);
+ * return new Response(stream, {
+ *   headers: {
+ *     'Content-Type': 'text/event-stream',
+ *     'Cache-Control': 'no-cache',
+ *     'Connection': 'keep-alive'
+ *   }
+ * });
+ * ```
+ */
+export declare class A2ASseEventSubscriber {
+    private connections;
+    private eventBus?;
+    private globalAbortController?;
+    /**
+     * Subscribe to agent event bus.
+     * Sets up global event listeners that broadcast to all SSE connections.
+     *
+     * @param eventBus Agent event bus to subscribe to
+     */
+    subscribe(eventBus: AgentEventBus): void;
+    /**
+     * Create a new SSE stream for a specific task.
+     *
+     * Returns a ReadableStream that emits SSE events for the task.
+     *
+     * @param taskId Task/Session ID to stream events for
+     * @returns ReadableStream for SSE connection
+     */
+    createStream(taskId: string): ReadableStream<Uint8Array>;
+    /**
+     * Broadcast an event to a specific task's SSE connections.
+     *
+     * @param taskId Task ID to broadcast to
+     * @param eventName SSE event name
+     * @param data Event data
+     */
+    private broadcastToTask;
+    /**
+     * Send an SSE event to a specific controller.
+     *
+     * Format: event: name\ndata: json\n\n
+     *
+     * @param controller Stream controller
+     * @param eventName Event name
+     * @param data Event data
+     */
+    private sendSSEEvent;
+    /**
+     * Send an SSE comment (for keepalive).
+     *
+     * Format: : comment\n
+     *
+     * @param controller Stream controller
+     * @param comment Comment text
+     */
+    private sendSSEComment;
+    /**
+     * Close all connections and cleanup.
+     */
+    cleanup(): void;
+    /**
+     * Get active connection count.
+     */
+    getConnectionCount(): number;
+    /**
+     * Get connection count for a specific task.
+     */
+    getTaskConnectionCount(taskId: string): number;
+}
+//# sourceMappingURL=a2a-sse-subscriber.d.ts.map

package/dist/events/a2a-sse-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-sse-subscriber.d.ts","sourceRoot":"","sources":["../../src/events/a2a-sse-subscriber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAiB5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,WAAW,CAAyC;IAC5D,OAAO,CAAC,QAAQ,CAAC,CAAgB;IACjC,OAAO,CAAC,qBAAqB,CAAC,CAAkB;IAEhD;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAkHxC;;;;;;;OAOG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC,UAAU,CAAC;IAiDxD;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IA0BvB;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY;IASpB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAKtB;;OAEG;IACH,OAAO,IAAI,IAAI;IAgBf;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;OAEG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CASjD"}