@dexto/server 1.2.5

package/dist/hono/schemas/responses.cjs

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