export { k as AgentCallbacks, d as AgentContext, A as AgentType, C as Checkpointer, l as ComputePreference, m as CrewAgentConfig, E as EADKAgent, a as EADKAgentConfig, n as EvalCase, o as EvalContext, p as EvalMetric, q as EvalResult, G as GraphConfig, r as GraphEdge, s as GraphNode, t as Guardrail, u as GuardrailContext, v as GuardrailResult, H as Handoff, w as HandoffResult, x as HookContext, L as LLMRequest, e as LLMResponse, y as LLMToolDefinition, z as LiveSession, j as MemoryBackend, i as MemoryConfig, f as MemoryEntry, g as MemoryScope, h as MemorySearchResult, B as Message, D as MessageRole, M as ModelConfig, F as ResponseMeta, R as RunConfig, c as RunEvent, I as RunEventData, J as RunEventType, K as RunHooks, b as RunResult, S as SessionConfig, N as SessionState, O as Span, P as SpanEvent, Q as SpanType, U as SteeringConfig, V as SteeringVectorInput, W as SuperinferenceConfig, X as SuperinferenceMode, Y as TokenUsage, T as Tool, Z as ToolCall, _ as ToolCallResult, $ as ToolContext, a0 as ToolGuardrail, a1 as ToolGuardrailResult, a2 as TraceExporter } from '../types-Ks98Z0E_.mjs';
export { B as BaseAgent, C as CustomAgent, L as LLMAgent, a as LLMProvider, g as getProvider, r as registerProvider } from '../agent-zMxIG3gI.mjs';
export { Runner, Session, agentAsTool, createAgentContext, createChildContext, createGuardrailContext, createHookContext, createNoOpHooks, createToolContext, defineTool, executeTool, mergeHooks, toolsToLLMDefinitions, zodToJsonSchema } from './core/index.mjs';
export { createContentFilterGuardrail, createPIIGuardrail, createRateLimitGuardrail, createTokenBudgetGuardrail, createTopicGuardrail } from './guardrails/index.mjs';
export { InMemoryBackend, IndexedDBBackend, MemoryService, createMemoryService } from './memory/index.mjs';
export { END, GraphAgent, InMemoryCheckpointer, LoopAgent, ParallelAgent, SequentialAgent, createHandoff, executeHandoff } from './orchestration/index.mjs';
export { ConsoleExporter, EdgeworkMetricsExporter, OpenTelemetryExporter, Tracer, getGlobalTracer, setGlobalTracer } from './tracing/index.mjs';
export { contains, createRegexMetric, evaluate, exactMatch, lengthRatio, toolUsage } from './eval/index.mjs';
export { EdgeAgent, LocalInferenceProvider, PeerAgent } from './edge/index.mjs';
export { A2AAgentCard, A2AClient, A2AMessage, A2AResponse, A2AServer, P2PMesh } from './transport/index.mjs';
export { createWASMTool } from './wasm/index.mjs';
export { MCPClient, MCPServer } from './mcp/index.mjs';
import 'zod';

/**
 * Edgework Agent Development Kit - Type Definitions
 */
interface WalletConfig {
    /** Private key (hex string with 0x prefix) */
    privateKey: string;
    /** Public address */
    address: string;
    /** Encryption key for key storage */
    encryptionKey?: string;
    /** Whether keys are stored locally encrypted */
    isLocal?: boolean;
}
interface GatewayConfig {
    /** Gateway name (e.g., "Office Worker") */
    name: string;
    /** Region (e.g., "us-west", "eu-central") */
    region: string;
    /** Wallet address for gateway owner */
    walletAddress: string;
    /** Custom metadata */
    metadata?: Record<string, unknown>;
    /** UCAN root for delegation (optional) */
    ucanRoot?: string;
}
interface ComputeConfig {
    /** CPU allocation (0-1, default: 0.8) */
    cpuAllocation: number;
    /** Memory in MB (default: 2048) */
    memoryMB: number;
    /** Max task duration in seconds (default: 600) */
    maxTaskDuration: number;
    /** Enable WebGPU if available */
    enableGPU?: boolean;
    /** Enable WebNN if available */
    enableWebNN?: boolean;
    /** Enable token-based spending (default: true) */
    enableTokenSpending?: boolean;
    /** EDGEWORK token address on Optimism (default: 0x55ef8e6e56DEDc7f72658E53C7b2759c74210a5A) */
    tokenAddress?: string;
    /** Cost per compute minute in tokens (as bigint, e.g., 1000000000000000000n = 1 token) */
    tokenCostPerMinute?: bigint;
    /** Minimum token balance required before tasks can run */
    minTokenBalance?: bigint;
}
interface SystemConfig {
    /** Run at system boot */
    runAtBoot: boolean;
    /** Show system tray icon */
    systemTray: boolean;
    /** Log level: 'debug' | 'info' | 'warn' | 'error' */
    logLevel: 'debug' | 'info' | 'warn' | 'error';
    /** Daemonize process (headless) */
    daemonize?: boolean;
    /** Auto-restart on unmet expectations */
    autoRestart?: boolean;
}
interface AgentConfig {
    gateway: GatewayConfig;
    compute: ComputeConfig;
    system: SystemConfig;
    wallet?: WalletConfig;
}
interface ComputeStats {
    tasksCompleted: number;
    totalComputeTime: number;
    estimatedEarnings: number;
    activeTaskCount: number;
    cpuUsage: number;
    memoryUsage: number;
    uptime: number;
}
interface GatewayRegistration {
    gatewayAddress: string;
    owner: string;
    ucanRoot: string;
    registeredAt: number;
    isActive: boolean;
    totalComputeUnits: number;
    pendingRewards: number;
}
interface ComputeTask {
    id: string;
    type: 'inference' | 'embedding' | 'analysis';
    input: unknown;
    timeout: number;
    createdAt: number;
}
interface ComputeResult {
    taskId: string;
    output: unknown;
    computeTimeMs: number;
    success: boolean;
    error?: string;
}
interface AgentManagerOptions {
    configPath?: string;
    walletAddress?: string;
    gatewayName?: string;
    /** API key for gateway auth (falls back to EDGEWORK_API_KEY env var) */
    apiKey?: string;
    cpuAllocation?: number;
    memoryMB?: number;
    enableTokenSpending?: boolean;
    enableSystemTray?: boolean;
    runAtBoot?: boolean;
    rpcUrl?: string;
    registryAddress?: string;
}
interface GatewayConnectorOptions {
    walletAddress: string;
    provider?: string;
    registryAddress?: string;
    /** API key for relayer auth (falls back to EDGEWORK_API_KEY env var) */
    apiKey?: string;
    chainId?: number;
    gasLimit?: number;
    gasPrice?: number;
}
interface ComputeNodeOptions {
    gatewayUrl: string;
    /** API key for gateway auth (falls back to EDGEWORK_API_KEY env var) */
    apiKey?: string;
    cpuAllocation: number;
    memoryMB: number;
    maxTaskDuration: number;
    enableGPU?: boolean;
}
interface SystemTrayOptions {
    agentManager: any;
    showOnStartup?: boolean;
    hideOnClose?: boolean;
    clickBehavior?: 'toggle' | 'show' | 'none';
}
interface SetupPromptOptions {
    nonInteractive?: boolean;
    defaults?: Partial<AgentConfig>;
    skipWallet?: boolean;
    skipSystemTray?: boolean;
}
interface AgentEvents {
    started: {
        timestamp: number;
    };
    stopped: {
        reason: string;
        timestamp: number;
    };
    taskReceived: {
        task: ComputeTask;
    };
    taskCompleted: {
        result: ComputeResult;
    };
    taskFailed: {
        taskId: string;
        error: string;
    };
    statsUpdated: {
        stats: ComputeStats;
    };
    walletRegistered: {
        address: string;
        txHash: string;
    };
    error: {
        error: Error;
        context: string;
    };
}
type AgentEventType = keyof AgentEvents;
type AgentEventListener<K extends AgentEventType> = (event: AgentEvents[K]) => void;
/**
 * Token-based rate limiting and spending
 */
interface TokenBalance {
    /** Total EDGEWORK tokens held */
    total: bigint;
    /** Available tokens (not locked in pending transactions) */
    available: bigint;
    /** Tokens locked in pending compute requests */
    locked: bigint;
    /** Last update timestamp */
    updatedAt: number;
}
interface TokenRateLimit {
    /** Cost per compute minute in tokens (e.g., 1000000000000000000n = 1 token/min) */
    costPerMinute: bigint;
    /** Cost per API call in tokens */
    costPerCall: bigint;
    /** Minimum token balance to submit tasks (prevents spam) */
    minimumBalance: bigint;
    /** Maximum tokens that can be spent per day */
    dailyLimit: bigint;
    /** Whether subscription is required (false = pure token-based) */
    subscriptionRequired: boolean;
}
interface TokenSpendingTransaction {
    /** Unique transaction ID */
    id: string;
    /** Task or request this spending is for */
    taskId: string;
    /** Amount of tokens to burn */
    amount: bigint;
    /** Compute duration in seconds */
    durationSeconds: number;
    /** Status: pending | confirmed | failed | refunded */
    status: 'pending' | 'confirmed' | 'failed' | 'refunded';
    /** Timestamp created */
    createdAt: number;
    /** Timestamp confirmed on-chain */
    confirmedAt?: number;
    /** On-chain transaction hash */
    txHash?: string;
    /** Error message if failed */
    error?: string;
}
interface TokenLedger {
    /** Wallet address */
    address: string;
    /** Current balance */
    balance: TokenBalance;
    /** Today's spending */
    spentToday: bigint;
    /** Pending transactions */
    pendingTransactions: TokenSpendingTransaction[];
    /** Completed transactions today */
    completedTransactions: TokenSpendingTransaction[];
    /** Last update from on-chain */
    lastSyncAt: number;
}
interface TokenSpendingConfig {
    /** Token contract address on Optimism */
    tokenAddress: string;
    /** Rate limits configuration */
    rateLimit: TokenRateLimit;
    /** Check balance every N milliseconds (default: 5 min = 300000ms) */
    balanceSyncInterval: number;
    /** Fallback RPC URL if custom not provided */
    rpcUrl?: string;
    /** Enable token-based spending (vs subscription-only) */
    enableTokenSpending: boolean;
}
interface TokenSpendingEvent {
    balanceUpdated: {
        balance: TokenBalance;
    };
    transactionSubmitted: {
        tx: TokenSpendingTransaction;
    };
    transactionConfirmed: {
        tx: TokenSpendingTransaction;
        txHash: string;
    };
    transactionFailed: {
        tx: TokenSpendingTransaction;
        error: string;
    };
    dailyLimitExceeded: {
        spent: bigint;
        limit: bigint;
    };
    insufficientBalance: {
        required: bigint;
        available: bigint;
    };
    computeApproved: {
        requestId: string;
        txId: string;
    };
}
type TokenSpendingEventType = keyof TokenSpendingEvent;
type TokenSpendingEventListener<K extends TokenSpendingEventType> = (event: TokenSpendingEvent[K]) => void;

/**
 * Wallet Manager - Handles local key generation and encrypted storage
 */

interface WalletManagerOptions {
    configDir?: string;
    encryptionKey?: string;
}
/**
 * Manages local encrypted wallet storage
 *
 * @example
 * ```typescript
 * const walletMgr = new WalletManager();
 *
 * // Create new wallet (auto-generates keys)
 * const wallet = await walletMgr.createWallet();
 * console.log(wallet.address); // 0x...
 *
 * // Load existing wallet
 * const existing = await walletMgr.loadWallet();
 *
 * // Sign data
 * const signature = await walletMgr.sign('0x' + Buffer.from('hello').toString('hex'));
 * ```
 */
declare class WalletManager {
    private configDir;
    private encryptionKey;
    private wallet;
    private keyPath;
    constructor(options?: WalletManagerOptions);
    /**
     * Get default config directory
     */
    private getDefaultConfigDir;
    /**
     * Derive device-specific encryption key
     * Uses hostname, OS, and hardware fingerprint
     */
    private deriveDeviceKey;
    /**
     * Generate a new Ethereum wallet (secp256k1)
     */
    generateWallet(): Promise<WalletConfig>;
    /**
     * Save wallet locally (encrypted)
     */
    saveWallet(): Promise<void>;
    /**
     * Load wallet from local storage
     */
    loadWallet(): Promise<WalletConfig | null>;
    /**
     * Check if wallet exists
     */
    walletExists(): Promise<boolean>;
    /**
     * Sign data with wallet private key
     */
    sign(message: string): Promise<string>;
    /**
     * Delete wallet (security feature)
     */
    deleteWallet(): Promise<void>;
    /**
     * Get current wallet address
     */
    getAddress(): string | null;
    /**
     * Verify wallet is loaded
     */
    isLoaded(): boolean;
}

/**
 * Gateway Connector - Registers agents with Edgework on Optimism
 */

/**
 * Connects to Optimism and registers gateway
 *
 * @example
 * ```typescript
 * const connector = new GatewayConnector({
 *   walletAddress: '0x...',
 *   provider: 'https://sepolia.optimism.io',
 * });
 *
 * // Register existing wallet
 * const reg = await connector.register();
 *
 * // Or create new wallet and register
 * const { wallet, registration } = await connector.registerWithNewWallet({
 *   name: 'My Gateway',
 *   region: 'us-west',
 * });
 * ```
 */
declare class GatewayConnector {
    private provider;
    private walletAddress;
    private registryAddress;
    private apiKey;
    private chainId;
    private walletManager;
    private web3Provider;
    private contract;
    private logger;
    constructor(options: GatewayConnectorOptions);
    private createLogger;
    /**
     * Connect to provider
     */
    connect(): Promise<void>;
    /**
     * Disconnect from provider
     */
    disconnect(): Promise<void>;
    /**
     * Register with existing wallet
     */
    register(config?: Partial<GatewayConfig>): Promise<GatewayRegistration>;
    /**
     * Register with a new auto-generated wallet
     */
    registerWithNewWallet(config: Omit<GatewayConfig, 'walletAddress'>): Promise<{
        wallet: WalletConfig;
        registration: GatewayRegistration;
    }>;
    /**
     * Get current registration status
     */
    getStatus(): Promise<GatewayRegistration | null>;
    /**
     * Send heartbeat to keep gateway active
     */
    sendHeartbeat(): Promise<void>;
    /**
     * Unregister from gateway
     */
    unregister(reason?: string): Promise<void>;
    /**
     * Register via a relayer (gas-sponsored)
     */
    registerViaRelayer(relayerUrl: string, config: GatewayConfig): Promise<GatewayRegistration>;
}

/**
 * Token Spending Manager - Handles EDGEWORK token balance and spending for compute
 * Implements subscription-first fallback: if subscription has credits, use those first.
 * Only burns tokens if subscription unavailable or credits exhausted.
 */

/**
 * Manages token-based compute spending with subscription fallback
 *
 * @example
 * ```typescript
 * const manager = new TokenSpendingManager({
 *   walletAddress: '0x...',
 *   tokenAddress: '0x55ef8e6e56DEDc7f72658E53C7b2759c74210a5A',
 *   enableTokenSpending: true,
 *   rateLimit: {
 *     costPerMinute: 1000000000000000000n, // 1 token per minute
 *     costPerCall: 100000000000000000n,
 *     minimumBalance: 1000000000000000000n,
 *     dailyLimit: 1000000000000000000000n,
 *     subscriptionRequired: false,
 *   },
 *   balanceSyncInterval: 300000, // 5 minutes
 *   rpcUrl: 'https://sepolia.optimism.io',
 * });
 *
 * await manager.initialize();
 * const balance = await manager.getBalance();
 * const tx = await manager.requestTokenSpend('task-123', 60, false);
 * ```
 */
declare class TokenSpendingManager {
    private walletAddress;
    private config;
    private ledger;
    private logger;
    private web3Provider;
    private tokenContract;
    private balanceSyncInterval;
    private listeners;
    constructor(walletAddress: string, config: TokenSpendingConfig);
    private createLogger;
    /**
     * Initialize and connect to token contract
     */
    initialize(): Promise<void>;
    private loadEthers;
    /**
     * Sync balance from on-chain
     */
    syncBalance(): Promise<void>;
    /**
     * Start periodic balance sync loop
     */
    private startBalanceSyncLoop;
    /**
     * Request token spend for compute task
     * Returns spending transaction if approved, null if using subscription or insufficient tokens
     */
    requestTokenSpend(taskId: string, durationSeconds: number, hasSubscription: boolean): Promise<TokenSpendingTransaction | null>;
    /**
     * Execute token burn on-chain after task completion
     */
    burnTokens(tx: TokenSpendingTransaction): Promise<void>;
    /**
     * Get current balance
     */
    getBalance(): TokenBalance;
    /**
     * Get full ledger
     */
    getLedger(): TokenLedger;
    /**
     * Check if user can afford compute
     */
    canAffordCompute(durationSeconds: number): boolean;
    /**
     * Get estimated cost for compute duration
     */
    getEstimatedCost(durationSeconds: number): bigint;
    /**
     * Register event listener
     */
    on<K extends TokenSpendingEventType>(event: K, listener: TokenSpendingEventListener<K>): void;
    /**
     * Unregister event listener
     */
    off<K extends TokenSpendingEventType>(event: K, listener: TokenSpendingEventListener<K>): void;
    /**
     * Emit event to all listeners
     */
    private emit;
    /**
     * Cleanup and stop sync
     */
    stop(): Promise<void>;
}

/**
 * Main agent orchestrator with token-based compute spending support
 *
 * @example
 * ```typescript
 * const manager = new AgentManager({
 *   gatewayName: 'My Node',
 *   cpuAllocation: 0.8,
 *   enableSystemTray: true,
 *   runAtBoot: true,
 * });
 *
 * await manager.initialize();
 * await manager.start();
 *
 * manager.on('statsUpdated', ({ stats }) => {
 *   console.log('Earnings:', stats.estimatedEarnings);
 * });
 * ```
 */
declare class AgentManager {
    private config;
    private configPath;
    private apiKey;
    private gateway;
    private computeNode;
    private walletManager;
    private tokenSpending;
    private listeners;
    private isRunning;
    private statsInterval;
    private heartbeatInterval;
    private logger;
    constructor(options?: AgentManagerOptions);
    private createLogger;
    private getConfigDir;
    /**
     * Initialize agent
     */
    initialize(): Promise<void>;
    /**
     * Start agent
     */
    start(): Promise<void>;
    /**
     * Stop agent
     */
    stop(reason?: string): Promise<void>;
    /**
     * Get current stats
     */
    getStats(): ComputeStats;
    /**
     * Send heartbeat to gateway
     */
    private sendHeartbeat;
    /**
     * Report stats and emit event
     */
    private reportStats;
    /**
     * Load or create config
     */
    private loadOrCreateConfig;
    /**
     * Save config to file
     */
    private saveConfig;
    /**
     * Event listener registration
     */
    on<K extends AgentEventType>(event: K, listener: AgentEventListener<K>): void;
    /**
     * Remove event listener
     */
    off<K extends AgentEventType>(event: K, listener: AgentEventListener<K>): void;
    /**
     * Emit event
     */
    private emit;
    /**
     * Get config
     */
    getConfig(): AgentConfig;
    /**
     * Get token spending manager (if enabled)
     */
    getTokenSpendingManager(): TokenSpendingManager | null;
    /**
     * Get current token balance
     */
    getTokenBalance(): TokenBalance | null;
    /**
     * Update config
     */
    updateConfig(partial: Partial<AgentConfig>): Promise<void>;
}

/**
 * Manages compute task execution with optional token-based payment
 *
 * @example
 * ```typescript
 * const node = new ComputeNode({
 *   gatewayUrl: 'http://localhost:8080',
 *   cpuAllocation: 0.8,
 *   memoryMB: 2048,
 *   maxTaskDuration: 600,
 *   walletAddress: '0x...',
 *   tokenSpendingManager: tokenManager, // optional
 * });
 *
 * await node.start();
 * ```
 */
declare class ComputeNode {
    private config;
    private isRunning;
    private taskQueue;
    private stats;
    private startTime;
    private logger;
    private apiKey?;
    private tokenSpendingManager?;
    private walletAddress?;
    private hasSubscription;
    constructor(config: ComputeNodeOptions, tokenSpendingManager?: TokenSpendingManager, walletAddress?: string, hasSubscription?: boolean);
    private createLogger;
    private getRequestHeaders;
    /**
     * Connect to gateway
     */
    connect(): Promise<void>;
    /**
     * Disconnect from gateway
     */
    disconnect(): Promise<void>;
    /**
     * Start compute node
     */
    start(): Promise<void>;
    /**
     * Stop compute node
     */
    stop(): Promise<void>;
    /**
     * Submit result to gateway
     */
    submitResult(result: ComputeResult): Promise<void>;
    /**
     * Get current stats
     */
    getStats(): ComputeStats;
    /**
     * Process tasks loop
     */
    private processTasksLoop;
    /**
     * Fetch task from gateway
     */
    private fetchTask;
    /**
     * Execute task (placeholder)
     */
    private executeTask;
    /**
     * Check token balance before task execution
     */
    checkTokenBalance(): Promise<boolean>;
    /**
     * Request token spend for task (if enabled and no subscription)
     */
    requestTokenSpend(taskId: string, estimatedDurationSeconds: number): Promise<string | null>;
    /**
     * Execute token burn after task completion
     */
    burnTokensForTask(txId: string, actualDurationSeconds: number): Promise<void>;
    /**
     * Get token balance info
     */
    getTokenBalance(): TokenBalance | null;
    /**
     * Get token ledger info
     */
    getTokenLedger(): TokenLedger | null;
}

/**
 * Base system tray abstraction
 */
declare abstract class SystemTray {
    protected agentManager: any;
    protected logger: any;
    constructor(agentManager: any);
    protected createLogger(): {
        debug: (msg: string, data?: any) => void;
        info: (msg: string, data?: any) => void;
        error: (msg: string, data?: any) => void;
    };
    abstract show(): Promise<void>;
    abstract hide(): Promise<void>;
    abstract setStatus(status: string): Promise<void>;
    abstract updateStats(): Promise<void>;
}
/**
 * macOS system tray (Cocoa/SwiftUI)
 */
declare class MacOSSystemTray extends SystemTray {
    private windowShown;
    show(): Promise<void>;
    hide(): Promise<void>;
    setStatus(status: string): Promise<void>;
    updateStats(): Promise<void>;
    private getMenuItems;
    private showStatus;
    private showSettings;
}
/**
 * Windows system tray (Windows API)
 */
declare class WindowsSystemTray extends SystemTray {
    private windowShown;
    show(): Promise<void>;
    hide(): Promise<void>;
    setStatus(status: string): Promise<void>;
    updateStats(): Promise<void>;
    private getMenuItems;
    private showStatus;
    private showSettings;
}
/**
 * Linux system tray (xdg-desktop-portal / GTK)
 */
declare class LinuxSystemTray extends SystemTray {
    private windowShown;
    show(): Promise<void>;
    hide(): Promise<void>;
    setStatus(status: string): Promise<void>;
    updateStats(): Promise<void>;
}
/**
 * Factory for creating platform-specific system tray
 */
declare function createSystemTray(options: any): SystemTray;

/**
 * Interactive Setup Command
 * eslint-disable luxury-ui/no-emojis
 */
interface SetupAnswers {
    createWallet: boolean;
    gatewayName: string;
    region: string;
    cpuAllocation: number;
    enableSystemTray: boolean;
    runAtBoot: boolean;
}
/**
 * Interactive setup wizard
 */
declare function runSetupWizard(nonInteractive?: boolean): Promise<SetupAnswers>;
/**
 * Save configuration and complete setup
 */
declare function completeSetup(answers: SetupAnswers): Promise<void>;

export { type AgentConfig, type AgentEventListener, type AgentEventType, type AgentEvents, AgentManager, type AgentManagerOptions, type ComputeConfig, ComputeNode, type ComputeNodeOptions, type ComputeResult, type ComputeStats, type ComputeTask, type GatewayConfig, GatewayConnector, type GatewayConnectorOptions, type GatewayRegistration, LinuxSystemTray, MacOSSystemTray, type SetupPromptOptions, type SystemConfig, SystemTray, type SystemTrayOptions, type TokenBalance, type TokenLedger, type TokenRateLimit, type TokenSpendingConfig, type TokenSpendingEvent, type TokenSpendingEventListener, type TokenSpendingEventType, TokenSpendingManager, type TokenSpendingTransaction, type WalletConfig, WalletManager, WindowsSystemTray, completeSetup, createSystemTray, runSetupWizard };