@dexto/server 1.2.5

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

@@ -0,0 +1,197 @@
+import { DextoAgent, createAgentCard } from "@dexto/core";
+import { createDextoApp } from "../index.js";
+import { createNodeServer } from "../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 DextoAgent(agentConfig);
+  await agent.start();
+  return agent;
+}
+async function startTestServer(agent, port, agentsContext) {
+  const serverPort = port ?? await findAvailablePort();
+  const agentCard = 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 = createDextoApp({
+    getAgent,
+    getAgentCard,
+    approvalCoordinator,
+    webhookSubscriber,
+    sseSubscriber,
+    ...agentsContext ? { agentsContext } : {}
+    // Include agentsContext only if provided
+  });
+  const bridge = createNodeServer(app, {
+    getAgent: () => agent,
+    port: serverPort
+  });
+  const updatedAgentCard = 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)
+};
+export {
+  createTestAgent,
+  createTestAgentConfig,
+  expectResponseStructure,
+  httpRequest,
+  startTestServer,
+  validators
+};

package/dist/hono/index.cjs

@@ -0,0 +1,166 @@
+"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 hono_exports = {};
+__export(hono_exports, {
+  createDextoApp: () => createDextoApp
+});
+module.exports = __toCommonJS(hono_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_health = require("./routes/health.js");
+var import_greeting = require("./routes/greeting.js");
+var import_messages = require("./routes/messages.js");
+var import_llm = require("./routes/llm.js");
+var import_sessions = require("./routes/sessions.js");
+var import_search = require("./routes/search.js");
+var import_mcp = require("./routes/mcp.js");
+var import_a2a = require("./routes/a2a.js");
+var import_a2a_jsonrpc = require("./routes/a2a-jsonrpc.js");
+var import_a2a_tasks = require("./routes/a2a-tasks.js");
+var import_webhooks = require("./routes/webhooks.js");
+var import_prompts = require("./routes/prompts.js");
+var import_resources = require("./routes/resources.js");
+var import_memory = require("./routes/memory.js");
+var import_agents = require("./routes/agents.js");
+var import_approvals = require("./routes/approvals.js");
+var import_error = require("./middleware/error.js");
+var import_redaction = require("./middleware/redaction.js");
+var import_cors = require("./middleware/cors.js");
+var import_auth = require("./middleware/auth.js");
+var import_node_fs = require("node:fs");
+var import_node_url = require("node:url");
+var import_node_path = require("node:path");
+const import_meta = {};
+const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
+const __dirname = (0, import_node_path.dirname)(__filename);
+const packageJson = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(__dirname, "../../package.json"), "utf-8"));
+const dummyAgentsContext = {
+  switchAgentById: async () => {
+    throw new Error("Multi-agent features not available in single-agent mode");
+  },
+  switchAgentByPath: async () => {
+    throw new Error("Multi-agent features not available in single-agent mode");
+  },
+  resolveAgentInfo: async () => {
+    throw new Error("Multi-agent features not available in single-agent mode");
+  },
+  ensureAgentAvailable: () => {
+  },
+  getActiveAgentId: () => void 0
+};
+function createDextoApp(options) {
+  const {
+    getAgent,
+    getAgentCard,
+    approvalCoordinator,
+    webhookSubscriber,
+    sseSubscriber,
+    agentsContext
+  } = options;
+  const app = new import_zod_openapi.OpenAPIHono({ strict: false });
+  app.use("*", (0, import_cors.createCorsMiddleware)());
+  app.use("*", (0, import_auth.createAuthMiddleware)());
+  app.onError((err, ctx) => (0, import_error.handleHonoError)(ctx, err));
+  app.use("/api/*", import_redaction.prettyJsonMiddleware);
+  app.use("/api/*", import_redaction.redactionMiddleware);
+  const fullApp = app.route("/health", (0, import_health.createHealthRouter)(getAgent)).route("/", (0, import_a2a.createA2aRouter)(getAgentCard)).route("/", (0, import_a2a_jsonrpc.createA2AJsonRpcRouter)(getAgent, sseSubscriber)).route("/", (0, import_a2a_tasks.createA2ATasksRouter)(getAgent, sseSubscriber)).route("/api", (0, import_greeting.createGreetingRouter)(getAgent)).route("/api", (0, import_messages.createMessagesRouter)(getAgent, approvalCoordinator)).route("/api", (0, import_llm.createLlmRouter)(getAgent)).route("/api", (0, import_sessions.createSessionsRouter)(getAgent)).route("/api", (0, import_search.createSearchRouter)(getAgent)).route("/api", (0, import_mcp.createMcpRouter)(getAgent)).route("/api", (0, import_webhooks.createWebhooksRouter)(getAgent, webhookSubscriber)).route("/api", (0, import_prompts.createPromptsRouter)(getAgent)).route("/api", (0, import_resources.createResourcesRouter)(getAgent)).route("/api", (0, import_memory.createMemoryRouter)(getAgent)).route("/api", (0, import_approvals.createApprovalsRouter)(getAgent, approvalCoordinator)).route("/api", (0, import_agents.createAgentsRouter)(getAgent, agentsContext || dummyAgentsContext));
+  fullApp.doc("/openapi.json", {
+    openapi: "3.0.0",
+    info: {
+      title: "Dexto API",
+      version: packageJson.version,
+      description: "OpenAPI spec for the Dexto REST API server"
+    },
+    servers: [
+      {
+        url: "http://localhost:3001",
+        description: "Local development server (default port)"
+      },
+      {
+        url: "http://localhost:{port}",
+        description: "Local development server (custom port)",
+        variables: {
+          port: {
+            default: "3001",
+            description: "API server port"
+          }
+        }
+      }
+    ],
+    tags: [
+      {
+        name: "system",
+        description: "System health and status endpoints"
+      },
+      {
+        name: "config",
+        description: "Agent configuration and greeting management"
+      },
+      {
+        name: "messages",
+        description: "Send messages to the agent and manage conversations"
+      },
+      {
+        name: "sessions",
+        description: "Create and manage conversation sessions"
+      },
+      {
+        name: "llm",
+        description: "Configure and switch between LLM providers and models"
+      },
+      {
+        name: "mcp",
+        description: "Manage Model Context Protocol (MCP) servers and tools"
+      },
+      {
+        name: "webhooks",
+        description: "Register and manage webhook endpoints for agent events"
+      },
+      {
+        name: "search",
+        description: "Search through messages and sessions"
+      },
+      {
+        name: "memory",
+        description: "Store and retrieve agent memories for context"
+      },
+      {
+        name: "prompts",
+        description: "Manage custom prompts and templates"
+      },
+      {
+        name: "resources",
+        description: "Access and manage resources from MCP servers and internal providers"
+      },
+      {
+        name: "agent",
+        description: "Current agent configuration and file operations"
+      },
+      {
+        name: "agents",
+        description: "Install, switch, and manage agent configurations"
+      }
+    ]
+  });
+  Object.assign(fullApp, { webhookSubscriber });
+  return fullApp;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDextoApp
+});