@dcyfr/ai 1.0.4 → 2.1.0

package/dist/ai/src/runtime/agent-runtime.js

@@ -0,0 +1,1084 @@
+/**
+ * DCYFR Agent Runtime with Delegation Support
+ * TLP:AMBER - Internal Use Only
+ *
+ * Agent runtime engine supporting delegation contract execution, capability
+ * self-assessment, and confidence tracking. Integrates with DCYFR delegation
+ * framework for intelligent task assignment and verification.
+ *
+ * @module runtime/agent-runtime
+ * @version 1.0.0
+ * @date 2026-02-13
+ */
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import { RuntimeTelemetryIntegration, createDefaultTelemetryIntegration, } from '../telemetry/index.js';
+import { VerificationIntegration, } from '../verification/parser-integration.js';
+/**
+ * DCYFR Agent Runtime
+ *
+ * Core runtime for AI agents with delegation support, capability tracking,
+ * and intelligent task execution.
+ */
+export class AgentRuntime extends EventEmitter {
+    config;
+    currentTasks = new Map();
+    taskHistory = [];
+    capabilityAssessments = new Map();
+    confidenceHistory = new Map();
+    telemetryIntegration;
+    verificationIntegration;
+    constructor(config) {
+        super();
+        this.config = {
+            max_concurrent_tasks: 5,
+            default_timeout_ms: 300000, // 5 minutes default
+            enable_telemetry: true,
+            enable_verification_formatting: true,
+            verification_auto_formats: ['json', 'markdown'],
+            max_verification_output_bytes: 1024 * 1024, // 1MB default
+            debug: false,
+            ...config,
+        };
+        // Initialize capability tracking
+        this.initializeCapabilityTracking();
+        // Initialize telemetry integration if enabled
+        this.initializeTelemetry();
+        // Initialize verification integration if enabled
+        this.initializeVerificationIntegration();
+        if (this.config.debug) {
+            console.log(`[AgentRuntime] Initialized agent: ${this.config.agent_id}`);
+        }
+    }
+    /**
+     * Get agent information
+     */
+    getAgentInfo() {
+        return {
+            agent_id: this.config.agent_id,
+            agent_name: this.config.agent_name,
+            version: this.config.version,
+            capabilities: this.config.capabilities?.capabilities || [],
+            reputation_score: this.calculateCurrentReputation(),
+            current_workload: this.currentTasks.size,
+            max_concurrent_tasks: this.config.max_concurrent_tasks || 5,
+        };
+    }
+    /**
+     * Execute a task with optional delegation context
+     */
+    async executeTask(taskDescription, taskParameters, delegationContract) {
+        // Check concurrent task limit
+        if (this.currentTasks.size >= (this.config.max_concurrent_tasks || 5)) {
+            throw new Error('Maximum concurrent task limit reached');
+        }
+        // Create execution context
+        const context = {
+            execution_id: randomUUID(),
+            task: {
+                description: taskDescription,
+                parameters: taskParameters,
+                priority: delegationContract?.priority || 5,
+            },
+            delegation_contract: delegationContract,
+            metadata: {
+                started_at: new Date().toISOString(),
+                status: 'pending',
+                progress: 0,
+            },
+        };
+        // Add timeout from delegation contract or default
+        const timeout = delegationContract?.timeout_ms || this.config.default_timeout_ms || 300000;
+        context.metadata.estimated_completion_ms = timeout;
+        this.currentTasks.set(context.execution_id, context);
+        this.emit('task:started', context);
+        if (delegationContract) {
+            this.emit('delegation:contract:received', delegationContract);
+        }
+        try {
+            // Validate delegation contract constraints
+            if (delegationContract) {
+                await this.validateDelegationContract(delegationContract);
+                this.emit('delegation:contract:accepted', delegationContract);
+            }
+            // Execute the task with retry support
+            const result = await this.performTaskExecutionWithRetry(context, timeout, delegationContract?.retry_policy);
+            // Verify result if required
+            if (delegationContract?.verification_policy) {
+                result.verification = await this.performVerification(result, delegationContract);
+            }
+            // Update task history and capabilities
+            this.taskHistory.push(result);
+            this.updateCapabilitiesFromExecution(result);
+            this.currentTasks.delete(context.execution_id);
+            this.emit('task:completed', result);
+            if (this.config.debug) {
+                console.log(`[AgentRuntime] Task completed: ${context.execution_id}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorType = error instanceof Error ? error.constructor.name : typeof error;
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            const result = {
+                context: { ...context, metadata: { ...context.metadata, status: 'failed' } },
+                success: false,
+                error: {
+                    type: errorType,
+                    message: errorMessage,
+                    stack: errorStack,
+                },
+                metrics: {
+                    execution_time_ms: Date.now() - new Date(context.metadata.started_at).getTime(),
+                },
+                completed_at: new Date().toISOString(),
+            };
+            this.taskHistory.push(result);
+            this.currentTasks.delete(context.execution_id);
+            this.emit('task:failed', result);
+            if (this.config.debug) {
+                console.error(`[AgentRuntime] Task failed: ${context.execution_id}`, error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Perform capability self-assessment
+     */
+    async performCapabilitySelfAssessment(capabilityId) {
+        const capabilities = this.config.capabilities?.capabilities || [];
+        const assessments = [];
+        const capabilitiesToAssess = capabilityId
+            ? capabilities.filter(c => c.capability_id === capabilityId)
+            : capabilities;
+        for (const capability of capabilitiesToAssess) {
+            const assessment = await this.assessCapability(capability);
+            assessments.push(assessment);
+            // Store assessment
+            const history = this.capabilityAssessments.get(capability.capability_id) || [];
+            history.push(assessment);
+            this.capabilityAssessments.set(capability.capability_id, history);
+            // Update confidence if significantly different
+            const confidenceDiff = Math.abs(assessment.confidence_level - capability.confidence_level);
+            if (confidenceDiff > 0.1) { // 10% threshold
+                const oldConfidence = capability.confidence_level;
+                capability.confidence_level = assessment.confidence_level;
+                this.updateConfidenceHistory(capability.capability_id, assessment.confidence_level);
+                this.emit('confidence:updated', capability.capability_id, oldConfidence, assessment.confidence_level);
+            }
+            this.emit('capability:assessed', assessment);
+        }
+        return assessments;
+    }
+    /**
+     * Get current task status
+     */
+    getCurrentTasks() {
+        return Array.from(this.currentTasks.values());
+    }
+    /**
+     * Get task execution history
+     */
+    getTaskHistory(limit) {
+        return limit ? this.taskHistory.slice(-limit) : [...this.taskHistory];
+    }
+    /**
+     * Get capability confidence history
+     */
+    getConfidenceHistory(capabilityId) {
+        return this.confidenceHistory.get(capabilityId) || [];
+    }
+    /**
+     * Get current capability manifest
+     */
+    getCapabilityManifest() {
+        return this.config.capabilities;
+    }
+    /**
+     * Update capability manifest
+     */
+    updateCapabilityManifest(manifest) {
+        this.config.capabilities = manifest;
+        if (this.config.debug) {
+            console.log(`[AgentRuntime] Updated capability manifest for ${this.config.agent_id}`);
+        }
+    }
+    /**
+     * Generate verification outputs for a task execution result
+     *
+     * @param result Task execution result to generate verification outputs for
+     * @param contract Delegation contract with verification requirements
+     * @param formats Optional additional output formats to generate
+     * @returns Parsed verification result with multi-modal outputs
+     */
+    async generateVerificationOutputs(result, contract, formats) {
+        if (!this.verificationIntegration) {
+            if (this.config.debug) {
+                console.warn('[AgentRuntime] Verification integration not initialized');
+            }
+            return null;
+        }
+        try {
+            const verificationResult = await this.verificationIntegration.processTaskResult(result, contract, { formats, validate_strict: true });
+            return verificationResult.parsedResult;
+        }
+        catch (error) {
+            console.error('[AgentRuntime] Failed to generate verification outputs:', error);
+            return null;
+        }
+    }
+    /**
+     * Generate multi-modal verification report for a task execution result
+     *
+     * @param result Task execution result to generate report for
+     * @param contract Delegation contract with verification requirements
+     * @param formats Optional output formats to include
+     * @returns Multi-modal verification report
+     */
+    async generateVerificationReport(result, contract, formats) {
+        if (!this.verificationIntegration) {
+            if (this.config.debug) {
+                console.warn('[AgentRuntime] Verification integration not initialized');
+            }
+            return null;
+        }
+        try {
+            const verificationResult = await this.verificationIntegration.processTaskResult(result, contract, { formats, validate_strict: true });
+            return verificationResult.multiModalReport;
+        }
+        catch (error) {
+            console.error('[AgentRuntime] Failed to generate verification report:', error);
+            return null;
+        }
+    }
+    /**
+     * Get supported verification output formats
+     *
+     * @returns Array of supported verification output formats
+     */
+    getSupportedVerificationFormats() {
+        return this.verificationIntegration?.getAvailableFormats() || [];
+    }
+    /**
+     * Check if verification output formatting is enabled
+     *
+     * @returns True if verification integration is initialized and enabled
+     */
+    isVerificationFormattingEnabled() {
+        return !!this.verificationIntegration && !!this.config.enable_verification_formatting;
+    }
+    /** Validate capability and timeout feasibility for a delegation contract */
+    checkCapabilityAndTimeout(contract, assessment) {
+        const updatedAssessment = { ...assessment };
+        if (contract.required_capabilities && contract.required_capabilities.length > 0) {
+            const capabilityIds = contract.required_capabilities.map(cap => typeof cap === 'string' ? cap : cap.capability_id);
+            const capabilityCheck = this.checkCapabilityRequirements(capabilityIds);
+            if (!capabilityCheck.canMeet) {
+                return { can_accept: false, reason: `Capability mismatch: ${capabilityCheck.reason}`, updated_assessment: updatedAssessment };
+            }
+            updatedAssessment.capability_match = capabilityCheck.match_score || 1;
+        }
+        else {
+            updatedAssessment.capability_match = 0.8;
+        }
+        const estimatedTime = this.estimateTaskTime(contract.task_description || contract.metadata?.task_categories?.join(' ') || '');
+        if (contract.timeout_ms && estimatedTime > contract.timeout_ms) {
+            return {
+                can_accept: false,
+                reason: `Task may exceed timeout (estimated: ${estimatedTime}ms, limit: ${contract.timeout_ms}ms)`,
+                updated_assessment: updatedAssessment
+            };
+        }
+        return { can_accept: true, updated_assessment: updatedAssessment };
+    }
+    /** Check reputation/permission requirements; mutates assessment.reputation_compliance and returns rejection or null */
+    checkReputationAndPermission(contract, assessment) {
+        if (contract.reputation_requirements) {
+            const check = this.checkReputationRequirements(contract.reputation_requirements);
+            if (!check.meets_requirements) {
+                return { can_accept: false, reason: `Reputation requirements not met: ${check.reason}`, confidence: 0, assessment: { ...assessment, reputation_compliance: false } };
+            }
+        }
+        assessment.reputation_compliance = true;
+        if (contract.permission_token) {
+            const check = this.validatePermissionToken(contract.permission_token);
+            if (!check.valid) {
+                return { can_accept: false, reason: `Permission validation failed: ${check.reason}`, confidence: 0, assessment };
+            }
+        }
+        return null;
+    }
+    /** Check firebreak constraints; mutates assessment.firebreak_compliance and returns rejection or null */
+    checkFirebreakConstraints(contract, assessment) {
+        if (!contract.firebreaks?.length) {
+            assessment.firebreak_compliance = true;
+            return null;
+        }
+        const check = this.validateFirebreaks(contract.firebreaks, contract);
+        if (!check.compliant) {
+            return { can_accept: false, reason: `Firebreak violation: ${check.reason}`, confidence: 0, assessment: { ...assessment, firebreak_compliance: false } };
+        }
+        assessment.firebreak_compliance = true;
+        return null;
+    }
+    /**
+     * Check if agent can accept delegation contract with comprehensive validation
+     */
+    async canAcceptDelegationContract(contract) {
+        let assessment = {
+            capability_match: 0, resource_availability: 0, workload_capacity: 0,
+            reputation_compliance: false, firebreak_compliance: false,
+        };
+        if (this.currentTasks.size >= (this.config.max_concurrent_tasks || 5)) {
+            return { can_accept: false, reason: 'Maximum concurrent tasks reached', confidence: 0, assessment };
+        }
+        assessment.workload_capacity = 1 - (this.currentTasks.size / (this.config.max_concurrent_tasks || 5));
+        const reputationRejection = this.checkReputationAndPermission(contract, assessment);
+        if (reputationRejection)
+            return reputationRejection;
+        const firebreakRejection = this.checkFirebreakConstraints(contract, assessment);
+        if (firebreakRejection)
+            return firebreakRejection;
+        if (contract.resource_requirements) {
+            const resourceCheck = this.checkResourceRequirements(contract.resource_requirements);
+            if (!resourceCheck.canMeet) {
+                return { can_accept: false, reason: `Insufficient resources: ${resourceCheck.reason}`, confidence: 0, assessment };
+            }
+            assessment.resource_availability = resourceCheck.availability_score || 1;
+        }
+        else {
+            assessment.resource_availability = 1;
+        }
+        const { can_accept, reason, updated_assessment } = this.checkCapabilityAndTimeout(contract, assessment);
+        assessment = updated_assessment;
+        if (!can_accept) {
+            return { can_accept: false, reason, confidence: 0, assessment };
+        }
+        const estimatedTime = this.estimateTaskTime(contract.task_description || contract.metadata?.task_categories?.join(' ') || '');
+        const confidence = this.calculateAcceptanceConfidence(assessment, contract);
+        return { can_accept: true, confidence, estimated_completion_ms: estimatedTime, assessment };
+    }
+    // Private methods
+    initializeCapabilityTracking() {
+        if (this.config.capabilities?.capabilities) {
+            for (const capability of this.config.capabilities.capabilities) {
+                this.updateConfidenceHistory(capability.capability_id, capability.confidence_level);
+            }
+        }
+    }
+    async validateDelegationContract(contract) {
+        const legacyContract = contract;
+        const hasExplicitTaskIdField = Object.prototype.hasOwnProperty.call(legacyContract, 'task_id');
+        const taskId = contract.task_id || contract.contract_id || legacyContract?.task?.id;
+        const delegatorAgentId = contract.delegator_agent_id || legacyContract?.delegator_agent || contract.delegator?.agent_id;
+        const delegateeAgentId = contract.delegatee_agent_id || legacyContract?.delegatee_agent || contract.delegatee?.agent_id;
+        // Validate contract format (support legacy aliases)
+        if ((hasExplicitTaskIdField && !contract.task_id) || !taskId || !delegatorAgentId || !delegateeAgentId) {
+            throw new Error('Invalid delegation contract: missing required fields');
+        }
+        // Check if we're the correct delegatee
+        const enforceDelegateeMatch = !!(contract.delegatee_agent_id || contract.delegatee?.agent_id);
+        if (enforceDelegateeMatch && delegateeAgentId !== this.config.agent_id) {
+            throw new Error(`Contract delegated to ${delegateeAgentId} but runtime is ${this.config.agent_id}`);
+        }
+        // Validate verification policy
+        const policyAliases = {
+            automated: 'direct_inspection',
+            manual: 'human_required',
+            capability_match: 'direct_inspection',
+        };
+        const rawPolicy = typeof contract.verification_policy === 'string'
+            ? contract.verification_policy
+            : legacyContract?.verification_policy?.verification_method;
+        const normalizedPolicy = policyAliases[rawPolicy] || rawPolicy;
+        const validPolicies = ['direct_inspection', 'third_party_audit', 'cryptographic_proof', 'human_required', 'none'];
+        if (!normalizedPolicy || !validPolicies.includes(String(normalizedPolicy))) {
+            throw new Error(`Invalid verification policy: ${rawPolicy}`);
+        }
+        // TLP Classification Enforcement
+        const { tlpEnforcement } = await import('../delegation/tlp-enforcement.js');
+        try {
+            tlpEnforcement.validateDelegationContract(contract);
+        }
+        catch (error) {
+            throw new Error(`TLP Security Violation: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async performTaskExecution(context, timeout) {
+        const startTime = Date.now();
+        context.metadata.status = 'running';
+        return new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                context.metadata.status = 'timeout';
+                reject(new Error(`Task execution timeout after ${timeout}ms`));
+            }, timeout);
+            // Simulate task execution (in real implementation, this would call actual task logic)
+            this.simulateTaskExecution(context)
+                .then(output => {
+                clearTimeout(timeoutHandle);
+                const endTime = Date.now();
+                const result = {
+                    context: { ...context, metadata: { ...context.metadata, status: 'completed', progress: 1 } },
+                    success: true,
+                    output,
+                    metrics: {
+                        execution_time_ms: endTime - startTime,
+                        peak_memory_mb: this.getCurrentMemoryUsage(),
+                        cpu_time_ms: endTime - startTime, // Simplified
+                    },
+                    completed_at: new Date().toISOString(),
+                };
+                resolve(result);
+            })
+                .catch(error => {
+                clearTimeout(timeoutHandle);
+                reject(error);
+            });
+        });
+    }
+    /** Apply retry delay and emit retry events for a given attempt */
+    async applyRetryDelay(context, attempt, retryPolicy) {
+        const delay = this.calculateRetryDelay(attempt, retryPolicy);
+        if (delay > 0) {
+            this.emit('task:retry:delay', context, attempt, delay);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        this.emit('task:retry:attempt', context, attempt);
+        if (this.config.debug) {
+            const max = retryPolicy?.max_retries || 0;
+            console.log(`[AgentRuntime] Retry attempt ${attempt}/${max} for task ${context.execution_id}`);
+        }
+    }
+    /** Handle retry catch: emits events, returns true if loop should continue, false if error should be thrown */
+    handleRetryAttemptError(error, context, attempt, maxRetries, retryPolicy) {
+        if (attempt < maxRetries && this.shouldRetryError(error, retryPolicy)) {
+            this.emit('task:retry:error', context, attempt, error);
+            return true;
+        }
+        if (attempt > 0)
+            this.emit('task:retry:exhausted', context, attempt);
+        return false;
+    }
+    async performTaskExecutionWithRetry(context, timeout, retryPolicy) {
+        const maxRetries = retryPolicy?.max_retries || 0;
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                if (attempt > 0)
+                    await this.applyRetryDelay(context, attempt, retryPolicy);
+                const result = await this.performTaskExecution(context, timeout);
+                if (attempt > 0)
+                    this.emit('task:retry:success', context, attempt);
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                if (this.handleRetryAttemptError(error, context, attempt, maxRetries, retryPolicy))
+                    continue;
+                throw error;
+            }
+        }
+        throw lastError || new Error('Unknown retry error');
+    }
+    calculateRetryDelay(attempt, retryPolicy) {
+        if (!retryPolicy)
+            return 0;
+        const baseDelay = retryPolicy.initial_delay_ms || 1000;
+        const maxDelay = retryPolicy.max_delay_ms || 30000;
+        let delay;
+        switch (retryPolicy.backoff_strategy) {
+            case 'linear':
+                delay = baseDelay * attempt;
+                break;
+            case 'exponential':
+                delay = baseDelay * Math.pow(2, attempt - 1);
+                break;
+            case 'none':
+            default:
+                delay = baseDelay;
+                break;
+        }
+        return Math.min(delay, maxDelay);
+    }
+    shouldRetryError(error, retryPolicy) {
+        if (!retryPolicy || !retryPolicy.retry_conditions) {
+            // Default: retry on timeout and network errors
+            return error.message.includes('timeout') ||
+                error.message.includes('network') ||
+                error.message.includes('ECONNRESET') ||
+                error.message.includes('ENOTFOUND');
+        }
+        const conditions = retryPolicy.retry_conditions;
+        for (const condition of conditions) {
+            switch (condition) {
+                case 'timeout':
+                    if (error.message.includes('timeout'))
+                        return true;
+                    break;
+                case 'network_error':
+                    if (error.message.includes('network') ||
+                        error.message.includes('ECONNRESET') ||
+                        error.message.includes('ENOTFOUND'))
+                        return true;
+                    break;
+                case 'resource_unavailable':
+                    if (error.message.includes('resource') ||
+                        error.message.includes('limit') ||
+                        error.message.includes('capacity'))
+                        return true;
+                    break;
+            }
+        }
+        return false;
+    }
+    async simulateTaskExecution(context) {
+        // Simulate progressive task execution with progress updates
+        const steps = 5;
+        for (let i = 1; i <= steps; i++) {
+            await new Promise(resolve => setTimeout(resolve, 100)); // Simulate work
+            context.metadata.progress = i / steps;
+            this.emit('task:progress', context, context.metadata.progress);
+        }
+        // Return simulated output based on task description
+        return {
+            task_id: context.task.description,
+            result: `Task completed: ${context.task.description}`,
+            execution_id: context.execution_id,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /** Apply verification integration outputs to result and update verificationResult accordingly */
+    async applyVerificationIntegration(result, contract, verificationResult) {
+        if (!this.verificationIntegration)
+            return;
+        try {
+            const verificationOutputResult = await this.verificationIntegration.processTaskResult(result, contract, { formats: this.config.verification_auto_formats, validate_strict: true });
+            result.verification_outputs = verificationOutputResult.parsedResult.formatted_outputs;
+            result.verification_report = verificationOutputResult.multiModalReport;
+            if (verificationOutputResult.validation && !verificationOutputResult.validation.valid) {
+                verificationResult.verified = false;
+                verificationResult.quality_score = Math.max(0, (verificationResult.quality_score ?? 0) - 0.2);
+                verificationResult.findings ??= [];
+                verificationResult.findings.push(...verificationOutputResult.validation.issues.map(issue => issue.message));
+            }
+            verificationResult.verification_details = JSON.stringify({
+                compliance_score: verificationOutputResult.parsedResult.compliance_analysis.compliance_score,
+                formats_generated: verificationOutputResult.parsedResult.formatted_outputs.map(o => o.format),
+                validation_summary: verificationOutputResult.validation?.summary,
+            });
+            if (this.config.debug) {
+                console.log(`[AgentRuntime] Generated ${verificationOutputResult.parsedResult.formatted_outputs.length} verification output formats`);
+            }
+        }
+        catch (error) {
+            console.error('[AgentRuntime] Failed to generate verification outputs:', error);
+            verificationResult.findings ??= [];
+            verificationResult.findings.push('Failed to generate verification output formatting');
+        }
+    }
+    async performVerification(result, contract) {
+        // Perform basic verification based on policy
+        const verificationResult = {
+            verified: result.success,
+            verified_at: new Date().toISOString(),
+            verified_by: this.config.agent_id,
+            verification_method: contract.verification_policy,
+            quality_score: result.success ? 0.85 : 0.0,
+            findings: result.success
+                ? ['output_exists', 'format_valid']
+                : ['task_failed'],
+        };
+        await this.applyVerificationIntegration(result, contract, verificationResult);
+        return verificationResult;
+    }
+    async assessCapability(capability) {
+        // Calculate confidence factors from task history
+        const recentTasks = this.getRecentTasksForCapability(capability.capability_id);
+        const successRate = this.calculateSuccessRate(recentTasks);
+        const avgExecutionTime = this.calculateAverageExecutionTime(recentTasks);
+        // Adjust confidence based on recent performance
+        let adjustedConfidence = capability.confidence_level;
+        if (successRate !== null) {
+            // Adjust based on success rate
+            if (successRate > 0.9) {
+                adjustedConfidence = Math.min(1.0, adjustedConfidence + 0.05);
+            }
+            else if (successRate < 0.7) {
+                adjustedConfidence = Math.max(0.1, adjustedConfidence - 0.1);
+            }
+        }
+        const assessment = {
+            capability_id: capability.capability_id,
+            confidence_level: adjustedConfidence,
+            assessed_at: new Date().toISOString(),
+            confidence_factors: {
+                recent_success_rate: successRate ?? undefined,
+                resource_efficiency: (this.calculateResourceEfficiency(recentTasks) ?? undefined),
+            },
+            reasoning: `Assessment based on ${recentTasks.length} recent tasks`,
+            recommendations: {
+                confidence_adjustment: adjustedConfidence - capability.confidence_level,
+                improvement_areas: successRate && successRate < 0.8 ? ['error_handling', 'edge_cases'] : [],
+            },
+        };
+        return assessment;
+    }
+    updateCapabilitiesFromExecution(result) {
+        // Update capability statistics based on execution result
+        if (this.config.capabilities?.capabilities) {
+            for (const capability of this.config.capabilities.capabilities) {
+                if (this.taskMatchesCapability(result.context.task.description, capability)) {
+                    capability.successful_completions = (capability.successful_completions || 0) + (result.success ? 1 : 0);
+                    capability.success_rate = (this.calculateCapabilitySuccessRate(capability.capability_id) ?? null) ?? undefined;
+                    if (result.metrics.execution_time_ms) {
+                        capability.completion_time_estimate_ms = this.calculateAverageCompletionTime(capability.capability_id) || 0;
+                    }
+                }
+            }
+        }
+    }
+    taskMatchesCapability(taskDescription, capability) {
+        // Simple pattern matching (in real implementation, this would be more sophisticated)
+        if (capability.supported_patterns) {
+            for (const pattern of capability.supported_patterns) {
+                if (new RegExp(pattern, 'i').test(taskDescription)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    getRecentTasksForCapability(capabilityId) {
+        return this.taskHistory
+            .filter(result => this.taskMatchesCapabilityId(result, capabilityId))
+            .slice(-10); // Last 10 tasks
+    }
+    taskMatchesCapabilityId(result, capabilityId) {
+        // Match task to capability (simplified)
+        const capability = this.config.capabilities?.capabilities.find(c => c.capability_id === capabilityId);
+        return capability ? this.taskMatchesCapability(result.context.task.description, capability) : false;
+    }
+    calculateSuccessRate(tasks) {
+        if (tasks.length === 0)
+            return null;
+        const successCount = tasks.filter(task => task.success).length;
+        return successCount / tasks.length;
+    }
+    calculateAverageExecutionTime(tasks) {
+        if (tasks.length === 0)
+            return null;
+        const totalTime = tasks.reduce((sum, task) => sum + task.metrics.execution_time_ms, 0);
+        return totalTime / tasks.length;
+    }
+    calculateResourceEfficiency(tasks) {
+        if (tasks.length === 0)
+            return null;
+        // Simplified efficiency calculation based on execution time vs estimated time
+        return 0.8; // Placeholder
+    }
+    calculateCurrentReputation() {
+        if (this.taskHistory.length === 0)
+            return 0.5; // Default
+        const recentTasks = this.taskHistory.slice(-20);
+        const successRate = this.calculateSuccessRate(recentTasks) || 0.5;
+        const avgQuality = this.calculateAverageQuality(recentTasks);
+        return (successRate * 0.7) + (avgQuality * 0.3);
+    }
+    calculateAverageQuality(tasks) {
+        const qualityScores = tasks
+            .filter(task => task.verification?.quality_score !== undefined)
+            .map(task => task.verification.quality_score);
+        if (qualityScores.length === 0)
+            return 0.5;
+        return qualityScores.reduce((sum, score) => sum + score, 0) / qualityScores.length;
+    }
+    calculateCapabilitySuccessRate(capabilityId) {
+        const tasks = this.getRecentTasksForCapability(capabilityId);
+        return this.calculateSuccessRate(tasks) || 0.5;
+    }
+    calculateAverageCompletionTime(capabilityId) {
+        const tasks = this.getRecentTasksForCapability(capabilityId);
+        return this.calculateAverageExecutionTime(tasks) || 60000; // Default 1 minute
+    }
+    updateConfidenceHistory(capabilityId, confidence) {
+        const history = this.confidenceHistory.get(capabilityId) || [];
+        history.push({
+            confidence,
+            timestamp: new Date().toISOString(),
+        });
+        // Keep only last 50 entries
+        if (history.length > 50) {
+            history.shift();
+        }
+        this.confidenceHistory.set(capabilityId, history);
+    }
+    checkResourceRequirements(requirements) {
+        const limits = this.config.resource_limits;
+        if (!limits)
+            return { canMeet: true, availability_score: 1 };
+        if (requirements.memory_mb && limits.memory_mb && requirements.memory_mb > limits.memory_mb) {
+            return { canMeet: false, reason: `Memory requirement ${requirements.memory_mb}MB exceeds limit ${limits.memory_mb}MB` };
+        }
+        if (requirements.cpu_cores && limits.cpu_percent && (requirements.cpu_cores * 100) > limits.cpu_percent) {
+            return { canMeet: false, reason: `CPU requirement ${requirements.cpu_cores * 100}% exceeds limit ${limits.cpu_percent}%` };
+        }
+        // Calculate availability score based on resource utilization
+        let score = 1;
+        if (requirements.memory_mb && limits.memory_mb) {
+            score *= (1 - requirements.memory_mb / limits.memory_mb);
+        }
+        if (requirements.cpu_cores && limits.cpu_percent) {
+            score *= (1 - (requirements.cpu_cores * 100) / limits.cpu_percent);
+        }
+        return { canMeet: true, availability_score: Math.max(0, score) };
+    }
+    checkCapabilityRequirements(requiredCapabilities) {
+        const myCapabilities = this.config.capabilities?.capabilities.map(c => c.capability_id) || [];
+        const myCapabilityMap = new Map(this.config.capabilities?.capabilities.map(c => [c.capability_id, c]) || []);
+        let totalConfidence = 0;
+        let matchedCount = 0;
+        for (const required of requiredCapabilities) {
+            if (!myCapabilities.includes(required)) {
+                return { canMeet: false, reason: `Missing required capability: ${required}` };
+            }
+            const capability = myCapabilityMap.get(required);
+            if (capability) {
+                totalConfidence += capability.confidence_level;
+                matchedCount++;
+            }
+        }
+        const matchScore = matchedCount > 0 ? totalConfidence / matchedCount : 0;
+        return { canMeet: true, match_score: matchScore };
+    }
+    checkSpecializationRequirements(requirements) {
+        if (!requirements.required_specializations || !this.config.capabilities) {
+            return { meets_requirements: true };
+        }
+        const mySpecs = this.config.capabilities.specializations || [];
+        const missing = requirements.required_specializations.filter(s => !mySpecs.includes(s));
+        if (missing.length > 0) {
+            return { meets_requirements: false, reason: `Missing required specializations: ${missing.join(', ')}` };
+        }
+        return { meets_requirements: true };
+    }
+    checkReputationRequirements(requirements) {
+        const currentReputation = this.calculateCurrentReputation();
+        const taskHistory = this.getTaskHistory();
+        const successfulTasks = taskHistory.filter(task => task.success).length;
+        if (requirements.min_security_score && currentReputation < requirements.min_security_score) {
+            return {
+                meets_requirements: false,
+                reason: `Security score ${currentReputation.toFixed(2)} below required ${requirements.min_security_score}`
+            };
+        }
+        if (requirements.min_tasks_completed && successfulTasks < requirements.min_tasks_completed) {
+            return {
+                meets_requirements: false,
+                reason: `Completed tasks ${successfulTasks} below required ${requirements.min_tasks_completed}`
+            };
+        }
+        if (requirements.min_confidence_score && this.config.capabilities) {
+            const avgConfidence = this.config.capabilities.overall_confidence;
+            if (avgConfidence != null && avgConfidence < requirements.min_confidence_score) {
+                return {
+                    meets_requirements: false,
+                    reason: `Confidence ${avgConfidence.toFixed(2)} below required ${requirements.min_confidence_score}`
+                };
+            }
+        }
+        if (requirements.max_consecutive_failures) {
+            const recentFailures = this.calculateConsecutiveFailures();
+            if (recentFailures > requirements.max_consecutive_failures) {
+                return {
+                    meets_requirements: false,
+                    reason: `Consecutive failures ${recentFailures} exceeds limit ${requirements.max_consecutive_failures}`
+                };
+            }
+        }
+        return this.checkSpecializationRequirements(requirements);
+    }
+    validatePermissionToken(token) {
+        // Check token expiration
+        if (token.expires_at) {
+            const expiryTime = new Date(token.expires_at).getTime();
+            const currentTime = Date.now();
+            if (currentTime > expiryTime) {
+                return { valid: false, reason: `Permission token expired at ${token.expires_at}` };
+            }
+        }
+        // Validate required scopes (placeholder - would need agent-specific scope requirements)
+        if (token.scopes.length === 0) {
+            return { valid: false, reason: 'Permission token has no scopes' };
+        }
+        // Validate required actions (placeholder)
+        if (token.actions.length === 0) {
+            return { valid: false, reason: 'Permission token has no allowed actions' };
+        }
+        // Validate resources (placeholder)
+        if (token.resources.length === 0) {
+            return { valid: false, reason: 'Permission token has no accessible resources' };
+        }
+        return { valid: true };
+    }
+    checkFirebreak(firebreak, contract) {
+        switch (firebreak.type) {
+            case 'max_depth': {
+                const depth = contract.metadata?.delegation_depth || 0;
+                if (firebreak.threshold && depth >= firebreak.threshold) {
+                    return { compliant: false, reason: `Delegation depth ${depth} exceeds firebreak limit ${firebreak.threshold}` };
+                }
+                return { compliant: true };
+            }
+            case 'tlp_escalation': {
+                const tlp = contract.tlp_classification || 'TLP:CLEAR';
+                if (this.isTLPEscalation(tlp, firebreak)) {
+                    return { compliant: false, reason: `TLP escalation beyond firebreak: ${tlp}` };
+                }
+                return { compliant: true };
+            }
+            case 'timeout': {
+                const est = this.estimateTaskTime(contract.task_description || '');
+                if (firebreak.threshold && est > firebreak.threshold) {
+                    return { compliant: false, reason: `Estimated time ${est}ms exceeds firebreak limit ${firebreak.threshold}ms` };
+                }
+                return { compliant: true };
+            }
+            case 'resource_limit':
+                if (contract.resource_requirements) {
+                    return this.checkFirebreakResourceLimits(contract.resource_requirements, firebreak);
+                }
+                return { compliant: true };
+            case 'human_review':
+                if (firebreak.action === 'require_approval') {
+                    return { compliant: false, reason: 'Human review firebreak requires manual approval' };
+                }
+                return { compliant: true };
+            default:
+                return { compliant: true };
+        }
+    }
+    validateFirebreaks(firebreaks, contract) {
+        for (const firebreak of firebreaks) {
+            const result = this.checkFirebreak(firebreak, contract);
+            if (!result.compliant)
+                return result;
+        }
+        return { compliant: true };
+    }
+    isTLPEscalation(currentTLP, firebreak) {
+        const tlpLevels = { 'TLP:CLEAR': 0, 'TLP:GREEN': 1, 'TLP:AMBER': 2, 'TLP:RED': 3 };
+        const currentLevel = tlpLevels[currentTLP] || 0;
+        const maxLevel = firebreak.threshold || 0;
+        return currentLevel > maxLevel;
+    }
+    checkFirebreakResourceLimits(requirements, firebreak) {
+        if (requirements.memory_mb && firebreak.threshold && requirements.memory_mb > firebreak.threshold) {
+            return {
+                compliant: false,
+                reason: `Memory requirement ${requirements.memory_mb}MB exceeds firebreak limit ${firebreak.threshold}MB`
+            };
+        }
+        return { compliant: true };
+    }
+    calculateAcceptanceConfidence(assessment, contract) {
+        // Weight factors based on importance
+        const weights = {
+            capability_match: 0.3,
+            resource_availability: 0.2,
+            workload_capacity: 0.2,
+            reputation_compliance: 0.15,
+            firebreak_compliance: 0.15,
+        };
+        let confidence = 0;
+        confidence += assessment.capability_match * weights.capability_match;
+        confidence += assessment.resource_availability * weights.resource_availability;
+        confidence += assessment.workload_capacity * weights.workload_capacity;
+        confidence += (assessment.reputation_compliance ? 1 : 0) * weights.reputation_compliance;
+        confidence += (assessment.firebreak_compliance ? 1 : 0) * weights.firebreak_compliance;
+        // Apply penalty for high complexity or tight deadlines
+        if (contract.metadata?.estimated_complexity && contract.metadata.estimated_complexity > 7) {
+            confidence *= 0.9; // 10% penalty for high complexity
+        }
+        if (contract.timeout_ms) {
+            const estimatedTime = this.estimateTaskTime(contract.task_description || '');
+            const timeRatio = estimatedTime / contract.timeout_ms;
+            if (timeRatio > 0.8) {
+                confidence *= (1 - (timeRatio - 0.8) * 2); // Penalty for tight deadlines
+            }
+        }
+        return Math.max(0, Math.min(1, confidence));
+    }
+    calculateConsecutiveFailures() {
+        const recentTasks = this.getTaskHistory(10); // Last 10 tasks
+        let consecutiveFailures = 0;
+        // Count failures from the end until we hit a success
+        for (let i = recentTasks.length - 1; i >= 0; i--) {
+            if (!recentTasks[i].success) {
+                consecutiveFailures++;
+            }
+            else {
+                break;
+            }
+        }
+        return consecutiveFailures;
+    }
+    estimateTaskTime(taskDescription) {
+        // Simple estimation based on task description length and complexity
+        const baseTime = 5000; // 5 seconds base for reasonable task estimates
+        const complexityBonus = Math.min(taskDescription.length * 50, 15000); // Max 15 seconds additional
+        // Check for complexity keywords that might indicate longer tasks
+        const complexKeywords = ['complex', 'comprehensive', 'detailed', 'enterprise', 'full'];
+        const isComplex = complexKeywords.some(keyword => taskDescription.toLowerCase().includes(keyword));
+        const complexityMultiplier = isComplex ? 2 : 1;
+        return (baseTime + complexityBonus) * complexityMultiplier;
+    }
+    getCurrentMemoryUsage() {
+        // In a real implementation, this would get actual memory usage
+        return Math.random() * 100; // Simulated memory usage in MB
+    }
+    /**
+     * Initialize telemetry integration
+     */
+    initializeTelemetry() {
+        if (!this.config.enable_telemetry) {
+            if (this.config.debug) {
+                console.log('[AgentRuntime] Telemetry disabled');
+            }
+            return;
+        }
+        try {
+            // Create telemetry integration with default or custom configuration
+            if (this.config.telemetry_config) {
+                this.telemetryIntegration = new RuntimeTelemetryIntegration({
+                    telemetry_config: {
+                        agent_id: this.config.agent_id,
+                        enabled: true,
+                        sinks: [], // Will be populated by createDefaultTelemetryIntegration
+                        ...this.config.telemetry_config.telemetry_config,
+                    },
+                    ...this.config.telemetry_config,
+                });
+            }
+            else {
+                // Use default telemetry integration
+                this.telemetryIntegration = createDefaultTelemetryIntegration(this.config.agent_id, {
+                    track_task_metrics: true,
+                    track_delegation_lifecycle: true,
+                    track_resource_utilization: true,
+                    track_retry_attempts: true,
+                });
+            }
+            // Attach telemetry to this runtime instance
+            this.telemetryIntegration.attach(this);
+            if (this.config.debug) {
+                console.log('[AgentRuntime] Telemetry integration initialized');
+            }
+        }
+        catch (error) {
+            console.error('[AgentRuntime] Failed to initialize telemetry:', error);
+            // Continue without telemetry rather than failing completely
+        }
+    }
+    /**
+     * Initialize verification integration
+     */
+    initializeVerificationIntegration() {
+        if (!this.config.enable_verification_formatting) {
+            if (this.config.debug) {
+                console.log('[AgentRuntime] Verification formatting disabled');
+            }
+            return;
+        }
+        try {
+            this.verificationIntegration = new VerificationIntegration({
+                strict_validation: true,
+                auto_generate_formats: this.config.verification_auto_formats || ['json', 'markdown'],
+                default_formatter_config: {
+                    default_formats: ['json', 'markdown'],
+                    include_human_readable: true,
+                    include_machine_readable: true,
+                    include_content_hash: true,
+                    enable_compression: false,
+                    strict_compliance_checking: true,
+                    max_content_size_bytes: this.config.max_verification_output_bytes || 1024 * 1024,
+                    metadata_options: {
+                        include_timing_data: true,
+                        include_resource_usage: true,
+                        include_error_details: true,
+                        include_verification_artifacts: true,
+                    },
+                },
+            });
+            if (this.config.debug) {
+                console.log('[AgentRuntime] Verification integration initialized');
+            }
+        }
+        catch (error) {
+            console.error('[AgentRuntime] Failed to initialize verification integration:', error);
+            // Continue without verification formatting rather than failing completely
+        }
+    }
+    /**
+     * Get telemetry integration (for external access)
+     */
+    getTelemetryIntegration() {
+        return this.telemetryIntegration;
+    }
+    /**
+     * Query telemetry events
+     */
+    async queryTelemetryEvents(filter) {
+        if (!this.telemetryIntegration) {
+            throw new Error('Telemetry is not enabled');
+        }
+        return this.telemetryIntegration.queryEvents(filter);
+    }
+    /**
+     * Shutdown runtime and cleanup resources
+     */
+    async shutdown() {
+        if (this.config.debug) {
+            console.log('[AgentRuntime] Shutting down...');
+        }
+        // Cancel all running tasks
+        const taskEntries = Array.from(this.currentTasks.entries());
+        for (const [executionId, context] of taskEntries) {
+            context.metadata.status = 'failed';
+            this.emit('task:failed', {
+                context,
+                success: false,
+                output: null,
+                error: {
+                    type: 'SHUTDOWN_ERROR',
+                    message: 'Runtime shutdown while task was executing',
+                    timestamp: new Date().toISOString(),
+                },
+                metrics: {
+                    execution_time_ms: Date.now() - new Date(context.metadata.started_at).getTime(),
+                },
+                completed_at: new Date().toISOString(),
+            });
+        }
+        // Clear all tasks
+        this.currentTasks.clear();
+        // Cleanup telemetry integration
+        if (this.telemetryIntegration) {
+            try {
+                await this.telemetryIntegration.detach(this);
+            }
+            catch (error) {
+                console.error('[AgentRuntime] Error during telemetry cleanup:', error);
+            }
+        }
+        // Emit shutdown event before removing listeners
+        this.emit('shutdown');
+        // Remove all event listeners
+        this.removeAllListeners();
+        if (this.config.debug) {
+            console.log('[AgentRuntime] Shutdown complete');
+        }
+    }
+}
+export default AgentRuntime;
+//# sourceMappingURL=agent-runtime.js.map