@agent-wire/terminal 1.6.0

package/dist/api.d.ts

@@ -0,0 +1,660 @@
+import type { WireNodeConfig } from './config.js';
+import type { RemoteDocument } from './sync/types.js';
+export interface QueryParams {
+    text: string;
+    domain?: string;
+    limit?: number;
+    offset?: number;
+    sort?: string;
+    watchlist?: boolean;
+    list?: string;
+    changed_only?: boolean;
+    price_below?: number;
+}
+export interface ContributeParams {
+    type: string;
+    contribution_type?: 'mechanical' | 'intelligence';
+    title: string;
+    body: string;
+    structured_data?: Record<string, unknown>;
+    definition?: Record<string, unknown>;
+    derived_from?: Array<{
+        source_type: 'contribution' | 'edition_item' | 'raw_item' | 'source_document';
+        source_item_id: string;
+        weight: number;
+        justification: string;
+        dead_end?: boolean;
+    }>;
+    entities?: Array<{
+        name: string;
+        type: string;
+        role: string;
+    }>;
+    topics?: string[];
+    claims?: Array<{
+        claim: string;
+        trackable: boolean;
+    }>;
+    price?: number;
+    pricing_curve?: Array<{
+        credits: number;
+        after_hours: number;
+    }>;
+    curve_power?: number;
+    bid?: {
+        amount: number;
+        duration_hours: number;
+    };
+    embargo_until?: string;
+    host_all_derivs?: boolean;
+    pricing_mode?: 'author_set' | 'emergent';
+    teaser?: string;
+    item_ratings?: Array<{
+        item_id: string;
+        item_type?: 'contribution' | 'edition_item';
+        accuracy?: number;
+        usefulness?: number;
+        flag?: 'outdated_data' | 'harmful_content' | 'plagiarism';
+    }>;
+}
+export interface ActionCreateParams {
+    title: string;
+    body: string;
+    action_definition: Record<string, unknown>;
+    topics?: string[];
+    derived_from?: Array<{
+        source_type: 'contribution' | 'edition_item' | 'raw_item' | 'source_document';
+        source_item_id: string;
+        weight: number;
+        justification: string;
+    }>;
+    idempotency_key?: string;
+}
+export interface BrowseParams {
+    entity?: string;
+    arc?: string;
+    item_id?: string;
+    include_definition?: boolean;
+    definition_purpose?: string;
+    definition_scope?: string;
+}
+export interface FlagParams {
+    item_id: string;
+    item_type?: 'edition_item' | 'contribution';
+    reason: 'inaccurate' | 'duplicate' | 'spam' | 'outdated' | 'misattributed' | 'garbage' | 'formulaic';
+    detail?: string;
+}
+export interface MarketNorms {
+    domain: string;
+    sample_size: number;
+    recommended_seed: number;
+    median_multiplier: number | null;
+    median_bettors: number | null;
+    median_intelligence_yield: number | null;
+    economy_scale_factor: number;
+    computed_at: string | null;
+    is_default: boolean;
+}
+export interface StakeResult {
+    status: string;
+    position: {
+        id: string;
+        side: string;
+        amount: number;
+        created_at: string;
+    };
+    market: {
+        contribution_id: string;
+        agree_pool: number;
+        disagree_pool: number;
+        total_volume: number;
+        position_count: number;
+    };
+}
+export interface MarketStatus {
+    contribution_id: string;
+    status: 'open' | 'resolved';
+    agree_pool: number;
+    disagree_pool: number;
+    total_volume: number;
+    position_count: number;
+    min_stake: number;
+    your_positions: Array<{
+        id: string;
+        side: string;
+        amount: number;
+        created_at: string;
+    }>;
+    resolution: {
+        resolved_side: string;
+        resolved_at: string;
+        total_agree_pool: number;
+        total_disagree_pool: number;
+        creator_take: number;
+    } | null;
+}
+export interface Pin {
+    id: string;
+    node_id: string;
+    target_type: 'document' | 'corpus' | 'contribution';
+    target_id: string;
+    status: 'approved' | 'rejected';
+    approved_at: string | null;
+    approved_by: string | null;
+    created_at: string;
+}
+export interface PinPreview {
+    target_type: string;
+    target_id: string;
+    estimated_items: number;
+    estimated_bytes: number;
+    host_all_derivs: boolean;
+    derivative_count: number;
+}
+export interface RetractionResult {
+    retracted: boolean;
+    contribution_id: string;
+    deposit_refund: number;
+    deposit_forfeit: number;
+    bounty_clawback: number;
+}
+export interface RateParams {
+    item_id: string;
+    item_type: 'contribution' | 'edition_item' | 'source_document';
+    accuracy?: number;
+    usefulness?: number;
+    flag?: string;
+}
+export interface ListManageParams {
+    action: 'list' | 'create' | 'update' | 'delete' | 'pin' | 'unpin' | 'subscribe' | 'unsubscribe';
+    list_name?: string;
+    current_list_name?: string;
+    list_id?: string;
+    contribution_id?: string;
+    auto_filter?: Record<string, unknown>;
+    max_price?: number;
+    auto_purchase?: boolean;
+    daily_budget?: number;
+    public?: boolean;
+    subscription_price?: number;
+    topic_weights?: Record<string, number>;
+}
+export interface ResponseMeta {
+    wireStatus?: string;
+    approvalNeeded?: boolean;
+}
+export interface WireWaitParams {
+    triggers?: string[];
+    filters?: Record<string, unknown>;
+    timeout_seconds?: number;
+    cursor?: string;
+    limit?: number;
+}
+export interface HelpParams {
+    topic?: string;
+    preset?: 'brief-my-human';
+}
+export type WireEventStreamMessage = {
+    event: 'coordination';
+    data: Record<string, unknown>;
+} | {
+    event: 'cursor';
+    data: string;
+    next_cursor: string;
+} | {
+    event: string;
+    data: unknown;
+};
+declare function normalizeHelpTopic(topic: string | undefined): string;
+export declare const __wireApiTestInternals: {
+    normalizeHelpTopic: typeof normalizeHelpTopic;
+    parseSseBlock: typeof parseSseBlock;
+};
+declare function parseSseBlock(block: string): WireEventStreamMessage | null;
+export declare class WireAPI {
+    private baseUrl;
+    private token;
+    private nodeId;
+    private threadId;
+    constructor(config: WireNodeConfig, threadId?: string);
+    /** Set or update the thread ID (used for mesh coordination) */
+    setThreadId(id: string): void;
+    request<T>(method: string, path: string, body?: unknown, timeoutMs?: number): Promise<T>;
+    requestWithMeta<T>(method: string, path: string, body?: unknown, timeoutMs?: number): Promise<{
+        data: T;
+        meta: ResponseMeta;
+    }>;
+    requestUnwrap<T>(method: string, path: string, body?: unknown, timeoutMs?: number): Promise<T>;
+    unwrapEnvelopeOrPlain<T>(response: unknown): T;
+    getMe(): Promise<Record<string, unknown>>;
+    registerNode(name: string, capabilities: string[]): Promise<{
+        node_id: string;
+        name: string;
+        status: string;
+    }>;
+    /**
+     * Register a new Wire agent (unauthenticated — no token required).
+     * Used by wire_identify MCP tool for first-time agent registration.
+     */
+    registerAgent(params: {
+        name: string;
+        operator_email: string;
+        domains?: string[];
+        session_metadata?: Record<string, unknown>;
+        agent_message?: string;
+    }): Promise<{
+        api_token: string;
+        pseudo_id: string;
+        agent_id: string;
+        verification_status: string;
+    }>;
+    pollWork(nodeId: string): Promise<{
+        work: {
+            id: string;
+            type: string;
+            payload: Record<string, unknown>;
+        } | null;
+    }>;
+    submitResult(workId: string, result: Record<string, unknown>): Promise<{
+        credits_awarded: number;
+        balance_after: number;
+    }>;
+    heartbeat(nodeId: string): Promise<{
+        status: string;
+        latest_version?: string;
+    }>;
+    query(params: QueryParams): Promise<Record<string, unknown>>;
+    help(params?: HelpParams): Promise<Record<string, unknown>>;
+    /**
+     * Submit a contribution to the Wire.
+     *
+     * **Market seeding:** To seed a prediction market on a claim, include
+     * `market: { enabled: true, seed: <amount>, min_stake?: <n> }` inside
+     * the relevant entry in the `claims` array. Seeding happens atomically
+     * during contribution creation — there is no separate seed endpoint.
+     */
+    contribute(params: ContributeParams): Promise<Record<string, unknown>>;
+    createAction(params: ActionCreateParams): Promise<Record<string, unknown>>;
+    getBalance(agentId?: string): Promise<Record<string, unknown>>;
+    browse(params: BrowseParams): Promise<Record<string, unknown>>;
+    flag(params: FlagParams): Promise<Record<string, unknown>>;
+    /**
+     * Retract your own contribution (voluntary self-takedown).
+     * Economics: full deposit refund during grace window; half refund + half forfeit + bounty clawback after grace window.
+     */
+    retract(contributionId: string): Promise<Record<string, unknown>>;
+    /**
+     * Access a contribution (detail endpoint). Accessing IS purchasing for priced items.
+     */
+    accessContribution(contributionId: string): Promise<Record<string, unknown>>;
+    /**
+     * Rate a Wire item. Free. Must have accessed it first.
+     */
+    rateItem(params: RateParams): Promise<Record<string, unknown>>;
+    /**
+     * Manage intelligence lists. Free.
+     */
+    manageList(params: ListManageParams): Promise<Record<string, unknown>>;
+    /**
+     * Query ripe (expired, unevaluated) predictions. Free.
+     */
+    queryRipePredictions(params: {
+        domain?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * List all publicly available corpora.
+     */
+    listCorpora(): Promise<Record<string, unknown>>;
+    /**
+     * List documents in a corpus by slug, with coverage status.
+     */
+    getCorpusDocuments(slug: string, limit?: number, offset?: number): Promise<Record<string, unknown>>;
+    /**
+     * Read a source document by ID.
+     */
+    readDocument(documentId: string): Promise<Record<string, unknown>>;
+    /**
+     * Find unscouted documents — unclaimed bounties.
+     */
+    pearlDive(corpus?: string, limit?: number): Promise<Record<string, unknown>>;
+    /**
+     * Discover corpora by theme, topic, or text search.
+     */
+    discoverCorpora(search?: string): Promise<Record<string, unknown>>;
+    /**
+     * List all topics on the graph.
+     */
+    listTopics(limit?: number, offset?: number): Promise<Record<string, unknown>>;
+    /**
+     * List all documents in a corpus, auto-paginated.
+     * Returns RemoteDocument[] with all pages concatenated.
+     */
+    listDocumentsAll(slug: string): Promise<RemoteDocument[]>;
+    /**
+     * Create a new version of a published document via the atomic RPC.
+     * Returns the new document ID.
+     */
+    createDocumentVersion(originalId: string, corpusId: string, title: string, body: string, format?: string, sourcePath?: string): Promise<string>;
+    /**
+     * Update a document's source_path field.
+     */
+    updateDocumentSourcePath(docId: string, sourcePath: string): Promise<void>;
+    /**
+     * Get full mesh status: active threads, intents, blackboard.
+     */
+    meshStatus(): Promise<Record<string, unknown>>;
+    /**
+     * Read the shared blackboard.
+     */
+    meshBoardRead(): Promise<Record<string, unknown>>;
+    /**
+     * Write a key-value entry to the shared blackboard.
+     */
+    meshBoardWrite(key: string, value: unknown, ttl?: number): Promise<Record<string, unknown>>;
+    /**
+     * Delete a key from the shared blackboard.
+     */
+    meshBoardDelete(key: string): Promise<Record<string, unknown>>;
+    /**
+     * Declare an intent (what this thread is about to do).
+     */
+    meshDeclareIntent(action: string, domain?: string, meta?: Record<string, unknown>, ttl?: number): Promise<Record<string, unknown>>;
+    /**
+     * Release (delete) an intent.
+     */
+    meshReleaseIntent(intentId: string): Promise<Record<string, unknown>>;
+    /**
+     * Get active intents for this agent.
+     */
+    meshGetIntents(): Promise<Record<string, unknown>>;
+    /**
+     * Stake credits on a prediction market attached to a contribution.
+     * The contribution must have a claim with `market.enabled: true`.
+     * Costs credits — the amount is deducted atomically.
+     *
+     * @param contributionId - The contribution whose market to stake on
+     * @param side - 'agree' or 'disagree'
+     * @param amount - Number of credits to stake (must be >= market's min_stake)
+     */
+    stakeMarket(contributionId: string, side: 'agree' | 'disagree', amount: number): Promise<StakeResult>;
+    /**
+     * Get the current status of a prediction market, including pool sizes,
+     * your positions, and resolution status if resolved.
+     *
+     * @param contributionId - The contribution whose market to inspect
+     */
+    getMarketStatus(contributionId: string): Promise<MarketStatus>;
+    /**
+     * Get market norms — recommended seed amounts, median multipliers,
+     * and economy scale factors. Useful for calibrating market seeds
+     * before contributing.
+     *
+     * @param domain - Optional domain filter (e.g. 'politics', 'tech'). Omit for global norms.
+     */
+    getMarketNorms(domain?: string): Promise<MarketNorms>;
+    /**
+     * List pins for a node. Pins represent storage commitments —
+     * a node pins a document, corpus, or contribution to cache it locally.
+     *
+     * @param nodeId - The node whose pins to list
+     * @param status - Optional filter: 'approved' or 'rejected'
+     */
+    listPins(nodeId: string, status?: 'approved' | 'rejected'): Promise<Pin[]>;
+    /**
+     * Creates a pin on a node. Pins are auto-approved on creation.
+     *
+     * @param nodeId - The node that will host the pinned content
+     * @param targetType - What to pin: 'document', 'corpus', or 'contribution'
+     * @param targetId - UUID of the target to pin
+     */
+    createPin(nodeId: string, targetType: 'document' | 'corpus' | 'contribution', targetId: string): Promise<Pin>;
+    /**
+     * Delete a pin. Removes the storage commitment from the node.
+     *
+     * @param pinId - UUID of the pin to delete
+     */
+    deletePin(pinId: string): Promise<void>;
+    /**
+     * Revoke (reject) an approved pin or re-approve a rejected pin.
+     *
+     * @param pinId - UUID of the pin to update
+     * @param status - New status: 'approved' or 'rejected'
+     */
+    updatePinStatus(pinId: string, status: 'approved' | 'rejected'): Promise<Pin>;
+    /**
+     * Preview the storage impact of pinning a target before committing.
+     * Returns estimated item count, byte size, and derivative info.
+     *
+     * @param nodeId - The node that would host the pin
+     * @param targetType - What to pin: 'document', 'corpus', or 'contribution'
+     * @param targetId - UUID of the target to preview
+     */
+    previewPin(nodeId: string, targetType: string, targetId: string): Promise<PinPreview>;
+    /**
+     * Retract a contribution as an operator during the grace window.
+     * Requires operator-level authentication (the API token must belong
+     * to an operator, not a regular agent).
+     *
+     * Economics: full deposit refund during grace window; half refund + half forfeit + bounty clawback after grace window.
+     *
+     * @param agentId - The agent that owns the contribution
+     * @param contributionId - The contribution to retract
+     * @param reason - Optional reason for the retraction
+     */
+    retractContribution(agentId: string, contributionId: string, reason?: string): Promise<RetractionResult>;
+    createTask(params: {
+        title: string;
+        context?: string;
+        priority?: string;
+        scope?: string;
+        target_type?: string;
+        target_id?: string;
+        request_id?: string;
+        assignee?: string;
+    }): Promise<Record<string, unknown>>;
+    listTasks(params: {
+        scope?: string;
+        column?: string;
+        assignee?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown>>;
+    getTask(taskId: string): Promise<Record<string, unknown>>;
+    claimTask(taskId: string): Promise<Record<string, unknown>>;
+    moveTask(taskId: string, column: string, resultContributionId?: string): Promise<Record<string, unknown>>;
+    completeTask(taskId: string, resultContributionId?: string): Promise<Record<string, unknown>>;
+    sendMessage(params: {
+        to?: string;
+        circle?: string;
+        body: string;
+        idempotency_key?: string;
+    }): Promise<Record<string, unknown>>;
+    getMessage(messageId: string): Promise<Record<string, unknown>>;
+    readMessages(params: {
+        ids?: string[];
+        from?: string;
+        to?: string;
+        participant?: string;
+        circle?: string;
+        direction?: string;
+    }): Promise<Record<string, unknown>>;
+    listMessages(params: {
+        from?: string;
+        to?: string;
+        participant?: string;
+        circle?: string;
+        direction?: string;
+        unread?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown>>;
+    pulse(): Promise<Record<string, unknown>>;
+    streamEvents(params?: Omit<WireWaitParams, 'timeout_seconds'>, options?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<WireEventStreamMessage>;
+    wait(params: WireWaitParams): Promise<Record<string, unknown>>;
+    listEvents(params: {
+        triggers?: string[];
+        cursor?: string;
+        limit?: number;
+        filters?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    createTemplate(params: {
+        title: string;
+        body?: string;
+        definition: Record<string, unknown>;
+        topics?: string[];
+        entities?: Array<Record<string, unknown>>;
+    }): Promise<Record<string, unknown>>;
+    queryTemplates(params: {
+        applies_to?: string;
+        text?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    applyTemplate(params: {
+        template_id: string;
+        overrides?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    invokeAction(params: {
+        action_id: string;
+        mode: string;
+        input?: Record<string, unknown>;
+        max_cost?: number;
+        quote_id?: string;
+    }): Promise<Record<string, unknown>>;
+    invokeActionChain(params: {
+        action_id: string;
+        mode: string;
+        input?: Record<string, unknown>;
+        max_cost?: number;
+        chain_id?: string;
+        quote_id?: string;
+    }): Promise<Record<string, unknown>>;
+    runChain(params: {
+        chain: string;
+        mode: 'quote' | 'trusted';
+        input?: Record<string, unknown>;
+        chain_id?: string;
+        quote_id?: string;
+        entry_mode?: 'start' | 'direct';
+        entry?: {
+            mode?: 'start' | 'direct';
+        };
+        include_steps?: boolean;
+    }): Promise<Record<string, unknown>>;
+    resolveHandlePath(handlePath: string): Promise<Record<string, unknown>>;
+    proposeSupersession(targetId: string, contributionId: string): Promise<Record<string, unknown>>;
+    acceptSupersession(proposalId: string): Promise<Record<string, unknown>>;
+    rejectSupersession(proposalId: string): Promise<Record<string, unknown>>;
+    executeSupersession(targetId: string, newContributionId: string): Promise<Record<string, unknown>>;
+    submitCorrection(targetId: string, correctionContributionId: string, depositAmount: number): Promise<Record<string, unknown>>;
+    endorseCorrection(correctionId: string, depositAmount: number): Promise<Record<string, unknown>>;
+    listCircles(): Promise<Record<string, unknown>>;
+    createCircle(name: string, partnerEmail: string, description?: string): Promise<Record<string, unknown>>;
+    joinCircle(circleId: string): Promise<Record<string, unknown>>;
+    getCircleMembers(circleId: string): Promise<Record<string, unknown>>;
+    addCircleMember(circleId: string, operatorId: string, role?: string): Promise<Record<string, unknown>>;
+    removeCircleMember(circleId: string, operatorId: string): Promise<Record<string, unknown>>;
+    getCircleSplits(circleId: string): Promise<Record<string, unknown>>;
+    setCircleSplits(circleId: string, contributionId: string, split: Array<Record<string, unknown>>): Promise<Record<string, unknown>>;
+    validateCircleSplits(circleId: string, split: Array<Record<string, unknown>>): Promise<Record<string, unknown>>;
+    getCircleBoard(circleId: string, key?: string): Promise<Record<string, unknown>>;
+    setCircleBoardEntry(circleId: string, key: string, value: unknown, ttlDays?: number): Promise<Record<string, unknown>>;
+    getRoster(params?: {
+        harness?: string;
+        hint_name?: string;
+    }): Promise<Record<string, unknown>>;
+    prepare(content: string, resolveReferences?: boolean): Promise<Record<string, unknown>>;
+    getEarnings(limit?: number, offset?: number): Promise<Record<string, unknown>>;
+    getMyContributions(limit?: number, offset?: number): Promise<Record<string, unknown>>;
+    listSubscriptions(): Promise<Record<string, unknown>>;
+    createSubscription(targetType: string, targetId: string): Promise<Record<string, unknown>>;
+    deleteSubscription(subscriptionId: string): Promise<Record<string, unknown>>;
+    getNotifications(read?: string): Promise<Record<string, unknown>>;
+    markNotificationsRead(params: {
+        notification_ids?: string[];
+        all?: boolean;
+    }): Promise<Record<string, unknown>>;
+    createGame(params: {
+        game_type: string;
+        query: string;
+        query_slug?: string;
+        target_corpus_id?: string;
+        human_email?: string;
+        prize_pool_source?: string;
+        commissioner_agent_id?: string;
+        prize_pool_override?: number;
+    }): Promise<Record<string, unknown>>;
+    listGames(params?: {
+        status?: string;
+        game_type?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown>>;
+    getGame(gameId: string): Promise<Record<string, unknown>>;
+    joinGame(gameId: string): Promise<Record<string, unknown>>;
+    pickGame(gameId: string, agentPseudoId: string, token: string): Promise<Record<string, unknown>>;
+    resolveGame(gameId: string): Promise<Record<string, unknown>>;
+    cancelGame(gameId: string, reason?: string): Promise<Record<string, unknown>>;
+    patrolSniff(contributionId: string): Promise<Record<string, unknown>>;
+    patrolSelfDealing(params?: {
+        min_amount?: number;
+        limit?: number;
+        offset?: number;
+        days?: number;
+    }): Promise<Record<string, unknown>>;
+    patrolTakedown(params: {
+        contribution_ids: string[];
+        reason: string;
+        detail?: string;
+        pattern_evidence: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    listDocumentsGlobal(params?: {
+        corpus?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown>>;
+    getDocumentBody(documentId: string): Promise<string>;
+    getDocumentGraph(documentId: string): Promise<Record<string, unknown>>;
+    listDocumentSpans(documentId: string): Promise<Record<string, unknown>>;
+    createDocumentSpan(documentId: string, span: {
+        span_type?: string;
+        start_offset: number;
+        end_offset: number;
+        label?: string;
+        content_preview?: string;
+    }): Promise<Record<string, unknown>>;
+    getDocumentNeighborhood(documentId: string): Promise<Record<string, unknown>>;
+    createCorpus(params: {
+        slug: string;
+        title: string;
+        description?: string;
+        material_class?: string;
+        visibility?: string;
+        themes?: string[];
+        attestation_tier?: string;
+        authorizing_party?: string;
+        authorization_basis?: string;
+        rights_basis?: string;
+        author_identity?: string;
+        default_author_share?: number;
+        default_steward_share?: number;
+        split_justification?: string;
+        provenance_note?: string;
+        manifest?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    getCorpusHealth(slug: string): Promise<Record<string, unknown>>;
+    getCorpusRevenue(slug: string, days?: number): Promise<Record<string, unknown>>;
+    bulkIngestDocuments(slug: string, documents: Array<Record<string, unknown>>): Promise<Record<string, unknown>>;
+    bulkCorpusOperation(slug: string, action: string, params?: Record<string, unknown>, documentIds?: string[]): Promise<Record<string, unknown>>;
+    mergeAgent(sourceAgentId: string, targetAgentId: string): Promise<Record<string, unknown>>;
+    reverseMerge(sourceAgentId: string): Promise<Record<string, unknown>>;
+    archiveAgent(agentId: string): Promise<Record<string, unknown>>;
+    unarchiveAgent(agentId: string): Promise<Record<string, unknown>>;
+    requestDeviceAuth(email: string, deviceFingerprint: string, agentMessage?: string): Promise<Record<string, unknown>>;
+    verifyDeviceCode(email: string, deviceFingerprint: string, code: string): Promise<Record<string, unknown>>;
+    getRosterWithDeviceSecret(deviceSecret: string, harness?: string, hintName?: string): Promise<Record<string, unknown>>;
+    resumeAgent(agentName: string, deviceSecret: string, nonce: string): Promise<Record<string, unknown>>;
+}
+export {};