402mob-merchant-sdk 0.1.3 → 0.3.0

package/README.md

@@ -1,8 +1,8 @@
 # 402Mob Merchant SDK
 
-An open-source, dependency-free TypeScript client for enrolling and operating a 402Mob merchant from a Node.js server or agent runtime.
+An open-source, dependency-free TypeScript client for resolving agent resources and enrolling or operating a 402Mob merchant from a Node.js server or agent runtime.
 
-It wraps the existing HTTP merchant API. It does not custody keys, sign for wallets, submit transactions, or make x402 purchases.
+It wraps the existing HTTP merchant API, including seller-side Work Ticket inbox, claim, quote, and result methods. It does not custody keys, sign for wallets, submit transactions, or make x402 purchases.
 
 The SDK is intended for server-side and agent-runtime use. `evidence.contact` does not enable cross-origin browser requests, and merchant API keys are long-lived secrets. For a browser UI, keep the key on your backend and proxy calls through it; the browser may sign the exact challenge message with its wallet and send only the signature to that backend.
 
@@ -26,7 +26,7 @@ Install from npm:
 npm install 402mob-merchant-sdk
 ```
 
-The current published release is **0.1.2**. The working tree prepares **0.1.3** with a typed directory visibility method; publish it from the SDK package directory when ready. See the [npm package page](https://www.npmjs.com/package/402mob-merchant-sdk) or browse the [source repository](https://github.com/gggggggg424242/402mob-merchant-sdk).
+This source prepares SDK version **0.3.0**, adding seller Work Ticket methods and public buyer status reads. The published npm version remains **0.2.0** until 0.3.0 is separately released. See the [npm package page](https://www.npmjs.com/package/402mob-merchant-sdk) or browse the [source repository](https://github.com/gggggggg424242/402mob-merchant-sdk).
 
 Requires Node.js 18 or newer. The SDK uses the built-in Fetch API and has no runtime dependencies.
 
@@ -64,6 +64,57 @@ console.log({ offerId: offer.id, checkout: offer.checkout });
 
 `wallet.signMessage` above is an adapter-specific example. The SDK never receives a private key and never logs the returned signature or API key.
 
+## Resolve agent resources
+
+Buyer agents can search opted-in providers without an API key, inspect a provider by known merchant ID, and resolve a saved offer ID to its current published version.
+
+```ts
+import { MerchantClient } from "402mob-merchant-sdk";
+
+const buyer = new MerchantClient();
+const page = await buyer.resolveResources({ query: "payment summary", limit: 20 });
+
+for (const { merchant, offer } of page.items) {
+  console.log({
+    provider: merchant.name,
+    title: offer.title,
+    priceUSDC: offer.amountUSDC,
+    checkout: offer.checkout,
+  });
+}
+
+if (page.items[0]) {
+  const current = await buyer.resolveLatestResource(
+    page.items[0].merchant.id,
+    page.items[0].offer.id,
+  );
+  console.log(current.offer.version, current.offer.title);
+}
+```
+
+`resolveResources` searches provider names, resource titles, and descriptions. It returns only active prepared resources from providers that opted into directory visibility. `getProviderResources(merchantId)` reads a known provider's public profile and resources even when it is not discoverable. `resolveLatestResource(merchantId, offerId)` follows an older offer ID to the current version in its series. These calls return descriptors and checkout paths; they do not execute work, purchase an artifact, sign a payment, or endorse the provider. Use an x402-capable buyer or the documented checkout flow to purchase.
+
+## Seller Work Tickets
+
+Merchant agents with the `merchant:work` scope can inspect their private inbox, claim a buyer-addressed task, submit a fixed quote, and deliver a result after the buyer's x402 payment is confirmed. The SDK methods are `listWorkTickets`, `claimWorkTicket`, `quoteWorkTicket`, `getWorkTicket`, and `submitWorkTicketResult`.
+
+```ts
+const seller = new MerchantClient({ apiKey: process.env.MERCHANT_API_KEY });
+const { tickets } = await seller.listWorkTickets({ states: ["open"], limit: 20 });
+const ticket = tickets[0];
+if (ticket) {
+  await seller.claimWorkTicket(ticket.id, 600);
+  await seller.quoteWorkTicket(ticket.id, {
+    priceUSDC: "0.05",
+    deliverable: "JSON transfer summary",
+    contentType: "application/json",
+    expiresInSeconds: 600,
+  });
+}
+```
+
+The buyer must separately sign the exact quote and pay through x402 before `submitWorkTicketResult` succeeds. The seller SDK does not make or sign buyer payments. Read the [Work Ticket protocol guide](https://evidence.contact/work-tickets.md) for the complete buyer/seller sequence and recovery rules.
+
 ## Enrollment with a wallet transaction tool
 
 For runtimes that can submit Base USDC actions but cannot sign arbitrary messages, pass a callback that submits the exact zero-USDC action from the challenge. Wait for the response's advertised confirmation depth before returning the transaction hash.
@@ -91,6 +142,9 @@ This action moves no USDC and grants no allowance, but it costs Base ETH for gas
 
 ### Public methods
 
+- `resolveResources({ query?, limit?, cursor? })` — search public, opted-in prepared resources without an API key.
+- `getProviderResources(merchantId)` — read one known provider's public profile and published resources.
+- `resolveLatestResource(merchantId, offerId)` — resolve an older offer ID to the current published version.
 - `createEnrollmentChallenge({ wallet, name })`
 - `completeEnrollmentWithSignature({ wallet, name, challengeId, signature })`
 - `completeEnrollmentWithTransaction({ wallet, name, challengeId, method, transactionHash })`
@@ -109,7 +163,7 @@ This action moves no USDC and grants no allowance, but it costs Base ETH for gas
 - `listSales(limit?)`
 - `getSale(operationId)`
 
-Create offer prices as decimal strings (for example `"0.02"`) to avoid floating-point rounding. Results are prepared JSON or text artifacts, limited by the service to 48 KiB. An offer's price and content are immutable. To publish an update, submit a higher semantic version and the current `supersedesOfferId`; the new version unpublishes its predecessor.
+Create offer prices as decimal strings (for example `"0.02"`) to avoid floating-point rounding. Prices must be positive, from `0.000001` through `999999.999999` USDC, with at most six fractional digits. Results are prepared JSON or text artifacts, limited by the service to 48 KiB. An offer's price and content are immutable. To publish an update, submit a higher semantic version and the current `supersedesOfferId`; the new version unpublishes its predecessor.
 
 ## Safety and behavior
 
@@ -130,14 +184,31 @@ npm test
 
 The SDK tests use mocked HTTP responses and do not contact `evidence.contact` or submit wallet transactions.
 
-See [`examples/enroll-and-publish.ts`](./examples/enroll-and-publish.ts) for an adapter-based integration that enrolls a wallet and creates its first offer.
+See [`examples/enroll-and-publish.ts`](./examples/enroll-and-publish.ts) for an adapter-based seller integration and [`examples/resolve-resources.ts`](./examples/resolve-resources.ts) for public buyer-agent discovery. Both examples import the built package output and are included in the npm tarball.
 
 MIT licensed. See [LICENSE](./LICENSE).
 
-## Version 0.1.3 (unpublished)
+## Version 0.2.0
+
+Adds public buyer-agent methods `resolveResources`, `getProviderResources`, and `resolveLatestResource`, plus typed resource response interfaces. The calls need no merchant key and do not make purchases. Existing seller enrollment and management methods remain available.
+
+## Version 0.1.3
 
 Adds `setDiscoverable(discoverable)`, which calls the authenticated `PUT /v1/agent/merchant/discovery` endpoint. The service controls visibility; enrollment still defaults to hidden. Directory search exposes active offer descriptions and prices to public callers.
 
 ## Version 0.1.2
 
 The source now rejects unreadable or incomplete successful API responses with `MerchantApiError` code `invalid_response`. Challenge fields and zero-USDC instructions are checked before invoking the wallet callback; enrollment and rotation responses must contain a merchant ID and a nonempty API key. An invalid completion response can mean the server already completed the operation: recover access through credential rotation if its one-time key was lost. This validation is included in published 0.1.2. Integrations using 0.1.1 should validate required fields explicitly. Preserve the original challenge and submitted transaction hash when completion is interrupted; rerunning `enrollWithTransaction` creates a fresh challenge and invokes the wallet callback again. A completion error is not permission to submit another proof transaction automatically.
+
+
+## Work Ticket reads and recovery (0.3.0 source)
+
+Buyer agents can call `client.getWorkTicketStatus(ticketId)` without an API key to read state, quote terms, payment references, and result hashes. This public response excludes the buyer wallet, private input, and signed buyer receipt. It does not fetch result bytes or authorize payment.
+
+Seller agents use `getWorkTicket(ticketId)` or `listWorkTickets({ states: ["paid"], limit: 20 })` with a `merchant:work` key. Inbox, detail, and claim responses include private `input`; it becomes `null` after retention ends. Quote and result-submission responses return `WorkTicketSummary`, which has no `input` field. Fetch the authenticated detail if the worker needs that input again.
+
+The supported states are `open`, `claimed`, `quoted`, `accepted`, `paying`, `paid`, `delivered`, `accepted_by_buyer`, `disputed`, and `expired`. Cancellation is not implemented. An explicit `states` filter must contain 1–10 supported states; omit it to use the server default. Work Ticket IDs must be UUIDs.
+
+SDK requests reject HTTP redirects and never retry automatically. An interrupted mutation may have completed. Read the ticket before repeating a claim or quote; quote and claim creation are not idempotent. Repeating identical result content is supported while retained. For payment recovery through HTTP or MCP, reuse the original checkout key and authorization, including after delivery or a buyer receipt. The SDK does not submit payments.
+
+These methods are prepared in the 0.3.0 source release; publishing the package is a separate step.

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export type EvmSignature = `0x${string}`;
 export type TransactionHash = `0x${string}`;
 export type ProofMethod = "approve_zero" | "transfer_zero";
 export type ArtifactContentType = "application/json" | "text/plain; charset=utf-8";
+export type WorkTicketState = "open" | "claimed" | "quoted" | "accepted" | "paying" | "paid" | "delivered" | "accepted_by_buyer" | "disputed" | "expired";
 export interface EnrollmentChallenge {
     challengeId: string;
     message: string;
@@ -113,6 +114,54 @@ export interface MerchantWorkspace {
     merchant: MerchantProfile;
     offers: MerchantOffer[];
 }
+/** Public provider fields returned while an agent resolves available resources. */
+export interface AgentResourceProvider {
+    id: string;
+    name: string;
+    /** Present in directory results; points to the provider's public profile. */
+    profile?: string;
+    /** Present in direct profile and latest-resource lookups. */
+    payoutAddress?: EvmAddress;
+    createdAt?: string;
+}
+/** A provider-published, fixed-price resource descriptor. */
+export interface AgentResource {
+    id: string;
+    seriesId: string;
+    version: string;
+    title: string;
+    description: string;
+    amountAtomic: string;
+    amountUSDC: string;
+    contentType: ArtifactContentType;
+    latest: string;
+    checkout: string;
+    directTransferChallenge: string;
+    supersedesOfferId?: string | null;
+}
+export interface ResolvedAgentResource {
+    merchant: AgentResourceProvider;
+    offer: AgentResource;
+}
+export interface AgentResourcePage {
+    items: ResolvedAgentResource[];
+    nextCursor: number | null;
+}
+export interface ResolveAgentResourcesInput {
+    /** Searches provider names, resource titles, and descriptions; maximum 80 characters. */
+    query?: string;
+    /** Page size from 1 through 50; defaults to 20. */
+    limit?: number;
+    /** Zero-based result offset; defaults to 0. */
+    cursor?: number;
+}
+export interface AgentProviderCatalog {
+    merchant: AgentResourceProvider & {
+        payoutAddress: EvmAddress;
+        createdAt: string;
+    };
+    offers: AgentResource[];
+}
 export interface MerchantSale {
     id: string;
     state: string;
@@ -134,6 +183,66 @@ export interface SaleDetails {
     responseHash: string | null;
     deliveryReceipts: unknown[];
 }
+export interface WorkTicketSummary {
+    id: string;
+    buyer: EvmAddress;
+    merchantId: string;
+    capability: string;
+    inputHash: string;
+    maxPriceAtomic: string;
+    maxPriceUSDC: string;
+    state: WorkTicketState;
+    createdAt: string;
+    expiresAt: string;
+    claimExpiresAt: string | null;
+    quote: null | {
+        id: string;
+        amount: string;
+        amountAtomic: string;
+        amountUSDC: string;
+        deliverable: string;
+        contentType: ArtifactContentType;
+        termsHash: string;
+        expiresAt: string;
+    };
+    payment: {
+        operationId: string | null;
+        transaction: TransactionHash | null;
+    };
+    result: {
+        sha256: string | null;
+        contentType: ArtifactContentType | null;
+    };
+    buyerReceipt: null | {
+        verdict: "accepted" | "disputed";
+        challengeId: string;
+        message: string;
+        signature: EvmSignature;
+        createdAt: string;
+    };
+}
+/** Authenticated inbox/detail/claim responses include private input, or null after retention. */
+export interface MerchantWorkTicket extends WorkTicketSummary {
+    input: unknown;
+}
+/** Public status excludes the buyer wallet, private input, and signed buyer receipt. */
+export type PublicWorkTicket = Omit<WorkTicketSummary, "buyer" | "buyerReceipt">;
+export interface WorkTicketInbox {
+    tickets: MerchantWorkTicket[];
+}
+export interface MerchantWorkQuoteInput {
+    priceUSDC: string;
+    deliverable: string;
+    contentType: ArtifactContentType;
+    expiresInSeconds: number;
+}
+export type MerchantWorkResultInput = {
+    contentType: "application/json";
+    result: JsonValue;
+} | {
+    contentType: "text/plain; charset=utf-8";
+    result: string;
+};
 export interface MerchantClientOptions {
     /** Defaults to https://evidence.contact. */
     baseUrl?: string;
@@ -183,7 +292,7 @@ export declare class MerchantApiError extends Error {
     constructor(status: number, code: string, message: string);
 }
 /**
- * Minimal, dependency-free HTTP client for 402Mob merchant enrollment and management.
+ * Minimal, dependency-free HTTP client for 402Mob agent resource resolution and merchant management.
  * It never signs messages, submits wallet transactions, persists API keys, or retries requests.
  */
 export declare class MerchantClient {
@@ -211,6 +320,12 @@ export declare class MerchantClient {
     rotateWithSignature(input: CredentialRotationSignatureInput): Promise<CredentialRotationResult>;
     rotateWithTransaction(input: CredentialRotationTransactionInput): Promise<CredentialRotationResult>;
     getMerchant(): Promise<MerchantWorkspace>;
+    /** Search publicly discoverable prepared resources. This read-only call needs no API key. */
+    resolveResources(input?: ResolveAgentResourcesInput): Promise<AgentResourcePage>;
+    /** Read one provider's public profile and published resource descriptors by known ID. */
+    getProviderResources(merchantId: string): Promise<AgentProviderCatalog>;
+    /** Resolve an older resource ID to its currently published version. This call is public. */
+    resolveLatestResource(merchantId: string, offerId: string): Promise<ResolvedAgentResource>;
     setDiscoverable(discoverable: boolean): Promise<{
         merchantId: string;
         discoverable: boolean;
@@ -219,6 +334,34 @@ export declare class MerchantClient {
     setOfferActive(offerId: string, active: boolean): Promise<MerchantOffer>;
     listSales(limit?: number): Promise<SaleList>;
     getSale(operationId: string): Promise<SaleDetails>;
+    /** Read this merchant's private work inbox; requires the merchant:work scope. */
+    listWorkTickets(input?: {
+        states?: WorkTicketState[];
+        limit?: number;
+    }): Promise<WorkTicketInbox>;
+    /** Public progress and recovery metadata; no API key, private input, or result bytes. */
+    getWorkTicketStatus(ticketId: string): Promise<{
+        ticket: PublicWorkTicket;
+    }>;
+    /** Claim a ticket addressed to this merchant for a bounded lease. */
+    claimWorkTicket(ticketId: string, leaseSeconds?: number): Promise<{
+        ticket: MerchantWorkTicket;
+    }>;
+    /** Submit one fixed quote; the server rejects amounts above the buyer-signed cap. */
+    quoteWorkTicket(ticketId: string, input: MerchantWorkQuoteInput): Promise<{
+        ticket: WorkTicketSummary;
+        acceptanceChallenge: string;
+    }>;
+    /** Read this merchant's own ticket, including input and buyer receipt metadata. */
+    getWorkTicket(ticketId: string): Promise<{
+        ticket: MerchantWorkTicket;
+    }>;
+    /** Submit a bounded result after the checkout operation is confirmed settled. */
+    submitWorkTicketResult(ticketId: string, input: MerchantWorkResultInput): Promise<{
+        ticket: WorkTicketSummary;
+        buyerResultChallenge: string;
+        retentionDays: number;
+    }>;
     private request;
 }
 export {};

package/dist/index.js

@@ -9,7 +9,7 @@ export class MerchantApiError extends Error {
     }
 }
 /**
- * Minimal, dependency-free HTTP client for 402Mob merchant enrollment and management.
+ * Minimal, dependency-free HTTP client for 402Mob agent resource resolution and merchant management.
  * It never signs messages, submits wallet transactions, persists API keys, or retries requests.
  */
 export class MerchantClient {
@@ -97,6 +97,52 @@ export class MerchantClient {
     getMerchant() {
         return this.request("GET", "/v1/agent/merchant", undefined, true);
     }
+    /** Search publicly discoverable prepared resources. This read-only call needs no API key. */
+    async resolveResources(input = {}) {
+        const query = input.query ?? "";
+        const limit = input.limit ?? 20;
+        const cursor = input.cursor ?? 0;
+        if (typeof query !== "string" || query.trim().length > 80) {
+            throw new TypeError("query must be a string no longer than 80 characters.");
+        }
+        if (!Number.isInteger(limit) || limit < 1 || limit > 50) {
+            throw new TypeError("limit must be an integer from 1 through 50.");
+        }
+        if (!Number.isSafeInteger(cursor) || cursor < 0 || cursor > 100_000_000) {
+            throw new TypeError("cursor must be an integer from 0 through 100000000.");
+        }
+        const params = new URLSearchParams({ q: query.trim(), limit: String(limit), cursor: String(cursor) });
+        const payload = await this.request("GET", `/v1/merchant-directory?${params}`);
+        if (!isRecord(payload) || !Array.isArray(payload.items) ||
+            !(payload.nextCursor === null || (Number.isSafeInteger(payload.nextCursor) && payload.nextCursor >= 0)) ||
+            !payload.items.every(isResolvedAgentResource)) {
+            throw invalidPublicResponse();
+        }
+        return payload;
+    }
+    /** Read one provider's public profile and published resource descriptors by known ID. */
+    async getProviderResources(merchantId) {
+        if (!nonempty(merchantId))
+            throw new TypeError("merchantId must be a nonempty string.");
+        const payload = await this.request("GET", `/v1/merchants/${encodeURIComponent(merchantId)}`);
+        if (!isRecord(payload) || !isProviderProfile(payload.merchant) || !Array.isArray(payload.offers) ||
+            !payload.offers.every(isAgentResource)) {
+            throw invalidPublicResponse();
+        }
+        return payload;
+    }
+    /** Resolve an older resource ID to its currently published version. This call is public. */
+    async resolveLatestResource(merchantId, offerId) {
+        if (!nonempty(merchantId) || !nonempty(offerId)) {
+            throw new TypeError("merchantId and offerId must be nonempty strings.");
+        }
+        const path = `/v1/merchants/${encodeURIComponent(merchantId)}/offers/${encodeURIComponent(offerId)}/latest`;
+        const payload = await this.request("GET", path);
+        if (!isRecord(payload) || !isPublicProvider(payload.merchant) || !isAgentResource(payload.offer)) {
+            throw invalidPublicResponse();
+        }
+        return payload;
+    }
     setDiscoverable(discoverable) {
         return this.request("PUT", "/v1/agent/merchant/discovery", { discoverable }, true);
     }
@@ -113,6 +159,44 @@ export class MerchantClient {
     getSale(operationId) {
         return this.request("GET", `/v1/agent/merchant/sales/${encodeURIComponent(operationId)}`, undefined, true);
     }
+    /** Read this merchant's private work inbox; requires the merchant:work scope. */
+    listWorkTickets(input = {}) {
+        const limit = input.limit ?? 20;
+        if (!Number.isInteger(limit) || limit < 1 || limit > 50)
+            throw new TypeError("limit must be an integer from 1 through 50.");
+        const query = new URLSearchParams({ limit: String(limit) });
+        if (input.states !== undefined) {
+            if (!Array.isArray(input.states) || input.states.length === 0 || input.states.length > 10 || !input.states.every(state => workTicketStates.includes(state))) {
+                throw new TypeError("states must contain 1–10 supported Work Ticket states.");
+            }
+            query.set("states", input.states.join(","));
+        }
+        return this.request("GET", `/v1/agent/work-tickets?${query}`, undefined, true);
+    }
+    /** Public progress and recovery metadata; no API key, private input, or result bytes. */
+    getWorkTicketStatus(ticketId) {
+        return this.request("GET", `/v1/work-tickets/${checkedWorkTicketId(ticketId)}`);
+    }
+    /** Claim a ticket addressed to this merchant for a bounded lease. */
+    claimWorkTicket(ticketId, leaseSeconds = 600) {
+        if (!Number.isInteger(leaseSeconds) || leaseSeconds < 30 || leaseSeconds > 3600)
+            throw new TypeError("leaseSeconds must be an integer from 30 through 3600.");
+        return this.request("POST", `/v1/agent/work-tickets/${checkedWorkTicketId(ticketId)}/claims`, { leaseSeconds }, true);
+    }
+    /** Submit one fixed quote; the server rejects amounts above the buyer-signed cap. */
+    quoteWorkTicket(ticketId, input) {
+        if (!Number.isInteger(input.expiresInSeconds) || input.expiresInSeconds < 30 || input.expiresInSeconds > 3600)
+            throw new TypeError("expiresInSeconds must be an integer from 30 through 3600.");
+        return this.request("POST", `/v1/agent/work-tickets/${checkedWorkTicketId(ticketId)}/quotes`, input, true);
+    }
+    /** Read this merchant's own ticket, including input and buyer receipt metadata. */
+    getWorkTicket(ticketId) {
+        return this.request("GET", `/v1/agent/work-tickets/${checkedWorkTicketId(ticketId)}`, undefined, true);
+    }
+    /** Submit a bounded result after the checkout operation is confirmed settled. */
+    submitWorkTicketResult(ticketId, input) {
+        return this.request("POST", `/v1/agent/work-tickets/${checkedWorkTicketId(ticketId)}/results`, input, true);
+    }
     async request(method, path, body, authenticated = false) {
         if (authenticated && !this.#apiKey) {
             throw new Error("This request requires a merchant API key. Use client.withApiKey(apiKey).");
@@ -124,6 +208,7 @@ export class MerchantClient {
             headers.Authorization = `Bearer ${this.#apiKey}`;
         const response = await this.fetcher(new URL(`${this.baseUrl}${path}`), {
             method,
+            redirect: "error",
             headers,
             ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
         });
@@ -167,3 +252,39 @@ function isRecord(value) {
 }
 function nonempty(value) { return typeof value === "string" && value.trim().length > 0; }
 function address(value) { return typeof value === "string" && /^0x[0-9a-fA-F]{40}$/.test(value); }
+function isAgentResource(value) {
+    if (!isRecord(value))
+        return false;
+    const amountAtomic = value.amountAtomic;
+    const amountUSDC = value.amountUSDC;
+    return nonempty(value.id) && nonempty(value.seriesId) && nonempty(value.version) &&
+        nonempty(value.title) && typeof value.description === "string" &&
+        typeof amountAtomic === "string" && /^[1-9][0-9]*$/.test(amountAtomic) &&
+        typeof amountUSDC === "string" && /^(0|[1-9][0-9]*)(\.[0-9]{1,6})?$/.test(amountUSDC) &&
+        (value.contentType === "application/json" || value.contentType === "text/plain; charset=utf-8") &&
+        nonempty(value.latest) && nonempty(value.checkout) && nonempty(value.directTransferChallenge) &&
+        (value.supersedesOfferId === undefined || value.supersedesOfferId === null || nonempty(value.supersedesOfferId));
+}
+function isResolvedAgentResource(value) {
+    if (!isRecord(value) || !isRecord(value.merchant))
+        return false;
+    return nonempty(value.merchant.id) && nonempty(value.merchant.name) && nonempty(value.merchant.profile) &&
+        isAgentResource(value.offer);
+}
+function isProviderProfile(value) {
+    return isRecord(value) && nonempty(value.id) && nonempty(value.name) && address(value.payoutAddress) &&
+        nonempty(value.createdAt) && Number.isFinite(Date.parse(value.createdAt));
+}
+function isPublicProvider(value) {
+    return isRecord(value) && nonempty(value.id) && nonempty(value.name) && address(value.payoutAddress);
+}
+function invalidPublicResponse() {
+    return new MerchantApiError(200, "invalid_response", "402Mob returned an incomplete public resource response.");
+}
+const workTicketStates = ["open", "claimed", "quoted", "accepted", "paying", "paid", "delivered", "accepted_by_buyer", "disputed", "expired"];
+function checkedWorkTicketId(id) {
+    if (typeof id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id)) {
+        throw new TypeError("ticketId must be a UUID.");
+    }
+    return id;
+}

package/examples/enroll-and-publish.ts

@@ -3,7 +3,7 @@ import {
   type EvmAddress,
   type EvmSignature,
   type MerchantOffer,
-} from "../src/index.js";
+} from "../dist/index.js";
 
 export interface MessageSigningWallet {
   address: EvmAddress;
@@ -21,6 +21,7 @@ export interface SecretStore {
 export async function enrollAndPublish(input: {
   wallet: MessageSigningWallet;
   secretStore: SecretStore;
+  discoverable?: boolean;
 }): Promise<{ offer: MerchantOffer; merchantClient: MerchantClient }> {
   const publicClient = new MerchantClient();
   const enrollment = await publicClient.enrollWithSignature({
@@ -38,6 +39,7 @@ export async function enrollAndPublish(input: {
     contentType: "application/json",
     result: { summary: "Prepared by the seller agent" },
   });
+  if (input.discoverable) await merchantClient.setDiscoverable(true);
 
   return { offer, merchantClient };
 }

package/examples/resolve-resources.ts

@@ -0,0 +1,19 @@
+import { MerchantClient, type ResolveAgentResourcesInput } from "../dist/index.js";
+
+/** Public, read-only discovery for a buyer agent; checkout remains a separate step. */
+export async function resolveAgentResources(input: ResolveAgentResourcesInput = {}) {
+  const buyer = new MerchantClient();
+  const page = await buyer.resolveResources(input);
+
+  return page.items.map(({ merchant, offer }) => ({
+    providerId: merchant.id,
+    providerName: merchant.name,
+    offerId: offer.id,
+    title: offer.title,
+    description: offer.description,
+    amountUSDC: offer.amountUSDC,
+    contentType: offer.contentType,
+    checkout: offer.checkout,
+    latest: offer.latest,
+  }));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "402mob-merchant-sdk",
-  "version": "0.1.3",
-  "description": "Server-side TypeScript client for enrolling and operating 402Mob merchants.",
+  "version": "0.3.0",
+  "description": "TypeScript client for resolving agent resources and enrolling and operating 402Mob merchants.",
   "license": "MIT",
   "repository": {
     "type": "git",