@elevasis/sdk 0.1.0 → 0.3.1

package/dist/index.js

@@ -1 +1,3445 @@
+import { z } from 'zod';
 
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/runtime.ts
+var StepType = /* @__PURE__ */ ((StepType2) => {
+  StepType2["LINEAR"] = "linear";
+  StepType2["CONDITIONAL"] = "conditional";
+  return StepType2;
+})(StepType || {});
+var ExecutionError = class extends Error {
+  type;
+  context;
+  constructor(message, context) {
+    super(message);
+    this.name = this.constructor.name;
+    this.type = "execution_error";
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  isRetryable() {
+    return false;
+  }
+};
+var ToolingError = class extends ExecutionError {
+  errorType;
+  details;
+  constructor(errorType, message, details) {
+    super(message, { type: errorType, details });
+    this.errorType = errorType;
+    this.details = details;
+  }
+};
+
+// ../core/src/platform/registry/domains.ts
+var DOMAINS = {
+  // Business domains
+  ACQUISITION: "acquisition",
+  SUPPORT: "support",
+  DELIVERY: "delivery",
+  OPERATIONS: "operations",
+  FINANCE: "finance",
+  EXECUTIVE: "executive",
+  // Technical domains
+  TESTING: "testing",
+  INTERNAL: "internal",
+  INTEGRATION: "integration",
+  UTILITY: "utility",
+  DIAGNOSTIC: "diagnostic"
+};
+var ACQUISITION_DOMAIN = {
+  id: DOMAINS.ACQUISITION,
+  name: "Client Acquisition",
+  description: "Client acquisition pipeline and lead database management",
+  color: "blue"
+};
+var SUPPORT_DOMAIN = {
+  id: DOMAINS.SUPPORT,
+  name: "Customer Support",
+  description: "Ticket triage, knowledge base, escalations",
+  color: "green"
+};
+var DELIVERY_DOMAIN = {
+  id: DOMAINS.DELIVERY,
+  name: "Client Delivery",
+  description: "Project execution and milestone tracking",
+  color: "orange"
+};
+var OPERATIONS_DOMAIN = {
+  id: DOMAINS.OPERATIONS,
+  name: "Operations",
+  description: "Internal business operations and administration",
+  color: "violet"
+};
+var FINANCE_DOMAIN = {
+  id: DOMAINS.FINANCE,
+  name: "Finance",
+  description: "Billing, invoicing, and financial operations",
+  color: "pink"
+};
+var EXECUTIVE_DOMAIN = {
+  id: DOMAINS.EXECUTIVE,
+  name: "Executive Operations",
+  description: "High-level business orchestration and decision-making",
+  color: "indigo"
+};
+var TESTING_DOMAIN = {
+  id: DOMAINS.TESTING,
+  name: "Testing",
+  description: "Test resources and development workflows",
+  color: "gray"
+};
+var INTERNAL_DOMAIN = {
+  id: DOMAINS.INTERNAL,
+  name: "Internal",
+  description: "Internal platform resources",
+  color: "dark"
+};
+var INTEGRATION_DOMAIN = {
+  id: DOMAINS.INTEGRATION,
+  name: "Integration",
+  description: "External service integrations",
+  color: "teal"
+};
+var UTILITY_DOMAIN = {
+  id: DOMAINS.UTILITY,
+  name: "Utility",
+  description: "Utility workflows for maintenance and diagnostics",
+  color: "grape"
+};
+var DIAGNOSTIC_DOMAIN = {
+  id: DOMAINS.DIAGNOSTIC,
+  name: "Diagnostic",
+  description: "Diagnostic workflows for testing integrations and services",
+  color: "yellow"
+};
+var DOMAIN_MAP = {
+  [DOMAINS.ACQUISITION]: ACQUISITION_DOMAIN,
+  [DOMAINS.SUPPORT]: SUPPORT_DOMAIN,
+  [DOMAINS.DELIVERY]: DELIVERY_DOMAIN,
+  [DOMAINS.OPERATIONS]: OPERATIONS_DOMAIN,
+  [DOMAINS.FINANCE]: FINANCE_DOMAIN,
+  [DOMAINS.EXECUTIVE]: EXECUTIVE_DOMAIN,
+  [DOMAINS.TESTING]: TESTING_DOMAIN,
+  [DOMAINS.INTERNAL]: INTERNAL_DOMAIN,
+  [DOMAINS.INTEGRATION]: INTEGRATION_DOMAIN,
+  [DOMAINS.UTILITY]: UTILITY_DOMAIN,
+  [DOMAINS.DIAGNOSTIC]: DIAGNOSTIC_DOMAIN
+};
+
+// ../core/src/execution/core/server/environment.ts
+function detectEnvironment() {
+  const env = process.env.NODE_ENV || "development";
+  if (env === "production") return "production";
+  if (env === "staging") return "staging";
+  return "development";
+}
+function canExecuteResource(resource, environment) {
+  const env = environment || detectEnvironment();
+  return env === "production" ? resource.status === "prod" : true;
+}
+
+// ../core/src/execution/engine/base/errors.ts
+var ExecutionError2 = class extends Error {
+  /**
+   * Additional context/metadata for the error.
+   * Stored in execution_errors.metadata JSONB column.
+   */
+  context;
+  /**
+   * @param message - Human-readable error message
+   * @param context - Additional context/metadata for observability
+   */
+  constructor(message, context) {
+    super(message);
+    this.name = this.constructor.name;
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Indicates whether this error type is retryable.
+   * Default: false (safe default - only retry when explicitly safe to do so)
+   *
+   * Subclasses should override to return true for retryable scenarios:
+   * - Network/infrastructure errors (exponential backoff)
+   * - Rate limiting (linear backoff)
+   * - Service availability (exponential backoff)
+   * - Circuit breaker (circuit breaker's own delay)
+   *
+   * DO NOT retry:
+   * - Authentication/authorization errors
+   * - Validation errors
+   * - Configuration errors
+   * - Resource exhaustion errors
+   */
+  isRetryable() {
+    return false;
+  }
+};
+var GPT5OptionsSchema = z.object({
+  reasoning_effort: z.enum(["minimal", "low", "medium", "high"]).optional(),
+  verbosity: z.enum(["low", "medium", "high"]).optional()
+});
+var GPT5ConfigSchema = z.object({
+  model: z.enum(["gpt-5", "gpt-5-mini"]),
+  provider: z.enum(["openai"]),
+  apiKey: z.string().min(1),
+  temperature: z.literal(1),
+  // Required to be exactly 1
+  maxTokens: z.number().min(4e3).optional(),
+  topP: z.number().min(0).max(1).optional(),
+  modelOptions: GPT5OptionsSchema.optional()
+});
+var MockConfigSchema = z.object({
+  model: z.enum(["mock"]),
+  provider: z.enum(["mock"]),
+  apiKey: z.string(),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().min(500).optional(),
+  topP: z.number().min(0).max(1).optional(),
+  modelOptions: z.object({}).strict().optional()
+  // No options supported
+});
+var OpenRouterOptionsSchema = z.object({
+  /** Optional transforms to apply (e.g., 'middle-out' for long context) */
+  transforms: z.array(z.string()).optional(),
+  /** Routing strategy (e.g., 'fallback' for automatic provider failover) */
+  route: z.enum(["fallback"]).optional()
+});
+var OpenRouterConfigSchema = z.object({
+  model: z.enum([
+    "openrouter/anthropic/claude-sonnet-4.5",
+    "openrouter/deepseek/deepseek-v3.2",
+    "openrouter/x-ai/grok-4.1-fast"
+  ]),
+  provider: z.literal("openrouter"),
+  apiKey: z.string().min(1),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().min(500).optional(),
+  topP: z.number().min(0).max(1).optional(),
+  modelOptions: OpenRouterOptionsSchema.optional()
+});
+var GoogleOptionsSchema = z.object({
+  /** Thinking level for Gemini 3 models (controls reasoning depth) */
+  thinkingLevel: z.enum(["minimal", "low", "medium", "high"]).optional()
+});
+var GoogleConfigSchema = z.object({
+  model: z.enum(["gemini-3-flash-preview"]),
+  provider: z.literal("google"),
+  apiKey: z.string().min(1),
+  temperature: z.literal(1).optional(),
+  // Must be 1 for Gemini 3 (changing degrades performance)
+  maxTokens: z.number().min(500).optional(),
+  topP: z.number().min(0).max(1).optional(),
+  modelOptions: GoogleOptionsSchema.optional()
+});
+var AnthropicOptionsSchema = z.object({});
+var AnthropicConfigSchema = z.object({
+  model: z.enum(["claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-4-5"]),
+  provider: z.literal("anthropic"),
+  apiKey: z.string().min(1),
+  temperature: z.number().min(0).max(1).optional(),
+  maxTokens: z.number().min(1e3).optional(),
+  // Anthropic requires max_tokens
+  topP: z.number().min(0).max(1).optional(),
+  modelOptions: AnthropicOptionsSchema.optional()
+});
+var MODEL_INFO = {
+  // OpenAI GPT-5 (Reasoning Models)
+  "gpt-5": {
+    inputCostPer1M: 125,
+    // $1.25 per 1M tokens
+    outputCostPer1M: 1e3,
+    // $10.00 per 1M tokens
+    minTokens: 4e3,
+    // Reasoning models need more
+    recommendedTokens: 8e3,
+    maxTokens: 4e5,
+    // 128k context window
+    category: "reasoning",
+    configSchema: GPT5ConfigSchema
+  },
+  "gpt-5-mini": {
+    inputCostPer1M: 25,
+    // $0.25 per 1M tokens
+    outputCostPer1M: 200,
+    // $2.00 per 1M tokens
+    minTokens: 4e3,
+    // Reasoning models need more
+    recommendedTokens: 8e3,
+    maxTokens: 4e5,
+    // 128k context window
+    category: "reasoning",
+    configSchema: GPT5ConfigSchema
+    // Same schema as gpt-5
+  },
+  // Mock model for testing
+  mock: {
+    inputCostPer1M: 0,
+    // Free for tests
+    outputCostPer1M: 0,
+    minTokens: 500,
+    // Low minimum for test flexibility
+    recommendedTokens: 1e3,
+    maxTokens: 1e5,
+    // 100k for testing
+    category: "standard",
+    configSchema: MockConfigSchema
+  },
+  // OpenRouter Models (via openrouter.ai)
+  "openrouter/anthropic/claude-sonnet-4.5": {
+    inputCostPer1M: 300,
+    // $3.00 per 1M tokens
+    outputCostPer1M: 1500,
+    // $15.00 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 4e3,
+    maxTokens: 2e5,
+    // 200k context window
+    category: "standard",
+    configSchema: OpenRouterConfigSchema
+  },
+  "openrouter/deepseek/deepseek-v3.2": {
+    inputCostPer1M: 26,
+    // $0.26 per 1M tokens
+    outputCostPer1M: 39,
+    // $0.39 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 4e3,
+    maxTokens: 163840,
+    // 163,840 context window
+    category: "reasoning",
+    configSchema: OpenRouterConfigSchema
+  },
+  "openrouter/x-ai/grok-4.1-fast": {
+    inputCostPer1M: 20,
+    // $0.20 per 1M tokens
+    outputCostPer1M: 50,
+    // $0.50 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 4e3,
+    maxTokens: 2e6,
+    // 2M context window
+    category: "standard",
+    configSchema: OpenRouterConfigSchema
+  },
+  // Google Gemini Models (direct SDK access via @google/genai)
+  "gemini-3-flash-preview": {
+    inputCostPer1M: 50,
+    // $0.50 per 1M tokens
+    outputCostPer1M: 300,
+    // $3.00 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 8e3,
+    maxTokens: 1e6,
+    // 1M context window
+    category: "standard",
+    configSchema: GoogleConfigSchema
+  },
+  // Anthropic Claude Models (direct SDK access via @anthropic-ai/sdk)
+  // Using aliases - automatically points to latest versions
+  "claude-opus-4-5": {
+    inputCostPer1M: 1500,
+    // $15.00 per 1M tokens
+    outputCostPer1M: 7500,
+    // $75.00 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 8e3,
+    maxTokens: 2e5,
+    // 200k context window
+    category: "reasoning",
+    configSchema: AnthropicConfigSchema
+  },
+  "claude-sonnet-4-5": {
+    inputCostPer1M: 300,
+    // $3.00 per 1M tokens
+    outputCostPer1M: 1500,
+    // $15.00 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 8e3,
+    maxTokens: 2e5,
+    // 200k context window
+    category: "standard",
+    configSchema: AnthropicConfigSchema
+  },
+  "claude-haiku-4-5": {
+    inputCostPer1M: 80,
+    // $0.80 per 1M tokens
+    outputCostPer1M: 400,
+    // $4.00 per 1M tokens
+    minTokens: 2e3,
+    recommendedTokens: 4e3,
+    maxTokens: 2e5,
+    // 200k context window
+    category: "standard",
+    configSchema: AnthropicConfigSchema
+  }
+};
+function getModelInfo(model) {
+  if (model in MODEL_INFO) {
+    return MODEL_INFO[model];
+  }
+  for (const [knownModel, info] of Object.entries(MODEL_INFO)) {
+    if (model.startsWith(knownModel)) {
+      return info;
+    }
+  }
+  return void 0;
+}
+
+// ../core/src/execution/engine/llm/errors.ts
+var ModelConfigError = class extends ExecutionError2 {
+  constructor(message, field, model, context) {
+    super(message, { ...context, field, model });
+    this.field = field;
+    this.model = model;
+  }
+  type = "model_config_error";
+  severity = "warning";
+  category = "validation";
+};
+function validateModelConfig(config) {
+  const model = config.model;
+  if (!model) {
+    throw new ModelConfigError("Missing model field", "model", "unknown");
+  }
+  const modelInfo = getModelInfo(model);
+  if (!modelInfo) {
+    throw new ModelConfigError(`Unknown model: ${model}`, "model", model);
+  }
+  if (!modelInfo.configSchema) {
+    return;
+  }
+  const result = modelInfo.configSchema.safeParse(config);
+  if (!result.success) {
+    const firstError = result.error.issues[0];
+    const fieldPath = firstError.path.join(".");
+    const fieldName = fieldPath || "config";
+    throw new ModelConfigError(`Invalid config for ${model}: ${firstError.message}`, fieldName, model);
+  }
+}
+
+// ../core/src/platform/registry/validation.ts
+var RegistryValidationError = class extends Error {
+  constructor(orgName, resourceId, field, message) {
+    super(message);
+    this.orgName = orgName;
+    this.resourceId = resourceId;
+    this.field = field;
+    this.name = "RegistryValidationError";
+  }
+};
+function validateOrganizationResources(orgName, resources) {
+  const seenIds = /* @__PURE__ */ new Set();
+  resources.workflows?.forEach((workflow) => {
+    const id = workflow.config.resourceId;
+    if (seenIds.has(id)) {
+      throw new RegistryValidationError(
+        orgName,
+        id,
+        null,
+        `Duplicate resourceId "${id}" in organization "${orgName}". Workflows and agents must have unique IDs within an organization.`
+      );
+    }
+    seenIds.add(id);
+    if ("modelConfig" in workflow && workflow.modelConfig) {
+      validateResourceModelConfig(orgName, id, workflow.modelConfig);
+    }
+    if (workflow.interface) {
+      validateExecutionInterface(orgName, id, workflow.interface, workflow.contract.inputSchema);
+    }
+  });
+  resources.agents?.forEach((agent) => {
+    const id = agent.config.resourceId;
+    if (seenIds.has(id)) {
+      throw new RegistryValidationError(
+        orgName,
+        id,
+        null,
+        `Duplicate resourceId "${id}" in organization "${orgName}". Workflows and agents must have unique IDs within an organization.`
+      );
+    }
+    seenIds.add(id);
+    validateResourceModelConfig(orgName, id, agent.modelConfig);
+    if (agent.interface) {
+      validateExecutionInterface(orgName, id, agent.interface, agent.contract.inputSchema);
+    }
+  });
+}
+function validateResourceModelConfig(orgName, resourceId, modelConfig) {
+  try {
+    validateModelConfig(modelConfig);
+  } catch (error) {
+    if (error instanceof ModelConfigError) {
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        error.field,
+        `Invalid model config in ${orgName}/${resourceId}: ${error.message} (field: ${error.field})`
+      );
+    }
+    throw error;
+  }
+}
+function validateExecutionInterface(orgName, resourceId, executionInterface, inputSchema) {
+  const form = executionInterface.form;
+  const fieldMappings = form.fieldMappings ?? {};
+  const schemaShape = extractZodShape(inputSchema);
+  if (!schemaShape) {
+    return;
+  }
+  const schemaFieldNames = Object.keys(schemaShape);
+  const formToSchemaMap = /* @__PURE__ */ new Map();
+  for (const field of form.fields) {
+    const schemaKey = fieldMappings[field.name] ?? field.name;
+    formToSchemaMap.set(field.name, schemaKey);
+  }
+  for (const schemaFieldName of schemaFieldNames) {
+    const schemaField = schemaShape[schemaFieldName];
+    const isRequired = !isZodOptional(schemaField);
+    let hasFormField = false;
+    for (const [formFieldName, mappedSchemaName] of Array.from(formToSchemaMap.entries())) {
+      if (mappedSchemaName === schemaFieldName) {
+        hasFormField = true;
+        const formField = form.fields.find((f) => f.name === formFieldName);
+        if (isRequired && !formField?.required) {
+          throw new RegistryValidationError(
+            orgName,
+            resourceId,
+            `interface.form.fields.${formFieldName}`,
+            `ExecutionInterface field "${formFieldName}" should be required to match inputSchema field "${schemaFieldName}" in ${orgName}/${resourceId}`
+          );
+        }
+        break;
+      }
+    }
+    if (isRequired && !hasFormField) {
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        "interface.form.fields",
+        `ExecutionInterface missing required field "${schemaFieldName}" from inputSchema in ${orgName}/${resourceId}`
+      );
+    }
+  }
+  for (const [formFieldName, schemaFieldName] of Array.from(formToSchemaMap.entries())) {
+    if (schemaFieldName.includes(".")) {
+      const topLevelField = schemaFieldName.split(".")[0];
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        `interface.form.fields.${formFieldName}`,
+        `ExecutionInterface field "${formFieldName}" uses nested notation. Flatten the inputSchema by moving nested fields to top-level (e.g., "${topLevelField}.x" \u2192 "x") in ${orgName}/${resourceId}`
+      );
+    }
+    if (!schemaFieldNames.includes(schemaFieldName)) {
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        `interface.form.fields.${formFieldName}`,
+        `ExecutionInterface field "${formFieldName}" maps to non-existent schema field "${schemaFieldName}" in ${orgName}/${resourceId}`
+      );
+    }
+  }
+}
+function extractZodShape(schema) {
+  if ("shape" in schema && typeof schema.shape === "object") {
+    return schema.shape;
+  }
+  if ("_def" in schema) {
+    const def = schema._def;
+    if (def.innerType) {
+      return extractZodShape(def.innerType);
+    }
+    if (def.schema) {
+      return extractZodShape(def.schema);
+    }
+  }
+  return null;
+}
+function isZodOptional(schema) {
+  return schema.isOptional();
+}
+function validateRelationships(orgName, resources) {
+  if (!resources.relationships && !resources.triggers && !resources.externalResources && !resources.humanCheckpoints) return;
+  const validAgentIds = new Set(resources.agents?.map((a) => a.config.resourceId) ?? []);
+  const validWorkflowIds = new Set(resources.workflows?.map((w) => w.config.resourceId) ?? []);
+  const validIntegrationIds = new Set(resources.integrations?.map((i) => i.resourceId) ?? []);
+  const validTriggerIds = new Set(resources.triggers?.map((t) => t.resourceId) ?? []);
+  const allInternalIds = /* @__PURE__ */ new Set([
+    ...Array.from(validAgentIds),
+    ...Array.from(validWorkflowIds),
+    ...Array.from(validTriggerIds),
+    ...Array.from(validIntegrationIds)
+  ]);
+  validateTriggers(orgName, resources.triggers ?? []);
+  validateResourceRelationships(
+    orgName,
+    resources.relationships ?? {},
+    validAgentIds,
+    validWorkflowIds,
+    validIntegrationIds,
+    validTriggerIds
+  );
+  validateExternalResources(
+    orgName,
+    resources.externalResources ?? [],
+    allInternalIds,
+    validAgentIds,
+    validWorkflowIds,
+    validIntegrationIds
+  );
+  validateHumanCheckpoints(orgName, resources.humanCheckpoints ?? [], allInternalIds, validAgentIds, validWorkflowIds);
+}
+function validateTriggers(_orgName, _triggers, _validAgentIds, _validWorkflowIds) {
+}
+function validateResourceRelationships(orgName, relationships, validAgentIds, validWorkflowIds, validIntegrationIds, validTriggerIds) {
+  for (const [resourceId, declaration] of Object.entries(relationships)) {
+    const resourceExists = validAgentIds.has(resourceId) || validWorkflowIds.has(resourceId) || validTriggerIds.has(resourceId);
+    if (!resourceExists) {
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        null,
+        `[${orgName}] Relationship declared for non-existent resource: ${resourceId}`
+      );
+    }
+    declaration.triggers?.agents?.forEach((agentId) => {
+      if (!validAgentIds.has(agentId)) {
+        throw new RegistryValidationError(
+          orgName,
+          resourceId,
+          "triggers.agents",
+          `[${orgName}] Resource '${resourceId}' triggers non-existent agent: ${agentId}`
+        );
+      }
+    });
+    declaration.triggers?.workflows?.forEach((workflowId) => {
+      if (!validWorkflowIds.has(workflowId)) {
+        throw new RegistryValidationError(
+          orgName,
+          resourceId,
+          "triggers.workflows",
+          `[${orgName}] Resource '${resourceId}' triggers non-existent workflow: ${workflowId}`
+        );
+      }
+    });
+    declaration.uses?.integrations?.forEach((integrationId) => {
+      if (!validIntegrationIds.has(integrationId)) {
+        throw new RegistryValidationError(
+          orgName,
+          resourceId,
+          "uses.integrations",
+          `[${orgName}] Resource '${resourceId}' uses non-existent integration: ${integrationId}`
+        );
+      }
+    });
+  }
+}
+function validateExternalResources(orgName, externalResources, allInternalIds, validAgentIds, validWorkflowIds, validIntegrationIds) {
+  externalResources.forEach((external) => {
+    if (allInternalIds.has(external.resourceId)) {
+      throw new RegistryValidationError(
+        orgName,
+        external.resourceId,
+        null,
+        `[${orgName}] External resource ID '${external.resourceId}' conflicts with internal resource ID`
+      );
+    }
+    external.triggers?.agents?.forEach((agentId) => {
+      if (!validAgentIds.has(agentId)) {
+        throw new RegistryValidationError(
+          orgName,
+          external.resourceId,
+          "triggers.agents",
+          `[${orgName}] External resource '${external.resourceId}' triggers non-existent agent: ${agentId}`
+        );
+      }
+    });
+    external.triggers?.workflows?.forEach((workflowId) => {
+      if (!validWorkflowIds.has(workflowId)) {
+        throw new RegistryValidationError(
+          orgName,
+          external.resourceId,
+          "triggers.workflows",
+          `[${orgName}] External resource '${external.resourceId}' triggers non-existent workflow: ${workflowId}`
+        );
+      }
+    });
+    external.uses?.integrations?.forEach((integrationId) => {
+      if (!validIntegrationIds.has(integrationId)) {
+        throw new RegistryValidationError(
+          orgName,
+          external.resourceId,
+          "uses.integrations",
+          `[${orgName}] External resource '${external.resourceId}' uses non-existent integration: ${integrationId}`
+        );
+      }
+    });
+  });
+}
+function validateHumanCheckpoints(orgName, humanCheckpoints, allInternalIds, validAgentIds, validWorkflowIds) {
+  humanCheckpoints.forEach((humanCheckpoint) => {
+    if (allInternalIds.has(humanCheckpoint.resourceId)) {
+      throw new RegistryValidationError(
+        orgName,
+        humanCheckpoint.resourceId,
+        null,
+        `[${orgName}] Human checkpoint ID '${humanCheckpoint.resourceId}' conflicts with internal resource ID`
+      );
+    }
+    humanCheckpoint.requestedBy?.agents?.forEach((agentId) => {
+      if (!validAgentIds.has(agentId)) {
+        throw new RegistryValidationError(
+          orgName,
+          humanCheckpoint.resourceId,
+          "requestedBy.agents",
+          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' requestedBy non-existent agent: ${agentId}`
+        );
+      }
+    });
+    humanCheckpoint.requestedBy?.workflows?.forEach((workflowId) => {
+      if (!validWorkflowIds.has(workflowId)) {
+        throw new RegistryValidationError(
+          orgName,
+          humanCheckpoint.resourceId,
+          "requestedBy.workflows",
+          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' requestedBy non-existent workflow: ${workflowId}`
+        );
+      }
+    });
+    humanCheckpoint.routesTo?.agents?.forEach((agentId) => {
+      if (!validAgentIds.has(agentId)) {
+        throw new RegistryValidationError(
+          orgName,
+          humanCheckpoint.resourceId,
+          "routesTo.agents",
+          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' routesTo non-existent agent: ${agentId}`
+        );
+      }
+    });
+    humanCheckpoint.routesTo?.workflows?.forEach((workflowId) => {
+      if (!validWorkflowIds.has(workflowId)) {
+        throw new RegistryValidationError(
+          orgName,
+          humanCheckpoint.resourceId,
+          "routesTo.workflows",
+          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' routesTo non-existent workflow: ${workflowId}`
+        );
+      }
+    });
+  });
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/Refs.js
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
+  }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/getRelativePath.js
+var getRelativePath = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i])
+      break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/zodV3V4Compat.js
+var ZodFirstPartyTypeKindFromZod;
+try {
+  const zodImport = __require("zod");
+  ZodFirstPartyTypeKindFromZod = zodImport.ZodFirstPartyTypeKind;
+} catch {
+}
+var ZodFirstPartyTypeKind = ZodFirstPartyTypeKindFromZod || {
+  ZodNumber: "ZodNumber",
+  ZodBigInt: "ZodBigInt",
+  ZodBoolean: "ZodBoolean",
+  ZodDate: "ZodDate",
+  ZodUndefined: "ZodUndefined",
+  ZodNull: "ZodNull",
+  ZodVoid: "ZodVoid",
+  ZodAny: "ZodAny",
+  ZodUnknown: "ZodUnknown",
+  ZodNever: "ZodNever",
+  ZodArray: "ZodArray",
+  ZodObject: "ZodObject",
+  ZodUnion: "ZodUnion",
+  ZodDiscriminatedUnion: "ZodDiscriminatedUnion",
+  ZodIntersection: "ZodIntersection",
+  ZodTuple: "ZodTuple",
+  ZodRecord: "ZodRecord",
+  ZodMap: "ZodMap",
+  ZodSet: "ZodSet",
+  ZodFunction: "ZodFunction",
+  ZodLazy: "ZodLazy",
+  ZodLiteral: "ZodLiteral",
+  ZodEnum: "ZodEnum",
+  ZodNativeEnum: "ZodNativeEnum",
+  ZodPromise: "ZodPromise",
+  ZodEffects: "ZodEffects",
+  ZodOptional: "ZodOptional",
+  ZodNullable: "ZodNullable",
+  ZodDefault: "ZodDefault",
+  ZodCatch: "ZodCatch",
+  ZodReadonly: "ZodReadonly",
+  ZodBranded: "ZodBranded",
+  ZodPipeline: "ZodPipeline"};
+function getDefTypeName(def) {
+  return def?.typeName || def?.type;
+}
+function getInnerTypeDef(wrapperDef) {
+  if (!wrapperDef?.innerType)
+    return void 0;
+  return wrapperDef.innerType.def || wrapperDef.innerType._def;
+}
+function isNullableType(def) {
+  const typeName = getDefTypeName(def);
+  return typeName === "nullable" || typeName === "ZodNullable";
+}
+function getAllPrimitiveTypeNames() {
+  return [
+    // V3 names
+    "ZodString",
+    "ZodNumber",
+    "ZodBigInt",
+    "ZodBoolean",
+    "ZodNull",
+    // V4 names
+    "string",
+    "number",
+    "bigint",
+    "boolean",
+    "null"
+  ];
+}
+function extractMetadata(schema) {
+  let metadata = {};
+  if (schema?._def?.description) {
+    metadata.description = schema._def.description;
+  }
+  if (typeof schema?.meta === "function") {
+    try {
+      const meta = schema.meta();
+      if (meta && typeof meta === "object") {
+        metadata = { ...metadata, ...meta };
+      }
+    } catch {
+    }
+  }
+  if (!metadata.description && schema?.description) {
+    metadata.description = schema.description;
+  }
+  return metadata;
+}
+var primitiveMappings = {
+  // V3 mappings
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "string",
+  // BigInt is represented as string in JSON
+  ZodBoolean: "boolean",
+  ZodNull: "null",
+  // V4 mappings
+  string: "string",
+  number: "number",
+  bigint: "string",
+  // BigInt is represented as string in JSON
+  boolean: "boolean",
+  null: "null"
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef(refs) {
+  if (refs.target !== "openAi") {
+    return {};
+  }
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/array.js
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  const elementType = def.element || def.type;
+  const elementDef = elementType?.def || elementType?._def;
+  const elementTypeName = elementDef?.type || elementDef?.typeName;
+  if (elementDef && elementTypeName !== "any" && elementTypeName !== "ZodAny") {
+    res.items = parseDef(elementDef, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.checks) {
+    for (const check of def.checks) {
+      const checkDef = check._zod?.def;
+      if (checkDef) {
+        let message = checkDef.message;
+        if (!message && checkDef.error && typeof checkDef.error === "function") {
+          try {
+            message = checkDef.error();
+          } catch (e) {
+          }
+        }
+        switch (checkDef.check) {
+          case "min_length":
+            setResponseValueAndErrors(res, "minItems", checkDef.minimum, message, refs);
+            break;
+          case "max_length":
+            setResponseValueAndErrors(res, "maxItems", checkDef.maximum, message, refs);
+            break;
+          case "length_equals":
+            const length = checkDef.length;
+            if (length !== void 0) {
+              setResponseValueAndErrors(res, "minItems", length, message, refs);
+              setResponseValueAndErrors(res, "maxItems", length, message, refs);
+            }
+            break;
+        }
+      }
+    }
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    const checkDef = check._zod?.def;
+    if (checkDef) {
+      let message = checkDef.message;
+      if (!message && checkDef.error && typeof checkDef.error === "function") {
+        try {
+          message = checkDef.error();
+        } catch (e) {
+        }
+      }
+      switch (checkDef.check) {
+        case "greater_than":
+          const minValue = checkDef.value;
+          if (refs.target === "jsonSchema7") {
+            if (checkDef.inclusive) {
+              setResponseValueAndErrors(res, "minimum", minValue, message, refs);
+            } else {
+              setResponseValueAndErrors(res, "exclusiveMinimum", minValue, message, refs);
+            }
+          } else {
+            if (!checkDef.inclusive) {
+              res.exclusiveMinimum = true;
+            }
+            setResponseValueAndErrors(res, "minimum", minValue, message, refs);
+          }
+          break;
+        case "less_than":
+          const maxValue = checkDef.value;
+          if (refs.target === "jsonSchema7") {
+            if (checkDef.inclusive) {
+              setResponseValueAndErrors(res, "maximum", maxValue, message, refs);
+            } else {
+              setResponseValueAndErrors(res, "exclusiveMaximum", maxValue, message, refs);
+            }
+          } else {
+            if (!checkDef.inclusive) {
+              res.exclusiveMaximum = true;
+            }
+            setResponseValueAndErrors(res, "maximum", maxValue, message, refs);
+          }
+          break;
+        case "multiple_of":
+          const multipleValue = checkDef.value;
+          setResponseValueAndErrors(res, "multipleOf", multipleValue, message, refs);
+          break;
+      }
+    } else {
+      switch (check.kind) {
+        case "min":
+          if (refs.target === "jsonSchema7") {
+            if (check.inclusive) {
+              setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+            } else {
+              setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+            }
+          } else {
+            if (!check.inclusive) {
+              res.exclusiveMinimum = true;
+            }
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          }
+          break;
+        case "max":
+          if (refs.target === "jsonSchema7") {
+            if (check.inclusive) {
+              setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+            } else {
+              setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+            }
+          } else {
+            if (!check.inclusive) {
+              res.exclusiveMaximum = true;
+            }
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          }
+          break;
+        case "multipleOf":
+          setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+          break;
+      }
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef(_def, refs) {
+  if (_def.type && _def.type._def) {
+    return parseDef(_def.type._def, refs);
+  } else {
+    return parseDef(_def, refs);
+  }
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/catch.js
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def, refs);
+  }
+}
+var integerDateParser = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  if (def.checks) {
+    for (const check of def.checks) {
+      const checkDef = check._zod?.def;
+      if (checkDef) {
+        let message = checkDef.message;
+        if (!message && checkDef.error && typeof checkDef.error === "function") {
+          try {
+            message = checkDef.error();
+          } catch (e) {
+          }
+        }
+        switch (checkDef.check) {
+          case "greater_than":
+            const minValue = checkDef.value instanceof Date ? checkDef.value.getTime() : checkDef.value;
+            setResponseValueAndErrors(res, "minimum", minValue, message, refs);
+            break;
+          case "less_than":
+            const maxValue = checkDef.value instanceof Date ? checkDef.value.getTime() : checkDef.value;
+            setResponseValueAndErrors(res, "maximum", maxValue, message, refs);
+            break;
+        }
+      } else {
+        switch (check.kind) {
+          case "min":
+            setResponseValueAndErrors(
+              res,
+              "minimum",
+              check.value,
+              // This is in milliseconds
+              check.message,
+              refs
+            );
+            break;
+          case "max":
+            setResponseValueAndErrors(
+              res,
+              "maximum",
+              check.value,
+              // This is in milliseconds
+              check.message,
+              refs
+            );
+            break;
+        }
+      }
+    }
+  }
+  return res;
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef(_def, refs) {
+  if (_def.type === "pipe") {
+    return refs.effectStrategy === "input" ? parseDef(_def.in?.def || _def.in?._def, refs) : parseAnyDef(refs);
+  }
+  if (_def.schema) {
+    return refs.effectStrategy === "input" ? parseDef(_def.schema._def || _def.schema.def, refs) : parseAnyDef(refs);
+  }
+  return parseAnyDef(refs);
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef(def) {
+  const values = def.entries ? Object.values(def.entries) : def.values;
+  return {
+    type: "string",
+    enum: Array.from(values)
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/intersection.js
+var isJsonSchema7AllOfType = (type) => {
+  if ("type" in type && type.type === "string")
+    return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === void 0) {
+        unevaluatedProperties = void 0;
+      }
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        unevaluatedProperties = void 0;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : void 0;
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef(def, refs) {
+  const value = def.values ? def.values[0] : def.value;
+  const parsedType = typeof value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType === "bigint" ? "integer" : parsedType,
+      enum: [value]
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: value
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/string.js
+var emojiRegex = void 0;
+var zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex === void 0) {
+      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    }
+    return emojiRegex;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      const checkDef = check._zod?.def;
+      if (checkDef) {
+        switch (checkDef.check) {
+          case "min_length":
+            let minLengthMessage = checkDef.message;
+            if (!minLengthMessage && checkDef.error && typeof checkDef.error === "function") {
+              try {
+                minLengthMessage = checkDef.error();
+              } catch (e) {
+              }
+            }
+            setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, checkDef.minimum) : checkDef.minimum, minLengthMessage, refs);
+            break;
+          case "max_length":
+            let maxLengthMessage = checkDef.message;
+            if (!maxLengthMessage && checkDef.error && typeof checkDef.error === "function") {
+              try {
+                maxLengthMessage = checkDef.error();
+              } catch (e) {
+              }
+            }
+            setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, checkDef.maximum) : checkDef.maximum, maxLengthMessage, refs);
+            break;
+          case "length_equals":
+            let message = checkDef.message;
+            if (!message && checkDef.error && typeof checkDef.error === "function") {
+              try {
+                message = checkDef.error();
+              } catch (e) {
+              }
+            }
+            const length = checkDef.length;
+            if (length !== void 0) {
+              setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, length) : length, message, refs);
+              setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, length) : length, message, refs);
+            }
+            break;
+          case "string_format":
+            let formatMessage = checkDef.message;
+            if (!formatMessage && checkDef.error && typeof checkDef.error === "function") {
+              try {
+                formatMessage = checkDef.error();
+              } catch (e) {
+              }
+            }
+            const format = checkDef.format;
+            if (format === "email") {
+              switch (refs.emailStrategy) {
+                case "format:email":
+                  addFormat(res, "email", formatMessage, refs);
+                  break;
+                case "format:idn-email":
+                  addFormat(res, "idn-email", formatMessage, refs);
+                  break;
+                case "pattern:zod":
+                  addPattern(res, zodPatterns.email, formatMessage, refs);
+                  break;
+              }
+            } else if (format === "uri") {
+              addFormat(res, "uri", formatMessage, refs);
+            } else if (format === "url") {
+              addFormat(res, "uri", formatMessage, refs);
+            } else if (format === "uuid") {
+              addFormat(res, "uuid", formatMessage, refs);
+            } else if (format === "date-time") {
+              addFormat(res, "date-time", formatMessage, refs);
+            } else if (format === "date") {
+              addFormat(res, "date", formatMessage, refs);
+            } else if (format === "time") {
+              addFormat(res, "time", formatMessage, refs);
+            } else if (format === "duration") {
+              addFormat(res, "duration", formatMessage, refs);
+            } else if (format === "datetime") {
+              addFormat(res, "date-time", formatMessage, refs);
+            } else if (format === "ipv4") {
+              addFormat(res, "ipv4", formatMessage, refs);
+            } else if (format === "ipv6") {
+              addFormat(res, "ipv6", formatMessage, refs);
+            } else if (format === "ulid") {
+              addPattern(res, zodPatterns.ulid, formatMessage, refs);
+            } else if (format === "nanoid") {
+              addPattern(res, zodPatterns.nanoid, formatMessage, refs);
+            } else if (format === "cuid") {
+              addPattern(res, zodPatterns.cuid, formatMessage, refs);
+            } else if (format === "cuid2") {
+              addPattern(res, zodPatterns.cuid2, formatMessage, refs);
+            } else if (format === "base64") {
+              switch (refs.base64Strategy) {
+                case "format:binary":
+                  addFormat(res, "binary", formatMessage, refs);
+                  break;
+                case "contentEncoding:base64":
+                default:
+                  if (formatMessage && refs.errorMessages) {
+                    res.errorMessage = {
+                      ...res.errorMessage,
+                      contentEncoding: formatMessage
+                    };
+                  }
+                  res.contentEncoding = "base64";
+                  break;
+                case "pattern:zod":
+                  addPattern(res, zodPatterns.base64, formatMessage, refs);
+                  break;
+              }
+            } else if (format === "regex" && checkDef.pattern) {
+              let message2 = checkDef.message;
+              if (!message2 && checkDef.error && typeof checkDef.error === "function") {
+                try {
+                  message2 = checkDef.error();
+                } catch (e) {
+                }
+              }
+              addPattern(res, checkDef.pattern, message2, refs);
+            } else if (checkDef.pattern) {
+              let message2 = checkDef.message;
+              if (!message2 && checkDef.error && typeof checkDef.error === "function") {
+                try {
+                  message2 = checkDef.error();
+                } catch (e) {
+                }
+              }
+              if (refs.patternStrategy === "preserve") {
+                let preservedPattern;
+                if (checkDef.prefix !== void 0) {
+                  preservedPattern = `^${checkDef.prefix}`;
+                } else if (checkDef.suffix !== void 0) {
+                  preservedPattern = `${checkDef.suffix}$`;
+                } else if (checkDef.includes !== void 0) {
+                  preservedPattern = checkDef.includes;
+                }
+                if (preservedPattern !== void 0) {
+                  addPattern(res, new RegExp(preservedPattern), message2, refs);
+                  break;
+                }
+              }
+              let normalizedPattern = checkDef.pattern;
+              const patternSource = checkDef.pattern.source;
+              if (patternSource.startsWith("^") && patternSource.endsWith(".*")) {
+                normalizedPattern = new RegExp(patternSource.slice(0, -2), checkDef.pattern.flags);
+              } else if (patternSource.startsWith(".*") && patternSource.endsWith("$")) {
+                normalizedPattern = new RegExp(patternSource.slice(2), checkDef.pattern.flags);
+              }
+              addPattern(res, normalizedPattern, message2, refs);
+            }
+            break;
+        }
+        continue;
+      }
+      if (check.kind) {
+        switch (check.kind) {
+          case "min":
+            setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+            break;
+          case "max":
+            setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+            break;
+          case "email":
+            switch (refs.emailStrategy) {
+              case "format:email":
+                addFormat(res, "email", check.message, refs);
+                break;
+              case "format:idn-email":
+                addFormat(res, "idn-email", check.message, refs);
+                break;
+              case "pattern:zod":
+                addPattern(res, zodPatterns.email, check.message, refs);
+                break;
+            }
+            break;
+          case "url":
+            addFormat(res, "uri", check.message, refs);
+            break;
+          case "uuid":
+            addFormat(res, "uuid", check.message, refs);
+            break;
+          case "regex":
+            addPattern(res, check.regex, check.message, refs);
+            break;
+          case "cuid":
+            addPattern(res, zodPatterns.cuid, check.message, refs);
+            break;
+          case "cuid2":
+            addPattern(res, zodPatterns.cuid2, check.message, refs);
+            break;
+          case "startsWith":
+            addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+            break;
+          case "endsWith":
+            addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+            break;
+          case "datetime":
+            addFormat(res, "date-time", check.message, refs);
+            break;
+          case "date":
+            addFormat(res, "date", check.message, refs);
+            break;
+          case "time":
+            addFormat(res, "time", check.message, refs);
+            break;
+          case "duration":
+            addFormat(res, "duration", check.message, refs);
+            break;
+          case "length":
+            setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+            setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+            break;
+          case "includes": {
+            addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+            break;
+          }
+          case "ip": {
+            if (check.version !== "v6") {
+              addFormat(res, "ipv4", check.message, refs);
+            }
+            if (check.version !== "v4") {
+              addFormat(res, "ipv6", check.message, refs);
+            }
+            break;
+          }
+          case "base64url":
+            addPattern(res, zodPatterns.base64url, check.message, refs);
+            break;
+          case "jwt":
+            addPattern(res, zodPatterns.jwt, check.message, refs);
+            break;
+          case "cidr": {
+            if (check.version !== "v6") {
+              addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+            }
+            if (check.version !== "v4") {
+              addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+            }
+            break;
+          }
+          case "emoji":
+            addPattern(res, zodPatterns.emoji(), check.message, refs);
+            break;
+          case "ulid": {
+            addPattern(res, zodPatterns.ulid, check.message, refs);
+            break;
+          }
+          case "base64": {
+            switch (refs.base64Strategy) {
+              case "format:binary": {
+                addFormat(res, "binary", check.message, refs);
+                break;
+              }
+              case "contentEncoding:base64": {
+                setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+                break;
+              }
+              case "pattern:zod": {
+                addPattern(res, zodPatterns.base64, check.message, refs);
+                break;
+              }
+            }
+            break;
+          }
+          case "nanoid": {
+            addPattern(res, zodPatterns.nanoid, check.message, refs);
+          }
+        }
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema.errorMessage.format }
+        }
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "format", value, message, refs);
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema.errorMessage.pattern }
+        }
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    // Case-insensitive
+    m: regex.flags.includes("m"),
+    // `^` and `$` matches adjacent to newline characters
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  try {
+    new RegExp(pattern);
+  } catch {
+    console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+    return regex.source;
+  }
+  return pattern;
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/record.js
+function parseRecordDef(def, refs) {
+  if (refs.target === "openAi") {
+    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+  }
+  const keyTypeDef = def.keyType?.def || def.keyType?._def;
+  const keyTypeType = keyTypeDef?.type || keyTypeDef?.typeName;
+  if (refs.target === "openApi3" && (keyTypeType === "enum" || keyTypeType === "ZodEnum")) {
+    const enumValues = keyTypeDef?.entries ? Object.values(keyTypeDef.entries) : keyTypeDef?.values;
+    const valueTypeDef2 = def.valueType?.def || def.valueType?._def;
+    if (enumValues && Array.isArray(enumValues)) {
+      return {
+        type: "object",
+        required: enumValues,
+        properties: enumValues.reduce((acc, key) => ({
+          ...acc,
+          [key]: parseDef(valueTypeDef2, {
+            ...refs,
+            currentPath: [...refs.currentPath, "properties", key]
+          }) ?? parseAnyDef(refs)
+        }), {}),
+        additionalProperties: refs.rejectedAdditionalProperties
+      };
+    }
+  }
+  const actualValueType = def.valueType || def.keyType;
+  const valueTypeDef = actualValueType?.def || actualValueType?._def;
+  const schema = {
+    type: "object",
+    additionalProperties: valueTypeDef ? parseDef(valueTypeDef, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) : refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if ((keyTypeType === "string" || keyTypeType === "ZodString") && keyTypeDef?.checks?.length) {
+    const { type, ...keyType } = parseStringDef(keyTypeDef, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (keyTypeType === "enum" || keyTypeType === "ZodEnum") {
+    const enumValues = keyTypeDef?.entries ? Object.values(keyTypeDef.entries) : keyTypeDef?.values;
+    return {
+      ...schema,
+      propertyNames: {
+        enum: enumValues
+      }
+    };
+  } else if ((keyTypeType === "branded" || keyTypeType === "ZodBranded") && keyTypeDef?.type) {
+    const brandedTypeDef = keyTypeDef.type?.def || keyTypeDef.type?._def;
+    const brandedTypeType = brandedTypeDef?.type || brandedTypeDef?.typeName;
+    if ((brandedTypeType === "string" || brandedTypeType === "ZodString") && brandedTypeDef?.checks?.length) {
+      const { type, ...keyType } = parseBrandedDef(keyTypeDef, refs);
+      return {
+        ...schema,
+        propertyNames: keyType
+      };
+    }
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/map.js
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef(refs);
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef(refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef(def) {
+  const object = def.entries || def.values;
+  const actualKeys = Object.keys(object).filter((key) => {
+    return typeof object[object[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object[key]);
+  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+  return {
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef(refs) {
+  return refs.target === "openAi" ? void 0 : {
+    not: parseAnyDef({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/nullable.js
+function parseNullableDef(def, refs) {
+  const innerTypeDef = getInnerTypeDef(def);
+  const innerTypeKey = getDefTypeName(innerTypeDef);
+  if (innerTypeKey && getAllPrimitiveTypeNames().includes(innerTypeKey) && (!innerTypeDef.checks || !innerTypeDef.checks.length)) {
+    if (refs.target === "openApi3") {
+      return {
+        type: primitiveMappings[innerTypeKey],
+        nullable: true
+      };
+    }
+    return {
+      type: [
+        primitiveMappings[innerTypeKey],
+        "null"
+      ]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base2 = parseDef(innerTypeDef, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2) {
+      const result = { allOf: [base2], nullable: true };
+      const refPath = base2.$ref;
+      if (refPath && refPath.includes(refs.definitionPath)) {
+        const pathParts = refPath.split("/");
+        const defName = pathParts[pathParts.length - 1];
+        const definitionSchema = refs.definitions[defName];
+        if (definitionSchema) {
+          let description;
+          if (typeof definitionSchema.meta === "function") {
+            try {
+              const meta = definitionSchema.meta();
+              if (meta && meta.description) {
+                description = meta.description;
+              }
+            } catch (e) {
+            }
+          }
+          if (!description && definitionSchema.description) {
+            description = definitionSchema.description;
+          }
+          if (description) {
+            result.description = description;
+          }
+        }
+      }
+      return result;
+    }
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef(innerTypeDef, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    const checkDef = check._zod?.def;
+    if (checkDef) {
+      let message = checkDef.message;
+      if (!message && checkDef.error && typeof checkDef.error === "function") {
+        try {
+          message = checkDef.error();
+        } catch (e) {
+        }
+      }
+      switch (checkDef.check) {
+        case "number_format":
+          if (checkDef.format === "safeint") {
+            res.type = "integer";
+            addErrorMessage(res, "type", message, refs);
+          }
+          break;
+        case "greater_than":
+          if (refs.target === "jsonSchema7") {
+            if (checkDef.inclusive) {
+              setResponseValueAndErrors(res, "minimum", checkDef.value, message, refs);
+            } else {
+              setResponseValueAndErrors(res, "exclusiveMinimum", checkDef.value, message, refs);
+            }
+          } else {
+            if (!checkDef.inclusive) {
+              res.exclusiveMinimum = true;
+            }
+            setResponseValueAndErrors(res, "minimum", checkDef.value, message, refs);
+          }
+          break;
+        case "less_than":
+          if (refs.target === "jsonSchema7") {
+            if (checkDef.inclusive) {
+              setResponseValueAndErrors(res, "maximum", checkDef.value, message, refs);
+            } else {
+              setResponseValueAndErrors(res, "exclusiveMaximum", checkDef.value, message, refs);
+            }
+          } else {
+            if (!checkDef.inclusive) {
+              res.exclusiveMaximum = true;
+            }
+            setResponseValueAndErrors(res, "maximum", checkDef.value, message, refs);
+          }
+          break;
+        case "multiple_of":
+          setResponseValueAndErrors(res, "multipleOf", checkDef.value, message, refs);
+          break;
+      }
+    } else {
+      switch (check.kind) {
+        case "int":
+          res.type = "integer";
+          addErrorMessage(res, "type", check.message, refs);
+          break;
+        case "min":
+          if (refs.target === "jsonSchema7") {
+            if (check.inclusive) {
+              setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+            } else {
+              setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+            }
+          } else {
+            if (!check.inclusive) {
+              res.exclusiveMinimum = true;
+            }
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          }
+          break;
+        case "max":
+          if (refs.target === "jsonSchema7") {
+            if (check.inclusive) {
+              setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+            } else {
+              setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+            }
+          } else {
+            if (!check.inclusive) {
+              res.exclusiveMaximum = true;
+            }
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          }
+          break;
+        case "multipleOf":
+          setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+          break;
+      }
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape;
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    const propDefInner = propDef.def || propDef._def;
+    if (propDef === void 0 || propDefInner === void 0) {
+      continue;
+    }
+    let propOptional = safeIsOptional(propDef);
+    let parsedDef;
+    if (propOptional && forceOptionalIntoNullable) {
+      const typeName = propDefInner.typeName || propDefInner.type;
+      if (typeName === "ZodOptional" || typeName === "optional") {
+        const innerType = propDefInner.innerType;
+        if (innerType) {
+          const innerTypeDef = innerType.def || innerType._def;
+          innerTypeDef?.type || innerTypeDef?.typeName;
+          const innerParsed = parseDef(innerTypeDef, {
+            ...refs,
+            currentPath: [...refs.currentPath, "properties", propName],
+            propertyPath: [...refs.currentPath, "properties", propName]
+          });
+          if (innerParsed && typeof innerParsed === "object" && "type" in innerParsed) {
+            if (typeof innerParsed.type === "string") {
+              parsedDef = {
+                ...innerParsed,
+                type: [innerParsed.type, "null"]
+              };
+            } else {
+              parsedDef = innerParsed;
+            }
+          } else {
+            parsedDef = innerParsed;
+          }
+        }
+      }
+      propOptional = false;
+    } else {
+      parsedDef = parseDef(propDefInner, {
+        ...refs,
+        currentPath: [...refs.currentPath, "properties", propName],
+        propertyPath: [...refs.currentPath, "properties", propName]
+      });
+    }
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall) {
+    const catchallDef = def.catchall.def || def.catchall._def;
+    const catchallType = catchallDef?.type || catchallDef?.typeName;
+    if (catchallType === "never" || catchallType === "ZodNever") {
+      return refs.rejectedAdditionalProperties;
+    } else if (catchallType === "unknown" || catchallType === "ZodUnknown") {
+      return refs.allowedAdditionalProperties;
+    } else {
+      return parseDef(catchallDef, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalProperties"]
+      });
+    }
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+  return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+}
+function safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/optional.js
+var parseOptionalDef = (def, refs) => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? {
+    anyOf: [
+      {
+        not: parseAnyDef(refs)
+      },
+      innerSchema
+    ]
+  } : parseAnyDef(refs);
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/pipeline.js
+var parsePipelineDef = (def, refs) => {
+  const inDef = def.in?.def || def.in?._def;
+  const outDef = def.out?.def || def.out?._def;
+  const isTransformLike = inDef?.type === "transform" || outDef?.type === "transform";
+  if (isTransformLike) {
+    if (refs.effectStrategy === "input") {
+      return inDef?.type === "transform" ? parseDef(outDef, refs) : parseDef(inDef, refs);
+    } else {
+      return {};
+    }
+  }
+  if (refs.pipeStrategy === "input") {
+    return parseDef(inDef, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef(outDef, refs);
+  }
+  const a = parseDef(inDef, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef(outDef, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== void 0)
+  };
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef(def, refs) {
+  const innerType = def.innerType || def.type;
+  const innerDef = innerType?.def || innerType?._def;
+  return parseDef(innerDef, refs);
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/set.js
+function parseSetDef(def, refs) {
+  const valueTypeDef = def.valueType?.def || def.valueType?._def;
+  const items = parseDef(valueTypeDef, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      const checkDef = check._zod?.def;
+      if (checkDef) {
+        let message = checkDef.message;
+        if (!message && checkDef.error && typeof checkDef.error === "function") {
+          try {
+            message = checkDef.error();
+          } catch (e) {
+          }
+        }
+        switch (checkDef.check) {
+          case "min_size":
+            setResponseValueAndErrors(schema, "minItems", checkDef.minimum, message, refs);
+            break;
+          case "max_size":
+            setResponseValueAndErrors(schema, "maxItems", checkDef.maximum, message, refs);
+            break;
+        }
+      }
+    }
+  }
+  if (def.minSize) {
+    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  }
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/tuple.js
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+    };
+  }
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef(refs) {
+  return {
+    not: parseAnyDef(refs)
+  };
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/union.js
+var primitiveMappings2 = {
+  // Zod V3 type names
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null",
+  // Zod V4 type names
+  string: "string",
+  number: "number",
+  bigint: "integer",
+  boolean: "boolean",
+  null: "null"
+};
+var extractMetaInfoForSchema = (schema) => {
+  if (!schema || !schema._def)
+    return;
+  let metaInfo = {};
+  if (schema.description) {
+    metaInfo.description = schema.description;
+  }
+  if (typeof schema.meta === "function") {
+    try {
+      const meta = schema.meta();
+      if (meta && typeof meta === "object") {
+        metaInfo = { ...metaInfo, ...meta };
+      }
+    } catch (e) {
+    }
+  }
+  if (Object.keys(metaInfo).length > 0) {
+    setSchemaMetaInfo(schema._def, metaInfo);
+  }
+};
+function parseUnionDef(def, refs) {
+  if (refs.target === "openApi3")
+    return asAnyOf(def, refs);
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  options.forEach((option) => extractMetaInfoForSchema(option));
+  if (options.every((x) => {
+    const typeKey = getDefTypeName(x._def);
+    return typeKey && typeKey in primitiveMappings2 && (!x._def.checks || !x._def.checks.length);
+  })) {
+    const types = options.reduce((types2, x) => {
+      const typeKey = getDefTypeName(x._def);
+      const type = typeKey ? primitiveMappings2[typeKey] : void 0;
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => {
+    const typeKey = getDefTypeName(x._def);
+    const hasDescription = x.description || getSchemaMetaInfo(x._def)?.description;
+    return typeKey && (typeKey === "ZodLiteral" || typeKey === "literal") && !hasDescription;
+  })) {
+    const types = options.reduce((acc, x) => {
+      const value = x._def.values ? x._def.values[0] : x._def.value;
+      const type = typeof value;
+      switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...acc, type];
+        case "bigint":
+          return [...acc, "integer"];
+        case "object":
+          if (value === null)
+            return [...acc, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return acc;
+      }
+    }, []);
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce((acc, x) => {
+          const value = x._def.values ? x._def.values[0] : x._def.value;
+          return acc.includes(value) ? acc : [...acc, value];
+        }, [])
+      };
+    }
+  } else if (options.every((x) => {
+    const typeKey = getDefTypeName(x._def);
+    return typeKey === "ZodEnum" || typeKey === "enum";
+  })) {
+    return {
+      type: "string",
+      enum: options.reduce((acc, x) => {
+        const values = x._def.entries ? Object.values(x._def.entries) : x._def.values;
+        return [...acc, ...values.filter((x2) => !acc.includes(x2))];
+      }, [])
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", `${i}`]
+  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+  return anyOf.length ? { anyOf } : void 0;
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef(refs) {
+  return parseAnyDef(refs);
+}
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parsers/readonly.js
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/selectParser.js
+var selectParser = (def, typeName, refs) => {
+  const actualType = typeName || def.type;
+  switch (actualType) {
+    case "ZodString":
+    case "string":
+      return parseStringDef(def, refs);
+    case "ZodNumber":
+    case "number":
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef(def, refs);
+    case "ZodObject":
+    case "object":
+    case ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef(def, refs);
+    case "ZodBigInt":
+    case "bigint":
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case "ZodBoolean":
+    case "boolean":
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef();
+    case "ZodDate":
+    case "date":
+    case ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef(def, refs);
+    case "ZodUndefined":
+    case "undefined":
+    case ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef(refs);
+    case "ZodNull":
+    case "null":
+    case ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef(refs);
+    case "ZodArray":
+    case "array":
+    case ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef(def, refs);
+    case "ZodUnion":
+    case "union":
+    case "ZodDiscriminatedUnion":
+    case "discriminatedUnion":
+    case ZodFirstPartyTypeKind.ZodUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case "ZodIntersection":
+    case "intersection":
+    case ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case "ZodTuple":
+    case "tuple":
+    case ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef(def, refs);
+    case "ZodRecord":
+    case "record":
+    case ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef(def, refs);
+    case "ZodLiteral":
+    case "literal":
+    case ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case "ZodEnum":
+    case "enum":
+    case ZodFirstPartyTypeKind.ZodEnum:
+      if (def.entries) {
+        const keys = Object.keys(def.entries);
+        const values = Object.values(def.entries);
+        const isNativeEnum = !keys.every((k, i) => k === values[i]);
+        if (isNativeEnum) {
+          return parseNativeEnumDef(def);
+        }
+      }
+      return parseEnumDef(def);
+    case "ZodNativeEnum":
+    case "nativeEnum":
+    case ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case "ZodNullable":
+    case "nullable":
+    case ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef(def, refs);
+    case "ZodOptional":
+    case "optional":
+    case ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case "ZodMap":
+    case "map":
+    case ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef(def, refs);
+    case "ZodSet":
+    case "set":
+    case ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef(def, refs);
+    case "ZodLazy":
+    case "lazy":
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return () => def.getter()._def;
+    case "ZodPromise":
+    case "promise":
+    case ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case "ZodNaN":
+    case "nan":
+    case "ZodNever":
+    case "never":
+    case ZodFirstPartyTypeKind.ZodNaN:
+    case ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef(refs);
+    case "ZodEffects":
+    case "effects":
+    case ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case "ZodAny":
+    case "any":
+    case ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef(refs);
+    case "ZodUnknown":
+    case "unknown":
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef(refs);
+    case "ZodDefault":
+    case "default":
+    case ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case "ZodBranded":
+    case "branded":
+    case ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case "ZodReadonly":
+    case "readonly":
+    case ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case "ZodCatch":
+    case "catch":
+    case ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef(def, refs);
+    case "ZodPipeline":
+    case "pipeline":
+    case "pipe":
+    // Zod V4 uses "pipe" instead of "pipeline"
+    case ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case "ZodFunction":
+    case "function":
+    case "ZodVoid":
+    case "void":
+    case "ZodSymbol":
+    case "symbol":
+    case ZodFirstPartyTypeKind.ZodFunction:
+    case ZodFirstPartyTypeKind.ZodVoid:
+    case ZodFirstPartyTypeKind.ZodSymbol:
+      return void 0;
+    case "custom":
+      return parseAnyDef(refs);
+    default:
+      return void 0;
+  }
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/parseDef.js
+var schemaMetaMap = /* @__PURE__ */ new WeakMap();
+var setSchemaMetaInfo = (def, metaInfo) => {
+  schemaMetaMap.set(def, metaInfo);
+};
+var getSchemaMetaInfo = (def) => {
+  return schemaMetaMap.get(def);
+};
+function parseDef(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) {
+      getDefTypeName(def);
+      if (isNullableType(def) && refs.target === "openApi3" && "$ref" in seenSchema) {
+        const metaInfo = getSchemaMetaInfo(def);
+        const innerTypeDef = getInnerTypeDef(def);
+        const innerSeenItem = innerTypeDef ? refs.seen.get(innerTypeDef) : null;
+        const hasOwnDescription = metaInfo?.description;
+        const innerMetaInfo = innerTypeDef ? getSchemaMetaInfo(innerTypeDef) : null;
+        const hasInnerDescription = innerMetaInfo?.description;
+        let referencedDefinitionDescription;
+        if (innerSeenItem && innerSeenItem.path.includes(refs.definitionPath)) {
+          const defName = innerSeenItem.path[innerSeenItem.path.length - 1];
+          const definitionSchema = refs.definitions[defName];
+          if (definitionSchema) {
+            if (typeof definitionSchema.meta === "function") {
+              try {
+                const meta = definitionSchema.meta();
+                if (meta && meta.description) {
+                  referencedDefinitionDescription = meta.description;
+                }
+              } catch (e) {
+              }
+            }
+            if (!referencedDefinitionDescription && definitionSchema.description) {
+              referencedDefinitionDescription = definitionSchema.description;
+            }
+          }
+        }
+        if (hasOwnDescription || hasInnerDescription || referencedDefinitionDescription) {
+          let refToUse = seenSchema;
+          if (innerSeenItem && innerSeenItem.path.includes(refs.definitionPath)) {
+            refToUse = { $ref: innerSeenItem.path.join("/") };
+          }
+          const result = { allOf: [refToUse], nullable: true };
+          const currentPathStr = refs.currentPath.join("/");
+          if (hasOwnDescription && !currentPathStr.includes("group")) {
+            result.description = metaInfo.description;
+          } else if (hasInnerDescription && !hasOwnDescription) {
+            result.description = innerMetaInfo.description;
+          } else if (referencedDefinitionDescription && !hasOwnDescription) {
+            result.description = referencedDefinitionDescription;
+          }
+          return result;
+        }
+        return seenSchema;
+      }
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const typeName = getDefTypeName(def);
+  const jsonSchemaOrGetter = selectParser(def, typeName, refs);
+  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema) {
+    addMeta(def, refs, jsonSchema);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+    newItem.jsonSchema = jsonSchema;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema;
+  return jsonSchema;
+}
+var get$ref = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+        return parseAnyDef(refs);
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
+    }
+  }
+};
+var addMeta = (def, refs, jsonSchema) => {
+  if (def.description) {
+    jsonSchema.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema.markdownDescription = def.description;
+    }
+  }
+  const metaInfo = getSchemaMetaInfo(def);
+  if (metaInfo) {
+    if (metaInfo.description) {
+      jsonSchema.description = metaInfo.description;
+      if (refs.markdownDescription) {
+        jsonSchema.markdownDescription = metaInfo.description;
+      }
+    }
+    if (metaInfo.title) {
+      jsonSchema.title = metaInfo.title;
+    }
+    if (metaInfo.examples) {
+      jsonSchema.examples = metaInfo.examples;
+    }
+    for (const [key, value] of Object.entries(metaInfo)) {
+      if (key !== "description" && key !== "title" && key !== "examples") {
+        jsonSchema[key] = value;
+      }
+    }
+  }
+  return jsonSchema;
+};
+
+// ../../node_modules/.pnpm/@alcyone-labs+zod-to-json-schema@4.0.10_zod@4.1.12/node_modules/@alcyone-labs/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+var extractAndStoreMetaInfo = (schema) => {
+  if (!schema || !schema._def)
+    return;
+  const metaInfo = extractMetadata(schema);
+  if (Object.keys(metaInfo).length > 0) {
+    setSchemaMetaInfo(schema._def, metaInfo);
+  }
+  if (schema._def.innerType) {
+    extractAndStoreMetaInfo(schema._def.innerType);
+  }
+  if (schema._def.options && Array.isArray(schema._def.options)) {
+    schema._def.options.forEach((option) => extractAndStoreMetaInfo(option));
+  }
+  if (schema._def.left) {
+    extractAndStoreMetaInfo(schema._def.left);
+  }
+  if (schema._def.right) {
+    extractAndStoreMetaInfo(schema._def.right);
+  }
+  if (schema._def.schema) {
+    extractAndStoreMetaInfo(schema._def.schema);
+  }
+  if (schema._def.type) {
+    extractAndStoreMetaInfo(schema._def.type);
+  }
+  if (schema._def.shape && typeof schema._def.shape === "object") {
+    Object.values(schema._def.shape).forEach((propSchema) => {
+      extractAndStoreMetaInfo(propSchema);
+    });
+  }
+  if (schema._def.element) {
+    extractAndStoreMetaInfo(schema._def.element);
+  }
+  if (schema._def.shape && typeof schema._def.shape === "object") {
+    Object.values(schema._def.shape).forEach((propertySchema) => {
+      extractAndStoreMetaInfo(propertySchema);
+    });
+  }
+  if (schema._def.type && schema._def.type._def) {
+    extractAndStoreMetaInfo(schema._def.type);
+  }
+};
+var zodToJsonSchema = (schema, options) => {
+  const refs = getRefs(options);
+  extractAndStoreMetaInfo(schema);
+  if (typeof options === "object" && options.definitions) {
+    Object.values(options.definitions).forEach((defSchema) => {
+      extractAndStoreMetaInfo(defSchema);
+    });
+  }
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
+    ...acc,
+    [name2]: parseDef(schema2._def, {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name2]
+    }, true) ?? parseAnyDef(refs)
+  }), {}) : void 0;
+  const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+  const main = parseDef(schema._def, name === void 0 ? refs : {
+    ...refs,
+    currentPath: [...refs.basePath, refs.definitionPath, name]
+  }, false) ?? parseAnyDef(refs);
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
+  }
+  if (refs.flags.hasReferencedOpenAiAnyType) {
+    if (!definitions) {
+      definitions = {};
+    }
+    if (!definitions[refs.openAiAnyTypeName]) {
+      definitions[refs.openAiAnyTypeName] = {
+        // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+        type: ["string", "number", "integer", "boolean", "array", "null"],
+        items: {
+          $ref: refs.$refStrategy === "relative" ? "1" : [
+            ...refs.basePath,
+            refs.definitionPath,
+            refs.openAiAnyTypeName
+          ].join("/")
+        }
+      };
+    }
+  }
+  const combined = name === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name]: main
+    }
+  };
+  if (refs.target === "jsonSchema7") {
+    combined.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+  }
+  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+  }
+  return combined;
+};
+
+// ../core/src/execution/engine/base/serialization.ts
+function serializeDefinition(definition, options) {
+  const opts = {
+    redactSecrets: true,
+    includeToolSchemas: true,
+    includeKnowledgeMap: true,
+    ...options
+  };
+  const context = {
+    ...opts,
+    visited: /* @__PURE__ */ new WeakSet()
+  };
+  return deepSerialize(definition, context);
+}
+function deepSerialize(value, ctx) {
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  if (ctx.visited.has(value)) {
+    return { __circular: true };
+  }
+  ctx.visited.add(value);
+  if (isZodSchema(value)) return convertZodToJsonSchema(value);
+  if (value instanceof Map) return convertMapToArray(value, ctx);
+  if (value instanceof Set) return convertSetToArray(value, ctx);
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "function") return void 0;
+  if (Array.isArray(value)) {
+    return value.map((item) => deepSerialize(item, ctx)).filter((item) => item !== void 0);
+  }
+  if (isToolObject(value)) return serializeTool(value, ctx);
+  if (isKnowledgeMapObject(value)) return serializeKnowledgeMap(value, ctx);
+  if (isNextConfigObject(value)) return serializeNextConfig(value);
+  return serializeObject(value, ctx);
+}
+function serializeObject(obj, ctx) {
+  const result = {};
+  for (const [key, val] of Object.entries(obj)) {
+    if (typeof val === "function") continue;
+    if (ctx.redactSecrets && isSecretKey(key)) {
+      result[key] = redactSecret(val);
+      continue;
+    }
+    if (key === "steps" && isWorkflowStepsRecord(val)) {
+      result[key] = convertRecordToArray(val, ctx);
+      continue;
+    }
+    const serialized = deepSerialize(val, ctx);
+    if (serialized !== void 0) {
+      result[key] = serialized;
+    }
+  }
+  return result;
+}
+function serializeTool(tool, ctx) {
+  const result = {
+    name: tool.name,
+    description: tool.description
+  };
+  if (ctx.includeToolSchemas && tool.inputSchema) {
+    result.inputSchema = deepSerialize(tool.inputSchema, ctx);
+  }
+  if (ctx.includeToolSchemas && tool.outputSchema) {
+    result.outputSchema = deepSerialize(tool.outputSchema, ctx);
+  }
+  return result;
+}
+function serializeKnowledgeMap(km, ctx) {
+  if (!ctx.includeKnowledgeMap) return void 0;
+  const nodes = km.nodes || {};
+  const nodeEntries = Object.entries(nodes).map(([id, node]) => ({
+    id,
+    description: node.description,
+    loaded: node.loaded || false,
+    hasPrompt: Boolean(node.prompt)
+    // load function automatically omitted
+    // prompt content omitted (too large for structure metadata)
+  }));
+  return {
+    nodeCount: nodeEntries.length,
+    nodes: nodeEntries
+  };
+}
+function serializeNextConfig(nextConfig, _context) {
+  if (!nextConfig) return null;
+  if (nextConfig.type === "linear" /* LINEAR */) {
+    return {
+      type: nextConfig.type,
+      target: nextConfig.target
+    };
+  }
+  if (nextConfig.type === "conditional" /* CONDITIONAL */) {
+    return {
+      type: nextConfig.type,
+      routes: nextConfig.routes?.map((route) => ({
+        // Strip condition function, keep only target
+        target: route.target
+      })) ?? [],
+      default: nextConfig.default
+    };
+  }
+  return null;
+}
+function convertMapToArray(map, ctx) {
+  return Array.from(map.entries()).map(([key, val]) => ({
+    id: key,
+    ...deepSerialize(val, ctx)
+  }));
+}
+function isWorkflowStepsRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || value instanceof Map || value instanceof Set) {
+    return false;
+  }
+  const entries = Object.values(value);
+  if (entries.length === 0) return false;
+  const first = entries[0];
+  return first && typeof first === "object" && "name" in first && "handler" in first;
+}
+function convertRecordToArray(record, ctx) {
+  return Object.entries(record).map(([key, val]) => ({
+    id: key,
+    ...deepSerialize(val, ctx)
+  }));
+}
+function convertSetToArray(set, ctx) {
+  return Array.from(set).map((v) => deepSerialize(v, ctx));
+}
+function convertZodToJsonSchema(schema) {
+  return zodToJsonSchema(schema, {
+    $refStrategy: "none",
+    errorMessages: true
+  });
+}
+function isZodSchema(value) {
+  return value && typeof value === "object" && "_def" in value && "parse" in value;
+}
+function isToolObject(value) {
+  return value && typeof value === "object" && "name" in value && "description" in value && "execute" in value;
+}
+function isKnowledgeMapObject(value) {
+  return value && typeof value === "object" && "nodes" in value && typeof value.nodes === "object";
+}
+function isNextConfigObject(value) {
+  return value && typeof value === "object" && "type" in value && (value.type === "linear" /* LINEAR */ || value.type === "conditional" /* CONDITIONAL */);
+}
+function isSecretKey(key) {
+  const lower = key.toLowerCase();
+  const whitelist = ["maxtokens", "memorytokens", "inputtokens", "outputtokens"];
+  if (whitelist.some((w) => lower.includes(w))) return false;
+  const patterns = ["apikey", "secret", "password", "token", "credential"];
+  return patterns.some((p) => lower.includes(p));
+}
+function redactSecret(value) {
+  if (typeof value !== "string") return "[REDACTED]";
+  if (value.length <= 7) return "[REDACTED]";
+  return value.substring(0, 7) + "...";
+}
+
+// ../core/src/platform/registry/serialization.ts
+function serializeAllOrganizations(registry) {
+  const cache = /* @__PURE__ */ new Map();
+  for (const [orgName, resources] of Object.entries(registry)) {
+    cache.set(orgName, serializeOrganization(resources));
+  }
+  return cache;
+}
+function deriveDomainDefinitions(resources) {
+  const domainIds = /* @__PURE__ */ new Set();
+  resources.workflows?.forEach((w) => w.config.domains?.forEach((d) => domainIds.add(d)));
+  resources.agents?.forEach((a) => a.config.domains?.forEach((d) => domainIds.add(d)));
+  resources.triggers?.forEach((t) => t.domains?.forEach((d) => domainIds.add(d)));
+  resources.integrations?.forEach((i) => i.domains?.forEach((d) => domainIds.add(d)));
+  resources.externalResources?.forEach((e) => e.domains?.forEach((d) => domainIds.add(d)));
+  resources.humanCheckpoints?.forEach((h) => h.domains?.forEach((d) => domainIds.add(d)));
+  return Array.from(domainIds).map((id) => DOMAIN_MAP[id]);
+}
+function serializeOrganization(resources) {
+  const workflowDefinitions = /* @__PURE__ */ new Map();
+  const workflowResources = [];
+  const commandViewWorkflows = [];
+  for (const workflow of resources.workflows ?? []) {
+    const resourceId = workflow.config.resourceId;
+    const serialized = serializeDefinition(workflow);
+    workflowDefinitions.set(resourceId, serialized);
+    workflowResources.push({
+      resourceId,
+      name: workflow.config.name,
+      description: workflow.config.description,
+      version: workflow.config.version,
+      type: "workflow",
+      status: workflow.config.status
+    });
+    commandViewWorkflows.push({
+      resourceId,
+      name: workflow.config.name,
+      description: workflow.config.description,
+      version: workflow.config.version,
+      type: "workflow",
+      status: workflow.config.status,
+      domains: workflow.config.domains,
+      stepCount: Object.keys(workflow.steps).length,
+      entryPoint: workflow.entryPoint
+    });
+  }
+  const agentDefinitions = /* @__PURE__ */ new Map();
+  const agentResources = [];
+  const commandViewAgents = [];
+  for (const agent of resources.agents ?? []) {
+    const resourceId = agent.config.resourceId;
+    const serialized = serializeDefinition(agent);
+    agentDefinitions.set(resourceId, serialized);
+    agentResources.push({
+      resourceId,
+      name: agent.config.name,
+      description: agent.config.description,
+      version: agent.config.version,
+      type: "agent",
+      status: agent.config.status
+    });
+    commandViewAgents.push({
+      resourceId,
+      name: agent.config.name,
+      description: agent.config.description,
+      version: agent.config.version,
+      type: "agent",
+      status: agent.config.status,
+      domains: agent.config.domains,
+      modelProvider: agent.modelConfig.provider,
+      modelId: agent.modelConfig.model,
+      toolCount: agent.tools.length,
+      hasKnowledgeMap: agent.knowledgeMap !== void 0,
+      hasMemory: agent.config.memoryPreferences !== void 0,
+      sessionCapable: agent.config.sessionCapable ?? false
+    });
+  }
+  const edges = buildEdges(resources);
+  const triggers = resources.triggers ?? [];
+  const integrations = resources.integrations ?? [];
+  const externalResources = resources.externalResources ?? [];
+  const humanCheckpoints = resources.humanCheckpoints ?? [];
+  const domainDefinitions = deriveDomainDefinitions(resources);
+  return {
+    resources: {
+      workflows: workflowResources,
+      agents: agentResources,
+      total: workflowResources.length + agentResources.length
+    },
+    definitions: {
+      workflows: workflowDefinitions,
+      agents: agentDefinitions
+    },
+    commandView: {
+      workflows: commandViewWorkflows,
+      agents: commandViewAgents,
+      triggers,
+      integrations,
+      externalResources,
+      humanCheckpoints,
+      edges,
+      domainDefinitions
+    },
+    triggers,
+    integrations,
+    externalResources,
+    humanCheckpoints,
+    relationships: resources.relationships
+  };
+}
+function buildEdges(resources) {
+  const edges = [];
+  let edgeId = 0;
+  for (const [resourceId, declaration] of Object.entries(resources.relationships ?? {})) {
+    for (const agentId of declaration.triggers?.agents ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: resourceId,
+        target: agentId,
+        relationship: "triggers"
+      });
+    }
+    for (const workflowId of declaration.triggers?.workflows ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: resourceId,
+        target: workflowId,
+        relationship: "triggers"
+      });
+    }
+    for (const integrationId of declaration.uses?.integrations ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: resourceId,
+        target: integrationId,
+        relationship: "uses"
+      });
+    }
+  }
+  for (const external of resources.externalResources ?? []) {
+    for (const workflowId of external.triggers?.workflows ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: external.resourceId,
+        target: workflowId,
+        relationship: "triggers"
+      });
+    }
+    for (const agentId of external.triggers?.agents ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: external.resourceId,
+        target: agentId,
+        relationship: "triggers"
+      });
+    }
+    for (const integrationId of external.uses?.integrations ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: external.resourceId,
+        target: integrationId,
+        relationship: "uses"
+      });
+    }
+  }
+  for (const humanCheckpoint of resources.humanCheckpoints ?? []) {
+    for (const agentId of humanCheckpoint.requestedBy?.agents ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: agentId,
+        target: humanCheckpoint.resourceId,
+        relationship: "approval"
+      });
+    }
+    for (const workflowId of humanCheckpoint.requestedBy?.workflows ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: workflowId,
+        target: humanCheckpoint.resourceId,
+        relationship: "approval"
+      });
+    }
+    for (const agentId of humanCheckpoint.routesTo?.agents ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: humanCheckpoint.resourceId,
+        target: agentId,
+        relationship: "triggers"
+      });
+    }
+    for (const workflowId of humanCheckpoint.routesTo?.workflows ?? []) {
+      edges.push({
+        id: `edge-${edgeId++}`,
+        source: humanCheckpoint.resourceId,
+        target: workflowId,
+        relationship: "triggers"
+      });
+    }
+  }
+  return edges;
+}
+
+// ../core/src/platform/registry/resource-registry.ts
+var ResourceRegistry = class {
+  constructor(registry) {
+    this.registry = registry;
+    this.validateRegistry();
+    this.validateRelationships();
+    this.serializedCache = serializeAllOrganizations(registry);
+  }
+  /**
+   * Pre-serialized organization data cache
+   * Computed once at construction, never invalidated (static registry)
+   */
+  serializedCache;
+  /**
+   * Validates registry on construction
+   * - Checks for duplicate resourceIds within organizations
+   * - Validates model configurations against constraints
+   * - Validates ExecutionInterface matches inputSchema
+   * @throws Error if validation fails
+   */
+  validateRegistry() {
+    for (const [orgName, resources] of Object.entries(this.registry)) {
+      validateOrganizationResources(orgName, resources);
+    }
+  }
+  /**
+   * Validates relationship declarations reference valid resources
+   * Runs at API server startup - fails fast in development
+   * @throws Error if validation fails
+   */
+  validateRelationships() {
+    for (const [orgName, resources] of Object.entries(this.registry)) {
+      validateRelationships(orgName, resources);
+    }
+  }
+  /**
+   * Get a resource definition by ID
+   * Returns full definition (WorkflowDefinition or AgentDefinition)
+   * Check definition.config.type to determine if it's a workflow or agent
+   */
+  getResourceDefinition(organizationName, resourceId) {
+    const orgResources = this.registry[organizationName];
+    if (!orgResources) return null;
+    const workflow = orgResources.workflows?.find((w) => w.config.resourceId === resourceId);
+    if (workflow) return workflow;
+    const agent = orgResources.agents?.find((a) => a.config.resourceId === resourceId);
+    if (agent) return agent;
+    return null;
+  }
+  /**
+   * List all resources for an organization
+   * Returns ResourceDefinition metadata (not full definitions)
+   *
+   * Environment filtering (automatic):
+   * - Development: Returns all resources (dev + prod)
+   * - Production: Returns only prod resources (filters out dev)
+   */
+  listResourcesForOrganization(organizationName, environment) {
+    const orgResources = this.registry[organizationName];
+    if (!orgResources) {
+      return {
+        workflows: [],
+        agents: [],
+        total: 0,
+        organizationName,
+        environment
+      };
+    }
+    const currentEnv = detectEnvironment();
+    const workflows = (orgResources.workflows || []).map((def) => ({
+      resourceId: def.config.resourceId,
+      name: def.config.name,
+      description: def.config.description,
+      version: def.config.version,
+      type: def.config.type,
+      status: def.config.status
+    })).filter((resource) => {
+      if (environment) {
+        return resource.status === environment;
+      }
+      return canExecuteResource(resource, currentEnv);
+    });
+    const agents = (orgResources.agents || []).map((def) => ({
+      resourceId: def.config.resourceId,
+      name: def.config.name,
+      description: def.config.description,
+      version: def.config.version,
+      type: def.config.type,
+      status: def.config.status,
+      sessionCapable: def.config.sessionCapable ?? false
+    })).filter((resource) => {
+      if (environment) {
+        return resource.status === environment;
+      }
+      return canExecuteResource(resource, currentEnv);
+    });
+    return {
+      workflows,
+      agents,
+      total: workflows.length + agents.length,
+      organizationName,
+      environment: environment || (currentEnv === "production" ? "prod" : void 0)
+    };
+  }
+  /**
+   * List all resources from all organizations
+   * NOTE: For debugging only - returns raw registry data
+   */
+  listAllResources() {
+    return this.registry;
+  }
+  // ============================================================================
+  // Resource Manifest Accessors
+  // ============================================================================
+  /**
+   * Get triggers for an organization
+   * @param organizationName - Organization name
+   * @returns Array of trigger definitions (empty if none defined)
+   */
+  getTriggers(organizationName) {
+    return this.registry[organizationName]?.triggers ?? [];
+  }
+  /**
+   * Get integrations for an organization
+   * @param organizationName - Organization name
+   * @returns Array of integration definitions (empty if none defined)
+   */
+  getIntegrations(organizationName) {
+    return this.registry[organizationName]?.integrations ?? [];
+  }
+  /**
+   * Get resource relationships for an organization
+   * @param organizationName - Organization name
+   * @returns Resource relationships map (undefined if none defined)
+   */
+  getRelationships(organizationName) {
+    return this.registry[organizationName]?.relationships;
+  }
+  /**
+   * Get a specific trigger by ID
+   * @param organizationName - Organization name
+   * @param triggerId - Trigger ID
+   * @returns Trigger definition or null if not found
+   */
+  getTrigger(organizationName, triggerId) {
+    const triggers = this.getTriggers(organizationName);
+    return triggers.find((t) => t.resourceId === triggerId) ?? null;
+  }
+  /**
+   * Get a specific integration by ID
+   * @param organizationName - Organization name
+   * @param integrationId - Integration ID
+   * @returns Integration definition or null if not found
+   */
+  getIntegration(organizationName, integrationId) {
+    const integrations = this.getIntegrations(organizationName);
+    return integrations.find((i) => i.resourceId === integrationId) ?? null;
+  }
+  /**
+   * Get external resources for an organization
+   * @param organizationName - Organization name
+   * @returns Array of external resource definitions (empty if none defined)
+   */
+  getExternalResources(organizationName) {
+    return this.registry[organizationName]?.externalResources ?? [];
+  }
+  /**
+   * Get a specific external resource by ID
+   * @param organizationName - Organization name
+   * @param externalId - External resource ID
+   * @returns External resource definition or null if not found
+   */
+  getExternalResource(organizationName, externalId) {
+    const externalResources = this.getExternalResources(organizationName);
+    return externalResources.find((e) => e.resourceId === externalId) ?? null;
+  }
+  /**
+   * Get human checkpoints for an organization
+   * @param organizationName - Organization name
+   * @returns Array of human checkpoint definitions (empty if none defined)
+   */
+  getHumanCheckpoints(organizationName) {
+    return this.registry[organizationName]?.humanCheckpoints ?? [];
+  }
+  /**
+   * Get a specific human checkpoint by ID
+   * @param organizationName - Organization name
+   * @param humanCheckpointId - Human checkpoint ID
+   * @returns Human checkpoint definition or null if not found
+   */
+  getHumanCheckpoint(organizationName, humanCheckpointId) {
+    const humanCheckpoints = this.getHumanCheckpoints(organizationName);
+    return humanCheckpoints.find((hc) => hc.resourceId === humanCheckpointId) ?? null;
+  }
+  // ============================================================================
+  // Serialized Data Access (Pre-computed at Startup)
+  // ============================================================================
+  /**
+   * Get serialized resource definition (instant lookup)
+   * Use for API responses - returns pre-computed JSON-safe structure
+   *
+   * @param organizationName - Organization name
+   * @param resourceId - Resource ID
+   * @returns Serialized definition or null if not found
+   */
+  getSerializedDefinition(organizationName, resourceId) {
+    const cache = this.serializedCache.get(organizationName);
+    if (!cache) return null;
+    return cache.definitions.agents.get(resourceId) ?? cache.definitions.workflows.get(resourceId) ?? null;
+  }
+  /**
+   * Get resource list for organization (instant lookup)
+   * Use for /resources endpoint - returns pre-computed ResourceDefinition array
+   *
+   * @param organizationName - Organization name
+   * @returns Resource list with workflows, agents, and total count
+   */
+  getResourceList(organizationName) {
+    const cache = this.serializedCache.get(organizationName);
+    if (!cache) {
+      return { workflows: [], agents: [], total: 0 };
+    }
+    return cache.resources;
+  }
+  /**
+   * Get Command View data for organization (instant lookup)
+   * Use for /command-view endpoint - returns complete graph data
+   *
+   * @param organizationName - Organization name
+   * @returns Command View data with nodes and edges
+   */
+  getCommandViewData(organizationName) {
+    const cache = this.serializedCache.get(organizationName);
+    if (!cache) {
+      return {
+        workflows: [],
+        agents: [],
+        triggers: [],
+        integrations: [],
+        externalResources: [],
+        humanCheckpoints: [],
+        edges: []
+      };
+    }
+    return cache.commandView;
+  }
+  /**
+   * List resources that have UI interfaces configured
+   * Used by Execution Runner Catalog UI
+   *
+   * @param organizationName - Organization name
+   * @param environment - Optional environment filter ('dev' or 'prod')
+   * @returns Array of resources with interfaces
+   */
+  listExecutable(organizationName, environment) {
+    const cache = this.serializedCache.get(organizationName);
+    if (!cache) {
+      return [];
+    }
+    const results = [];
+    cache.definitions.workflows.forEach((serializedWorkflow, resourceId) => {
+      if (!serializedWorkflow.interface) return;
+      if (environment && serializedWorkflow.config.status !== environment) return;
+      results.push({
+        resourceId,
+        resourceName: serializedWorkflow.config.name,
+        resourceType: "workflow",
+        description: serializedWorkflow.config.description,
+        status: serializedWorkflow.config.status,
+        version: serializedWorkflow.config.version,
+        interface: serializedWorkflow.interface
+      });
+    });
+    cache.definitions.agents.forEach((serializedAgent, resourceId) => {
+      if (!serializedAgent.interface) return;
+      if (environment && serializedAgent.config.status !== environment) return;
+      results.push({
+        resourceId,
+        resourceName: serializedAgent.config.name,
+        resourceType: "agent",
+        description: serializedAgent.config.description,
+        status: serializedAgent.config.status,
+        version: serializedAgent.config.version,
+        interface: serializedAgent.interface
+      });
+    });
+    return results;
+  }
+};
+
+export { ExecutionError, RegistryValidationError, ResourceRegistry, StepType, ToolingError };