@dexto/server 1.2.5

package/dist/events/webhook-subscriber.js

@@ -0,0 +1,269 @@
+import crypto from "crypto";
+import { setMaxListeners } from "events";
+import {
+  INTEGRATION_EVENTS
+} from "@dexto/core";
+import { logger } from "@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;
+    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;
+    setMaxListeners(MAX_SHARED_SIGNAL_LISTENERS, signal);
+    INTEGRATION_EVENTS.forEach((eventName) => {
+      eventBus.on(
+        eventName,
+        (payload) => {
+          this.deliverEvent(eventName, payload);
+        },
+        { signal }
+      );
+    });
+    logger.info(`Webhook subscriber active with ${this.webhooks.size} registered webhooks`);
+  }
+  /**
+   * Register a new webhook endpoint
+   */
+  addWebhook(webhook) {
+    this.webhooks.set(webhook.id, webhook);
+    logger.info(`Webhook registered: ${webhook.id} -> ${webhook.url}`);
+  }
+  /**
+   * Remove a webhook endpoint
+   */
+  removeWebhook(webhookId) {
+    const removed = this.webhooks.delete(webhookId);
+    if (removed) {
+      logger.info(`Webhook removed: ${webhookId}`);
+    } else {
+      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();
+    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) {
+        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"
+    };
+    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) {
+            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));
+        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 }
+    };
+    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}`;
+      }
+      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 = crypto.createHmac("sha256", secret);
+    hmac.update(payload, "utf8");
+    return `sha256=${hmac.digest("hex")}`;
+  }
+}
+export {
+  WebhookEventSubscriber
+};

package/dist/events/webhook-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 webhook_types_exports = {};
+module.exports = __toCommonJS(webhook_types_exports);

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

@@ -0,0 +1,91 @@
+import type { AgentEventMap, AgentEventName } from '@dexto/core';
+/**
+ * TODO: temporarily DUPE OF cli
+ * Webhook configuration interface
+ * Represents a registered webhook endpoint
+ */
+export interface WebhookConfig {
+    /** Unique identifier for the webhook */
+    id: string;
+    /** The URL to send webhook events to */
+    url: string;
+    /** Optional secret for signature verification */
+    secret?: string;
+    /** When the webhook was registered */
+    createdAt: Date;
+    /** Optional description for the webhook */
+    description?: string;
+}
+/**
+ * Webhook event payload interface
+ * Mirrors Stripe.Event structure for familiar developer experience
+ */
+export interface DextoWebhookEvent<T extends AgentEventName = AgentEventName> {
+    /** Unique identifier for this webhook event */
+    id: string;
+    /** The type of event - provides IDE autocomplete */
+    type: T;
+    /** The event data payload - typed based on event type */
+    data: AgentEventMap[T];
+    /** When the event was created */
+    created: string;
+    /** API version for future compatibility */
+    apiVersion: string;
+}
+/**
+ * Webhook delivery attempt result
+ */
+export interface WebhookDeliveryResult {
+    /** Whether the delivery was successful */
+    success: boolean;
+    /** HTTP status code received */
+    statusCode?: number;
+    /** Error message if delivery failed */
+    error?: string;
+    /** Response time in milliseconds */
+    responseTime: number;
+    /** Number of delivery attempts */
+    attempt: number;
+}
+/**
+ * Webhook registration request body
+ */
+export interface WebhookRegistrationRequest {
+    /** The URL to send webhook events to */
+    url: string;
+    /** Optional secret for signature verification */
+    secret?: string;
+    /** Optional description for the webhook */
+    description?: string;
+}
+/**
+ * Webhook test event payload
+ */
+export interface WebhookTestEvent extends DextoWebhookEvent<'tools:available-updated'> {
+    /** Indicates this is a test event */
+    test: true;
+}
+/**
+ * Type-safe webhook handler function signature
+ * Provides autocomplete for event types and typed data payloads
+ */
+export type WebhookHandler<T extends AgentEventName = AgentEventName> = (event: DextoWebhookEvent<T>) => Promise<void> | void;
+/**
+ * Webhook handler mapping for type-safe event routing
+ * Provides IDE autocomplete for event names like Stripe webhooks
+ */
+export type WebhookEventHandlers = {
+    [K in AgentEventName]?: WebhookHandler<K>;
+};
+/**
+ * Webhook delivery options
+ */
+export interface WebhookDeliveryOptions {
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Include signature verification header */
+    includeSignature?: boolean;
+}
+//# sourceMappingURL=webhook-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-types.d.ts","sourceRoot":"","sources":["../../src/events/webhook-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAEjE;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC1B,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,SAAS,EAAE,IAAI,CAAC;IAChB,2CAA2C;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc;IACxE,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,IAAI,EAAE,CAAC,CAAC;IACR,yDAAyD;IACzD,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACvB,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,0CAA0C;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACvC,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB,CAAC,yBAAyB,CAAC;IAClF,qCAAqC;IACrC,IAAI,EAAE,IAAI,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI,CACpE,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAC1B,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1B;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;KAC9B,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;CAC5C,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC,uCAAuC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B"}

package/dist/hono/__tests__/test-fixtures.cjs

@@ -0,0 +1,236 @@
+"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 test_fixtures_exports = {};
+__export(test_fixtures_exports, {
+  createTestAgent: () => createTestAgent,
+  createTestAgentConfig: () => createTestAgentConfig,
+  expectResponseStructure: () => expectResponseStructure,
+  httpRequest: () => httpRequest,
+  startTestServer: () => startTestServer,
+  validators: () => validators
+});
+module.exports = __toCommonJS(test_fixtures_exports);
+var import_core = require("@dexto/core");
+var import__ = require("../index.js");
+var import_node = require("../node/index.js");
+function createTestAgentConfig() {
+  return {
+    systemPrompt: "You are a test assistant.",
+    llm: {
+      provider: "openai",
+      model: "gpt-5-nano",
+      apiKey: "test-key-123",
+      // Mock key for testing
+      router: "vercel",
+      maxIterations: 10
+    },
+    mcpServers: {},
+    storage: {
+      cache: { type: "in-memory" },
+      database: { type: "in-memory" },
+      blob: { type: "local", storePath: "/tmp/test-blobs" }
+    },
+    sessions: {
+      maxSessions: 10,
+      sessionTTL: 3600
+    },
+    toolConfirmation: {
+      mode: "auto-approve",
+      timeout: 12e4
+    },
+    elicitation: {
+      enabled: false,
+      timeout: 12e4
+    }
+  };
+}
+async function createTestAgent(config) {
+  const agentConfig = config ?? createTestAgentConfig();
+  const agent = new import_core.DextoAgent(agentConfig);
+  await agent.start();
+  return agent;
+}
+async function startTestServer(agent, port, agentsContext) {
+  const serverPort = port ?? await findAvailablePort();
+  const agentCard = (0, import_core.createAgentCard)({
+    defaultName: "test-agent",
+    defaultVersion: "1.0.0",
+    defaultBaseUrl: `http://localhost:${serverPort}`
+  });
+  const getAgent = () => agent;
+  const getAgentCard = () => agentCard;
+  const { WebhookEventSubscriber } = await import("../../events/webhook-subscriber.js");
+  const { A2ASseEventSubscriber } = await import("../../events/a2a-sse-subscriber.js");
+  const { ApprovalCoordinator } = await import("../../approval/approval-coordinator.js");
+  const webhookSubscriber = new WebhookEventSubscriber();
+  const sseSubscriber = new A2ASseEventSubscriber();
+  const approvalCoordinator = new ApprovalCoordinator();
+  webhookSubscriber.subscribe(agent.agentEventBus);
+  sseSubscriber.subscribe(agent.agentEventBus);
+  const app = (0, import__.createDextoApp)({
+    getAgent,
+    getAgentCard,
+    approvalCoordinator,
+    webhookSubscriber,
+    sseSubscriber,
+    ...agentsContext ? { agentsContext } : {}
+    // Include agentsContext only if provided
+  });
+  const bridge = (0, import_node.createNodeServer)(app, {
+    getAgent: () => agent,
+    port: serverPort
+  });
+  const updatedAgentCard = (0, import_core.createAgentCard)({
+    defaultName: "test-agent",
+    defaultVersion: "1.0.0",
+    defaultBaseUrl: `http://localhost:${serverPort}`
+  });
+  await new Promise((resolve, reject) => {
+    bridge.server.listen(serverPort, "0.0.0.0", () => {
+      resolve();
+    });
+    bridge.server.on("error", reject);
+  });
+  const baseUrl = `http://localhost:${serverPort}`;
+  return {
+    server: bridge.server,
+    app,
+    bridge,
+    agent,
+    agentCard: updatedAgentCard,
+    baseUrl,
+    port: serverPort,
+    cleanup: async () => {
+      webhookSubscriber.cleanup();
+      sseSubscriber.cleanup();
+      approvalCoordinator.removeAllListeners();
+      await new Promise((resolve, reject) => {
+        bridge.server.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+      if (agent.isStarted()) {
+        await agent.stop();
+      }
+    }
+  };
+}
+async function findAvailablePort() {
+  const { createServer } = await import("node:http");
+  const startPort = 49152 + Math.floor(Math.random() * 1e3);
+  for (let port = startPort; port < 65535; port++) {
+    try {
+      await new Promise((resolve, reject) => {
+        const server = createServer();
+        server.on("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            reject(new Error(`Port ${port} is in use`));
+          } else {
+            reject(err);
+          }
+        });
+        server.listen(port, () => {
+          server.close(() => resolve());
+        });
+      });
+      return port;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(`Could not find an available port starting from ${startPort}`);
+}
+async function httpRequest(baseUrl, method, path, body, headers) {
+  const url = `${baseUrl}${path}`;
+  const options = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    }
+  };
+  if (body !== void 0) {
+    options.body = JSON.stringify(body);
+  }
+  const response = await fetch(url, options);
+  const text = await response.text();
+  let parsedBody;
+  try {
+    parsedBody = JSON.parse(text);
+  } catch {
+    parsedBody = text;
+  }
+  const headersObject = {};
+  response.headers.forEach((value, key) => {
+    headersObject[key] = value;
+  });
+  return {
+    status: response.status,
+    headers: headersObject,
+    body: parsedBody,
+    text
+  };
+}
+function expectResponseStructure(body, schema) {
+  if (typeof body !== "object" || body === null) {
+    throw new Error(`Expected object response, got ${typeof body}`);
+  }
+  const bodyObj = body;
+  for (const [key, validator] of Object.entries(schema)) {
+    if (!(key in bodyObj)) {
+      throw new Error(`Missing required field: ${key}`);
+    }
+    if (!validator(bodyObj[key])) {
+      throw new Error(
+        `Invalid type for field '${key}': expected validator to return true, got false`
+      );
+    }
+  }
+}
+const validators = {
+  string: (value) => typeof value === "string",
+  number: (value) => typeof value === "number",
+  boolean: (value) => typeof value === "boolean",
+  array: (value) => Array.isArray(value),
+  object: (value) => typeof value === "object" && value !== null && !Array.isArray(value),
+  optionalString: (value) => value === void 0 || typeof value === "string",
+  optionalNumber: (value) => value === void 0 || typeof value === "number",
+  optionalArray: (value) => value === void 0 || Array.isArray(value),
+  optionalObject: (value) => value === void 0 || typeof value === "object" && value !== null && !Array.isArray(value)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTestAgent,
+  createTestAgentConfig,
+  expectResponseStructure,
+  httpRequest,
+  startTestServer,
+  validators
+});

package/dist/hono/__tests__/test-fixtures.d.ts

@@ -0,0 +1,65 @@
+import { DextoAgent } from '@dexto/core';
+import type { AgentConfig, AgentCard } from '@dexto/core';
+import type { Server as HttpServer } from 'node:http';
+import type { DextoApp } from '../types.js';
+import { type NodeBridgeResult } from '../node/index.js';
+import type { CreateDextoAppOptions } from '../index.js';
+/**
+ * Test configuration for integration tests
+ * Uses in-memory storage to avoid side effects
+ */
+export declare function createTestAgentConfig(): AgentConfig;
+/**
+ * Creates a real DextoAgent instance with in-memory storage
+ * No mocks - uses real implementations
+ */
+export declare function createTestAgent(config?: AgentConfig): Promise<DextoAgent>;
+/**
+ * Test server setup result
+ */
+export interface TestServer {
+    server: HttpServer;
+    app: DextoApp;
+    bridge: NodeBridgeResult;
+    agent: DextoAgent;
+    agentCard: AgentCard;
+    baseUrl: string;
+    port: number;
+    cleanup: () => Promise<void>;
+}
+/**
+ * Starts a real HTTP server for testing
+ * Uses createDextoApp and createNodeServer directly
+ * @param agent - The agent instance to use
+ * @param port - Optional port (auto-selected if not provided)
+ * @param agentsContext - Optional agent switching context (enables /api/agents routes)
+ */
+export declare function startTestServer(agent: DextoAgent, port?: number, agentsContext?: CreateDextoAppOptions['agentsContext']): Promise<TestServer>;
+/**
+ * Helper to make HTTP requests to the test server
+ */
+export declare function httpRequest(baseUrl: string, method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<{
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+    text: string;
+}>;
+/**
+ * Validates that a response has the expected structure
+ */
+export declare function expectResponseStructure(body: unknown, schema: Record<string, (value: unknown) => boolean>): void;
+/**
+ * Common response validators
+ */
+export declare const validators: {
+    string: (value: unknown) => boolean;
+    number: (value: unknown) => boolean;
+    boolean: (value: unknown) => boolean;
+    array: (value: unknown) => boolean;
+    object: (value: unknown) => boolean;
+    optionalString: (value: unknown) => boolean;
+    optionalNumber: (value: unknown) => boolean;
+    optionalArray: (value: unknown) => boolean;
+    optionalObject: (value: unknown) => boolean;
+};
+//# sourceMappingURL=test-fixtures.d.ts.map

package/dist/hono/__tests__/test-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-fixtures.d.ts","sourceRoot":"","sources":["../../../src/hono/__tests__/test-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmB,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,WAAW,CAAC;AAEtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,WAAW,CA6BnD;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAK/E;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,MAAM,EAAE,UAAU,CAAC;IACnB,GAAG,EAAE,QAAQ,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAChC;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACjC,KAAK,EAAE,UAAU,EACjB,IAAI,CAAC,EAAE,MAAM,EACb,aAAa,CAAC,EAAE,qBAAqB,CAAC,eAAe,CAAC,GACvD,OAAO,CAAC,UAAU,CAAC,CAwFrB;AAmCD;;GAEG;AACH,wBAAsB,WAAW,CAC7B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,OAAO,CAAC;IACP,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC,CAmCD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,GACpD,IAAI,CAgBN;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;oBACH,OAAO,KAAG,OAAO;oBACjB,OAAO,KAAG,OAAO;qBAChB,OAAO,KAAG,OAAO;mBACnB,OAAO,KAAG,OAAO;oBAChB,OAAO,KAAG,OAAO;4BAET,OAAO,KAAG,OAAO;4BACjB,OAAO,KAAG,OAAO;2BAClB,OAAO,KAAG,OAAO;4BAChB,OAAO,KAAG,OAAO;CAG5C,CAAC"}