402mob-merchant-sdk 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.6.0
+
+- Accept semantically identical inspection-plan property order in proposal responses while rejecting unknown or substituted fields.
+
+- Add the protected inspection seller example: reviewed worker publication, exact capability search and explicit buyer-funded proposal construction; no automatic signing or payment.
+
+- Add explicit protected inspection proposals/handoffs and `ProtectedInspectionClient`, isolated from direct Work Tickets and JSON escrow. A separate configured deployment is required; no signing or spending is added to the SDK.
+
+- Retain requested format, selected payout, title and proposal note in the grant input. Reject unexpected handoff fields and substituted request lifetimes. Proposal publication checks the 32 KiB canonical grant-input limit.
+
+- Add typed fresh-work request, proposal, preflight decline and signed-selection helpers with response/handoff validation. Direct selection returns a separately signed Work Ticket grant template; protected inspection selection returns an escrow task. Neither selection authorizes payment.
+- Existing prepared-offer demand methods remain unchanged. The SDK never signs, purchases external tests or broadcasts settlement transactions; spending authority remains in the caller runtime.
+
 ## 0.5.0
 
 - Add `ProtectedWorkClient` for the separate experimental JSON escrow HTTP API, generated request/response types and schema checks. Pin contract/verifier; validate read challenges, signing domains and transaction targets. No signing, broadcasting, automatic retry or replica management. Includes protocol integration tests and an example. Earlier versions do not include these methods.

package/README.md

@@ -1,6 +1,9 @@
 # 402Mob Merchant SDK
 
-Version 0.5.0 adds wallet-signed delivery complaints and the separate `ProtectedWorkClient` for experimental JSON escrow. Install `402mob-merchant-sdk@0.5.0` for these methods; earlier versions do not include them.
+**Version 0.6.0** adds fresh-work proposals and `ProtectedInspectionClient`, plus a seller example for advertising buyer-funded inspections. Use `402mob-merchant-sdk@0.6.0` and check the target server’s `workRequests` and `protectedInspections` capabilities before starting.
+
+
+Version 0.5.0 adds wallet-signed delivery complaints and the separate `ProtectedWorkClient` for experimental JSON escrow. Install `402mob-merchant-sdk@0.6.0` for these methods; earlier versions do not include them.
 
 **Version 0.4.0** adds worker profiles and discovery, public buyer requests and newest-first Work Ticket reads. Upgrade from 0.3.1 to use these additions. Check the target server's `/v1/capabilities` first; new worker routes require `workerDiscovery`. See [CHANGELOG.md](./CHANGELOG.md).
 
@@ -254,7 +257,7 @@ To test a local build in another project, install the generated file with `npm i
 
 The SDK tests use mocked HTTP responses and type-check every bundled example. They do not contact `evidence.contact` or submit wallet transactions. Service integration tests in the main repository cover actual local HTTP/enrollment signatures; Work Ticket and public-request live Base validation remain pending.
 
-Examples included in the tarball import the built package output: [enroll and publish](./examples/enroll-and-publish.ts), [resolve prepared resources](./examples/resolve-resources.ts), [worker discovery](./examples/worker-discovery.ts), and [signed request to checkout handoff](./examples/request-to-checkout.ts).
+Examples included in the tarball import the built package output: [enroll and publish](./examples/enroll-and-publish.ts), [resolve prepared resources](./examples/resolve-resources.ts), [worker discovery](./examples/worker-discovery.ts), [signed request to checkout handoff](./examples/request-to-checkout.ts), and [protected inspection service](./examples/protected-inspection-service.ts).
 
 MIT licensed. See [LICENSE](./LICENSE).
 
@@ -312,3 +315,21 @@ Dispute writes require `binding` from a fresh signed read. Read challenges conta
 `ProtectedWorkClient` covers all primary protected-work HTTP endpoints with generated OpenAPI types and request/response validation. It requires a pinned contract and verifier hash for job operations, checks signing domains, exact read challenges, transaction targets and approval amounts, and sends no merchant credential. It does not hold keys, sign, broadcast, decode every transaction, verify cryptographic commitments or automatically retry. A configured server may relay signed actions; funding is never relayed.
 
 Start with `new ProtectedWorkClient({baseUrl}).getCapabilities()` and stop when `configured` is false. The isolated Base test does not activate production. SDK helpers have HTTP integration coverage with simulated chain state; the Base test used direct HTTP. Use version 0.5.0 for these helpers. See [the full client guide](https://evidence.contact/merchant-sdk.md#protected-json-work-source-050), [protocol](https://evidence.contact/protected-work.md) and [source examples](examples/protected-work.ts). Replica consent/upload/decision calls remain separate verifier HTTP calls; there are no protected-work CLI, Python wallet or hosted MCP action helpers.
+
+## Fresh-work requests (0.6.0)
+
+Use `createWorkRequestChallenge` / `completeWorkRequest` to publish a buyer-signed public need with acceptance criteria, then `listWorkRequests` / `getWorkRequest` to read it. A merchant client can `proposeWorkRequest` with its declared accepting capability, fee, proposed deadline and seller-funded test budget, or `declineWorkRequest` with a free preflight reason. One immutable response per merchant is allowed.
+
+`createWorkRequestSelectionChallenge` / `selectWorkRequestProposal` require the buyer's separate EIP-191 signature. For direct proposals, the SDK validates the returned `workTicketHandoff`, including its exact input fields and the selected format, payout and proposal note. Add the intended buyer wallet and a new persisted grant idempotency key, then follow the existing Work Ticket grant, quote acceptance and payment flow. Selection creates no ticket or payment and does not track either. The deadline and test budget are declarations, not escrow or wallet spending limits. Inputs and responses are public; never include live payment authorizations or secrets.
+
+See [the auditor response example](examples/respond-to-work-request.ts) and [the protocol guide](https://evidence.contact/work-requests.md). Existing wallet/CLI/Python packages do not yet wrap these routes; retain credentials in your runtime and use HTTP/MCP or this SDK.
+
+The grant input is limited to 32 KiB in canonical JSON; an oversized proposal is rejected before it becomes immutable. Compare the actual quote with the retained proposal terms before signing, and check that its deadline is still useful. The copied format/payout/deadline fields are review context, not extra Work Ticket enforcement. Reuse the saved grant key after timeouts; another key can create another ticket. Public demand proves neither buyer funds nor authorization to test an external endpoint. For direct proposals, external test costs remain the seller’s risk, and a free decline does not reimburse them. Explicit protected inspection proposals instead use buyer-funded probes and a separate escrow handoff; see below.
+
+## Protected inspections (0.6.0)
+
+`ProtectedInspectionClient` provides the separate inspection HTTP flow: `getCapabilities`, `prepare`, `prepareFunding` (including the exact task), `getJob`, `createReadChallenge`, `submitObservation`, `start`, candidate submission, replicas, evaluation, result reads and settlement/appeal transaction preparation. Pin the new inspection contract and verifier hash. There is no signing, external HTTP probe, automatic retry or transaction broadcast in this client. The source probe script lives in the service repository. Negative observations may satisfy the narrow paid task; HTTP truth and general audit quality are not certified. Stop on `configured:false`; the separate same-operator pilot is configured, but its full funded lifecycle has not been live-money tested. See https://evidence.contact/protected-inspections.md.
+
+### Offer a protected inspection service
+
+Use the free [service recipe](https://evidence.contact/protected-inspection-service.json) and [seller walkthrough](https://evidence.contact/protected-inspections.md#offer-this-service). Publish the reviewed `payment-readiness-inspection` worker profile, then propose an explicit protected inspection against an actual `/v1/work-requests` record. Profile writes replace existing capabilities. Buyer selection returns `protectedWorkHandoff`; it does not authorize payment. This is not a prepared-artifact offer or Payment Link. Require confirmed escrow and retained buyer evidence before work. SDK 0.6.0 includes `examples/protected-inspection-service.ts`; earlier SDK 0.5.0 can advertise/search profiles but lacks fresh-proposal and inspection helpers. No automatic job inbox or notification is provided.

package/dist/index.d.ts

@@ -425,6 +425,108 @@ export interface WorkerDirectoryPage {
     items: WorkerProfileView[];
     nextCursor: number | null;
 }
+export interface FreshWorkRequestInput extends BuyerRequestInput {
+    acceptanceCriteria: string[];
+}
+export interface InspectionPlan {
+    version: "buyer-probe-v1";
+    targetUrl: string;
+    method: "GET";
+    paymentRecipient: EvmAddress;
+    maxTestAmountAtomic: string;
+    maxPaidAttempts: 1;
+}
+export interface FreshWorkProposalInput {
+    capability: string;
+    deliverable: string;
+    priceUSDC: string;
+    deliveryDeadline: string;
+    testPurchaseBudgetUSDC: string;
+    testPurchasePayer: "seller" | "buyer";
+    note: string;
+    settlementMode?: "protected_inspection";
+    inspection?: InspectionPlan;
+}
+export interface FreshWorkDeclineInput {
+    reason: "endpoint_unavailable" | "unsupported_payment" | "scope_unsupported" | "capacity_unavailable" | "other";
+    note: string;
+}
+export interface PublicFreshWorkRequest extends Omit<FreshWorkRequestInput, "buyer"> {
+    id: string;
+    kind: "fresh";
+    state: "open" | "selected" | "expired";
+    createdAt: string;
+    expiresAt: string;
+    selectedProposalId: string | null;
+}
+export type FreshWorkResponse = {
+    id: string;
+    requestId: string;
+    merchantId: string;
+    payoutAddress: EvmAddress;
+    termsHash: string;
+    createdAt: string;
+} & ({
+    kind: "proposal";
+    terms: FreshWorkProposalInput;
+} | {
+    kind: "decline";
+    terms: FreshWorkDeclineInput;
+});
+export interface FreshWorkHandoff {
+    kind: "work_ticket_grant";
+    method: "POST";
+    path: "/v1/work-tickets/challenges";
+    body: {
+        merchantId: string;
+        capability: string;
+        input: {
+            workRequestId: string;
+            proposalId: string;
+            proposalTermsHash: string;
+            title: string;
+            contentType: ArtifactContentType;
+            payoutAddress: EvmAddress;
+            proposalNote: string;
+            scope: string;
+            acceptanceCriteria: string[];
+            deliverable: string;
+            deliveryDeadline: string;
+            testPurchaseBudgetUSDC: string;
+            testPurchasePayer: "seller";
+        };
+        maxPriceUSDC: string;
+        expiresInSeconds: number;
+    };
+    buyerWalletRequired: true;
+    grantSignatureRequired: true;
+    paymentAuthorized: false;
+    quoteAcceptanceRequired: true;
+    tracksTicketCreation: false;
+}
+export interface InspectionHandoff {
+    kind: "protected_inspection";
+    path: "/v1/protected-inspections/prepare";
+    task: {
+        version: "funded-inspection-v1";
+        requestId: string;
+        proposalId: string;
+        proposalTermsHash: string;
+        plan: InspectionPlan;
+    };
+    seller: EvmAddress;
+    amountAtomic: string;
+    deliveryDeadline: number;
+    fundingRequired: true;
+    buyerProbeRequired: true;
+    paymentAuthorized: false;
+}
+export interface FreshWorkDetail {
+    request: PublicFreshWorkRequest;
+    responses: FreshWorkResponse[];
+    workTicketHandoff: FreshWorkHandoff | null;
+    protectedWorkHandoff: InspectionHandoff | null;
+}
 export interface BuyerRequestInput {
     buyer: EvmAddress;
     title: string;
@@ -607,6 +709,41 @@ export declare class MerchantClient {
         retentionDays: number;
     }>;
     /** Free public demand. Caller persists the key, signs the returned message and completes separately. */
+    createWorkRequestChallenge(input: FreshWorkRequestInput, idempotencyKey: string): Promise<BuyerRequestChallenge>;
+    completeWorkRequest(input: FreshWorkRequestInput & {
+        challengeId: string;
+        signature: EvmSignature;
+    }, idempotencyKey: string): Promise<FreshWorkDetail & {
+        replay: boolean;
+    }>;
+    listWorkRequests(input?: ResolveAgentResourcesInput): Promise<{
+        items: PublicFreshWorkRequest[];
+        nextCursor: number | null;
+    }>;
+    getWorkRequest(id: string): Promise<FreshWorkDetail>;
+    proposeWorkRequest(id: string, input: FreshWorkProposalInput): Promise<{
+        response: FreshWorkResponse;
+        replay: boolean;
+    }>;
+    declineWorkRequest(id: string, input: FreshWorkDeclineInput): Promise<{
+        response: FreshWorkResponse;
+        replay: boolean;
+    }>;
+    createWorkRequestSelectionChallenge(id: string, input: {
+        buyer: EvmAddress;
+        proposalId: string;
+    }): Promise<{
+        challengeId: string;
+        message: string;
+        expiresAt: string;
+        proposal: FreshWorkResponse;
+    }>;
+    selectWorkRequestProposal(id: string, input: {
+        challengeId: string;
+        signature: EvmSignature;
+    }): Promise<FreshWorkDetail & {
+        replay: boolean;
+    }>;
     createBuyerRequestChallenge(input: BuyerRequestInput, idempotencyKey: string): Promise<BuyerRequestChallenge>;
     completeBuyerRequest(input: BuyerRequestInput & {
         challengeId: string;
@@ -655,3 +792,6 @@ export declare class MerchantClient {
 export { ProtectedWorkClient, ProtectedWorkApiError } from "./protected-work.js";
 export type { ProtectedWorkClientOptions } from "./protected-work.js";
 export type * from "./protected-work-types.js";
+export { ProtectedInspectionClient, ProtectedInspectionApiError } from "./protected-inspection.js";
+export type * from "./protected-inspection-types.js";
+export type { ProtectedInspectionClientOptions } from "./protected-inspection.js";

package/dist/index.js

@@ -250,6 +250,23 @@ export class MerchantClient {
         return this.request("POST", `/v1/agent/work-tickets/${checkedWorkTicketId(ticketId)}/results`, input, true);
     }
     /** Free public demand. Caller persists the key, signs the returned message and completes separately. */
+    createWorkRequestChallenge(input, idempotencyKey) { return this.request("POST", "/v1/work-requests/challenges", input, false, { "Idempotency-Key": idempotencyKey }); }
+    completeWorkRequest(input, idempotencyKey) { return this.request("POST", "/v1/work-requests", input, false, { "Idempotency-Key": idempotencyKey }); }
+    listWorkRequests(input = {}) {
+        const q = new URLSearchParams();
+        if (input.query !== undefined)
+            q.set("q", input.query);
+        if (input.limit !== undefined)
+            q.set("limit", String(input.limit));
+        if (input.cursor !== undefined)
+            q.set("cursor", String(input.cursor));
+        return this.request("GET", "/v1/work-requests?" + q);
+    }
+    getWorkRequest(id) { return this.request("GET", `/v1/work-requests/${encodeURIComponent(id)}`); }
+    proposeWorkRequest(id, input) { return this.request("POST", `/v1/agent/work-requests/${encodeURIComponent(id)}/proposals`, input, true); }
+    declineWorkRequest(id, input) { return this.request("POST", `/v1/agent/work-requests/${encodeURIComponent(id)}/declines`, input, true); }
+    createWorkRequestSelectionChallenge(id, input) { return this.request("POST", `/v1/work-requests/${encodeURIComponent(id)}/selection-challenges`, input); }
+    selectWorkRequestProposal(id, input) { return this.request("POST", `/v1/work-requests/${encodeURIComponent(id)}/selections`, input); }
     createBuyerRequestChallenge(input, idempotencyKey) {
         return this.request("POST", "/v1/buyer-requests/challenges", input, false, { "Idempotency-Key": buyerRequestKey(idempotencyKey) });
     }
@@ -346,6 +363,8 @@ export class MerchantClient {
             if (method === "PUT" && JSON.stringify(normalizedWorkerProfile(payload.workerProfile)) !== JSON.stringify(body))
                 throw invalidResponse();
         }
+        if ((path.startsWith("/v1/work-requests") || path.startsWith("/v1/agent/work-requests/")) && !isFreshWorkResponse(method, path, payload, body))
+            throw invalidResponse();
         if ((path.startsWith("/v1/buyer-requests") || path.startsWith("/v1/agent/buyer-requests/")) && !isBuyerRequestResponse(method, path, payload, body))
             throw invalidResponse();
         if (path === "/v1/merchants/enrollment-challenges" || path === "/v1/merchants/credential-challenges") {
@@ -627,3 +646,75 @@ function isDisputeResponse(v, operationId, proof, origin) {
     return true;
 }
 export { ProtectedWorkClient, ProtectedWorkApiError } from "./protected-work.js";
+function isFreshRequest(v) {
+    if (!isRecord(v) || Object.hasOwn(v, "buyer"))
+        return false;
+    return uuid(v.id) && v.kind === "fresh" && publicText(v.title, 100) && publicText(v.description, 2000) && usdcAtomic(v.maxPriceUSDC) !== undefined && Number(usdcAtomic(v.maxPriceUSDC)) > 0 && artifactType(v.contentType) && Array.isArray(v.acceptanceCriteria) && v.acceptanceCriteria.length >= 1 && v.acceptanceCriteria.length <= 10 && v.acceptanceCriteria.every(x => publicText(x, 300)) && Number.isInteger(v.expiresInSeconds) && Number(v.expiresInSeconds) >= 60 && Number(v.expiresInSeconds) <= 86400 && timestamp(v.createdAt) && timestamp(v.expiresAt) && ["open", "selected", "expired"].includes(String(v.state)) && (v.state === "selected" ? uuid(v.selectedProposalId) : v.selectedProposalId === null);
+}
+function isInspectionPlan(v) {
+    if (!isRecord(v) || !freshExactKeys(v, ["version", "targetUrl", "method", "paymentRecipient", "maxTestAmountAtomic", "maxPaidAttempts"]) || v.version !== "buyer-probe-v1" || v.method !== "GET" || !address(v.paymentRecipient) || v.maxPaidAttempts !== 1 || typeof v.maxTestAmountAtomic !== "string" || !/^(?:0|[1-9][0-9]{0,5}|1000000)$/.test(v.maxTestAmountAtomic) || typeof v.targetUrl !== "string" || v.targetUrl.length > 2048)
+        return false;
+    try {
+        const u = new URL(v.targetUrl);
+        return u.protocol === "https:" && !u.username && !u.password && !u.hash && (!u.port || u.port === "443") && u.href === v.targetUrl;
+    }
+    catch {
+        return false;
+    }
+}
+function sameInspectionPlan(a, b) { return isInspectionPlan(a) && isInspectionPlan(b) && Object.entries(a).every(([key, value]) => value === b[key]); }
+function isFreshProposal(v) {
+    if (!isRecord(v) || !uuid(v.id) || !uuid(v.requestId) || !uuid(v.merchantId) || !address(v.payoutAddress) || !digest(v.termsHash) || !timestamp(v.createdAt) || !isRecord(v.terms) || !publicText(v.terms.note, 300))
+        return false;
+    const t = v.terms;
+    if (v.kind === "decline")
+        return ["endpoint_unavailable", "unsupported_payment", "scope_unsupported", "capacity_unavailable", "other"].includes(String(t.reason));
+    return v.kind === "proposal" && typeof t.capability === "string" && /^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/.test(t.capability) && publicText(t.deliverable, 300) && usdcAtomic(t.priceUSDC) !== undefined && Number(usdcAtomic(t.priceUSDC)) > 0 && timestamp(t.deliveryDeadline) && usdcAtomic(t.testPurchaseBudgetUSDC) !== undefined && (t.settlementMode === "protected_inspection" ? t.testPurchasePayer === "buyer" && isInspectionPlan(t.inspection) && t.inspection.maxTestAmountAtomic === usdcAtomic(t.testPurchaseBudgetUSDC) : t.settlementMode === undefined && t.inspection === undefined && t.testPurchasePayer === "seller");
+}
+function freshExactKeys(value, keys) {
+    return Object.keys(value).length === keys.length && keys.every(k => Object.hasOwn(value, k));
+}
+function isFreshDetail(v, id) {
+    if (!isRecord(v) || !isFreshRequest(v.request) || id && v.request.id !== id || !Array.isArray(v.responses) || v.responses.length > 20 || !v.responses.every(isFreshProposal))
+        return false;
+    const r = v.request, responses = v.responses;
+    if (new Set(responses.map(p => p.merchantId)).size !== responses.length || new Set(responses.map(p => p.id)).size !== responses.length || responses.some(p => p.requestId !== r.id || p.kind === "proposal" && BigInt(usdcAtomic(p.terms.priceUSDC)) > BigInt(usdcAtomic(r.maxPriceUSDC))))
+        return false;
+    if (r.state !== "selected")
+        return v.workTicketHandoff === null && v.protectedWorkHandoff === null;
+    const p = responses.find(p => p.id === r.selectedProposalId), h = v.workTicketHandoff;
+    if (p?.kind === "proposal" && p.terms.settlementMode === "protected_inspection") {
+        const x = v.protectedWorkHandoff;
+        if (h !== null || !isRecord(x) || x.kind !== "protected_inspection" || x.path !== "/v1/protected-inspections/prepare" || !isRecord(x.task))
+            return false;
+        return r.contentType === "application/json" && x.seller === p.payoutAddress && x.amountAtomic === usdcAtomic(p.terms.priceUSDC) && x.deliveryDeadline === Math.floor(Date.parse(p.terms.deliveryDeadline) / 1000) && x.fundingRequired === true && x.buyerProbeRequired === true && x.paymentAuthorized === false && x.task.version === "funded-inspection-v1" && x.task.requestId === r.id && x.task.proposalId === p.id && x.task.proposalTermsHash === p.termsHash && sameInspectionPlan(x.task.plan, p.terms.inspection) && freshExactKeys(x, ["kind", "path", "task", "seller", "amountAtomic", "deliveryDeadline", "fundingRequired", "buyerProbeRequired", "paymentAuthorized"]) && freshExactKeys(x.task, ["version", "requestId", "proposalId", "proposalTermsHash", "plan"]);
+    }
+    if (v.protectedWorkHandoff !== null)
+        return false;
+    if (!p || p.kind !== "proposal" || !isRecord(h) || h.kind !== "work_ticket_grant" || h.method !== "POST" || h.path !== "/v1/work-tickets/challenges" || h.buyerWalletRequired !== true || h.grantSignatureRequired !== true || h.paymentAuthorized !== false || h.quoteAcceptanceRequired !== true || h.tracksTicketCreation !== false || !isRecord(h.body) || !isRecord(h.body.input))
+        return false;
+    const b = h.body, i = b.input;
+    if (!freshExactKeys(h, ["kind", "method", "path", "body", "buyerWalletRequired", "grantSignatureRequired", "paymentAuthorized", "quoteAcceptanceRequired", "tracksTicketCreation"]) || !freshExactKeys(b, ["merchantId", "capability", "input", "maxPriceUSDC", "expiresInSeconds"]) || !freshExactKeys(i, ["workRequestId", "proposalId", "proposalTermsHash", "title", "scope", "contentType", "acceptanceCriteria", "payoutAddress", "deliverable", "proposalNote", "deliveryDeadline", "testPurchaseBudgetUSDC", "testPurchasePayer"]))
+        return false;
+    return i.title === r.title && i.contentType === r.contentType && i.payoutAddress === p.payoutAddress && i.proposalNote === p.terms.note && b.merchantId === p.merchantId && b.capability === p.terms.capability && b.maxPriceUSDC === p.terms.priceUSDC && b.expiresInSeconds === 3600 && !Object.hasOwn(b, "buyer") && i.workRequestId === r.id && i.proposalId === p.id && i.proposalTermsHash === p.termsHash && i.scope === r.description && JSON.stringify(i.acceptanceCriteria) === JSON.stringify(r.acceptanceCriteria) && i.deliverable === p.terms.deliverable && i.deliveryDeadline === p.terms.deliveryDeadline && i.testPurchaseBudgetUSDC === p.terms.testPurchaseBudgetUSDC && i.testPurchasePayer === "seller";
+}
+function isFreshWorkResponse(method, path, v, body) {
+    const args = isRecord(body) ? body : {}, id = path.match(/^\/v1\/(?:agent\/)?work-requests\/([^/?]+)/)?.[1];
+    const challenge = () => uuid(v.challengeId) && nonempty(v.message) && timestamp(v.expiresAt);
+    if (path === "/v1/work-requests/challenges")
+        return challenge() && timestamp(v.requestExpiresAt) && digest(v.policyHash) && Date.parse(String(v.expiresAt)) <= Date.parse(String(v.requestExpiresAt));
+    if (path === "/v1/work-requests" && method === "POST")
+        return isFreshDetail(v) && typeof v.replay === "boolean" && v.request.title === String(args.title).trim() && v.request.description === String(args.description).trim() && v.request.contentType === args.contentType && v.request.expiresInSeconds === args.expiresInSeconds && usdcAtomic(v.request.maxPriceUSDC) === usdcAtomic(args.maxPriceUSDC) && JSON.stringify(v.request.acceptanceCriteria) === JSON.stringify(args.acceptanceCriteria?.map(x => typeof x === 'string' ? x.trim() : x));
+    if (path.startsWith("/v1/work-requests?") || path === "/v1/work-requests" && method === "GET")
+        return Array.isArray(v.items) && v.items.length <= 50 && v.items.every(isFreshRequest) && (v.nextCursor === null || Number.isSafeInteger(v.nextCursor) && Number(v.nextCursor) >= 0);
+    if (path.endsWith("/selection-challenges"))
+        return challenge() && isFreshProposal(v.proposal) && v.proposal.kind === "proposal" && v.proposal.requestId === id && v.proposal.id === args.proposalId;
+    if (path.endsWith("/proposals") || path.endsWith("/declines")) {
+        if (!isFreshProposal(v.response) || v.response.requestId !== id || v.response.kind !== (path.endsWith("/proposals") ? "proposal" : "decline") || typeof v.replay !== "boolean")
+            return false;
+        const terms = v.response.terms;
+        return Object.entries(args).every(([k, x]) => k === "inspection" ? sameInspectionPlan(terms[k], x) : ["priceUSDC", "testPurchaseBudgetUSDC"].includes(k) ? usdcAtomic(terms[k]) === usdcAtomic(x) : JSON.stringify(terms[k]) === JSON.stringify(typeof x === 'string' ? x.trim() : x));
+    }
+    return isFreshDetail(v, id) && (method === "GET" || v.request.state === "selected" && typeof v.replay === "boolean");
+}
+export { ProtectedInspectionClient, ProtectedInspectionApiError } from "./protected-inspection.js";

package/dist/protected-inspection-schemas.d.ts

@@ -0,0 +1,2 @@
+export declare const inspectionSchemaHash = "8ce432ff8bb61355db7c2d01e7a5048ec20ed0688087df7094134788a81c81e7";
+export declare const inspectionSchemas: Record<string, unknown>;