@dexto/server 1.2.5

package/dist/hono/schemas/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../../src/hono/schemas/responses.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAI3E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI4B,CAAC;AAGjE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqE,CAAC;AAElG,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAGzE,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAG9D,OAAO,EACH,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,eAAe,EACpB,KAAK,wBAAwB,GAChC,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAG3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAoC3D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;EAuBD,CAAC;AAElC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAoDrE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAaU,CAAC;AAExC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBc,CAAC;AAEjD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIrE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaY,CAAC;AAE5C,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBK,CAAC;AAE5C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAI7E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;EAQW,CAAC;AAEtC,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;AAKrD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BiB,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAGvE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAekC,CAAC;AAErE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAGrE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEkC,CAAC;AAE/D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAIzD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAUA,CAAC;AAEtC,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAQ3E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBO,CAAC;AAEnC,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AAIvD,eAAO,MAAM,UAAU;;;;;;;;;;;;EAOO,CAAC;AAE/B,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC;AAI/C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAOU,CAAC;AAE5C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEnE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWe,CAAC;AAEnD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAae,CAAC;AAE7C,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;EAYO,CAAC;AAEjC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC;AAOnD,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC;;;;;;;;;iEAO1B,CAAC;AAG7C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaG,CAAC;AAEpC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGjE,eAAO,MAAM,oBAAoB;;;;;;;;;EAMD,CAAC;AAEjC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGnE,eAAO,MAAM,oBAAoB;;;;;;;;;EAMS,CAAC;AAE3C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/hono/schemas/responses.js

@@ -0,0 +1,227 @@
+import { z } from "zod";
+import { LLMConfigBaseSchema as CoreLLMConfigBaseSchema } from "@dexto/core";
+import { MemorySchema } from "@dexto/core";
+import { LLMConfigBaseSchema } from "@dexto/core";
+const LLMConfigResponseSchema = CoreLLMConfigBaseSchema.omit({ apiKey: true }).extend({
+  hasApiKey: z.boolean().optional().describe("Whether an API key is configured")
+}).describe("LLM configuration (apiKey omitted for security)");
+const LLMConfigSchema = CoreLLMConfigBaseSchema.describe("LLM configuration with API key");
+import { AgentCardSchema } from "@dexto/core";
+import {
+  McpServerConfigSchema,
+  StdioServerConfigSchema,
+  SseServerConfigSchema,
+  HttpServerConfigSchema
+} from "@dexto/core";
+import { ToolConfirmationConfigSchema } from "@dexto/core";
+import { InternalResourceConfigSchema } from "@dexto/core";
+const BinaryDataSchema = z.custom(
+  (val) => {
+    return typeof val === "string" || val instanceof Buffer || val instanceof Uint8Array || val instanceof URL;
+  },
+  { message: "Must be string, Buffer, Uint8Array, or URL" }
+);
+const SessionMetadataSchema = z.object({
+  id: z.string().describe("Unique session identifier"),
+  createdAt: z.number().int().positive().nullable().describe("Creation timestamp (Unix ms, null if unavailable)"),
+  lastActivity: z.number().int().positive().nullable().describe("Last activity timestamp (Unix ms, null if unavailable)"),
+  messageCount: z.number().int().nonnegative().describe("Total number of messages in session"),
+  title: z.string().optional().nullable().describe("Optional session title")
+}).strict().describe("Session metadata");
+const TextPartSchema = z.object({
+  type: z.literal("text").describe("Part type: text"),
+  text: z.string().describe("Text content")
+}).strict().describe("Text content part");
+const ImagePartSchema = z.object({
+  type: z.literal("image").describe("Part type: image"),
+  image: BinaryDataSchema.describe("Image data (string, binary, or URL)"),
+  mimeType: z.string().optional().describe("MIME type of the image")
+}).strict().describe("Image content part");
+const FilePartSchema = z.object({
+  type: z.literal("file").describe("Part type: file"),
+  data: BinaryDataSchema.describe("File data (string, binary, or URL)"),
+  mimeType: z.string().describe("MIME type of the file"),
+  filename: z.string().optional().describe("Optional filename")
+}).strict().describe("File content part");
+const ContentPartSchema = z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Message content part (text, image, or file)");
+const ToolCallSchema = z.object({
+  id: z.string().describe("Unique identifier for this tool call"),
+  type: z.literal("function").describe("Tool call type (currently only function is supported)"),
+  function: z.object({
+    name: z.string().describe("Name of the function to call"),
+    arguments: z.string().describe("Arguments for the function in JSON string format")
+  }).strict().describe("Function call details")
+}).strict().describe("Tool call made by the assistant");
+const TokenUsageSchema = z.object({
+  inputTokens: z.number().int().nonnegative().optional().describe("Number of input tokens"),
+  outputTokens: z.number().int().nonnegative().optional().describe("Number of output tokens"),
+  reasoningTokens: z.number().int().nonnegative().optional().describe("Number of reasoning tokens"),
+  totalTokens: z.number().int().nonnegative().optional().describe("Total tokens used")
+}).strict().describe("Token usage accounting");
+const InternalMessageSchema = z.object({
+  role: z.enum(["system", "user", "assistant", "tool"]).describe("Role of the message sender"),
+  timestamp: z.number().int().positive().optional().describe("Creation timestamp (Unix ms)"),
+  content: z.union([z.string(), z.null(), z.array(ContentPartSchema)]).describe("Message content (string, null, or array of parts)"),
+  reasoning: z.string().optional().describe("Optional model reasoning text"),
+  tokenUsage: TokenUsageSchema.optional().describe("Optional token usage accounting"),
+  model: z.string().optional().describe("Model identifier for assistant messages"),
+  provider: z.string().optional().describe("Provider identifier for assistant messages"),
+  router: z.string().optional().describe("Router metadata for assistant messages"),
+  toolCalls: z.array(ToolCallSchema).optional().describe("Tool calls made by the assistant"),
+  toolCallId: z.string().optional().describe("ID of the tool call this message responds to"),
+  name: z.string().optional().describe("Name of the tool that produced this result")
+}).strict().describe("Internal message representation");
+const SearchResultSchema = z.object({
+  sessionId: z.string().describe("Session ID where the message was found"),
+  message: InternalMessageSchema.describe("The message that matched the search"),
+  matchedText: z.string().describe("The specific text that matched the search query"),
+  context: z.string().describe("Context around the match for preview"),
+  messageIndex: z.number().int().nonnegative().describe("Index of the message within the session")
+}).strict().describe("Result of a message search");
+const SessionSearchResultSchema = z.object({
+  sessionId: z.string().describe("Session ID"),
+  matchCount: z.number().int().nonnegative().describe("Number of messages that matched in this session"),
+  firstMatch: SearchResultSchema.describe("Preview of the first matching message"),
+  metadata: z.object({
+    createdAt: z.number().int().positive().describe("Session creation timestamp"),
+    lastActivity: z.number().int().positive().describe("Last activity timestamp"),
+    messageCount: z.number().int().nonnegative().describe("Total messages in session")
+  }).strict().describe("Session metadata")
+}).strict().describe("Result of a session search");
+const WebhookSchema = z.object({
+  id: z.string().describe("Unique webhook identifier"),
+  url: z.string().url().describe("Webhook URL to send events to"),
+  events: z.array(z.string()).describe("Array of event types this webhook subscribes to"),
+  createdAt: z.number().int().positive().describe("Creation timestamp (Unix ms)")
+}).strict().describe("Webhook subscription");
+const CatalogModelInfoSchema = z.object({
+  name: z.string().describe("Model name identifier"),
+  maxInputTokens: z.number().int().positive().describe("Maximum input tokens"),
+  default: z.boolean().optional().describe("Whether this is a default model"),
+  supportedFileTypes: z.array(z.enum(["audio", "pdf", "image"])).describe("File types this model supports"),
+  supportedRouters: z.array(z.enum(["vercel", "in-built"])).optional().describe("Routing strategies this model supports"),
+  displayName: z.string().optional().describe("Human-readable display name"),
+  pricing: z.object({
+    inputPerM: z.number().describe("Input cost per million tokens (USD)"),
+    outputPerM: z.number().describe("Output cost per million tokens (USD)"),
+    cacheReadPerM: z.number().optional().describe("Cache read cost per million tokens"),
+    cacheWritePerM: z.number().optional().describe("Cache write cost per million tokens"),
+    currency: z.literal("USD").optional().describe("Currency"),
+    unit: z.literal("per_million_tokens").optional().describe("Unit")
+  }).optional().describe("Pricing information in USD per million tokens")
+}).strict().describe("Model information from LLM registry");
+const ProviderCatalogSchema = z.object({
+  name: z.string().describe("Provider display name"),
+  hasApiKey: z.boolean().describe("Whether API key is configured"),
+  primaryEnvVar: z.string().describe("Primary environment variable for API key"),
+  supportedRouters: z.array(z.enum(["vercel", "in-built"])).describe("Routing strategies supported by this provider"),
+  supportsBaseURL: z.boolean().describe("Whether custom base URLs are supported"),
+  models: z.array(CatalogModelInfoSchema).describe("Models available from this provider"),
+  supportedFileTypes: z.array(z.enum(["audio", "pdf", "image"])).describe("Provider-level file type support")
+}).strict().describe("Provider catalog entry with models and capabilities");
+const ModelFlatSchema = CatalogModelInfoSchema.extend({
+  provider: z.string().describe("Provider identifier for this model")
+}).describe("Flattened model entry with provider information");
+const AgentRegistryEntrySchema = z.object({
+  id: z.string().describe("Unique agent identifier"),
+  name: z.string().describe("Agent name"),
+  description: z.string().describe("Agent description"),
+  author: z.string().optional().describe("Agent author"),
+  tags: z.array(z.string()).optional().describe("Agent tags"),
+  type: z.enum(["builtin", "custom"]).describe("Agent type")
+}).strict().describe("Agent registry entry");
+const ResourceSchema = z.object({
+  uri: z.string().describe("Resource URI"),
+  name: z.string().optional().describe("Resource name"),
+  description: z.string().optional().describe("Resource description"),
+  mimeType: z.string().optional().describe("MIME type of the resource"),
+  source: z.enum(["mcp", "internal"]).describe("Source system that provides this resource"),
+  serverName: z.string().optional().describe("Original server/provider name (for MCP resources)"),
+  size: z.number().optional().describe("Size of the resource in bytes (if known)"),
+  lastModified: z.string().datetime().optional().describe("Last modified timestamp (ISO 8601 string)"),
+  metadata: z.record(z.unknown()).optional().describe("Additional metadata specific to the resource type")
+}).strict().describe("Resource metadata");
+const ToolSchema = z.object({
+  name: z.string().describe("Tool name"),
+  description: z.string().describe("Tool description"),
+  inputSchema: z.record(z.unknown()).describe("JSON Schema for tool input parameters")
+}).strict().describe("Tool metadata");
+const PromptArgumentSchema = z.object({
+  name: z.string().describe("Argument name"),
+  description: z.string().optional().describe("Argument description"),
+  required: z.boolean().optional().describe("Whether the argument is required")
+}).strict().describe("Prompt argument definition");
+const PromptDefinitionSchema = z.object({
+  name: z.string().describe("Prompt name"),
+  title: z.string().optional().describe("Prompt title"),
+  description: z.string().optional().describe("Prompt description"),
+  arguments: z.array(PromptArgumentSchema).optional().describe("Array of argument definitions")
+}).strict().describe("Prompt definition (MCP-compliant)");
+const PromptInfoSchema = z.object({
+  name: z.string().describe("Prompt name"),
+  title: z.string().optional().describe("Prompt title"),
+  description: z.string().optional().describe("Prompt description"),
+  arguments: z.array(PromptArgumentSchema).optional().describe("Array of argument definitions"),
+  source: z.enum(["mcp", "file", "starter", "custom"]).describe("Source of the prompt"),
+  metadata: z.record(z.unknown()).optional().describe("Additional metadata")
+}).strict().describe("Enhanced prompt information");
+const PromptSchema = z.object({
+  id: z.string().describe("Unique prompt identifier"),
+  name: z.string().describe("Prompt name"),
+  description: z.string().optional().describe("Prompt description"),
+  content: z.string().describe("Prompt template content"),
+  variables: z.array(z.string()).optional().describe("List of variable placeholders in the prompt")
+}).strict().describe("Prompt template");
+const OkResponseSchema = (dataSchema) => z.object({
+  ok: z.literal(true).describe("Indicates successful response"),
+  data: dataSchema.describe("Response data")
+}).strict().describe("Successful API response");
+const ErrorResponseSchema = z.object({
+  ok: z.literal(false).describe("Indicates failed response"),
+  error: z.object({
+    message: z.string().describe("Error message"),
+    code: z.string().optional().describe("Error code"),
+    details: z.unknown().optional().describe("Additional error details")
+  }).strict().describe("Error details")
+}).strict().describe("Error API response");
+const StatusResponseSchema = z.object({
+  status: z.string().describe("Operation status"),
+  message: z.string().optional().describe("Optional status message")
+}).strict().describe("Status response");
+const DeleteResponseSchema = z.object({
+  status: z.literal("deleted").describe("Indicates successful deletion"),
+  id: z.string().optional().describe("ID of the deleted resource")
+}).strict().describe("Delete operation response");
+export {
+  AgentCardSchema,
+  AgentRegistryEntrySchema,
+  CatalogModelInfoSchema,
+  DeleteResponseSchema,
+  ErrorResponseSchema,
+  HttpServerConfigSchema,
+  InternalMessageSchema,
+  InternalResourceConfigSchema,
+  LLMConfigBaseSchema,
+  LLMConfigResponseSchema,
+  LLMConfigSchema,
+  McpServerConfigSchema,
+  MemorySchema,
+  ModelFlatSchema,
+  OkResponseSchema,
+  PromptArgumentSchema,
+  PromptDefinitionSchema,
+  PromptInfoSchema,
+  PromptSchema,
+  ProviderCatalogSchema,
+  ResourceSchema,
+  SearchResultSchema,
+  SessionMetadataSchema,
+  SessionSearchResultSchema,
+  SseServerConfigSchema,
+  StatusResponseSchema,
+  StdioServerConfigSchema,
+  TokenUsageSchema,
+  ToolConfirmationConfigSchema,
+  ToolSchema,
+  WebhookSchema
+};

package/dist/hono/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/hono/types.d.ts

@@ -0,0 +1,6 @@
+import type { OpenAPIHono } from '@hono/zod-openapi';
+import type { WebhookEventSubscriber } from '../events/webhook-subscriber.js';
+export type DextoApp = OpenAPIHono & {
+    webhookSubscriber?: WebhookEventSubscriber;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/hono/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E,MAAM,MAAM,QAAQ,GAAG,WAAW,GAAG;IACjC,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;CAC9C,CAAC"}

package/dist/index.cjs

@@ -0,0 +1,38 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./hono/index.js"), module.exports);
+__reExport(index_exports, require("./hono/node/index.js"), module.exports);
+__reExport(index_exports, require("./events/webhook-subscriber.js"), module.exports);
+__reExport(index_exports, require("./events/a2a-sse-subscriber.js"), module.exports);
+__reExport(index_exports, require("./events/webhook-types.js"), module.exports);
+__reExport(index_exports, require("./events/types.js"), module.exports);
+__reExport(index_exports, require("./mcp/mcp-handler.js"), module.exports);
+__reExport(index_exports, require("./approval/manual-approval-handler.js"), module.exports);
+__reExport(index_exports, require("./approval/approval-coordinator.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./hono/index.js"),
+  ...require("./hono/node/index.js"),
+  ...require("./events/webhook-subscriber.js"),
+  ...require("./events/a2a-sse-subscriber.js"),
+  ...require("./events/webhook-types.js"),
+  ...require("./events/types.js"),
+  ...require("./mcp/mcp-handler.js"),
+  ...require("./approval/manual-approval-handler.js"),
+  ...require("./approval/approval-coordinator.js")
+});

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './hono/index.js';
+export * from './hono/node/index.js';
+export type { DextoApp } from './hono/types.js';
+export * from './events/webhook-subscriber.js';
+export * from './events/a2a-sse-subscriber.js';
+export * from './events/webhook-types.js';
+export * from './events/types.js';
+export * from './mcp/mcp-handler.js';
+export * from './approval/manual-approval-handler.js';
+export * from './approval/approval-coordinator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./hono/index.js";
+export * from "./hono/node/index.js";
+export * from "./events/webhook-subscriber.js";
+export * from "./events/a2a-sse-subscriber.js";
+export * from "./events/webhook-types.js";
+export * from "./events/types.js";
+export * from "./mcp/mcp-handler.js";
+export * from "./approval/manual-approval-handler.js";
+export * from "./approval/approval-coordinator.js";

package/dist/mcp/mcp-handler.cjs

@@ -0,0 +1,145 @@
+"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 mcp_handler_exports = {};
+__export(mcp_handler_exports, {
+  createMcpHttpHandlers: () => createMcpHttpHandlers,
+  createMcpTransport: () => createMcpTransport,
+  initializeAgentCardResource: () => initializeAgentCardResource,
+  initializeMcpServer: () => initializeMcpServer
+});
+module.exports = __toCommonJS(mcp_handler_exports);
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_core = require("@dexto/core");
+var import_zod = require("zod");
+var import_crypto = require("crypto");
+async function createMcpTransport(transportType = "http") {
+  import_core.logger.info(`Creating MCP transport of type: ${transportType}`);
+  switch (transportType) {
+    case "stdio":
+      return new import_stdio.StdioServerTransport();
+    case "sse":
+      throw new Error(
+        "SSE transport requires HTTP response context and should be created per-request"
+      );
+    default: {
+      return new import_streamableHttp.StreamableHTTPServerTransport({
+        sessionIdGenerator: import_crypto.randomUUID,
+        enableJsonResponse: true
+      });
+    }
+  }
+}
+async function initializeMcpServer(agent, agentCardData, mcpTransport) {
+  const mcpServer = new import_mcp.McpServer(
+    { name: agentCardData.name, version: agentCardData.version },
+    {
+      capabilities: {
+        resources: {}
+      }
+    }
+  );
+  const toolName = "chat_with_agent";
+  const toolDescription = "Allows you to chat with the an AI agent. Send a message to interact.";
+  mcpServer.tool(
+    toolName,
+    toolDescription,
+    { message: import_zod.z.string() },
+    async ({ message }) => {
+      agent.logger.info(
+        `MCP tool '${toolName}' received message: ${message.substring(0, 100)}${message.length > 100 ? "..." : ""}`
+      );
+      const session = await agent.createSession(`mcp-${(0, import_crypto.randomUUID)()}`);
+      try {
+        const text = await agent.run(message, void 0, void 0, session.id);
+        agent.logger.info(
+          `MCP tool '${toolName}' sending response: ${text?.substring(0, 100)}${(text?.length ?? 0) > 100 ? "..." : ""}`
+        );
+        return { content: [{ type: "text", text: text ?? "" }] };
+      } finally {
+        await agent.deleteSession(session.id).catch(
+          (err) => agent.logger.warn(`Failed to cleanup MCP session ${session.id}: ${err}`)
+        );
+      }
+    }
+  );
+  agent.logger.info(`Registered MCP tool: '${toolName}'`);
+  await initializeAgentCardResource(mcpServer, agentCardData, agent.logger);
+  agent.logger.info(`Initializing MCP protocol server connection...`);
+  await mcpServer.connect(mcpTransport);
+  agent.logger.info(`\u2705 MCP server protocol connected via transport.`);
+  return mcpServer;
+}
+async function initializeAgentCardResource(mcpServer, agentCardData, agentLogger) {
+  const agentCardResourceProgrammaticName = "agentCard";
+  const agentCardResourceUri = "dexto://agent/card";
+  try {
+    const readCallback = async (uri, _extra) => {
+      agentLogger.info(`MCP client requesting resource at ${uri.href}`);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            type: "application/json",
+            text: JSON.stringify(agentCardData, null, 2)
+          }
+        ]
+      };
+    };
+    mcpServer.resource(agentCardResourceProgrammaticName, agentCardResourceUri, readCallback);
+    agentLogger.info(
+      `Registered MCP Resource: '${agentCardResourceProgrammaticName}' at URI '${agentCardResourceUri}'`
+    );
+  } catch (e) {
+    agentLogger.warn(
+      `Error attempting to register MCP Resource '${agentCardResourceProgrammaticName}': ${e.message}. Check SDK.`
+    );
+  }
+}
+function createMcpHttpHandlers(mcpTransport) {
+  if (!(mcpTransport instanceof import_streamableHttp.StreamableHTTPServerTransport)) {
+    import_core.logger.info("Non-HTTP transport detected. Skipping HTTP route setup.");
+    return null;
+  }
+  const handlePost = async (req, res, body) => {
+    import_core.logger.info(`MCP POST /mcp received request body: ${JSON.stringify(body)}`);
+    try {
+      await mcpTransport.handleRequest(req, res, body);
+    } catch (err) {
+      import_core.logger.error(`MCP POST error: ${JSON.stringify(err, null, 2)}`);
+    }
+  };
+  const handleGet = async (req, res) => {
+    import_core.logger.info("MCP GET /mcp received request, attempting to establish SSE connection.");
+    try {
+      await mcpTransport.handleRequest(req, res);
+    } catch (err) {
+      import_core.logger.error(`MCP GET error: ${JSON.stringify(err, null, 2)}`);
+    }
+  };
+  return { handlePost, handleGet };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMcpHttpHandlers,
+  createMcpTransport,
+  initializeAgentCardResource,
+  initializeMcpServer
+});

package/dist/mcp/mcp-handler.d.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { AgentCard, IDextoLogger } from '@dexto/core';
+import type { DextoAgent } from '@dexto/core';
+export type McpTransportType = 'stdio' | 'sse' | 'http';
+export declare function createMcpTransport(transportType?: McpTransportType): Promise<Transport>;
+export declare function initializeMcpServer(agent: DextoAgent, agentCardData: AgentCard, mcpTransport: Transport): Promise<McpServer>;
+export declare function initializeAgentCardResource(mcpServer: McpServer, agentCardData: AgentCard, agentLogger: IDextoLogger): Promise<void>;
+export declare function createMcpHttpHandlers(mcpTransport: Transport): {
+    handlePost: (req: IncomingMessage, res: ServerResponse, body: unknown) => Promise<void>;
+    handleGet: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+} | null;
+//# sourceMappingURL=mcp-handler.d.ts.map

package/dist/mcp/mcp-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-handler.d.ts","sourceRoot":"","sources":["../../src/mcp/mcp-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAExD,wBAAsB,kBAAkB,CACpC,aAAa,GAAE,gBAAyB,GACzC,OAAO,CAAC,SAAS,CAAC,CAiBpB;AAED,wBAAsB,mBAAmB,CACrC,KAAK,EAAE,UAAU,EACjB,aAAa,EAAE,SAAS,EACxB,YAAY,EAAE,SAAS,GACxB,OAAO,CAAC,SAAS,CAAC,CA+CpB;AAED,wBAAsB,2BAA2B,CAC7C,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,SAAS,EACxB,WAAW,EAAE,YAAY,GAC1B,OAAO,CAAC,IAAI,CAAC,CAyBf;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,SAAS;sBAM1B,eAAe,OAAO,cAAc,QAAQ,OAAO;qBASpD,eAAe,OAAO,cAAc;SAUrE"}

package/dist/mcp/mcp-handler.js

@@ -0,0 +1,118 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { logger } from "@dexto/core";
+import { z } from "zod";
+import { randomUUID } from "crypto";
+async function createMcpTransport(transportType = "http") {
+  logger.info(`Creating MCP transport of type: ${transportType}`);
+  switch (transportType) {
+    case "stdio":
+      return new StdioServerTransport();
+    case "sse":
+      throw new Error(
+        "SSE transport requires HTTP response context and should be created per-request"
+      );
+    default: {
+      return new StreamableHTTPServerTransport({
+        sessionIdGenerator: randomUUID,
+        enableJsonResponse: true
+      });
+    }
+  }
+}
+async function initializeMcpServer(agent, agentCardData, mcpTransport) {
+  const mcpServer = new McpServer(
+    { name: agentCardData.name, version: agentCardData.version },
+    {
+      capabilities: {
+        resources: {}
+      }
+    }
+  );
+  const toolName = "chat_with_agent";
+  const toolDescription = "Allows you to chat with the an AI agent. Send a message to interact.";
+  mcpServer.tool(
+    toolName,
+    toolDescription,
+    { message: z.string() },
+    async ({ message }) => {
+      agent.logger.info(
+        `MCP tool '${toolName}' received message: ${message.substring(0, 100)}${message.length > 100 ? "..." : ""}`
+      );
+      const session = await agent.createSession(`mcp-${randomUUID()}`);
+      try {
+        const text = await agent.run(message, void 0, void 0, session.id);
+        agent.logger.info(
+          `MCP tool '${toolName}' sending response: ${text?.substring(0, 100)}${(text?.length ?? 0) > 100 ? "..." : ""}`
+        );
+        return { content: [{ type: "text", text: text ?? "" }] };
+      } finally {
+        await agent.deleteSession(session.id).catch(
+          (err) => agent.logger.warn(`Failed to cleanup MCP session ${session.id}: ${err}`)
+        );
+      }
+    }
+  );
+  agent.logger.info(`Registered MCP tool: '${toolName}'`);
+  await initializeAgentCardResource(mcpServer, agentCardData, agent.logger);
+  agent.logger.info(`Initializing MCP protocol server connection...`);
+  await mcpServer.connect(mcpTransport);
+  agent.logger.info(`\u2705 MCP server protocol connected via transport.`);
+  return mcpServer;
+}
+async function initializeAgentCardResource(mcpServer, agentCardData, agentLogger) {
+  const agentCardResourceProgrammaticName = "agentCard";
+  const agentCardResourceUri = "dexto://agent/card";
+  try {
+    const readCallback = async (uri, _extra) => {
+      agentLogger.info(`MCP client requesting resource at ${uri.href}`);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            type: "application/json",
+            text: JSON.stringify(agentCardData, null, 2)
+          }
+        ]
+      };
+    };
+    mcpServer.resource(agentCardResourceProgrammaticName, agentCardResourceUri, readCallback);
+    agentLogger.info(
+      `Registered MCP Resource: '${agentCardResourceProgrammaticName}' at URI '${agentCardResourceUri}'`
+    );
+  } catch (e) {
+    agentLogger.warn(
+      `Error attempting to register MCP Resource '${agentCardResourceProgrammaticName}': ${e.message}. Check SDK.`
+    );
+  }
+}
+function createMcpHttpHandlers(mcpTransport) {
+  if (!(mcpTransport instanceof StreamableHTTPServerTransport)) {
+    logger.info("Non-HTTP transport detected. Skipping HTTP route setup.");
+    return null;
+  }
+  const handlePost = async (req, res, body) => {
+    logger.info(`MCP POST /mcp received request body: ${JSON.stringify(body)}`);
+    try {
+      await mcpTransport.handleRequest(req, res, body);
+    } catch (err) {
+      logger.error(`MCP POST error: ${JSON.stringify(err, null, 2)}`);
+    }
+  };
+  const handleGet = async (req, res) => {
+    logger.info("MCP GET /mcp received request, attempting to establish SSE connection.");
+    try {
+      await mcpTransport.handleRequest(req, res);
+    } catch (err) {
+      logger.error(`MCP GET error: ${JSON.stringify(err, null, 2)}`);
+    }
+  };
+  return { handlePost, handleGet };
+}
+export {
+  createMcpHttpHandlers,
+  createMcpTransport,
+  initializeAgentCardResource,
+  initializeMcpServer
+};