@haven_ai/signer 0.6.0-alpha.0 → 0.8.0-alpha.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { randomUUID, createHash } from 'crypto';
 import { readFile, mkdir, writeFile, stat, lstat, rename, appendFile, chmod } from 'fs/promises';
 import { resolve, dirname, join } from 'path';
-import { createNextStepBuilder, havenClientIdentity, isSupportedNodeVersion, unsupportedNodeVersionMessage, addressFromKey, HavenSigningError, buildSweepTypedData, selectStandardPaymentOption, HavenApiError, toStandardPaymentRequirements, decodeBase64Json, encodeBase64Json, x402V2PaymentEnvelope, isSettlementChildTypedData, chainIdForNetwork, assertOwnSettlementChild, isPackedUserOperationTypedData, assertUserOpTypedDataBinding, assertBoundDirectPaymentUserOp as assertBoundDirectPaymentUserOp$1, assertFundingLegPaysDelegate, HavenTypedDataRefusedError, connectorRerunCommand, buildSweepAuthorizationMessage, verifySignature, x402AuthorizationAmount, SignerRefusalCode, SIGNER_UPDATE_FALLBACK, HavenUnsupportedSignerVersionError, buildX402ExpectedMessage, DIRECT_SIGN_CONTEXT_VERSION, HavenError, AgentPaymentFailureCode, AgentPaymentNextAction, HavenUserOpBindingError, assertOwnTaskChild, assertOwnTaskBudgetCloseUserOp, readClientUpdate, HAVEN_CLIENT_HEADER } from '@haven_ai/sdk/edge';
+import { createNextStepBuilder, havenClientIdentity, isSupportedNodeVersion, unsupportedNodeVersionMessage, addressFromKey, HavenSigningError, buildSweepTypedData, selectStandardPaymentOption, HavenApiError, toStandardPaymentRequirements, decodeBase64Json, encodeBase64Json, x402V2PaymentEnvelope, isSettlementChildTypedData, chainIdForNetwork, assertOwnSettlementChild, isPackedUserOperationTypedData, assertUserOpTypedDataBinding, assertBoundDirectPaymentUserOp as assertBoundDirectPaymentUserOp$1, assertFundingLegPaysDelegate, HavenTypedDataRefusedError, connectorUpgradeCommand, buildSweepAuthorizationMessage, verifySignature, x402AuthorizationAmount, SignerRefusalCode, SIGNER_UPDATE_FALLBACK, HavenUnsupportedSignerVersionError, buildX402ExpectedMessage, TASK_SIGN_CONTEXT_VERSION, DIRECT_SIGN_CONTEXT_VERSION, HavenError, AgentPaymentFailureCode, AgentPaymentNextAction, HavenUserOpBindingError, connectorRerunCommand, assertOwnTaskChild, assertOwnTaskBudgetCloseUserOp, assertOwnSubBudgetChild, assertOwnSubBudgetCloseUserOp, readClientUpdate, HAVEN_CLIENT_HEADER } from '@haven_ai/sdk/edge';
 import { recoverTypedDataAddress, hashTypedData, hashMessage } from 'viem';
 import { z as z$1 } from 'zod/v3';
 import { z } from 'zod';
@@ -12,7 +12,14 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { privateKeyToAccount } from 'viem/accounts';
 
 var SIGNER_HOSTED_HANDOFF_SHAPES = {
-  haven_get_payment_status: { payment_id: z.string().min(1) }
+  haven_get_payment_status: { payment_id: z.string().min(1) },
+  // #3506: `haven_sign` hands a signed budget row to the hosted `haven_submit`
+  // (`signTaskBudget` / `signSubBudget` in tools.ts emit exactly these
+  // `next_arguments`). One hosted tool, two argument shapes, so each shape is
+  // its own entry keyed `<hosted tool>#<variant>`; the parity test reads the
+  // part before `#` as the hosted tool it checks the entry against.
+  "haven_submit#task_budget": { task_budget_id: z.string().min(1), signature: z.string().regex(/^0x[0-9a-fA-F]+$/) },
+  "haven_submit#sub_budget": { sub_budget_id: z.string().min(1), signature: z.string().regex(/^0x[0-9a-fA-F]+$/) }
 };
 function target(shape) {
   const schema = z.object(shape).strict();
@@ -159,7 +166,8 @@ function stableStringify(value) {
   const object = value;
   return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
 }
-var DIRECT_RELAY_FALLBACK = "call haven_sign with payload_hash and typed_data_b64 from the haven_send / haven_pay result, passed through unchanged";
+var DIRECT_RELAY_FALLBACK = "re-run whichever of haven_send / haven_pay you called, with the SAME idempotency_key (echoed on its result) plus include_signing_payload: true, then call haven_sign with payload_hash and typed_data_b64 from THAT re-run's result, passed through unchanged";
+var DIRECT_404_FALLBACK = "either the payment_id is not from this agent\u2019s own POST /payments call, or this Haven backend predates #3271 (which also predates #3495, so its result already carries payload_hash and typed_data_b64 unconditionally): pass those fields from the ORIGINAL haven_send / haven_pay result, unchanged, if it already carries them \u2014 or, on a newer server, re-run haven_send / haven_pay with the SAME idempotency_key plus include_signing_payload: true and pass them from THAT result instead";
 var HavenSignContextError = class extends HavenSigningError {
   /**
    * #3001 / #3010 review: the recovery path, when signing OTHER bytes is
@@ -212,7 +220,7 @@ var HavenSignContextError = class extends HavenSigningError {
   /**
    * #3303: on a 426 `client_outdated` refusal, the backend's update hint —
    * this signer is below the minimum the deployment set, and
-   * `client_update.upgrade_command` is what updates it.
+   * `client_update.upgrade_command` starts the update (#3412: for the signer, the doctor, then its repair line).
    */
   client_update;
   constructor(message, code, refusal, paymentId, flow = "x402") {
@@ -229,7 +237,7 @@ var HavenSignContextError = class extends HavenSigningError {
         step = signerRefusalStep({
           nextAction: AgentPaymentNextAction.StopAndTellUser,
           nextTool: null,
-          nextToolOmittedReason: `this signer is below the minimum version Haven accepts \u2014 tell the user to run ${refusal.clientUpdate?.upgrade_command ?? "the connector again"}, restart the agent runtime, then retry the same haven_sign / haven_sign_x402 call`
+          nextToolOmittedReason: `this signer is below the minimum version Haven accepts \u2014 tell the user to run ${refusal.clientUpdate?.upgrade_command ?? connectorUpgradeCommand()} and the repair line it prints, restart the agent runtime, then retry the same haven_sign / haven_sign_x402 call`
         });
       } else if (flow === "direct" && refusal?.httpStatus === 404) {
         this.fallback = "typed_data_b64";
@@ -237,7 +245,7 @@ var HavenSignContextError = class extends HavenSigningError {
         step = signerRefusalStep({
           nextAction: AgentPaymentNextAction.StopAndTellUser,
           nextTool: null,
-          nextToolOmittedReason: DIRECT_RELAY_FALLBACK
+          nextToolOmittedReason: DIRECT_404_FALLBACK
         });
       } else if (flow === "direct" && refusal?.errorCode === "expired") {
         this.next_action = AgentPaymentNextAction.PaymentWindowExpired;
@@ -392,7 +400,7 @@ async function fetchDirectSignContext(identity, paymentId, fetchImpl = fetch, ti
   } catch (err) {
     const timedOut = err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
     throw new HavenSignContextError(
-      timedOut ? `Haven did not answer the direct-payment signing-context fetch for ${paymentId} within ${timeoutMs} ms. Retry, or pass typed_data_b64 from the payment result instead.` : `Could not reach Haven to fetch the direct-payment signing context for ${paymentId}: ${err instanceof Error ? err.message : String(err)}. Retry, or pass typed_data_b64 from the payment result instead.`,
+      timedOut ? `Haven did not answer the direct-payment signing-context fetch for ${paymentId} within ${timeoutMs} ms. Retry, or re-run haven_send / haven_pay with the same idempotency_key plus include_signing_payload: true and pass typed_data_b64 from that result instead.` : `Could not reach Haven to fetch the direct-payment signing context for ${paymentId}: ${err instanceof Error ? err.message : String(err)}. Retry, or re-run haven_send / haven_pay with the same idempotency_key plus include_signing_payload: true and pass typed_data_b64 from that result instead.`,
       timedOut ? "SIGN_CONTEXT_TIMEOUT" : "SIGN_CONTEXT_UNREACHABLE",
       void 0,
       paymentId,
@@ -405,7 +413,7 @@ async function fetchDirectSignContext(identity, paymentId, fetchImpl = fetch, ti
   } catch (err) {
     if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
       throw new HavenSignContextError(
-        `Haven did not finish sending the direct-payment signing context for ${paymentId} within ${timeoutMs} ms. Retry, or pass typed_data_b64 from the payment result instead.`,
+        `Haven did not finish sending the direct-payment signing context for ${paymentId} within ${timeoutMs} ms. Retry, or re-run haven_send / haven_pay with the same idempotency_key plus include_signing_payload: true and pass typed_data_b64 from that result instead.`,
         "SIGN_CONTEXT_TIMEOUT",
         void 0,
         paymentId,
@@ -417,7 +425,7 @@ async function fetchDirectSignContext(identity, paymentId, fetchImpl = fetch, ti
   if (!response.ok) {
     const detail = typeof body.error === "string" ? body.error : `HTTP ${response.status}`;
     throw new HavenSignContextError(
-      `Haven refused the direct-payment signing-context fetch for ${paymentId}: ${detail}` + (response.status === 404 ? " \u2014 either the payment_id is not from this agent\u2019s own POST /payments call, or this Haven backend predates #3271. Pass payload_hash and typed_data_b64 from the haven_send / haven_pay result, unchanged, instead." : body.error_code === "expired" ? " The payment window has expired; call haven_send / haven_pay again with the same idempotency_key." : ""),
+      `Haven refused the direct-payment signing-context fetch for ${paymentId}: ${detail}` + (response.status === 404 ? " \u2014 either the payment_id is not from this agent\u2019s own POST /payments call, or this Haven backend predates #3271 (which also predates #3495, so its haven_send / haven_pay result already carries payload_hash and typed_data_b64 unconditionally). Pass payload_hash and typed_data_b64, unchanged, from the original result \u2014 or, on a newer server, from a same-key re-run with include_signing_payload: true." : body.error_code === "expired" ? " The payment window has expired; call haven_send / haven_pay again with the same idempotency_key." : ""),
       "SIGN_CONTEXT_REFUSED",
       refusalOf(response.status, body),
       paymentId,
@@ -428,7 +436,7 @@ async function fetchDirectSignContext(identity, paymentId, fetchImpl = fetch, ti
   const version = body.direct_sign_context_version;
   if (!signData || typeof signData.hash !== "string" || !signData.typed_data || typeof signData.typed_data !== "object" || signData.signature_scheme !== "eip712_userop" || typeof version !== "number" || !SUPPORTED_DIRECT_SIGN_CONTEXT_VERSIONS.includes(version)) {
     throw new HavenSignContextError(
-      typeof version === "number" && !SUPPORTED_DIRECT_SIGN_CONTEXT_VERSIONS.includes(version) ? `The Haven direct-payment sign-context response is version ${version}, which this signer does not support (supported: ${SUPPORTED_DIRECT_SIGN_CONTEXT_VERSIONS.join(", ")}). Update @haven_ai/signer.` : "The Haven direct-payment sign-context response is missing sign_data.typed_data, or its signature_scheme is not 'eip712_userop' \u2014 the backend may predate #3271. Pass typed_data_b64 from the payment result instead.",
+      typeof version === "number" && !SUPPORTED_DIRECT_SIGN_CONTEXT_VERSIONS.includes(version) ? `The Haven direct-payment sign-context response is version ${version}, which this signer does not support (supported: ${SUPPORTED_DIRECT_SIGN_CONTEXT_VERSIONS.join(", ")}). Update @haven_ai/signer.` : "The Haven direct-payment sign-context response is missing sign_data.typed_data, or its signature_scheme is not 'eip712_userop' \u2014 the backend may predate #3271. Re-run haven_send / haven_pay with the same idempotency_key plus include_signing_payload: true and pass typed_data_b64 from that result instead.",
       "SIGN_CONTEXT_MALFORMED",
       void 0,
       paymentId,
@@ -444,7 +452,120 @@ async function fetchDirectSignContext(identity, paymentId, fetchImpl = fetch, ti
     clientUpdate: readClientUpdate(body.client_update)
   };
 }
-var SUPPORTED_TASK_SIGN_CONTEXT_VERSIONS = [1];
+var SUPPORTED_TASK_SIGN_CONTEXT_VERSIONS = [TASK_SIGN_CONTEXT_VERSION];
+var SUPPORTED_SUB_BUDGET_SIGN_CONTEXT_VERSIONS = [1];
+async function fetchSubBudgetSignContext(identity, subBudgetId, fetchImpl = fetch, timeoutMs = SIGN_CONTEXT_TIMEOUT_MS, clientIdentity) {
+  let response;
+  try {
+    response = await fetchImpl(
+      `${identity.apiUrl}/sub-budgets/${encodeURIComponent(subBudgetId)}/sign-context`,
+      {
+        headers: signContextHeaders(identity, clientIdentity),
+        signal: AbortSignal.timeout(timeoutMs)
+      }
+    );
+  } catch (err) {
+    const timedOut = err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
+    throw new HavenSignContextError(
+      timedOut ? `Haven did not answer the sub-budget signing-context fetch for ${subBudgetId} within ${timeoutMs} ms. Retry.` : `Could not reach Haven to fetch the sub-budget signing context for ${subBudgetId}: ${err instanceof Error ? err.message : String(err)}.`,
+      timedOut ? "SIGN_CONTEXT_TIMEOUT" : "SIGN_CONTEXT_UNREACHABLE",
+      void 0,
+      subBudgetId,
+      "task"
+    );
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (err) {
+    if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
+      throw new HavenSignContextError(
+        `Haven did not finish sending the sub-budget signing context for ${subBudgetId} within ${timeoutMs} ms. Retry.`,
+        "SIGN_CONTEXT_TIMEOUT",
+        void 0,
+        subBudgetId,
+        "task"
+      );
+    }
+    body = {};
+  }
+  if (!response.ok) {
+    const detail = typeof body.error === "string" ? body.error : `HTTP ${response.status}`;
+    throw new HavenSignContextError(
+      `Haven refused the sub-budget signing-context fetch for ${subBudgetId}: ${detail}`,
+      "SIGN_CONTEXT_REFUSED",
+      refusalOf(response.status, body),
+      subBudgetId,
+      "task"
+    );
+  }
+  const purpose = body.purpose;
+  const typedData = body.typed_data;
+  const version = body.sub_budget_sign_context_version;
+  const expected = body.expected;
+  const malformed = (detail) => {
+    throw new HavenSignContextError(
+      `The Haven sub-budget sign-context response for ${subBudgetId} is malformed: ${detail}.`,
+      "SIGN_CONTEXT_MALFORMED",
+      void 0,
+      subBudgetId,
+      "task"
+    );
+  };
+  if (typeof version !== "number" || !SUPPORTED_SUB_BUDGET_SIGN_CONTEXT_VERSIONS.includes(version)) {
+    throw new HavenSignContextError(
+      `The Haven sub-budget sign-context response is version ${String(version)}, which this signer does not support (supported: ${SUPPORTED_SUB_BUDGET_SIGN_CONTEXT_VERSIONS.join(", ")}). Update @haven_ai/signer.`,
+      "SIGN_CONTEXT_MALFORMED",
+      void 0,
+      subBudgetId,
+      "task"
+    );
+  }
+  if (!typedData || typeof typedData !== "object") return malformed("missing typed_data");
+  if (!expected || typeof expected !== "object") return malformed("missing expected");
+  const e = expected;
+  if (purpose === "open") {
+    if (typeof e.delegate_account !== "string" || typeof e.chain_id !== "number" || typeof e.token_address !== "string" || typeof e.period_amount_atomic !== "string" || typeof e.period_duration_seconds !== "number" || typeof e.start_date !== "number" || e.recipient_address !== null && typeof e.recipient_address !== "string" || typeof e.expires_at !== "number" || typeof e.parent_delegation_hash !== "string" || typeof e.child_delegate_account !== "string") {
+      return malformed("expected is missing a required field for purpose open");
+    }
+    return {
+      purpose: "open",
+      subBudgetId: String(body.sub_budget_id ?? subBudgetId),
+      typedData,
+      expected: {
+        delegateAccount: e.delegate_account,
+        chainId: e.chain_id,
+        tokenAddress: e.token_address,
+        periodAmountAtomic: e.period_amount_atomic,
+        periodDurationSeconds: e.period_duration_seconds,
+        startDate: e.start_date,
+        recipientAddress: e.recipient_address ?? null,
+        expiresAt: e.expires_at,
+        parentDelegationHash: e.parent_delegation_hash,
+        childDelegateAccount: e.child_delegate_account
+      }
+    };
+  }
+  if (purpose === "close") {
+    const userOpHash = body.user_op_hash;
+    if (typeof userOpHash !== "string") return malformed("missing user_op_hash for purpose close");
+    if (typeof e.delegate_account !== "string" || typeof e.chain_id !== "number" || typeof e.delegation_hash !== "string") {
+      return malformed("expected is missing a required field for purpose close");
+    }
+    return {
+      purpose: "close",
+      subBudgetId: String(body.sub_budget_id ?? subBudgetId),
+      typedData,
+      userOpHash,
+      expected: {
+        delegateAccount: e.delegate_account,
+        chainId: e.chain_id,
+        delegationHash: e.delegation_hash
+      }
+    };
+  }
+  return malformed(`unknown purpose '${String(purpose)}'`);
+}
 async function fetchTaskBudgetSignContext(identity, taskBudgetId, fetchImpl = fetch, timeoutMs = SIGN_CONTEXT_TIMEOUT_MS, clientIdentity) {
   let response;
   try {
@@ -556,6 +677,9 @@ async function fetchTaskBudgetSignContext(identity, taskBudgetId, fetchImpl = fe
 }
 
 // src/tools.ts
+var SIGNER_NAME = "@haven_ai/signer";
+var SIGNER_VERSION = "0.8.0-alpha.0";
+var UNSUPPORTED_ARGUMENT_MARKER = "HavenSignerUnsupportedArgument:";
 var USEROP_BINDING_MISMATCH = "USEROP_BINDING_MISMATCH";
 var HavenUserOpBindingRefusedError = class extends HavenSigningError {
   next_action = AgentPaymentNextAction.StopAndTellUser;
@@ -568,7 +692,7 @@ var HavenUserOpBindingRefusedError = class extends HavenSigningError {
     this.step = signerRefusalStep({
       nextAction: AgentPaymentNextAction.StopAndTellUser,
       nextTool: null,
-      nextToolOmittedReason: "call haven_sign again with payment_id alone (preferred), or with typed_data copied unchanged from the payment result"
+      nextToolOmittedReason: "call haven_sign again with payment_id alone (preferred), or with typed_data copied unchanged from the payment result (or, on a compact direct-payment result, from a same-key re-run with include_signing_payload: true)"
     });
   }
 };
@@ -683,7 +807,13 @@ var toolSchemas = {
     // Mutually exclusive with payment_id / payload_hash (checked in the
     // handler, since Zod's object-level refine on a raw shape used by
     // several call sites is not the shape this schema is composed as).
-    task_budget_id: z$1.string().min(1).optional()
+    task_budget_id: z$1.string().min(1).optional(),
+    // #3330: sign a sub-budget's own child delegation or its early-close
+    // UserOp — same fetch-verify-sign channel as task_budget_id, against
+    // `GET /sub-budgets/:id/sign-context`. Mutually exclusive with
+    // payment_id / payload_hash AND with task_budget_id (checked in the
+    // handler).
+    sub_budget_id: z$1.string().min(1).optional()
   },
   haven_x402_sign_header: {
     // The parsed HTTP 402 PaymentRequired from the merchant. Typed as an object
@@ -964,9 +1094,76 @@ function createToolHandlers(signer, options = {}) {
       next_arguments: { task_budget_id: ctx.taskBudgetId, signature }
     };
   }
+  async function signSubBudget(subBudgetId) {
+    const identity = await options.signContext?.loadIdentity() ?? null;
+    if (!identity) {
+      throw new HavenSigningError(
+        `sub_budget_id signing needs the agent identity (identity.json next to the signer credentials), which this signer could not load. Re-run \`${connectorRerunCommand()}\` to restore it.`
+      );
+    }
+    const ctx = await fetchSubBudgetSignContext(
+      identity,
+      subBudgetId,
+      options.signContext?.fetchImpl,
+      void 0,
+      options.signContext?.clientIdentity
+    );
+    let signature;
+    if (ctx.purpose === "open") {
+      try {
+        assertOwnSubBudgetChild(
+          ctx.typedData,
+          {
+            chainId: ctx.expected.chainId,
+            tokenAddress: ctx.expected.tokenAddress,
+            periodAmountAtomic: ctx.expected.periodAmountAtomic,
+            periodDurationSeconds: ctx.expected.periodDurationSeconds,
+            startDate: ctx.expected.startDate,
+            recipientAddress: ctx.expected.recipientAddress,
+            expiresAt: ctx.expected.expiresAt,
+            parentDelegationHash: ctx.expected.parentDelegationHash,
+            delegateAccount: ctx.expected.delegateAccount,
+            childDelegateAccount: ctx.expected.childDelegateAccount
+          },
+          signer.delegateAddress
+        );
+      } catch (err) {
+        if (err instanceof HavenTypedDataRefusedError) throw err;
+        throw new HavenTypedDataRefusedError(err instanceof Error ? err.message : String(err));
+      }
+      signature = await signer.signDelegationTypedData(ctx.typedData);
+    } else {
+      try {
+        assertUserOpTypedDataBinding(ctx.typedData, ctx.userOpHash);
+      } catch (err) {
+        if (err instanceof HavenUserOpBindingError) throw new HavenUserOpBindingRefusedError(err.message);
+        throw err;
+      }
+      try {
+        assertOwnSubBudgetCloseUserOp(
+          ctx.typedData,
+          { delegationHash: ctx.expected.delegationHash },
+          signer.delegateAddress
+        );
+      } catch (err) {
+        if (err instanceof HavenTypedDataRefusedError) throw err;
+        throw new HavenTypedDataRefusedError(err instanceof Error ? err.message : String(err));
+      }
+      signature = await signer.signDelegationTypedData(ctx.typedData);
+    }
+    await auditSigning("haven_sign", hashTypedData(ctx.typedData));
+    return {
+      signature,
+      sub_budget_id: ctx.subBudgetId,
+      purpose: ctx.purpose,
+      next_tool_name: "haven_submit",
+      next_tool_server_role: "hosted",
+      next_arguments: { sub_budget_id: ctx.subBudgetId, signature }
+    };
+  }
   return {
     haven_sign: async (input) => runTool(async () => {
-      const args = parse("haven_sign", coerceX402Expected(input));
+      const args = parseStrictFor("haven_sign", coerceX402Expected(input));
       if (args.task_budget_id) {
         if (args.payment_id || args.payload_hash) {
           throw new z$1.ZodError([
@@ -977,8 +1174,29 @@ function createToolHandlers(signer, options = {}) {
             }
           ]);
         }
+        if (args.sub_budget_id) {
+          throw new z$1.ZodError([
+            {
+              code: z$1.ZodIssueCode.custom,
+              path: ["sub_budget_id"],
+              message: "task_budget_id is mutually exclusive with sub_budget_id \u2014 pass exactly one."
+            }
+          ]);
+        }
         return signTaskBudget(args.task_budget_id);
       }
+      if (args.sub_budget_id) {
+        if (args.payment_id || args.payload_hash) {
+          throw new z$1.ZodError([
+            {
+              code: z$1.ZodIssueCode.custom,
+              path: ["sub_budget_id"],
+              message: "sub_budget_id is mutually exclusive with payment_id / payload_hash \u2014 pass exactly one."
+            }
+          ]);
+        }
+        return signSubBudget(args.sub_budget_id);
+      }
       const resolved = await resolveSignContext(args, { allowDirectFallback: true });
       const typedData = resolved?.ctx.typedData ?? resolveTypedData(args);
       const payloadHash = resolved?.ctx.payloadHash ?? args.payload_hash;
@@ -1021,7 +1239,7 @@ function createToolHandlers(signer, options = {}) {
       return { signature: result.signature, x402_binding: result.x402Binding, ...clientUpdateField(resolved) };
     }),
     haven_x402_sign_header: async (input) => runTool(async () => {
-      const args = parse("haven_x402_sign_header", coercePaymentRequired(input));
+      const args = parseStrictFor("haven_x402_sign_header", coercePaymentRequired(input));
       const result = await signer.buildX402PaymentHeader(
         args.payment_required,
         args.x402_binding
@@ -1033,7 +1251,7 @@ function createToolHandlers(signer, options = {}) {
       return { payment_header: result.paymentHeader, accepted: result.accepted };
     }),
     haven_sign_x402: async (input) => runTool(async () => {
-      const args = parse("haven_sign_x402", coerceX402Expected(coercePaymentRequired(input)));
+      const args = parseStrictFor("haven_sign_x402", coerceX402Expected(coercePaymentRequired(input)));
       const resolved = await resolveSignContext(args, { allowDirectFallback: false });
       const fetched = resolved?.kind === "x402" ? resolved.ctx : void 0;
       const payloadHash = fetched?.payloadHash ?? args.payload_hash;
@@ -1069,7 +1287,7 @@ function createToolHandlers(signer, options = {}) {
       };
     }),
     haven_sign_sweep_delegate: async (input) => runTool(async () => {
-      const args = parse("haven_sign_sweep_delegate", input);
+      const args = parseStrictFor("haven_sign_sweep_delegate", input);
       const result = await signer.signSweepAuthorization({
         authorization: args.authorization,
         expectedAuth: args.expected_auth,
@@ -1102,8 +1320,18 @@ function createToolHandlers(signer, options = {}) {
     }
   }
 }
-function parse(name, input) {
-  return z$1.object(toolSchemas[name]).parse(input ?? {});
+function parseStrictFor(name, input) {
+  const result = z$1.object(toolSchemas[name]).strict().safeParse(input ?? {});
+  if (result.success) return result.data;
+  const topLevelUnknown = result.error.issues.flatMap(
+    (issue) => issue.code === "unrecognized_keys" && issue.path.length === 0 ? issue.keys : []
+  );
+  if (topLevelUnknown.length === 0) throw result.error;
+  const unknown = [...new Set(topLevelUnknown)];
+  const err = new Error(
+    `${UNSUPPORTED_ARGUMENT_MARKER} ${name} does not accept ${unknown.map((k) => `"${k}"`).join(", ")} \u2014 this signer predates that argument form. Nothing was signed or fetched.`
+  );
+  throw err;
 }
 function coerceX402Expected(input) {
   if (!input || typeof input !== "object") return input;
@@ -1142,6 +1370,25 @@ async function runTool(fn) {
   }
 }
 function normalizeError(err) {
+  if (err instanceof Error && err.message.startsWith(UNSUPPORTED_ARGUMENT_MARKER)) {
+    const unknown = [...err.message.matchAll(/"([^"]+)"/g)].map((m) => m[1]);
+    return {
+      success: false,
+      code: "UNSUPPORTED_ARGUMENT",
+      message: err.message.replace(`${UNSUPPORTED_ARGUMENT_MARKER} `, ""),
+      unknown_arguments: unknown,
+      signer_version: SIGNER_VERSION,
+      fallback: connectorUpgradeCommand(),
+      next_action: AgentPaymentNextAction.StopAndTellUser,
+      ...nextStepWireFields(
+        signerRefusalStep({
+          nextAction: AgentPaymentNextAction.StopAndTellUser,
+          nextTool: null,
+          nextToolOmittedReason: `update @haven_ai/signer: run ${connectorUpgradeCommand()} and the repair line it prints, then repeat the same call`
+        })
+      )
+    };
+  }
   if (err instanceof z$1.ZodError) {
     return {
       success: false,
@@ -1163,7 +1410,9 @@ function normalizeError(err) {
       ...nextStepWireFields(signerRefusalStep({
         nextAction: AgentPaymentNextAction.StopAndTellUser,
         nextTool: null,
-        nextToolOmittedReason: "update @haven_ai/signer by re-running the connector, then repeat the same call"
+        // #3412: the upgrade command, not "re-run the connector" — a bare re-run
+        // stops at "Missing --setup" on an existing install.
+        nextToolOmittedReason: `update @haven_ai/signer: run ${connectorUpgradeCommand()} and the repair line it prints, then repeat the same call`
       }))
     };
   }
@@ -1249,7 +1498,7 @@ function normalizeError(err) {
 
 // src/consent.ts
 var toolSummaries = {
-  haven_sign: "signs a Haven-prepared payment, task-budget open, or task-budget close (a UserOp from your own account whose only call redeems a delegation made to it, directly or through a self-delegated task-budget child, or an x402 funding intent against a Haven-signed context)",
+  haven_sign: "signs a Haven-prepared payment, task-budget or sub-budget open or close (a UserOp from your own account redeeming a delegation made to it, directly or via a task-budget child; a sub-budget child narrowing your budget for another agent of yours; or an x402 funding intent against a Haven-signed context)",
   haven_x402_sign_header: "builds and signs the EIP-3009 merchant payment header for an x402 payment",
   haven_sign_x402: "the two above in one call: funding payload + merchant header",
   haven_sign_sweep_delegate: "signs a Haven-prepared gasless sweep of stranded funds back to your own account"
@@ -1680,7 +1929,7 @@ function assertSupportedBindingVersion(received, supported, context) {
   const highest = Math.max(...supported);
   const outOfDate = received > highest;
   const code = context === "x402 expected context" ? SignerRefusalCode.UnsupportedExpectedContextVersion : SignerRefusalCode.UnsupportedSweepBindingVersion;
-  const ceiling = outOfDate ? `This signer is out of date: it supports ${context} versions up to ${highest}, and Haven sent version ${received}. Update @haven_ai/signer \u2014 rerun the Haven connector (\`${connectorRerunCommand()}\`), which reinstalls the pinned MCP runtime.` : `Unsupported ${context} version ${received}: this signer supports ${supported.join(", ")}.`;
+  const ceiling = outOfDate ? `This signer is out of date: it supports ${context} versions up to ${highest}, and Haven sent version ${received}. Update @haven_ai/signer \u2014 run \`${connectorUpgradeCommand()}\`, then the repair line it prints, which reinstalls the pinned MCP runtime.` : `Unsupported ${context} version ${received}: this signer supports ${supported.join(", ")}.`;
   const fallback = outOfDate ? SIGNER_UPDATE_FALLBACK : `This ${context} version (${received}) is older than what this signer enforces (${supported.join(", ")}) \u2014 updating @haven_ai/signer will not restore it. Nothing was signed or spent; stop and tell the user rather than retrying.`;
   throw new HavenUnsupportedSignerVersionError(
     `${ceiling} Nothing was signed. Do not rewrite the version field to a supported value: it is part of the Haven-signed binding message, so changing it invalidates the signature and would misrepresent what Haven declared.`,
@@ -1782,7 +2031,8 @@ function signerCompatibility() {
     x402_expected_context_versions: [...SUPPORTED_X402_EXPECTED_VERSIONS],
     sweep_binding_versions: [...SUPPORTED_SWEEP_BINDING_VERSIONS],
     direct_sign_context_versions: [...SUPPORTED_DIRECT_SIGN_CONTEXT_VERSIONS],
-    task_sign_context_versions: [...SUPPORTED_TASK_SIGN_CONTEXT_VERSIONS]
+    task_sign_context_versions: [...SUPPORTED_TASK_SIGN_CONTEXT_VERSIONS],
+    sub_budget_sign_context_versions: [...SUPPORTED_SUB_BUDGET_SIGN_CONTEXT_VERSIONS]
   };
 }
 function signerCapabilityAdvertisement() {
@@ -1802,12 +2052,13 @@ function signerInstructions() {
     `- sweep authorization binding versions supported: ${compatibility.sweep_binding_versions.join(", ")}`,
     `- direct-payment (haven_send / haven_pay) sign-context versions supported: ${compatibility.direct_sign_context_versions.join(", ")} \u2014 pass payment_id alone to haven_sign; this signer fetches the exact bytes`,
     `- task-budget sign-context versions supported: ${compatibility.task_sign_context_versions.join(", ")} \u2014 pass task_budget_id alone to haven_sign; this signer fetches the exact bytes`,
+    `- sub-budget sign-context versions supported: ${compatibility.sub_budget_sign_context_versions.join(", ")} \u2014 pass sub_budget_id alone to haven_sign; this signer fetches the exact bytes (a sub-budget your owner issued narrows your own budget for another agent of your account)`,
     "",
     "Haven quote and prepare results report the expected-context version they will emit",
     "(signer_compatibility.x402_expected_context_version). If that version is not in the list",
     "above, this signer is out of date: STOP before signing, and tell the user to update",
-    `@haven_ai/signer by rerunning \`${connectorRerunCommand()}\`, which reinstalls the pinned`,
-    "MCP runtime. Do not edit the version field to a supported value \u2014 it is part of the",
+    `@haven_ai/signer: run \`${connectorUpgradeCommand()}\`, then the repair line it prints,`,
+    "which reinstalls the pinned MCP runtime. Do not edit the version field to a supported value \u2014 it is part of the",
     "Haven-signed binding message, so changing it invalidates the signature.",
     "",
     "A version-mismatch refusal from haven_sign / haven_sign_x402 / haven_sign_sweep_delegate is",
@@ -1815,7 +2066,13 @@ function signerInstructions() {
     "fallback fields alongside the message, so you can branch on it directly. Every signer",
     "refusal also carries the next-step family: next_tool_name + next_tool_server_role when a",
     "hosted tool follows (resolve the role against your own server names), else",
-    "next_tool_omitted_reason saying why not."
+    "next_tool_omitted_reason saying why not.",
+    "",
+    "An undeclared top-level argument is refused, not stripped: haven_sign answers",
+    "UNSUPPORTED_ARGUMENT with unknown_arguments, signer_version and fallback (the update",
+    "command) instead of dropping the key and answering the generic signing error \u2014 if you see",
+    "that refusal, this signer predates the argument form you sent. Update the signer; nothing",
+    "was signed, fetched or audited."
   ].join("\n");
 }
 async function loadSignerCredentials(path = process.env.HAVEN_CREDENTIALS) {
@@ -1918,8 +2175,6 @@ async function warnIfCredentialFilePermissive(path, log = (message) => process.s
 }
 
 // src/server.ts
-var SIGNER_NAME = "@haven_ai/signer";
-var SIGNER_VERSION = "0.6.0-alpha.0";
 async function resolveSignerRuntime(options = {}) {
   assertSupportedNodeVersion(options.nodeVersion);
   if (options.delegateKey) {
@@ -1970,12 +2225,14 @@ function buildSignerMcpServer(signer, options = {}) {
       clientIdentity: havenClientIdentity(SIGNER_NAME, SIGNER_VERSION)
     }
   });
-  const registerTool = server.tool.bind(server);
+  const registerTool = server.registerTool.bind(server);
   for (const name of Object.keys(toolSchemas)) {
     registerTool(
       name,
-      toolDescriptions[name],
-      toolSchemas[name],
+      {
+        description: toolDescriptions[name],
+        inputSchema: z.object(toolSchemas[name]).passthrough()
+      },
       async (args) => toMcpResult(await handlers[name](args))
     );
   }