@elisym/cli 0.22.0 → 0.22.3

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env -S node --no-deprecation
 import { ReadableStream } from 'node:stream/web';
 import { readFileSync, existsSync, readdirSync, statSync, renameSync, chmodSync, mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve, basename, relative, sep, extname } from 'node:path';
-import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, ElisymClient, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, makeCensor, DEFAULT_REDACT_PATHS, POLICY_T_TAG, createSlidingWindowLimiter, getProtocolProgramId, getProtocolConfig, utf8ByteLength, LIMITS, calculateProtocolFee, decodeJobPayload, BoundedSet, KIND_JOB_FEEDBACK, NATIVE_SOL } from '@elisym/sdk';
+import { dirname, join, resolve, basename, extname, relative, sep } from 'node:path';
+import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, ElisymClient, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, createBlossomTransport, makeCensor, DEFAULT_REDACT_PATHS, POLICY_T_TAG, createSlidingWindowLimiter, getProtocolProgramId, getProtocolConfig, utf8ByteLength, LIMITS, readAcceptedTransports, calculateProtocolFee, decodeJobPayload, BoundedSet, KIND_JOB_FEEDBACK, NATIVE_SOL } from '@elisym/sdk';
 import { ElisymYamlSchema, resolveInHome, resolveInProject, createAgentDir, writeYamlInitial, writeExampleSkillTemplate, writeSecrets, listAgents, loadAgent, writeYaml, agentPaths, readMediaCache, loadPoliciesFromDir, ensureGitignoreHasIrohEntry, lookupCachedUrl, newCacheEntry, writeMediaCache } from '@elisym/sdk/agent-store';
 import { isAddress, createSolanaRpc, address } from '@solana/kit';
 import { generateSecretKey, getPublicKey, nip19, verifyEvent } from 'nostr-tools';
@@ -14,7 +14,7 @@ import { createIrohTransport } from '@elisym/sdk/node';
 import { lookup } from 'node:dns/promises';
 import { Socket } from 'node:net';
 import pino from 'pino';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { readFile, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import pLimit from 'p-limit';
 import { parseSkillMd, validateSkillFrontmatter, resolveInsidePath, DEFAULT_SCRIPT_TIMEOUT_MS, DynamicScriptSkill as DynamicScriptSkill$1, StaticScriptSkill as StaticScriptSkill$1, StaticFileSkill as StaticFileSkill$1, ScriptSkill as ScriptSkill$1 } from '@elisym/sdk/skills';
@@ -1865,6 +1865,9 @@ var JobLedger = class {
     if (fields.resultAttachment !== void 0) {
       entry.result_attachment = fields.resultAttachment;
     }
+    if (fields.resultAttachments !== void 0) {
+      entry.result_attachments = fields.resultAttachments;
+    }
     this.flush();
   }
   markDelivered(jobId) {
@@ -2106,9 +2109,35 @@ var ExecutionBudgetExceededError = class extends Error {
     this.name = "ExecutionBudgetExceededError";
   }
 };
+var SeedFailedError = class extends Error {
+  constructor(cause) {
+    super("Result is ready - delivery is retrying and will arrive shortly.", { cause });
+    this.name = "SeedFailedError";
+  }
+};
+var MIME_EXTENSIONS = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/webp": ".webp",
+  "image/gif": ".gif",
+  "image/svg+xml": ".svg",
+  "application/pdf": ".pdf",
+  "text/plain": ".txt",
+  "text/markdown": ".md",
+  "application/json": ".json",
+  "audio/mpeg": ".mp3",
+  "audio/wav": ".wav",
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "application/zip": ".zip"
+};
+function extensionForMime(mime) {
+  return mime ? MIME_EXTENSIONS[mime] ?? "" : "";
+}
+var SLOW_SEED_LOG_MS = 5e3;
 var CUSTOMER_SAFE_MESSAGE_PREFIXES = ["Input too long", "No skill matched", "Payment timeout"];
 function customerSafeMessage(error) {
-  if (error instanceof AgentUnavailableError || error instanceof ExecutionBudgetExceededError) {
+  if (error instanceof AgentUnavailableError || error instanceof ExecutionBudgetExceededError || error instanceof SeedFailedError) {
     return error.message;
   }
   if (error instanceof ScriptExecutionError) {
@@ -2152,7 +2181,7 @@ var PAID_GLOBAL_MAX_JOBS_PER_WINDOW = 2e3;
 var MAX_TRACKED_CUSTOMERS = 1e3;
 var GLOBAL_LIMITER_KEY = "__global__";
 var AgentRuntime = class {
-  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}, healthMonitor, irohTransport) {
+  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}, healthMonitor, irohTransport, identity, blossomTransport) {
     this.transport = transport;
     this.skills = skills;
     this.skillCtx = skillCtx;
@@ -2161,6 +2190,8 @@ var AgentRuntime = class {
     this.callbacks = callbacks;
     this.healthMonitor = healthMonitor;
     this.irohTransport = irohTransport;
+    this.identity = identity;
+    this.blossomTransport = blossomTransport;
     this.limit = pLimit(config.maxConcurrentJobs);
     this.maxQueueSize = config.maxQueueSize ?? config.maxConcurrentJobs * 10;
   }
@@ -2513,14 +2544,12 @@ var AgentRuntime = class {
       const log = this.callbacks.onLog ?? console.log;
       log(`[${job.jobId.slice(0, 8)}] Error: ${e.message}`);
       const currentStatus = this.ledger.getStatus(job.jobId);
-      const keepPaidForRecovery = e instanceof AgentUnavailableError && currentStatus === "paid";
+      const keepPaidForRecovery = (e instanceof AgentUnavailableError || e instanceof SeedFailedError) && currentStatus === "paid";
       if (currentStatus !== "executed" && !keepPaidForRecovery) {
         this.ledger.markFailed(job.jobId);
       }
       if (keepPaidForRecovery) {
-        log(
-          `[${job.jobId.slice(0, 8)}] Keeping status=paid; recovery will re-execute when LLM pair recovers (24h cutoff).`
-        );
+        log(`[${job.jobId.slice(0, 8)}] Keeping status=paid; recovery will retry (24h cutoff).`);
       }
       const operatorMessage = e instanceof ScriptExecutionError ? `${e.message}: ${e.detail}` : e.message ?? "Unknown error";
       this.callbacks.onJobError?.(job.jobId, operatorMessage);
@@ -2588,7 +2617,7 @@ var AgentRuntime = class {
       );
       this.callbacks.onPaymentReceived?.(job.jobId, netAmount);
     }
-    const inputFile = await this.resolveInputFile(job.attachment);
+    const inputFile = await this.resolveInputFile(job.attachment, job.customerId);
     await this.transport.sendFeedback(job, { type: "processing" }).catch(() => {
     });
     const skill = this.skills.route(job.tags);
@@ -2658,19 +2687,48 @@ var AgentRuntime = class {
         });
       }
     }
-    const { attachment, deliveredContent } = await this.buildResultAttachment(job.jobId, output);
+    const { attachments, deliveredContent } = await this.buildResultAttachment(
+      job.jobId,
+      output,
+      job.customerId,
+      readAcceptedTransports(job.rawEvent.tags)
+    );
     this.ledger.markExecuted(job.jobId, deliveredContent);
     log(`[${job.jobId.slice(0, 8)}] Skill completed, delivering result`);
     const eventId = await this.transport.deliverResult(
       job,
       deliveredContent,
       netAmount,
-      attachment
+      attachments.length > 0 ? attachments : void 0
     );
     this.ledger.markDelivered(job.jobId);
     log(`[${job.jobId.slice(0, 8)}] Delivered: ${eventId.slice(0, 16)}...`);
     this.callbacks.onJobCompleted?.(job.jobId, output.data);
   }
+  /**
+   * Seed a result blob through iroh, timing it and converting any failure (incl. the
+   * transport's seed timeout, which also resets the wedged node) into a
+   * `SeedFailedError` so the post-execute catch keeps the job `paid` for recovery
+   * rather than losing the customer's paid job.
+   */
+  async seedGuarded(jobId, kind, run) {
+    const log = this.callbacks.onLog ?? console.log;
+    const started = Date.now();
+    try {
+      const seeded = await run();
+      const elapsed = Date.now() - started;
+      if (elapsed > SLOW_SEED_LOG_MS) {
+        log(`[${jobId.slice(0, 8)}] iroh seed (${kind}) slow: ${elapsed}ms`);
+      }
+      return seeded;
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      log(
+        `[${jobId.slice(0, 8)}] iroh seed (${kind}) failed after ${Date.now() - started}ms: ${detail}`
+      );
+      throw new SeedFailedError(error);
+    }
+  }
   /**
    * Decide how a skill's result travels: inline text, a seeded file, or seeded
    * large text. Returns the attachment descriptor (if any) PLUS the content to
@@ -2685,21 +2743,27 @@ var AgentRuntime = class {
    * recovery re-executes (rather than re-delivering a dead ticket). Runs after the
    * `skill.execute` budget window, so a slow seed never trips `max_execution_secs`.
    */
-  async buildResultAttachment(jobId, output) {
-    if (output.filePath !== void 0) {
+  async buildResultAttachment(jobId, output, customerPubkey, acceptedTransports) {
+    const wantBlossom = acceptedTransports === void 0 || acceptedTransports.includes("blossom");
+    const filePaths = output.filePaths ?? (output.filePath !== void 0 ? [output.filePath] : []);
+    if (filePaths.length > 0) {
       try {
-        if (!this.irohTransport) {
-          throw new Error("Skill produced a file result but iroh transport is unavailable.");
+        const attachments = [];
+        for (const filePath of filePaths) {
+          attachments.push(
+            await this.seedFileToAttachment(
+              jobId,
+              filePath,
+              output.outputMime,
+              customerPubkey,
+              wantBlossom
+            )
+          );
         }
-        const seeded = await this.irohTransport.seedPath(output.filePath);
-        const attachment = {
-          name: basename(output.filePath),
-          size: seeded.size,
-          mime: output.outputMime ?? "application/octet-stream",
-          transports: [{ kind: "iroh", ticket: seeded.ticket }]
-        };
-        this.ledger.recordAttachment(jobId, { resultAttachment: JSON.stringify(attachment) });
-        return { attachment, deliveredContent: output.data };
+        this.ledger.recordAttachment(jobId, {
+          resultAttachments: attachments.map((a) => JSON.stringify(a))
+        });
+        return { attachments, deliveredContent: output.data };
       } finally {
         await output.cleanup?.().catch(() => {
         });
@@ -2709,17 +2773,82 @@ var AgentRuntime = class {
       if (!this.irohTransport) {
         throw new Error("Result is too large to deliver inline and iroh transport is unavailable.");
       }
-      const seeded = await this.irohTransport.seedBytes(Buffer.from(output.data, "utf8"));
+      const iroh = this.irohTransport;
+      const dataBytes = Buffer.from(output.data, "utf8");
+      const seeded = await this.seedGuarded(jobId, "large-text", () => iroh.seedBytes(dataBytes));
+      const transports = [{ kind: "iroh", ticket: seeded.ticket }];
+      if (wantBlossom) {
+        const blossomMember = await this.seedBlossomMember(dataBytes, customerPubkey);
+        if (blossomMember !== void 0) {
+          transports.unshift(blossomMember);
+        }
+      }
       const attachment = {
         name: "result.txt",
         size: seeded.size,
         mime: "text/plain",
-        transports: [{ kind: "iroh", ticket: seeded.ticket }]
+        transports
       };
-      this.ledger.recordAttachment(jobId, { resultAttachment: JSON.stringify(attachment) });
-      return { attachment, deliveredContent: "" };
+      this.ledger.recordAttachment(jobId, { resultAttachments: [JSON.stringify(attachment)] });
+      return { attachments: [attachment], deliveredContent: "" };
+    }
+    return { attachments: [], deliveredContent: output.data };
+  }
+  /**
+   * Seed ONE result file to iroh (+ encrypted Blossom when wanted) and build its
+   * FileAttachment. A seed timeout throws SeedFailedError (job stays `paid` for
+   * recovery). Shared by the single- and multi-file result paths.
+   */
+  async seedFileToAttachment(jobId, filePath, outputMime, customerPubkey, wantBlossom) {
+    if (!this.irohTransport) {
+      throw new Error("Skill produced a file result but iroh transport is unavailable.");
+    }
+    const iroh = this.irohTransport;
+    const seeded = await this.seedGuarded(jobId, "file", () => iroh.seedPath(filePath));
+    const transports = [{ kind: "iroh", ticket: seeded.ticket }];
+    if (wantBlossom) {
+      const blossomMember = await this.seedBlossomFromPath(filePath, seeded.size, customerPubkey);
+      if (blossomMember !== void 0) {
+        transports.unshift(blossomMember);
+      }
+    }
+    const producedName = basename(filePath);
+    const name = extname(producedName) ? producedName : `${producedName}${extensionForMime(outputMime)}`;
+    return { name, size: seeded.size, mime: outputMime ?? "application/octet-stream", transports };
+  }
+  /**
+   * Encrypt `bytes` to `recipientPubkey` and seed them to Blossom, returning a `blossom` transport
+   * member - or `undefined` when blossom isn't configured, the bytes exceed the encrypted cap, or the
+   * upload fails. Returning undefined (never throwing) keeps iroh as the guaranteed transport: an
+   * optional second path must never fail the job.
+   */
+  async seedBlossomMember(bytes, recipientPubkey) {
+    if (this.blossomTransport === void 0 || this.identity === void 0) {
+      return void 0;
+    }
+    if (bytes.byteLength > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+      return void 0;
+    }
+    try {
+      return await this.blossomTransport.seedBytes({ bytes, recipientPubkey });
+    } catch {
+      return void 0;
+    }
+  }
+  /** Read a file (only when within the encrypted cap, to bound memory) and seed it to Blossom. */
+  async seedBlossomFromPath(filePath, size, recipientPubkey) {
+    if (this.blossomTransport === void 0 || this.identity === void 0) {
+      return void 0;
+    }
+    if (size > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+      return void 0;
+    }
+    try {
+      const bytes = await readFile(filePath);
+      return await this.seedBlossomMember(bytes, recipientPubkey);
+    } catch {
+      return void 0;
     }
-    return { attachment: void 0, deliveredContent: output.data };
   }
   /**
    * Rebuild a file-result attachment for crash-recovery re-delivery: re-share the
@@ -2735,12 +2864,34 @@ var AgentRuntime = class {
       throw new Error("Cannot recover a file result: iroh transport is unavailable.");
     }
     const stored = JSON.parse(resultAttachmentJson);
-    const irohTransport = stored.transports.find((transport) => transport.kind === "iroh");
+    const irohTransport = stored.transports.find(
+      (transport) => transport.kind === "iroh"
+    );
     if (!irohTransport) {
       throw new Error("Stored result attachment has no iroh transport.");
     }
     const freshTicket = await this.irohTransport.reShare(irohTransport.ticket);
-    return { ...stored, transports: [{ kind: "iroh", ticket: freshTicket }] };
+    const transports = stored.transports.map(
+      (transport) => transport.kind === "iroh" ? { kind: "iroh", ticket: freshTicket } : transport
+    );
+    return { ...stored, transports };
+  }
+  /**
+   * Re-share ALL of a recovered job's result attachments (multi-file aware). Prefers
+   * the `result_attachments` array; falls back to the legacy single `result_attachment`.
+   * A failure on ANY attachment throws (the caller marks the whole job failed - a
+   * partial multi-file delivery is not a valid paid result).
+   */
+  async reShareResultAttachments(entry) {
+    const stored = entry.result_attachments ?? (entry.result_attachment !== void 0 ? [entry.result_attachment] : []);
+    const out = [];
+    for (const serialized of stored) {
+      const attachment = await this.reShareResultAttachment(serialized);
+      if (attachment !== void 0) {
+        out.push(attachment);
+      }
+    }
+    return out;
   }
   /**
    * Resolve a job's file/large-text input (when it carries an attachment) via iroh.
@@ -2755,31 +2906,67 @@ var AgentRuntime = class {
    * `fetchToBytes`/`fetchToPath` enforce the real cap on the BLAKE3-verified size, so
    * an incorrect declared `size` cannot exceed the in-memory ceiling.
    */
-  async resolveInputFile(attachment) {
+  async resolveInputFile(attachment, senderPubkey) {
     if (attachment === void 0) {
       return void 0;
     }
-    if (!this.irohTransport) {
-      throw new Error("Job carries a file input but iroh transport is unavailable.");
-    }
-    const irohTransport = attachment.transports.find((transport) => transport.kind === "iroh");
-    if (!irohTransport) {
-      throw new Error("File input has no iroh transport.");
-    }
-    if (attachment.mime.startsWith("text/") && attachment.size <= LIMITS.MAX_REINLINE_TEXT_BYTES) {
-      const bytes = await this.irohTransport.fetchToBytes(irohTransport.ticket, {
-        maxBytes: LIMITS.MAX_REINLINE_TEXT_BYTES
-      });
+    const irohMember = attachment.transports.find(
+      (t) => t.kind === "iroh"
+    );
+    const blossomMember = attachment.transports.find(
+      (t) => t.kind === "blossom"
+    );
+    if (irohMember !== void 0 && this.irohTransport !== void 0) {
+      if (attachment.mime.startsWith("text/") && attachment.size <= LIMITS.MAX_REINLINE_TEXT_BYTES) {
+        const bytes = await this.irohTransport.fetchToBytes(irohMember.ticket, {
+          maxBytes: LIMITS.MAX_REINLINE_TEXT_BYTES
+        });
+        return this.materializeBytesInput(bytes, attachment.mime);
+      }
+      const dir = await mkdtemp(join(tmpdir(), "elisym-job-"));
+      const filePath = join(dir, "input");
+      try {
+        await this.irohTransport.fetchToPath(irohMember.ticket, filePath);
+      } catch (error) {
+        await rm(dir, { recursive: true, force: true }).catch(() => {
+        });
+        throw error;
+      }
       return {
-        inlineText: Buffer.from(bytes).toString("utf8"),
+        filePath,
         cleanup: async () => {
+          await rm(dir, { recursive: true, force: true });
         }
       };
     }
+    if (blossomMember !== void 0 && this.blossomTransport !== void 0 && this.identity !== void 0) {
+      if (attachment.size > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+        throw new Error("Blossom file input exceeds the encrypted size cap.");
+      }
+      const bytes = await this.blossomTransport.fetchToBytes({
+        transport: blossomMember,
+        senderPubkey,
+        maxBytes: LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES
+      });
+      return this.materializeBytesInput(bytes, attachment.mime);
+    }
+    throw new Error("Job carries a file input but no supported transport is available.");
+  }
+  /**
+   * Turn fetched input bytes into a SkillInput: text within the re-inline ceiling becomes an
+   * in-memory string; anything else is written to a fixed `input` name inside a unique mkdtemp dir
+   * (the untrusted attachment `name` never touches the path). Shared by the iroh-text and blossom
+   * paths (both have the bytes in hand); the iroh-binary path streams to disk separately.
+   */
+  async materializeBytesInput(bytes, mime) {
+    if (mime.startsWith("text/") && bytes.byteLength <= LIMITS.MAX_REINLINE_TEXT_BYTES) {
+      return { inlineText: Buffer.from(bytes).toString("utf8"), cleanup: async () => {
+      } };
+    }
     const dir = await mkdtemp(join(tmpdir(), "elisym-job-"));
     const filePath = join(dir, "input");
     try {
-      await this.irohTransport.fetchToPath(irohTransport.ticket, filePath);
+      await writeFile(filePath, bytes);
     } catch (error) {
       await rm(dir, { recursive: true, force: true }).catch(() => {
       });
@@ -3058,15 +3245,20 @@ var AgentRuntime = class {
       };
       if (entry.status === "executed" && entry.result !== void 0) {
         this.ledger.incrementRetry(entry.job_id);
-        let attachment;
+        let attachments;
         try {
-          attachment = await this.reShareResultAttachment(entry.result_attachment);
+          attachments = await this.reShareResultAttachments(entry);
         } catch {
           log(`[${entry.job_id.slice(0, 8)}] Recovery: result blob unavailable, marking failed`);
           this.ledger.markFailed(entry.job_id);
           return;
         }
-        await this.transport.deliverResult(fakeJob, entry.result, entry.net_amount, attachment);
+        await this.transport.deliverResult(
+          fakeJob,
+          entry.result,
+          entry.net_amount,
+          attachments.length > 0 ? attachments : void 0
+        );
         this.ledger.markDelivered(entry.job_id);
         log(`[${entry.job_id.slice(0, 8)}] Recovery: re-delivered`);
       } else if (entry.status === "paid") {
@@ -3112,7 +3304,8 @@ var AgentRuntime = class {
         let recoveryInputFile;
         try {
           recoveryInputFile = await this.resolveInputFile(
-            decodeJobPayload(rawEvent.content).attachment
+            decodeJobPayload(rawEvent.content).attachment,
+            entry.customer_id
           );
         } catch {
           log(`[${entry.job_id.slice(0, 8)}] Recovery: input file unavailable, marking failed`);
@@ -3157,16 +3350,18 @@ var AgentRuntime = class {
             });
           }
         }
-        const { attachment: resultAttachment, deliveredContent } = await this.buildResultAttachment(
+        const { attachments: resultAttachments, deliveredContent } = await this.buildResultAttachment(
           entry.job_id,
-          output
+          output,
+          entry.customer_id,
+          readAcceptedTransports(rawEvent.tags)
         );
         this.ledger.markExecuted(entry.job_id, deliveredContent);
         await this.transport.deliverResult(
           fakeJob,
           deliveredContent,
           entry.net_amount,
-          resultAttachment
+          resultAttachments.length > 0 ? resultAttachments : void 0
         );
         this.ledger.markDelivered(entry.job_id);
         log(`[${entry.job_id.slice(0, 8)}] Recovery: re-executed and delivered`);
@@ -3359,8 +3554,9 @@ var DynamicScriptSkill = class {
   llmOverride;
   // Discovery hints surfaced in the published capability card (buildCard).
   // `outputMime` is also forwarded to the inner SDK runner (it labels the file
-  // result); `inputMime` is publish-time metadata only.
+  // result); `inputMime`/`inputText` are publish-time metadata only.
   inputMime;
+  inputText;
   outputMime;
   inner;
   constructor(params) {
@@ -3374,6 +3570,7 @@ var DynamicScriptSkill = class {
     this.dir = params.dir;
     this.llmOverride = params.llmOverride;
     this.inputMime = params.inputMime;
+    this.inputText = params.inputText;
     this.outputMime = params.outputMime;
     this.inner = new DynamicScriptSkill$1({
       name: params.name,
@@ -3542,7 +3739,8 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
       skill = parsed.mode === "dynamic-script" ? new DynamicScriptSkill({
         ...scriptParams,
         outputMime: parsed.outputMime,
-        inputMime: parsed.inputMime
+        inputMime: parsed.inputMime,
+        inputText: parsed.inputText
       }) : new StaticScriptSkill(scriptParams);
       break;
     }
@@ -3751,7 +3949,7 @@ var NostrTransport = class {
     }
   }
   /** Deliver result to customer. Retries with exponential backoff via SDK. */
-  async deliverResult(job, content, amount, attachment, retries = 3) {
+  async deliverResult(job, content, amount, attachments, retries = 3) {
     return this.client.marketplace.submitJobResultWithRetry(
       this.identity,
       job.rawEvent,
@@ -3759,7 +3957,7 @@ var NostrTransport = class {
       amount,
       retries,
       void 0,
-      attachment
+      attachments
     );
   }
   /** Returns true if an event was received within the given idle window. */
@@ -4312,9 +4510,10 @@ async function cmdStart(nameArg, options = {}) {
       capabilities: skill.capabilities,
       image: skill.image,
       ...isStatic ? { static: true } : {},
-      // File-exchange hints (dynamic-script only). `inputMime` lets clients that
-      // cannot send files (the web app) gate the Buy button before payment.
+      // File-exchange hints (dynamic-script only). `inputMime` flags a file input;
+      // `inputText` tells the web whether to also show its text box for that file job.
       ...skill.inputMime ? { inputMime: skill.inputMime } : {},
+      ...skill.inputText ? { inputText: skill.inputText } : {},
       ...skill.outputMime ? { outputMime: skill.outputMime } : {},
       payment: solanaAddress ? {
         chain: "solana",
@@ -4445,6 +4644,7 @@ async function cmdStart(nameArg, options = {}) {
     });
     diagLog("LLM health monitor armed (lazy recovery, 5min interval).");
   }
+  const blossomTransport = createBlossomTransport({ blossom: client.blossom, identity });
   const runtime = new AgentRuntime(
     transport,
     registry,
@@ -4476,7 +4676,9 @@ async function cmdStart(nameArg, options = {}) {
       }
     },
     healthMonitor,
-    irohTransport
+    irohTransport,
+    identity,
+    blossomTransport
   );
   console.log("  * Running. Press Ctrl+C to stop.\n");
   await runtime.run();