@mdxui/do 2.1.1

package/dist/agents-xcIn2dUB.d.ts

@@ -0,0 +1,832 @@
+import { ExecutionError, TokenUsage } from './schemas/index.js';
+
+/**
+ * Workflow Types - Business Process Orchestration
+ *
+ * Workflows orchestrate multi-step business processes using:
+ * - Event, schedule, manual, or webhook triggers
+ * - Function steps (Code, Generative, Agentic, Human)
+ * - Conditional branching and parallel execution
+ * - Saga pattern for compensation/rollback
+ *
+ * @remarks
+ * Workflows are implemented via the StateMachine DO using XState v5.
+ * Each execution maintains its own state with full audit trail.
+ */
+
+/**
+ * Workflow status
+ */
+type WorkflowStatus = 'draft' | 'active' | 'deprecated' | 'archived';
+/**
+ * Core workflow definition
+ */
+interface Workflow {
+    /** Unique workflow identifier */
+    id: string;
+    /** URL-friendly slug */
+    slug: string;
+    /** Workflow name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Namespace */
+    ns: string;
+    /** Version */
+    version: string;
+    /** Workflow status */
+    status: WorkflowStatus;
+    /** Trigger configuration */
+    trigger: WorkflowTrigger;
+    /** Workflow steps */
+    steps: WorkflowStep[];
+    /** Error handling configuration */
+    errorHandling: ErrorHandlingConfig;
+    /** Compensation steps (saga pattern) */
+    compensation?: CompensationConfig;
+    /** Workflow configuration */
+    config: WorkflowConfig;
+    /** Tags */
+    tags: string[];
+    /** Owner user ID */
+    owner: string;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last update timestamp */
+    updatedAt: Date;
+}
+/**
+ * Trigger types
+ */
+type TriggerType = 'event' | 'schedule' | 'manual' | 'webhook';
+/**
+ * Base trigger configuration
+ */
+interface TriggerBase {
+    /** Trigger type */
+    type: TriggerType;
+    /** Trigger name */
+    name: string;
+    /** Is this trigger enabled? */
+    enabled: boolean;
+}
+/**
+ * Event trigger - $.Subject.predicate pattern
+ */
+interface EventTrigger extends TriggerBase {
+    type: 'event';
+    /** Event pattern to match ($.Subject.predicate) */
+    pattern: string;
+    /** Additional filter conditions */
+    filter?: Record<string, unknown>;
+    /** Batch events */
+    batch?: {
+        maxSize: number;
+        maxWaitMs: number;
+    };
+}
+/**
+ * Schedule trigger - Cron or interval
+ */
+interface ScheduleTrigger extends TriggerBase {
+    type: 'schedule';
+    /** Cron expression */
+    cron?: string;
+    /** Interval in seconds */
+    intervalSeconds?: number;
+    /** Timezone */
+    timezone?: string;
+}
+/**
+ * Manual trigger - User-initiated
+ */
+interface ManualTrigger extends TriggerBase {
+    type: 'manual';
+    /** Input schema for manual trigger */
+    inputSchema?: Record<string, unknown>;
+    /** Require approval before execution */
+    requireApproval?: boolean;
+    /** Allowed users/roles */
+    allowedBy?: string[];
+}
+/**
+ * Webhook trigger - HTTP endpoint
+ */
+interface WebhookTrigger extends TriggerBase {
+    type: 'webhook';
+    /** Webhook path */
+    path: string;
+    /** HTTP methods allowed */
+    methods: ('GET' | 'POST' | 'PUT' | 'DELETE')[];
+    /** Authentication required */
+    authentication?: 'none' | 'api-key' | 'jwt' | 'hmac';
+    /** Secret for HMAC validation */
+    hmacSecret?: string;
+}
+/**
+ * Union of all trigger types
+ */
+type WorkflowTrigger = EventTrigger | ScheduleTrigger | ManualTrigger | WebhookTrigger;
+/**
+ * Step types
+ */
+type StepType = 'function' | 'workflow' | 'task' | 'wait' | 'parallel' | 'choice' | 'foreach' | 'http' | 'database' | 'ai' | 'event';
+/**
+ * Workflow step definition
+ */
+interface WorkflowStep {
+    /** Step ID (unique within workflow) */
+    id: string;
+    /** Step name */
+    name: string;
+    /** Step type */
+    type: StepType;
+    /** Step configuration */
+    config: StepConfig;
+    /** Dependencies (step IDs that must complete first) */
+    dependsOn?: string[];
+    /** Chain after (for RPC optimization) */
+    chainAfter?: string;
+    /** Condition (JSONLogic) for conditional execution */
+    condition?: Record<string, unknown>;
+    /** Retry configuration */
+    retry?: RetryConfig;
+    /** Timeout in ms */
+    timeout?: number;
+    /** Output mapping */
+    outputMapping?: Record<string, string>;
+}
+/**
+ * Step configuration by type
+ */
+interface StepConfig {
+    /** Function ID (for function steps) */
+    functionId?: string;
+    /** Workflow ID (for workflow steps) */
+    workflowId?: string;
+    /** Wait duration in ms (for wait steps) */
+    waitMs?: number;
+    /** Wait until date/time (for wait steps) */
+    waitUntil?: string;
+    /** Parallel branches (for parallel steps) */
+    branches?: WorkflowStep[][];
+    /** Choice conditions (for choice steps) */
+    choices?: ChoiceCondition[];
+    /** Default branch (for choice steps) */
+    default?: WorkflowStep[];
+    /** Iterator expression (for foreach steps) */
+    iterator?: string;
+    /** Loop body (for foreach steps) */
+    body?: WorkflowStep[];
+    /** HTTP request config (for http steps) */
+    http?: HttpStepConfig;
+    /** Database query config (for database steps) */
+    database?: DatabaseStepConfig;
+    /** AI config (for ai steps) */
+    ai?: AIStepConfig;
+    /** Event config (for event steps) */
+    event?: EventStepConfig;
+    /** Input mapping (template expressions) */
+    input?: Record<string, string>;
+}
+/**
+ * Choice condition for branching
+ */
+interface ChoiceCondition {
+    /** Condition (JSONLogic) */
+    condition: Record<string, unknown>;
+    /** Steps to execute if condition is true */
+    steps: WorkflowStep[];
+}
+/**
+ * HTTP step configuration
+ */
+interface HttpStepConfig {
+    /** URL (supports template expressions) */
+    url: string;
+    /** HTTP method */
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Headers */
+    headers?: Record<string, string>;
+    /** Request body */
+    body?: unknown;
+    /** Response handling */
+    responseType?: 'json' | 'text' | 'binary';
+}
+/**
+ * Database step configuration
+ */
+interface DatabaseStepConfig {
+    /** Operation type */
+    operation: 'query' | 'insert' | 'update' | 'delete';
+    /** Collection/table name */
+    collection: string;
+    /** Query filter */
+    filter?: Record<string, unknown>;
+    /** Data for insert/update */
+    data?: Record<string, unknown>;
+}
+/**
+ * AI step configuration
+ */
+interface AIStepConfig {
+    /** Prompt (supports template expressions) */
+    prompt: string;
+    /** Model */
+    model: string;
+    /** Output schema for structured output */
+    outputSchema?: Record<string, unknown>;
+    /** Temperature */
+    temperature?: number;
+    /** Max tokens */
+    maxTokens?: number;
+}
+/**
+ * Event step configuration (emit event)
+ */
+interface EventStepConfig {
+    /** Event type/pattern */
+    eventType: string;
+    /** Event payload (supports template expressions) */
+    payload: Record<string, unknown>;
+}
+/**
+ * Retry configuration
+ */
+interface RetryConfig {
+    /** Maximum retry attempts */
+    maxAttempts: number;
+    /** Backoff strategy */
+    backoff: 'exponential' | 'linear' | 'fixed';
+    /** Initial delay in ms */
+    initialDelayMs: number;
+    /** Maximum delay in ms */
+    maxDelayMs: number;
+    /** Retry on specific errors */
+    retryOn?: string[];
+}
+/**
+ * Error handling configuration
+ */
+interface ErrorHandlingConfig {
+    /** Global error strategy */
+    strategy: 'retry' | 'compensate' | 'ignore' | 'fail';
+    /** Retry config (if strategy is retry) */
+    retry?: RetryConfig;
+    /** Notification on error */
+    notify?: NotificationConfig;
+    /** Custom error handler function */
+    errorHandler?: string;
+}
+/**
+ * Compensation configuration (saga pattern)
+ */
+interface CompensationConfig {
+    /** Compensation steps (run in reverse order) */
+    steps: WorkflowStep[];
+    /** Strategy */
+    strategy: 'sequential' | 'parallel';
+    /** Continue on compensation failure? */
+    continueOnFailure: boolean;
+}
+/**
+ * Workflow configuration
+ */
+interface WorkflowConfig {
+    /** Global timeout in ms */
+    timeout: number;
+    /** Maximum concurrent executions */
+    maxConcurrency?: number;
+    /** Rate limiting */
+    rateLimit?: {
+        maxPerMinute: number;
+        strategy: 'sliding' | 'fixed';
+    };
+    /** Execution mode */
+    executionMode: 'async' | 'sync';
+    /** Store execution history */
+    storeHistory: boolean;
+    /** Retention period for history in days */
+    historyRetentionDays: number;
+}
+/**
+ * Notification configuration
+ */
+interface NotificationConfig {
+    /** Notification channels */
+    channels: ('email' | 'slack' | 'webhook')[];
+    /** Recipients */
+    recipients: string[];
+    /** Custom message template */
+    messageTemplate?: string;
+}
+/**
+ * Execution status
+ */
+type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'compensating' | 'compensated';
+/**
+ * Workflow execution record
+ */
+interface WorkflowExecution {
+    /** Execution ID */
+    id: string;
+    /** Workflow ID */
+    workflowId: string;
+    /** Workflow version at execution time */
+    workflowVersion: string;
+    /** Execution status */
+    status: ExecutionStatus;
+    /** Trigger data */
+    trigger: TriggerData;
+    /** Execution context */
+    context: ExecutionContext;
+    /** Step executions */
+    steps: StepExecution[];
+    /** Start time */
+    startedAt: Date;
+    /** End time */
+    completedAt?: Date;
+    /** Duration in ms */
+    durationMs?: number;
+    /** Error if failed */
+    error?: ExecutionError;
+    /** Namespace */
+    ns: string;
+}
+/**
+ * Trigger data (what triggered the execution)
+ */
+interface TriggerData {
+    /** Trigger type */
+    type: TriggerType;
+    /** Trigger payload */
+    data: Record<string, unknown>;
+    /** Trigger timestamp */
+    triggeredAt: Date;
+    /** Trigger source (user, event, schedule) */
+    source: string;
+}
+/**
+ * Execution context
+ */
+interface ExecutionContext {
+    /** Variables (workflow-scoped state) */
+    variables: Record<string, unknown>;
+    /** Step outputs (step_id -> output) */
+    stepOutputs: Record<string, unknown>;
+    /** Metadata */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Step execution record
+ */
+interface StepExecution {
+    /** Step ID */
+    stepId: string;
+    /** Step name */
+    stepName: string;
+    /** Execution status */
+    status: ExecutionStatus;
+    /** Input provided */
+    input: Record<string, unknown>;
+    /** Output produced */
+    output?: Record<string, unknown>;
+    /** Error if failed */
+    error?: ExecutionError;
+    /** Start time */
+    startedAt: Date;
+    /** End time */
+    completedAt?: Date;
+    /** Duration in ms */
+    durationMs?: number;
+    /** Retry count */
+    retryCount: number;
+}
+/**
+ * Workflow filter for queries
+ */
+interface WorkflowFilter {
+    /** Filter by status */
+    status?: WorkflowStatus[];
+    /** Filter by namespace */
+    ns?: string;
+    /** Filter by tags */
+    tags?: string[];
+    /** Filter by trigger type */
+    triggerType?: TriggerType[];
+    /** Search by name */
+    nameSearch?: string;
+    /** Filter by owner */
+    owner?: string;
+}
+/**
+ * Execution filter for queries
+ */
+interface ExecutionFilter {
+    /** Filter by workflow ID */
+    workflowId?: string;
+    /** Filter by status */
+    status?: ExecutionStatus[];
+    /** Filter by trigger type */
+    triggerType?: TriggerType[];
+    /** Filter by date range */
+    startedAfter?: Date;
+    startedBefore?: Date;
+    /** Filter by namespace */
+    ns?: string;
+}
+
+/**
+ * Agent Types - Autonomous AI Workers
+ *
+ * Agents are autonomous AI workers derived from:
+ * - O*NET occupations (1,459 occupations)
+ * - NAICS industries (68 industries)
+ * - Task × Tool × Operation combinations
+ *
+ * This creates 40,000+ potential agent types that can perform
+ * specialized work autonomously or semi-autonomously.
+ *
+ * @remarks
+ * Agent classifications:
+ * - Digital-first (22%): Remote-only operations
+ * - Hybrid (60%): Mix of digital and physical
+ * - Embodiment-required (18%): Physical work
+ */
+
+/**
+ * Agent definition
+ */
+interface Agent {
+    /** Unique agent identifier */
+    id: string;
+    /** Agent name */
+    name: string;
+    /** Agent slug (URL-friendly) */
+    slug: string;
+    /** Agent description */
+    description: string;
+    /** Namespace */
+    ns: string;
+    /** Agent type/role */
+    type: AgentType;
+    /** Classification */
+    classification: AgentClassification;
+    /** System prompt */
+    systemPrompt: string;
+    /** Character description (for persona) */
+    characterBible?: CharacterBible;
+    /** Available tools */
+    tools: string[];
+    /** AI model to use */
+    model: string;
+    /** Maximum iterations per execution */
+    maxIterations: number;
+    /** Thinking budget (for reasoning) */
+    thinkingBudget?: number;
+    /** Guardrails */
+    guardrails: AgentGuardrail[];
+    /** Handoff rules */
+    handoffRules: HandoffRule[];
+    /** Status */
+    status: AgentStatus;
+    /** Performance metrics */
+    metrics?: AgentMetrics;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last update timestamp */
+    updatedAt: Date;
+    /** Creator */
+    createdBy: string;
+}
+/**
+ * Agent type derived from O*NET + NAICS
+ */
+interface AgentType {
+    /** O*NET occupation code (e.g., "15-1252.00") */
+    onetCode?: string;
+    /** O*NET occupation title */
+    onetTitle?: string;
+    /** NAICS industry code */
+    naicsCode?: string;
+    /** NAICS industry title */
+    naicsTitle?: string;
+    /** Custom type name */
+    customType?: string;
+    /** Role category */
+    roleCategory: RoleCategory;
+}
+/**
+ * Role categories
+ */
+type RoleCategory = 'sdr' | 'csm' | 'engineer' | 'devops' | 'content' | 'design' | 'security' | 'compliance' | 'finance' | 'hr' | 'legal' | 'support' | 'analyst' | 'researcher' | 'manager' | 'executive' | 'specialist' | 'custom';
+/**
+ * Agent classification
+ */
+interface AgentClassification {
+    /** Work mode */
+    workMode: 'digital-first' | 'hybrid' | 'embodiment-required';
+    /** Role type */
+    roleType: 'leadership' | 'analytical' | 'creative' | 'customer-facing' | 'operational';
+    /** Autonomy level (0-1) */
+    autonomyLevel: number;
+    /** Automation score (from O*NET) */
+    automationScore?: number;
+    /** Job zone (1-5, complexity) */
+    jobZone?: number;
+    /** Required skills */
+    requiredSkills: string[];
+    /** Required knowledge */
+    requiredKnowledge: string[];
+}
+/**
+ * Character bible for agent persona
+ */
+interface CharacterBible {
+    /** Full name */
+    fullName: string;
+    /** Pronouns */
+    pronouns: string;
+    /** Age */
+    age?: number;
+    /** Background story */
+    background: string;
+    /** Personality traits */
+    traits: string[];
+    /** Communication style */
+    communicationStyle: string;
+    /** Expertise areas */
+    expertise: string[];
+    /** Limitations/boundaries */
+    limitations: string[];
+    /** Avatar/headshot URL */
+    avatarUrl?: string;
+    /** Voice characteristics (for audio) */
+    voiceCharacteristics?: string;
+}
+/**
+ * Agent guardrail
+ */
+interface AgentGuardrail {
+    /** Guardrail ID */
+    id: string;
+    /** Guardrail type */
+    type: 'input' | 'output' | 'action' | 'content' | 'safety';
+    /** Check to perform */
+    check: string;
+    /** Action on violation */
+    onViolation: 'block' | 'warn' | 'log' | 'escalate';
+    /** Custom validator function */
+    validator?: string;
+    /** Severity */
+    severity: 'low' | 'medium' | 'high' | 'critical';
+}
+/**
+ * Handoff rule for agent coordination
+ */
+interface HandoffRule {
+    /** Rule ID */
+    id: string;
+    /** Condition for handoff (natural language or JSONLogic) */
+    condition: string;
+    /** Target agent or workflow */
+    target: string;
+    /** Target type */
+    targetType: 'agent' | 'workflow' | 'human';
+    /** Context to pass */
+    context: string[];
+    /** Is this handoff required? */
+    required: boolean;
+    /** Priority */
+    priority: number;
+}
+/**
+ * Agent status
+ */
+type AgentStatus = 'draft' | 'active' | 'paused' | 'deprecated' | 'archived';
+/**
+ * Agent performance metrics
+ */
+interface AgentMetrics {
+    /** Total executions */
+    totalExecutions: number;
+    /** Successful executions */
+    successfulExecutions: number;
+    /** Failed executions */
+    failedExecutions: number;
+    /** Success rate (0-1) */
+    successRate: number;
+    /** Average duration in ms */
+    avgDurationMs: number;
+    /** Average iterations */
+    avgIterations: number;
+    /** Average token usage */
+    avgTokenUsage: number;
+    /** Average cost in USD */
+    avgCostUsd: number;
+    /** User satisfaction (0-5) */
+    userSatisfaction?: number;
+    /** Last execution time */
+    lastExecutedAt?: Date;
+    /** Period start */
+    periodStart: Date;
+    /** Period end */
+    periodEnd: Date;
+}
+/**
+ * Agent execution record
+ */
+interface AgentExecution {
+    /** Execution ID */
+    id: string;
+    /** Agent ID */
+    agentId: string;
+    /** Execution status */
+    status: AgentExecutionStatus;
+    /** Input/task provided */
+    input: AgentInput;
+    /** Output produced */
+    output?: AgentOutput;
+    /** Execution trace */
+    trace: AgentTrace[];
+    /** Handoffs that occurred */
+    handoffs: AgentHandoff[];
+    /** Guardrail violations */
+    violations: GuardrailViolation[];
+    /** Start time */
+    startedAt: Date;
+    /** End time */
+    completedAt?: Date;
+    /** Duration in ms */
+    durationMs?: number;
+    /** Total iterations */
+    iterations: number;
+    /** Token usage */
+    tokenUsage: TokenUsage;
+    /** Cost in USD */
+    costUsd: number;
+    /** User feedback */
+    feedback?: AgentFeedback;
+    /** Namespace */
+    ns: string;
+    /** Triggered by */
+    triggeredBy: string;
+}
+/**
+ * Execution status
+ */
+type AgentExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'handed-off' | 'awaiting-human';
+/**
+ * Agent input
+ */
+interface AgentInput {
+    /** Task description */
+    task: string;
+    /** Context information */
+    context?: Record<string, unknown>;
+    /** Constraints */
+    constraints?: string[];
+    /** Expected output format */
+    outputFormat?: string;
+}
+/**
+ * Agent output
+ */
+interface AgentOutput {
+    /** Result/response */
+    result: unknown;
+    /** Summary */
+    summary: string;
+    /** Confidence score (0-1) */
+    confidence?: number;
+    /** Artifacts produced */
+    artifacts?: AgentArtifact[];
+    /** Recommendations */
+    recommendations?: string[];
+}
+/**
+ * Agent artifact (file, code, etc.)
+ */
+interface AgentArtifact {
+    /** Artifact type */
+    type: 'file' | 'code' | 'image' | 'document' | 'data';
+    /** Artifact name */
+    name: string;
+    /** Content or URL */
+    content: string;
+    /** MIME type */
+    mimeType?: string;
+}
+/**
+ * Agent execution trace (step-by-step)
+ */
+interface AgentTrace {
+    /** Iteration number */
+    iteration: number;
+    /** Timestamp */
+    timestamp: Date;
+    /** Action type */
+    type: 'thought' | 'action' | 'observation' | 'decision';
+    /** Content */
+    content: string;
+    /** Tool used (if action) */
+    tool?: string;
+    /** Tool input (if action) */
+    toolInput?: Record<string, unknown>;
+    /** Tool output (if observation) */
+    toolOutput?: unknown;
+    /** Token usage for this step */
+    tokenUsage?: TokenUsage;
+}
+/**
+ * Agent handoff record
+ */
+interface AgentHandoff {
+    /** Handoff timestamp */
+    timestamp: Date;
+    /** Rule that triggered handoff */
+    ruleId: string;
+    /** Source agent */
+    fromAgent: string;
+    /** Target agent/workflow/human */
+    toTarget: string;
+    /** Target type */
+    targetType: 'agent' | 'workflow' | 'human';
+    /** Context passed */
+    context: Record<string, unknown>;
+    /** Handoff successful? */
+    successful: boolean;
+}
+/**
+ * Guardrail violation record
+ */
+interface GuardrailViolation {
+    /** Timestamp */
+    timestamp: Date;
+    /** Guardrail ID */
+    guardrailId: string;
+    /** Violation type */
+    type: string;
+    /** Details */
+    details: string;
+    /** Action taken */
+    actionTaken: 'blocked' | 'warned' | 'logged' | 'escalated';
+    /** Severity */
+    severity: 'low' | 'medium' | 'high' | 'critical';
+}
+/**
+ * User feedback on agent execution
+ */
+interface AgentFeedback {
+    /** Rating (1-5) */
+    rating: number;
+    /** Comment */
+    comment?: string;
+    /** Feedback categories */
+    categories?: ('accurate' | 'helpful' | 'fast' | 'clear' | 'wrong' | 'slow' | 'confusing')[];
+    /** Timestamp */
+    submittedAt: Date;
+    /** User who submitted */
+    submittedBy: string;
+}
+/**
+ * Agent filter for queries
+ */
+interface AgentFilter {
+    /** Filter by status */
+    status?: AgentStatus[];
+    /** Filter by role category */
+    roleCategory?: RoleCategory[];
+    /** Filter by work mode */
+    workMode?: ('digital-first' | 'hybrid' | 'embodiment-required')[];
+    /** Filter by namespace */
+    ns?: string;
+    /** Search by name */
+    nameSearch?: string;
+    /** Filter by tools */
+    tools?: string[];
+    /** Minimum autonomy level */
+    minAutonomyLevel?: number;
+}
+/**
+ * Execution filter for queries
+ */
+interface AgentExecutionFilter {
+    /** Filter by agent ID */
+    agentId?: string;
+    /** Filter by status */
+    status?: AgentExecutionStatus[];
+    /** Filter by date range */
+    startedAfter?: Date;
+    startedBefore?: Date;
+    /** Filter by namespace */
+    ns?: string;
+    /** Filter by triggered by */
+    triggeredBy?: string;
+    /** Has feedback */
+    hasFeedback?: boolean;
+    /** Minimum rating */
+    minRating?: number;
+}
+
+export type { AIStepConfig as A, AgentMetrics as B, ChoiceCondition as C, DatabaseStepConfig as D, EventTrigger as E, AgentExecution as F, AgentExecutionStatus as G, HttpStepConfig as H, AgentInput as I, AgentOutput as J, AgentArtifact as K, AgentTrace as L, ManualTrigger as M, NotificationConfig as N, AgentHandoff as O, GuardrailViolation as P, AgentFeedback as Q, RetryConfig as R, ScheduleTrigger as S, TriggerType as T, AgentFilter as U, AgentExecutionFilter as V, WorkflowStatus as W, Workflow as a, TriggerBase as b, WebhookTrigger as c, WorkflowTrigger as d, StepType as e, WorkflowStep as f, StepConfig as g, EventStepConfig as h, ErrorHandlingConfig as i, CompensationConfig as j, WorkflowConfig as k, ExecutionStatus as l, WorkflowExecution as m, TriggerData as n, ExecutionContext as o, StepExecution as p, WorkflowFilter as q, ExecutionFilter as r, Agent as s, AgentType as t, RoleCategory as u, AgentClassification as v, CharacterBible as w, AgentGuardrail as x, HandoffRule as y, AgentStatus as z };