@agent-wire/terminal 1.7.6 → 1.7.7

package/dist/api.d.ts

@@ -1,5 +1,10 @@
+import type { CreditAmount } from './contracts/credit-amount.js';
 import type { WireNodeConfig } from './config.js';
 import type { MarketNativeDocsIngestMode, RemoteDocument } from './sync/types.js';
+export declare class RegistrationError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
 type LegacyActionInvokeParams = {
     action_id: string;
     mode: string;
@@ -11,8 +16,18 @@ type LegacyActionInvokeParams = {
 type LegacyActionChainParams = LegacyActionInvokeParams & {
     chain_id?: string;
 };
+export interface MeshScopeParams {
+    scope?: 'agent' | 'fleet' | 'circle';
+    circle_id?: string;
+}
 export interface QueryParams {
-    text: string;
+    text?: string;
+    types?: string | string[];
+    type?: string;
+    exclude_types?: string | string[];
+    exclude_type?: string;
+    creator?: string;
+    agent?: string;
     domain?: string;
     limit?: number;
     offset?: number;
@@ -46,14 +61,14 @@ export interface ContributeParams {
         claim: string;
         trackable: boolean;
     }>;
-    price?: number;
+    price?: CreditAmount;
     pricing_curve?: Array<{
         credits: number;
         after_hours: number;
     }>;
     curve_power?: number;
     bid?: {
-        amount: number;
+        amount: CreditAmount;
         duration_hours: number;
     };
     embargo_until?: string;
@@ -111,7 +126,7 @@ export interface StakeResult {
     position: {
         id: string;
         side: string;
-        amount: number;
+        amount: CreditAmount;
         created_at: string;
     };
     market: {
@@ -133,7 +148,7 @@ export interface MarketStatus {
     your_positions: Array<{
         id: string;
         side: string;
-        amount: number;
+        amount: CreditAmount;
         created_at: string;
     }>;
     resolution: {
@@ -165,8 +180,8 @@ export interface PinPreview {
 export interface RetractionResult {
     retracted: boolean;
     contribution_id: string;
-    deposit_refund: number;
-    deposit_forfeit: number;
+    deposit_refund: CreditAmount;
+    deposit_forfeit: CreditAmount;
     bounty_clawback: number;
 }
 export interface RateParams {
@@ -272,13 +287,14 @@ export type WireEventStreamMessage = {
     data: unknown;
 };
 export declare function normalizeWaitTimeoutSeconds(timeoutSeconds: number | undefined): number;
-declare function normalizeHelpTopic(topic: string | undefined): string;
+export 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 {
+    claims(params: Record<string, unknown>): Promise<unknown>;
     private baseUrl;
     private token;
     private nodeId;
@@ -328,7 +344,7 @@ export declare class WireAPI {
     }>;
     submitResult(workId: string, result: Record<string, unknown>): Promise<{
         credits_awarded: number;
-        balance_after: number;
+        balance_after: CreditAmount;
     }>;
     heartbeat(nodeId: string): Promise<{
         status: string;
@@ -362,6 +378,30 @@ export declare class WireAPI {
     private localHeaders;
     private localAuthToken;
     private tryLocalContributionRead;
+    /**
+     * Generic local-node fetch for the pyramid consume-head proxies. Returns the
+     * parsed JSON body on success, throws a descriptive error on non-2xx.
+     */
+    private localNodeFetch;
+    /**
+     * pyramid_map — GET /pyramid/{slug}/map.
+     * Apex synthesis + freshness counts + nav skeleton + unresolved gaps.
+     * Orient first at boot, then drill via pyramid_hydrate using nav node ids.
+     */
+    getPyramidMap(slug: string): Promise<Record<string, unknown>>;
+    /**
+     * pyramid_hydrate — GET /pyramid/{slug}/drill/{node_id}.
+     * Returns the DrillResult: full node content (headline/distilled/narrative
+     * via the node payload) plus children, evidence, gaps, web_edges, and
+     * question context. Pull one node/region after orienting via pyramid_map.
+     */
+    getPyramidDrill(slug: string, nodeId: string): Promise<Record<string, unknown>>;
+    /**
+     * pyramid_ask — POST /pyramid/{slug}/question  body { question }.
+     * Cheap (<5s, no-LLM) mechanical retrieval over the existing pyramid;
+     * returns a markdown answer plus node-id citations / sources.
+     */
+    askPyramid(slug: string, question: string): Promise<Record<string, unknown>>;
     /**
      * Rate a Wire item. Free. Must have accessed it first.
      */
@@ -418,31 +458,31 @@ export declare class WireAPI {
     /**
      * Get full mesh status: active threads, intents, blackboard.
      */
-    meshStatus(): Promise<Record<string, unknown>>;
+    meshStatus(scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Read the shared blackboard.
      */
-    meshBoardRead(): Promise<Record<string, unknown>>;
+    meshBoardRead(scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Write a key-value entry to the shared blackboard.
      */
-    meshBoardWrite(key: string, value: unknown, ttl?: number): Promise<Record<string, unknown>>;
+    meshBoardWrite(key: string, value: unknown, ttl?: number, scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Delete a key from the shared blackboard.
      */
-    meshBoardDelete(key: string): Promise<Record<string, unknown>>;
+    meshBoardDelete(key: string, scope?: MeshScopeParams): 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>>;
+    meshDeclareIntent(action: string, domain?: string, meta?: Record<string, unknown>, ttl?: number, scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Release (delete) an intent.
      */
-    meshReleaseIntent(intentId: string): Promise<Record<string, unknown>>;
+    meshReleaseIntent(intentId: string, scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Get active intents for this agent.
      */
-    meshGetIntents(): Promise<Record<string, unknown>>;
+    meshGetIntents(scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Stake credits on a prediction market attached to a contribution.
      * The contribution must have a claim with `market.enabled: true`.
@@ -452,7 +492,7 @@ export declare class WireAPI {
      * @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>;
+    stakeMarket(contributionId: string, side: 'agree' | 'disagree', amount: CreditAmount, requestId?: string): Promise<StakeResult>;
     /**
      * Get the current status of a prediction market, including pool sizes,
      * your positions, and resolution status if resolved.
@@ -619,8 +659,9 @@ export declare class WireAPI {
     acceptSupersession(proposalId: string): Promise<Record<string, unknown>>;
     rejectSupersession(proposalId: string): Promise<Record<string, unknown>>;
     executeSupersession(targetId: string, newContributionId: string, allowTypeChange?: boolean): Promise<Record<string, unknown>>;
-    submitCorrection(targetId: string, correctionContributionId: string, depositAmount: number): Promise<Record<string, unknown>>;
-    endorseCorrection(correctionId: string, depositAmount: number): Promise<Record<string, unknown>>;
+    submitCorrection(targetId: string, correctionContributionId: string, depositAmount: CreditAmount): Promise<Record<string, unknown>>;
+    withdrawCorrection(correctionId: string): Promise<Record<string, unknown>>;
+    endorseCorrection(correctionId: string, depositAmount: CreditAmount): 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>>;
@@ -729,4 +770,13 @@ export declare class WireAPI {
     getRosterWithDeviceSecret(deviceSecret: string, harness?: string, hintName?: string): Promise<Record<string, unknown>>;
     resumeAgent(agentName: string, deviceSecret: string, nonce: string): Promise<Record<string, unknown>>;
 }
+/**
+ * Paginate through all results from a fetch function.
+ * Concatenates pages until a page returns fewer than pageSize items.
+ *
+ * @param fetchPage - Function that fetches a page (1-indexed page number, pageSize)
+ * @param pageSize - Number of items per page (default 100)
+ * @returns All items concatenated
+ */
+export declare function paginateAll<T>(fetchPage: (page: number, pageSize: number) => Promise<T[]>, pageSize?: number): Promise<T[]>;
 export {};

package/dist/api.js

@@ -1,8 +1,15 @@
-import { paginateAll } from './sync/paginate.js';
 const DEFAULT_TRUSTED_CHAIN_TIMEOUT_MS = 600_000;
 const TRUSTED_CHAIN_CLIENT_GRACE_MS = 5_000;
 const DEFAULT_WIRE_SYNC_TIMEOUT_MS = DEFAULT_TRUSTED_CHAIN_TIMEOUT_MS + TRUSTED_CHAIN_CLIENT_GRACE_MS;
 const DEFAULT_ACTION_QUOTE_TIMEOUT_MS = 30_000;
+export class RegistrationError extends Error {
+    status;
+    constructor(status, message) {
+        super(`Registration failed (${status}): ${message}`);
+        this.status = status;
+        this.name = 'RegistrationError';
+    }
+}
 function legacyActionRequestOptions(params) {
     if (params.mode === 'quote') {
         return { body: params, timeoutMs: DEFAULT_ACTION_QUOTE_TIMEOUT_MS };
@@ -13,6 +20,14 @@ function legacyActionRequestOptions(params) {
         timeoutMs: timeoutMs + TRUSTED_CHAIN_CLIENT_GRACE_MS,
     };
 }
+function meshQuery(params, extra = {}) {
+    const query = new URLSearchParams(extra);
+    if (params.scope)
+        query.set('scope', params.scope);
+    if (params.circle_id)
+        query.set('circle_id', params.circle_id);
+    return query.size ? `?${query}` : '';
+}
 const DEFAULT_WAIT_TIMEOUT_SECONDS = 30;
 // Raised from 1800 (30m): the SSE event stream is server-side UNCAPPED + 30s-keepalived, so a long
 // client park is just a client-side deadline, not an infra limit. 86400 = 24h finite ceiling.
@@ -69,7 +84,7 @@ function appendWaitParams(url, params) {
             url.searchParams.set(key, String(value));
     }
 }
-function normalizeHelpTopic(topic) {
+export function normalizeHelpTopic(topic) {
     return (topic || '')
         .trim()
         .replace(/^https?:\/\/[^/]+\/api\/v1\/help\/?/i, '')
@@ -131,6 +146,13 @@ function parseSseBlock(block) {
     }
 }
 export class WireAPI {
+    async claims(params) {
+        const { action, claim_id } = params;
+        if (action === 'get' || action === 'list') {
+            return this.request('GET', '/wire/claims' + (claim_id ? `?claim_id=${encodeURIComponent(String(claim_id))}` : ''));
+        }
+        return this.request('POST', '/wire/claims', params, 120_000);
+    }
     baseUrl;
     token;
     nodeId;
@@ -222,7 +244,7 @@ export class WireAPI {
         return response;
     }
     async getMe() {
-        return this.request('GET', '/me');
+        return this.unwrapEnvelopeOrPlain(await this.request('GET', '/me'));
     }
     async registerNode(name, capabilities) {
         return this.request('POST', '/node/register', { name, capabilities });
@@ -242,7 +264,7 @@ export class WireAPI {
         });
         if (!res.ok) {
             const err = await res.json().catch(() => ({ error: res.statusText }));
-            throw new Error(`Registration failed (${res.status}): ${err.error || res.statusText}`);
+            throw new RegistrationError(res.status, err.error || res.statusText);
         }
         // Server wraps response in wireEnvelope: { data: { ... }, mesh, fleet, ... }
         const envelope = await res.json();
@@ -263,21 +285,10 @@ export class WireAPI {
     }
     async query(params) {
         const qs = new URLSearchParams();
-        qs.set('text', params.text);
-        qs.set('domain', params.domain || 'all');
-        if (params.limit !== undefined)
-            qs.set('limit', String(params.limit));
-        if (params.offset !== undefined)
-            qs.set('offset', String(params.offset));
-        qs.set('sort', params.sort || 'recency');
-        if (params.watchlist)
-            qs.set('watchlist', 'true');
-        if (params.list)
-            qs.set('list', params.list);
-        if (params.changed_only)
-            qs.set('changed_only', 'true');
-        if (params.price_below !== undefined)
-            qs.set('price_below', String(params.price_below));
+        for (const [key, value] of Object.entries({ domain: 'all', sort: 'recency', ...params })) {
+            if (value !== undefined && value !== null)
+                qs.set(key, String(value));
+        }
         return this.request('GET', `/wire/query?${qs.toString()}`);
     }
     async help(params = {}) {
@@ -476,6 +487,55 @@ export class WireAPI {
             return null;
         }
     }
+    // ── Pyramid consume-head proxies (spec green playful/176/24) ───────────
+    // Thin HTTP proxies to the LOCAL AWN node's read-time pyramid routes
+    // (pyramid_routes mounted at /pyramid/*). They forward (slug, args) to the
+    // route and return the parsed JSON as-is. Auth: pass the local Bearer token
+    // (this.localHeaders()); the AWN routes enforce dual-auth + access-tier +
+    // nano-payment. Same local-node fetch pattern as tryLocalContributionRead.
+    /**
+     * Generic local-node fetch for the pyramid consume-head proxies. Returns the
+     * parsed JSON body on success, throws a descriptive error on non-2xx.
+     */
+    async localNodeFetch(method, path, body, timeoutMs = 15_000) {
+        const res = await fetch(`${this.localNodeUrl}${path}`, {
+            method,
+            headers: this.localHeaders(),
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            const message = err.error || res.statusText;
+            throw new Error(`Local node ${method} ${path} failed (${res.status}): ${message}`);
+        }
+        return await res.json();
+    }
+    /**
+     * pyramid_map — GET /pyramid/{slug}/map.
+     * Apex synthesis + freshness counts + nav skeleton + unresolved gaps.
+     * Orient first at boot, then drill via pyramid_hydrate using nav node ids.
+     */
+    async getPyramidMap(slug) {
+        return this.localNodeFetch('GET', `/pyramid/${encodeURIComponent(slug)}/map`);
+    }
+    /**
+     * pyramid_hydrate — GET /pyramid/{slug}/drill/{node_id}.
+     * Returns the DrillResult: full node content (headline/distilled/narrative
+     * via the node payload) plus children, evidence, gaps, web_edges, and
+     * question context. Pull one node/region after orienting via pyramid_map.
+     */
+    async getPyramidDrill(slug, nodeId) {
+        return this.localNodeFetch('GET', `/pyramid/${encodeURIComponent(slug)}/drill/${encodeURIComponent(nodeId)}`);
+    }
+    /**
+     * pyramid_ask — POST /pyramid/{slug}/question  body { question }.
+     * Cheap (<5s, no-LLM) mechanical retrieval over the existing pyramid;
+     * returns a markdown answer plus node-id citations / sources.
+     */
+    async askPyramid(slug, question) {
+        return this.localNodeFetch('POST', `/pyramid/${encodeURIComponent(slug)}/question`, { question });
+    }
     /**
      * Rate a Wire item. Free. Must have accessed it first.
      */
@@ -523,7 +583,8 @@ export class WireAPI {
      * Read a source document by ID.
      */
     async readDocument(documentId) {
-        return this.request('GET', `/wire/documents/${documentId}?include_body=true`, undefined, 30_000);
+        const quote = await this.request('GET', `/wire/documents/${documentId}`, undefined, 30_000);
+        return this.request('POST', `/wire/documents/${quote.id ?? quote.data?.id ?? documentId}`, { max_price: quote.current_price ?? quote.data?.current_price ?? 0 }, 30_000);
     }
     /**
      * Find unscouted documents — unclaimed bounties.
@@ -596,44 +657,44 @@ export class WireAPI {
     /**
      * Get full mesh status: active threads, intents, blackboard.
      */
-    async meshStatus() {
-        return this.request('GET', '/mesh/status');
+    async meshStatus(scope = {}) {
+        return this.request('GET', `/mesh/status${meshQuery(scope)}`);
     }
     /**
      * Read the shared blackboard.
      */
-    async meshBoardRead() {
-        return this.request('GET', '/mesh/board');
+    async meshBoardRead(scope = {}) {
+        return this.request('GET', `/mesh/board${meshQuery(scope)}`);
     }
     /**
      * Write a key-value entry to the shared blackboard.
      */
-    async meshBoardWrite(key, value, ttl) {
-        return this.request('POST', '/mesh/board', { key, value, ttl });
+    async meshBoardWrite(key, value, ttl, scope = {}) {
+        return this.request('POST', '/mesh/board', { key, value, ttl, ...scope });
     }
     /**
      * Delete a key from the shared blackboard.
      */
-    async meshBoardDelete(key) {
-        return this.request('DELETE', `/mesh/board?key=${encodeURIComponent(key)}`);
+    async meshBoardDelete(key, scope = {}) {
+        return this.request('DELETE', `/mesh/board${meshQuery(scope, { key })}`);
     }
     /**
      * Declare an intent (what this thread is about to do).
      */
-    async meshDeclareIntent(action, domain, meta, ttl) {
-        return this.request('POST', '/mesh/intent', { action, domain, meta, ttl });
+    async meshDeclareIntent(action, domain, meta, ttl, scope = {}) {
+        return this.request('POST', '/mesh/intent', { action, domain, meta, ttl, ...scope });
     }
     /**
      * Release (delete) an intent.
      */
-    async meshReleaseIntent(intentId) {
-        return this.request('DELETE', `/mesh/intent?intent_id=${encodeURIComponent(intentId)}`);
+    async meshReleaseIntent(intentId, scope = {}) {
+        return this.request('DELETE', `/mesh/intent${meshQuery(scope, { intent_id: intentId })}`);
     }
     /**
      * Get active intents for this agent.
      */
-    async meshGetIntents() {
-        return this.request('GET', '/mesh/intent');
+    async meshGetIntents(scope = {}) {
+        return this.request('GET', `/mesh/intent${meshQuery(scope)}`);
     }
     // ── Prediction Markets ─────────────────────────────────────
     /**
@@ -645,8 +706,8 @@ export class WireAPI {
      * @param side - 'agree' or 'disagree'
      * @param amount - Number of credits to stake (must be >= market's min_stake)
      */
-    async stakeMarket(contributionId, side, amount) {
-        return this.request('POST', `/wire/market/${contributionId}/stake`, { side, amount });
+    async stakeMarket(contributionId, side, amount, requestId = crypto.randomUUID()) {
+        return this.request('POST', `/wire/market/${contributionId}/stake`, { side, amount, request_id: requestId });
     }
     /**
      * Get the current status of a prediction market, including pool sizes,
@@ -1020,6 +1081,9 @@ export class WireAPI {
     async submitCorrection(targetId, correctionContributionId, depositAmount) {
         return this.request('POST', `/wire/contributions/${encodeURIComponent(targetId)}/correct`, { correction_contribution_id: correctionContributionId, deposit_amount: depositAmount });
     }
+    async withdrawCorrection(correctionId) {
+        return this.request('DELETE', `/wire/contributions/${encodeURIComponent(correctionId)}/endorse-correction`);
+    }
     async endorseCorrection(correctionId, depositAmount) {
         return this.request('POST', `/wire/contributions/${encodeURIComponent(correctionId)}/endorse-correction`, { deposit_amount: depositAmount });
     }
@@ -1313,4 +1377,30 @@ export class WireAPI {
         return json.data || json;
     }
 }
+/**
+ * Paginate through all results from a fetch function.
+ * Concatenates pages until a page returns fewer than pageSize items.
+ *
+ * @param fetchPage - Function that fetches a page (1-indexed page number, pageSize)
+ * @param pageSize - Number of items per page (default 100)
+ * @returns All items concatenated
+ */
+export async function paginateAll(fetchPage, pageSize = 100) {
+    const allItems = [];
+    let page = 1;
+    const MAX_PAGES = 500; // 500 pages * 100 per page = 50k docs max
+    while (true) {
+        if (page > MAX_PAGES) {
+            console.error(`[wire-sync] Pagination stopped at ${MAX_PAGES} pages (${allItems.length} items). If your corpus has more documents, contact support.`);
+            break;
+        }
+        const items = await fetchPage(page, pageSize);
+        allItems.push(...items);
+        if (items.length < pageSize) {
+            break;
+        }
+        page++;
+    }
+    return allItems;
+}
 //# sourceMappingURL=api.js.map