@holoscript/framework 6.0.3

package/dist/AgentManifest-CB4xM-Ma.d.ts

@@ -0,0 +1,704 @@
+/**
+ * @holoscript/core - Agent Type Definitions
+ *
+ * Shared types for the HoloScript Agent Framework.
+ * Defines the 7-phase uAA2++ protocol and agent capabilities.
+ */
+/**
+ * The 7 phases of the uAA2++ protocol
+ */
+type AgentPhase = 'INTAKE' | 'REFLECT' | 'EXECUTE' | 'COMPRESS' | 'REINTAKE' | 'GROW' | 'EVOLVE';
+/**
+ * Phase execution order
+ */
+declare const PHASE_ORDER: readonly AgentPhase[];
+/**
+ * Default phase timings (milliseconds)
+ */
+declare const DEFAULT_PHASE_TIMINGS: Record<AgentPhase, number>;
+/**
+ * Base result for all phases
+ */
+interface PhaseResult {
+    success: boolean;
+    phase: AgentPhase;
+    duration_ms: number;
+    error?: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * INTAKE phase result
+ */
+interface IntakeResult extends PhaseResult {
+    phase: 'INTAKE';
+    sources: string[];
+    items_loaded: number;
+    data?: {
+        knowledge?: Record<string, unknown>;
+        patterns?: unknown[];
+        wisdom?: unknown[];
+        gotchas?: unknown[];
+        context?: Record<string, unknown>;
+    };
+}
+/**
+ * REFLECT phase result
+ */
+interface ReflectResult extends PhaseResult {
+    phase: 'REFLECT';
+    analysis_depth: 'shallow' | 'medium' | 'deep';
+    insights_generated: number;
+    data?: {
+        ai_context?: string;
+        decision_criteria?: Record<string, unknown>;
+        priorities?: string[];
+        risks?: string[];
+    };
+}
+/**
+ * EXECUTE phase result
+ */
+interface ExecuteResult extends PhaseResult {
+    phase: 'EXECUTE';
+    actions_taken: number;
+    deliverables: string[];
+    data?: {
+        outputs?: unknown[];
+        side_effects?: string[];
+        metrics?: Record<string, number>;
+    };
+}
+/**
+ * COMPRESS phase result
+ */
+interface CompressResult extends PhaseResult {
+    phase: 'COMPRESS';
+    compression_ratio: number;
+    tokens_saved: number;
+    data?: {
+        compressed_knowledge?: string;
+        symbol_mappings?: Record<string, string>;
+        patterns_extracted?: string[];
+        wisdom_extracted?: string[];
+        gotchas_captured?: string[];
+    };
+}
+/**
+ * REINTAKE phase result
+ */
+interface ReintakeResult extends PhaseResult {
+    phase: 'REINTAKE';
+    items_refreshed: number;
+    effectiveness: number;
+    data?: {
+        merged_knowledge?: Record<string, unknown>;
+        conflicts_resolved?: number;
+        new_insights?: string[];
+    };
+}
+/**
+ * GROW phase result
+ */
+interface GrowResult extends PhaseResult {
+    phase: 'GROW';
+    patterns_learned: number;
+    wisdom_gained: number;
+    gotchas_captured: number;
+    data?: {
+        new_patterns?: Array<{
+            id: string;
+            name: string;
+            confidence: number;
+        }>;
+        new_wisdom?: Array<{
+            id: string;
+            content: string;
+            domain: string;
+        }>;
+        new_gotchas?: Array<{
+            id: string;
+            trigger: string;
+            avoidance: string;
+        }>;
+        capability_score_delta?: number;
+    };
+}
+/**
+ * EVOLVE phase result
+ */
+interface EvolveResult extends PhaseResult {
+    phase: 'EVOLVE';
+    evolution_level: number;
+    traits_activated: string[];
+    traits_deactivated: string[];
+    data?: {
+        new_capabilities?: string[];
+        optimizations_applied?: string[];
+        efficiency_improvement?: number;
+        next_evolution_threshold?: number;
+    };
+}
+/**
+ * Union type for all phase results
+ */
+type AnyPhaseResult = IntakeResult | ReflectResult | ExecuteResult | CompressResult | ReintakeResult | GrowResult | EvolveResult;
+/**
+ * Complete cycle result
+ */
+interface CycleResult {
+    cycle_number: number;
+    success: boolean;
+    total_duration_ms: number;
+    phases: {
+        intake?: IntakeResult;
+        reflect?: ReflectResult;
+        execute?: ExecuteResult;
+        compress?: CompressResult;
+        reintake?: ReintakeResult;
+        grow?: GrowResult;
+        evolve?: EvolveResult;
+    };
+    learnings: {
+        patterns: number;
+        wisdom: number;
+        gotchas: number;
+    };
+    evolution_delta: number;
+    timestamp: string;
+}
+/**
+ * Agent category classification
+ */
+type AgentCategory = 'trading' | 'analysis' | 'optimization' | 'monitoring' | 'creative' | 'management' | 'strategic' | 'assistant' | 'orchestrator' | 'quest_creator' | 'librarian' | 'twin_manager' | 'payment_handler' | 'autonomous';
+/**
+ * Agent position in the Lotus Flower Architecture
+ */
+type AgentPosition = 'center' | 'inner-circle' | 'main-petal' | 'inner-petal' | 'supportive' | 'background' | 'infrastructure';
+/**
+ * Agent orchestral section (musical metaphor)
+ */
+type AgentSection = 'strings' | 'woodwinds' | 'brass' | 'percussion' | 'keyboard' | 'vocal';
+/**
+ * Architecture awareness metadata
+ */
+interface ArchitectureAwareness {
+    position: AgentPosition;
+    section?: AgentSection;
+    role: string;
+    visualizationDoc?: string;
+    musicPatterns?: {
+        interval: 'I' | 'II' | 'III' | 'IV' | 'V' | 'VI' | 'VII' | 'VIII';
+        formRole: 'exposition' | 'development' | 'recapitulation' | 'coda' | 'refrain';
+        pulse: 'strong' | 'weak' | 'syncopated';
+    };
+}
+/**
+ * Phase configuration overrides
+ */
+interface PhaseConfig {
+    enabled?: boolean;
+    timeout_ms?: number;
+    retries?: number;
+    parallel?: boolean;
+    dependencies?: AgentPhase[];
+}
+/**
+ * Curiosity configuration (what's next?)
+ */
+interface CuriosityConfig {
+    enabled: boolean;
+    depth: 'shallow' | 'medium' | 'deep';
+    sources: Array<'todo' | 'handoff' | 'codebase' | 'related' | 'improvement' | 'pattern'>;
+    auto_continue: boolean;
+    max_results: number;
+}
+/**
+ * Budget configuration for runaway prevention
+ */
+interface BudgetConfig {
+    max_tokens_per_cycle: number;
+    max_duration_ms: number;
+    max_actions_per_minute: number;
+    max_consecutive_failures: number;
+}
+/**
+ * Complete agent configuration
+ */
+interface AgentConfig {
+    agent_id: string;
+    agent_name: string;
+    agent_type: string;
+    categories: AgentCategory[];
+    architecture?: ArchitectureAwareness;
+    phases?: Partial<Record<AgentPhase, PhaseConfig>>;
+    phase_timings?: Partial<Record<AgentPhase, number>>;
+    enabled_phases?: AgentPhase[];
+    auto_transition?: boolean;
+    curiosity?: Partial<CuriosityConfig>;
+    budget?: Partial<BudgetConfig>;
+    llm?: {
+        model?: string;
+        temperature?: number;
+        max_tokens?: number;
+        system_prompt?: string;
+    };
+    custom?: Record<string, unknown>;
+}
+/**
+ * Cycle metrics for lifespan tracking
+ */
+interface CycleMetric {
+    cycle_number: number;
+    duration_ms: number;
+    success: boolean;
+    score: number;
+    timestamp: number;
+}
+/**
+ * Agent lifespan context - tracks evolution across cycles
+ */
+interface AgentLifespanContext {
+    total_cycles_completed: number;
+    evolution_level: number;
+    performance_trend: 'improving' | 'stable' | 'declining';
+    average_cycle_duration: number;
+    recent_metrics: CycleMetric[];
+    knowledge_growth_trajectory: number;
+    adaptation_score: number;
+    related_tasks: string[];
+}
+/**
+ * Assistant-specific lifespan context (e.g., Brittney)
+ */
+interface AssistantLifespanContext {
+    total_interactions: number;
+    training_data_processed: number;
+    personality_evolution: {
+        emotional_responsiveness: number;
+        communication_style: string[];
+        user_preferences: Record<string, unknown>;
+    };
+    desktop_environment_memory: {
+        frequent_apps: string[];
+        window_arrangement_patterns: string[];
+        user_workflows: string[];
+        last_active_session_id?: string;
+    };
+    conversation_history: unknown[];
+}
+/**
+ * Complete agent state
+ */
+interface AgentState {
+    agent_id: string;
+    current_phase: AgentPhase;
+    phase_start_time: number;
+    cycle_number: number;
+    knowledge: Map<string, unknown>;
+    patterns: unknown[];
+    wisdom: unknown[];
+    gotchas: unknown[];
+    reflection_context: Record<string, unknown>;
+    execution_result: unknown;
+    compressed_knowledge: string;
+    metrics: {
+        phases_completed: number;
+        total_cycles: number;
+        efficiency_score: number;
+        token_usage: number;
+    };
+    lifespan?: AgentLifespanContext;
+    assistant_lifespan?: AssistantLifespanContext;
+    is_training_mode: boolean;
+    is_shutting_down: boolean;
+}
+/**
+ * Message priority levels
+ */
+type MessagePriority = 'low' | 'medium' | 'high' | 'critical' | 'sovereign';
+/**
+ * Inter-agent message
+ */
+interface AgentMessage {
+    id: string;
+    from: string;
+    to: string | 'broadcast';
+    type: 'request' | 'response' | 'notification' | 'event';
+    action: string;
+    payload: Record<string, unknown>;
+    priority: MessagePriority;
+    timestamp: number;
+    correlation_id?: string;
+    ttl_ms?: number;
+}
+/**
+ * Agent response
+ */
+interface AgentResponse {
+    message_id: string;
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    duration_ms: number;
+}
+/**
+ * Pattern entry for knowledge base
+ */
+interface PatternEntry {
+    pattern_id: string;
+    name: string;
+    domain: string;
+    description: string;
+    template: string;
+    confidence: number;
+    usage_count: number;
+    created_at: string;
+    updated_at: string;
+    tags: string[];
+}
+/**
+ * Wisdom entry for knowledge base
+ */
+interface WisdomEntry {
+    wisdom_id: string;
+    content: string;
+    domain: string;
+    source: string;
+    confidence: number;
+    citations: string[];
+    created_at: string;
+    tags: string[];
+}
+/**
+ * Gotcha entry for knowledge base
+ */
+interface GotchaEntry {
+    gotcha_id: string;
+    trigger: string;
+    consequence: string;
+    avoidance: string;
+    domain: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    occurrence_count: number;
+    created_at: string;
+    tags: string[];
+}
+/**
+ * Agent-specific trait context
+ */
+interface AgentTraitContext {
+    agent_id: string;
+    agent_name: string;
+    agent_type: string;
+    current_phase: AgentPhase;
+    phase_history: AgentPhase[];
+    getKnowledge: (key: string) => unknown;
+    setKnowledge: (key: string, value: unknown) => void;
+    queryKnowledge: (query: string) => Promise<unknown[]>;
+    sendMessage: (to: string, action: string, payload: unknown) => Promise<AgentResponse>;
+    broadcast: (action: string, payload: unknown) => Promise<void>;
+    callAI: (options: {
+        prompt: string;
+        context?: Record<string, unknown>;
+        model?: string;
+        temperature?: number;
+        max_tokens?: number;
+    }) => Promise<{
+        text: string;
+        tokens_used: number;
+    }>;
+    transitionTo: (phase: AgentPhase) => void;
+    skipPhase: (phase: AgentPhase) => void;
+    repeatPhase: () => void;
+    recordMetric: (name: string, value: number) => void;
+    getMetrics: () => Record<string, number>;
+    log: (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: unknown) => void;
+    wallet?: {
+        getBalance: (asset?: string) => Promise<number>;
+        pay: (endpoint: string, amount: number, asset: string) => Promise<{
+            success: boolean;
+            txHash?: string;
+        }>;
+        trade: (from: string, to: string, amount: number) => Promise<{
+            success: boolean;
+            txHash?: string;
+        }>;
+        mintNFT: (metadata: Record<string, any>) => Promise<{
+            success: boolean;
+            tokenId?: string;
+        }>;
+    };
+    story_weaver?: {
+        generateNarrative: (context: Record<string, unknown>) => Promise<string>;
+        createWorld: (theme: string) => Promise<string>;
+        deployContracts: (worldId: string) => Promise<boolean>;
+    };
+}
+
+/**
+ * @holoscript/core - Agent Manifest Definitions
+ *
+ * Defines the structure for agent registration and capability declaration.
+ * Part of HoloScript v3.1 Agentic Choreography.
+ */
+
+/**
+ * Resource cost for executing a capability
+ */
+interface ResourceCost {
+    /** Estimated compute cost (0-100 scale) */
+    compute: number;
+    /** Estimated memory usage (0-100 scale) */
+    memory: number;
+    /** Estimated network usage (0-100 scale) */
+    network: number;
+    /** Token cost for LLM operations (if applicable) */
+    tokens?: number;
+}
+/**
+ * Latency profile for a capability
+ */
+type LatencyProfile = 'instant' | 'fast' | 'medium' | 'slow' | 'background';
+/**
+ * Latency thresholds in milliseconds
+ */
+declare const LATENCY_THRESHOLDS: Record<LatencyProfile, number>;
+/**
+ * Capability types that agents can provide
+ */
+type CapabilityType = 'render' | 'analyze' | 'generate' | 'approve' | 'detect' | 'transform' | 'store' | 'retrieve' | 'communicate' | 'orchestrate' | 'validate' | 'optimize' | 'custom';
+/**
+ * Capability domains
+ */
+type CapabilityDomain = 'vision' | 'nlp' | 'spatial' | 'blockchain' | 'audio' | 'video' | 'physics' | 'networking' | 'storage' | 'security' | 'trading' | 'social' | 'gaming' | 'general';
+/**
+ * Single agent capability
+ */
+interface AgentCapability {
+    /** Capability type identifier */
+    type: CapabilityType | string;
+    /** Domain the capability operates in */
+    domain: CapabilityDomain | string;
+    /** Unique capability identifier */
+    id?: string;
+    /** Human-readable name */
+    name?: string;
+    /** Description of what this capability does */
+    description?: string;
+    /** Resource cost profile */
+    cost?: Partial<ResourceCost>;
+    /** Expected latency */
+    latency?: LatencyProfile;
+    /** Capability version */
+    version?: string;
+    /** Required input types */
+    inputs?: string[];
+    /** Output type */
+    output?: string;
+    /** Whether this capability is currently available */
+    available?: boolean;
+    /** Priority for conflict resolution (higher = preferred) */
+    priority?: number;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Endpoint protocol types
+ */
+type EndpointProtocol = 'local' | 'ipc' | 'http' | 'https' | 'ws' | 'wss' | 'grpc' | 'mqtt' | 'custom';
+/**
+ * Agent communication endpoint
+ */
+interface AgentEndpoint {
+    /** Endpoint protocol */
+    protocol: EndpointProtocol;
+    /** Endpoint address (URL, IPC path, etc.) */
+    address: string;
+    /** Endpoint port (if applicable) */
+    port?: number;
+    /** Whether this is the primary endpoint */
+    primary?: boolean;
+    /** Health check path (if applicable) */
+    healthPath?: string;
+    /** Authentication required */
+    authRequired?: boolean;
+    /** Supported message formats */
+    formats?: Array<'json' | 'msgpack' | 'protobuf' | 'custom'>;
+}
+/**
+ * 3D Vector for spatial definitions
+ */
+interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Bounding box for spatial agents
+ */
+interface BoundingBox {
+    /** Minimum point (corner) */
+    min: Vector3;
+    /** Maximum point (opposite corner) */
+    max: Vector3;
+    /** Coordinate system reference */
+    coordinateSystem?: 'world' | 'local' | 'scene';
+}
+/**
+ * Spatial scope for agents
+ */
+interface SpatialScope {
+    /** Bounding box if defined */
+    bounds?: BoundingBox;
+    /** Named scene/world */
+    scene?: string;
+    /** Specific node IDs this agent operates on */
+    nodes?: string[];
+    /** Radius from a center point */
+    radius?: {
+        center: Vector3;
+        distance: number;
+    };
+    /** Whether agent can operate outside its spatial scope */
+    global?: boolean;
+}
+/**
+ * Trust level for agents
+ */
+type TrustLevel = 'local' | 'verified' | 'known' | 'external' | 'untrusted';
+/**
+ * Verification status
+ */
+interface VerificationStatus {
+    /** Whether the agent is verified */
+    verified: boolean;
+    /** Verification method used */
+    method?: 'signature' | 'certificate' | 'oauth' | 'token' | 'manual';
+    /** When verification was performed */
+    verifiedAt?: number;
+    /** When verification expires */
+    expiresAt?: number;
+    /** Verifying authority */
+    authority?: string;
+    /** Verification signature/proof */
+    proof?: string;
+}
+/**
+ * Complete agent manifest for registration
+ */
+interface AgentManifest {
+    /** Unique agent identifier */
+    id: string;
+    /** Human-readable agent name */
+    name: string;
+    /** Agent version (semver) */
+    version: string;
+    /** Agent description */
+    description?: string;
+    /** Agent categories */
+    categories?: AgentCategory[];
+    /** Position in architecture */
+    position?: AgentPosition;
+    /** Orchestral section */
+    section?: AgentSection;
+    /** Custom tags for filtering */
+    tags?: string[];
+    /** List of capabilities this agent provides */
+    capabilities: AgentCapability[];
+    /** Available endpoints for communication */
+    endpoints: AgentEndpoint[];
+    /** Spatial scope this agent operates in */
+    spatialScope?: SpatialScope;
+    /** Trust level */
+    trustLevel: TrustLevel;
+    /** Verification status */
+    verification?: VerificationStatus;
+    /** Health check interval in ms */
+    healthCheckInterval?: number;
+    /** Last heartbeat timestamp */
+    lastHeartbeat?: number;
+    /** Current health status */
+    status?: 'online' | 'offline' | 'degraded' | 'unknown';
+    /** Registration timestamp */
+    registeredAt?: number;
+    /** Last updated timestamp */
+    updatedAt?: number;
+    /** Owner/creator identifier */
+    owner?: string;
+    /** Source repository/package */
+    source?: string;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Fluent builder for creating agent manifests
+ */
+declare class AgentManifestBuilder {
+    private manifest;
+    /**
+     * Set agent identity
+     */
+    identity(id: string, name: string, version: string): this;
+    /**
+     * Set agent description
+     */
+    description(desc: string): this;
+    /**
+     * Set classification
+     */
+    classify(categories: AgentCategory[], position?: AgentPosition, section?: AgentSection): this;
+    /**
+     * Add a capability
+     */
+    addCapability(capability: AgentCapability): this;
+    /**
+     * Add multiple capabilities
+     */
+    addCapabilities(capabilities: AgentCapability[]): this;
+    /**
+     * Add an endpoint
+     */
+    addEndpoint(endpoint: AgentEndpoint): this;
+    /**
+     * Set spatial scope
+     */
+    spatial(scope: SpatialScope): this;
+    /**
+     * Set trust level
+     */
+    trust(level: TrustLevel, verification?: VerificationStatus): this;
+    /**
+     * Set health check interval
+     */
+    healthCheck(intervalMs: number): this;
+    /**
+     * Add custom tags
+     */
+    tags(...tags: string[]): this;
+    /**
+     * Set metadata
+     */
+    metadata(data: Record<string, unknown>): this;
+    /**
+     * Build the manifest
+     */
+    build(): AgentManifest;
+}
+/**
+ * Create a new manifest builder
+ */
+declare function createManifest(): AgentManifestBuilder;
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Validate an agent manifest
+ */
+declare function validateManifest(manifest: Partial<AgentManifest>): ValidationResult;
+
+export { type AgentManifest as A, type BoundingBox as B, type CapabilityType as C, DEFAULT_PHASE_TIMINGS as D, type EndpointProtocol as E, LATENCY_THRESHOLDS as F, type GotchaEntry as G, type PatternEntry as H, type IntakeResult as I, type PhaseConfig as J, type PhaseResult as K, type LatencyProfile as L, type MessagePriority as M, type ReintakeResult as N, type ResourceCost as O, PHASE_ORDER as P, type VerificationStatus as Q, type ReflectResult as R, type SpatialScope as S, type TrustLevel as T, createManifest as U, type Vector3 as V, type WisdomEntry as W, validateManifest as X, type AgentCapability as a, type CapabilityDomain as b, type AgentCategory as c, type AgentConfig as d, type AgentEndpoint as e, type AgentLifespanContext as f, AgentManifestBuilder as g, type AgentMessage as h, type AgentPhase as i, type AgentPosition as j, type AgentResponse as k, type AgentSection as l, type AgentState as m, type AgentTraitContext as n, type ValidationResult as o, type AnyPhaseResult as p, type ArchitectureAwareness as q, type AssistantLifespanContext as r, type BudgetConfig as s, type CompressResult as t, type CuriosityConfig as u, type CycleMetric as v, type CycleResult as w, type EvolveResult as x, type ExecuteResult as y, type GrowResult as z };