@dexto/server 1.2.5

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

@@ -0,0 +1,247 @@
+import { setMaxListeners } from "events";
+import { logger } from "@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;
+    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 }
+    );
+    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);
+        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);
+          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);
+          logger.warn(`Failed to send SSE event to ${connectionId}: ${errorMessage}`);
+          connection.abortController.abort();
+          this.connections.delete(connectionId);
+        }
+      }
+    }
+    if (sent > 0) {
+      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() {
+    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;
+  }
+}
+export {
+  A2ASseEventSubscriber
+};

package/dist/events/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/events/types.d.ts

@@ -0,0 +1,15 @@
+import { AgentEventBus } from '@dexto/core';
+/**
+ * Generic interface for subscribing to core events.
+ */
+export interface EventSubscriber {
+    /**
+     * Attach event handlers to the given event bus.
+     */
+    subscribe(eventBus: AgentEventBus): void;
+    /**
+     * Clean up event listeners and resources.
+     */
+    cleanup?(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/events/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/events/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAC;IAEzC;;OAEG;IACH,OAAO,CAAC,IAAI,IAAI,CAAC;CACpB"}

package/dist/events/webhook-subscriber.cjs

@@ -0,0 +1,301 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webhook_subscriber_exports = {};
+__export(webhook_subscriber_exports, {
+  WebhookEventSubscriber: () => WebhookEventSubscriber
+});
+module.exports = __toCommonJS(webhook_subscriber_exports);
+var import_crypto = __toESM(require("crypto"), 1);
+var import_events = require("events");
+var import_core = require("@dexto/core");
+var import_core2 = require("@dexto/core");
+const DEFAULT_DELIVERY_OPTIONS = {
+  maxRetries: 3,
+  timeout: 1e4,
+  // 10 seconds
+  includeSignature: true
+};
+class WebhookEventSubscriber {
+  webhooks = /* @__PURE__ */ new Map();
+  abortController;
+  deliveryOptions;
+  fetchFn;
+  constructor({
+    fetchFn,
+    ...deliveryOptions
+  } = {}) {
+    this.deliveryOptions = { ...DEFAULT_DELIVERY_OPTIONS, ...deliveryOptions };
+    this.fetchFn = fetchFn || fetch;
+    import_core2.logger.debug("WebhookEventSubscriber initialized");
+  }
+  /**
+   * Subscribe to agent events and deliver them to registered webhooks
+   */
+  subscribe(eventBus) {
+    this.abortController?.abort();
+    this.abortController = new AbortController();
+    const { signal } = this.abortController;
+    const MAX_SHARED_SIGNAL_LISTENERS = 20;
+    (0, import_events.setMaxListeners)(MAX_SHARED_SIGNAL_LISTENERS, signal);
+    import_core.INTEGRATION_EVENTS.forEach((eventName) => {
+      eventBus.on(
+        eventName,
+        (payload) => {
+          this.deliverEvent(eventName, payload);
+        },
+        { signal }
+      );
+    });
+    import_core2.logger.info(`Webhook subscriber active with ${this.webhooks.size} registered webhooks`);
+  }
+  /**
+   * Register a new webhook endpoint
+   */
+  addWebhook(webhook) {
+    this.webhooks.set(webhook.id, webhook);
+    import_core2.logger.info(`Webhook registered: ${webhook.id} -> ${webhook.url}`);
+  }
+  /**
+   * Remove a webhook endpoint
+   */
+  removeWebhook(webhookId) {
+    const removed = this.webhooks.delete(webhookId);
+    if (removed) {
+      import_core2.logger.info(`Webhook removed: ${webhookId}`);
+    } else {
+      import_core2.logger.warn(`Attempted to remove non-existent webhook: ${webhookId}`);
+    }
+    return removed;
+  }
+  /**
+   * Get all registered webhooks
+   */
+  getWebhooks() {
+    return Array.from(this.webhooks.values());
+  }
+  /**
+   * Get a specific webhook by ID
+   */
+  getWebhook(webhookId) {
+    return this.webhooks.get(webhookId);
+  }
+  /**
+   * Test a webhook by sending a sample event
+   */
+  async testWebhook(webhookId) {
+    const webhook = this.webhooks.get(webhookId);
+    if (!webhook) {
+      throw new Error(`Webhook not found: ${webhookId}`);
+    }
+    const testEvent = {
+      id: `evt_test_${Date.now()}`,
+      type: "tools:available-updated",
+      data: {
+        tools: ["test-tool"],
+        source: "mcp"
+      },
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      apiVersion: "2025-07-03"
+    };
+    return this.deliverToWebhook(webhook, testEvent);
+  }
+  /**
+   * Clean up event listeners and resources
+   */
+  cleanup() {
+    if (this.abortController) {
+      this.abortController.abort();
+      delete this.abortController;
+    }
+    this.webhooks.clear();
+    import_core2.logger.debug("Webhook event subscriber cleaned up");
+  }
+  /**
+   * Unsubscribe from current event bus without clearing registered webhooks
+   */
+  unsubscribe() {
+    if (this.abortController) {
+      const controller = this.abortController;
+      delete this.abortController;
+      try {
+        controller.abort();
+      } catch (error) {
+        import_core2.logger.debug(
+          `Error aborting controller during unsubscribe: ${error instanceof Error ? error.message : String(error)}`,
+          {
+            location: "WebhookEventSubscriber.unsubscribe",
+            ...error instanceof Error ? { stack: error.stack } : { value: String(error) }
+          }
+        );
+      }
+    }
+  }
+  /**
+   * Deliver an event to all registered webhooks
+   */
+  async deliverEvent(eventType, eventData) {
+    if (this.webhooks.size === 0) {
+      return;
+    }
+    const webhookEvent = {
+      id: `evt_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+      type: eventType,
+      data: eventData,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      apiVersion: "2025-07-03"
+    };
+    import_core2.logger.debug(`Delivering webhook event: ${eventType} to ${this.webhooks.size} webhooks`);
+    const deliveryPromises = Array.from(this.webhooks.values()).map((webhook) => ({
+      webhook,
+      promise: this.deliverToWebhook(webhook, webhookEvent)
+    }));
+    const handleSettled = (results) => {
+      results.forEach((result, i) => {
+        if (result.status === "rejected") {
+          const webhook = deliveryPromises[i]?.webhook;
+          if (webhook) {
+            import_core2.logger.error(
+              `Webhook delivery failed for ${webhook.id}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`
+            );
+          }
+        }
+      });
+    };
+    if (process.env.NODE_ENV === "test") {
+      const results = await Promise.allSettled(deliveryPromises.map((p) => p.promise));
+      handleSettled(results);
+    } else {
+      Promise.allSettled(deliveryPromises.map((p) => p.promise)).then(handleSettled);
+    }
+  }
+  /**
+   * Deliver an event to a specific webhook with retry logic
+   */
+  async deliverToWebhook(webhook, event) {
+    const startTime = Date.now();
+    let lastError;
+    let lastStatusCode;
+    for (let attempt = 1; attempt <= this.deliveryOptions.maxRetries; attempt++) {
+      try {
+        const result2 = await this.sendWebhookRequest(webhook, event, attempt);
+        if (result2.success) {
+          return result2;
+        }
+        lastError = new Error(result2.error || `HTTP ${result2.statusCode}`);
+        lastStatusCode = result2.statusCode;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        import_core2.logger.warn(
+          `Webhook delivery attempt ${attempt}/${this.deliveryOptions.maxRetries} failed for ${webhook.id}: ${lastError.message}`
+        );
+      }
+      if (attempt < this.deliveryOptions.maxRetries) {
+        const baseDelay = process.env.NODE_ENV === "test" ? 1 : 1e3;
+        const exp = baseDelay * Math.pow(2, attempt - 1);
+        const jitter = exp * 0.2 * Math.random();
+        const backoffMs = Math.min(exp + jitter, 1e4);
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+      }
+    }
+    const totalTime = Date.now() - startTime;
+    const result = {
+      success: false,
+      error: lastError?.message || "Unknown error",
+      responseTime: totalTime,
+      attempt: this.deliveryOptions.maxRetries,
+      ...lastStatusCode !== void 0 && { statusCode: lastStatusCode }
+    };
+    import_core2.logger.error(
+      `Webhook delivery failed after ${this.deliveryOptions.maxRetries} attempts for ${webhook.id}: ${result.error}`
+    );
+    return result;
+  }
+  /**
+   * Send HTTP request to webhook endpoint
+   */
+  async sendWebhookRequest(webhook, event, attempt) {
+    const startTime = Date.now();
+    const payload = JSON.stringify(event);
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "DextoAgent/1.0",
+      "X-Dexto-Event-Type": event.type,
+      "X-Dexto-Event-Id": event.id,
+      "X-Dexto-Delivery-Attempt": attempt.toString()
+    };
+    if (webhook.secret && this.deliveryOptions.includeSignature) {
+      const signature = this.generateSignature(payload, webhook.secret);
+      headers["X-Dexto-Signature-256"] = signature;
+    }
+    try {
+      const response = await this.fetchFn(webhook.url, {
+        method: "POST",
+        headers,
+        body: payload,
+        signal: AbortSignal.timeout(this.deliveryOptions.timeout)
+      });
+      const responseTime = Date.now() - startTime;
+      const success = response.ok;
+      const result = {
+        success,
+        statusCode: response.status,
+        responseTime,
+        attempt
+      };
+      if (!success) {
+        result.error = `HTTP ${response.status}: ${response.statusText}`;
+      }
+      import_core2.logger.debug(
+        `Webhook delivery ${success ? "succeeded" : "failed"} for ${webhook.id}: ${response.status} in ${responseTime}ms`
+      );
+      return result;
+    } catch (error) {
+      const responseTime = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMessage,
+        responseTime,
+        attempt
+      };
+    }
+  }
+  /**
+   * Generate HMAC signature for webhook verification
+   */
+  generateSignature(payload, secret) {
+    const hmac = import_crypto.default.createHmac("sha256", secret);
+    hmac.update(payload, "utf8");
+    return `sha256=${hmac.digest("hex")}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebhookEventSubscriber
+});

package/dist/events/webhook-subscriber.d.ts

@@ -0,0 +1,64 @@
+import { AgentEventBus } from '@dexto/core';
+import { EventSubscriber } from './types.js';
+import { type WebhookConfig, type WebhookDeliveryResult, type WebhookDeliveryOptions } from './webhook-types.js';
+/**
+ * Webhook event subscriber that delivers agent events via HTTP POST
+ */
+export declare class WebhookEventSubscriber implements EventSubscriber {
+    private webhooks;
+    private abortController?;
+    private deliveryOptions;
+    private fetchFn;
+    constructor({ fetchFn, ...deliveryOptions }?: WebhookDeliveryOptions & {
+        fetchFn?: typeof globalThis.fetch;
+    });
+    /**
+     * Subscribe to agent events and deliver them to registered webhooks
+     */
+    subscribe(eventBus: AgentEventBus): void;
+    /**
+     * Register a new webhook endpoint
+     */
+    addWebhook(webhook: WebhookConfig): void;
+    /**
+     * Remove a webhook endpoint
+     */
+    removeWebhook(webhookId: string): boolean;
+    /**
+     * Get all registered webhooks
+     */
+    getWebhooks(): WebhookConfig[];
+    /**
+     * Get a specific webhook by ID
+     */
+    getWebhook(webhookId: string): WebhookConfig | undefined;
+    /**
+     * Test a webhook by sending a sample event
+     */
+    testWebhook(webhookId: string): Promise<WebhookDeliveryResult>;
+    /**
+     * Clean up event listeners and resources
+     */
+    cleanup(): void;
+    /**
+     * Unsubscribe from current event bus without clearing registered webhooks
+     */
+    unsubscribe(): void;
+    /**
+     * Deliver an event to all registered webhooks
+     */
+    private deliverEvent;
+    /**
+     * Deliver an event to a specific webhook with retry logic
+     */
+    private deliverToWebhook;
+    /**
+     * Send HTTP request to webhook endpoint
+     */
+    private sendWebhookRequest;
+    /**
+     * Generate HMAC signature for webhook verification
+     */
+    private generateSignature;
+}
+//# sourceMappingURL=webhook-subscriber.d.ts.map

package/dist/events/webhook-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-subscriber.d.ts","sourceRoot":"","sources":["../../src/events/webhook-subscriber.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,aAAa,EAIhB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EACH,KAAK,aAAa,EAElB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC9B,MAAM,oBAAoB,CAAC;AAW5B;;GAEG;AACH,qBAAa,sBAAuB,YAAW,eAAe;IAC1D,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,OAAO,CAA0B;gBAE7B,EACR,OAAO,EACP,GAAG,eAAe,EACrB,GAAE,sBAAsB,GAAG;QAAE,OAAO,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;KAAO;IAOtE;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IA4BxC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAKxC;;OAEG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAUzC;;OAEG;IACH,WAAW,IAAI,aAAa,EAAE;IAI9B;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIxD;;OAEG;IACG,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAoBpE;;OAEG;IACH,OAAO,IAAI,IAAI;IAUf;;OAEG;IACH,WAAW,IAAI,IAAI;IAsBnB;;OAEG;YACW,YAAY;IA+C1B;;OAEG;YACW,gBAAgB;IAoD9B;;OAEG;YACW,kBAAkB;IA+DhC;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAK5B"}