@mdxui/do 2.1.1

package/dist/chunk-GGO5GW72.js

@@ -0,0 +1,695 @@
+import { z } from 'zod';
+
+// src/types/schemas.ts
+var ThingFilterSchema = z.object({
+  /** Filter by namespace - single string or array of strings */
+  ns: z.union([z.string(), z.array(z.string())]).optional(),
+  /** Filter by type - single string or array of strings */
+  type: z.union([z.string(), z.array(z.string())]).optional(),
+  /** Filter by ID pattern (supports wildcards) */
+  idPattern: z.string().optional(),
+  /** Filter by name (case-insensitive search) */
+  nameSearch: z.string().optional(),
+  /** Filter by creation date range - start */
+  createdAfter: z.coerce.date().optional(),
+  /** Filter by creation date range - end */
+  createdBefore: z.coerce.date().optional(),
+  /** Filter by update date range - start */
+  updatedAfter: z.coerce.date().optional(),
+  /** Filter by update date range - end */
+  updatedBefore: z.coerce.date().optional(),
+  /** Include soft-deleted things */
+  includeDeleted: z.boolean().optional(),
+  /** Filter by specific property values in data */
+  properties: z.record(z.unknown()).optional(),
+  /** Filter by variant */
+  variant: z.string().optional()
+}).passthrough();
+var ThingSortSchema = z.object({
+  /** Field to sort by */
+  field: z.enum(["name", "createdAt", "updatedAt", "ts", "type"]),
+  /** Sort direction */
+  order: z.enum(["asc", "desc"])
+});
+var ThingPaginationSchema = z.object({
+  /** Page number (1-indexed, must be positive) */
+  page: z.number().int().positive(),
+  /** Items per page (must be positive, max 1000) */
+  perPage: z.number().int().positive().max(1e3)
+});
+var ThingDataSchema = z.object({
+  /** JSON-LD context */
+  "@context": z.union([z.string(), z.record(z.unknown())]).optional(),
+  /** JSON-LD type */
+  "@type": z.string().optional(),
+  /** JSON-LD identifier */
+  "@id": z.string().optional()
+}).passthrough();
+var ThingCreateInputSchema = z.object({
+  /** Namespace (required, non-empty string) */
+  ns: z.string().min(1, "Namespace is required"),
+  /** Type (required, non-empty string) */
+  type: z.string().min(1, "Type is required"),
+  /** ID (optional, auto-generated if not provided) */
+  id: z.string().optional(),
+  /** Display name (required, non-empty string) */
+  name: z.string().min(1, "Name is required"),
+  /** JSON-LD data */
+  data: ThingDataSchema,
+  /** Variant for A/B testing */
+  variant: z.string().optional()
+});
+var ThingUpdateInputSchema = z.object({
+  /** Updated name */
+  name: z.string().min(1, "Name cannot be empty").optional(),
+  /** Updated data (merged with existing) */
+  data: ThingDataSchema.partial().optional(),
+  /** Updated variant */
+  variant: z.string().optional()
+});
+var ThingDeleteOptionsSchema = z.object({
+  /** Hard delete (permanent) vs soft delete */
+  hard: z.boolean().optional()
+});
+var AgentStatusSchema = z.enum(["draft", "active", "paused", "deprecated", "archived"]);
+var RoleCategorySchema = z.enum([
+  "sdr",
+  "csm",
+  "engineer",
+  "devops",
+  "content",
+  "design",
+  "security",
+  "compliance",
+  "finance",
+  "hr",
+  "legal",
+  "support",
+  "analyst",
+  "researcher",
+  "manager",
+  "executive",
+  "specialist",
+  "custom"
+]);
+var WorkModeSchema = z.enum(["digital-first", "hybrid", "embodiment-required"]);
+var AgentFilterSchema = z.object({
+  /** Filter by status - array of status values */
+  status: z.array(AgentStatusSchema).optional(),
+  /** Filter by role category - array of role categories */
+  roleCategory: z.array(RoleCategorySchema).optional(),
+  /** Filter by work mode - array of work modes */
+  workMode: z.array(WorkModeSchema).optional(),
+  /** Filter by namespace */
+  ns: z.string().optional(),
+  /** Search by name */
+  nameSearch: z.string().optional(),
+  /** Filter by tools - array of tool names */
+  tools: z.array(z.string()).optional(),
+  /** Minimum autonomy level (0-1) */
+  minAutonomyLevel: z.number().min(0).max(1).optional()
+}).passthrough();
+var AgentExecutionStatusSchema = z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled",
+  "handed-off",
+  "awaiting-human"
+]);
+var AgentExecutionFilterSchema = z.object({
+  /** Filter by agent ID */
+  agentId: z.string().optional(),
+  /** Filter by status - array of status values */
+  status: z.array(AgentExecutionStatusSchema).optional(),
+  /** Filter by date range - start */
+  startedAfter: z.coerce.date().optional(),
+  /** Filter by date range - end */
+  startedBefore: z.coerce.date().optional(),
+  /** Filter by namespace */
+  ns: z.string().optional(),
+  /** Filter by triggered by */
+  triggeredBy: z.string().optional(),
+  /** Has feedback */
+  hasFeedback: z.boolean().optional(),
+  /** Minimum rating (1-5) */
+  minRating: z.number().int().min(1).max(5).optional()
+}).passthrough();
+var AgentExecuteInputSchema = z.object({
+  /** Task description (required) */
+  task: z.string().min(1, "Task description is required"),
+  /** Context information */
+  context: z.record(z.unknown()).optional()
+});
+var AgentFeedbackInputSchema = z.object({
+  /** Rating (1-5) */
+  rating: z.number().int().min(1).max(5),
+  /** Comment */
+  comment: z.string().optional(),
+  /** Feedback categories */
+  categories: z.array(z.enum(["accurate", "helpful", "fast", "clear", "wrong", "slow", "confusing"])).optional()
+});
+var WorkflowStatusSchema = z.enum(["draft", "active", "deprecated", "archived"]);
+var TriggerTypeSchema = z.enum(["event", "schedule", "manual", "webhook"]);
+var WorkflowFilterSchema = z.object({
+  /** Filter by status - array of status values */
+  status: z.array(WorkflowStatusSchema).optional(),
+  /** Filter by namespace */
+  ns: z.string().optional(),
+  /** Filter by tags - array of tag strings */
+  tags: z.array(z.string()).optional(),
+  /** Filter by trigger type - array of trigger types */
+  triggerType: z.array(TriggerTypeSchema).optional(),
+  /** Search by name */
+  nameSearch: z.string().optional(),
+  /** Filter by owner */
+  owner: z.string().optional()
+}).passthrough();
+var ExecutionStatusSchema = z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled",
+  "compensating",
+  "compensated"
+]);
+var ExecutionFilterSchema = z.object({
+  /** Filter by workflow ID */
+  workflowId: z.string().optional(),
+  /** Filter by status - array of status values */
+  status: z.array(ExecutionStatusSchema).optional(),
+  /** Filter by trigger type - array of trigger types */
+  triggerType: z.array(TriggerTypeSchema).optional(),
+  /** Filter by date range - start */
+  startedAfter: z.coerce.date().optional(),
+  /** Filter by date range - end */
+  startedBefore: z.coerce.date().optional(),
+  /** Filter by namespace */
+  ns: z.string().optional()
+}).passthrough();
+var WorkflowTriggerInputSchema = z.record(z.unknown()).optional();
+var EntityReferenceSchema = z.object({
+  /** Namespace */
+  ns: z.string().min(1, "Namespace is required"),
+  /** Type */
+  type: z.string().min(1, "Type is required"),
+  /** ID */
+  id: z.string().min(1, "ID is required"),
+  /** Semantic ID (ns/type/id) */
+  semanticId: z.string().optional(),
+  /** Display name (if loaded) */
+  name: z.string().optional()
+});
+var PartialEntityReferenceSchema = z.object({
+  /** Namespace */
+  ns: z.string().optional(),
+  /** Type */
+  type: z.string().optional(),
+  /** ID */
+  id: z.string().optional()
+}).passthrough();
+var SemanticPredicateCategorySchema = z.enum([
+  "temporal",
+  "spatial",
+  "directional",
+  "relational",
+  "causal",
+  "ownership",
+  "membership",
+  "dependency",
+  "custom"
+]);
+var RelationshipFilterSchema = z.object({
+  /** Filter by predicate type - array of predicates */
+  predicates: z.array(z.string()).optional(),
+  /** Filter by source entity */
+  from: PartialEntityReferenceSchema.optional(),
+  /** Filter by target entity */
+  to: PartialEntityReferenceSchema.optional(),
+  /** Filter by category - array of categories */
+  categories: z.array(SemanticPredicateCategorySchema).optional(),
+  /** Include deleted */
+  includeDeleted: z.boolean().optional(),
+  /** Filter by metadata */
+  metadata: z.record(z.unknown()).optional(),
+  /** Date range - start */
+  createdAfter: z.coerce.date().optional(),
+  /** Date range - end */
+  createdBefore: z.coerce.date().optional()
+}).passthrough();
+var RelationshipMetadataSchema = z.object({
+  /** Relationship strength/weight (0-1) */
+  weight: z.number().min(0).max(1).optional(),
+  /** Confidence score (0-1) */
+  confidence: z.number().min(0).max(1).optional(),
+  /** Source of the relationship */
+  source: z.enum(["manual", "inferred", "imported", "system"]).optional(),
+  /** Start date (for temporal relationships) */
+  startDate: z.coerce.date().optional(),
+  /** End date (for temporal relationships) */
+  endDate: z.coerce.date().optional()
+}).passthrough();
+var RelationshipCreateInputSchema = z.object({
+  /** Predicate type (required) */
+  relationshipType: z.string().min(1, "Relationship type is required"),
+  /** Source entity (required) */
+  from: EntityReferenceSchema,
+  /** Target entity (required) */
+  to: EntityReferenceSchema,
+  /** Metadata */
+  metadata: RelationshipMetadataSchema.optional()
+});
+var GraphPatternSchema = z.object({
+  /** Subject pattern */
+  subject: PartialEntityReferenceSchema.extend({ pattern: z.string().optional() }).optional(),
+  /** Predicate filter - single or array */
+  predicate: z.union([z.string(), z.array(z.string())]).optional(),
+  /** Object pattern */
+  object: PartialEntityReferenceSchema.extend({ pattern: z.string().optional() }).optional(),
+  /** Maximum depth for traversal */
+  depth: z.number().int().positive().max(10).optional(),
+  /** Direction of traversal */
+  direction: z.enum(["outgoing", "incoming", "both"]).optional()
+}).passthrough();
+var DateResponseSchema = z.union([
+  z.date(),
+  z.string().datetime().transform((str) => new Date(str)),
+  z.string().transform((str) => new Date(str))
+  // Fallback for non-standard date strings
+]);
+var OptionalDateResponseSchema = z.union([DateResponseSchema, z.null()]).optional();
+var ThingResponseSchema = z.object({
+  ns: z.string(),
+  type: z.string(),
+  id: z.string(),
+  ts: DateResponseSchema,
+  name: z.string(),
+  createdAt: DateResponseSchema,
+  updatedAt: DateResponseSchema,
+  createdBy: z.string().optional(),
+  updatedBy: z.string().optional(),
+  deletedAt: OptionalDateResponseSchema,
+  variant: z.string().optional(),
+  data: ThingDataSchema
+});
+var ThingQueryResultResponseSchema = z.object({
+  data: z.array(ThingResponseSchema),
+  total: z.number(),
+  page: z.number(),
+  perPage: z.number(),
+  totalPages: z.number()
+});
+var ThingVersionResponseSchema = z.object({
+  eventId: z.string(),
+  eventType: z.enum(["create", "update", "delete", "create_version", "update_version"]),
+  ts: DateResponseSchema,
+  userId: z.string(),
+  data: ThingDataSchema,
+  delta: ThingDataSchema.optional(),
+  metadata: z.record(z.unknown())
+});
+var TypeStatsResponseSchema = z.object({
+  type: z.string(),
+  ns: z.string(),
+  count: z.number(),
+  activeCount: z.number(),
+  createdToday: z.number(),
+  updatedToday: z.number(),
+  lastCreatedAt: DateResponseSchema.optional(),
+  lastUpdatedAt: DateResponseSchema.optional()
+});
+var AgentTypeResponseSchema = z.object({
+  onetCode: z.string().optional(),
+  onetTitle: z.string().optional(),
+  naicsCode: z.string().optional(),
+  naicsTitle: z.string().optional(),
+  customType: z.string().optional(),
+  roleCategory: RoleCategorySchema
+});
+var AgentClassificationResponseSchema = z.object({
+  workMode: WorkModeSchema,
+  roleType: z.enum(["leadership", "analytical", "creative", "customer-facing", "operational"]),
+  autonomyLevel: z.number(),
+  automationScore: z.number().optional(),
+  jobZone: z.number().optional(),
+  requiredSkills: z.array(z.string()),
+  requiredKnowledge: z.array(z.string())
+});
+var CharacterBibleResponseSchema = z.object({
+  fullName: z.string(),
+  pronouns: z.string(),
+  age: z.number().optional(),
+  background: z.string(),
+  traits: z.array(z.string()),
+  communicationStyle: z.string(),
+  expertise: z.array(z.string()),
+  limitations: z.array(z.string()),
+  avatarUrl: z.string().optional(),
+  voiceCharacteristics: z.string().optional()
+});
+var AgentGuardrailResponseSchema = z.object({
+  id: z.string(),
+  type: z.enum(["input", "output", "action", "content", "safety"]),
+  check: z.string(),
+  onViolation: z.enum(["block", "warn", "log", "escalate"]),
+  validator: z.string().optional(),
+  severity: z.enum(["low", "medium", "high", "critical"])
+});
+var HandoffRuleResponseSchema = z.object({
+  id: z.string(),
+  condition: z.string(),
+  target: z.string(),
+  targetType: z.enum(["agent", "workflow", "human"]),
+  context: z.array(z.string()),
+  required: z.boolean(),
+  priority: z.number()
+});
+var AgentMetricsResponseSchema = z.object({
+  totalExecutions: z.number(),
+  successfulExecutions: z.number(),
+  failedExecutions: z.number(),
+  successRate: z.number(),
+  avgDurationMs: z.number(),
+  avgIterations: z.number(),
+  avgTokenUsage: z.number(),
+  avgCostUsd: z.number(),
+  userSatisfaction: z.number().optional(),
+  lastExecutedAt: DateResponseSchema.optional(),
+  periodStart: DateResponseSchema,
+  periodEnd: DateResponseSchema
+});
+var AgentResponseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string(),
+  ns: z.string(),
+  type: AgentTypeResponseSchema,
+  classification: AgentClassificationResponseSchema,
+  systemPrompt: z.string(),
+  characterBible: CharacterBibleResponseSchema.optional(),
+  tools: z.array(z.string()),
+  model: z.string(),
+  maxIterations: z.number(),
+  thinkingBudget: z.number().optional(),
+  guardrails: z.array(AgentGuardrailResponseSchema),
+  handoffRules: z.array(HandoffRuleResponseSchema),
+  status: AgentStatusSchema,
+  metrics: AgentMetricsResponseSchema.optional(),
+  createdAt: DateResponseSchema,
+  updatedAt: DateResponseSchema,
+  createdBy: z.string()
+});
+var TokenUsageResponseSchema = z.object({
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  totalTokens: z.number(),
+  thinkingTokens: z.number().optional()
+});
+var AgentInputResponseSchema = z.object({
+  task: z.string(),
+  context: z.record(z.unknown()).optional(),
+  constraints: z.array(z.string()).optional(),
+  outputFormat: z.string().optional()
+});
+var AgentArtifactResponseSchema = z.object({
+  type: z.enum(["file", "code", "image", "document", "data"]),
+  name: z.string(),
+  content: z.string(),
+  mimeType: z.string().optional()
+});
+var AgentOutputResponseSchema = z.object({
+  result: z.unknown(),
+  summary: z.string(),
+  confidence: z.number().optional(),
+  artifacts: z.array(AgentArtifactResponseSchema).optional(),
+  recommendations: z.array(z.string()).optional()
+});
+var AgentTraceResponseSchema = z.object({
+  iteration: z.number(),
+  timestamp: DateResponseSchema,
+  type: z.enum(["thought", "action", "observation", "decision"]),
+  content: z.string(),
+  tool: z.string().optional(),
+  toolInput: z.record(z.unknown()).optional(),
+  toolOutput: z.unknown().optional(),
+  tokenUsage: TokenUsageResponseSchema.optional()
+});
+var AgentHandoffResponseSchema = z.object({
+  timestamp: DateResponseSchema,
+  ruleId: z.string(),
+  fromAgent: z.string(),
+  toTarget: z.string(),
+  targetType: z.enum(["agent", "workflow", "human"]),
+  context: z.record(z.unknown()),
+  successful: z.boolean()
+});
+var GuardrailViolationResponseSchema = z.object({
+  timestamp: DateResponseSchema,
+  guardrailId: z.string(),
+  type: z.string(),
+  details: z.string(),
+  actionTaken: z.enum(["blocked", "warned", "logged", "escalated"]),
+  severity: z.enum(["low", "medium", "high", "critical"])
+});
+var AgentFeedbackResponseSchema = z.object({
+  rating: z.number(),
+  comment: z.string().optional(),
+  categories: z.array(z.enum(["accurate", "helpful", "fast", "clear", "wrong", "slow", "confusing"])).optional(),
+  submittedAt: DateResponseSchema,
+  submittedBy: z.string()
+});
+var AgentExecutionResponseSchema = z.object({
+  id: z.string(),
+  agentId: z.string(),
+  status: AgentExecutionStatusSchema,
+  input: AgentInputResponseSchema,
+  output: AgentOutputResponseSchema.optional(),
+  trace: z.array(AgentTraceResponseSchema),
+  handoffs: z.array(AgentHandoffResponseSchema),
+  violations: z.array(GuardrailViolationResponseSchema),
+  startedAt: DateResponseSchema,
+  completedAt: DateResponseSchema.optional(),
+  durationMs: z.number().optional(),
+  iterations: z.number(),
+  tokenUsage: TokenUsageResponseSchema,
+  costUsd: z.number(),
+  feedback: AgentFeedbackResponseSchema.optional(),
+  ns: z.string(),
+  triggeredBy: z.string()
+});
+var RetryConfigResponseSchema = z.object({
+  maxAttempts: z.number(),
+  backoff: z.enum(["exponential", "linear", "fixed"]),
+  initialDelayMs: z.number(),
+  maxDelayMs: z.number(),
+  retryOn: z.array(z.string()).optional()
+});
+var StepConfigResponseSchema = z.record(z.unknown());
+var WorkflowStepResponseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.enum(["function", "workflow", "task", "wait", "parallel", "choice", "foreach", "http", "database", "ai", "event"]),
+  config: StepConfigResponseSchema,
+  dependsOn: z.array(z.string()).optional(),
+  chainAfter: z.string().optional(),
+  condition: z.record(z.unknown()).optional(),
+  retry: RetryConfigResponseSchema.optional(),
+  timeout: z.number().optional(),
+  outputMapping: z.record(z.string()).optional()
+});
+var TriggerBaseResponseSchema = z.object({
+  type: TriggerTypeSchema,
+  name: z.string(),
+  enabled: z.boolean()
+});
+var WorkflowTriggerResponseSchema = z.discriminatedUnion("type", [
+  TriggerBaseResponseSchema.extend({
+    type: z.literal("event"),
+    pattern: z.string(),
+    filter: z.record(z.unknown()).optional(),
+    batch: z.object({
+      maxSize: z.number(),
+      maxWaitMs: z.number()
+    }).optional()
+  }),
+  TriggerBaseResponseSchema.extend({
+    type: z.literal("schedule"),
+    cron: z.string().optional(),
+    intervalSeconds: z.number().optional(),
+    timezone: z.string().optional()
+  }),
+  TriggerBaseResponseSchema.extend({
+    type: z.literal("manual"),
+    inputSchema: z.record(z.unknown()).optional(),
+    requireApproval: z.boolean().optional(),
+    allowedBy: z.array(z.string()).optional()
+  }),
+  TriggerBaseResponseSchema.extend({
+    type: z.literal("webhook"),
+    path: z.string(),
+    methods: z.array(z.enum(["GET", "POST", "PUT", "DELETE"])),
+    authentication: z.enum(["none", "api-key", "jwt", "hmac"]).optional(),
+    hmacSecret: z.string().optional()
+  })
+]);
+var ErrorHandlingConfigResponseSchema = z.object({
+  strategy: z.enum(["retry", "compensate", "ignore", "fail"]),
+  retry: RetryConfigResponseSchema.optional(),
+  notify: z.object({
+    channels: z.array(z.enum(["email", "slack", "webhook"])),
+    recipients: z.array(z.string()),
+    messageTemplate: z.string().optional()
+  }).optional(),
+  errorHandler: z.string().optional()
+});
+var CompensationConfigResponseSchema = z.object({
+  steps: z.array(WorkflowStepResponseSchema),
+  strategy: z.enum(["sequential", "parallel"]),
+  continueOnFailure: z.boolean()
+});
+var WorkflowConfigResponseSchema = z.object({
+  timeout: z.number(),
+  maxConcurrency: z.number().optional(),
+  rateLimit: z.object({
+    maxPerMinute: z.number(),
+    strategy: z.enum(["sliding", "fixed"])
+  }).optional(),
+  executionMode: z.enum(["async", "sync"]),
+  storeHistory: z.boolean(),
+  historyRetentionDays: z.number()
+});
+var WorkflowResponseSchema = z.object({
+  id: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string(),
+  ns: z.string(),
+  version: z.string(),
+  status: WorkflowStatusSchema,
+  trigger: WorkflowTriggerResponseSchema,
+  steps: z.array(WorkflowStepResponseSchema),
+  errorHandling: ErrorHandlingConfigResponseSchema,
+  compensation: CompensationConfigResponseSchema.optional(),
+  config: WorkflowConfigResponseSchema,
+  tags: z.array(z.string()),
+  owner: z.string(),
+  createdAt: DateResponseSchema,
+  updatedAt: DateResponseSchema
+});
+var TriggerDataResponseSchema = z.object({
+  type: TriggerTypeSchema,
+  data: z.record(z.unknown()),
+  triggeredAt: DateResponseSchema,
+  source: z.string()
+});
+var ExecutionContextResponseSchema = z.object({
+  variables: z.record(z.unknown()),
+  stepOutputs: z.record(z.unknown()),
+  metadata: z.record(z.unknown())
+});
+var ExecutionErrorResponseSchema = z.object({
+  code: z.string(),
+  message: z.string(),
+  stack: z.string().optional(),
+  failedStep: z.string().optional()
+});
+var StepExecutionResponseSchema = z.object({
+  stepId: z.string(),
+  stepName: z.string(),
+  status: ExecutionStatusSchema,
+  input: z.record(z.unknown()),
+  output: z.record(z.unknown()).optional(),
+  error: ExecutionErrorResponseSchema.optional(),
+  startedAt: DateResponseSchema,
+  completedAt: DateResponseSchema.optional(),
+  durationMs: z.number().optional(),
+  retryCount: z.number()
+});
+var WorkflowExecutionResponseSchema = z.object({
+  id: z.string(),
+  workflowId: z.string(),
+  workflowVersion: z.string(),
+  status: ExecutionStatusSchema,
+  trigger: TriggerDataResponseSchema,
+  context: ExecutionContextResponseSchema,
+  steps: z.array(StepExecutionResponseSchema),
+  startedAt: DateResponseSchema,
+  completedAt: DateResponseSchema.optional(),
+  durationMs: z.number().optional(),
+  error: ExecutionErrorResponseSchema.optional(),
+  ns: z.string()
+});
+var RelationshipMetadataResponseSchema = z.object({
+  weight: z.number().optional(),
+  confidence: z.number().optional(),
+  source: z.enum(["manual", "inferred", "imported", "system"]).optional(),
+  startDate: DateResponseSchema.optional(),
+  endDate: DateResponseSchema.optional()
+}).catchall(z.unknown());
+var RelationshipResponseSchema = z.object({
+  relationshipId: z.string(),
+  relationshipType: z.string(),
+  fromNs: z.string(),
+  fromType: z.string(),
+  fromId: z.string(),
+  toNs: z.string(),
+  toType: z.string(),
+  toId: z.string(),
+  createdAt: DateResponseSchema,
+  createdBy: z.string(),
+  deletedAt: OptionalDateResponseSchema,
+  deletedBy: z.string().optional(),
+  metadata: RelationshipMetadataResponseSchema
+});
+var EntityReferenceResponseSchema = z.object({
+  ns: z.string(),
+  type: z.string(),
+  id: z.string(),
+  semanticId: z.string(),
+  name: z.string().optional()
+});
+var GraphPathResponseSchema = z.object({
+  start: EntityReferenceResponseSchema,
+  end: EntityReferenceResponseSchema,
+  edges: z.array(RelationshipResponseSchema),
+  totalWeight: z.number(),
+  length: z.number()
+});
+var GraphTraversalResultResponseSchema = z.object({
+  root: EntityReferenceResponseSchema,
+  nodes: z.array(EntityReferenceResponseSchema),
+  edges: z.array(RelationshipResponseSchema),
+  depth: z.number(),
+  paths: z.array(GraphPathResponseSchema)
+});
+var GraphStatsResponseSchema = z.object({
+  totalRelationships: z.number(),
+  activeRelationships: z.number(),
+  byPredicate: z.record(z.number()),
+  byCategory: z.record(z.number()),
+  averageDegree: z.number(),
+  topConnectedNodes: z.array(z.object({
+    entity: EntityReferenceResponseSchema,
+    degree: z.number()
+  }))
+});
+var EntityRelationshipsResultResponseSchema = z.object({
+  outgoing: z.array(RelationshipResponseSchema),
+  incoming: z.array(RelationshipResponseSchema)
+});
+var PaginatedResultResponseSchema = (dataSchema) => z.object({
+  data: z.array(dataSchema),
+  total: z.number(),
+  page: z.number(),
+  perPage: z.number(),
+  totalPages: z.number(),
+  hasMore: z.boolean().optional(),
+  cursor: z.string().optional()
+});
+
+export { AgentArtifactResponseSchema, AgentClassificationResponseSchema, AgentExecuteInputSchema, AgentExecutionFilterSchema, AgentExecutionResponseSchema, AgentFeedbackInputSchema, AgentFeedbackResponseSchema, AgentFilterSchema, AgentGuardrailResponseSchema, AgentHandoffResponseSchema, AgentInputResponseSchema, AgentMetricsResponseSchema, AgentOutputResponseSchema, AgentResponseSchema, AgentTraceResponseSchema, AgentTypeResponseSchema, CharacterBibleResponseSchema, CompensationConfigResponseSchema, DateResponseSchema, EntityReferenceResponseSchema, EntityReferenceSchema, EntityRelationshipsResultResponseSchema, ErrorHandlingConfigResponseSchema, ExecutionContextResponseSchema, ExecutionErrorResponseSchema, ExecutionFilterSchema, GraphPathResponseSchema, GraphPatternSchema, GraphStatsResponseSchema, GraphTraversalResultResponseSchema, GuardrailViolationResponseSchema, HandoffRuleResponseSchema, OptionalDateResponseSchema, PaginatedResultResponseSchema, PartialEntityReferenceSchema, RelationshipCreateInputSchema, RelationshipFilterSchema, RelationshipMetadataResponseSchema, RelationshipMetadataSchema, RelationshipResponseSchema, RetryConfigResponseSchema, StepConfigResponseSchema, StepExecutionResponseSchema, ThingCreateInputSchema, ThingDataSchema, ThingDeleteOptionsSchema, ThingFilterSchema, ThingPaginationSchema, ThingQueryResultResponseSchema, ThingResponseSchema, ThingSortSchema, ThingUpdateInputSchema, ThingVersionResponseSchema, TokenUsageResponseSchema, TriggerDataResponseSchema, TypeStatsResponseSchema, WorkflowConfigResponseSchema, WorkflowExecutionResponseSchema, WorkflowFilterSchema, WorkflowResponseSchema, WorkflowStepResponseSchema, WorkflowTriggerInputSchema, WorkflowTriggerResponseSchema };
+//# sourceMappingURL=chunk-GGO5GW72.js.map
+//# sourceMappingURL=chunk-GGO5GW72.js.map