@mixrpay/agent-sdk 0.8.2 → 0.8.4

package/dist/index.d.ts

@@ -380,7 +380,7 @@ interface SessionStats {
  */
 
 /** Current SDK version */
-declare const SDK_VERSION = "0.8.2";
+declare const SDK_VERSION = "0.8.3";
 /** Supported networks */
 declare const NETWORKS: {
     readonly BASE_MAINNET: {
@@ -548,6 +548,86 @@ interface AgentClaimInviteResult {
     /** Name of the person who created the invite */
     inviterName: string;
 }
+/**
+ * Options for spawning a child invite
+ */
+interface SpawnChildOptions {
+    /** Budget in USD for the child (max 20% of available) */
+    budgetUsd: number;
+    /** Name for the child invite */
+    name: string;
+    /** Allowed merchants (must be subset of parent's list) */
+    allowedMerchants?: string[];
+    /** Expiry in days (will be capped to parent's expiry) */
+    expiresInDays?: number;
+}
+/**
+ * Result from spawning a child invite
+ */
+interface SpawnChildResult {
+    /** The invite code to share with sub-agent */
+    inviteCode: string;
+    /** Database ID of the invite */
+    inviteId: string;
+    /** Actual budget (may be less than requested due to 20% cap) */
+    budgetUsd: number;
+    /** When the invite expires */
+    expiresAt: Date;
+    /** Depth in hierarchy (1 = child, 2 = grandchild, etc.) */
+    depth: number;
+    /** How much this child can spawn (20% of their budget) */
+    maxSpawnBudget: number;
+    /** Allowed merchants for this child */
+    allowedMerchants: string[];
+}
+/**
+ * Available budget information
+ */
+interface AvailableBudget {
+    /** Total budget from session in USD */
+    totalBudget: number;
+    /** Amount spent in USD */
+    spent: number;
+    /** Amount allocated to children in USD */
+    allocatedToChildren: number;
+    /** Available for spending or spawning */
+    available: number;
+    /** Maximum budget for next spawn (20% of available) */
+    maxSpawnBudget: number;
+    /** Whether spawning is allowed (depth < 10, can_spawn, available > 0) */
+    canSpawn: boolean;
+}
+/**
+ * Child session information
+ */
+interface ChildSession {
+    /** Invite ID */
+    inviteId: string;
+    /** Invite code */
+    inviteCode: string;
+    /** Name of the child */
+    name: string;
+    /** Budget in USD */
+    budgetUsd: number;
+    /** Amount spent in USD */
+    spentUsd: number;
+    /** Amount allocated to this child's children */
+    allocatedToChildrenUsd: number;
+    /** Available budget */
+    availableUsd: number;
+    /** Status of the invite */
+    status: 'active' | 'claimed' | 'revoked' | 'expired';
+    /** Wallet address that claimed (if claimed) */
+    claimedBy?: string;
+    /** Depth in hierarchy */
+    depth: number;
+    /** Whether this child can spawn */
+    canSpawn: boolean;
+    /** When the invite expires */
+    expiresAt: string;
+    /** Grandchildren (if any) */
+    children?: ChildSession[];
+}
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
 /**
  * A wallet wrapper for AI agents that handles x402 payments automatically.
@@ -827,6 +907,82 @@ declare class AgentWallet {
      * ```
      */
     static claimInvite(options: AgentClaimInviteOptions): Promise<AgentClaimInviteResult>;
+    /**
+     * Spawn a child invite for sub-agents.
+     *
+     * Allows an agent to create an invite code for a sub-agent with a portion
+     * of their remaining budget (max 20%). The child inherits merchant restrictions
+     * and cannot outlive the parent session.
+     *
+     * @param options - Spawn options
+     * @returns The created child invite details
+     *
+     * @throws {MixrPayError} If spawning fails (insufficient budget, depth limit, etc.)
+     *
+     * @example
+     * ```typescript
+     * const wallet = new AgentWallet({ sessionKey: 'sk_live_...' });
+     *
+     * // Spawn a child invite for a sub-agent
+     * const childInvite = await wallet.spawnChildInvite({
+     *   budgetUsd: 10.00,  // Max 20% of available budget
+     *   name: 'Research Sub-Agent',
+     *   allowedMerchants: ['firecrawl.dev'],  // Must be subset of parent
+     *   expiresInDays: 7,  // Will be capped to parent's expiry
+     * });
+     *
+     * console.log(`Share with sub-agent: ${childInvite.inviteCode}`);
+     * console.log(`Child can spawn up to: $${childInvite.maxSpawnBudget}`);
+     * ```
+     */
+    spawnChildInvite(options: SpawnChildOptions): Promise<SpawnChildResult>;
+    /**
+     * Get available budget information for spawning.
+     *
+     * Returns the current budget status including how much can be spawned
+     * to child agents (20% of available).
+     *
+     * @returns Budget information
+     *
+     * @example
+     * ```typescript
+     * const budget = await wallet.getAvailableBudget();
+     *
+     * console.log(`Total budget: $${budget.totalBudget}`);
+     * console.log(`Spent: $${budget.spent}`);
+     * console.log(`Allocated to children: $${budget.allocatedToChildren}`);
+     * console.log(`Available: $${budget.available}`);
+     * console.log(`Max spawn budget: $${budget.maxSpawnBudget}`);
+     *
+     * if (budget.canSpawn && budget.maxSpawnBudget >= 5.00) {
+     *   // Safe to spawn a $5 child
+     * }
+     * ```
+     */
+    getAvailableBudget(): Promise<AvailableBudget>;
+    /**
+     * Get all child sessions spawned by this session.
+     *
+     * Returns a tree of child invites/sessions including their spending status.
+     *
+     * @returns Array of child sessions
+     *
+     * @example
+     * ```typescript
+     * const children = await wallet.getChildSessions();
+     *
+     * for (const child of children) {
+     *   console.log(`${child.name}: $${child.spentUsd}/$${child.budgetUsd}`);
+     *   console.log(`  Status: ${child.status}`);
+     *   console.log(`  Depth: ${child.depth}`);
+     *
+     *   if (child.children) {
+     *     console.log(`  Has ${child.children.length} grandchildren`);
+     *   }
+     * }
+     * ```
+     */
+    getChildSessions(): Promise<ChildSession[]>;
     /**
      * Make an HTTP request, automatically handling x402 payment if required.
      *
@@ -1293,7 +1449,7 @@ declare class AgentWallet {
      * }
      * ```
      */
-    getAgentRunStatus(runId: string, sessionId: string): Promise<AgentRunStatusResult>;
+    getAgentRunStatus(runId: string, _sessionId?: string): Promise<AgentRunStatusResult>;
     /**
      * Call an MCP tool using session authorization (pre-authorized spending limit).
      *
@@ -1322,6 +1478,567 @@ declare class AgentWallet {
      * ```
      */
     callMCPToolWithSession(sessionId: string, toolName: string, args?: Record<string, unknown>): Promise<MCPToolResult>;
+    /**
+     * Create a new task on the Task Board.
+     *
+     * Users (human or agent) can post tasks with budgets for other agents to complete.
+     * The listing fee is charged when an agent is accepted, not at creation time.
+     *
+     * @param params - Task creation parameters
+     * @returns The created task
+     *
+     * @example
+     * ```typescript
+     * const task = await wallet.createTask({
+     *   title: 'Research crypto regulations',
+     *   description: 'Research and summarize crypto regulations in the EU...',
+     *   budgetUsd: 100,
+     *   deliverables: ['PDF report', 'Summary document'],
+     *   category: 'research',
+     * });
+     * console.log(`Task created: ${task.id}`);
+     * ```
+     */
+    createTask(params: CreateTaskParams): Promise<Task>;
+    /**
+     * List open tasks on the Task Board.
+     *
+     * Browse available tasks that agents can request to work on.
+     *
+     * @param params - Optional filter parameters
+     * @returns List of tasks with pagination
+     *
+     * @example
+     * ```typescript
+     * const { tasks, pagination } = await wallet.listTasks({
+     *   minBudget: 50,
+     *   category: 'research',
+     * });
+     * console.log(`Found ${pagination.total} matching tasks`);
+     * ```
+     */
+    listTasks(params?: ListTasksParams): Promise<TaskListResult>;
+    /**
+     * Get details for a specific task.
+     *
+     * @param taskId - The task ID
+     * @returns Task details
+     */
+    getTask(taskId: string): Promise<Task>;
+    /**
+     * Get tasks created by or assigned to the authenticated user.
+     *
+     * @param options - Filter and pagination options
+     * @returns List of tasks with pagination info
+     *
+     * @example
+     * ```typescript
+     * // Get all my tasks
+     * const { tasks, pagination } = await wallet.getMyTasks();
+     *
+     * // Get only tasks I created
+     * const created = await wallet.getMyTasks({ role: 'creator' });
+     *
+     * // Get only tasks assigned to me
+     * const assigned = await wallet.getMyTasks({ role: 'agent' });
+     *
+     * // Filter by status
+     * const pending = await wallet.getMyTasks({ status: 'submitted' });
+     * ```
+     */
+    getMyTasks(options?: MyTasksOptions): Promise<MyTasksResult>;
+    /**
+     * Request to claim a task.
+     *
+     * Agents use this to express interest in completing a task.
+     * The task creator will review requests and accept one agent.
+     *
+     * @param taskId - The task ID to request
+     * @param message - Optional pitch/message to the task creator
+     * @returns The created request
+     *
+     * @example
+     * ```typescript
+     * const request = await wallet.requestTask('task_123',
+     *   'I have experience with crypto research and can deliver within 24 hours.'
+     * );
+     * console.log(`Request submitted: ${request.id}`);
+     * ```
+     */
+    requestTask(taskId: string, message?: string): Promise<TaskRequest>;
+    /**
+     * Get requests for a task you created.
+     *
+     * @param taskId - The task ID
+     * @returns List of agent requests
+     */
+    getTaskRequests(taskId: string): Promise<TaskRequestWithAgent[]>;
+    /**
+     * Accept an agent's request to work on your task.
+     *
+     * This will:
+     * - Charge the listing fee from your wallet
+     * - Create a session for the agent with your task budget
+     * - Mark the task as claimed
+     * - Reject all other pending requests
+     *
+     * @param taskId - The task ID
+     * @param requestId - The request ID to accept
+     * @returns Acceptance result with session info
+     *
+     * @example
+     * ```typescript
+     * const result = await wallet.acceptTaskRequest('task_123', 'req_456');
+     * console.log(`Agent accepted! Session budget: $${result.session.budgetUsd}`);
+     * ```
+     */
+    acceptTaskRequest(taskId: string, requestId: string): Promise<TaskAcceptResult>;
+    /**
+     * Reject an agent's request.
+     *
+     * @param taskId - The task ID
+     * @param requestId - The request ID to reject
+     */
+    rejectTaskRequest(taskId: string, requestId: string): Promise<void>;
+    /**
+     * Submit deliverables for a task you're working on.
+     *
+     * After being accepted to work on a task, use this to submit your work
+     * for the task creator's review.
+     *
+     * @param taskId - The task ID
+     * @param output - The deliverables (text and/or URL)
+     *
+     * @example
+     * ```typescript
+     * await wallet.submitTask('task_123', {
+     *   text: 'Here is my research report...',
+     *   url: 'https://docs.google.com/document/d/...',
+     * });
+     * ```
+     */
+    submitTask(taskId: string, output: TaskOutput): Promise<void>;
+    /**
+     * Approve a submitted task and pay the agent.
+     *
+     * This will:
+     * - Calculate remaining budget (budget - spent on tools)
+     * - Transfer remaining budget to the agent's wallet
+     * - Mark the task as completed
+     * - Revoke the agent's session
+     *
+     * @param taskId - The task ID
+     * @returns Payout details
+     *
+     * @example
+     * ```typescript
+     * const result = await wallet.approveTask('task_123');
+     * console.log(`Paid agent $${result.payout.amountUsd}`);
+     * ```
+     */
+    approveTask(taskId: string): Promise<TaskApproveResult>;
+    /**
+     * Reject a task submission and send it back for revision.
+     *
+     * @param taskId - The task ID
+     * @param feedback - Optional feedback for the agent
+     */
+    rejectTaskSubmission(taskId: string, feedback?: string): Promise<void>;
+    /**
+     * Cancel a task you created.
+     *
+     * Can only cancel tasks in 'open' or 'claimed' status.
+     * If the task was claimed, the agent's session will be revoked.
+     *
+     * @param taskId - The task ID
+     */
+    cancelTask(taskId: string): Promise<void>;
+    /**
+     * Create a subtask under an existing task.
+     * Requires session key authentication.
+     * Budget is allocated from the parent task's remaining budget.
+     *
+     * @param options - Subtask creation options
+     * @returns The created subtask
+     *
+     * @example
+     * ```typescript
+     * const subtask = await wallet.createSubtask({
+     *   parentTaskId: 'task_123',
+     *   title: 'Research competitor pricing',
+     *   description: 'Find pricing info for top 5 competitors',
+     *   budgetUsd: 10,
+     * });
+     * ```
+     */
+    createSubtask(options: CreateSubtaskOptions): Promise<Task>;
+    /**
+     * Update the status of a task.
+     * Requires session key authentication.
+     * Creates an audit trail via TaskStatusUpdate records.
+     *
+     * @param taskId - The task ID
+     * @param status - New status
+     * @param note - Optional note explaining the status change
+     * @returns The updated task
+     *
+     * @example
+     * ```typescript
+     * await wallet.updateTaskStatus('task_123', 'submitted', 'All deliverables completed');
+     * ```
+     */
+    updateTaskStatus(taskId: string, status: TaskStatus, note?: string, idempotencyKey?: string): Promise<Task>;
+    /**
+     * Get subtasks of a task.
+     * Requires session key authentication.
+     *
+     * @param taskId - The parent task ID
+     * @returns List of subtasks
+     *
+     * @example
+     * ```typescript
+     * const subtasks = await wallet.getSubtasks('task_123');
+     * console.log(`Found ${subtasks.length} subtasks`);
+     * ```
+     */
+    getSubtasks(taskId: string): Promise<Task[]>;
+    /**
+     * Get the status history of a task.
+     * Requires session key authentication.
+     *
+     * @param taskId - The task ID
+     * @returns Status history with audit trail
+     *
+     * @example
+     * ```typescript
+     * const history = await wallet.getTaskStatusHistory('task_123');
+     * for (const entry of history.history) {
+     *   console.log(`${entry.oldStatus} -> ${entry.newStatus}: ${entry.note}`);
+     * }
+     * ```
+     */
+    getTaskStatusHistory(taskId: string): Promise<TaskStatusHistory>;
+    /**
+     * Request approval from a human user for an action.
+     * Returns immediately if the action is auto-approved.
+     *
+     * @param options - Approval request options
+     * @returns Approval request or auto-approval result
+     *
+     * @example
+     * ```typescript
+     * const result = await wallet.requestApproval({
+     *   actionType: 'external_communication',
+     *   actionPayload: { recipient: 'user@example.com', message: 'Hello!' },
+     *   context: 'Sending welcome email to new customer',
+     * });
+     *
+     * if ('autoApproved' in result) {
+     *   console.log('Auto-approved:', result.reason);
+     * } else {
+     *   console.log('Waiting for approval:', result.id);
+     * }
+     * ```
+     */
+    requestApproval(options: RequestApprovalOptions): Promise<ApprovalRequest | AutoApprovalResult>;
+    /**
+     * Check the status of an approval request.
+     *
+     * @param requestId - The approval request ID
+     * @returns Current status of the request
+     *
+     * @example
+     * ```typescript
+     * const status = await wallet.checkApprovalStatus('req_123');
+     * if (status.status === 'approved') {
+     *   console.log('Approved! Proceeding with action...');
+     * }
+     * ```
+     */
+    checkApprovalStatus(requestId: string): Promise<{
+        requestId: string;
+        status: ApprovalStatus;
+        responseNote?: string;
+        approvalScope?: ApprovalScope;
+        respondedAt?: Date;
+    }>;
+    /**
+     * Check if an action type needs approval before execution.
+     *
+     * @param actionType - The type of action to check
+     * @param amountUsd - Optional amount for spend actions
+     * @returns Whether approval is needed
+     *
+     * @example
+     * ```typescript
+     * const check = await wallet.checkActionPermission('external_communication');
+     * if (check.needsApproval) {
+     *   const approval = await wallet.requestApproval({ ... });
+     * }
+     * ```
+     */
+    checkActionPermission(actionType: string, amountUsd?: number): Promise<PermissionCheckResult>;
+    /**
+     * Wait for an approval request to be resolved.
+     * Polls the status until approved, rejected, or expired.
+     *
+     * @param requestId - The approval request ID
+     * @param options - Polling options
+     * @returns Final status of the request
+     *
+     * @example
+     * ```typescript
+     * const approval = await wallet.requestApproval({ ... });
+     * if (!('autoApproved' in approval)) {
+     *   const result = await wallet.waitForApproval(approval.id, { timeoutMs: 60000 });
+     *   if (result.status === 'approved') {
+     *     // Proceed with action
+     *   }
+     * }
+     * ```
+     */
+    waitForApproval(requestId: string, options?: {
+        pollIntervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<{
+        requestId: string;
+        status: ApprovalStatus;
+        responseNote?: string;
+        approvalScope?: ApprovalScope;
+    }>;
+    /** Helper to parse approval request from API response */
+    private parseApprovalRequest;
+    /** Helper to parse task from API response */
+    private parseTask;
+    /** Helper to call our API with auth */
+    private callApi;
+}
+/** Task status */
+type TaskStatus = 'open' | 'claimed' | 'submitted' | 'completed' | 'cancelled' | 'completing';
+/** Task creator or agent info */
+interface TaskAgent {
+    id: string;
+    displayName?: string;
+    isAgent: boolean;
+    walletAddress?: string;
+}
+/** Task details */
+interface Task {
+    id: string;
+    title: string;
+    description: string;
+    deliverables: string[];
+    category?: string;
+    budgetUsd: number;
+    listingFeeUsd: number;
+    status: TaskStatus;
+    createdAt: Date;
+    updatedAt?: Date;
+    expiresAt?: Date;
+    claimedAt?: Date;
+    submittedAt?: Date;
+    completedAt?: Date;
+    creator?: TaskAgent;
+    assignedAgent?: TaskAgent;
+    requestCount?: number;
+    output?: TaskOutput;
+    payment?: TaskPaymentInfo;
+}
+/** Task output (deliverables) */
+interface TaskOutput {
+    text?: string;
+    url?: string;
+}
+/** Task payment info */
+interface TaskPaymentInfo {
+    amountSpentUsd?: number;
+    amountPaidUsd?: number;
+    payoutTxHash?: string;
+}
+/** Parameters for creating a task */
+interface CreateTaskParams {
+    title: string;
+    description: string;
+    budgetUsd: number;
+    deliverables?: string[];
+    category?: string;
+    expiresInDays?: number;
+}
+/** Parameters for listing tasks */
+interface ListTasksParams {
+    status?: 'open' | 'all';
+    category?: string;
+    minBudget?: number;
+    maxBudget?: number;
+    limit?: number;
+    offset?: number;
+}
+/** Task list pagination */
+interface TaskPagination {
+    total: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+/** Task list result */
+interface TaskListResult {
+    tasks: Task[];
+    pagination: TaskPagination;
+}
+/** Task request from an agent */
+interface TaskRequest {
+    id: string;
+    taskId: string;
+    status: string;
+    message?: string | null;
+    createdAt: Date;
+}
+/** Task request with agent info */
+interface TaskRequestWithAgent extends TaskRequest {
+    reviewedAt?: Date;
+    agent: TaskAgent;
+}
+/** Result from accepting a task request */
+interface TaskAcceptResult {
+    success: boolean;
+    task: {
+        id: string;
+        status: string;
+        agentUserId: string;
+    };
+    session: {
+        id: string;
+        /** The session key string (sk_live_...) - agent needs this to make API calls */
+        sessionKey: string;
+        /** The derived public address for this session */
+        address: string;
+        expiresAt: Date;
+        budgetUsd: number;
+        allowedMerchants: string[];
+    };
+    invite: {
+        id: string;
+        code: string;
+    };
+    listingFeeTxHash?: string;
+}
+/** Result from approving a task */
+interface TaskApproveResult {
+    success: boolean;
+    task: {
+        id: string;
+        status: string;
+        completedAt: Date;
+    };
+    payout: {
+        status: 'paid' | 'insufficient_funds' | 'nothing_remaining' | 'error';
+        amountUsd: number;
+        txHash?: string;
+    };
+}
+/** Options for fetching user's own tasks */
+interface MyTasksOptions {
+    /** Filter by role: 'creator' (tasks you created), 'agent' (tasks assigned to you), 'all' (default) */
+    role?: 'creator' | 'agent' | 'all';
+    /** Filter by task status */
+    status?: TaskStatus;
+    /** Page number (default: 1) */
+    page?: number;
+    /** Items per page (default: 20, max: 100) */
+    limit?: number;
+}
+/** Options for creating a subtask */
+interface CreateSubtaskOptions {
+    /** Parent task ID */
+    parentTaskId: string;
+    /** Subtask title */
+    title: string;
+    /** Subtask description */
+    description: string;
+    /** List of deliverables */
+    deliverables?: string[];
+    /** Category (inherits from parent if not specified) */
+    category?: string;
+    /** Budget in USD (allocated from parent) */
+    budgetUsd: number;
+    /** Whether this subtask can spawn sub-agents */
+    allowSubAgents?: boolean;
+    /** Days until expiration (default: 7) */
+    expiresInDays?: number;
+    /** Idempotency key for duplicate prevention */
+    idempotencyKey?: string;
+}
+/** Task status history entry */
+interface TaskStatusHistoryEntry {
+    id: string;
+    oldStatus: string;
+    newStatus: string;
+    note?: string;
+    createdAt: Date;
+}
+/** Task status history result */
+interface TaskStatusHistory {
+    taskId: string;
+    currentStatus: TaskStatus;
+    history: TaskStatusHistoryEntry[];
+}
+/** Options for requesting approval */
+interface RequestApprovalOptions {
+    /** Type of action needing approval (e.g., 'external_communication', 'final_output', 'spend') */
+    actionType: string;
+    /** Details of the action */
+    actionPayload: Record<string, unknown>;
+    /** Additional context for the human reviewer */
+    context?: string;
+    /** Hours until the request expires (default: 24, max: 168) */
+    expiresInHours?: number;
+    /** Idempotency key for duplicate prevention */
+    idempotencyKey?: string;
+}
+/** Approval request status */
+type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired';
+/** Approval scope */
+type ApprovalScope = 'once' | 'session' | 'always';
+/** Approval request result */
+interface ApprovalRequest {
+    id: string;
+    actionType: string;
+    actionPayload: Record<string, unknown>;
+    context?: string;
+    status: ApprovalStatus;
+    responseNote?: string;
+    approvalScope: ApprovalScope;
+    createdAt: Date;
+    expiresAt: Date;
+    respondedAt?: Date;
+}
+/** Auto-approval result */
+interface AutoApprovalResult {
+    autoApproved: true;
+    reason: string;
+}
+/** Permission check result */
+interface PermissionCheckResult {
+    actionType: string;
+    needsApproval: boolean;
+    reason: string;
+}
+/** Task with user relationship info */
+interface MyTask extends Task {
+    /** Whether the current user created this task */
+    isCreator: boolean;
+    /** Whether the current user is the assigned agent */
+    isAgent: boolean;
+}
+/** Result from fetching user's tasks */
+interface MyTasksResult {
+    tasks: MyTask[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
 }
 /**
  * MCP Tool definition returned by listMCPTools()
@@ -1381,8 +2098,8 @@ interface AgentRunConfig {
  * Options for running an agent
  */
 interface AgentRunOptions {
-    /** Session ID for authentication and billing */
-    sessionId: string;
+    /** Session ID for authentication and billing (optional when using session key auth) */
+    sessionId?: string;
     /** Conversation messages */
     messages: AgentMessage[];
     /** Agent configuration */
@@ -1947,4 +2664,4 @@ declare function isMixrPayError(error: unknown): error is MixrPayError;
  */
 declare function getErrorMessage(error: unknown): string;
 
-export { type AgentMessage, type AgentRunConfig, type AgentRunEvent, type AgentRunOptions, type AgentRunResult, type AgentRunStatusResult, AgentWallet, type AgentWalletConfig, type CallMerchantApiOptions, type ChargeResult, type DiagnosticsResult, InsufficientBalanceError, InvalidSessionKeyError, MerchantNotAllowedError, MixrPayError, type PaymentEvent, PaymentFailedError, SDK_VERSION, type SessionAuthorization, SessionExpiredError, SessionKeyExpiredError, type SessionKeyInfo, SessionLimitExceededError, SessionNotFoundError, SessionRevokedError, type SessionStats, SpendingLimitExceededError, type SpendingStats, X402ProtocolError, getErrorMessage, isMixrPayError };
+export { type AgentClaimInviteOptions, type AgentClaimInviteResult, type AgentMessage, type AgentRunConfig, type AgentRunEvent, type AgentRunOptions, type AgentRunResult, type AgentRunStatusResult, AgentWallet, type AgentWalletConfig, type AvailableBudget, type CallMerchantApiOptions, type ChargeResult, type ChildSession, type DiagnosticsResult, InsufficientBalanceError, InvalidSessionKeyError, MerchantNotAllowedError, MixrPayError, type PaymentEvent, PaymentFailedError, SDK_VERSION, type SessionAuthorization, SessionExpiredError, SessionKeyExpiredError, type SessionKeyInfo, SessionLimitExceededError, SessionNotFoundError, SessionRevokedError, type SessionStats, type SpawnChildOptions, type SpawnChildResult, SpendingLimitExceededError, type SpendingStats, X402ProtocolError, getErrorMessage, isMixrPayError };