@elisym/sdk 0.25.0 → 0.25.3

package/dist/index.d.cts

@@ -50,6 +50,51 @@ declare const FileTransportSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<
 }, {
     kind: "iroh";
     ticket: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"blossom">;
+    /** Public HTTP(S) URL of the CIPHERTEXT blob on a Blossom relay. */
+    url: z.ZodString;
+    /** sha256 (lowercase hex) of the ciphertext - what the relay stores and addresses. */
+    sha256: z.ZodString;
+    /**
+     * Hybrid-encryption parameters. The file bytes are AES-256-GCM encrypted with a random
+     * content key; that key is NIP-44-wrapped to the recipient. `name`/`mime`/`size` on the
+     * attachment describe the PLAINTEXT and live only inside the (encrypted) envelope - never
+     * sent to the relay (the relay only ever sees opaque ciphertext).
+     */
+    enc: z.ZodObject<{
+        alg: z.ZodLiteral<"AES-256-GCM">;
+        /** base64 12-byte GCM IV (non-secret). */
+        iv: z.ZodString;
+        /** NIP-44-wrapped content key. */
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        alg: "AES-256-GCM";
+        iv: string;
+        key: string;
+    }, {
+        alg: "AES-256-GCM";
+        iv: string;
+        key: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    kind: "blossom";
+    url: string;
+    sha256: string;
+    enc: {
+        alg: "AES-256-GCM";
+        iv: string;
+        key: string;
+    };
+}, {
+    kind: "blossom";
+    url: string;
+    sha256: string;
+    enc: {
+        alg: "AES-256-GCM";
+        iv: string;
+        key: string;
+    };
 }>]>;
 declare const FileAttachmentSchema: z.ZodObject<{
     /** Display name only. Never used to derive a filesystem path (callers sanitize). */
@@ -57,37 +102,62 @@ declare const FileAttachmentSchema: z.ZodObject<{
     /** Declared size in bytes (display/hint only; enforcement is on actual streamed bytes). */
     size: z.ZodNumber;
     mime: z.ZodString;
-    /** Ordered by sender preference; at least one. */
-    transports: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
-        kind: z.ZodLiteral<"iroh">;
-        /** Opaque iroh `BlobTicket` string. Parsed into a real ticket only at fetch time. */
-        ticket: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
+    /**
+     * Ordered by sender preference; at least one KNOWN transport. Parsed leniently: unknown
+     * transport `kind`s are dropped (not rejected) so adding a new transport never makes an older
+     * decoder throw away the whole envelope - it just ignores the kinds it doesn't know and uses
+     * the ones it does. At least one known transport must survive, else the attachment is invalid.
+     */
+    transports: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodUnknown, "many">, ({
         kind: "iroh";
         ticket: string;
-    }, {
+    } | {
+        kind: "blossom";
+        url: string;
+        sha256: string;
+        enc: {
+            alg: "AES-256-GCM";
+            iv: string;
+            key: string;
+        };
+    })[], unknown[]>, ({
         kind: "iroh";
         ticket: string;
-    }>]>, "many">;
+    } | {
+        kind: "blossom";
+        url: string;
+        sha256: string;
+        enc: {
+            alg: "AES-256-GCM";
+            iv: string;
+            key: string;
+        };
+    })[], unknown[]>;
     /** Optional provider hint (unix seconds) for when seeding may stop. */
     seedingExpiresAt: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     size: number;
     mime: string;
-    transports: {
+    transports: ({
         kind: "iroh";
         ticket: string;
-    }[];
+    } | {
+        kind: "blossom";
+        url: string;
+        sha256: string;
+        enc: {
+            alg: "AES-256-GCM";
+            iv: string;
+            key: string;
+        };
+    })[];
     seedingExpiresAt?: number | undefined;
 }, {
     name: string;
     size: number;
     mime: string;
-    transports: {
-        kind: "iroh";
-        ticket: string;
-    }[];
+    transports: unknown[];
     seedingExpiresAt?: number | undefined;
 }>;
 declare const JobPayloadEnvelopeSchema: z.ZodObject<{
@@ -99,39 +169,128 @@ declare const JobPayloadEnvelopeSchema: z.ZodObject<{
         /** Declared size in bytes (display/hint only; enforcement is on actual streamed bytes). */
         size: z.ZodNumber;
         mime: z.ZodString;
-        /** Ordered by sender preference; at least one. */
-        transports: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
-            kind: z.ZodLiteral<"iroh">;
-            /** Opaque iroh `BlobTicket` string. Parsed into a real ticket only at fetch time. */
-            ticket: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
+        /**
+         * Ordered by sender preference; at least one KNOWN transport. Parsed leniently: unknown
+         * transport `kind`s are dropped (not rejected) so adding a new transport never makes an older
+         * decoder throw away the whole envelope - it just ignores the kinds it doesn't know and uses
+         * the ones it does. At least one known transport must survive, else the attachment is invalid.
+         */
+        transports: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodUnknown, "many">, ({
             kind: "iroh";
             ticket: string;
-        }, {
+        } | {
+            kind: "blossom";
+            url: string;
+            sha256: string;
+            enc: {
+                alg: "AES-256-GCM";
+                iv: string;
+                key: string;
+            };
+        })[], unknown[]>, ({
             kind: "iroh";
             ticket: string;
-        }>]>, "many">;
+        } | {
+            kind: "blossom";
+            url: string;
+            sha256: string;
+            enc: {
+                alg: "AES-256-GCM";
+                iv: string;
+                key: string;
+            };
+        })[], unknown[]>;
         /** Optional provider hint (unix seconds) for when seeding may stop. */
         seedingExpiresAt: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         size: number;
         mime: string;
-        transports: {
+        transports: ({
             kind: "iroh";
             ticket: string;
-        }[];
+        } | {
+            kind: "blossom";
+            url: string;
+            sha256: string;
+            enc: {
+                alg: "AES-256-GCM";
+                iv: string;
+                key: string;
+            };
+        })[];
         seedingExpiresAt?: number | undefined;
     }, {
         name: string;
         size: number;
         mime: string;
-        transports: {
+        transports: unknown[];
+        seedingExpiresAt?: number | undefined;
+    }>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Display name only. Never used to derive a filesystem path (callers sanitize). */
+        name: z.ZodString;
+        /** Declared size in bytes (display/hint only; enforcement is on actual streamed bytes). */
+        size: z.ZodNumber;
+        mime: z.ZodString;
+        /**
+         * Ordered by sender preference; at least one KNOWN transport. Parsed leniently: unknown
+         * transport `kind`s are dropped (not rejected) so adding a new transport never makes an older
+         * decoder throw away the whole envelope - it just ignores the kinds it doesn't know and uses
+         * the ones it does. At least one known transport must survive, else the attachment is invalid.
+         */
+        transports: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodUnknown, "many">, ({
+            kind: "iroh";
+            ticket: string;
+        } | {
+            kind: "blossom";
+            url: string;
+            sha256: string;
+            enc: {
+                alg: "AES-256-GCM";
+                iv: string;
+                key: string;
+            };
+        })[], unknown[]>, ({
+            kind: "iroh";
+            ticket: string;
+        } | {
+            kind: "blossom";
+            url: string;
+            sha256: string;
+            enc: {
+                alg: "AES-256-GCM";
+                iv: string;
+                key: string;
+            };
+        })[], unknown[]>;
+        /** Optional provider hint (unix seconds) for when seeding may stop. */
+        seedingExpiresAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        size: number;
+        mime: string;
+        transports: ({
             kind: "iroh";
             ticket: string;
-        }[];
+        } | {
+            kind: "blossom";
+            url: string;
+            sha256: string;
+            enc: {
+                alg: "AES-256-GCM";
+                iv: string;
+                key: string;
+            };
+        })[];
         seedingExpiresAt?: number | undefined;
-    }>>;
+    }, {
+        name: string;
+        size: number;
+        mime: string;
+        transports: unknown[];
+        seedingExpiresAt?: number | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     v: "elisym-job/1";
     text?: string | undefined;
@@ -139,12 +298,40 @@ declare const JobPayloadEnvelopeSchema: z.ZodObject<{
         name: string;
         size: number;
         mime: string;
-        transports: {
+        transports: ({
             kind: "iroh";
             ticket: string;
-        }[];
+        } | {
+            kind: "blossom";
+            url: string;
+            sha256: string;
+            enc: {
+                alg: "AES-256-GCM";
+                iv: string;
+                key: string;
+            };
+        })[];
         seedingExpiresAt?: number | undefined;
     } | undefined;
+    attachments?: {
+        name: string;
+        size: number;
+        mime: string;
+        transports: ({
+            kind: "iroh";
+            ticket: string;
+        } | {
+            kind: "blossom";
+            url: string;
+            sha256: string;
+            enc: {
+                alg: "AES-256-GCM";
+                iv: string;
+                key: string;
+            };
+        })[];
+        seedingExpiresAt?: number | undefined;
+    }[] | undefined;
 }, {
     v: "elisym-job/1";
     text?: string | undefined;
@@ -152,21 +339,50 @@ declare const JobPayloadEnvelopeSchema: z.ZodObject<{
         name: string;
         size: number;
         mime: string;
-        transports: {
-            kind: "iroh";
-            ticket: string;
-        }[];
+        transports: unknown[];
         seedingExpiresAt?: number | undefined;
     } | undefined;
+    attachments?: {
+        name: string;
+        size: number;
+        mime: string;
+        transports: unknown[];
+        seedingExpiresAt?: number | undefined;
+    }[] | undefined;
 }>;
 type FileTransport = z.infer<typeof FileTransportSchema>;
 type FileAttachment = z.infer<typeof FileAttachmentSchema>;
 type JobPayloadEnvelope = z.infer<typeof JobPayloadEnvelopeSchema>;
-/** Decoded job payload: a free-text note and/or a file attachment. */
+/** The kinds of file transport a job can use ('iroh' | 'blossom'). */
+type TransportKind = FileTransport['kind'];
+/** Public job-request tag advertising which transports a customer can RECEIVE output on. */
+declare const ACCEPT_TRANSPORTS_TAG = "accept";
+/**
+ * Build the `['accept', ...kinds]` job-request tag from a client's RECEIVE-capable transports.
+ * Drops unknown kinds and dedupes, preserving the client's preference order.
+ */
+declare function buildAcceptTransportsTag(kinds: TransportKind[]): string[];
+/**
+ * Read accepted transports from an event's tags. Returns the ordered, deduped, known kinds, or
+ * `undefined` when there is no `accept` tag or it carries no known kind - both normalize to the
+ * provider's default (seed all transports). Lenient: unknown kinds (from a newer client) are ignored
+ * so this never strands a job.
+ */
+declare function readAcceptedTransports(tags: string[][]): TransportKind[] | undefined;
+/** Decoded job payload: a free-text note and/or file attachment(s). */
 interface DecodedJobPayload {
     text?: string;
+    /** Legacy single attachment (also mirrors `attachments[0]`). */
     attachment?: FileAttachment;
+    /** All attachments when a job carries multiple files. */
+    attachments?: FileAttachment[];
 }
+/**
+ * Normalize a decoded payload to the full attachment list, treating the legacy
+ * single `attachment` as a 1-element list. Use this everywhere instead of reading
+ * `.attachment`/`.attachments` directly, so single- and multi-file are uniform.
+ */
+declare function attachmentsOf(decoded: DecodedJobPayload): FileAttachment[];
 /**
  * Serialize a job payload into the envelope string that goes (encrypted) into a
  * Nostr event's `content`. Used only when an attachment is present; plain-text
@@ -208,6 +424,13 @@ interface CapabilityCard {
     inputMime?: string;
     /** MIME of a file result the capability produces (from `output_mime`). */
     outputMime?: string;
+    /**
+     * Whether a file-input capability ALSO accepts a text prompt (from `input_text`):
+     * `'none'` = file only, `'optional'` = file + optional note, `'required'` = both.
+     * Discovery hint; the web app shows/hides its text box accordingly. Only meaningful
+     * with `inputMime`. Untrusted - gate on it, never render the raw value.
+     */
+    inputText?: 'required' | 'optional' | 'none';
 }
 /** Payment info embedded in capability card (legacy format for on-network events). */
 interface PaymentInfo {
@@ -329,16 +552,23 @@ interface SubmitJobOptions {
      * itself travels out-of-band (P2P via iroh), not in the Nostr event.
      */
     attachment?: FileAttachment;
+    /**
+     * Ordered (by client preference) transports this customer can RECEIVE output on. Published as a
+     * public `accept` tag. When omitted, providers default to seeding all transports (back-compat);
+     * advertising `['iroh']` makes a provider skip the (encrypted-Blossom) upload it can't use.
+     */
+    acceptTransports?: TransportKind[];
 }
 interface JobUpdateCallbacks {
     onFeedback?: (status: string, amount?: number, paymentRequest?: string, senderPubkey?: string) => void;
     /**
      * Fired on a job result. `content` is the result text (for a file result, the
-     * envelope's text note, or `''`); `attachment` is the file descriptor when the
-     * result carries a file. The file is fetched separately (P2P via iroh), never
-     * inlined here.
+     * envelope's text note, or `''`); `attachment` is the FIRST file descriptor
+     * (= `attachments[0]`, kept for back-compat); `attachments` is the full list for
+     * a multi-file result. Files are fetched separately (P2P via iroh / Blossom),
+     * never inlined here.
      */
-    onResult?: (content: string, eventId: string, attachment?: FileAttachment) => void;
+    onResult?: (content: string, eventId: string, attachment?: FileAttachment, attachments?: FileAttachment[]) => void;
     onError?: (error: string) => void;
     /**
      * Fired when the result wait window expires without a result - a distinct,
@@ -553,6 +783,15 @@ declare class BlossomService {
     private serverUrl;
     private fallback?;
     constructor(serverUrl?: string, fallback?: BlossomUploadFallback | undefined);
+    /**
+     * The content-addressed GET URL for a blob, derivable from its sha256 BEFORE
+     * upload (BUD-01: `<serverUrl>/<sha256>`, no extension for our octet-stream
+     * ciphertext uploads - same form `delete` addresses by). Lets a caller build a
+     * complete attachment descriptor and defer the actual byte upload (the descriptor
+     * is submitted first, the bytes PUT later). `upload()` re-verifies the server
+     * returns this exact url.
+     */
+    contentUrl(sha256: string): string;
     /**
      * Upload a file to the Blossom server, returning its descriptor. On any failure, falls
      * back to the configured uploader (if any) and returns a normalized descriptor with
@@ -561,6 +800,15 @@ declare class BlossomService {
     upload(identity: ElisymIdentity, file: Blob): Promise<BlobDescriptor>;
     /** Delete a blob by sha256 (BUD-02). Blossom only - there is no fallback for deletes. */
     delete(identity: ElisymIdentity, sha256: string): Promise<void>;
+    /**
+     * Download a public blob (BUD-01 GET, no auth). Bounds memory on the ACTUAL streamed bytes (never
+     * the declared Content-Length) and verifies the sha256 when `expectedSha256` is given. Browser-safe.
+     */
+    download(url: string, opts?: {
+        maxBytes?: number;
+        timeoutMs?: number;
+        expectedSha256?: string;
+    }): Promise<Uint8Array>;
     private uploadToBlossom;
     private authHeader;
 }
@@ -763,14 +1011,14 @@ declare class MarketplaceService {
      */
     subscribeToJobRequests(identity: ElisymIdentity, kinds: number[], onRequest: (event: Event) => void): SubCloser;
     /** Submit a job result with NIP-44 encrypted content. Result kind is derived from the request kind. */
-    submitJobResult(identity: ElisymIdentity, requestEvent: Event, content: string, amount?: number, attachment?: FileAttachment): Promise<string>;
+    submitJobResult(identity: ElisymIdentity, requestEvent: Event, content: string, amount?: number, attachments?: FileAttachment[]): Promise<string>;
     /**
      * Submit a job result with retry and exponential backoff.
      * Retries on publish failures (e.g. relay disconnects).
      * With maxAttempts=3: try, ~1s, try, ~2s, try, throw.
      * Jitter: 0.5x-1.0x of calculated delay.
      */
-    submitJobResultWithRetry(identity: ElisymIdentity, requestEvent: Event, content: string, amount?: number, maxAttempts?: number, baseDelayMs?: number, attachment?: FileAttachment): Promise<string>;
+    submitJobResultWithRetry(identity: ElisymIdentity, requestEvent: Event, content: string, amount?: number, maxAttempts?: number, baseDelayMs?: number, attachments?: FileAttachment[]): Promise<string>;
     /** Submit payment-required feedback with a payment request. */
     submitPaymentRequiredFeedback(identity: ElisymIdentity, requestEvent: Event, amount: number, paymentRequestJson: string): Promise<void>;
     /** Submit processing feedback to notify customer that work has started. */
@@ -909,6 +1157,92 @@ declare class ElisymClient {
     close(): void;
 }
 
+type BlossomTransport = Extract<FileTransport, {
+    kind: 'blossom';
+}>;
+interface BlossomBlobTransport {
+    /** Encrypt `bytes` to `recipientPubkey`, upload the ciphertext, return a `blossom` transport member. */
+    seedBytes(args: {
+        bytes: Uint8Array;
+        recipientPubkey: string;
+    }): Promise<BlossomTransport>;
+    /** Download the ciphertext (bounded + sha256-verified) and decrypt it (sent by `senderPubkey`). */
+    fetchToBytes(args: {
+        transport: BlossomTransport;
+        senderPubkey: string;
+        maxBytes?: number;
+    }): Promise<Uint8Array>;
+}
+declare function createBlossomTransport(opts: {
+    blossom: BlossomService;
+    identity: ElisymIdentity;
+}): BlossomBlobTransport;
+
+/**
+ * Encrypt `file` to `providerPubkey` and build a complete `FileAttachment` WITHOUT uploading the bytes
+ * yet. Because Blossom is content-addressed, the blob URL is derivable from the ciphertext sha256, so the
+ * caller can submit the job request with this descriptor and DEFER the byte upload (via the returned
+ * `upload()`) until the customer commits - e.g. after the provider quotes a price, so an unresponsive
+ * provider never costs a wasted upload. TARGETED jobs only (a recipient pubkey is required to encrypt).
+ *
+ * `upload()` PUTs the ciphertext and verifies the server returns the precomputed url/sha256 (the request
+ * already carries them, so a mismatch must fail loudly - pre-commit - rather than 404 the provider).
+ */
+declare function prepareEncryptedFileInput(args: {
+    file: Blob & {
+        name?: string;
+    };
+    providerPubkey: string;
+    identity: ElisymIdentity;
+    blossom: BlossomService;
+}): Promise<{
+    attachment: FileAttachment;
+    upload: () => Promise<void>;
+}>;
+/**
+ * Encrypt `file` to `providerPubkey` AND upload it immediately, returning the `FileAttachment`
+ * (prepare + upload in one step). Use `prepareEncryptedFileInput` when you want to defer the upload.
+ */
+declare function buildEncryptedFileInput(args: {
+    file: Blob & {
+        name?: string;
+    };
+    providerPubkey: string;
+    identity: ElisymIdentity;
+    blossom: BlossomService;
+}): Promise<FileAttachment>;
+/**
+ * Download + decrypt a `blossom` file output from an attachment (sent by `providerPubkey`). Returns the
+ * plaintext bytes plus the envelope-carried name/mime. Throws if there is no blossom transport.
+ */
+declare function fetchEncryptedFileOutput(args: {
+    attachment: FileAttachment;
+    providerPubkey: string;
+    identity: ElisymIdentity;
+    blossom: BlossomService;
+    maxBytes?: number;
+}): Promise<{
+    bytes: Uint8Array;
+    name: string;
+    mime: string;
+}>;
+
+interface EncryptedBytes {
+    /** AES-256-GCM ciphertext with the 16-byte auth tag appended (WebCrypto layout). */
+    ciphertext: Uint8Array;
+    /** NIP-44-wrapped content key (sender secret key -> recipient pubkey). */
+    wrappedKey: string;
+    /** base64 GCM IV (non-secret). */
+    iv: string;
+}
+/** Encrypt `bytes` so that only `recipientPubkey` (with the sender's pubkey) can decrypt. */
+declare function encryptBytesForRecipient(bytes: Uint8Array, senderSk: Uint8Array, recipientPubkey: string): Promise<EncryptedBytes>;
+/**
+ * Decrypt bytes produced by `encryptBytesForRecipient`. Throws on any tamper (GCM auth tag), a
+ * corrupted/forged wrapped key (NIP-44 MAC), or the wrong receiver/sender key pair.
+ */
+declare function decryptBytesFromSender(ciphertext: Uint8Array, wrappedKey: string, iv: string, receiverSk: Uint8Array, senderPubkey: string): Promise<Uint8Array>;
+
 /**
  * Customer-facing error feedback that arrives via `subscribeToJobUpdates`'s
  * `onError` callback can come from many places:
@@ -1519,7 +1853,9 @@ declare const DEFAULTS: {
     readonly QUERY_MAX_CONCURRENCY: 6;
     readonly VERIFY_SIGNATURE_LIMIT: 25;
     readonly IROH_FETCH_TIMEOUT_MS: 300000;
+    readonly IROH_SEED_TIMEOUT_MS: 120000;
     readonly BLOSSOM_UPLOAD_TIMEOUT_MS: 300000;
+    readonly BLOSSOM_FETCH_TIMEOUT_MS: 300000;
 };
 /** Protocol limits for input validation. */
 declare const LIMITS: {
@@ -1528,6 +1864,7 @@ declare const LIMITS: {
     readonly MAX_ENCRYPTED_INLINE_BYTES: 60000;
     readonly MAX_REINLINE_TEXT_BYTES: 4194304;
     readonly MAX_FILE_SIZE: 1073741824;
+    readonly MAX_BLOSSOM_ENCRYPTED_BYTES: 104857600;
     readonly MAX_TIMEOUT_SECS: 600;
     readonly MAX_EXECUTION_SECS: 2147483;
     readonly MAX_CAPABILITIES: 20;
@@ -1548,4 +1885,4 @@ declare const LIMITS: {
  */
 declare function utf8ByteLength(value: string): number;
 
-export { type Agent, type AgentPolicy, type AggregateNetworkStatsOptions, Asset, type BlobDescriptor, BlossomService, type BlossomUploadFallback, BoundedSet, type BuildTransactionOptions, type CapabilityCard, DEFAULTS, DEFAULT_KIND_OFFSET, DEFAULT_REDACT_PATHS, type DecodedJobPayload, DiscoveryService, ELISYM_PROTOCOL_TAG, ENVELOPE_VERSION, ElisymClient, type ElisymClientConfig, type ElisymClientFullConfig, ElisymIdentity, type EstimatePriorityFeeOptions, type EstimateSolFeeOptions, type FileAttachment, type FileTransport, type GetProtocolConfigOptions, INPUT_REDACT_PATHS, type Job, type JobErrorKind, type JobPayloadEnvelope, type JobStatus, type JobSubscriptionOptions, type JobUpdateCallbacks, JobWaitTimeoutError, KIND_APP_HANDLER, KIND_JOB_FEEDBACK, KIND_JOB_REQUEST, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT, KIND_JOB_RESULT_BASE, KIND_LONG_FORM_ARTICLE, KIND_PING, KIND_PONG, LAMPORTS_PER_SOL, LIMITS, MarketplaceService, MediaService, type Network, type NetworkBaselineEstimate, type NetworkBaselineOptions, type NetworkStats, type NetworkStatsResult, NostrPool, type OnchainNetworkStats, POLICY_D_TAG_PREFIX, POLICY_TYPE_REGEX, POLICY_T_TAG, PROTOCOL_PROGRAM_ID_DEVNET, type ParseOptions, type ParseResult, type ParsedPaymentRequest, type PaymentAssetRef, type PaymentInfo, type PaymentRequestData, PaymentRequestSchema, type PaymentStrategy, type PaymentValidationCode, type PaymentValidationError, type PingResult, PingService, PoliciesService, type PolicyInput, type ProtocolCluster, type ProtocolConfig, type ProtocolConfigInput, type QuickVerifyReason, type QuickVerifyResult, RELAYS, type RankKey, SECRET_REDACT_PATHS, type Signer, type SolFeeEstimate, SolanaPaymentStrategy, type SubCloser, type SubmitJobOptions, type VerifyOptions, type VerifyResult, aggregateNetworkStats, assertExpiry, assertLamports, buildPaymentInstructions, calculateProtocolFee, classifyJobError, clearPriorityFeeCache, clearProtocolConfigCache, clearQuickVerifyCache, compareAgentsByRank, computeRankKey, createPaymentRequestWithOnchainConfig, decodeJobPayload, encodeJobPayload, estimateNetworkBaseline, estimatePriorityFeeMicroLamports, estimateSolFeeLamports, formatFeeBreakdown, formatNetworkBaseline, formatSol, getNetworkStats, getProtocolConfig, getProtocolProgramId, jobRequestKind, jobResultKind, makeCensor, nip44Decrypt, nip44Encrypt, parsePaymentRequest, pickPercentileFee, timeAgo, toDTag, truncateKey, utf8ByteLength, validateAgentName, validateExpiry, verifyJobPaymentQuick };
+export { ACCEPT_TRANSPORTS_TAG, type Agent, type AgentPolicy, type AggregateNetworkStatsOptions, Asset, type BlobDescriptor, type BlossomBlobTransport, BlossomService, type BlossomUploadFallback, BoundedSet, type BuildTransactionOptions, type CapabilityCard, DEFAULTS, DEFAULT_KIND_OFFSET, DEFAULT_REDACT_PATHS, type DecodedJobPayload, DiscoveryService, ELISYM_PROTOCOL_TAG, ENVELOPE_VERSION, ElisymClient, type ElisymClientConfig, type ElisymClientFullConfig, ElisymIdentity, type EncryptedBytes, type EstimatePriorityFeeOptions, type EstimateSolFeeOptions, type FileAttachment, type FileTransport, type GetProtocolConfigOptions, INPUT_REDACT_PATHS, type Job, type JobErrorKind, type JobPayloadEnvelope, type JobStatus, type JobSubscriptionOptions, type JobUpdateCallbacks, JobWaitTimeoutError, KIND_APP_HANDLER, KIND_JOB_FEEDBACK, KIND_JOB_REQUEST, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT, KIND_JOB_RESULT_BASE, KIND_LONG_FORM_ARTICLE, KIND_PING, KIND_PONG, LAMPORTS_PER_SOL, LIMITS, MarketplaceService, MediaService, type Network, type NetworkBaselineEstimate, type NetworkBaselineOptions, type NetworkStats, type NetworkStatsResult, NostrPool, type OnchainNetworkStats, POLICY_D_TAG_PREFIX, POLICY_TYPE_REGEX, POLICY_T_TAG, PROTOCOL_PROGRAM_ID_DEVNET, type ParseOptions, type ParseResult, type ParsedPaymentRequest, type PaymentAssetRef, type PaymentInfo, type PaymentRequestData, PaymentRequestSchema, type PaymentStrategy, type PaymentValidationCode, type PaymentValidationError, type PingResult, PingService, PoliciesService, type PolicyInput, type ProtocolCluster, type ProtocolConfig, type ProtocolConfigInput, type QuickVerifyReason, type QuickVerifyResult, RELAYS, type RankKey, SECRET_REDACT_PATHS, type Signer, type SolFeeEstimate, SolanaPaymentStrategy, type SubCloser, type SubmitJobOptions, type TransportKind, type VerifyOptions, type VerifyResult, aggregateNetworkStats, assertExpiry, assertLamports, attachmentsOf, buildAcceptTransportsTag, buildEncryptedFileInput, buildPaymentInstructions, calculateProtocolFee, classifyJobError, clearPriorityFeeCache, clearProtocolConfigCache, clearQuickVerifyCache, compareAgentsByRank, computeRankKey, createBlossomTransport, createPaymentRequestWithOnchainConfig, decodeJobPayload, decryptBytesFromSender, encodeJobPayload, encryptBytesForRecipient, estimateNetworkBaseline, estimatePriorityFeeMicroLamports, estimateSolFeeLamports, fetchEncryptedFileOutput, formatFeeBreakdown, formatNetworkBaseline, formatSol, getNetworkStats, getProtocolConfig, getProtocolProgramId, jobRequestKind, jobResultKind, makeCensor, nip44Decrypt, nip44Encrypt, parsePaymentRequest, pickPercentileFee, prepareEncryptedFileInput, readAcceptedTransports, timeAgo, toDTag, truncateKey, utf8ByteLength, validateAgentName, validateExpiry, verifyJobPaymentQuick };