@wzrd_sol/eliza-plugin 0.1.2 → 0.3.0

package/dist/actions/rewards.js

@@ -0,0 +1,31 @@
+import { getWzrdClient } from '../client-factory.js';
+export const rewardsAction = {
+    name: 'WZRD_REWARDS',
+    similes: ['WZRD_BALANCE', 'CHECK_REWARDS', 'MY_CCM'],
+    description: 'Check your pending CCM rewards, lifetime total, rank, and contribution count.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'How much CCM have I earned?' } },
+            { name: '{{agentName}}', content: { text: 'Pending: 142.5 CCM. Lifetime: 326,000 CCM. Rank #3.' } },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, _msg, _state, _opt, callback) => {
+        const client = getWzrdClient(runtime);
+        try {
+            const rewards = await client.getRewards();
+            const text = `WZRD Rewards:\n` +
+                `Pending: ${(rewards.pending_ccm / 1e9).toFixed(2)} CCM\n` +
+                `Lifetime: ${(rewards.total_rewarded_ccm / 1e9).toFixed(2)} CCM\n` +
+                `Contributions: ${rewards.contribution_count}\n` +
+                (rewards.rank ? `Rank: #${rewards.rank}` : 'Rank: unranked');
+            await callback?.({ text });
+            return { success: true, data: rewards };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Failed to fetch rewards: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/actions/verify-receipt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * WZRD_VERIFY_RECEIPT — Offline leaf + Ed25519 verification (no network).
+ * Handles both V5 and V6 receipts; the SDK selects the leaf binding from the
+ * receipt's domain (V6 binds the reputation_* provenance fields into the leaf).
+ */
+import type { Action } from '@elizaos/core';
+export declare const verifyReceiptAction: Action;

package/dist/actions/verify-receipt.js

@@ -0,0 +1,44 @@
+import { verifyReceipt } from '@wzrd_sol/sdk';
+import { getIntelBase, parseReceipt, withTimeout } from '../intel-helpers.js';
+export const verifyReceiptAction = {
+    name: 'WZRD_VERIFY_RECEIPT',
+    similes: ['WZRD_VERIFY', 'VERIFY_TWZRD_RECEIPT', 'CHECK_RECEIPT'],
+    description: 'Offline verify a TwzrdReceipt (V5 or V6): recompute keccak leaf from preimage and check Ed25519 signature ' +
+        'against the published TWZRD key. No network required when trustedPubkey is known.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Verify this receipt: {"version":"v5","leaf":"0x...","preimage":{...}}' } },
+            { name: '{{agentName}}', content: { text: 'Receipt valid: leaf OK, signature OK.' } },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = (message.content ?? {});
+        const receipt = parseReceipt(content);
+        if (!receipt) {
+            await callback?.({
+                text: 'Provide a TwzrdReceipt as JSON in text or as content.receipt.',
+            });
+            return { success: false, error: 'Missing receipt' };
+        }
+        const apiBase = getIntelBase(runtime);
+        const fetchPubkey = content.fetch_pubkey === true || content.fetchPubkey === true;
+        try {
+            const result = await withTimeout(() => verifyReceipt(receipt, { apiBase, fetchPubkey }));
+            const text = result.valid
+                ? `Receipt VALID (leaf=${result.leafValid}, sig=${result.signatureValid}, key=${result.trustedPubkey})`
+                : `Receipt INVALID: ${result.errors.join('; ') || 'unknown error'}`;
+            await callback?.({ text });
+            return {
+                success: result.valid,
+                data: result,
+                error: result.valid ? undefined : result.errors.join('; '),
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Verify failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/client-factory.d.ts

@@ -0,0 +1,14 @@
+import { WzrdClient } from './client.js';
+import type { IAgentRuntime } from '@elizaos/core';
+import { intelPreflight, verifyReceipt } from '@wzrd_sol/sdk';
+/** Intel API base URL from runtime settings (default https://intel.twzrd.xyz). */
+export declare function getIntelApiBase(runtime: IAgentRuntime): string;
+export declare function getWzrdClient(runtime: IAgentRuntime): WzrdClient;
+/** Reset client cache — useful for tests. */
+export declare function clearClientCache(): void;
+/** Intel client (per plan): reads WZRD_INTEL_URL + paying fetch; thin delegate to SDK. */
+export declare function getIntelClient(runtime: IAgentRuntime): {
+    preflight: (input: Parameters<typeof intelPreflight>[0]) => Promise<import("@wzrd_sol/sdk").PreflightResponse>;
+    trust: (pubkey: string) => Promise<import("@wzrd_sol/sdk").IntelTrustResponse>;
+    verify: (receipt: Parameters<typeof verifyReceipt>[0], opts?: Parameters<typeof verifyReceipt>[1]) => Promise<import("@wzrd_sol/sdk").VerifyReceiptResult>;
+};

package/dist/client-factory.js

@@ -0,0 +1,40 @@
+/** Extract keypair from ElizaOS runtime, return cached WzrdClient. */
+import { Keypair } from '@solana/web3.js';
+import { WzrdClient } from './client.js';
+import { getIntelBase, withTimeout } from './intel-helpers.js';
+import { resolvePayingFetch } from './paying-fetch.js';
+import { intelPreflight, fetchIntelTrust, verifyReceipt } from '@wzrd_sol/sdk';
+const cache = new Map();
+/** Intel API base URL from runtime settings (default https://intel.twzrd.xyz). */
+export function getIntelApiBase(runtime) {
+    return getIntelBase(runtime);
+}
+export function getWzrdClient(runtime) {
+    const sk = runtime.getSetting('SOLANA_PRIVATE_KEY');
+    if (!sk)
+        throw new Error('SOLANA_PRIVATE_KEY not configured in ElizaOS runtime');
+    const kp = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(String(sk))));
+    const pub = kp.publicKey.toBase58();
+    if (!cache.has(pub)) {
+        const apiUrl = runtime.getSetting('WZRD_API_URL');
+        cache.set(pub, new WzrdClient(kp, typeof apiUrl === 'string' ? apiUrl : undefined));
+    }
+    return cache.get(pub);
+}
+/** Reset client cache — useful for tests. */
+export function clearClientCache() {
+    cache.clear();
+}
+/** Intel client (per plan): reads WZRD_INTEL_URL + paying fetch; thin delegate to SDK. */
+export function getIntelClient(runtime) {
+    const apiBase = getIntelApiBase(runtime);
+    return {
+        preflight: (input) => withTimeout(() => intelPreflight(input, apiBase)),
+        trust: (pubkey) => withTimeout((signal) => {
+            const f = resolvePayingFetch(runtime);
+            const abortingFetch = ((input, init) => f(input, { ...(init || {}), signal }));
+            return fetchIntelTrust(pubkey, { apiBase, fetchImpl: abortingFetch });
+        }),
+        verify: (receipt, opts) => withTimeout(() => verifyReceipt(receipt, { apiBase, ...(opts || {}) })),
+    };
+}

package/dist/client.d.ts

@@ -1,3 +1,91 @@
-import { WzrdClient } from '@wzrd_sol/solana-agent-plugin';
-import type { IAgentRuntime } from '@elizaos/core';
-export declare function getWzrdClient(runtime: IAgentRuntime): WzrdClient;
+/**
+ * Standalone WZRD API client for ElizaOS agents.
+ * No external dependencies beyond @solana/web3.js for Ed25519 signing.
+ *
+ * Auth flow: challenge → sign → verify → Bearer token (24h TTL)
+ * Earn flow: infer → report(execution_id) → claim
+ */
+import { Keypair } from '@solana/web3.js';
+export interface InferResult {
+    execution_id: string;
+    executed_model: string;
+    requested_model: string;
+    provider: string;
+    quality_score: number;
+    response_preview: string;
+    latency_ms: number;
+    cost_usd?: number;
+}
+export interface ReportResult {
+    contribution_id: number;
+    verification_state: string;
+    lifetime_contributions: number;
+    pending_ccm: number;
+    pipeline_state: string;
+    idempotent: boolean;
+    provider_receipt_present: boolean;
+}
+export interface RewardsBalance {
+    pending_ccm: number;
+    total_rewarded_ccm: number;
+    rank: number | null;
+    contribution_count: number;
+}
+export interface ClaimResult {
+    tx_sig: string | null;
+    root_seq: number;
+    cumulative_total: number;
+    status: string;
+}
+export interface LeaderboardResult {
+    market_count: number;
+    total_tvl: number;
+    root: {
+        root_seq: number;
+    };
+    markets: Array<{
+        market_id: number;
+        metric: string;
+        platform: string;
+        velocity_ema: number;
+        multiplier_bps: number;
+        snapshot_count: number;
+    }>;
+}
+export declare class WzrdClient {
+    private keypair;
+    private apiUrl;
+    private token;
+    private tokenExpiry;
+    constructor(keypair: Keypair, apiUrl?: string);
+    get pubkey(): string;
+    /** Ed25519 challenge → sign → verify → Bearer token */
+    private authenticate;
+    /** Authenticated fetch helper */
+    private authedFetch;
+    /** Pick a model from the momentum signal — returns top model's channel_id */
+    pickModel(taskType?: string): Promise<string>;
+    /** Server-witnessed inference — WZRD calls the provider, grades quality */
+    infer(prompt: string, model?: string, taskType?: string): Promise<InferResult>;
+    /** Report model pick with execution_id for verified rewards */
+    report(params: {
+        model_id: string;
+        execution_id: string;
+        task_type?: string;
+        quality_score?: number;
+        latency_ms?: number;
+    }): Promise<ReportResult>;
+    /** Check pending + total rewards (flattens nested /v1/agent/earned response) */
+    getRewards(): Promise<RewardsBalance>;
+    /** Gasless CCM claim via server relay */
+    claimRelay(): Promise<ClaimResult>;
+    /** Public: fetch leaderboard (no auth) */
+    getLeaderboard(limit?: number): Promise<LeaderboardResult>;
+    /** Public: fetch claims status */
+    getClaimStatus(): Promise<{
+        cumulative_total: number;
+        claimed_total: number;
+        claimable: number;
+    }>;
+}
+export { intelPreflight as intelPreflightClient, fetchIntelTrust as fetchIntelTrustClient, verifyReceipt as verifyReceiptClient, } from '@wzrd_sol/sdk';

package/dist/client.js

@@ -1,17 +1,137 @@
-/** Shared helper: extract wallet from ELIZA runtime, return cached WzrdClient. */
-import { Keypair } from '@solana/web3.js';
-import { WzrdClient } from '@wzrd_sol/solana-agent-plugin';
-const DEFAULT_API_URL = 'https://api.twzrd.xyz';
-const cache = new Map();
-export function getWzrdClient(runtime) {
-    const sk = runtime.getSetting('SOLANA_PRIVATE_KEY');
-    if (!sk)
-        throw new Error('SOLANA_PRIVATE_KEY not configured in ELIZA runtime');
-    const kp = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(String(sk))));
-    const pub = kp.publicKey.toBase58();
-    if (!cache.has(pub)) {
-        const apiUrl = runtime.getSetting('WZRD_API_URL');
-        cache.set(pub, new WzrdClient(kp, (typeof apiUrl === 'string' ? apiUrl : undefined) || DEFAULT_API_URL));
-    }
-    return cache.get(pub);
+import nacl from 'tweetnacl';
+import bs58 from 'bs58';
+const DEFAULT_API = 'https://api.twzrd.xyz';
+export class WzrdClient {
+    keypair;
+    apiUrl;
+    token = null;
+    tokenExpiry = 0;
+    constructor(keypair, apiUrl) {
+        this.keypair = keypair;
+        this.apiUrl = apiUrl || DEFAULT_API;
+    }
+    get pubkey() {
+        return this.keypair.publicKey.toBase58();
+    }
+    /** Ed25519 challenge → sign → verify → Bearer token */
+    async authenticate() {
+        if (this.token && Date.now() < this.tokenExpiry)
+            return this.token;
+        // 1. Get challenge
+        const challengeRes = await fetch(`${this.apiUrl}/v1/agent/challenge`);
+        if (!challengeRes.ok)
+            throw new Error(`Challenge failed: ${challengeRes.status}`);
+        const { nonce } = await challengeRes.json();
+        // 2. Construct message locally (must match server's agent_auth_message format)
+        const message = `wzrd-agent-auth v1 | wallet:${this.pubkey} | nonce:${nonce}`;
+        const messageBytes = new TextEncoder().encode(message);
+        const signature = nacl.sign.detached(messageBytes, this.keypair.secretKey);
+        // 3. Verify — signature must be base58-encoded (Solana Signature format)
+        const verifyRes = await fetch(`${this.apiUrl}/v1/agent/verify`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                pubkey: this.pubkey,
+                nonce,
+                signature: bs58.encode(signature),
+            }),
+        });
+        if (!verifyRes.ok)
+            throw new Error(`Verify failed: ${verifyRes.status}`);
+        const { token } = await verifyRes.json();
+        this.token = token;
+        this.tokenExpiry = Date.now() + 23 * 60 * 60 * 1000; // refresh 1h before 24h expiry
+        return token;
+    }
+    /** Authenticated fetch helper */
+    async authedFetch(path, init) {
+        const token = await this.authenticate();
+        const headers = new Headers(init?.headers);
+        headers.set('Authorization', `Bearer ${token}`);
+        headers.set('Content-Type', 'application/json');
+        return fetch(`${this.apiUrl}${path}`, { ...init, headers });
+    }
+    /** Pick a model from the momentum signal — returns top model's channel_id */
+    async pickModel(taskType) {
+        const res = await fetch(`${this.apiUrl}/v1/signals/momentum?limit=10&trending=true`);
+        if (!res.ok)
+            throw new Error(`Momentum fetch failed: ${res.status}`);
+        const data = await res.json();
+        if (!data.models?.length)
+            throw new Error('No models available in momentum feed');
+        // Return the top-ranked model's channel_id (e.g. "moonshotai/Kimi-K2.5")
+        return data.models[0].model;
+    }
+    /** Server-witnessed inference — WZRD calls the provider, grades quality */
+    async infer(prompt, model, taskType) {
+        const resolvedModel = model || await this.pickModel(taskType);
+        const res = await this.authedFetch('/v1/agent/infer', {
+            method: 'POST',
+            body: JSON.stringify({ model: resolvedModel, prompt, task_type: taskType || 'chat' }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Infer failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Report model pick with execution_id for verified rewards */
+    async report(params) {
+        const res = await this.authedFetch('/v1/agent/report', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Report failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Check pending + total rewards (flattens nested /v1/agent/earned response) */
+    async getRewards() {
+        const res = await this.authedFetch('/v1/agent/earned');
+        if (!res.ok)
+            throw new Error(`Rewards check failed: ${res.status}`);
+        const data = await res.json();
+        const economy = data.economy;
+        const routing = data.routing;
+        return {
+            pending_ccm: Number(economy?.pending_ccm ?? 0),
+            total_rewarded_ccm: Number(economy?.earned_ccm ?? 0),
+            rank: null, // rank not in this endpoint
+            contribution_count: Number(routing?.lifetime_contributions ?? 0),
+        };
+    }
+    /** Gasless CCM claim via server relay */
+    async claimRelay() {
+        const res = await this.authedFetch(`/v1/claims/${this.pubkey}/relay`, {
+            method: 'POST',
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Claim relay failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Public: fetch leaderboard (no auth) */
+    async getLeaderboard(limit = 20) {
+        const res = await fetch(`${this.apiUrl}/v1/leaderboard?limit=${limit}`);
+        if (!res.ok)
+            throw new Error(`Leaderboard failed: ${res.status}`);
+        return res.json();
+    }
+    /** Public: fetch claims status */
+    async getClaimStatus() {
+        const res = await this.authedFetch(`/v1/claims/${this.pubkey}`);
+        if (!res.ok) {
+            if (res.status === 404)
+                return { cumulative_total: 0, claimed_total: 0, claimable: 0 };
+            throw new Error(`Claim status failed: ${res.status}`);
+        }
+        const data = await res.json();
+        return { ...data, claimable: data.cumulative_total - data.claimed_total };
+    }
 }
+// Thin wrappers delegating to @wzrd_sol/sdk intel surface (preflight/trust/verify) per plan.
+// Kept in client.ts alongside earn WzrdClient. Actual runtime client for intel is via getIntelClient() in factory.
+export { intelPreflight as intelPreflightClient, fetchIntelTrust as fetchIntelTrustClient, verifyReceipt as verifyReceiptClient, } from '@wzrd_sol/sdk';

package/dist/index.d.ts

@@ -1,16 +1,33 @@
 /**
- * @wzrd_sol/eliza-plugin — WZRD Liquid Attention Protocol for ElizaOS.
- * Thin adapter wrapping @wzrd_sol/solana-agent-plugin's WzrdClient.
+ * @wzrd_sol/eliza-plugin — WZRD Agent Intel + Earn Loop for ElizaOS
  *
- * Config (runtime.getSetting): SOLANA_PRIVATE_KEY (required), WZRD_API_URL, SOLANA_RPC_URL
+ * Intel lane (default https://intel.twzrd.xyz):
+ *   WZRD_INTEL_PREFLIGHT → WZRD_INTEL_TRUST → WZRD_VERIFY_RECEIPT
+ * Paid intel requires caller-supplied x402 fetch via setPayingFetch().
+ *
+ * Earn lane (default https://api.twzrd.xyz):
+ *   WZRD_INFER → WZRD_REPORT → WZRD_EARN → WZRD_CLAIM / WZRD_REWARDS
+ *
+ * Config (runtime.getSetting):
+ *   SOLANA_PRIVATE_KEY  — required for earn tx/auth
+ *   WZRD_API_URL        — optional, defaults to https://api.twzrd.xyz
+ *   WZRD_INTEL_URL      — optional, defaults to https://intel.twzrd.xyz
  */
 import type { Plugin } from '@elizaos/core';
-import { leaderboardAction } from './actions/leaderboard.js';
-import { portfolioAction } from './actions/portfolio.js';
+import { inferAction } from './actions/infer.js';
+import { reportAction } from './actions/report.js';
+import { earnAction } from './actions/earn.js';
 import { claimAction } from './actions/claim.js';
-import { depositAction } from './actions/deposit.js';
-import { velocityAction } from './actions/velocity.js';
+import { rewardsAction } from './actions/rewards.js';
+import { intelPreflightAction } from './actions/intel-preflight.js';
+import { intelTrustAction } from './actions/intel-trust.js';
+import { verifyReceiptAction } from './actions/verify-receipt.js';
 export declare const wzrdPlugin: Plugin;
 export default wzrdPlugin;
-export { leaderboardAction, portfolioAction, claimAction, depositAction, velocityAction };
-export { getWzrdClient } from './client.js';
+export { intelPreflightAction, intelTrustAction, verifyReceiptAction, earnAction, inferAction, reportAction, claimAction, rewardsAction, };
+export { getWzrdClient, clearClientCache, getIntelApiBase, getIntelClient } from './client-factory.js';
+export { setPayingFetch, clearPayingFetch, resolvePayingFetch } from './paying-fetch.js';
+export { WzrdClient } from './client.js';
+export type { InferResult, ReportResult, RewardsBalance, ClaimResult } from './client.js';
+export { IntelPaymentRequiredError, intelPreflight, fetchIntelTrust, verifyReceipt, preSpendGate, intelTrustUrl, TRUSTED_RECEIPT_PUBKEY, INTEL_TRUST_PRICE_USDC, } from '@wzrd_sol/sdk';
+export type { ReadinessCard, PreflightInput, PreflightResponse, TwzrdReceipt, IntelTrustResponse, VerifyReceiptResult, X402PaymentRequired, } from '@wzrd_sol/sdk';

package/dist/index.js

@@ -1,14 +1,30 @@
-import { leaderboardAction } from './actions/leaderboard.js';
-import { portfolioAction } from './actions/portfolio.js';
+import { inferAction } from './actions/infer.js';
+import { reportAction } from './actions/report.js';
+import { earnAction } from './actions/earn.js';
 import { claimAction } from './actions/claim.js';
-import { depositAction } from './actions/deposit.js';
-import { velocityAction } from './actions/velocity.js';
+import { rewardsAction } from './actions/rewards.js';
+import { intelPreflightAction } from './actions/intel-preflight.js';
+import { intelTrustAction } from './actions/intel-trust.js';
+import { verifyReceiptAction } from './actions/verify-receipt.js';
 export const wzrdPlugin = {
     name: 'wzrd',
-    description: 'WZRD Liquid Attention Protocol — deposit USDC into AI attention markets, ' +
-        'earn CCM yield based on model velocity.',
-    actions: [leaderboardAction, portfolioAction, claimAction, depositAction, velocityAction],
+    description: 'WZRD Agent Intel — free ReadinessCard preflight (gates spends before paying), x402-paid trust receipts ' +
+        '(V5/V6), offline verification on intel.twzrd.xyz. Also ships the legacy earn loop (infer/report/claim) ' +
+        'on api.twzrd.xyz.',
+    actions: [
+        intelPreflightAction,
+        intelTrustAction,
+        verifyReceiptAction,
+        earnAction,
+        inferAction,
+        reportAction,
+        claimAction,
+        rewardsAction,
+    ],
 };
 export default wzrdPlugin;
-export { leaderboardAction, portfolioAction, claimAction, depositAction, velocityAction };
-export { getWzrdClient } from './client.js';
+export { intelPreflightAction, intelTrustAction, verifyReceiptAction, earnAction, inferAction, reportAction, claimAction, rewardsAction, };
+export { getWzrdClient, clearClientCache, getIntelApiBase, getIntelClient } from './client-factory.js';
+export { setPayingFetch, clearPayingFetch, resolvePayingFetch } from './paying-fetch.js';
+export { WzrdClient } from './client.js';
+export { IntelPaymentRequiredError, intelPreflight, fetchIntelTrust, verifyReceipt, preSpendGate, intelTrustUrl, TRUSTED_RECEIPT_PUBKEY, INTEL_TRUST_PRICE_USDC, } from '@wzrd_sol/sdk';

package/dist/intel-helpers.d.ts

@@ -0,0 +1,22 @@
+import { IntelPaymentRequiredError, type PreflightInput, type TwzrdReceipt } from '@wzrd_sol/sdk';
+export declare function getIntelBase(runtime: {
+    getSetting: (k: string) => string | boolean | number | null;
+}): string;
+/** Pull structured fields from Eliza message content (flat or JSON-in-text). */
+export declare function parsePreflightInput(content: Record<string, unknown>): PreflightInput;
+export declare function parseReceipt(content: Record<string, unknown>): TwzrdReceipt | null;
+export declare function extractPubkey(content: Record<string, unknown>): string | null;
+export declare function formatPaymentRequired(err: IntelPaymentRequiredError, apiBase: string, pubkey: string): string;
+/**
+ * Timeout wrapper for SDK network calls (preflight/trust/verify).
+ * Supports two call forms for minimal change:
+ * - withTimeout(promise) for preflight (SDK does not expose fetchImpl/signal)
+ * - withTimeout((signal) => sdkCallWithFetchImpl(abortingFetch)) for trust/verify
+ * Uses AbortController + signal: abort() is called on timeout so that when caller
+ * wires the returned signal into fetchImpl, the underlying network request is aborted.
+ * Always clears timer in finally (no leak). Attaches rejection observer to the
+ * call promise (without altering settlement) to avoid unhandled rejections on the
+ * loser of the race.
+ * Applied to actions + getIntelClient delegates.
+ */
+export declare function withTimeout<T>(pOrMake: Promise<T> | ((signal?: AbortSignal) => Promise<T>), ms?: number): Promise<T>;