/**
 * @fileoverview Canonical Agent type definitions for the Vorion Platform.
 *
 * This file provides the authoritative definitions for agent-related types,
 * unifying the various representations found across packages into a single
 * canonical source with Zod validation schemas.
 *
 * Agent types cover:
 * - Agent lifecycle status
 * - Runtime operational status
 * - Capabilities and permissions
 * - Configuration and settings
 * - Performance metrics
 * - Task management
 *
 * @module @vorionsys/contracts/canonical/agent
 */
import { z } from 'zod';
/**
 * Canonical agent lifecycle status.
 *
 * Represents the administrative/lifecycle state of an agent in the platform.
 * This is distinct from runtime operational status.
 *
 * States:
 * - `draft`: Initial creation, not yet deployed
 * - `training`: Undergoing training/certification
 * - `active`: Deployed and operational
 * - `suspended`: Temporarily disabled (can be reactivated)
 * - `archived`: Permanently deactivated (historical record)
 *
 * @example
 * ```typescript
 * const status: AgentLifecycleStatus = 'active';
 * ```
 */
export type AgentLifecycleStatus = 'draft' | 'training' | 'active' | 'suspended' | 'archived';
/**
 * Array of all lifecycle statuses in logical order.
 */
export declare const AGENT_LIFECYCLE_STATUSES: readonly AgentLifecycleStatus[];
/**
 * Human-readable labels for lifecycle statuses.
 */
export declare const AGENT_LIFECYCLE_LABELS: Readonly<Record<AgentLifecycleStatus, string>>;
/**
 * Color codes for lifecycle statuses (for UI display).
 */
export declare const AGENT_LIFECYCLE_COLORS: Readonly<Record<AgentLifecycleStatus, string>>;
/**
 * Zod schema for AgentLifecycleStatus validation.
 */
export declare const agentLifecycleStatusSchema: z.ZodEnum<["draft", "training", "active", "suspended", "archived"]>;
/**
 * Canonical agent runtime operational status.
 *
 * Represents the current operational state of an agent during execution.
 * Used for real-time monitoring and coordination.
 *
 * States:
 * - `IDLE`: Ready and waiting for tasks
 * - `WORKING`: Actively processing a task
 * - `PAUSED`: Temporarily halted (can resume)
 * - `ERROR`: In error state requiring attention
 * - `OFFLINE`: Not connected/available
 *
 * @example
 * ```typescript
 * const status: AgentRuntimeStatus = 'WORKING';
 * ```
 */
export type AgentRuntimeStatus = 'IDLE' | 'WORKING' | 'PAUSED' | 'ERROR' | 'OFFLINE';
/**
 * Array of all runtime statuses.
 */
export declare const AGENT_RUNTIME_STATUSES: readonly AgentRuntimeStatus[];
/**
 * Human-readable labels for runtime statuses.
 */
export declare const AGENT_RUNTIME_LABELS: Readonly<Record<AgentRuntimeStatus, string>>;
/**
 * Color codes for runtime statuses (for UI display).
 */
export declare const AGENT_RUNTIME_COLORS: Readonly<Record<AgentRuntimeStatus, string>>;
/**
 * Zod schema for AgentRuntimeStatus validation.
 */
export declare const agentRuntimeStatusSchema: z.ZodEnum<["IDLE", "WORKING", "PAUSED", "ERROR", "OFFLINE"]>;
/**
 * Canonical permission-based agent capability.
 *
 * Represents what actions an agent is authorized to perform.
 * Used for permission enforcement and delegation.
 *
 * Capabilities:
 * - `execute`: Can execute tasks locally
 * - `external`: Can make external API calls
 * - `delegate`: Can delegate tasks to other agents
 * - `spawn`: Can create/spawn new agents
 * - `admin`: Has administrative privileges
 *
 * @example
 * ```typescript
 * const caps: AgentPermission[] = ['execute', 'external'];
 * ```
 */
export type AgentPermission = 'execute' | 'external' | 'delegate' | 'spawn' | 'admin';
/**
 * Array of all agent permissions.
 */
export declare const AGENT_PERMISSIONS: readonly AgentPermission[];
/**
 * Descriptions for each permission.
 */
export declare const AGENT_PERMISSION_DESCRIPTIONS: Readonly<Record<AgentPermission, string>>;
/**
 * Zod schema for AgentPermission validation.
 */
export declare const agentPermissionSchema: z.ZodEnum<["execute", "external", "delegate", "spawn", "admin"]>;
/**
 * Collaboration mode types for agent interactions.
 */
export type CollaborationMode = 'DELEGATE' | 'CONSULT' | 'PARALLEL' | 'SEQUENTIAL' | 'CONSENSUS';
/**
 * Array of all collaboration modes.
 */
export declare const COLLABORATION_MODES: readonly CollaborationMode[];
/**
 * Zod schema for CollaborationMode validation.
 */
export declare const collaborationModeSchema: z.ZodEnum<["DELEGATE", "CONSULT", "PARALLEL", "SEQUENTIAL", "CONSENSUS"]>;
/**
 * Extended agent capability definition with domain and skills.
 *
 * Provides detailed capability information for agent matching and routing.
 */
export interface AgentCapability {
    /** Primary domain of expertise (e.g., 'security', 'data-analysis') */
    domain: string;
    /** Specific skills within the domain */
    skills: string[];
    /** Minimum trust score required to handle tasks in this domain (0-1000). This is a routing requirement, not a stored trust score on the agent identity. */
    trustLevel: number;
    /** Autonomy level (0-7, maps to TrustBand) */
    autonomyLevel: number;
    /** Preferred modes for collaboration */
    collaborationPreference: CollaborationMode[];
}
/**
 * Zod schema for AgentCapability validation.
 */
export declare const agentCapabilitySchema: z.ZodObject<{
    domain: z.ZodString;
    skills: z.ZodArray<z.ZodString, "many">;
    trustLevel: z.ZodNumber;
    autonomyLevel: z.ZodNumber;
    collaborationPreference: z.ZodArray<z.ZodEnum<["DELEGATE", "CONSULT", "PARALLEL", "SEQUENTIAL", "CONSENSUS"]>, "many">;
}, "strip", z.ZodTypeAny, {
    domain: string;
    skills: string[];
    trustLevel: number;
    autonomyLevel: number;
    collaborationPreference: ("DELEGATE" | "CONSULT" | "PARALLEL" | "SEQUENTIAL" | "CONSENSUS")[];
}, {
    domain: string;
    skills: string[];
    trustLevel: number;
    autonomyLevel: number;
    collaborationPreference: ("DELEGATE" | "CONSULT" | "PARALLEL" | "SEQUENTIAL" | "CONSENSUS")[];
}>;
/** Inferred type from schema */
export type AgentCapabilityInput = z.input<typeof agentCapabilitySchema>;
/**
 * Agent specialization categories.
 *
 * Predefined categories for agent domain expertise.
 */
export type AgentSpecialization = 'core' | 'customer_service' | 'technical' | 'creative' | 'research' | 'education' | 'security' | 'data_analysis' | 'development' | 'operations';
/**
 * Array of all specializations.
 */
export declare const AGENT_SPECIALIZATIONS: readonly AgentSpecialization[];
/**
 * Human-readable labels for specializations.
 */
export declare const AGENT_SPECIALIZATION_LABELS: Readonly<Record<AgentSpecialization, string>>;
/**
 * Zod schema for AgentSpecialization validation.
 */
export declare const agentSpecializationSchema: z.ZodEnum<["core", "customer_service", "technical", "creative", "research", "education", "security", "data_analysis", "development", "operations"]>;
/**
 * Runtime operational metrics for agent monitoring.
 *
 * Used for real-time health monitoring and load balancing.
 */
export interface AgentRuntimeMetrics {
    /** CPU usage percentage (0-100) */
    cpuUsage?: number;
    /** Memory usage percentage (0-100) */
    memoryUsage?: number;
    /** Number of tasks in queue */
    taskQueue?: number;
    /** Number of currently active tasks */
    activeTasks?: number;
    /** Uptime in milliseconds */
    uptime?: number;
    /** Custom metrics for domain-specific monitoring */
    customMetrics?: Record<string, number>;
}
/**
 * Zod schema for AgentRuntimeMetrics validation.
 */
export declare const agentRuntimeMetricsSchema: z.ZodObject<{
    cpuUsage: z.ZodOptional<z.ZodNumber>;
    memoryUsage: z.ZodOptional<z.ZodNumber>;
    taskQueue: z.ZodOptional<z.ZodNumber>;
    activeTasks: z.ZodOptional<z.ZodNumber>;
    uptime: z.ZodOptional<z.ZodNumber>;
    customMetrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    cpuUsage?: number | undefined;
    memoryUsage?: number | undefined;
    taskQueue?: number | undefined;
    activeTasks?: number | undefined;
    uptime?: number | undefined;
    customMetrics?: Record<string, number> | undefined;
}, {
    cpuUsage?: number | undefined;
    memoryUsage?: number | undefined;
    taskQueue?: number | undefined;
    activeTasks?: number | undefined;
    uptime?: number | undefined;
    customMetrics?: Record<string, number> | undefined;
}>;
/** Inferred type from schema */
export type AgentRuntimeMetricsInput = z.input<typeof agentRuntimeMetricsSchema>;
/**
 * Performance metrics for agent quality assessment.
 *
 * Used for trust scoring, performance reviews, and optimization.
 */
export interface AgentPerformanceMetrics {
    /** Total number of tasks completed */
    tasksCompleted: number;
    /** Total number of tasks that failed */
    tasksFailed: number;
    /** Average quality score (0-1) */
    averageQuality: number;
    /** Average response time in milliseconds */
    averageResponseTime: number;
    /** User satisfaction score (0-1) */
    userSatisfaction: number;
    /** Rate of escalations to higher authority (0-1) */
    escalationRate: number;
    /** Collaboration effectiveness score (0-1) */
    collaborationScore: number;
}
/**
 * Zod schema for AgentPerformanceMetrics validation.
 */
export declare const agentPerformanceMetricsSchema: z.ZodObject<{
    tasksCompleted: z.ZodNumber;
    tasksFailed: z.ZodNumber;
    averageQuality: z.ZodNumber;
    averageResponseTime: z.ZodNumber;
    userSatisfaction: z.ZodNumber;
    escalationRate: z.ZodNumber;
    collaborationScore: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    tasksCompleted: number;
    tasksFailed: number;
    averageQuality: number;
    averageResponseTime: number;
    userSatisfaction: number;
    escalationRate: number;
    collaborationScore: number;
}, {
    tasksCompleted: number;
    tasksFailed: number;
    averageQuality: number;
    averageResponseTime: number;
    userSatisfaction: number;
    escalationRate: number;
    collaborationScore: number;
}>;
/** Inferred type from schema */
export type AgentPerformanceMetricsInput = z.input<typeof agentPerformanceMetricsSchema>;
/**
 * Task priority levels.
 */
export type TaskPriority = 'low' | 'medium' | 'high' | 'critical';
/**
 * Array of all task priorities in ascending order.
 */
export declare const TASK_PRIORITIES: readonly TaskPriority[];
/**
 * Zod schema for TaskPriority validation.
 */
export declare const taskPrioritySchema: z.ZodEnum<["low", "medium", "high", "critical"]>;
/**
 * Task status values.
 */
export type TaskStatus = 'queued' | 'assigned' | 'active' | 'paused' | 'completed' | 'failed' | 'delegated' | 'cancelled';
/**
 * Array of all task statuses.
 */
export declare const TASK_STATUSES: readonly TaskStatus[];
/**
 * Zod schema for TaskStatus validation.
 */
export declare const taskStatusSchema: z.ZodEnum<["queued", "assigned", "active", "paused", "completed", "failed", "delegated", "cancelled"]>;
/**
 * Task source indicating where the task originated.
 */
export type TaskSource = 'system' | 'user' | 'agent' | 'collaboration' | 'proactive' | 'scheduled';
/**
 * Array of all task sources.
 */
export declare const TASK_SOURCES: readonly TaskSource[];
/**
 * Zod schema for TaskSource validation.
 */
export declare const taskSourceSchema: z.ZodEnum<["system", "user", "agent", "collaboration", "proactive", "scheduled"]>;
/**
 * Canonical agent task definition.
 *
 * Comprehensive task structure for agent workloads.
 */
export interface AgentTask {
    /** Unique task identifier */
    id: string;
    /** Agent ID this task is assigned to */
    agentId: string;
    /** Type/category of the task */
    taskType: string;
    /** Human-readable title */
    title?: string;
    /** Detailed description */
    description: string;
    /** Task context and parameters */
    context: Record<string, unknown>;
    /** Priority level */
    priority: TaskPriority;
    /** Current status */
    status: TaskStatus;
    /** Origin of the task */
    source: TaskSource;
    /** Reference ID for the source (e.g., user ID, agent ID) */
    sourceId?: string;
    /** ID of agent/entity that assigned the task */
    assignedBy?: string;
    /** ID of agent task was delegated to */
    delegatedTo?: string;
    /** Scheduled execution time */
    scheduledFor?: Date | string;
    /** Deadline for completion */
    deadline?: Date | string;
    /** When the task started processing */
    startedAt?: Date | string;
    /** When the task completed */
    completedAt?: Date | string;
    /** Task creation timestamp */
    createdAt: Date | string;
    /** Task input data */
    input?: Record<string, unknown>;
    /** Task output/result */
    output?: Record<string, unknown>;
    /** Error message if failed */
    error?: string;
    /** Additional metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Zod schema for AgentTask validation.
 */
export declare const agentTaskSchema: z.ZodObject<{
    id: z.ZodString;
    agentId: z.ZodString;
    taskType: z.ZodString;
    title: z.ZodOptional<z.ZodString>;
    description: z.ZodString;
    context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    priority: z.ZodEnum<["low", "medium", "high", "critical"]>;
    status: z.ZodEnum<["queued", "assigned", "active", "paused", "completed", "failed", "delegated", "cancelled"]>;
    source: z.ZodEnum<["system", "user", "agent", "collaboration", "proactive", "scheduled"]>;
    sourceId: z.ZodOptional<z.ZodString>;
    assignedBy: z.ZodOptional<z.ZodString>;
    delegatedTo: z.ZodOptional<z.ZodString>;
    scheduledFor: z.ZodOptional<z.ZodUnion<[z.ZodDate, z.ZodString]>>;
    deadline: z.ZodOptional<z.ZodUnion<[z.ZodDate, z.ZodString]>>;
    startedAt: z.ZodOptional<z.ZodUnion<[z.ZodDate, z.ZodString]>>;
    completedAt: z.ZodOptional<z.ZodUnion<[z.ZodDate, z.ZodString]>>;
    createdAt: z.ZodUnion<[z.ZodDate, z.ZodString]>;
    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    error: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    id: string;
    status: "active" | "completed" | "failed" | "queued" | "assigned" | "paused" | "delegated" | "cancelled";
    createdAt: string | Date;
    description: string;
    agentId: string;
    taskType: string;
    context: Record<string, unknown>;
    priority: "low" | "medium" | "high" | "critical";
    source: "agent" | "system" | "user" | "collaboration" | "proactive" | "scheduled";
    error?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    title?: string | undefined;
    sourceId?: string | undefined;
    assignedBy?: string | undefined;
    delegatedTo?: string | undefined;
    scheduledFor?: string | Date | undefined;
    deadline?: string | Date | undefined;
    startedAt?: string | Date | undefined;
    completedAt?: string | Date | undefined;
    input?: Record<string, unknown> | undefined;
    output?: Record<string, unknown> | undefined;
}, {
    id: string;
    status: "active" | "completed" | "failed" | "queued" | "assigned" | "paused" | "delegated" | "cancelled";
    createdAt: string | Date;
    description: string;
    agentId: string;
    taskType: string;
    context: Record<string, unknown>;
    priority: "low" | "medium" | "high" | "critical";
    source: "agent" | "system" | "user" | "collaboration" | "proactive" | "scheduled";
    error?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    title?: string | undefined;
    sourceId?: string | undefined;
    assignedBy?: string | undefined;
    delegatedTo?: string | undefined;
    scheduledFor?: string | Date | undefined;
    deadline?: string | Date | undefined;
    startedAt?: string | Date | undefined;
    completedAt?: string | Date | undefined;
    input?: Record<string, unknown> | undefined;
    output?: Record<string, unknown> | undefined;
}>;
/** Inferred type from schema */
export type AgentTaskInput = z.input<typeof agentTaskSchema>;
/**
 * Agent persona/personality configuration.
 */
export interface AgentPersona {
    /** Display name */
    displayName: string;
    /** Avatar URL */
    avatar?: string;
    /** Communication/voice style descriptor */
    voiceStyle?: string;
    /** Personality traits (e.g., 'professional', 'friendly') */
    traits: string[];
    /** Default greeting message */
    greeting?: string;
    /** Default farewell message */
    farewell?: string;
    /** Default error response */
    errorResponse?: string;
}
/**
 * Zod schema for AgentPersona validation.
 */
export declare const agentPersonaSchema: z.ZodObject<{
    displayName: z.ZodString;
    avatar: z.ZodOptional<z.ZodString>;
    voiceStyle: z.ZodOptional<z.ZodString>;
    traits: z.ZodArray<z.ZodString, "many">;
    greeting: z.ZodOptional<z.ZodString>;
    farewell: z.ZodOptional<z.ZodString>;
    errorResponse: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    displayName: string;
    traits: string[];
    avatar?: string | undefined;
    voiceStyle?: string | undefined;
    greeting?: string | undefined;
    farewell?: string | undefined;
    errorResponse?: string | undefined;
}, {
    displayName: string;
    traits: string[];
    avatar?: string | undefined;
    voiceStyle?: string | undefined;
    greeting?: string | undefined;
    farewell?: string | undefined;
    errorResponse?: string | undefined;
}>;
/** Inferred type from schema */
export type AgentPersonaInput = z.input<typeof agentPersonaSchema>;
/**
 * MCP (Model Context Protocol) server configuration.
 */
export interface MCPServerConfig {
    /** Server name/identifier */
    name: string;
    /** Server URL */
    url: string;
    /** Whether the server is enabled */
    enabled: boolean;
    /** Minimum trust score required to use this server */
    minTrustScore?: number;
    /** Server capabilities/features */
    capabilities?: string[];
    /** Additional configuration */
    config?: Record<string, unknown>;
}
/**
 * Zod schema for MCPServerConfig validation.
 */
export declare const mcpServerConfigSchema: z.ZodObject<{
    name: z.ZodString;
    url: z.ZodString;
    enabled: z.ZodBoolean;
    minTrustScore: z.ZodOptional<z.ZodNumber>;
    capabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    url: string;
    enabled: boolean;
    minTrustScore?: number | undefined;
    capabilities?: string[] | undefined;
    config?: Record<string, unknown> | undefined;
}, {
    name: string;
    url: string;
    enabled: boolean;
    minTrustScore?: number | undefined;
    capabilities?: string[] | undefined;
    config?: Record<string, unknown> | undefined;
}>;
/** Inferred type from schema */
export type MCPServerConfigInput = z.input<typeof mcpServerConfigSchema>;
/**
 * User role for permission context.
 */
export type UserRole = 'owner' | 'admin' | 'operator' | 'viewer' | 'both';
/**
 * Zod schema for UserRole validation.
 */
export declare const userRoleSchema: z.ZodEnum<["owner", "admin", "operator", "viewer", "both"]>;
/**
 * Comprehensive agent configuration for runtime.
 *
 * This is the main configuration structure used when initializing
 * an agent for execution.
 */
export interface AgentConfig {
    /** Unique agent identifier */
    agentId: string;
    /** Owner/user identifier */
    userId: string;
    /** User's role/permissions */
    userRole: UserRole;
    /** Agent lifecycle status */
    status: AgentLifecycleStatus;
    /** Current trust score (0-1000) */
    trustScore: number;
    /** Last activity timestamp */
    lastActivity?: Date | string;
    /** Agent name */
    name: string;
    /** Agent description */
    description?: string;
    /** Domain specialization */
    specialization?: AgentSpecialization | string;
    /** Personality traits */
    personalityTraits?: string[];
    /** Custom system prompt */
    systemPrompt?: string;
    /** Enabled capabilities/skills */
    capabilities: string[];
    /** Agent permissions */
    permissions?: AgentPermission[];
    /** AI model identifier */
    model?: string;
    /** Temperature for generation */
    temperature?: number;
    /** Maximum tokens for responses */
    maxTokens?: number;
    /** Configured MCP servers */
    mcpServers?: MCPServerConfig[];
    /** Environment variables */
    environment?: Record<string, string>;
    /** Current session identifier */
    sessionId?: string;
    /** Current conversation identifier */
    conversationId?: string;
    /** Message count in current session */
    messageCount?: number;
}
/**
 * Zod schema for AgentConfig validation.
 */
export declare const agentConfigSchema: z.ZodObject<{
    agentId: z.ZodString;
    userId: z.ZodString;
    userRole: z.ZodEnum<["owner", "admin", "operator", "viewer", "both"]>;
    status: z.ZodEnum<["draft", "training", "active", "suspended", "archived"]>;
    trustScore: z.ZodNumber;
    lastActivity: z.ZodOptional<z.ZodUnion<[z.ZodDate, z.ZodString]>>;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    specialization: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["core", "customer_service", "technical", "creative", "research", "education", "security", "data_analysis", "development", "operations"]>, z.ZodString]>>;
    personalityTraits: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    systemPrompt: z.ZodOptional<z.ZodString>;
    capabilities: z.ZodArray<z.ZodString, "many">;
    permissions: z.ZodOptional<z.ZodArray<z.ZodEnum<["execute", "external", "delegate", "spawn", "admin"]>, "many">>;
    model: z.ZodOptional<z.ZodString>;
    temperature: z.ZodOptional<z.ZodNumber>;
    maxTokens: z.ZodOptional<z.ZodNumber>;
    mcpServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        url: z.ZodString;
        enabled: z.ZodBoolean;
        minTrustScore: z.ZodOptional<z.ZodNumber>;
        capabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        url: string;
        enabled: boolean;
        minTrustScore?: number | undefined;
        capabilities?: string[] | undefined;
        config?: Record<string, unknown> | undefined;
    }, {
        name: string;
        url: string;
        enabled: boolean;
        minTrustScore?: number | undefined;
        capabilities?: string[] | undefined;
        config?: Record<string, unknown> | undefined;
    }>, "many">>;
    environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    sessionId: z.ZodOptional<z.ZodString>;
    conversationId: z.ZodOptional<z.ZodString>;
    messageCount: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    name: string;
    status: "active" | "draft" | "training" | "suspended" | "archived";
    agentId: string;
    capabilities: string[];
    userId: string;
    userRole: "operator" | "admin" | "owner" | "viewer" | "both";
    trustScore: number;
    description?: string | undefined;
    lastActivity?: string | Date | undefined;
    specialization?: string | undefined;
    personalityTraits?: string[] | undefined;
    systemPrompt?: string | undefined;
    permissions?: ("execute" | "external" | "delegate" | "spawn" | "admin")[] | undefined;
    model?: string | undefined;
    temperature?: number | undefined;
    maxTokens?: number | undefined;
    mcpServers?: {
        name: string;
        url: string;
        enabled: boolean;
        minTrustScore?: number | undefined;
        capabilities?: string[] | undefined;
        config?: Record<string, unknown> | undefined;
    }[] | undefined;
    environment?: Record<string, string> | undefined;
    sessionId?: string | undefined;
    conversationId?: string | undefined;
    messageCount?: number | undefined;
}, {
    name: string;
    status: "active" | "draft" | "training" | "suspended" | "archived";
    agentId: string;
    capabilities: string[];
    userId: string;
    userRole: "operator" | "admin" | "owner" | "viewer" | "both";
    trustScore: number;
    description?: string | undefined;
    lastActivity?: string | Date | undefined;
    specialization?: string | undefined;
    personalityTraits?: string[] | undefined;
    systemPrompt?: string | undefined;
    permissions?: ("execute" | "external" | "delegate" | "spawn" | "admin")[] | undefined;
    model?: string | undefined;
    temperature?: number | undefined;
    maxTokens?: number | undefined;
    mcpServers?: {
        name: string;
        url: string;
        enabled: boolean;
        minTrustScore?: number | undefined;
        capabilities?: string[] | undefined;
        config?: Record<string, unknown> | undefined;
    }[] | undefined;
    environment?: Record<string, string> | undefined;
    sessionId?: string | undefined;
    conversationId?: string | undefined;
    messageCount?: number | undefined;
}>;
/** Inferred type from schema */
export type AgentConfigInput = z.input<typeof agentConfigSchema>;
/**
 * Type guard for AgentLifecycleStatus.
 */
export declare function isAgentLifecycleStatus(value: unknown): value is AgentLifecycleStatus;
/**
 * Type guard for AgentRuntimeStatus.
 */
export declare function isAgentRuntimeStatus(value: unknown): value is AgentRuntimeStatus;
/**
 * Type guard for AgentPermission.
 */
export declare function isAgentPermission(value: unknown): value is AgentPermission;
/**
 * Type guard for AgentSpecialization.
 */
export declare function isAgentSpecialization(value: unknown): value is AgentSpecialization;
/**
 * Type guard for TaskPriority.
 */
export declare function isTaskPriority(value: unknown): value is TaskPriority;
/**
 * Type guard for TaskStatus.
 */
export declare function isTaskStatus(value: unknown): value is TaskStatus;
/**
 * Type guard for TaskSource.
 */
export declare function isTaskSource(value: unknown): value is TaskSource;
/**
 * Checks if an agent can transition to a new lifecycle status.
 *
 * Valid transitions:
 * - draft -> training, active
 * - training -> active, suspended, draft
 * - active -> suspended, archived
 * - suspended -> active, archived
 * - archived -> (no transitions allowed)
 *
 * @param current - Current lifecycle status
 * @param target - Target lifecycle status
 * @returns True if transition is valid
 */
export declare function canTransitionLifecycleStatus(current: AgentLifecycleStatus, target: AgentLifecycleStatus): boolean;
/**
 * Converts runtime status to lifecycle status where applicable.
 *
 * @param runtimeStatus - Agent runtime status
 * @returns Corresponding lifecycle status or null if no direct mapping
 */
export declare function runtimeToLifecycleStatus(runtimeStatus: AgentRuntimeStatus): AgentLifecycleStatus | null;
/**
 * Gets the numeric priority value for sorting.
 *
 * @param priority - Task priority
 * @returns Numeric value (0-3, higher = more urgent)
 */
export declare function getTaskPriorityValue(priority: TaskPriority): number;
/**
 * Compares two task priorities.
 *
 * @param a - First priority
 * @param b - Second priority
 * @returns -1 if a < b, 0 if equal, 1 if a > b
 */
export declare function compareTaskPriorities(a: TaskPriority, b: TaskPriority): -1 | 0 | 1;
/**
 * Maps legacy status strings to canonical AgentLifecycleStatus.
 *
 * @deprecated Use AgentLifecycleStatus directly. This is for migration only.
 */
export declare const LEGACY_STATUS_MAP: Readonly<Record<string, AgentLifecycleStatus>>;
/**
 * Converts a legacy status string to canonical AgentLifecycleStatus.
 *
 * @deprecated Use AgentLifecycleStatus directly. This is for migration only.
 * @param legacyStatus - Legacy status string
 * @returns Canonical status or 'draft' if not recognized
 */
export declare function legacyToLifecycleStatus(legacyStatus: string): AgentLifecycleStatus;
/**
 * Maps legacy AgentStatus from SDK (uppercase) to canonical types.
 *
 * @deprecated Use AgentRuntimeStatus directly. This is for migration only.
 */
export declare const LEGACY_RUNTIME_STATUS_MAP: Readonly<Record<string, AgentRuntimeStatus>>;
/**
 * Converts a legacy runtime status to canonical AgentRuntimeStatus.
 *
 * @deprecated Use AgentRuntimeStatus directly. This is for migration only.
 * @param legacyStatus - Legacy status string
 * @returns Canonical runtime status or 'OFFLINE' if not recognized
 */
export declare function legacyToRuntimeStatus(legacyStatus: string): AgentRuntimeStatus;