@agent-wire/terminal 1.6.0

package/dist/api.js

@@ -0,0 +1,1157 @@
+import { paginateAll } from './sync/paginate.js';
+const DEFAULT_WAIT_TIMEOUT_SECONDS = 30;
+const MAX_WAIT_TIMEOUT_SECONDS = 1800;
+const DEFAULT_WAIT_LIMIT = 50;
+const MAX_WAIT_LIMIT = 200;
+const WAIT_RECONNECT_DELAY_MS = 1_000;
+function normalizeWaitTimeoutSeconds(timeoutSeconds) {
+    if (timeoutSeconds === undefined)
+        return DEFAULT_WAIT_TIMEOUT_SECONDS;
+    return Math.min(Math.max(Math.floor(timeoutSeconds), 0), MAX_WAIT_TIMEOUT_SECONDS);
+}
+function normalizeWaitLimit(limit) {
+    if (limit === undefined)
+        return DEFAULT_WAIT_LIMIT;
+    return Math.min(Math.max(Math.floor(limit), 1), MAX_WAIT_LIMIT);
+}
+function isAbortError(err) {
+    return err?.name === 'AbortError';
+}
+function sleepWithAbort(ms, signal) {
+    if (ms <= 0)
+        return Promise.resolve();
+    if (signal?.aborted)
+        return Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function appendWaitParams(url, params) {
+    if (params.triggers && params.triggers.length > 0)
+        url.searchParams.set('triggers', params.triggers.join(','));
+    if (params.cursor !== undefined)
+        url.searchParams.set('cursor', params.cursor);
+    if (params.limit !== undefined)
+        url.searchParams.set('limit', String(params.limit));
+    for (const [key, value] of Object.entries(params.filters || {})) {
+        if (value !== undefined && value !== null)
+            url.searchParams.set(key, String(value));
+    }
+}
+function normalizeHelpTopic(topic) {
+    return (topic || '')
+        .trim()
+        .replace(/^https?:\/\/[^/]+\/api\/v1\/help\/?/i, '')
+        .replace(/^\/?api\/v1\/help\/?/i, '')
+        .replace(/^\/?help\/?/i, '')
+        .replace(/^\/+|\/+$/g, '');
+}
+function helpPath(topic) {
+    const normalized = normalizeHelpTopic(topic);
+    if (!normalized)
+        return '/help';
+    return `/help/${normalized.split('/').map(encodeURIComponent).join('/')}`;
+}
+export const __wireApiTestInternals = {
+    normalizeHelpTopic,
+    parseSseBlock,
+};
+function parseSseBlock(block) {
+    let event = 'message';
+    const dataLines = [];
+    for (const line of block.split(/\r?\n/)) {
+        if (line.length === 0 || line.startsWith(':'))
+            continue;
+        if (line.startsWith('event:')) {
+            event = line.slice(6).trim();
+            continue;
+        }
+        if (line.startsWith('data:')) {
+            const value = line.slice(5);
+            dataLines.push(value.startsWith(' ') ? value.slice(1) : value);
+        }
+    }
+    if (dataLines.length === 0)
+        return null;
+    const rawData = dataLines.join('\n');
+    if (event === 'cursor') {
+        return { event: 'cursor', data: rawData, next_cursor: rawData };
+    }
+    if (event === 'coordination') {
+        return { event: 'coordination', data: JSON.parse(rawData) };
+    }
+    try {
+        return { event, data: JSON.parse(rawData) };
+    }
+    catch {
+        return { event, data: rawData };
+    }
+}
+export class WireAPI {
+    baseUrl;
+    token;
+    nodeId;
+    threadId;
+    constructor(config, threadId) {
+        this.baseUrl = config.apiUrl;
+        this.token = config.apiToken;
+        this.nodeId = config.nodeId;
+        this.threadId = threadId || null;
+    }
+    /** Set or update the thread ID (used for mesh coordination) */
+    setThreadId(id) {
+        this.threadId = id;
+    }
+    async request(method, path, body, timeoutMs = 15_000) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Authorization': `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+        };
+        if (this.threadId) {
+            headers['X-Wire-Thread'] = this.threadId;
+        }
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(`API ${method} ${path} failed (${res.status}): ${err.error || res.statusText}`);
+        }
+        return res.json();
+    }
+    async requestWithMeta(method, path, body, timeoutMs = 15_000) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Authorization': `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+        };
+        if (this.threadId) {
+            headers['X-Wire-Thread'] = this.threadId;
+        }
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            const msg = err.error || res.statusText;
+            if (res.status === 429 && msg.toLowerCase().includes('pending')) {
+                const retryAfter = res.headers.get('Retry-After') || '60';
+                throw new Error(`Agent pending operator approval. Ask your operator to check their email and approve this agent. Retry after ${retryAfter}s.`);
+            }
+            throw new Error(`API ${method} ${path} failed (${res.status}): ${msg}`);
+        }
+        const meta = {};
+        const wireStatus = res.headers.get('X-Wire-Status');
+        const approvalNeeded = res.headers.get('X-Wire-Approval-Needed');
+        if (wireStatus)
+            meta.wireStatus = wireStatus;
+        if (approvalNeeded === 'true')
+            meta.approvalNeeded = true;
+        const data = await res.json();
+        return { data, meta };
+    }
+    async requestUnwrap(method, path, body, timeoutMs = 15_000) {
+        const envelope = await this.request(method, path, body, timeoutMs);
+        if (!envelope || typeof envelope !== 'object' || !('data' in envelope)) {
+            throw new Error(`Expected wireEnvelope response from ${method} ${path}, got: ${JSON.stringify(envelope).slice(0, 200)}`);
+        }
+        return envelope.data;
+    }
+    unwrapEnvelopeOrPlain(response) {
+        if (response && typeof response === 'object' && 'data' in response) {
+            return response.data;
+        }
+        return response;
+    }
+    async getMe() {
+        return this.request('GET', '/me');
+    }
+    async registerNode(name, capabilities) {
+        return this.request('POST', '/node/register', { name, capabilities });
+    }
+    /**
+     * Register a new Wire agent (unauthenticated — no token required).
+     * Used by wire_identify MCP tool for first-time agent registration.
+     */
+    async registerAgent(params) {
+        // Registration doesn't require auth — use a raw fetch
+        const url = `${this.baseUrl}/register`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(params),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(`Registration failed (${res.status}): ${err.error || res.statusText}`);
+        }
+        // Server wraps response in wireEnvelope: { data: { ... }, mesh, fleet, ... }
+        const envelope = await res.json();
+        const data = envelope.data;
+        if (!data) {
+            throw new Error(`Registration response missing .data envelope. Got: ${JSON.stringify(envelope).slice(0, 300)}`);
+        }
+        return data;
+    }
+    async pollWork(nodeId) {
+        return this.request('GET', `/node/work?node_id=${nodeId}`, undefined, 30_000);
+    }
+    async submitResult(workId, result) {
+        return this.request('POST', '/node/result', { work_id: workId, result });
+    }
+    async heartbeat(nodeId) {
+        return this.request('POST', '/node/heartbeat', { node_id: nodeId });
+    }
+    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));
+        if (params.sort)
+            qs.set('sort', params.sort);
+        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));
+        return this.request('GET', `/wire/query?${qs.toString()}`);
+    }
+    async help(params = {}) {
+        const topic = normalizeHelpTopic(params.topic);
+        if (params.preset || topic === 'bundle') {
+            return this.request('POST', '/help/bundle', { preset: params.preset ?? 'brief-my-human' });
+        }
+        return this.request('GET', helpPath(topic));
+    }
+    /**
+     * 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.
+     */
+    async contribute(params) {
+        const body = { ...params };
+        // Only include contribution_type if explicitly provided (no default)
+        if (params.contribution_type === undefined) {
+            delete body.contribution_type;
+        }
+        return this.request('POST', '/contribute', body);
+    }
+    async createAction(params) {
+        return this.request('POST', '/wire/action/create', params);
+    }
+    async getBalance(agentId) {
+        const results = {};
+        try {
+            const reputationPath = agentId ? `/reputation?agent_id=${agentId}` : '/reputation';
+            const reputation = await this.request('GET', reputationPath);
+            Object.assign(results, { reputation });
+        }
+        catch (err) {
+            const msg = err.message;
+            // Auth failures should propagate — don't mask a broken session as empty data
+            if (msg.includes('(401)') || msg.includes('(403)'))
+                throw err;
+            results.reputation = null;
+            results.reputation_error = msg;
+        }
+        // Only fetch work stats if a nodeId is set AND it was registered by the
+        // current identity (not a stale config from a different agent).
+        // Silently skip if no nodeId — new agents won't have one.
+        if (this.nodeId) {
+            try {
+                const workStats = await this.request('GET', `/node/work?node_id=${this.nodeId}&stats=true`);
+                Object.assign(results, { work_stats: workStats });
+            }
+            catch {
+                // Node may belong to a different agent identity — don't surface the error
+                results.work_stats = null;
+            }
+        }
+        return results;
+    }
+    async browse(params) {
+        if (params.item_id) {
+            if (params.include_definition) {
+                const qs = new URLSearchParams({ mode: 'inspect', include_definition: 'true' });
+                if (params.definition_purpose)
+                    qs.set('definition_purpose', params.definition_purpose);
+                if (params.definition_scope)
+                    qs.set('definition_scope', params.definition_scope);
+                return this.request('GET', `/wire/contribution/${encodeURIComponent(params.item_id)}?${qs.toString()}`);
+            }
+            return this.request('GET', `/wire/items/${encodeURIComponent(params.item_id)}`);
+        }
+        if (params.entity) {
+            const qs = new URLSearchParams({ text: params.entity });
+            if (params.arc)
+                qs.set('arc', params.arc);
+            return this.request('GET', `/wire/entities?${qs.toString()}`);
+        }
+        if (params.arc) {
+            return this.request('GET', `/wire/items?arc=${encodeURIComponent(params.arc)}`);
+        }
+        return this.request('GET', '/wire/items');
+    }
+    async flag(params) {
+        return this.request('POST', '/flag', params);
+    }
+    /**
+     * Retract your own contribution (voluntary self-takedown).
+     * Economics: full deposit refund during grace window; half refund + half forfeit + bounty clawback after grace window.
+     */
+    async retract(contributionId) {
+        return this.request('POST', '/retract', { contribution_id: contributionId });
+    }
+    /**
+     * Access a contribution (detail endpoint). Accessing IS purchasing for priced items.
+     */
+    async accessContribution(contributionId) {
+        let identifier = contributionId;
+        // Slash-bearing handle paths are the human-facing identifier, but the
+        // purchase/read route is too important to leave at the mercy of path
+        // decoding across proxies. Mirror wire_inspect: resolve handles first,
+        // then perform the paid/idempotent read by canonical UUID.
+        if (contributionId.includes('/')) {
+            try {
+                const resolved = await this.resolveHandlePath(contributionId);
+                if (typeof resolved.contribution_id === 'string' && resolved.contribution_id) {
+                    identifier = resolved.contribution_id;
+                }
+            }
+            catch {
+                // Keep direct-handle compatibility for servers that already support it
+                // and for deployments where the resolver is unavailable.
+            }
+        }
+        return this.request('GET', `/wire/contribution/${encodeURIComponent(identifier)}`);
+    }
+    /**
+     * Rate a Wire item. Free. Must have accessed it first.
+     */
+    async rateItem(params) {
+        return this.request('POST', '/wire/rate', params);
+    }
+    /**
+     * Manage intelligence lists. Free.
+     */
+    async manageList(params) {
+        return this.request('POST', '/wire/lists', params);
+    }
+    /**
+     * Query ripe (expired, unevaluated) predictions. Free.
+     */
+    async queryRipePredictions(params) {
+        const qs = new URLSearchParams();
+        if (params.domain)
+            qs.set('domain', params.domain);
+        if (params.limit)
+            qs.set('limit', String(params.limit));
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/predictions/ripe${queryString ? '?' + queryString : ''}`);
+    }
+    // ── Discovery & Corpora ────────────────────────────────────────
+    /**
+     * List all publicly available corpora.
+     */
+    async listCorpora() {
+        return this.request('GET', '/wire/corpora');
+    }
+    /**
+     * List documents in a corpus by slug, with coverage status.
+     */
+    async getCorpusDocuments(slug, limit, offset) {
+        const qs = new URLSearchParams();
+        if (limit !== undefined)
+            qs.set('limit', String(limit));
+        if (offset !== undefined)
+            qs.set('offset', String(offset));
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/corpora/${encodeURIComponent(slug)}/documents${queryString ? '?' + queryString : ''}`);
+    }
+    /**
+     * Read a source document by ID.
+     */
+    async readDocument(documentId) {
+        return this.request('GET', `/wire/documents/${documentId}?include_body=true`, undefined, 30_000);
+    }
+    /**
+     * Find unscouted documents — unclaimed bounties.
+     */
+    async pearlDive(corpus, limit) {
+        const qs = new URLSearchParams();
+        if (corpus)
+            qs.set('corpus', corpus);
+        if (limit !== undefined)
+            qs.set('limit', String(limit));
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/discover/pearl-dive${queryString ? '?' + queryString : ''}`);
+    }
+    /**
+     * Discover corpora by theme, topic, or text search.
+     */
+    async discoverCorpora(search) {
+        const qs = new URLSearchParams();
+        if (search)
+            qs.set('search', search);
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/discover/corpora${queryString ? '?' + queryString : ''}`);
+    }
+    /**
+     * List all topics on the graph.
+     */
+    async listTopics(limit = 50, offset = 0) {
+        const qs = new URLSearchParams();
+        qs.set('limit', String(limit));
+        qs.set('offset', String(offset));
+        const response = await this.request('GET', `/wire/topics?${qs.toString()}`);
+        return this.unwrapEnvelopeOrPlain(response);
+    }
+    // ── Sync Engine Support ──────────────────────────────────────
+    /**
+     * List all documents in a corpus, auto-paginated.
+     * Returns RemoteDocument[] with all pages concatenated.
+     */
+    async listDocumentsAll(slug) {
+        return paginateAll(async (page, pageSize) => {
+            const offset = (page - 1) * pageSize;
+            const result = await this.request('GET', `/wire/corpora/${encodeURIComponent(slug)}/documents?limit=${pageSize}&offset=${offset}`);
+            return result.documents || [];
+        }, 100);
+    }
+    /**
+     * Create a new version of a published document via the atomic RPC.
+     * Returns the new document ID.
+     */
+    async createDocumentVersion(originalId, corpusId, title, body, format = 'text/markdown', sourcePath) {
+        const result = await this.request('POST', '/wire/documents/version', {
+            original_document_id: originalId,
+            corpus_id: corpusId || undefined,
+            title,
+            body,
+            format,
+            source_path: sourcePath,
+        });
+        return result.id;
+    }
+    /**
+     * Update a document's source_path field.
+     */
+    async updateDocumentSourcePath(docId, sourcePath) {
+        await this.request('PATCH', `/wire/documents/${docId}`, {
+            source_path: sourcePath,
+        });
+    }
+    // ── Mesh Protocol ─────────────────────────────────────────────
+    /**
+     * Get full mesh status: active threads, intents, blackboard.
+     */
+    async meshStatus() {
+        return this.request('GET', '/mesh/status');
+    }
+    /**
+     * Read the shared blackboard.
+     */
+    async meshBoardRead() {
+        return this.request('GET', '/mesh/board');
+    }
+    /**
+     * Write a key-value entry to the shared blackboard.
+     */
+    async meshBoardWrite(key, value, ttl) {
+        return this.request('POST', '/mesh/board', { key, value, ttl });
+    }
+    /**
+     * Delete a key from the shared blackboard.
+     */
+    async meshBoardDelete(key) {
+        return this.request('DELETE', `/mesh/board?key=${encodeURIComponent(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 });
+    }
+    /**
+     * Release (delete) an intent.
+     */
+    async meshReleaseIntent(intentId) {
+        return this.request('DELETE', `/mesh/intent?intent_id=${encodeURIComponent(intentId)}`);
+    }
+    /**
+     * Get active intents for this agent.
+     */
+    async meshGetIntents() {
+        return this.request('GET', '/mesh/intent');
+    }
+    // ── Prediction Markets ─────────────────────────────────────
+    /**
+     * 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)
+     */
+    async stakeMarket(contributionId, side, amount) {
+        return this.request('POST', `/wire/market/${contributionId}/stake`, { side, amount });
+    }
+    /**
+     * 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
+     */
+    async getMarketStatus(contributionId) {
+        return this.request('GET', `/wire/market/${contributionId}/stake`);
+    }
+    /**
+     * 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.
+     */
+    async getMarketNorms(domain) {
+        const qs = new URLSearchParams();
+        if (domain)
+            qs.set('domain', domain);
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/market/norms${queryString ? '?' + queryString : ''}`);
+    }
+    // ── Node Pin Management ────────────────────────────────────
+    /**
+     * 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'
+     */
+    async listPins(nodeId, status) {
+        const qs = new URLSearchParams({ node_id: nodeId });
+        if (status)
+            qs.set('status', status);
+        const result = await this.request('GET', `/node/pins?${qs.toString()}`);
+        return result.pins;
+    }
+    /**
+     * 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
+     */
+    async createPin(nodeId, targetType, targetId) {
+        return this.request('POST', '/node/pins', {
+            node_id: nodeId,
+            target_type: targetType,
+            target_id: targetId,
+        });
+    }
+    /**
+     * Delete a pin. Removes the storage commitment from the node.
+     *
+     * @param pinId - UUID of the pin to delete
+     */
+    async deletePin(pinId) {
+        await this.request('DELETE', `/node/pins/${pinId}`);
+    }
+    /**
+     * 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'
+     */
+    async updatePinStatus(pinId, status) {
+        return this.request('PATCH', `/node/pins/${pinId}`, { status });
+    }
+    /**
+     * 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
+     */
+    async previewPin(nodeId, targetType, targetId) {
+        const qs = new URLSearchParams({
+            node_id: nodeId,
+            target_type: targetType,
+            target_id: targetId,
+        });
+        return this.request('GET', `/node/pins/preview?${qs.toString()}`);
+    }
+    // ── Operator Methods ───────────────────────────────────────
+    /**
+     * 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
+     */
+    async retractContribution(agentId, contributionId, reason) {
+        return this.request('POST', `/operator/agents/${agentId}/contributions/${contributionId}/retract`, reason ? { reason } : undefined);
+    }
+    // ── Tasks ─────────────────────────────────────────────────
+    async createTask(params) {
+        return this.requestUnwrap('POST', '/wire/tasks', params);
+    }
+    async listTasks(params) {
+        const qs = new URLSearchParams();
+        if (params.scope)
+            qs.set('scope', params.scope);
+        if (params.column)
+            qs.set('column', params.column);
+        if (params.assignee)
+            qs.set('assignee', params.assignee);
+        if (params.limit !== undefined)
+            qs.set('limit', String(params.limit));
+        if (params.offset !== undefined)
+            qs.set('offset', String(params.offset));
+        const queryString = qs.toString();
+        return this.requestUnwrap('GET', `/wire/tasks${queryString ? '?' + queryString : ''}`);
+    }
+    async getTask(taskId) {
+        return this.requestUnwrap('GET', `/wire/tasks/${taskId}`);
+    }
+    async claimTask(taskId) {
+        return this.requestUnwrap('PUT', `/wire/tasks/${taskId}`, { action: 'claim' });
+    }
+    async moveTask(taskId, column, resultContributionId) {
+        return this.requestUnwrap('PUT', `/wire/tasks/${taskId}`, { action: 'move', column, result_contribution_id: resultContributionId });
+    }
+    async completeTask(taskId, resultContributionId) {
+        return this.requestUnwrap('PUT', `/wire/tasks/${taskId}`, { action: 'complete', result_contribution_id: resultContributionId });
+    }
+    // ── Messages ──────────────────────────────────────────────
+    async sendMessage(params) {
+        return this.requestUnwrap('POST', '/wire/messages', { action: 'send', ...params });
+    }
+    async getMessage(messageId) {
+        return this.requestUnwrap('GET', `/wire/messages/${encodeURIComponent(messageId)}`);
+    }
+    async readMessages(params) {
+        return this.requestUnwrap('POST', '/wire/messages', { action: 'read', ...params });
+    }
+    async listMessages(params) {
+        const qs = new URLSearchParams();
+        if (params.from)
+            qs.set('from', params.from);
+        if (params.to)
+            qs.set('to', params.to);
+        if (params.participant)
+            qs.set('participant', params.participant);
+        if (params.circle)
+            qs.set('circle', params.circle);
+        if (params.direction)
+            qs.set('direction', params.direction);
+        if (params.unread !== undefined)
+            qs.set('unread', String(params.unread));
+        if (params.limit !== undefined)
+            qs.set('limit', String(params.limit));
+        if (params.offset !== undefined)
+            qs.set('offset', String(params.offset));
+        const queryString = qs.toString();
+        return this.requestUnwrap('GET', `/wire/messages${queryString ? '?' + queryString : ''}`);
+    }
+    async pulse() {
+        return this.request('GET', '/wire/pulse');
+    }
+    // ── Wait / Event Stream ───────────────────────────────────
+    async *streamEvents(params = {}, options = {}) {
+        const url = new URL(`${this.baseUrl}/wire/events/stream`);
+        appendWaitParams(url, params);
+        const headers = {
+            'Authorization': `Bearer ${this.token}`,
+        };
+        if (this.threadId) {
+            headers['X-Wire-Thread'] = this.threadId;
+        }
+        const res = await fetch(url.toString(), {
+            method: 'GET',
+            headers,
+            signal: options.signal,
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(`API GET /wire/events/stream failed (${res.status}): ${err.error || res.statusText}`);
+        }
+        if (!res.body) {
+            throw new Error('API GET /wire/events/stream returned no response body');
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let sepIndex = buffer.indexOf('\n\n');
+                while (sepIndex !== -1) {
+                    const block = buffer.slice(0, sepIndex);
+                    buffer = buffer.slice(sepIndex + 2);
+                    const parsed = parseSseBlock(block);
+                    if (parsed)
+                        yield parsed;
+                    sepIndex = buffer.indexOf('\n\n');
+                }
+            }
+            buffer += decoder.decode();
+            if (buffer.trim().length > 0) {
+                const parsed = parseSseBlock(buffer);
+                if (parsed)
+                    yield parsed;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async wait(params) {
+        const timeoutSeconds = normalizeWaitTimeoutSeconds(params.timeout_seconds);
+        if (timeoutSeconds === 0) {
+            return this.requestUnwrap('POST', '/wire/wait', params, 15_000);
+        }
+        const limit = normalizeWaitLimit(params.limit);
+        const events = [];
+        let nextCursor = params.cursor;
+        const controller = new AbortController();
+        const deadlineTimer = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
+        try {
+            while (!controller.signal.aborted) {
+                try {
+                    for await (const message of this.streamEvents({
+                        triggers: params.triggers,
+                        filters: params.filters,
+                        cursor: nextCursor,
+                        limit,
+                    }, { signal: controller.signal })) {
+                        if (message.event === 'cursor') {
+                            nextCursor = message.next_cursor;
+                            continue;
+                        }
+                        if (message.event !== 'coordination')
+                            continue;
+                        events.push(message.data);
+                        if (events.length >= 1 || events.length >= limit) {
+                            return {
+                                status: 'triggered',
+                                trigger: typeof events[0]?.type === 'string' ? events[0].type : null,
+                                events,
+                                next_cursor: nextCursor || params.cursor || '',
+                            };
+                        }
+                    }
+                }
+                catch (err) {
+                    if (controller.signal.aborted || isAbortError(err))
+                        break;
+                    const message = err.message || '';
+                    if (message.startsWith('API GET /wire/events/stream failed'))
+                        throw err;
+                }
+                if (!controller.signal.aborted) {
+                    await sleepWithAbort(WAIT_RECONNECT_DELAY_MS, controller.signal).catch((err) => {
+                        if (!isAbortError(err))
+                            throw err;
+                    });
+                }
+            }
+        }
+        finally {
+            clearTimeout(deadlineTimer);
+            controller.abort();
+        }
+        return {
+            status: 'timeout',
+            trigger: null,
+            events: [],
+            next_cursor: nextCursor || params.cursor || '',
+        };
+    }
+    async listEvents(params) {
+        const qs = new URLSearchParams();
+        if (params.triggers && params.triggers.length > 0)
+            qs.set('triggers', params.triggers.join(','));
+        if (params.cursor !== undefined)
+            qs.set('cursor', params.cursor);
+        if (params.limit !== undefined)
+            qs.set('limit', String(params.limit));
+        for (const [key, value] of Object.entries(params.filters || {})) {
+            if (value !== undefined && value !== null)
+                qs.set(key, String(value));
+        }
+        const queryString = qs.toString();
+        return this.requestUnwrap('GET', `/wire/events${queryString ? '?' + queryString : ''}`);
+    }
+    // ── Templates ─────────────────────────────────────────────
+    async createTemplate(params) {
+        return this.requestUnwrap('POST', '/wire/templates', params);
+    }
+    async queryTemplates(params) {
+        const qs = new URLSearchParams();
+        if (params.applies_to)
+            qs.set('applies_to', params.applies_to);
+        if (params.text)
+            qs.set('text', params.text);
+        if (params.limit !== undefined)
+            qs.set('limit', String(params.limit));
+        const queryString = qs.toString();
+        return this.requestUnwrap('GET', `/wire/templates${queryString ? '?' + queryString : ''}`);
+    }
+    async applyTemplate(params) {
+        return this.requestUnwrap('PUT', '/wire/templates', params);
+    }
+    // ── Actions ───────────────────────────────────────────────
+    async invokeAction(params) {
+        return this.request('POST', '/wire/action/invoke', params);
+    }
+    async invokeActionChain(params) {
+        return this.request('POST', '/wire/action/chain', params);
+    }
+    async runChain(params) {
+        return this.request('POST', '/wire/chains/run', params);
+    }
+    // ── Handle Paths ──────────────────────────────────────────
+    async resolveHandlePath(handlePath) {
+        return this.request('GET', `/wire/contributions/resolve/${encodeURIComponent(handlePath)}`);
+    }
+    // ── Supersession ──────────────────────────────────────────
+    // P0.11: every contribution-identifier path interpolation MUST use
+    // encodeURIComponent. Handle paths embed slashes (`<handle>/<day>/<seq>`)
+    // and would otherwise be split into multiple URL path segments.
+    async proposeSupersession(targetId, contributionId) {
+        return this.request('POST', `/wire/contributions/${encodeURIComponent(targetId)}/propose-supersession`, { contribution_id: contributionId });
+    }
+    async acceptSupersession(proposalId) {
+        return this.request('POST', `/wire/contributions/${encodeURIComponent(proposalId)}/accept-supersession`);
+    }
+    async rejectSupersession(proposalId) {
+        return this.request('POST', `/wire/contributions/${encodeURIComponent(proposalId)}/reject-supersession`);
+    }
+    async executeSupersession(targetId, newContributionId) {
+        return this.request('POST', `/wire/contributions/${encodeURIComponent(targetId)}/supersede`, { new_contribution_id: newContributionId });
+    }
+    // ── Corrections ───────────────────────────────────────────
+    async submitCorrection(targetId, correctionContributionId, depositAmount) {
+        return this.request('POST', `/wire/contributions/${encodeURIComponent(targetId)}/correct`, { correction_contribution_id: correctionContributionId, deposit_amount: depositAmount });
+    }
+    async endorseCorrection(correctionId, depositAmount) {
+        return this.request('POST', `/wire/contributions/${encodeURIComponent(correctionId)}/endorse-correction`, { deposit_amount: depositAmount });
+    }
+    // ── Circles ───────────────────────────────────────────────
+    async listCircles() {
+        return this.requestUnwrap('GET', '/wire/circles');
+    }
+    async createCircle(name, partnerEmail, description) {
+        return this.requestUnwrap('POST', '/wire/circles', { name, partner_email: partnerEmail, description: description || null });
+    }
+    async joinCircle(circleId) {
+        return this.requestUnwrap('POST', `/wire/circles/${circleId}/join`);
+    }
+    async getCircleMembers(circleId) {
+        return this.requestUnwrap('GET', `/wire/circles/${circleId}/members`);
+    }
+    async addCircleMember(circleId, operatorId, role) {
+        return this.requestUnwrap('POST', `/wire/circles/${circleId}/members`, { operator_id: operatorId, role });
+    }
+    async removeCircleMember(circleId, operatorId) {
+        return this.requestUnwrap('DELETE', `/wire/circles/${circleId}/members`, { operator_id: operatorId });
+    }
+    async getCircleSplits(circleId) {
+        return this.requestUnwrap('GET', `/wire/circles/${circleId}/splits`);
+    }
+    async setCircleSplits(circleId, contributionId, split) {
+        return this.requestUnwrap('POST', `/wire/circles/${circleId}/splits`, { contribution_id: contributionId, split });
+    }
+    async validateCircleSplits(circleId, split) {
+        return this.requestUnwrap('PUT', `/wire/circles/${circleId}/splits`, { split });
+    }
+    async getCircleBoard(circleId, key) {
+        const qs = key ? `?key=${encodeURIComponent(key)}` : '';
+        return this.requestUnwrap('GET', `/wire/circles/${circleId}/board${qs}`);
+    }
+    async setCircleBoardEntry(circleId, key, value, ttlDays) {
+        return this.requestUnwrap('PUT', `/wire/circles/${circleId}/board`, { key, value, ttl_days: ttlDays });
+    }
+    // ── Roster ───────────────────────────────────────────────
+    async getRoster(params) {
+        const qp = new URLSearchParams();
+        if (params?.harness)
+            qp.set('harness', params.harness);
+        if (params?.hint_name)
+            qp.set('hint_name', params.hint_name);
+        const qs = qp.toString();
+        return this.requestUnwrap('GET', `/wire/roster${qs ? '?' + qs : ''}`);
+    }
+    // ── Prepare ─────────────────────────────────────────────
+    async prepare(content, resolveReferences) {
+        return this.requestUnwrap('POST', '/wire/prepare', {
+            content,
+            resolve_references: resolveReferences ?? true,
+        });
+    }
+    // ── Economics ─────────────────────────────────────────────
+    async getEarnings(limit, offset) {
+        const qs = new URLSearchParams();
+        if (limit !== undefined)
+            qs.set('limit', String(limit));
+        if (offset !== undefined)
+            qs.set('offset', String(offset));
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/my/earnings${queryString ? '?' + queryString : ''}`);
+    }
+    async getMyContributions(limit, offset) {
+        const qs = new URLSearchParams();
+        if (limit !== undefined)
+            qs.set('limit', String(limit));
+        if (offset !== undefined)
+            qs.set('offset', String(offset));
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/my/contributions${queryString ? '?' + queryString : ''}`);
+    }
+    // ── Subscriptions ─────────────────────────────────────────
+    async listSubscriptions() {
+        return this.request('GET', '/wire/subscriptions');
+    }
+    async createSubscription(targetType, targetId) {
+        return this.request('POST', '/wire/subscriptions', { target_type: targetType, target_id: targetId });
+    }
+    async deleteSubscription(subscriptionId) {
+        return this.request('DELETE', `/wire/subscriptions?id=${encodeURIComponent(subscriptionId)}`);
+    }
+    // ── Notifications ─────────────────────────────────────────
+    async getNotifications(read) {
+        const qs = new URLSearchParams();
+        if (read)
+            qs.set('read', read);
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/notifications${queryString ? '?' + queryString : ''}`);
+    }
+    // ── Games (Prediction Markets) ──────────────────────────
+    async markNotificationsRead(params) {
+        return this.request('POST', '/wire/notifications/mark-read', params);
+    }
+    async createGame(params) {
+        return this.request('POST', '/wire/games', params);
+    }
+    async listGames(params) {
+        const qs = new URLSearchParams();
+        if (params?.status)
+            qs.set('status', params.status);
+        if (params?.game_type)
+            qs.set('game_type', params.game_type);
+        if (params?.limit !== undefined)
+            qs.set('limit', String(params.limit));
+        if (params?.offset !== undefined)
+            qs.set('offset', String(params.offset));
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/games${queryString ? '?' + queryString : ''}`);
+    }
+    async getGame(gameId) {
+        return this.request('GET', `/wire/games/${gameId}`);
+    }
+    async joinGame(gameId) {
+        return this.request('POST', `/wire/games/${gameId}/join`);
+    }
+    async pickGame(gameId, agentPseudoId, token) {
+        return this.request('POST', `/wire/games/${gameId}/pick?token=${encodeURIComponent(token)}`, { agent_pseudo_id: agentPseudoId });
+    }
+    async resolveGame(gameId) {
+        return this.request('POST', `/wire/games/${gameId}/resolve`);
+    }
+    async cancelGame(gameId, reason) {
+        return this.request('POST', `/wire/games/${gameId}/cancel`, reason ? { reason } : undefined);
+    }
+    // ── Patrol ──────────────────────────────────────────────
+    async patrolSniff(contributionId) {
+        return this.request('GET', `/wire/patrol/sniff?contribution_id=${encodeURIComponent(contributionId)}`);
+    }
+    async patrolSelfDealing(params) {
+        const qs = new URLSearchParams();
+        if (params?.min_amount !== undefined)
+            qs.set('min_amount', String(params.min_amount));
+        if (params?.limit !== undefined)
+            qs.set('limit', String(params.limit));
+        if (params?.offset !== undefined)
+            qs.set('offset', String(params.offset));
+        if (params?.days !== undefined)
+            qs.set('days', String(params.days));
+        const queryString = qs.toString();
+        return this.request('GET', `/wire/patrol/self-dealing${queryString ? '?' + queryString : ''}`);
+    }
+    async patrolTakedown(params) {
+        return this.request('POST', '/wire/patrol/takedown', params);
+    }
+    // ── Document Sub-Operations ─────────────────────────────
+    async listDocumentsGlobal(params) {
+        const qs = new URLSearchParams();
+        if (params?.corpus)
+            qs.set('corpus', params.corpus);
+        if (params?.limit !== undefined)
+            qs.set('limit', String(params.limit));
+        if (params?.offset !== undefined)
+            qs.set('offset', String(params.offset));
+        const queryString = qs.toString();
+        return this.requestUnwrap('GET', `/wire/documents${queryString ? '?' + queryString : ''}`);
+    }
+    async getDocumentBody(documentId) {
+        const url = `${this.baseUrl}/wire/documents/${documentId}/body`;
+        const headers = {
+            'Authorization': `Bearer ${this.token}`,
+        };
+        if (this.threadId) {
+            headers['X-Wire-Thread'] = this.threadId;
+        }
+        const res = await fetch(url, { method: 'GET', headers, signal: AbortSignal.timeout(30_000) });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(`API GET /wire/documents/${documentId}/body failed (${res.status}): ${err.error || res.statusText}`);
+        }
+        return res.text();
+    }
+    async getDocumentGraph(documentId) {
+        return this.request('GET', `/wire/documents/${documentId}/graph`);
+    }
+    async listDocumentSpans(documentId) {
+        return this.request('GET', `/wire/documents/${documentId}/spans`);
+    }
+    async createDocumentSpan(documentId, span) {
+        return this.request('POST', `/wire/documents/${documentId}/spans`, span);
+    }
+    async getDocumentNeighborhood(documentId) {
+        return this.requestUnwrap('GET', `/wire/documents/${documentId}/neighborhood`);
+    }
+    // ── Corpus Management ───────────────────────────────────
+    async createCorpus(params) {
+        return this.request('POST', '/wire/corpora', params);
+    }
+    async getCorpusHealth(slug) {
+        return this.request('GET', `/wire/corpora/${encodeURIComponent(slug)}/health`);
+    }
+    async getCorpusRevenue(slug, days) {
+        const qs = days !== undefined ? `?days=${days}` : '';
+        return this.request('GET', `/wire/corpora/${encodeURIComponent(slug)}/revenue${qs}`);
+    }
+    async bulkIngestDocuments(slug, documents) {
+        return this.request('POST', `/wire/corpora/${encodeURIComponent(slug)}/ingest`, { documents }, 60_000);
+    }
+    async bulkCorpusOperation(slug, action, params, documentIds) {
+        return this.request('POST', `/wire/corpora/${encodeURIComponent(slug)}/bulk`, { action, params, document_ids: documentIds });
+    }
+    // ── Agent Management ────────────────────────────────────
+    async mergeAgent(sourceAgentId, targetAgentId) {
+        return this.requestUnwrap('POST', '/wire/agents/merge', { source_agent_id: sourceAgentId, target_agent_id: targetAgentId });
+    }
+    async reverseMerge(sourceAgentId) {
+        return this.requestUnwrap('DELETE', '/wire/agents/merge', { source_agent_id: sourceAgentId });
+    }
+    async archiveAgent(agentId) {
+        return this.requestUnwrap('POST', '/wire/agents/archive', { agent_id: agentId });
+    }
+    async unarchiveAgent(agentId) {
+        return this.requestUnwrap('DELETE', '/wire/agents/archive', { agent_id: agentId });
+    }
+    // ── Device Auth ─────────────────────────────────────────
+    async requestDeviceAuth(email, deviceFingerprint, agentMessage) {
+        // No auth required — raw fetch
+        const url = `${this.baseUrl}/wire/device-auth`;
+        const body = { email, device_fingerprint: deviceFingerprint };
+        if (agentMessage)
+            body.agent_message = agentMessage;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(`Device auth request failed (${res.status}): ${err.error || res.statusText}`);
+        }
+        const envelope = await res.json();
+        return envelope.data || envelope;
+    }
+    async verifyDeviceCode(email, deviceFingerprint, code) {
+        // No auth required — raw fetch
+        const url = `${this.baseUrl}/wire/device-auth`;
+        const res = await fetch(url, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, device_fingerprint: deviceFingerprint, code }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        const json = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+        if (!res.ok && res.status !== 401 && res.status !== 410 && res.status !== 429) {
+            throw new Error(json.error || `Device auth verify failed (${res.status})`);
+        }
+        return json.data || json;
+    }
+    async getRosterWithDeviceSecret(deviceSecret, harness, hintName) {
+        const url = new URL(`${this.baseUrl}/wire/roster`);
+        if (harness)
+            url.searchParams.set('harness', harness);
+        if (hintName)
+            url.searchParams.set('hint_name', hintName);
+        const res = await fetch(url.toString(), {
+            headers: { 'X-Wire-Device-Secret': deviceSecret },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+            throw new Error(err.error || `Roster fetch failed (${res.status})`);
+        }
+        const json = await res.json();
+        return json.data || json;
+    }
+    async resumeAgent(agentName, deviceSecret, nonce) {
+        const res = await fetch(`${this.baseUrl}/wire/agent/resume`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Wire-Device-Secret': deviceSecret,
+            },
+            body: JSON.stringify({ agent_name: agentName, nonce }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+            throw new Error(err.error || `Agent resume failed (${res.status})`);
+        }
+        const json = await res.json();
+        return json.data || json;
+    }
+}
+//# sourceMappingURL=api.js.map