@elisym/mcp 0.25.0 → 0.25.1

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { LIMITS, SESSION_ID_REGEX, DEFAULT_KIND_OFFSET, SolanaPaymentStrategy, makeCensor, DEFAULT_REDACT_PATHS, validateAgentName, exportKeyPairBytes, RELAYS, toDTag, resolveUsdcAsset, deriveOwnerDelegationAta, getDelegation, formatAssetAmount, mintDelegationNonce, buildDelegationAuthProof, JobWaitTimeoutError, assetKey, MAX_PROOF_TTL_SECS, attachmentsOf, decodeJobPayload, utf8ByteLength, estimateNetworkBaseline, formatSol as formatSol$1, resolveKnownAsset, verifyAgentIdentities, splAssetsForNetwork, parseAssetAmount, delegationApproveFeeSubunits, buildApproveDelegate, decodeApproveDelegate, decodeDelegationFeeTransfer, buildRevokeDelegate, estimateSolFeeLamports, formatFeeBreakdown, getProtocolProgramId, isDefinitelyUnpaid, resolveAssetFromPaymentRequest as resolveAssetFromPaymentRequest$1, resolveLsmAsset, ElisymIdentity, ElisymClient, encodeJobPayload, NATIVE_SOL, assetByKey, sendConfirmToTerminal, ONCHAIN_DISCLAIMER, defaultCeilings, verifyOnchainCall, ONCHAIN_REFUSAL_HEADLINES, getProtocolConfig, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT_BASE, USDC_SOLANA_DEVNET, USDC_SOLANA_MAINNET, LSM_SOLANA_MAINNET, estimateAssetStatsRentLamports, formatNetworkBaseline, MAX_CALL_BASE64_CHARS, MAX_EXPLAIN_ENTRIES, MAX_EXPLAIN_TEXT_CHARS, ONCHAIN_UNATTRIBUTED_NOTICE, KNOWN_ASSETS } from '@elisym/sdk';
-import { listAgents, createAgentDir, writeYamlInitial, writeExampleSkillTemplate, writeSecrets, resolveAgent, loadAgent, globalConfigPath, writeYaml, ensureGitignoreHasMessagesEntry, writeFileAtomic as writeFileAtomic$1, ensureGitignoreHasJobSessionsEntry } from '@elisym/sdk/agent-store';
+import { LIMITS, SESSION_ID_REGEX, DEFAULT_KIND_OFFSET, SolanaPaymentStrategy, makeCensor, DEFAULT_REDACT_PATHS, validateAgentName, exportKeyPairBytes, RELAYS, toDTag, utf8ByteLength, JobWaitTimeoutError, attachmentsOf, decodeJobPayload, formatAssetAmount, estimateNetworkBaseline, formatSol as formatSol$1, resolveKnownAsset, verifyAgentIdentities, splAssetsForNetwork, deriveOwnerDelegationAta, getDelegation, resolveUsdcAsset, parseAssetAmount, delegationApproveFeeSubunits, buildApproveDelegate, decodeApproveDelegate, decodeDelegationFeeTransfer, buildRevokeDelegate, estimateSolFeeLamports, formatFeeBreakdown, getProtocolProgramId, isDefinitelyUnpaid, resolveAssetFromPaymentRequest as resolveAssetFromPaymentRequest$1, resolveLsmAsset, ElisymIdentity, ElisymClient, mintDelegationNonce, buildDelegationAuthProof, assetKey, MAX_PROOF_TTL_SECS, encodeJobPayload, NATIVE_SOL, assetByKey, sendConfirmToTerminal, ONCHAIN_DISCLAIMER, defaultCeilings, verifyOnchainCall, ONCHAIN_REFUSAL_HEADLINES, getProtocolConfig, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT_BASE, USDC_SOLANA_DEVNET, USDC_SOLANA_MAINNET, LSM_SOLANA_MAINNET, estimateAssetStatsRentLamports, formatNetworkBaseline, MAX_CALL_BASE64_CHARS, MAX_EXPLAIN_ENTRIES, MAX_EXPLAIN_TEXT_CHARS, ONCHAIN_UNATTRIBUTED_NOTICE, KNOWN_ASSETS } from '@elisym/sdk';
+import { listAgents, createAgentDir, writeYamlInitial, writeExampleSkillTemplate, writeSecrets, resolveAgent, loadAgent, globalConfigPath, writeYaml, writeFileAtomic as writeFileAtomic$1, ensureGitignoreHasMessagesEntry, ensureGitignoreHasJobSessionsEntry } from '@elisym/sdk/agent-store';
 import { createIrohTransport, loadGlobalConfig, writeGlobalConfig } from '@elisym/sdk/node';
-import { getBase58Encoder, getBase58Decoder, generateKeyPairSigner, createSolanaRpc, createKeyPairSignerFromBytes, address, getSignatureFromTransaction, createSolanaRpcSubscriptions, sendAndConfirmTransactionFactory, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, getBase64Encoder, getTransactionDecoder, signTransaction, isAddress } from '@solana/kit';
+import { getBase58Encoder, getBase58Decoder, generateKeyPairSigner, createSolanaRpc, address, getSignatureFromTransaction, createSolanaRpcSubscriptions, sendAndConfirmTransactionFactory, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, createKeyPairSignerFromBytes, getBase64Encoder, getTransactionDecoder, signTransaction, isAddress } from '@solana/kit';
 import { Command } from 'commander';
 import { generateSecretKey, nip19, getPublicKey, verifyEvent } from 'nostr-tools';
 import { writeFile, realpath, readFile, rm, stat, mkdir, rename, unlink } from 'node:fs/promises';
@@ -2519,6 +2519,11 @@ var SubmitAndPayJobFromFileSchema = z.object({
   ),
   session_id: SessionIdSchema
 });
+var SubmitDelegatedJobFromFileSchema = SubmitAndPayJobFromFileSchema.omit({
+  session_id: true
+}).extend({
+  max_price_lamports: SubmitDelegatedJobSchema.shape.max_price_lamports
+});
 var SubmitDiffReviewSchema = z.object({
   provider_npub: z.string(),
   capability: z.string().min(1).max(64).default("review").describe('Capability tag advertised by the reviewer. Override if not "review".'),
@@ -2699,6 +2704,9 @@ ${formatNetworkBaseline(baseline)}${statsHint}`;
     return "";
   }
 }
+function isDelegatedTool(toolName) {
+  return toolName === "submit_delegated_job" || toolName === "submit_delegated_job_from_file";
+}
 async function confirmPriceGate(opts) {
   const {
     agent,
@@ -2720,7 +2728,7 @@ async function confirmPriceGate(opts) {
   if (price > 0 && maxPriceLamports === void 0) {
     const gasLine = await gasHintForCardAsset(agent, asset);
     const subject = toolName === "buy_capability" ? `Capability "${capability}" from "${providerLabel}"` : `Job for capability "${capability}" from "${providerLabel}"`;
-    const costLine = meteredMinSubunits !== void 0 && toolName === "submit_delegated_job" ? `${subject} is billed for what it actually uses: from ${formatAssetAmount(asset, meteredMinSubunits)} and never more than ${formatAssetAmount(asset, BigInt(price))}.` : `${subject} costs ${formatAssetAmount(asset, BigInt(price))}.`;
+    const costLine = meteredMinSubunits !== void 0 && isDelegatedTool(toolName) ? `${subject} is billed for what it actually uses: from ${formatAssetAmount(asset, meteredMinSubunits)} and never more than ${formatAssetAmount(asset, BigInt(price))}.` : `${subject} costs ${formatAssetAmount(asset, BigInt(price))}.`;
     const { text } = sanitizeUntrusted(
       `${costLine}${gasLine}
 
@@ -2997,6 +3005,51 @@ async function prepareTextInput(agent, text, options) {
     };
   }
 }
+var FILE_PROMPT_INLINE_CAP = 55e3;
+async function validateFileInput(ctx, options) {
+  const prompt = options.prompt.trim();
+  if (utf8ByteLength(prompt) > FILE_PROMPT_INLINE_CAP) {
+    return {
+      error: `Prompt is too long to ride inline (max ${FILE_PROMPT_INLINE_CAP} bytes); the file occupies the only attachment slot, so shorten the prompt.`
+    };
+  }
+  let file;
+  try {
+    file = await prepareFileInput(options.inputPath, {
+      allowOutsideCwd: options.allowOutsideCwd
+    });
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+  const agent = ctx.active();
+  if (agent.agentDir === void 0) {
+    return {
+      error: `Sending a file requires a persistent agent (this is an ephemeral session). Files are always transferred P2P via iroh, never inline.`
+    };
+  }
+  return { agent, prompt, file };
+}
+async function seedFileAttachment(agent, file) {
+  try {
+    const seeded = await ensureIrohTransport(agent).seedPath(file.absPath);
+    return {
+      attachment: {
+        name: file.name,
+        size: seeded.size,
+        mime: file.mime,
+        transports: [{ kind: "iroh", ticket: seeded.ticket }]
+      }
+    };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (/@number0\/iroh|iroh file transfer is unavailable/i.test(msg)) {
+      return {
+        error: `File transfer is unavailable: the optional @number0/iroh addon is not installed. Install it (e.g. \`bun add @number0/iroh\`) to send files.`
+      };
+    }
+    return { error: `Failed to seed file for transfer: ${msg}` };
+  }
+}
 async function executeSubmitAndPay(ctx, agent, params) {
   const ping = await agent.client.ping.pingAgent(params.providerPubkey, PRE_PING_TIMEOUT_MS);
   if (!ping.online) {
@@ -3225,6 +3278,234 @@ ${sessionIdLine(sessionId).trimEnd()}` : "";
     );
   }
 }
+async function executeDelegatedJob(ctx, agent, params) {
+  if (!agent.solanaKeypair) {
+    return errorResult(
+      "Solana wallet not configured for this agent - delegated payment signs the proof with the owner (wallet) key."
+    );
+  }
+  const providerPubkey = decodeNpub(params.providerNpub);
+  const dTag = toDTag(params.capability);
+  const { timeoutMs } = params;
+  const ping = await agent.client.ping.pingAgent(providerPubkey, PRE_PING_TIMEOUT_MS);
+  if (!ping.online) {
+    return errorResult(
+      `Provider ${params.providerNpub} is offline. Run search_agents to find currently-online providers.`
+    );
+  }
+  const providers = await agent.client.discovery.fetchAgents(agent.network);
+  const provider = providers.find((candidate) => candidate.npub === params.providerNpub);
+  if (!provider) {
+    return errorResult(
+      `Provider ${params.providerNpub} not found on ${agent.network}. Refresh discovery (e.g. search_agents) or verify the npub is correct.`
+    );
+  }
+  const card = paymentCardForCapability(provider, dTag);
+  const descriptor = card?.delegation;
+  if (!descriptor) {
+    const payUpFrontTool = params.toolName === "submit_delegated_job_from_file" ? "submit_and_pay_job_from_file" : "submit_and_pay_job";
+    return errorResult(
+      `Capability "${params.capability}" of ${params.providerNpub} does not advertise delegated payment. Use ${payUpFrontTool} instead.`
+    );
+  }
+  const { price, asset } = advertisedPriceForCapability(provider, dTag);
+  if (price <= 0) {
+    return errorResult(
+      `Capability "${params.capability}" advertises no price - delegated payment needs a priced skill. Use create_job for free capabilities.`
+    );
+  }
+  const delegationAsset = resolveUsdcAsset(agent.network);
+  const cardPayment = paymentCardForCapability(provider, dTag)?.payment;
+  const cardMint = cardPayment?.mint;
+  const isCanonicalUsdc = (cardPayment?.chain ?? delegationAsset.chain) === delegationAsset.chain && cardPayment?.token?.toLowerCase() === delegationAsset.token && (cardMint === void 0 || cardMint === delegationAsset.mint);
+  if (!isCanonicalUsdc) {
+    const declared = cardPayment?.symbol ?? cardPayment?.token ?? asset.symbol;
+    const { text } = sanitizeUntrusted(
+      `Delegated payment is USDC-only, but this capability is priced in ${declared}.`,
+      "text"
+    );
+    return errorResult(text);
+  }
+  const priceSubunits = BigInt(price);
+  const rpc = createSolanaRpc(rpcUrlFor(agent.network));
+  const ownerAta = await deriveOwnerDelegationAta(agent.solanaKeypair.publicKey, agent.network);
+  let delegation;
+  try {
+    delegation = await getDelegation(rpc, ownerAta);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return errorResult(`Could not read your delegation on-chain: ${message}`);
+  }
+  if (delegation === null || delegation.delegate === null) {
+    return errorResult(
+      "No active delegation from this wallet. Approve one first (web app Delegation tab, or the approve flow), then retry."
+    );
+  }
+  if (delegation.delegate !== descriptor.delegate_pubkey) {
+    const { text } = sanitizeUntrusted(
+      `Your delegation is granted to ${delegation.delegate}, but this capability advertises delegate ${descriptor.delegate_pubkey} (the provider may have rotated its key). Re-approve the delegation, then retry.`,
+      "text"
+    );
+    return errorResult(text);
+  }
+  if (delegation.remainingCap < priceSubunits) {
+    return errorResult(
+      `Remaining delegated cap ${formatAssetAmount(delegationAsset, delegation.remainingCap)} is below the price ${formatAssetAmount(delegationAsset, priceSubunits)}. Top up the delegation (re-approve) first.`
+    );
+  }
+  if (delegation.balance < priceSubunits) {
+    return errorResult(
+      `Delegation account balance ${formatAssetAmount(delegationAsset, delegation.balance)} is below the price ${formatAssetAmount(delegationAsset, priceSubunits)}. Fund the wallet first.`
+    );
+  }
+  try {
+    assertCanSpend(ctx, delegationAsset, priceSubunits);
+  } catch (e) {
+    return errorResult(e instanceof Error ? e.message : String(e));
+  }
+  const priceGate = await confirmPriceGate({
+    agent,
+    providerLabel: sanitizeField(provider.name || params.providerNpub, 64),
+    capability: params.capability,
+    price,
+    asset: delegationAsset,
+    maxPriceLamports: params.maxPriceLamports,
+    toolName: params.toolName,
+    // Card-published floor, so the quote reads "from X, never more than Y"
+    // instead of a flat number the buyer will usually not be charged.
+    ...card?.metered !== void 0 ? { meteredMinSubunits: BigInt(card.metered.min_subunits) } : {}
+  });
+  if (priceGate) {
+    return priceGate;
+  }
+  const preparedInput = await params.prepareInput();
+  if ("error" in preparedInput) {
+    return errorResult(preparedInput.error);
+  }
+  const ownerSigner = await createKeyPairSignerFromBytes(agent.solanaKeypair.secretKey);
+  const expiryUnix = Math.floor(Date.now() / 1e3) + MAX_PROOF_TTL_SECS;
+  const nonce = mintDelegationNonce();
+  const proof = await buildDelegationAuthProof({
+    ownerSigner,
+    agentDelegate: descriptor.delegate_pubkey,
+    nostrAuthor: agent.identity.publicKey,
+    owner: agent.solanaKeypair.publicKey,
+    expiryUnix,
+    nonce
+  });
+  const submittedAt = Date.now();
+  const jobId = await agent.client.marketplace.submitJobRequest(agent.identity, {
+    input: preparedInput.input,
+    attachment: preparedInput.attachment,
+    capability: dTag,
+    providerPubkey,
+    kindOffset: params.kindOffset,
+    acceptTransports: MCP_ACCEPT_TRANSPORTS,
+    delegatedPayment: {
+      owner: agent.solanaKeypair.publicKey,
+      expiryUnix,
+      nonce,
+      proof
+    }
+  });
+  let resultAttachment;
+  let pullTx;
+  let settledAmountSubunits;
+  try {
+    const result = await awaitJobResult(
+      agent,
+      {},
+      ({ resolve, reject }) => ({
+        jobEventId: jobId,
+        providerPubkey,
+        customerPublicKey: agent.identity.publicKey,
+        callbacks: {
+          onResult(content, _eventId, attachment, _attachments, paymentTx, paidAmountSubunits) {
+            pullTx = paymentTx;
+            settledAmountSubunits = paidAmountSubunits;
+            if (attachment) {
+              resultAttachment = attachment;
+              resolve(formatFileResultMetadata(jobId, attachment));
+              return;
+            }
+            const sanitized = sanitizeResultContent(content);
+            resolve(`Job completed.
+
+${sanitized.text}`);
+          },
+          onError(error) {
+            rejectWithProviderError(reject, error);
+          },
+          onTimeout(waitedMs) {
+            reject(new JobWaitTimeoutError(waitedMs));
+          }
+        },
+        timeoutMs,
+        customerSecretKey: agent.identity.secretKey
+      }),
+      timeoutMs + 5e3
+    );
+    const settledForSession = settledSubunitsForHistory(card, price, settledAmountSubunits);
+    recordSpend(ctx, delegationAsset, BigInt(settledForSession));
+    await recordJobOutcome(agent, {
+      jobEventId: jobId,
+      capability: dTag,
+      providerPubkey,
+      providerName: clipProviderName(provider.name),
+      // What actually moved, as recorded in the buyer's OWN history.
+      //
+      // On a FLAT card the runtime always pulls exactly `price`, so there is
+      // nothing to learn from the provider and the reported figure is only a
+      // way to lie - the card price is the truth by construction.
+      //
+      // On a METERED card the pull is variable, so the provider's report is
+      // the only source of the real number. It is still attacker-controlled
+      // and arrives through a tag parser that accepts negatives and
+      // prefix-parses garbage, so it is trusted only inside the range the
+      // card published and the buyer approved: `[min, price]`. Anything
+      // outside degrades to the ceiling rather than to the attacker's value.
+      paidAmountSubunits: String(settledForSession),
+      // The registry key, not the card's. A mint-less `usdc` card is
+      // accepted by the gate above but keys as `solana:usdc`, which
+      // `assetByKey` cannot resolve and which splits any per-asset
+      // aggregation away from the canonical `solana:usdc:<mint>` rows.
+      assetKey: assetKey(delegationAsset),
+      status: "completed",
+      submittedAt,
+      completedAt: Date.now(),
+      resultPreview: result.slice(0, RESULT_PREVIEW_MAX_LEN),
+      paymentSig: pullTx,
+      attachmentJson: resultAttachment ? JSON.stringify(resultAttachment) : void 0
+    });
+    const pullLine = pullTx !== void 0 ? `pull_tx=${pullTx}
+` : "";
+    const tip = buildJobCompletionTip(jobId, params.providerNpub);
+    return textResult(`event_id=${jobId}
+${pullLine}${result}${tip}`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const isTimeout = e instanceof JobWaitTimeoutError;
+    await recordJobOutcome(agent, {
+      jobEventId: jobId,
+      capability: dTag,
+      providerPubkey,
+      providerName: clipProviderName(provider.name),
+      status: isTimeout ? "timeout" : "failed",
+      submittedAt,
+      completedAt: Date.now()
+    });
+    if (isTimeout) {
+      return textResult(
+        `event_id=${jobId}
+Still processing (delegated: the provider pulls payment only after delivering the result). This is NOT an error - retry get_job_result with event_id="${jobId}" later. If the provider never starts, the proof expires within ${MAX_PROOF_TTL_SECS / 60} minutes with no charge.`
+      );
+    }
+    const safeMsg = sanitizeUntrusted(msg, "text").text;
+    return errorResult(
+      `Job ${jobId} failed: ${safeMsg}. Delegated jobs charge only on delivery - no charge occurred unless a pull was reported.`
+    );
+  }
+}
 function awaitJobResult(agent, options, fn, safetyTimeoutMs) {
   return new Promise((resolve, reject) => {
     let closeFn = null;
@@ -3333,233 +3614,59 @@ var customerTools = [
   }),
   defineTool({
     name: "submit_delegated_job",
-    description: "Submit a job paid from your existing spl-approve USDC delegation: the provider does the work FIRST, then pulls from your delegated allowance - no per-job payment transaction from you. On an ordinary capability it pulls the advertised price. On a METERED one (the card carries a `metered` block) the advertised price is a CEILING and the pull is what the job actually consumed, never more than that ceiling - so a metered card is usually cheaper here than its listed price suggests. Requires an ACTIVE delegation to the delegate key this capability advertises (check with get_delegation). Within the approved cap the delegate can pull without your signature, so treat the cap as the max loss. Your per-session spend limit also applies: the job is refused if its ceiling does not fit the remaining session budget. If max_price_lamports is not set, returns the price - or the range, when metered - for confirmation without publishing anything.",
+    description: "Submit a job paid from your existing spl-approve USDC delegation: the provider does the work FIRST, then pulls from your delegated allowance - no per-job payment transaction from you. On an ordinary capability it pulls the advertised price. On a METERED one (the card carries a `metered` block) the advertised price is a CEILING and the pull is what the job actually consumed, never more than that ceiling - so a metered card is usually cheaper here than its listed price suggests. Requires an ACTIVE delegation to the delegate key this capability advertises (check with get_delegation). Within the approved cap the delegate can pull without your signature, so treat the cap as the max loss. Your per-session spend limit also applies: the job is refused if its ceiling does not fit the remaining session budget. An input too large to ride inline is sent via iroh automatically (needs a persistent agent); for a file on disk use submit_delegated_job_from_file. If max_price_lamports is not set, returns the price - or the range, when metered - for confirmation without publishing anything.",
     schema: SubmitDelegatedJobSchema,
     async handler(ctx, input) {
       ctx.toolRateLimiter.check();
-      checkLen("input", input.input, MAX_INPUT_LEN);
       checkLen("provider_npub", input.provider_npub, MAX_NPUB_LEN);
-      const agent = ctx.active();
-      if (!agent.solanaKeypair) {
-        return errorResult(
-          "Solana wallet not configured for this agent - delegated payment signs the proof with the owner (wallet) key."
-        );
-      }
-      const providerPubkey = decodeNpub(input.provider_npub);
-      const dTag = toDTag(input.capability);
-      const timeoutMs = Math.min(input.timeout_secs, MAX_TIMEOUT_SECS) * 1e3;
-      const ping = await agent.client.ping.pingAgent(providerPubkey, PRE_PING_TIMEOUT_MS);
-      if (!ping.online) {
-        return errorResult(
-          `Provider ${input.provider_npub} is offline. Run search_agents to find currently-online providers.`
-        );
-      }
-      const providers = await agent.client.discovery.fetchAgents(agent.network);
-      const provider = providers.find((candidate) => candidate.npub === input.provider_npub);
-      if (!provider) {
-        return errorResult(
-          `Provider ${input.provider_npub} not found on ${agent.network}. Refresh discovery (e.g. search_agents) or verify the npub is correct.`
-        );
-      }
-      const card = paymentCardForCapability(provider, dTag);
-      const descriptor = card?.delegation;
-      if (!descriptor) {
-        return errorResult(
-          `Capability "${input.capability}" of ${input.provider_npub} does not advertise delegated payment. Use submit_and_pay_job instead.`
-        );
-      }
-      const { price, asset } = advertisedPriceForCapability(provider, dTag);
-      if (price <= 0) {
-        return errorResult(
-          `Capability "${input.capability}" advertises no price - delegated payment needs a priced skill. Use create_job for free capabilities.`
-        );
-      }
-      const delegationAsset = resolveUsdcAsset(agent.network);
-      const cardPayment = paymentCardForCapability(provider, dTag)?.payment;
-      const cardMint = cardPayment?.mint;
-      const isCanonicalUsdc = (cardPayment?.chain ?? delegationAsset.chain) === delegationAsset.chain && cardPayment?.token?.toLowerCase() === delegationAsset.token && (cardMint === void 0 || cardMint === delegationAsset.mint);
-      if (!isCanonicalUsdc) {
-        const declared = cardPayment?.symbol ?? cardPayment?.token ?? asset.symbol;
-        const { text } = sanitizeUntrusted(
-          `Delegated payment is USDC-only, but this capability is priced in ${declared}.`,
-          "text"
-        );
-        return errorResult(text);
-      }
-      const priceSubunits = BigInt(price);
-      const rpc = createSolanaRpc(rpcUrlFor(agent.network));
-      const ownerAta = await deriveOwnerDelegationAta(agent.solanaKeypair.publicKey, agent.network);
-      let delegation;
-      try {
-        delegation = await getDelegation(rpc, ownerAta);
-      } catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        return errorResult(`Could not read your delegation on-chain: ${message}`);
-      }
-      if (delegation === null || delegation.delegate === null) {
-        return errorResult(
-          "No active delegation from this wallet. Approve one first (web app Delegation tab, or the approve flow), then retry."
-        );
-      }
-      if (delegation.delegate !== descriptor.delegate_pubkey) {
-        const { text } = sanitizeUntrusted(
-          `Your delegation is granted to ${delegation.delegate}, but this capability advertises delegate ${descriptor.delegate_pubkey} (the provider may have rotated its key). Re-approve the delegation, then retry.`,
-          "text"
-        );
-        return errorResult(text);
-      }
-      if (delegation.remainingCap < priceSubunits) {
-        return errorResult(
-          `Remaining delegated cap ${formatAssetAmount(delegationAsset, delegation.remainingCap)} is below the price ${formatAssetAmount(delegationAsset, priceSubunits)}. Top up the delegation (re-approve) first.`
-        );
-      }
-      if (delegation.balance < priceSubunits) {
+      const inputBytes = utf8ByteLength(input.input);
+      if (inputBytes > LIMITS.MAX_REINLINE_TEXT_BYTES) {
         return errorResult(
-          `Delegation account balance ${formatAssetAmount(delegationAsset, delegation.balance)} is below the price ${formatAssetAmount(delegationAsset, priceSubunits)}. Fund the wallet first.`
+          `Input is ${inputBytes} bytes (max ${LIMITS.MAX_REINLINE_TEXT_BYTES} for an inline job). Send a large file with submit_delegated_job_from_file.`
         );
       }
-      try {
-        assertCanSpend(ctx, delegationAsset, priceSubunits);
-      } catch (e) {
-        return errorResult(e instanceof Error ? e.message : String(e));
-      }
-      const priceGate = await confirmPriceGate({
-        agent,
-        providerLabel: sanitizeField(provider.name || input.provider_npub, 64),
+      const agent = ctx.active();
+      return executeDelegatedJob(ctx, agent, {
+        // Large input spills to iroh transparently; small input stays inline.
+        prepareInput: () => prepareTextInput(agent, input.input),
+        providerNpub: input.provider_npub,
         capability: input.capability,
-        price,
-        asset: delegationAsset,
+        kindOffset: input.kind_offset,
+        timeoutMs: Math.min(input.timeout_secs, MAX_TIMEOUT_SECS) * 1e3,
         maxPriceLamports: input.max_price_lamports,
-        toolName: "submit_delegated_job",
-        // Card-published floor, so the quote reads "from X, never more than Y"
-        // instead of a flat number the buyer will usually not be charged.
-        ...card?.metered !== void 0 ? { meteredMinSubunits: BigInt(card.metered.min_subunits) } : {}
+        toolName: "submit_delegated_job"
       });
-      if (priceGate) {
-        return priceGate;
-      }
-      const ownerSigner = await createKeyPairSignerFromBytes(agent.solanaKeypair.secretKey);
-      const expiryUnix = Math.floor(Date.now() / 1e3) + MAX_PROOF_TTL_SECS;
-      const nonce = mintDelegationNonce();
-      const proof = await buildDelegationAuthProof({
-        ownerSigner,
-        agentDelegate: descriptor.delegate_pubkey,
-        nostrAuthor: agent.identity.publicKey,
-        owner: agent.solanaKeypair.publicKey,
-        expiryUnix,
-        nonce
+    }
+  }),
+  defineTool({
+    name: "submit_delegated_job_from_file",
+    description: "Same as submit_delegated_job, but the job input is read from a file on disk by the MCP server and sent peer-to-peer via iroh - the file content never enters the model's output tokens. Prefer this over submit_and_pay_job_from_file whenever the capability advertises delegation: that tool pays the full listed price up front, while here the provider pulls from your delegation after delivering - on a METERED card only what the job consumed, never more than the listed price. Requires an ACTIVE delegation to the delegate key the capability advertises (check with get_delegation), a persistent agent, and the iroh addon. Text files reach the skill on stdin; binary files via ELISYM_INPUT_FILE. Pass an optional `prompt` to send a text instruction alongside the file; it rides inline (encrypted) while the file rides P2P. If max_price_lamports is not set, returns the price - or the range, when metered - for confirmation without publishing anything.",
+    schema: SubmitDelegatedJobFromFileSchema,
+    async handler(ctx, input) {
+      ctx.toolRateLimiter.check();
+      checkLen("provider_npub", input.provider_npub, MAX_NPUB_LEN);
+      const validated = await validateFileInput(ctx, {
+        inputPath: input.input_path,
+        allowOutsideCwd: input.allow_outside_cwd,
+        prompt: input.prompt
       });
-      const submittedAt = Date.now();
-      const jobId = await agent.client.marketplace.submitJobRequest(agent.identity, {
-        input: input.input,
-        capability: dTag,
-        providerPubkey,
+      if ("error" in validated) {
+        return errorResult(validated.error);
+      }
+      const { agent, prompt, file } = validated;
+      return executeDelegatedJob(ctx, agent, {
+        // Seeded lazily: the delegation pre-checks and price gate run first.
+        prepareInput: async () => {
+          const seeded = await seedFileAttachment(agent, file);
+          return "error" in seeded ? seeded : { input: prompt, attachment: seeded.attachment };
+        },
+        providerNpub: input.provider_npub,
+        capability: input.capability,
         kindOffset: input.kind_offset,
-        acceptTransports: MCP_ACCEPT_TRANSPORTS,
-        delegatedPayment: {
-          owner: agent.solanaKeypair.publicKey,
-          expiryUnix,
-          nonce,
-          proof
-        }
+        timeoutMs: Math.min(input.timeout_secs, MAX_TIMEOUT_SECS) * 1e3,
+        maxPriceLamports: input.max_price_lamports,
+        toolName: "submit_delegated_job_from_file"
       });
-      let resultAttachment;
-      let pullTx;
-      let settledAmountSubunits;
-      try {
-        const result = await awaitJobResult(
-          agent,
-          {},
-          ({ resolve, reject }) => ({
-            jobEventId: jobId,
-            providerPubkey,
-            customerPublicKey: agent.identity.publicKey,
-            callbacks: {
-              onResult(content, _eventId, attachment, _attachments, paymentTx, paidAmountSubunits) {
-                pullTx = paymentTx;
-                settledAmountSubunits = paidAmountSubunits;
-                if (attachment) {
-                  resultAttachment = attachment;
-                  resolve(formatFileResultMetadata(jobId, attachment));
-                  return;
-                }
-                const sanitized = sanitizeResultContent(content);
-                resolve(`Job completed.
-
-${sanitized.text}`);
-              },
-              onError(error) {
-                rejectWithProviderError(reject, error);
-              },
-              onTimeout(waitedMs) {
-                reject(new JobWaitTimeoutError(waitedMs));
-              }
-            },
-            timeoutMs,
-            customerSecretKey: agent.identity.secretKey
-          }),
-          timeoutMs + 5e3
-        );
-        const settledForSession = settledSubunitsForHistory(card, price, settledAmountSubunits);
-        recordSpend(ctx, delegationAsset, BigInt(settledForSession));
-        await recordJobOutcome(agent, {
-          jobEventId: jobId,
-          capability: dTag,
-          providerPubkey,
-          providerName: clipProviderName(provider.name),
-          // What actually moved, as recorded in the buyer's OWN history.
-          //
-          // On a FLAT card the runtime always pulls exactly `price`, so there is
-          // nothing to learn from the provider and the reported figure is only a
-          // way to lie - the card price is the truth by construction.
-          //
-          // On a METERED card the pull is variable, so the provider's report is
-          // the only source of the real number. It is still attacker-controlled
-          // and arrives through a tag parser that accepts negatives and
-          // prefix-parses garbage, so it is trusted only inside the range the
-          // card published and the buyer approved: `[min, price]`. Anything
-          // outside degrades to the ceiling rather than to the attacker's value.
-          paidAmountSubunits: String(settledForSession),
-          // The registry key, not the card's. A mint-less `usdc` card is
-          // accepted by the gate above but keys as `solana:usdc`, which
-          // `assetByKey` cannot resolve and which splits any per-asset
-          // aggregation away from the canonical `solana:usdc:<mint>` rows.
-          assetKey: assetKey(delegationAsset),
-          status: "completed",
-          submittedAt,
-          completedAt: Date.now(),
-          resultPreview: result.slice(0, RESULT_PREVIEW_MAX_LEN),
-          paymentSig: pullTx,
-          attachmentJson: resultAttachment ? JSON.stringify(resultAttachment) : void 0
-        });
-        const pullLine = pullTx !== void 0 ? `pull_tx=${pullTx}
-` : "";
-        const tip = buildJobCompletionTip(jobId, input.provider_npub);
-        return textResult(`event_id=${jobId}
-${pullLine}${result}${tip}`);
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        const isTimeout = e instanceof JobWaitTimeoutError;
-        await recordJobOutcome(agent, {
-          jobEventId: jobId,
-          capability: dTag,
-          providerPubkey,
-          providerName: clipProviderName(provider.name),
-          status: isTimeout ? "timeout" : "failed",
-          submittedAt,
-          completedAt: Date.now()
-        });
-        if (isTimeout) {
-          return textResult(
-            `event_id=${jobId}
-Still processing (delegated: the provider pulls payment only after delivering the result). This is NOT an error - retry get_job_result with event_id="${jobId}" later. If the provider never starts, the proof expires within ${MAX_PROOF_TTL_SECS / 60} minutes with no charge.`
-          );
-        }
-        const safeMsg = sanitizeUntrusted(msg, "text").text;
-        return errorResult(
-          `Job ${jobId} failed: ${safeMsg}. Delegated jobs charge only on delivery - no charge occurred unless a pull was reported.`
-        );
-      }
     }
   }),
   defineTool({
@@ -3918,7 +4025,7 @@ ${text}`);
   }),
   defineTool({
     name: "submit_and_pay_job",
-    description: 'Full customer flow: submit job -> auto-pay -> wait for result. Validates that the payment recipient matches the provider card. If payment succeeded but no result arrives within the wait window, this returns a non-error "still processing" notice with the event ID (NOT a failure) - re-poll get_job_result later (results persist on the relays; for long jobs, poll periodically, e.g. from a subagent). Handles both free and paid providers automatically. If max_price_lamports is not set and the capability is paid, this returns the advertised price for confirmation WITHOUT submitting a job - re-call with max_price_lamports set to approve payments up to that limit (this is a confirmation, not an error). COST: input is sent inline in the tool call, so a large input pays output tokens on the calling LLM. For files or git diffs, prefer submit_and_pay_job_from_file or submit_diff_review respectively.',
+    description: 'Full customer flow: submit job -> auto-pay -> wait for result. Validates that the payment recipient matches the provider card. If payment succeeded but no result arrives within the wait window, this returns a non-error "still processing" notice with the event ID (NOT a failure) - re-poll get_job_result later (results persist on the relays; for long jobs, poll periodically, e.g. from a subagent). Handles both free and paid providers automatically. If max_price_lamports is not set and the capability is paid, this returns the advertised price for confirmation WITHOUT submitting a job - re-call with max_price_lamports set to approve payments up to that limit (this is a confirmation, not an error). COST: input is sent inline in the tool call, so a large input pays output tokens on the calling LLM. For files or git diffs, prefer submit_and_pay_job_from_file or submit_diff_review respectively. This pays the listed price up front; when the capability advertises delegation, submit_delegated_job bills a metered card for actual usage instead.',
     schema: SubmitAndPayJobSchema,
     async handler(ctx, input) {
       ctx.toolRateLimiter.check();
@@ -3957,53 +4064,26 @@ ${text}`);
   }),
   defineTool({
     name: "submit_and_pay_job_from_file",
-    description: "Same as submit_and_pay_job, but the job input is read from a file on disk by the MCP server instead of being passed inline by the LLM. Use this when the input is large or binary (images, logs, captured output) and the LLM only needs to forward it - the file content never enters the model's output tokens. input_path may be absolute or relative to the MCP server's working directory. The file is ALWAYS transferred peer-to-peer via iroh, so this needs: a persistent agent, a PAID provider skill (free skills reject file inputs), and the iroh addon. Text files reach the skill on stdin; binary files via ELISYM_INPUT_FILE. Pass an optional `prompt` to send a text instruction alongside the file (e.g. how to edit an image); it rides inline (encrypted) while the file rides P2P.",
+    description: "Same as submit_and_pay_job, but the job input is read from a file on disk by the MCP server instead of being passed inline by the LLM. Use this when the input is large or binary (images, logs, captured output) and the LLM only needs to forward it - the file content never enters the model's output tokens. input_path may be absolute or relative to the MCP server's working directory. The file is ALWAYS transferred peer-to-peer via iroh, so this needs: a persistent agent, a PAID provider skill (free skills reject file inputs), and the iroh addon. Text files reach the skill on stdin; binary files via ELISYM_INPUT_FILE. Pass an optional `prompt` to send a text instruction alongside the file (e.g. how to edit an image); it rides inline (encrypted) while the file rides P2P. This pays the listed price up front; when the capability advertises delegation, use submit_delegated_job_from_file so a metered card bills only actual usage.",
     schema: SubmitAndPayJobFromFileSchema,
     async handler(ctx, input) {
       ctx.toolRateLimiter.check();
       checkLen("provider_npub", input.provider_npub, MAX_NPUB_LEN);
-      const PROMPT_INLINE_CAP = 55e3;
-      const trimmedPrompt = input.prompt.trim();
-      if (utf8ByteLength(trimmedPrompt) > PROMPT_INLINE_CAP) {
-        return errorResult(
-          `Prompt is too long to ride inline (max ${PROMPT_INLINE_CAP} bytes); the file occupies the only attachment slot, so shorten the prompt.`
-        );
-      }
-      let prepared;
-      try {
-        prepared = await prepareFileInput(input.input_path, {
-          allowOutsideCwd: input.allow_outside_cwd
-        });
-      } catch (e) {
-        return errorResult(e instanceof Error ? e.message : String(e));
-      }
-      const agent = ctx.active();
-      if (agent.agentDir === void 0) {
-        return errorResult(
-          `Sending a file requires a persistent agent (this is an ephemeral session). Files are always transferred P2P via iroh, never inline.`
-        );
+      const validated = await validateFileInput(ctx, {
+        inputPath: input.input_path,
+        allowOutsideCwd: input.allow_outside_cwd,
+        prompt: input.prompt
+      });
+      if ("error" in validated) {
+        return errorResult(validated.error);
       }
-      let attachment;
-      try {
-        const seeded = await ensureIrohTransport(agent).seedPath(prepared.absPath);
-        attachment = {
-          name: prepared.name,
-          size: seeded.size,
-          mime: prepared.mime,
-          transports: [{ kind: "iroh", ticket: seeded.ticket }]
-        };
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        if (/@number0\/iroh|iroh file transfer is unavailable/i.test(msg)) {
-          return errorResult(
-            `File transfer is unavailable: the optional @number0/iroh addon is not installed. Install it (e.g. \`bun add @number0/iroh\`) to send files.`
-          );
-        }
-        return errorResult(`Failed to seed file for transfer: ${msg}`);
+      const seeded = await seedFileAttachment(validated.agent, validated.file);
+      if ("error" in seeded) {
+        return errorResult(seeded.error);
       }
-      return executeSubmitAndPay(ctx, agent, {
-        input: trimmedPrompt,
-        attachment,
+      return executeSubmitAndPay(ctx, validated.agent, {
+        input: validated.prompt,
+        attachment: seeded.attachment,
         providerNpub: input.provider_npub,
         providerPubkey: decodeNpub(input.provider_npub),
         capability: input.capability,
@@ -4730,11 +4810,11 @@ var discoveryTools = [
               // Metered pricing: `job_price` above is then the CEILING, and the
               // real charge lands between the floor and it. Surfaced so a buying
               // model does not read the ceiling as a flat rate and skip a card
-              // that is usually far cheaper. Only ever reachable through
-              // submit_delegated_job - the ordinary paid path settles up front
-              // and always collects the ceiling.
+              // that is usually far cheaper. Only ever reachable through the
+              // delegated tools - the ordinary paid path settles up front and
+              // always collects the ceiling.
               // Gated on `delegation` too: metering is only reachable through
-              // `submit_delegated_job`, which refuses a card with no delegation
+              // the delegated tools, which refuse a card with no delegation
               // descriptor outright. Advertising "billed for actual usage
               // (requires delegated payment)" on such a card would point a
               // buying model at a door that is bolted shut.
@@ -4750,7 +4830,8 @@ var discoveryTools = [
               network: card.payment?.network,
               network_fee_estimate_sol: gasEstimate,
               // File-exchange hints (dynamic-script). Informational: the MCP/CLI
-              // CAN send files via submit_and_pay_job_from_file, so this does not
+              // CAN send files via submit_and_pay_job_from_file and
+              // submit_delegated_job_from_file, so this does not
               // gate anything - it just tells the caller a file input is expected.
               // Already length-bounded by parseCapabilityEvent.
               ...card.inputMime ? { input_mime: card.inputMime } : {},