@oneshot-agent/sdk 0.46.0 → 0.48.0

package/dist/index.js

@@ -37,6 +37,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OneShot = exports.executeSwap = exports.getSwapQuote = exports.ReadOnlyWalletProvider = exports.CdpWalletProvider = exports.EthersWalletProvider = void 0;
+const hunts_1 = require("./hunts");
+__exportStar(require("./hunts"), exports);
 const physical_mail_1 = require("./physical-mail");
 __exportStar(require("./physical-mail"), exports);
 __exportStar(require("./approvals"), exports);
@@ -63,7 +65,7 @@ const approvals_1 = require("./approvals");
 // stay off this public surface (see tests/unit/sdk-provider-cost-removed.test.ts).
 // Import from the `@oneshot-agent/sdk/receipt` subpath instead.
 // Keep in sync with package.json `version`. Guarded by version.test.ts.
-const SDK_VERSION = '0.46.0';
+const SDK_VERSION = '0.48.0';
 /** HTTP poll cadence while push is unconfirmed: fast first checks, settling at 2s. */
 const HTTP_POLL_BACKOFF_MS = [300, 600, 1000, 2000];
 /** HTTP poll cadence once the WebSocket has delivered for this request. */
@@ -187,6 +189,7 @@ class OneShot {
      * For CDP wallets, use OneShot.create() instead.
      */
     constructor(config, walletProvider) {
+        this.hunts = new hunts_1.Hunts(this);
         this.physicalMail = new physical_mail_1.PhysicalMail(async (path, method, body, mime) => {
             const response = await fetch(`${this.baseUrl}/v1/tools/physical-mail${path}`, {
                 method, headers: { ...await this.signedReadHeaders(method === 'GET' ? 'read' : 'write'), 'Content-Type': mime ?? 'application/json' },
@@ -208,6 +211,7 @@ class OneShot {
         /** ETH mode: serializes read → decide → swap → reserve per instance (also prevents concurrent swap nonce races). */
         this._usdcLock = Promise.resolve();
         this.baseUrl = config.baseUrl ?? BASE_URL;
+        this.huntUrl = config.huntUrl;
         this.debug = config.debug ?? false;
         this.logger = config.logger ?? console.log;
         this._currency = config.currency ?? 'USDC';
@@ -313,8 +317,24 @@ class OneShot {
         const fromAddress = useRotation
             ? undefined
             : `${options.from_mailbox ?? 'agent'}@${options.from_domain}`;
+        // Confirming a new-domain registration (#1070): the caller passes back the
+        // quote_id of the `confirmation_required` result it was shown. That quote
+        // is sent as-is — no second quote — so the server charges the stored total
+        // of the quote the user saw (x402-legacy validates the id and takes the
+        // amount from the stored quote). A bare `true` is not a confirmation: it
+        // names no amount, so it falls through to the quote-only path below. An
+        // expired or already-used quote is refused by the server, and the next
+        // unconfirmed call produces a fresh quote to show again.
+        const confirmedQuote = typeof options.confirmNewDomain === 'string' && options.confirmNewDomain.trim()
+            ? options.confirmNewDomain.trim() : undefined;
+        if (confirmedQuote) {
+            this.log(`Email: sending against confirmed quote ${confirmedQuote}`);
+            return this.executeToolRequest('/v1/tools/email/send', this.emailSendPayload(options, fromAddress), confirmedQuote);
+        }
         // `mailbox_provisioning_fee` (>0) means `from_address` is a new address that
         // provisions a mailbox on first send — a one-time fee folded into `total_cost`.
+        // `is_new` (true) means this quote would register a brand-new domain, which
+        // drives the confirm-before-charge gate below (#1070 round 2).
         const quote = await this.tool('email/quote', {
             ...(fromAddress ? { from_address: fromAddress } : {}),
             ...(options.to !== undefined ? { to_address: options.to } : {}),
@@ -334,7 +354,32 @@ class OneShot {
         // un-set so the server returned a 200 with the quote and the caller still
         // wants the local guard to apply).
         this.assertWithinMaxCost(quote.total_cost, options.maxCost);
-        const resolvedFromAddress = fromAddress ?? quote.from_address;
+        // Registering a brand-new domain is charged only after its exact quote has
+        // been shown and explicitly authorized (#1070 round 2) — this call stops
+        // here, before /email/send, and charges nothing. Pass confirmNewDomain:
+        // true (with the same from_domain) to register the domain, pay the quoted
+        // total, and send the email in one follow-up call.
+        if (quote.is_new) {
+            const domainName = quote.domain ?? options.from_domain ?? '';
+            const breakdown = quote.registration_fee !== undefined && quote.service_fee !== undefined
+                ? ` (registration $${quote.registration_fee} + service fee $${quote.service_fee}` +
+                    `${quote.mailbox_provisioning_fee ? ` + mailbox fee $${quote.mailbox_provisioning_fee}` : ''})`
+                : '';
+            return {
+                status: 'confirmation_required',
+                cost: parseFloat(quote.total_cost),
+                quote_id: quote.quote_id,
+                domain: { domain: domainName, status: 'quote_only', was_provisioned: false },
+                message: `Registering ${domainName} costs $${quote.total_cost} total${breakdown}. ` +
+                    `Nothing has been charged yet. Show the user this exact amount; once they agree, call this again with the same ` +
+                    `arguments and confirm_new_domain: '${quote.quote_id}' (SDK: confirmNewDomain) to register the domain, ` +
+                    `charge exactly $${quote.total_cost}, and send this email. true only re-quotes; a wrong or expired quote id is refused without charge.`,
+            };
+        }
+        return this.executeToolRequest('/v1/tools/email/send', this.emailSendPayload(options, fromAddress ?? quote.from_address), quote.quote_id);
+    }
+    /** The /email/send body for `email()`: the same whether it follows a fresh quote or a confirmed one. */
+    emailSendPayload(options, resolvedFromAddress) {
         const payload = {
             // Server replays the locked address from the quote when from_address
             // is absent, but sending it anyway is harmless and forward-compatible
@@ -366,7 +411,11 @@ class OneShot {
             // Releases a send the action policy held (see ApprovalRequiredError).
             payload.approvalId = options.approvalId;
         }
-        return this.executeToolRequest('/v1/tools/email/send', payload, quote.quote_id);
+        // Forward maxCost so the server-side X-Max-Cost-USDC header also guards
+        // the send, which matters on a confirmed send that skipped the quote.
+        if (options.maxCost !== undefined)
+            payload.maxCost = options.maxCost;
+        return payload;
     }
     /** List the caller's domain pool with warmup and rotation metadata. */
     async listDomains() {
@@ -780,6 +829,7 @@ class OneShot {
             payload,
             signal: options.signal,
             maxCost: options.maxCost,
+            approvalId: options.approvalId,
             // Build analysis can be slow server-side; bound the quote leg client-side.
             quoteTimeoutMs: 120000,
             expectMsg: 'Expected 402 for quote',
@@ -1065,6 +1115,35 @@ class OneShot {
         const { accountId, conversationId, text, ...rest } = options;
         return this.tool('linkedin/reply', { ...rest, account_id: accountId, conversation_id: conversationId, text, timeout: options.timeout ?? 180 });
     }
+    /**
+     * Message a first-degree connection: into the 1:1 conversation the account
+     * already has with them, or a new one. Use it once an invitation is accepted,
+     * or for a connection the account has never messaged. Needs the `reply`
+     * grant; shares the reply daily cap and pacing. A failed send carries an
+     * error code: `not_connected` (invite them first) and `rate_limited` mean
+     * "defer", not "give up".
+     */
+    async linkedinMessage(options) {
+        this.validate(options.accountId, 'accountId');
+        this.validate(options.profile, 'profile');
+        this.validate(options.text, 'text');
+        const { accountId, profile, text, ...rest } = options;
+        return this.tool('linkedin/message', { ...rest, account_id: accountId, profile, text, timeout: options.timeout ?? 180 });
+    }
+    /** One invitation sent through linkedinInvite: `accepted` (with `accepted_at`) as soon as the person is a connection. Free. */
+    async linkedinInvitation(options) {
+        this.validate(options.accountId, 'accountId');
+        this.validate(options.invitationId, 'invitationId');
+        return this.linkedinFree('GET', `/accounts/${encodeURIComponent(options.accountId)}/invitations/${encodeURIComponent(options.invitationId)}`, { what: 'invitation' });
+    }
+    /** Invitations sent through linkedinInvite, most recently changed first. Poll with `changedSince`. Free. */
+    async linkedinInvitations(options) {
+        this.validate(options.accountId, 'accountId');
+        return this.linkedinFree('GET', `/accounts/${encodeURIComponent(options.accountId)}/invitations`, {
+            what: 'invitations',
+            query: { status: options.status, changed_since: options.changedSince, limit: options.limit?.toString() },
+        });
+    }
     /** View a profile through the connected account. `notify: true` is visible to the target and cannot be undone. */
     async linkedinViewProfile(options) {
         this.validate(options.accountId, 'accountId');
@@ -1351,6 +1430,8 @@ class OneShot {
             payload.schedule = options.schedule;
         if (options.approvals)
             payload.approvals = options.approvals;
+        if (options.done_check)
+            payload.done_check = options.done_check;
         // Compute returns the goal directly on 202 — no job polling, unlike the
         // other paid tools.
         const { execResp: createResp } = await this.runQuoteToPay({
@@ -1496,6 +1577,33 @@ class OneShot {
         const json = await response.json();
         return json.data;
     }
+    /**
+     * Answer whether a goal in `awaiting_confirmation` is done. A goal with no
+     * done-check completes only when its owner confirms: the agent that ran it
+     * cannot. `approved: false` sends it back with `response` as what is missing.
+     *
+     * @example
+     * ```typescript
+     * const goal = await agent.getComputeGoal(goalId);
+     * if (goal.status === 'awaiting_confirmation') {
+     *   await agent.confirmComputeGoal(goalId, { approved: true });
+     * }
+     * ```
+     */
+    async confirmComputeGoal(goalId, input) {
+        this.validate(goalId, 'goalId');
+        const response = await fetch(`${this.baseUrl}/v1/compute/${goalId}/respond`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...(await this.signedReadHeaders('write')) },
+            body: JSON.stringify({ confirm_done: input.approved, ...(input.response ? { response: input.response } : {}) }),
+        });
+        if (response.status === 404)
+            throw new errors_2.ToolError('Goal not found', 404, await response.text());
+        if (!response.ok)
+            throw new errors_2.ToolError('Failed to confirm compute goal', response.status, await response.text());
+        const json = await response.json();
+        return json.data;
+    }
     /**
      * Pause a recurring compute goal
      *
@@ -1865,7 +1973,7 @@ class OneShot {
      * locally. A fresh nonce per call prevents replay. Signing failure falls back
      * to plain headers, with a one-time warning.
      */
-    async signedReadHeaders(scope = 'read') {
+    async signedReadHeaders(scope = 'read', domainName = 'OneShot Agent Auth') {
         const base = this.headers();
         // The bearer token already binds the request to the agent (and is
         // revocable); the API accepts it in place of the signed proof.
@@ -1875,7 +1983,14 @@ class OneShot {
             const agent = this.provider.address;
             const issuedAt = Math.floor(Date.now() / 1000);
             const nonce = ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(32));
-            const signature = await this.provider.signTypedData({ name: 'OneShot Agent Auth', version: '1' }, {
+            const signature = await this.provider.signTypedData(
+            // `domainName` lets a different origin (e.g. Soul Hunt, which keeps
+            // its own nonce store — see hunts.ts) use a DIFFERENT EIP-712 domain
+            // than api-service's. EIP-712 mixes the domain into the signed hash,
+            // so a proof is only valid for the one origin it was signed for and
+            // can't be replayed across service boundaries (security finding
+            // F-t_d4805d6f-3, round 2).
+            { name: domainName, version: '1' }, {
                 AgentReadAuth: [
                     { name: 'agent', type: 'address' },
                     { name: 'scope', type: 'string' },
@@ -2316,7 +2431,7 @@ class OneShot {
     }
     async executeToolRequest(endpoint, options, quoteId) {
         // LinkedIn writes act through a human's account and cannot be recalled: always keyed.
-        const reliable = /(?:^|\/)(enrich\/(profile|email)|verify\/email|linkedin\/(reply|profile-view|react|invite(?:\/withdraw)?))$/.test(endpoint);
+        const reliable = /(?:^|\/)(enrich\/(profile|email)|verify\/email|linkedin\/(reply|message|profile-view|react|invite(?:\/withdraw)?))$/.test(endpoint);
         const key = options.idempotencyKey ?? (reliable ? ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(16)) : undefined);
         if (options.totalTimeoutMs !== undefined && (!Number.isFinite(options.totalTimeoutMs) || options.totalTimeoutMs <= 0)) {
             throw new errors_2.ValidationError('totalTimeoutMs must be positive', 'totalTimeoutMs');
@@ -3041,7 +3156,7 @@ class OneShot {
         }
         catch (err) {
             // Keyed writes may already be queued server-side after a transport failure: keep the reservation.
-            if (!/(enrich\/(profile|email)|verify\/email|physical-mail\/send|linkedin\/(reply|profile-view|react|invite(?:\/withdraw)?))$/.test(endpoint))
+            if (!/(enrich\/(profile|email)|verify\/email|physical-mail\/send|linkedin\/(reply|message|profile-view|react|invite(?:\/withdraw)?))$/.test(endpoint))
                 this.releaseUsdcReservation(signed.reservation);
             throw err;
         }