@dexto/server 1.6.20 → 1.6.21

package/dist/hono/schemas/responses.cjs

@@ -21,16 +21,23 @@ __export(responses_exports, {
   AgentCardSchema: () => import_core4.AgentCardSchema,
   AgentRegistryEntrySchema: () => AgentRegistryEntrySchema,
   ApiErrorResponseSchema: () => ApiErrorResponseSchema,
+  BadRequestErrorResponse: () => BadRequestErrorResponse,
   CatalogModelInfoSchema: () => CatalogModelInfoSchema,
+  ConflictErrorResponse: () => ConflictErrorResponse,
   ContentPartSchema: () => ContentPartSchema,
   DeleteResponseSchema: () => DeleteResponseSchema,
   ErrorResponseSchema: () => ErrorResponseSchema,
   ExecutionLogSchema: () => ExecutionLogSchema,
   FilePartSchema: () => FilePartSchema,
+  ForbiddenErrorResponse: () => ForbiddenErrorResponse,
   HttpServerConfigSchema: () => import_core5.HttpServerConfigSchema,
   ImagePartSchema: () => ImagePartSchema,
+  InternalErrorResponse: () => InternalErrorResponse,
   InternalMessageSchema: () => InternalMessageSchema,
   IssueSchema: () => IssueSchema,
+  JsonObjectSchema: () => JsonObjectSchema,
+  JsonSchemaPropertySchema: () => JsonSchemaPropertySchema,
+  JsonValueSchema: () => JsonValueSchema,
   LLMConfigBaseSchema: () => import_core3.LLMConfigBaseSchema,
   LLMConfigResponseSchema: () => LLMConfigResponseSchema,
   LLMConfigSchema: () => LLMConfigSchema,
@@ -39,7 +46,9 @@ __export(responses_exports, {
   MessageSearchResponseSchema: () => MessageSearchResponseSchema,
   ModelFlatSchema: () => ModelFlatSchema,
   ModelStatisticsSchema: () => ModelStatisticsSchema,
+  NotFoundErrorResponse: () => NotFoundErrorResponse,
   OkResponseSchema: () => OkResponseSchema,
+  PaymentRequiredErrorResponse: () => PaymentRequiredErrorResponse,
   PermissionsConfigSchema: () => import_core6.PermissionsConfigSchema,
   PricingStatusSchema: () => PricingStatusSchema,
   PromptArgumentSchema: () => PromptArgumentSchema,
@@ -47,6 +56,7 @@ __export(responses_exports, {
   PromptInfoSchema: () => PromptInfoSchema,
   PromptSchema: () => PromptSchema,
   ProviderCatalogSchema: () => ProviderCatalogSchema,
+  RateLimitErrorResponse: () => RateLimitErrorResponse,
   RequestContentPartSchema: () => RequestContentPartSchema,
   RequestContentSchema: () => RequestContentSchema,
   ResourceConfigSchema: () => import_core7.ResourceConfigSchema,
@@ -65,10 +75,13 @@ __export(responses_exports, {
   StatusResponseSchema: () => StatusResponseSchema,
   StdioServerConfigSchema: () => import_core5.StdioServerConfigSchema,
   TextPartSchema: () => TextPartSchema,
+  TimeoutErrorResponse: () => TimeoutErrorResponse,
   TokenUsageSchema: () => TokenUsageSchema,
   ToolCallSchema: () => ToolCallSchema,
+  ToolInputSchema: () => ToolInputSchema,
   ToolSchema: () => ToolSchema,
   UIResourcePartSchema: () => UIResourcePartSchema,
+  UpstreamErrorResponse: () => UpstreamErrorResponse,
   UsageSummarySchema: () => UsageSummarySchema,
   WebhookSchema: () => WebhookSchema,
   WorkspaceSchema: () => WorkspaceSchema,
@@ -76,7 +89,7 @@ __export(responses_exports, {
   toContentInput: () => toContentInput
 });
 module.exports = __toCommonJS(responses_exports);
-var import_zod = require("zod");
+var import_zod_openapi = require("@hono/zod-openapi");
 var import_core = require("@dexto/core");
 var import_core2 = require("@dexto/core");
 var import_core3 = require("@dexto/core");
@@ -84,69 +97,174 @@ 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 IssueSchema = import_zod.z.object({
-  code: import_zod.z.string().describe("Machine-readable issue code"),
-  message: import_zod.z.string().describe("Human-readable issue message"),
-  scope: import_zod.z.string().describe("Domain that produced the issue"),
-  type: import_zod.z.string().describe("Error type used for HTTP status mapping"),
-  severity: import_zod.z.enum(["error", "warning"]).describe("Issue severity"),
-  path: import_zod.z.array(import_zod.z.union([import_zod.z.string(), import_zod.z.number()])).optional().describe("Optional location for the issue"),
-  context: import_zod.z.unknown().optional().describe("Optional structured issue context")
+const JsonValueOpenApiPlaceholder = {
+  type: "object",
+  additionalProperties: true,
+  description: "Any JSON-serializable value"
+};
+const JsonValueSchema = import_zod_openapi.z.lazy(
+  () => import_zod_openapi.z.union([
+    import_zod_openapi.z.string(),
+    import_zod_openapi.z.number(),
+    import_zod_openapi.z.boolean(),
+    import_zod_openapi.z.null(),
+    import_zod_openapi.z.array(JsonValueSchema),
+    import_zod_openapi.z.record(import_zod_openapi.z.string(), JsonValueSchema)
+  ])
+).openapi("JsonValue", JsonValueOpenApiPlaceholder).describe("Any JSON-serializable value");
+const JsonObjectSchema = import_zod_openapi.z.record(import_zod_openapi.z.string(), JsonValueSchema).openapi("JsonObject", {
+  type: "object",
+  additionalProperties: true
+}).describe("JSON object with arbitrary serializable values");
+const JsonSchemaPrimitiveTypeSchema = import_zod_openapi.z.enum(["string", "number", "integer", "boolean", "object", "array"]).describe("JSON Schema primitive type");
+const JsonSchemaEnumValueSchema = import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.number(), import_zod_openapi.z.boolean(), import_zod_openapi.z.null()]).describe("Allowed JSON Schema enum value");
+const JsonSchemaPropertySchema = import_zod_openapi.z.object({
+  type: JsonSchemaPrimitiveTypeSchema.optional().describe("Property type"),
+  description: import_zod_openapi.z.string().optional().describe("Property description"),
+  enum: import_zod_openapi.z.array(JsonSchemaEnumValueSchema).optional().describe("Enum values"),
+  default: JsonValueSchema.optional().describe("Default value"),
+  format: import_zod_openapi.z.string().optional().describe("JSON Schema format hint")
+}).passthrough().describe("JSON Schema property definition");
+const ToolInputSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("object").optional().describe('Schema type, always "object" when present'),
+  properties: import_zod_openapi.z.record(import_zod_openapi.z.string(), JsonSchemaPropertySchema).optional().describe("Property definitions"),
+  required: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Required property names")
+}).passthrough().describe("JSON Schema for tool input parameters");
+const IssueSchema = import_zod_openapi.z.object({
+  code: import_zod_openapi.z.string().describe("Machine-readable issue code"),
+  message: import_zod_openapi.z.string().describe("Human-readable issue message"),
+  scope: import_zod_openapi.z.string().describe("Domain that produced the issue"),
+  type: import_zod_openapi.z.string().describe("Error type used for HTTP status mapping"),
+  severity: import_zod_openapi.z.enum(["error", "warning"]).describe("Issue severity"),
+  path: import_zod_openapi.z.array(import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.number()])).optional().describe("Optional location for the issue"),
+  context: JsonValueSchema.optional().describe("Optional structured issue context")
 }).strict().describe("Structured validation or runtime issue");
-const ApiErrorResponseSchema = import_zod.z.object({
-  name: import_zod.z.string().optional().describe("Optional error class name"),
-  message: import_zod.z.string().describe("Human-readable error message"),
-  code: import_zod.z.string().optional().describe("Machine-readable error code"),
-  scope: import_zod.z.string().optional().describe("Domain that produced the error"),
-  type: import_zod.z.string().optional().describe("Error type used for HTTP status mapping"),
-  severity: import_zod.z.enum(["error", "warning"]).optional().describe("Optional error severity for lightweight failures"),
-  endpoint: import_zod.z.string().describe("Request path that failed"),
-  method: import_zod.z.string().describe("HTTP method for the failed request"),
-  traceId: import_zod.z.string().optional().describe("Optional trace identifier"),
-  recovery: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]).optional().describe("Optional recovery guidance"),
-  context: import_zod.z.unknown().optional().describe("Optional structured error context"),
-  issues: import_zod.z.array(IssueSchema).optional().describe("Validation issues when present"),
-  errorCount: import_zod.z.number().int().nonnegative().optional().describe("Number of errors"),
-  warningCount: import_zod.z.number().int().nonnegative().optional().describe("Number of warnings"),
-  stack: import_zod.z.string().optional().describe("Development-only stack trace")
+const ApiErrorResponseSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().optional().describe("Optional error class name"),
+  message: import_zod_openapi.z.string().describe("Human-readable error message"),
+  code: import_zod_openapi.z.string().optional().describe("Machine-readable error code"),
+  scope: import_zod_openapi.z.string().optional().describe("Domain that produced the error"),
+  type: import_zod_openapi.z.string().optional().describe("Error type used for HTTP status mapping"),
+  severity: import_zod_openapi.z.enum(["error", "warning"]).optional().describe("Optional error severity for lightweight failures"),
+  endpoint: import_zod_openapi.z.string().describe("Request path that failed"),
+  method: import_zod_openapi.z.string().describe("HTTP method for the failed request"),
+  traceId: import_zod_openapi.z.string().optional().describe("Optional trace identifier"),
+  recovery: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(import_zod_openapi.z.string())]).optional().describe("Optional recovery guidance"),
+  context: JsonValueSchema.optional().describe("Optional structured error context"),
+  issues: import_zod_openapi.z.array(IssueSchema).optional().describe("Validation issues when present"),
+  errorCount: import_zod_openapi.z.number().int().nonnegative().optional().describe("Number of errors"),
+  warningCount: import_zod_openapi.z.number().int().nonnegative().optional().describe("Number of warnings"),
+  stack: import_zod_openapi.z.string().optional().describe("Development-only stack trace")
 }).strict().describe("Standard API error response");
-const TextPartSchema = import_zod.z.object({
-  type: import_zod.z.literal("text").describe("Part type: text"),
-  text: import_zod.z.string().describe("Text content")
+const BadRequestErrorResponse = {
+  description: "Validation or request error",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const PaymentRequiredErrorResponse = {
+  description: "Payment required",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const ForbiddenErrorResponse = {
+  description: "Forbidden",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const NotFoundErrorResponse = {
+  description: "Resource not found",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const TimeoutErrorResponse = {
+  description: "Request timed out",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const ConflictErrorResponse = {
+  description: "Conflict",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const RateLimitErrorResponse = {
+  description: "Rate limited",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const InternalErrorResponse = {
+  description: "Internal server error",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const UpstreamErrorResponse = {
+  description: "Upstream service failure",
+  content: {
+    "application/json": {
+      schema: ApiErrorResponseSchema
+    }
+  }
+};
+const TextPartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("text").describe("Part type: text"),
+  text: import_zod_openapi.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: import_zod.z.string().describe("Base64-encoded image data"),
-  mimeType: import_zod.z.string().optional().describe("MIME type of the image")
+const ImagePartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("image").describe("Part type: image"),
+  image: import_zod_openapi.z.string().describe("Base64-encoded image data"),
+  mimeType: import_zod_openapi.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: import_zod.z.string().describe("Base64-encoded file data"),
-  mimeType: import_zod.z.string().describe("MIME type of the file"),
-  filename: import_zod.z.string().optional().describe("Optional filename")
+const FilePartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("file").describe("Part type: file"),
+  data: import_zod_openapi.z.string().describe("Base64-encoded file data"),
+  mimeType: import_zod_openapi.z.string().describe("MIME type of the file"),
+  filename: import_zod_openapi.z.string().optional().describe("Optional filename")
 }).strict().describe("File content part");
-const UIResourcePartSchema = import_zod.z.object({
-  type: import_zod.z.literal("ui-resource").describe("Part type: ui-resource"),
-  uri: import_zod.z.string().describe("URI identifying the UI resource (must start with ui://)"),
-  mimeType: import_zod.z.string().describe("MIME type: text/html, text/uri-list, or application/vnd.mcp-ui.remote-dom"),
-  content: import_zod.z.string().optional().describe("Inline HTML content or URL"),
-  blob: import_zod.z.string().optional().describe("Base64-encoded content (alternative to content)"),
-  metadata: import_zod.z.object({
-    title: import_zod.z.string().optional().describe("Display title for the UI resource"),
-    preferredSize: import_zod.z.object({
-      width: import_zod.z.number().describe("Preferred width in pixels"),
-      height: import_zod.z.number().describe("Preferred height in pixels")
+const UIResourcePartSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("ui-resource").describe("Part type: ui-resource"),
+  uri: import_zod_openapi.z.string().describe("URI identifying the UI resource (must start with ui://)"),
+  mimeType: import_zod_openapi.z.string().describe("MIME type: text/html, text/uri-list, or application/vnd.mcp-ui.remote-dom"),
+  content: import_zod_openapi.z.string().optional().describe("Inline HTML content or URL"),
+  blob: import_zod_openapi.z.string().optional().describe("Base64-encoded content (alternative to content)"),
+  metadata: import_zod_openapi.z.object({
+    title: import_zod_openapi.z.string().optional().describe("Display title for the UI resource"),
+    preferredSize: import_zod_openapi.z.object({
+      width: import_zod_openapi.z.number().describe("Preferred width in pixels"),
+      height: import_zod_openapi.z.number().describe("Preferred height in pixels")
     }).strict().optional().describe("Preferred rendering size")
   }).strict().optional().describe("Optional metadata for the UI resource")
 }).strict().describe("UI Resource content part for MCP-UI interactive components");
-const ContentPartSchema = import_zod.z.discriminatedUnion("type", [
+const ContentPartSchema = import_zod_openapi.z.discriminatedUnion("type", [
   TextPartSchema,
   ImagePartSchema,
   FilePartSchema,
   UIResourcePartSchema
 ]).describe("Message content part (text, image, file, or UI resource)");
-const RequestContentPartSchema = import_zod.z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Request message content part (text, image, or file)");
-const RequestContentSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.array(RequestContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal");
+const RequestContentPartSchema = import_zod_openapi.z.discriminatedUnion("type", [TextPartSchema, ImagePartSchema, FilePartSchema]).describe("Request message content part (text, image, or file)");
+const RequestContentSchema = import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(RequestContentPartSchema)]).describe("Message content - string for text, or ContentPart[] for multimodal");
 function serializeBinaryValue(value) {
   if (typeof value === "string") {
     return value;
@@ -217,300 +335,323 @@ function toApiContentPart(part) {
       };
   }
 }
-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")
+const ToolCallSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Unique identifier for this tool call"),
+  type: import_zod_openapi.z.literal("function").describe("Tool call type (currently only function is supported)"),
+  function: import_zod_openapi.z.object({
+    name: import_zod_openapi.z.string().describe("Name of the function to call"),
+    arguments: import_zod_openapi.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"),
-  cacheReadTokens: import_zod.z.number().int().nonnegative().optional().describe("Number of cache read tokens"),
-  cacheWriteTokens: import_zod.z.number().int().nonnegative().optional().describe("Number of cache write tokens"),
-  totalTokens: import_zod.z.number().int().nonnegative().optional().describe("Total tokens used")
+const TokenUsageSchema = import_zod_openapi.z.object({
+  inputTokens: import_zod_openapi.z.number().int().nonnegative().optional().describe("Number of input tokens"),
+  outputTokens: import_zod_openapi.z.number().int().nonnegative().optional().describe("Number of output tokens"),
+  reasoningTokens: import_zod_openapi.z.number().int().nonnegative().optional().describe("Number of reasoning tokens"),
+  cacheReadTokens: import_zod_openapi.z.number().int().nonnegative().optional().describe("Number of cache read tokens"),
+  cacheWriteTokens: import_zod_openapi.z.number().int().nonnegative().optional().describe("Number of cache write tokens"),
+  totalTokens: import_zod_openapi.z.number().int().nonnegative().optional().describe("Total tokens used")
 }).strict().describe("Token usage accounting");
-const PricingStatusSchema = import_zod.z.enum(import_core.LLM_PRICING_STATUSES).describe("Whether pricing was resolved for this response");
-const InternalMessageSchema = import_zod.z.object({
-  id: import_zod.z.string().uuid().optional().describe("Unique message identifier (UUID)"),
-  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"),
+const PricingStatusSchema = import_zod_openapi.z.enum(import_core.LLM_PRICING_STATUSES).describe("Whether pricing was resolved for this response");
+const InternalMessageSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().uuid().optional().describe("Unique message identifier (UUID)"),
+  role: import_zod_openapi.z.enum(["system", "user", "assistant", "tool"]).describe("Role of the message sender"),
+  timestamp: import_zod_openapi.z.number().int().positive().optional().describe("Creation timestamp (Unix ms)"),
+  content: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.null(), import_zod_openapi.z.array(ContentPartSchema)]).describe("Message content (string, null, or array of parts)"),
+  reasoning: import_zod_openapi.z.string().optional().describe("Optional model reasoning text"),
   tokenUsage: TokenUsageSchema.optional().describe("Optional token usage accounting"),
-  estimatedCost: import_zod.z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
+  estimatedCost: import_zod_openapi.z.number().nonnegative().optional().describe("Estimated cost in USD for this response"),
   pricingStatus: PricingStatusSchema.optional().describe(
     "Whether pricing was resolved for this response"
   ),
-  usageScopeId: import_zod.z.string().optional().describe("Optional usage scope identifier for runtime-scoped metering"),
-  model: import_zod.z.string().optional().describe("Model identifier for assistant messages"),
-  provider: import_zod.z.enum(import_core.LLM_PROVIDERS).optional().describe("Provider identifier 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"),
-  success: import_zod.z.boolean().optional().describe("Whether tool execution succeeded (present for role=tool messages)")
+  usageScopeId: import_zod_openapi.z.string().optional().describe("Optional usage scope identifier for runtime-scoped metering"),
+  model: import_zod_openapi.z.string().optional().describe("Model identifier for assistant messages"),
+  provider: import_zod_openapi.z.enum(import_core.LLM_PROVIDERS).optional().describe("Provider identifier for assistant messages"),
+  toolCalls: import_zod_openapi.z.array(ToolCallSchema).optional().describe("Tool calls made by the assistant"),
+  toolCallId: import_zod_openapi.z.string().optional().describe("ID of the tool call this message responds to"),
+  name: import_zod_openapi.z.string().optional().describe("Name of the tool that produced this result"),
+  success: import_zod_openapi.z.boolean().optional().describe("Whether tool execution succeeded (present for role=tool messages)")
 }).strict().describe("Internal message representation");
 const LLMConfigResponseSchema = import_core.LLMConfigBaseSchema.omit({ apiKey: true }).extend({
-  hasApiKey: import_zod.z.boolean().optional().describe("Whether an API key is configured")
+  hasApiKey: import_zod_openapi.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 SessionTokenUsageSchema = TokenUsageSchema.required().describe(
   "Session-level token usage (all fields required for cumulative totals)"
 );
-const SessionUsageTrackingSchema = import_zod.z.object({
-  hasUntrackedChatGPTLoginUsage: import_zod.z.boolean().optional().describe("Whether this session includes known untracked ChatGPT Login usage")
+const SessionUsageTrackingSchema = import_zod_openapi.z.object({
+  hasUntrackedChatGPTLoginUsage: import_zod_openapi.z.boolean().optional().describe("Whether this session includes known untracked ChatGPT Login usage")
 }).strict().describe("Usage tracking caveats for a session");
-const ModelStatisticsSchema = import_zod.z.object({
-  provider: import_zod.z.string().describe("LLM provider identifier"),
-  model: import_zod.z.string().describe("Model identifier"),
-  messageCount: import_zod.z.number().int().nonnegative().describe("Number of messages using this model"),
+const ModelStatisticsSchema = import_zod_openapi.z.object({
+  provider: import_zod_openapi.z.string().describe("LLM provider identifier"),
+  model: import_zod_openapi.z.string().describe("Model identifier"),
+  messageCount: import_zod_openapi.z.number().int().nonnegative().describe("Number of messages using this model"),
   tokenUsage: SessionTokenUsageSchema.describe("Token usage for this model"),
-  estimatedCost: import_zod.z.number().nonnegative().describe("Estimated cost in USD for this model"),
-  firstUsedAt: import_zod.z.number().int().positive().describe("First use timestamp (Unix ms)"),
-  lastUsedAt: import_zod.z.number().int().positive().describe("Last use timestamp (Unix ms)")
+  estimatedCost: import_zod_openapi.z.number().nonnegative().describe("Estimated cost in USD for this model"),
+  firstUsedAt: import_zod_openapi.z.number().int().positive().describe("First use timestamp (Unix ms)"),
+  lastUsedAt: import_zod_openapi.z.number().int().positive().describe("Last use timestamp (Unix ms)")
 }).strict().describe("Per-model statistics within a session");
-const UsageSummarySchema = import_zod.z.object({
+const UsageSummarySchema = import_zod_openapi.z.object({
   tokenUsage: SessionTokenUsageSchema.describe(
     "Aggregate token usage for the selected scope"
   ),
-  estimatedCost: import_zod.z.number().nonnegative().describe("Total estimated cost in USD for the selected scope"),
-  hasUnpricedResponses: import_zod.z.boolean().describe(
+  estimatedCost: import_zod_openapi.z.number().nonnegative().describe("Total estimated cost in USD for the selected scope"),
+  hasUnpricedResponses: import_zod_openapi.z.boolean().describe(
     "Whether any response in the selected scope has usage but no resolved pricing"
   ),
-  modelStats: import_zod.z.array(
-    import_zod.z.object({
-      provider: import_zod.z.string().describe("LLM provider identifier"),
-      model: import_zod.z.string().describe("Model identifier"),
-      messageCount: import_zod.z.number().int().nonnegative().describe("Number of responses using this model in the selected scope"),
+  modelStats: import_zod_openapi.z.array(
+    import_zod_openapi.z.object({
+      provider: import_zod_openapi.z.string().describe("LLM provider identifier"),
+      model: import_zod_openapi.z.string().describe("Model identifier"),
+      messageCount: import_zod_openapi.z.number().int().nonnegative().describe("Number of responses using this model in the selected scope"),
       tokenUsage: SessionTokenUsageSchema.describe(
         "Token usage for this model in the selected scope"
       ),
-      estimatedCost: import_zod.z.number().nonnegative().describe("Estimated cost in USD for this model in the selected scope")
+      estimatedCost: import_zod_openapi.z.number().nonnegative().describe("Estimated cost in USD for this model in the selected scope")
     }).strict()
   ).optional().describe("Per-model usage statistics within the selected scope")
 }).strict().describe("Usage summary for a session or session scope");
 const ScopedUsageSummarySchema = UsageSummarySchema.extend({
-  scopeId: import_zod.z.string().describe("Usage scope identifier")
+  scopeId: import_zod_openapi.z.string().describe("Usage scope identifier")
 }).strict().describe("Usage summary for a specific scope within a session");
-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"),
+const SessionMetadataSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Unique session identifier"),
+  createdAt: import_zod_openapi.z.number().int().positive().nullable().describe("Creation timestamp (Unix ms, null if unavailable)"),
+  lastActivity: import_zod_openapi.z.number().int().positive().nullable().describe("Last activity timestamp (Unix ms, null if unavailable)"),
+  messageCount: import_zod_openapi.z.number().int().nonnegative().describe("Total number of messages in session"),
+  title: import_zod_openapi.z.string().optional().nullable().describe("Optional session title"),
   tokenUsage: SessionTokenUsageSchema.optional().describe(
     "Aggregate token usage across all models"
   ),
-  estimatedCost: import_zod.z.number().nonnegative().optional().describe("Total estimated cost in USD across all models"),
-  modelStats: import_zod.z.array(ModelStatisticsSchema).optional().describe("Per-model usage statistics (for multi-model sessions)"),
+  estimatedCost: import_zod_openapi.z.number().nonnegative().optional().describe("Total estimated cost in USD across all models"),
+  modelStats: import_zod_openapi.z.array(ModelStatisticsSchema).optional().describe("Per-model usage statistics (for multi-model sessions)"),
   usageTracking: SessionUsageTrackingSchema.optional().describe(
     "Known caveats or gaps in usage tracking for this session"
   ),
-  workspaceId: import_zod.z.string().optional().nullable().describe("Associated workspace ID, if any"),
-  parentSessionId: import_zod.z.string().optional().nullable().describe("Parent session ID if this session was forked, otherwise null")
+  workspaceId: import_zod_openapi.z.string().optional().nullable().describe("Associated workspace ID, if any"),
+  parentSessionId: import_zod_openapi.z.string().optional().nullable().describe("Parent session ID if this session was forked, otherwise null")
 }).strict().describe("Session metadata");
-const WorkspaceSchema = import_zod.z.object({
-  id: import_zod.z.string().describe("Workspace identifier"),
-  path: import_zod.z.string().describe("Workspace root path"),
-  name: import_zod.z.string().optional().nullable().describe("Optional workspace display name"),
-  createdAt: import_zod.z.number().int().positive().describe("Creation timestamp (Unix ms)"),
-  lastActiveAt: import_zod.z.number().int().positive().describe("Last active timestamp (Unix ms)")
+const WorkspaceSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Workspace identifier"),
+  path: import_zod_openapi.z.string().describe("Workspace root path"),
+  name: import_zod_openapi.z.string().optional().nullable().describe("Optional workspace display name"),
+  createdAt: import_zod_openapi.z.number().int().positive().describe("Creation timestamp (Unix ms)"),
+  lastActiveAt: import_zod_openapi.z.number().int().positive().describe("Last active timestamp (Unix ms)")
 }).strict().describe("Workspace metadata");
-const ScheduleTaskSchema = import_zod.z.object({
-  instruction: import_zod.z.string().describe("Instruction to execute"),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Optional task metadata")
+const ScheduleTaskSchema = import_zod_openapi.z.object({
+  instruction: import_zod_openapi.z.string().describe("Instruction to execute"),
+  metadata: JsonObjectSchema.optional().describe("Optional task metadata")
 }).strict().describe("Schedule task definition");
-const ScheduleSchema = import_zod.z.object({
-  id: import_zod.z.string().describe("Schedule ID"),
-  name: import_zod.z.string().describe("Schedule name"),
-  cronExpression: import_zod.z.string().describe("Cron expression"),
-  timezone: import_zod.z.string().describe("Timezone for schedule"),
-  enabled: import_zod.z.boolean().describe("Whether the schedule is enabled"),
+const ScheduleSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Schedule ID"),
+  name: import_zod_openapi.z.string().describe("Schedule name"),
+  cronExpression: import_zod_openapi.z.string().describe("Cron expression"),
+  timezone: import_zod_openapi.z.string().describe("Timezone for schedule"),
+  enabled: import_zod_openapi.z.boolean().describe("Whether the schedule is enabled"),
   task: ScheduleTaskSchema.describe("Schedule task configuration"),
-  sessionMode: import_zod.z.enum(["ephemeral", "dedicated", "inherit", "fixed"]).describe("Session context mode"),
-  sessionId: import_zod.z.string().optional().describe("Session ID when using fixed/inherit mode"),
-  workspacePath: import_zod.z.string().optional().describe("Workspace path override"),
-  createdAt: import_zod.z.number().int().positive().describe("Creation timestamp (Unix ms)"),
-  updatedAt: import_zod.z.number().int().positive().describe("Last update timestamp (Unix ms)"),
-  lastRunAt: import_zod.z.number().int().positive().optional().describe("Last run timestamp (Unix ms)"),
-  nextRunAt: import_zod.z.number().int().positive().optional().describe("Next run timestamp (Unix ms)"),
-  runCount: import_zod.z.number().int().nonnegative().describe("Total executions"),
-  successCount: import_zod.z.number().int().nonnegative().describe("Successful executions"),
-  failureCount: import_zod.z.number().int().nonnegative().describe("Failed executions"),
-  lastError: import_zod.z.string().optional().describe("Last execution error, if any")
+  sessionMode: import_zod_openapi.z.enum(["ephemeral", "dedicated", "inherit", "fixed"]).describe("Session context mode"),
+  sessionId: import_zod_openapi.z.string().optional().describe("Session ID when using fixed/inherit mode"),
+  workspacePath: import_zod_openapi.z.string().optional().describe("Workspace path override"),
+  createdAt: import_zod_openapi.z.number().int().positive().describe("Creation timestamp (Unix ms)"),
+  updatedAt: import_zod_openapi.z.number().int().positive().describe("Last update timestamp (Unix ms)"),
+  lastRunAt: import_zod_openapi.z.number().int().positive().optional().describe("Last run timestamp (Unix ms)"),
+  nextRunAt: import_zod_openapi.z.number().int().positive().optional().describe("Next run timestamp (Unix ms)"),
+  runCount: import_zod_openapi.z.number().int().nonnegative().describe("Total executions"),
+  successCount: import_zod_openapi.z.number().int().nonnegative().describe("Successful executions"),
+  failureCount: import_zod_openapi.z.number().int().nonnegative().describe("Failed executions"),
+  lastError: import_zod_openapi.z.string().optional().describe("Last execution error, if any")
 }).strict().describe("Automation schedule");
-const ExecutionLogSchema = import_zod.z.object({
-  id: import_zod.z.string().describe("Execution log ID"),
-  scheduleId: import_zod.z.string().describe("Schedule ID"),
-  triggeredAt: import_zod.z.number().int().positive().describe("Trigger timestamp (Unix ms)"),
-  completedAt: import_zod.z.number().int().positive().optional().describe("Completion timestamp (Unix ms)"),
-  status: import_zod.z.enum(["pending", "success", "failed", "timeout"]).describe("Execution status"),
-  duration: import_zod.z.number().int().nonnegative().optional().describe("Execution duration in ms"),
-  error: import_zod.z.string().optional().describe("Execution error, if any"),
-  result: import_zod.z.string().optional().describe("Execution result, if any")
+const ExecutionLogSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Execution log ID"),
+  scheduleId: import_zod_openapi.z.string().describe("Schedule ID"),
+  triggeredAt: import_zod_openapi.z.number().int().positive().describe("Trigger timestamp (Unix ms)"),
+  completedAt: import_zod_openapi.z.number().int().positive().optional().describe("Completion timestamp (Unix ms)"),
+  status: import_zod_openapi.z.enum(["pending", "success", "failed", "timeout"]).describe("Execution status"),
+  duration: import_zod_openapi.z.number().int().nonnegative().optional().describe("Execution duration in ms"),
+  error: import_zod_openapi.z.string().optional().describe("Execution error, if any"),
+  result: import_zod_openapi.z.string().optional().describe("Execution result, if any")
 }).strict().describe("Schedule execution log");
-const SearchResultSchema = import_zod.z.object({
-  sessionId: import_zod.z.string().describe("Session ID where the message was found"),
+const SearchResultSchema = import_zod_openapi.z.object({
+  sessionId: import_zod_openapi.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")
+  matchedText: import_zod_openapi.z.string().describe("The specific text that matched the search query"),
+  context: import_zod_openapi.z.string().describe("Context around the match for preview"),
+  messageIndex: import_zod_openapi.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"),
+const SessionSearchResultSchema = import_zod_openapi.z.object({
+  sessionId: import_zod_openapi.z.string().describe("Session ID"),
+  matchCount: import_zod_openapi.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")
+  metadata: import_zod_openapi.z.object({
+    createdAt: import_zod_openapi.z.number().int().positive().describe("Session creation timestamp"),
+    lastActivity: import_zod_openapi.z.number().int().positive().describe("Last activity timestamp"),
+    messageCount: import_zod_openapi.z.number().int().nonnegative().describe("Total messages in session")
   }).strict().describe("Session metadata")
 }).strict().describe("Result of a session search");
-const MessageSearchResponseSchema = import_zod.z.object({
-  results: import_zod.z.array(SearchResultSchema).describe("Array of search results"),
-  total: import_zod.z.number().int().nonnegative().describe("Total number of results available"),
-  hasMore: import_zod.z.boolean().describe("Whether there are more results beyond the current page"),
-  query: import_zod.z.string().describe("Query that was searched")
+const MessageSearchResponseSchema = import_zod_openapi.z.object({
+  results: import_zod_openapi.z.array(SearchResultSchema).describe("Array of search results"),
+  total: import_zod_openapi.z.number().int().nonnegative().describe("Total number of results available"),
+  hasMore: import_zod_openapi.z.boolean().describe("Whether there are more results beyond the current page"),
+  query: import_zod_openapi.z.string().describe("Query that was searched")
 }).strict().describe("Message search response");
-const SessionSearchResponseSchema = import_zod.z.object({
-  results: import_zod.z.array(SessionSearchResultSchema).describe("Array of session search results"),
-  total: import_zod.z.number().int().nonnegative().describe("Total number of sessions with matches"),
-  hasMore: import_zod.z.boolean().describe(
+const SessionSearchResponseSchema = import_zod_openapi.z.object({
+  results: import_zod_openapi.z.array(SessionSearchResultSchema).describe("Array of session search results"),
+  total: import_zod_openapi.z.number().int().nonnegative().describe("Total number of sessions with matches"),
+  hasMore: import_zod_openapi.z.boolean().describe(
     "Always false - session search returns all matching sessions without pagination"
   ),
-  query: import_zod.z.string().describe("Query that was searched")
+  query: import_zod_openapi.z.string().describe("Query that was searched")
 }).strict().describe("Session search response");
-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)")
+const WebhookSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Unique webhook identifier"),
+  url: import_zod_openapi.z.string().url().describe("Webhook URL to send events to"),
+  events: import_zod_openapi.z.array(import_zod_openapi.z.string()).describe("Array of event types this webhook subscribes to"),
+  createdAt: import_zod_openapi.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"),
-  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")
+const CatalogModelInfoSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe("Model name identifier"),
+  maxInputTokens: import_zod_openapi.z.number().int().positive().describe("Maximum input tokens"),
+  default: import_zod_openapi.z.boolean().optional().describe("Whether this is a default model"),
+  supportedFileTypes: import_zod_openapi.z.array(import_zod_openapi.z.enum(["audio", "pdf", "image"])).describe("File types this model supports"),
+  displayName: import_zod_openapi.z.string().optional().describe("Human-readable display name"),
+  pricing: import_zod_openapi.z.object({
+    inputPerM: import_zod_openapi.z.number().describe("Input cost per million tokens (USD)"),
+    outputPerM: import_zod_openapi.z.number().describe("Output cost per million tokens (USD)"),
+    cacheReadPerM: import_zod_openapi.z.number().optional().describe("Cache read cost per million tokens"),
+    cacheWritePerM: import_zod_openapi.z.number().optional().describe("Cache write cost per million tokens"),
+    currency: import_zod_openapi.z.literal("USD").optional().describe("Currency"),
+    unit: import_zod_openapi.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"),
-  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")
+const ProviderCatalogSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe("Provider display name"),
+  hasApiKey: import_zod_openapi.z.boolean().describe("Whether API key is configured"),
+  primaryEnvVar: import_zod_openapi.z.string().describe("Primary environment variable for API key"),
+  supportsBaseURL: import_zod_openapi.z.boolean().describe("Whether custom base URLs are supported"),
+  models: import_zod_openapi.z.array(CatalogModelInfoSchema).describe("Models available from this provider"),
+  supportedFileTypes: import_zod_openapi.z.array(import_zod_openapi.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")
+  provider: import_zod_openapi.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")
+const AgentRegistryEntrySchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Unique agent identifier"),
+  name: import_zod_openapi.z.string().describe("Agent name"),
+  description: import_zod_openapi.z.string().describe("Agent description"),
+  author: import_zod_openapi.z.string().optional().describe("Agent author"),
+  tags: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Agent tags"),
+  type: import_zod_openapi.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")
+const ResourceSchema = import_zod_openapi.z.object({
+  uri: import_zod_openapi.z.string().describe("Resource URI"),
+  name: import_zod_openapi.z.string().optional().describe("Resource name"),
+  description: import_zod_openapi.z.string().optional().describe("Resource description"),
+  mimeType: import_zod_openapi.z.string().optional().describe("MIME type of the resource"),
+  source: import_zod_openapi.z.enum(["mcp", "internal"]).describe("Source system that provides this resource"),
+  serverName: import_zod_openapi.z.string().optional().describe("Original server/provider name (for MCP resources)"),
+  size: import_zod_openapi.z.number().optional().describe("Size of the resource in bytes (if known)"),
+  lastModified: import_zod_openapi.z.string().datetime().optional().describe("Last modified timestamp (ISO 8601 string)"),
+  metadata: import_zod_openapi.z.record(import_zod_openapi.z.string(), JsonValueSchema).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")
+const ToolSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe("Tool name"),
+  description: import_zod_openapi.z.string().describe("Tool description"),
+  inputSchema: ToolInputSchema.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")
+const PromptArgumentSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe("Argument name"),
+  description: import_zod_openapi.z.string().optional().describe("Argument description"),
+  required: import_zod_openapi.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")
+const PromptDefinitionSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe("Prompt name"),
+  title: import_zod_openapi.z.string().optional().describe("Prompt title"),
+  description: import_zod_openapi.z.string().optional().describe("Prompt description"),
+  arguments: import_zod_openapi.z.array(PromptArgumentSchema).optional().describe("Array of argument definitions"),
+  disableModelInvocation: import_zod_openapi.z.boolean().optional().describe("Exclude from auto-invocation list in system prompt"),
+  userInvocable: import_zod_openapi.z.boolean().optional().describe("Whether to show in slash command menu"),
+  allowedTools: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Tools to auto-approve when this prompt is active"),
+  toolkits: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Toolkits to load when invoked"),
+  model: import_zod_openapi.z.string().optional().describe("Model to use when this prompt is invoked"),
+  context: import_zod_openapi.z.enum(["inline", "fork"]).optional().describe("Execution context for this prompt"),
+  agent: import_zod_openapi.z.string().optional().describe("Agent ID to use for fork execution")
 }).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", "config", "custom"]).describe("Source of the prompt"),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Additional metadata")
+const PromptInfoSchema = import_zod_openapi.z.object({
+  name: import_zod_openapi.z.string().describe("Prompt name"),
+  title: import_zod_openapi.z.string().optional().describe("Prompt title"),
+  description: import_zod_openapi.z.string().optional().describe("Prompt description"),
+  arguments: import_zod_openapi.z.array(PromptArgumentSchema).optional().describe("Array of argument definitions"),
+  disableModelInvocation: import_zod_openapi.z.boolean().optional().describe("Exclude from auto-invocation list in system prompt"),
+  userInvocable: import_zod_openapi.z.boolean().optional().describe("Whether to show in slash command menu"),
+  allowedTools: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Tools to auto-approve when this prompt is active"),
+  toolkits: import_zod_openapi.z.array(import_zod_openapi.z.string()).optional().describe("Toolkits to load when invoked"),
+  model: import_zod_openapi.z.string().optional().describe("Model to use when this prompt is invoked"),
+  context: import_zod_openapi.z.enum(["inline", "fork"]).optional().describe("Execution context for this prompt"),
+  agent: import_zod_openapi.z.string().optional().describe("Agent ID to use for fork execution"),
+  source: import_zod_openapi.z.enum(["mcp", "config", "custom"]).describe("Source of the prompt"),
+  displayName: import_zod_openapi.z.string().optional().describe("Base display name set by provider"),
+  commandName: import_zod_openapi.z.string().optional().describe("Collision-resolved slash command name"),
+  metadata: JsonObjectSchema.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")
+const PromptSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Unique prompt identifier"),
+  name: import_zod_openapi.z.string().describe("Prompt name"),
+  description: import_zod_openapi.z.string().optional().describe("Prompt description"),
+  content: import_zod_openapi.z.string().describe("Prompt template content"),
+  variables: import_zod_openapi.z.array(import_zod_openapi.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"),
+const OkResponseSchema = (dataSchema) => import_zod_openapi.z.object({
+  ok: import_zod_openapi.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")
+const ErrorResponseSchema = import_zod_openapi.z.object({
+  ok: import_zod_openapi.z.literal(false).describe("Indicates failed response"),
+  error: import_zod_openapi.z.object({
+    message: import_zod_openapi.z.string().describe("Error message"),
+    code: import_zod_openapi.z.string().optional().describe("Error code"),
+    details: JsonValueSchema.optional().describe("Additional error details")
   }).strict().describe("Error details")
 }).strict().describe("Error API response");
-const StandardErrorEnvelopeSchema = import_zod.z.object({
-  code: import_zod.z.string().describe("Error code"),
-  message: import_zod.z.string().describe("Error message"),
-  scope: import_zod.z.string().describe("Error scope"),
-  type: import_zod.z.string().describe("Error type"),
-  context: import_zod.z.unknown().optional().describe("Error context"),
-  recovery: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]).optional().describe("Recovery guidance"),
-  traceId: import_zod.z.string().describe("Trace identifier"),
-  endpoint: import_zod.z.string().describe("Request endpoint"),
-  method: import_zod.z.string().describe("HTTP method")
+const StandardErrorEnvelopeSchema = import_zod_openapi.z.object({
+  code: import_zod_openapi.z.string().describe("Error code"),
+  message: import_zod_openapi.z.string().describe("Error message"),
+  scope: import_zod_openapi.z.string().describe("Error scope"),
+  type: import_zod_openapi.z.string().describe("Error type"),
+  context: JsonValueSchema.optional().describe("Error context"),
+  recovery: import_zod_openapi.z.union([import_zod_openapi.z.string(), import_zod_openapi.z.array(import_zod_openapi.z.string())]).optional().describe("Recovery guidance"),
+  traceId: import_zod_openapi.z.string().describe("Trace identifier"),
+  endpoint: import_zod_openapi.z.string().describe("Request endpoint"),
+  method: import_zod_openapi.z.string().describe("HTTP method")
 }).strict().describe("Standard API error envelope");
-const StatusResponseSchema = import_zod.z.object({
-  status: import_zod.z.string().describe("Operation status"),
-  message: import_zod.z.string().optional().describe("Optional status message")
+const StatusResponseSchema = import_zod_openapi.z.object({
+  status: import_zod_openapi.z.string().describe("Operation status"),
+  message: import_zod_openapi.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")
+const DeleteResponseSchema = import_zod_openapi.z.object({
+  status: import_zod_openapi.z.literal("deleted").describe("Indicates successful deletion"),
+  id: import_zod_openapi.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,
   ApiErrorResponseSchema,
+  BadRequestErrorResponse,
   CatalogModelInfoSchema,
+  ConflictErrorResponse,
   ContentPartSchema,
   DeleteResponseSchema,
   ErrorResponseSchema,
   ExecutionLogSchema,
   FilePartSchema,
+  ForbiddenErrorResponse,
   HttpServerConfigSchema,
   ImagePartSchema,
+  InternalErrorResponse,
   InternalMessageSchema,
   IssueSchema,
+  JsonObjectSchema,
+  JsonSchemaPropertySchema,
+  JsonValueSchema,
   LLMConfigBaseSchema,
   LLMConfigResponseSchema,
   LLMConfigSchema,
@@ -519,7 +660,9 @@ const DeleteResponseSchema = import_zod.z.object({
   MessageSearchResponseSchema,
   ModelFlatSchema,
   ModelStatisticsSchema,
+  NotFoundErrorResponse,
   OkResponseSchema,
+  PaymentRequiredErrorResponse,
   PermissionsConfigSchema,
   PricingStatusSchema,
   PromptArgumentSchema,
@@ -527,6 +670,7 @@ const DeleteResponseSchema = import_zod.z.object({
   PromptInfoSchema,
   PromptSchema,
   ProviderCatalogSchema,
+  RateLimitErrorResponse,
   RequestContentPartSchema,
   RequestContentSchema,
   ResourceConfigSchema,
@@ -545,10 +689,13 @@ const DeleteResponseSchema = import_zod.z.object({
   StatusResponseSchema,
   StdioServerConfigSchema,
   TextPartSchema,
+  TimeoutErrorResponse,
   TokenUsageSchema,
   ToolCallSchema,
+  ToolInputSchema,
   ToolSchema,
   UIResourcePartSchema,
+  UpstreamErrorResponse,
   UsageSummarySchema,
   WebhookSchema,
   WorkspaceSchema,