plugin-sagg-x402 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SAGG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,195 @@
+# plugin-sagg-x402
+
+An [ElizaOS](https://elizaos.ai/) plugin that pays for SAGG chat-completion requests
+**per-request, via the [x402 protocol](https://x402.org/)** (a signed USDC micropayment)
+instead of an API key. Registers as a `TEXT_LARGE`/`TEXT_SMALL` model handler, so an
+ElizaOS agent can use SAGG as its LLM the same way it would use `@elizaos/plugin-openai`
+or `@elizaos/plugin-anthropic` - except every call is paid for by the agent's own
+funded wallet, with no human provisioning an API key first.
+
+**Status: testnet only (Base Sepolia). Not published to npm or the ElizaOS plugin
+registry - prepared for review, not distributed.**
+
+## Why this exists
+
+ElizaOS agents are unusually well-suited for this: they already carry EVM wallets for
+DeFi/on-chain actions (`@elizaos/plugin-evm` and others), so paying for an LLM call the
+same way is a natural fit rather than a bolted-on feature. ElizaOS has no native x402 /
+decentralized-inference plugin today - the same kind of gap
+[langchain-ai/langchain#36306](https://github.com/langchain-ai/langchain/issues/36306)
+documents for LangChain. This plugin is the ElizaOS counterpart to the sibling
+`langchain-x402-sagg`, `crewai-x402-sagg`, and `sagg-mcp-server` adapters already built
+for the same SAGG x402 endpoint - same protocol, same gateway, this ecosystem's own
+idiom (a `Plugin` object with a `models` map) instead of a `Tool`/MCP server.
+
+## Why pure TypeScript (viem), not a bridge to the existing Go module
+
+SAGG's own x402 client/server code (`x402module/`, now its own repo) is written in Go.
+As with the earlier Python adapters, two approaches were considered: wrapping the Go
+module via a subprocess/bridge, or reimplementing the EIP-712/EIP-3009 signing logic
+natively. EIP-712 and EIP-3009 are open cryptographic standards, not Go-specific -
+[viem](https://viem.sh) is the standard, actively maintained TypeScript implementation,
+and it's already what `@elizaos/plugin-evm` itself is built on. Shipping or requiring a
+platform-specific Go binary alongside an npm package would be real distribution
+friction for no real benefit here - the same reasoning the LangChain adapter's own
+README gives for choosing `eth_account` over a Go bridge in Python. Independently
+verified, not just "no exception thrown": `src/__tests__/signer.test.ts` recovers the
+signer's address from a produced signature via a **separate** call path
+(`viem`'s `recoverTypedDataAddress`, not the package's own signing code), and includes
+a double control that a corrupted signature genuinely fails that recovery.
+
+## Installation
+
+```bash
+npm install
+npm run build
+```
+
+Not published - install from this local checkout, and reference it by local path from
+an ElizaOS project's `character.ts`:
+
+```ts
+plugins: [
+  '@elizaos/plugin-sql',
+  '../plugin-sagg-x402',
+]
+```
+
+## Configuration
+
+All read via `runtime.getSetting()` (character `settings` or environment variables):
+
+| Setting | Default | Meaning |
+|---|---|---|
+| `SAGG_X402_URL` | required | Base URL of the SAGG gateway (no trailing `/v1/...`). |
+| `SAGG_X402_PRIVATE_KEY` | none | Dedicated hex EVM private key for x402 payments. **Recommended over `EVM_PRIVATE_KEY`** - see Security below. |
+| `EVM_PRIVATE_KEY` | none | Fallback: the same key `@elizaos/plugin-evm` already reads. Used only if `SAGG_X402_PRIVATE_KEY` is unset. |
+| `SAGG_X402_MODEL` | `deepseek-ai/DeepSeek-V4-Flash-0731` | Model id to request. |
+| `SAGG_X402_MAX_AMOUNT_ATOMIC` | `1000000` (1.00 USDC) | Hard per-call payment ceiling, in USDC's smallest unit (6 decimals). A 402 challenge asking for more is refused **before any signature is produced**. |
+| `SAGG_X402_NETWORK` | `base-sepolia` | Only network this plugin has been tested against. `base` (mainnet) is accepted by the code but untested and out of scope - see Security. |
+
+One of `SAGG_X402_PRIVATE_KEY` or `EVM_PRIVATE_KEY` is required; a missing/misconfigured
+key surfaces as a clear error on the first `useModel` call routed here (not at plugin
+load time - see `model.ts`'s own comment on why).
+
+## How it works
+
+Registers the same handler function for both `ModelType.TEXT_LARGE` and
+`ModelType.TEXT_SMALL` (SAGG's gateway already does provider tiering/failover
+server-side - this plugin doesn't reimplement a large/small distinction of its own; see
+"What this plugin does NOT do"). On each `useModel` call:
+
+1. POST the composed prompt/messages to `{SAGG_X402_URL}/v1/chat/completions`.
+2. If the response is `402 Payment Required`, parse the price from the challenge
+   (`accepts[0]`).
+3. Refuse if the price exceeds `SAGG_X402_MAX_AMOUNT_ATOMIC`.
+4. Sign a fresh EIP-3009 `TransferWithAuthorization` for the exact amount, to the exact
+   recipient, with a fresh random nonce (never reused - see `signer.ts`'s own comment on
+   why that's the actual replay-protection mechanism).
+5. Repost with an `X-PAYMENT` header carrying the signed payload.
+6. Return the model's response text.
+
+## A real finding from live-testing, not assumed from the spec
+
+The generic x402 spec's `X-PAYMENT-RESPONSE` header (what `x402-go`'s own stock
+middleware sets, and what the sibling Go/Python clients' `GetSettlement`/
+`get_settlement` look for) is **never sent** by SAGG's actual `/v1/chat/completions`
+x402 path - confirmed by inspecting real response headers from a live gateway
+instance, not by reading the handler source alone. SAGG's `x402ChatCompletionsHandler`
+is built on `DynamicServer` (needed for per-request dynamic pricing - x402-go's stock
+middleware only supports one fixed price set at startup) and sets its own plain
+headers instead: `X-SAGG-X402-Ceiling-Tx` (always present on a served response) and
+`X-SAGG-X402-Refund-Tx` (present only when a refund was actually sent). This plugin's
+`SaggX402Client.getSettlement()` reads the real headers; worth fixing in the sibling
+Python adapters too, but out of this plugin's own scope.
+
+Also corrected here: the sibling LangChain/CrewAI adapters default to the model id
+`deepseek-v4-flash-0731`. The real, documented full-form id is
+`deepseek-ai/DeepSeek-V4-Flash-0731` (PROJECT_STATE.md sec 3.164) - the short form is
+exactly the class of bug that section found and fixed elsewhere (it breaks model-name
+translation for the `eterial-deepseek`/`gonka24-deepseek` fallback tiers specifically).
+This plugin defaults to the correct full form; worth fixing upstream in the sibling
+adapters too.
+
+## Testing
+
+```bash
+npm test          # fast, no network - signing/recovery logic + a mocked-fetch payment flow
+npm run test:live # opt-in, moves real (testnet) funds - needs a reachable SAGG endpoint
+```
+
+```bash
+SAGG_X402_TEST_PRIVATE_KEY=0x... \
+SAGG_X402_TEST_URL=http://localhost:8080 \
+RUN_LIVE_X402_TEST=1 \
+npm run test:live
+```
+
+**This was run for real** against a locally-running SAGG gateway built from
+`feat/x402-billing-integration` (Base Sepolia, real `x402.org/facilitator`, real
+on-chain settlement) during this plugin's own development - 5 consecutive real payment
+cycles across both the raw client and the actual registered `handleGenerateText` model
+handler, each ceiling transaction independently confirmed via a raw
+`eth_getTransactionReceipt` RPC call (not trusted from the gateway's own response
+alone) - e.g. `0xcd8df9355f0a86758c1b228607856700e8e47d39cbccab61063c2a0b46e59f27`,
+`status: 0x1`, a real USDC `Transfer` event for exactly 326 atomic units
+(0.000326 USDC) from the test wallet to SAGG's configured `payTo` address. Every real
+completion came back as genuine model output (e.g. a literal `"pong"` for a
+`"reply with exactly one word: pong"` prompt), not a canned/mocked value.
+
+**One real limitation, disclosed rather than worked around**: this development session's
+server-side test wallet held testnet USDC but no testnet ETH, so every refund attempt
+(the ceiling always includes a safety margin above the real cost, so a small refund is
+normal) failed with `insufficient funds for gas` and was logged - but the request was
+still served successfully to the client either way, since SAGG's own handler treats a
+refund failure as a bookkeeping gap, never a reason to fail an already-paid request (see
+`cmd/gateway/x402billing.go`). The **payment-and-serve path this plugin actually
+depends on was fully live-verified**; the refund leg specifically was not, for lack of
+testnet ETH on the server wallet used this session - a future run with a
+gas-funded server wallet would additionally confirm `X-SAGG-X402-Refund-Tx` end to end.
+Separately: this run surfaced a real, pre-existing minor bug in SAGG's own gateway - a
+refund failure for ANY reason (including plain insufficient gas, as hit here) is logged
+as `"actual cost exceeded ceiling - refund refused per metering's own invariant"`,
+which is only actually true for one specific failure cause, not this one. Flagged for
+SAGG's own maintainers; not fixed here, out of this plugin's scope.
+
+## Security
+
+- **Testnet only.** Tested exclusively against Base Sepolia. Do not put a
+  mainnet-funded private key in `SAGG_X402_PRIVATE_KEY`/`EVM_PRIVATE_KEY` - nothing in
+  this plugin's code prevents it, but no part of it has been reviewed or tested for
+  mainnet use.
+- **Use a dedicated key, not the agent's main wallet, if you can.** `EVM_PRIVATE_KEY`
+  (the same key `plugin-evm` uses for DeFi actions) works as a fallback for
+  convenience, but a compromised or over-eager LLM-payment path then has access to
+  every other fund that wallet holds. `SAGG_X402_PRIVATE_KEY` lets you isolate this
+  plugin's spending to a wallet that holds only what you're willing to lose - the same
+  principle the sibling Python adapters' own README states.
+- **The private key is held in plain process memory** for the agent's lifetime - the
+  same custody model SAGG's own Go server wallet uses today (see the main
+  `sagg-project` repo's Stage 3 security audit, `PROJECT_STATE.md` sec 3.147).
+- `SAGG_X402_MAX_AMOUNT_ATOMIC` is a real, enforced ceiling checked before any
+  signature is produced, but it's a courtesy limit on THIS client's own behavior - it
+  does not protect against a malicious or compromised server issuing a valid-looking
+  but overpriced challenge below that ceiling. Set it to the smallest value your actual
+  use case needs.
+- **Signing refuses on a network mismatch, before any signature is produced.** Added
+  after a real failure in the sibling `langchain-x402-sagg` package's first mainnet
+  attempt: a client configured for one network but pointed at a server actually
+  issuing a challenge for a different one would otherwise sign with the wrong chain id
+  - a well-formed but cryptographically wrong signature the facilitator correctly
+  rejects, with no clue in the error as to why. `postWithPayment` now checks the
+  challenge's own `network` field against `SAGG_X402_NETWORK` and throws
+  `SaggX402PaymentError` immediately on any mismatch instead.
+
+## What this plugin does NOT do
+
+- Publish itself anywhere (no npm, no ElizaOS plugin registry) - prepared for review
+  only, per its own scope.
+- Distinguish `TEXT_LARGE` from `TEXT_SMALL` - both call the same configured SAGG model;
+  SAGG's own gateway already handles provider tiering server-side.
+- Support streaming responses, `TEXT_EMBEDDING`, or any ModelType beyond text
+  generation.
+- Implement provider failover/retries beyond what SAGG's own gateway already does -
+  this is a minimal, first-version client.
+- Touch mainnet, create a real wallet, or move real money in any way.

package/dist/index.d.ts

@@ -0,0 +1,211 @@
+import { IAgentRuntime, Plugin } from '@elizaos/core';
+import { Hex } from 'viem';
+
+/**
+ * The actual SAGG-backed TEXT_LARGE/TEXT_SMALL model handler. SAGG's own
+ * gateway already does provider tiering/failover server-side (Standard
+ * vs Super Deal lines - see the main sagg-project repo) - this plugin
+ * deliberately does not reimplement a large/small model distinction of
+ * its own; both ModelType.TEXT_LARGE and ModelType.TEXT_SMALL are wired
+ * to the SAME handler and the same configured model id (see README's
+ * "What this plugin does NOT do" for this and other scope calls).
+ */
+
+interface GenerateTextParamsLike {
+    prompt?: string;
+    system?: string;
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    maxTokens?: number;
+    temperature?: number;
+    stopSequences?: string[];
+}
+/** The handler wired to ModelType.TEXT_LARGE/TEXT_SMALL in index.ts.
+ * Pays via x402 on every call - SAGG's x402 path is a genuinely separate
+ * accounting mechanism from its API-key/Stripe path (no quota, no
+ * subscription), so there is no "free" request to fall back to if a
+ * payment fails; a payment/HTTP error here is a real, user-visible
+ * failure, not something to swallow. */
+declare function handleGenerateText(runtime: IAgentRuntime, params: GenerateTextParamsLike): Promise<string>;
+
+/**
+ * HTTP client implementing the client side of the x402 "exact" scheme:
+ * probe -> 402 challenge -> sign -> pay -> response. Mirrors
+ * x402module/poc/pkg/x402protocol/dynamicclient.go's own two-request
+ * design (a fresh, unpaid probe carrying the real body, then a SEPARATE
+ * paid retry with its own fresh body) and the sibling Python adapters'
+ * client.py (langchain-x402-sagg, crewai-x402-sagg) field-for-field.
+ * Node's global `fetch` builds a brand-new request body from the object
+ * passed to it on each call, so - like the Python adapters using
+ * `requests` - there is no equivalent of the mark3labs/x402-go
+ * single-consumed-body bug this project found and worked around in Go
+ * (PROJECT_STATE.md sec 3.145); noted for comparison, not because a
+ * workaround was needed here.
+ */
+
+declare class SaggX402PaymentError extends Error {
+}
+/** Shaped around what SAGG's own x402 handler actually reports, not the
+ * generic x402 spec's success/errorReason/transaction Settlement shape
+ * (see getSettlement's own doc comment for why those two differ). */
+interface Settlement {
+    ceilingTx: string;
+    refundTx: string | null;
+}
+interface SaggX402ClientOptions {
+    privateKey: Hex;
+    maxAmountAtomic: bigint;
+    network?: string;
+    timeoutMs?: number;
+}
+/** Pays for x402-gated SAGG requests using an EVM private key, enforcing
+ * a hard per-call maximum (maxAmountAtomic) independent of whatever a
+ * server's own requirement asks for - the same "never auto-pay more
+ * than this" discipline as the Go module's WalletSigner and both Python
+ * adapters. */
+declare class SaggX402Client {
+    private readonly privateKey;
+    private readonly maxAmountAtomic;
+    private readonly network;
+    private readonly chainId;
+    private readonly timeoutMs;
+    constructor(options: SaggX402ClientOptions);
+    /** POSTs jsonBody to url. If the first response is a real x402 402
+     * challenge, signs the first accepted requirement (refusing if it
+     * exceeds maxAmountAtomic) and reposts a FRESH request with the
+     * resulting X-PAYMENT header. Any other first response (2xx, or a
+     * non-402 error) is returned as-is, unpaid. */
+    postWithPayment(url: string, jsonBody: Record<string, unknown>): Promise<Response>;
+    /** Extracts settlement info from SAGG's OWN response headers.
+     *
+     * A real, live-testing-only finding, not something assumed from the
+     * spec or copied from the sibling adapters: the generic x402 spec's
+     * `X-PAYMENT-RESPONSE` header (base64 JSON, what x402-go's OWN stock
+     * middleware sets, and what x402protocol.GetSettlement (client.go)
+     * and the sibling LangChain/CrewAI adapters' get_settlement look for)
+     * is NEVER set by SAGG's actual `/v1/chat/completions` x402 path -
+     * confirmed by inspecting real response headers from a live local
+     * gateway instance, not by reading the handler source alone. SAGG's
+     * x402ChatCompletionsHandler (x402billing.go) is built directly on
+     * DynamicServer (needed for per-request dynamic pricing - x402-go's
+     * own stock middleware only supports one fixed price set at startup),
+     * and sets its OWN plain headers instead:
+     * `X-SAGG-X402-Ceiling-Tx` (always present on a served response) and
+     * `X-SAGG-X402-Refund-Tx` (present only when a refund was actually
+     * sent - absent, not empty, when the refund amount was zero OR when
+     * sending it failed, e.g. the server wallet lacking gas - see this
+     * plugin's README for what that means for a real refund's
+     * observability from the client side). No `success`/`errorReason`
+     * fields exist in this scheme at all - a served 200 response with a
+     * ceiling-tx header IS the success signal. */
+    static getSettlement(response: Response): Settlement | null;
+    private postJson;
+}
+
+/**
+ * EIP-3009 (transferWithAuthorization) signing for the x402 "exact"
+ * payment scheme, via viem's own EIP-712 typed-data support.
+ *
+ * Mirrors the EXACT typed-data shape SAGG's Go gateway builds
+ * (x402module/poc/pkg/x402protocol/signer_adapter.go, WalletSigner.Sign)
+ * and this project's own Python adapters (langchain-x402-sagg/signer.py,
+ * crewai-x402-sagg) - same field names, same types, same domain
+ * structure - so a signature produced here is verified identically by
+ * the same facilitator/on-chain contract, regardless of which language
+ * signed it. EIP-712/EIP-3009 are open cryptographic standards, not
+ * anything Go- or Python-specific; viem is the standard, widely-used
+ * TypeScript implementation (the same library @elizaos/plugin-evm
+ * itself is built on) - this mirrors the earlier adapters' own choice
+ * of the host ecosystem's standard web3 library over a cross-language
+ * bridge to the Go module.
+ *
+ * One real difference from the Go/Python versions, not a bug: viem's
+ * signTypedData derives the "EIP712Domain" type entry itself from the
+ * `domain` object - it must NOT be listed again in `types` (unlike
+ * go-ethereum's apitypes.TypedData and eth_account's
+ * encode_typed_data/sign_typed_data, which both require it spelled out
+ * explicitly). Verified against viem's own docs before writing this.
+ */
+
+interface SignedAuthorization {
+    signature: Hex;
+    fromAddress: Hex;
+    toAddress: Hex;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+    nonce: Hex;
+}
+interface TransferAuthorizationTypedData {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: Hex;
+    };
+    types: {
+        TransferWithAuthorization: [
+            {
+                name: "from";
+                type: "address";
+            },
+            {
+                name: "to";
+                type: "address";
+            },
+            {
+                name: "value";
+                type: "uint256";
+            },
+            {
+                name: "validAfter";
+                type: "uint256";
+            },
+            {
+                name: "validBefore";
+                type: "uint256";
+            },
+            {
+                name: "nonce";
+                type: "bytes32";
+            }
+        ];
+    };
+    primaryType: "TransferWithAuthorization";
+    message: {
+        from: Hex;
+        to: Hex;
+        value: bigint;
+        validAfter: bigint;
+        validBefore: bigint;
+        nonce: Hex;
+    };
+}
+/** Builds the EIP-712 typed-data object for a TransferWithAuthorization -
+ * field-for-field identical to what SAGG's own Go signer and the sibling
+ * Python adapters build, minus the EIP712Domain entry viem derives on
+ * its own (see this file's own top comment). Exported separately from
+ * signTransferAuthorization so tests can independently re-derive the
+ * same digest viem signs, the same "recover the signer independently"
+ * discipline this whole project's own test suites already use. */
+declare function buildTypedData(domainName: string, domainVersion: string, chainId: number, tokenAddress: Hex, fromAddress: Hex, toAddress: Hex, value: bigint, validAfter: bigint, validBefore: bigint, nonce: Hex): TransferAuthorizationTypedData;
+/** Signs a fresh EIP-3009 authorization for exactly `value` atomic units
+ * of tokenAddress, payable to toAddress, valid from ~now until
+ * validTimeoutSeconds from now (mirrors the Go/Python signers' own
+ * 10-second clock-drift tolerance on validAfter). */
+declare function signTransferAuthorization(privateKey: Hex, domainName: string, domainVersion: string, chainId: number, tokenAddress: Hex, toAddress: Hex, value: bigint, validTimeoutSeconds: number): Promise<SignedAuthorization>;
+
+/**
+ * plugin-sagg-x402 - pays for SAGG (https://api.privatedeskai.com) LLM
+ * chat-completion requests per-request via the x402 protocol (a signed
+ * USDC micropayment) instead of an API key, registered as an ElizaOS
+ * model handler for ModelType.TEXT_LARGE/TEXT_SMALL. See README.md for
+ * why this exists and how it fits alongside the sibling LangChain/
+ * CrewAI/MCP adapters built for the same SAGG x402 endpoint.
+ */
+
+declare const saggX402Plugin: Plugin;
+
+export { SaggX402Client, SaggX402PaymentError, buildTypedData, saggX402Plugin as default, handleGenerateText, saggX402Plugin, signTransferAuthorization };

package/dist/index.js

@@ -0,0 +1,349 @@
+// src/index.ts
+import { logger, ModelType } from "@elizaos/core";
+
+// src/signer.ts
+import { privateKeyToAccount } from "viem/accounts";
+function randomNonceHex() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return "0x" + Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function buildTypedData(domainName, domainVersion, chainId, tokenAddress, fromAddress, toAddress, value, validAfter, validBefore, nonce) {
+  return {
+    domain: {
+      name: domainName,
+      version: domainVersion,
+      chainId,
+      verifyingContract: tokenAddress
+    },
+    types: {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    },
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: fromAddress,
+      to: toAddress,
+      value,
+      validAfter,
+      validBefore,
+      nonce
+    }
+  };
+}
+async function signTransferAuthorization(privateKey, domainName, domainVersion, chainId, tokenAddress, toAddress, value, validTimeoutSeconds) {
+  const account = privateKeyToAccount(privateKey);
+  const now = BigInt(Math.floor(Date.now() / 1e3));
+  const validAfter = now - 10n;
+  const validBefore = now + BigInt(validTimeoutSeconds);
+  const nonce = randomNonceHex();
+  const typedData = buildTypedData(
+    domainName,
+    domainVersion,
+    chainId,
+    tokenAddress,
+    account.address,
+    toAddress,
+    value,
+    validAfter,
+    validBefore,
+    nonce
+  );
+  const signature = await account.signTypedData(typedData);
+  return {
+    signature,
+    fromAddress: account.address,
+    toAddress,
+    value: value.toString(),
+    validAfter: validAfter.toString(),
+    validBefore: validBefore.toString(),
+    nonce
+  };
+}
+
+// src/client.ts
+var CHAIN_IDS = {
+  base: 8453,
+  "base-sepolia": 84532
+};
+var SaggX402PaymentError = class extends Error {
+};
+var SaggX402Client = class {
+  privateKey;
+  maxAmountAtomic;
+  network;
+  chainId;
+  timeoutMs;
+  constructor(options) {
+    const network = options.network ?? "base-sepolia";
+    const chainId = CHAIN_IDS[network];
+    if (chainId === void 0) {
+      throw new Error(
+        `unsupported network ${JSON.stringify(network)}, want one of ${Object.keys(CHAIN_IDS).join(", ")}`
+      );
+    }
+    this.privateKey = options.privateKey;
+    this.maxAmountAtomic = options.maxAmountAtomic;
+    this.network = network;
+    this.chainId = chainId;
+    this.timeoutMs = options.timeoutMs ?? 6e4;
+  }
+  /** POSTs jsonBody to url. If the first response is a real x402 402
+   * challenge, signs the first accepted requirement (refusing if it
+   * exceeds maxAmountAtomic) and reposts a FRESH request with the
+   * resulting X-PAYMENT header. Any other first response (2xx, or a
+   * non-402 error) is returned as-is, unpaid. */
+  async postWithPayment(url, jsonBody) {
+    const probe = await this.postJson(url, jsonBody);
+    if (probe.status !== 402) {
+      return probe;
+    }
+    const challenge = await probe.json();
+    const accepts = challenge.accepts ?? [];
+    if (accepts.length === 0) {
+      throw new SaggX402PaymentError(
+        "402 challenge carried no accepted payment methods"
+      );
+    }
+    const requirement = accepts[0];
+    const amount = BigInt(requirement.maxAmountRequired);
+    if (amount > this.maxAmountAtomic) {
+      throw new SaggX402PaymentError(
+        `requirement asks for ${amount} atomic units, exceeds this client's configured max ${this.maxAmountAtomic}`
+      );
+    }
+    const extra = requirement.extra ?? {};
+    if (!extra.name || !extra.version) {
+      throw new SaggX402PaymentError(
+        "requirement missing EIP-3009 domain name/version in its 'extra' field"
+      );
+    }
+    if (requirement.network !== this.network) {
+      throw new SaggX402PaymentError(
+        `requirement's network ${JSON.stringify(requirement.network)} does not match this client's configured network ${JSON.stringify(this.network)} - refusing to sign. This client was likely constructed with the wrong \`network\` option for the URL it's actually talking to.`
+      );
+    }
+    const signed = await signTransferAuthorization(
+      this.privateKey,
+      extra.name,
+      extra.version,
+      this.chainId,
+      requirement.asset,
+      requirement.payTo,
+      amount,
+      requirement.maxTimeoutSeconds ?? 60
+    );
+    const paymentPayload = {
+      x402Version: 1,
+      scheme: "exact",
+      network: requirement.network,
+      payload: {
+        signature: signed.signature,
+        authorization: {
+          from: signed.fromAddress,
+          to: signed.toAddress,
+          value: signed.value,
+          validAfter: signed.validAfter,
+          validBefore: signed.validBefore,
+          nonce: signed.nonce
+        }
+      }
+    };
+    const headerValue = Buffer.from(JSON.stringify(paymentPayload)).toString(
+      "base64"
+    );
+    return this.postJson(url, jsonBody, { "X-PAYMENT": headerValue });
+  }
+  /** Extracts settlement info from SAGG's OWN response headers.
+   *
+   * A real, live-testing-only finding, not something assumed from the
+   * spec or copied from the sibling adapters: the generic x402 spec's
+   * `X-PAYMENT-RESPONSE` header (base64 JSON, what x402-go's OWN stock
+   * middleware sets, and what x402protocol.GetSettlement (client.go)
+   * and the sibling LangChain/CrewAI adapters' get_settlement look for)
+   * is NEVER set by SAGG's actual `/v1/chat/completions` x402 path -
+   * confirmed by inspecting real response headers from a live local
+   * gateway instance, not by reading the handler source alone. SAGG's
+   * x402ChatCompletionsHandler (x402billing.go) is built directly on
+   * DynamicServer (needed for per-request dynamic pricing - x402-go's
+   * own stock middleware only supports one fixed price set at startup),
+   * and sets its OWN plain headers instead:
+   * `X-SAGG-X402-Ceiling-Tx` (always present on a served response) and
+   * `X-SAGG-X402-Refund-Tx` (present only when a refund was actually
+   * sent - absent, not empty, when the refund amount was zero OR when
+   * sending it failed, e.g. the server wallet lacking gas - see this
+   * plugin's README for what that means for a real refund's
+   * observability from the client side). No `success`/`errorReason`
+   * fields exist in this scheme at all - a served 200 response with a
+   * ceiling-tx header IS the success signal. */
+  static getSettlement(response) {
+    const ceilingTx = response.headers.get("X-SAGG-X402-Ceiling-Tx");
+    if (!ceilingTx) {
+      return null;
+    }
+    return {
+      ceilingTx,
+      refundTx: response.headers.get("X-SAGG-X402-Refund-Tx")
+    };
+  }
+  async postJson(url, jsonBody, extraHeaders) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...extraHeaders },
+        body: JSON.stringify(jsonBody),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/model.ts
+var DEFAULT_MODEL = "deepseek-ai/DeepSeek-V4-Flash-0731";
+var DEFAULT_MAX_AMOUNT_ATOMIC = 1000000n;
+var DEFAULT_NETWORK = "base-sepolia";
+var cachedClient = null;
+var cachedClientKey = null;
+function requireSetting(runtime, key) {
+  const value = runtime.getSetting(key);
+  if (value === null || value === void 0 || value === "") {
+    throw new Error(
+      `plugin-sagg-x402: required setting ${key} is not configured`
+    );
+  }
+  return String(value);
+}
+function optionalSetting(runtime, key) {
+  const value = runtime.getSetting(key);
+  if (value === null || value === void 0 || value === "") {
+    return null;
+  }
+  return String(value);
+}
+function resolvePrivateKey(runtime) {
+  const dedicated = optionalSetting(runtime, "SAGG_X402_PRIVATE_KEY");
+  const fallback = dedicated ?? optionalSetting(runtime, "EVM_PRIVATE_KEY");
+  if (!fallback) {
+    throw new Error(
+      "plugin-sagg-x402: neither SAGG_X402_PRIVATE_KEY nor EVM_PRIVATE_KEY is configured"
+    );
+  }
+  return fallback.startsWith("0x") ? fallback : `0x${fallback}`;
+}
+function getClient(runtime) {
+  const privateKey = resolvePrivateKey(runtime);
+  const network = optionalSetting(runtime, "SAGG_X402_NETWORK") ?? DEFAULT_NETWORK;
+  const maxAmountSetting = optionalSetting(
+    runtime,
+    "SAGG_X402_MAX_AMOUNT_ATOMIC"
+  );
+  const maxAmountAtomic = maxAmountSetting ? BigInt(maxAmountSetting) : DEFAULT_MAX_AMOUNT_ATOMIC;
+  const cacheKey = `${privateKey}:${network}:${maxAmountAtomic}`;
+  if (cachedClient && cachedClientKey === cacheKey) {
+    return cachedClient;
+  }
+  cachedClient = new SaggX402Client({ privateKey, network, maxAmountAtomic });
+  cachedClientKey = cacheKey;
+  return cachedClient;
+}
+function buildMessages(params) {
+  const messages = [];
+  if (params.system) {
+    messages.push({ role: "system", content: params.system });
+  }
+  if (params.messages && params.messages.length > 0) {
+    for (const m of params.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    return messages;
+  }
+  if (params.prompt) {
+    messages.push({ role: "user", content: params.prompt });
+    return messages;
+  }
+  throw new Error(
+    "plugin-sagg-x402: GenerateTextParams carried neither `messages` nor `prompt`"
+  );
+}
+async function handleGenerateText(runtime, params) {
+  const saggUrl = requireSetting(runtime, "SAGG_X402_URL").replace(/\/+$/, "");
+  const model = optionalSetting(runtime, "SAGG_X402_MODEL") ?? DEFAULT_MODEL;
+  const client = getClient(runtime);
+  const body = {
+    model,
+    messages: buildMessages(params)
+  };
+  if (params.maxTokens !== void 0) body.max_tokens = params.maxTokens;
+  if (params.temperature !== void 0) body.temperature = params.temperature;
+  if (params.stopSequences && params.stopSequences.length > 0) {
+    body.stop = params.stopSequences;
+  }
+  let response;
+  try {
+    response = await client.postWithPayment(
+      `${saggUrl}/v1/chat/completions`,
+      body
+    );
+  } catch (err) {
+    if (err instanceof SaggX402PaymentError) {
+      throw new Error(`plugin-sagg-x402: payment refused: ${err.message}`);
+    }
+    throw err;
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(
+      `plugin-sagg-x402: SAGG request failed (${response.status}): ${text}`
+    );
+  }
+  const data = await response.json();
+  const content = data.choices?.[0]?.message?.content;
+  if (typeof content !== "string") {
+    throw new Error(
+      "plugin-sagg-x402: SAGG response had no choices[0].message.content"
+    );
+  }
+  return content;
+}
+
+// src/index.ts
+var saggX402Plugin = {
+  name: "sagg-x402",
+  description: "Pays for SAGG LLM completions per-request via the x402 protocol (signed USDC micropayment, no API key). Testnet (Base Sepolia) only as shipped.",
+  async init(_config, runtime) {
+    const hasUrl = Boolean(runtime.getSetting("SAGG_X402_URL"));
+    const hasKey = Boolean(runtime.getSetting("SAGG_X402_PRIVATE_KEY")) || Boolean(runtime.getSetting("EVM_PRIVATE_KEY"));
+    if (!hasUrl || !hasKey) {
+      logger.warn(
+        "plugin-sagg-x402: SAGG_X402_URL and/or a private key (SAGG_X402_PRIVATE_KEY or EVM_PRIVATE_KEY) are not configured - TEXT_LARGE/TEXT_SMALL calls routed to this plugin will fail."
+      );
+    }
+  },
+  models: {
+    [ModelType.TEXT_LARGE]: handleGenerateText,
+    [ModelType.TEXT_SMALL]: handleGenerateText
+  }
+};
+var index_default = saggX402Plugin;
+export {
+  SaggX402Client,
+  SaggX402PaymentError,
+  buildTypedData,
+  index_default as default,
+  handleGenerateText,
+  saggX402Plugin,
+  signTransferAuthorization
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/signer.ts","../src/client.ts","../src/model.ts"],"sourcesContent":["/**\n * plugin-sagg-x402 - pays for SAGG (https://api.privatedeskai.com) LLM\n * chat-completion requests per-request via the x402 protocol (a signed\n * USDC micropayment) instead of an API key, registered as an ElizaOS\n * model handler for ModelType.TEXT_LARGE/TEXT_SMALL. See README.md for\n * why this exists and how it fits alongside the sibling LangChain/\n * CrewAI/MCP adapters built for the same SAGG x402 endpoint.\n */\n\nimport type { IAgentRuntime, Plugin } from \"@elizaos/core\";\nimport { logger, ModelType } from \"@elizaos/core\";\nimport { handleGenerateText } from \"./model.js\";\n\nexport const saggX402Plugin: Plugin = {\n  name: \"sagg-x402\",\n  description:\n    \"Pays for SAGG LLM completions per-request via the x402 protocol (signed USDC micropayment, no API key). Testnet (Base Sepolia) only as shipped.\",\n\n  async init(_config: Record<string, string>, runtime: IAgentRuntime) {\n    // Deliberately does NOT validate/throw here - see model.ts's own\n    // comment on why a missing/bad private key surfaces at first real\n    // call instead of at plugin load time. This only logs a clear,\n    // early warning so a misconfiguration is visible in the agent's\n    // own startup logs rather than a silent surprise on first use.\n    const hasUrl = Boolean(runtime.getSetting(\"SAGG_X402_URL\"));\n    const hasKey =\n      Boolean(runtime.getSetting(\"SAGG_X402_PRIVATE_KEY\")) ||\n      Boolean(runtime.getSetting(\"EVM_PRIVATE_KEY\"));\n    if (!hasUrl || !hasKey) {\n      logger.warn(\n        \"plugin-sagg-x402: SAGG_X402_URL and/or a private key \" +\n          \"(SAGG_X402_PRIVATE_KEY or EVM_PRIVATE_KEY) are not configured - \" +\n          \"TEXT_LARGE/TEXT_SMALL calls routed to this plugin will fail.\",\n      );\n    }\n  },\n\n  models: {\n    [ModelType.TEXT_LARGE]: handleGenerateText,\n    [ModelType.TEXT_SMALL]: handleGenerateText,\n  },\n};\n\nexport default saggX402Plugin;\nexport { handleGenerateText } from \"./model.js\";\nexport { SaggX402Client, SaggX402PaymentError } from \"./client.js\";\nexport { signTransferAuthorization, buildTypedData } from \"./signer.js\";\n","/**\n * EIP-3009 (transferWithAuthorization) signing for the x402 \"exact\"\n * payment scheme, via viem's own EIP-712 typed-data support.\n *\n * Mirrors the EXACT typed-data shape SAGG's Go gateway builds\n * (x402module/poc/pkg/x402protocol/signer_adapter.go, WalletSigner.Sign)\n * and this project's own Python adapters (langchain-x402-sagg/signer.py,\n * crewai-x402-sagg) - same field names, same types, same domain\n * structure - so a signature produced here is verified identically by\n * the same facilitator/on-chain contract, regardless of which language\n * signed it. EIP-712/EIP-3009 are open cryptographic standards, not\n * anything Go- or Python-specific; viem is the standard, widely-used\n * TypeScript implementation (the same library @elizaos/plugin-evm\n * itself is built on) - this mirrors the earlier adapters' own choice\n * of the host ecosystem's standard web3 library over a cross-language\n * bridge to the Go module.\n *\n * One real difference from the Go/Python versions, not a bug: viem's\n * signTypedData derives the \"EIP712Domain\" type entry itself from the\n * `domain` object - it must NOT be listed again in `types` (unlike\n * go-ethereum's apitypes.TypedData and eth_account's\n * encode_typed_data/sign_typed_data, which both require it spelled out\n * explicitly). Verified against viem's own docs before writing this.\n */\n\nimport { privateKeyToAccount, type PrivateKeyAccount } from \"viem/accounts\";\nimport type { Hex } from \"viem\";\n\nexport interface SignedAuthorization {\n  signature: Hex;\n  fromAddress: Hex;\n  toAddress: Hex;\n  value: string;\n  validAfter: string;\n  validBefore: string;\n  nonce: Hex;\n}\n\n/** A fresh, cryptographically random 32-byte EIP-3009 nonce - a new one\n * MUST be generated per authorization; reusing one with the same signer\n * produces a signature the on-chain contract rejects as already-used on\n * the second attempt (PROJECT_STATE.md's x402 Stage 3 audit, sec 3.147,\n * item 1 - EIP-3009's own nonce tracking is the real replay protection\n * here, not anything this client does). Uses the Web Crypto API\n * (globalThis.crypto), available in both Node 19+ and browsers - no\n * separate crypto import needed. */\nexport function randomNonceHex(): Hex {\n  const bytes = new Uint8Array(32);\n  globalThis.crypto.getRandomValues(bytes);\n  return (\"0x\" +\n    Array.from(bytes, (b) => b.toString(16).padStart(2, \"0\")).join(\n      \"\",\n    )) as Hex;\n}\n\ninterface TransferAuthorizationTypedData {\n  domain: {\n    name: string;\n    version: string;\n    chainId: number;\n    verifyingContract: Hex;\n  };\n  types: {\n    TransferWithAuthorization: [\n      { name: \"from\"; type: \"address\" },\n      { name: \"to\"; type: \"address\" },\n      { name: \"value\"; type: \"uint256\" },\n      { name: \"validAfter\"; type: \"uint256\" },\n      { name: \"validBefore\"; type: \"uint256\" },\n      { name: \"nonce\"; type: \"bytes32\" },\n    ];\n  };\n  primaryType: \"TransferWithAuthorization\";\n  message: {\n    from: Hex;\n    to: Hex;\n    value: bigint;\n    validAfter: bigint;\n    validBefore: bigint;\n    nonce: Hex;\n  };\n}\n\n/** Builds the EIP-712 typed-data object for a TransferWithAuthorization -\n * field-for-field identical to what SAGG's own Go signer and the sibling\n * Python adapters build, minus the EIP712Domain entry viem derives on\n * its own (see this file's own top comment). Exported separately from\n * signTransferAuthorization so tests can independently re-derive the\n * same digest viem signs, the same \"recover the signer independently\"\n * discipline this whole project's own test suites already use. */\nexport function buildTypedData(\n  domainName: string,\n  domainVersion: string,\n  chainId: number,\n  tokenAddress: Hex,\n  fromAddress: Hex,\n  toAddress: Hex,\n  value: bigint,\n  validAfter: bigint,\n  validBefore: bigint,\n  nonce: Hex,\n): TransferAuthorizationTypedData {\n  return {\n    domain: {\n      name: domainName,\n      version: domainVersion,\n      chainId,\n      verifyingContract: tokenAddress,\n    },\n    types: {\n      TransferWithAuthorization: [\n        { name: \"from\", type: \"address\" },\n        { name: \"to\", type: \"address\" },\n        { name: \"value\", type: \"uint256\" },\n        { name: \"validAfter\", type: \"uint256\" },\n        { name: \"validBefore\", type: \"uint256\" },\n        { name: \"nonce\", type: \"bytes32\" },\n      ],\n    },\n    primaryType: \"TransferWithAuthorization\",\n    message: {\n      from: fromAddress,\n      to: toAddress,\n      value,\n      validAfter,\n      validBefore,\n      nonce,\n    },\n  };\n}\n\n/** Signs a fresh EIP-3009 authorization for exactly `value` atomic units\n * of tokenAddress, payable to toAddress, valid from ~now until\n * validTimeoutSeconds from now (mirrors the Go/Python signers' own\n * 10-second clock-drift tolerance on validAfter). */\nexport async function signTransferAuthorization(\n  privateKey: Hex,\n  domainName: string,\n  domainVersion: string,\n  chainId: number,\n  tokenAddress: Hex,\n  toAddress: Hex,\n  value: bigint,\n  validTimeoutSeconds: number,\n): Promise<SignedAuthorization> {\n  const account: PrivateKeyAccount = privateKeyToAccount(privateKey);\n  const now = BigInt(Math.floor(Date.now() / 1000));\n  const validAfter = now - 10n;\n  const validBefore = now + BigInt(validTimeoutSeconds);\n  const nonce = randomNonceHex();\n\n  const typedData = buildTypedData(\n    domainName,\n    domainVersion,\n    chainId,\n    tokenAddress,\n    account.address,\n    toAddress,\n    value,\n    validAfter,\n    validBefore,\n    nonce,\n  );\n\n  const signature = await account.signTypedData(typedData);\n\n  return {\n    signature,\n    fromAddress: account.address,\n    toAddress,\n    value: value.toString(),\n    validAfter: validAfter.toString(),\n    validBefore: validBefore.toString(),\n    nonce,\n  };\n}\n","/**\n * HTTP client implementing the client side of the x402 \"exact\" scheme:\n * probe -> 402 challenge -> sign -> pay -> response. Mirrors\n * x402module/poc/pkg/x402protocol/dynamicclient.go's own two-request\n * design (a fresh, unpaid probe carrying the real body, then a SEPARATE\n * paid retry with its own fresh body) and the sibling Python adapters'\n * client.py (langchain-x402-sagg, crewai-x402-sagg) field-for-field.\n * Node's global `fetch` builds a brand-new request body from the object\n * passed to it on each call, so - like the Python adapters using\n * `requests` - there is no equivalent of the mark3labs/x402-go\n * single-consumed-body bug this project found and worked around in Go\n * (PROJECT_STATE.md sec 3.145); noted for comparison, not because a\n * workaround was needed here.\n */\n\nimport { signTransferAuthorization } from \"./signer.js\";\nimport type { Hex } from \"viem\";\n\nconst CHAIN_IDS: Record<string, number> = {\n  base: 8453,\n  \"base-sepolia\": 84532,\n};\n\nexport class SaggX402PaymentError extends Error {}\n\n/** Shaped around what SAGG's own x402 handler actually reports, not the\n * generic x402 spec's success/errorReason/transaction Settlement shape\n * (see getSettlement's own doc comment for why those two differ). */\nexport interface Settlement {\n  ceilingTx: string;\n  refundTx: string | null;\n}\n\ninterface PaymentRequirement {\n  maxAmountRequired: string;\n  asset: Hex;\n  payTo: Hex;\n  network: string;\n  maxTimeoutSeconds?: number;\n  extra?: { name?: string; version?: string };\n}\n\ninterface X402Challenge {\n  x402Version: number;\n  error?: string;\n  accepts?: PaymentRequirement[];\n}\n\nexport interface SaggX402ClientOptions {\n  privateKey: Hex;\n  maxAmountAtomic: bigint;\n  network?: string;\n  timeoutMs?: number;\n}\n\n/** Pays for x402-gated SAGG requests using an EVM private key, enforcing\n * a hard per-call maximum (maxAmountAtomic) independent of whatever a\n * server's own requirement asks for - the same \"never auto-pay more\n * than this\" discipline as the Go module's WalletSigner and both Python\n * adapters. */\nexport class SaggX402Client {\n  private readonly privateKey: Hex;\n  private readonly maxAmountAtomic: bigint;\n  private readonly network: string;\n  private readonly chainId: number;\n  private readonly timeoutMs: number;\n\n  constructor(options: SaggX402ClientOptions) {\n    const network = options.network ?? \"base-sepolia\";\n    const chainId = CHAIN_IDS[network];\n    if (chainId === undefined) {\n      throw new Error(\n        `unsupported network ${JSON.stringify(network)}, want one of ${Object.keys(CHAIN_IDS).join(\", \")}`,\n      );\n    }\n    this.privateKey = options.privateKey;\n    this.maxAmountAtomic = options.maxAmountAtomic;\n    this.network = network;\n    this.chainId = chainId;\n    this.timeoutMs = options.timeoutMs ?? 60_000;\n  }\n\n  /** POSTs jsonBody to url. If the first response is a real x402 402\n   * challenge, signs the first accepted requirement (refusing if it\n   * exceeds maxAmountAtomic) and reposts a FRESH request with the\n   * resulting X-PAYMENT header. Any other first response (2xx, or a\n   * non-402 error) is returned as-is, unpaid. */\n  async postWithPayment(\n    url: string,\n    jsonBody: Record<string, unknown>,\n  ): Promise<Response> {\n    const probe = await this.postJson(url, jsonBody);\n    if (probe.status !== 402) {\n      return probe;\n    }\n\n    const challenge = (await probe.json()) as X402Challenge;\n    const accepts = challenge.accepts ?? [];\n    if (accepts.length === 0) {\n      throw new SaggX402PaymentError(\n        \"402 challenge carried no accepted payment methods\",\n      );\n    }\n    const requirement = accepts[0];\n\n    const amount = BigInt(requirement.maxAmountRequired);\n    if (amount > this.maxAmountAtomic) {\n      throw new SaggX402PaymentError(\n        `requirement asks for ${amount} atomic units, exceeds this client's configured max ${this.maxAmountAtomic}`,\n      );\n    }\n\n    const extra = requirement.extra ?? {};\n    if (!extra.name || !extra.version) {\n      throw new SaggX402PaymentError(\n        \"requirement missing EIP-3009 domain name/version in its 'extra' field\",\n      );\n    }\n\n    // this.chainId was fixed once at construction from this.network -\n    // correct ONLY as long as the requirement the server actually\n    // issued is for that same network. Real bug found live in the\n    // sibling langchain-x402-sagg package on the first real mainnet\n    // attempt (PROJECT_STATE.md sec 3.172, then confirmed to be the\n    // same shape here too): a client built with the default\n    // network=\"base-sepolia\" but pointed at a real mainnet SAGG_X402_URL\n    // signs with chainId 84532 while the server's requirement is for\n    // chainId 8453 - the facilitator correctly rejects the resulting\n    // signature as invalid (\"invalid_exact_evm_signature\"), a confusing\n    // failure with no clue as to the real cause. Refusing outright on a\n    // mismatch (rather than silently trusting whatever the server\n    // claims and re-deriving chainId from it) is the safer failure mode\n    // too: a testnet-configured client must never be tricked into\n    // producing a valid signature for a real mainnet transfer just\n    // because it was pointed at the wrong URL.\n    if (requirement.network !== this.network) {\n      throw new SaggX402PaymentError(\n        `requirement's network ${JSON.stringify(requirement.network)} does not match this client's configured network ${JSON.stringify(this.network)} - refusing to sign. This client was likely constructed with the wrong \\`network\\` option for the URL it's actually talking to.`,\n      );\n    }\n\n    const signed = await signTransferAuthorization(\n      this.privateKey,\n      extra.name,\n      extra.version,\n      this.chainId,\n      requirement.asset,\n      requirement.payTo,\n      amount,\n      requirement.maxTimeoutSeconds ?? 60,\n    );\n\n    const paymentPayload = {\n      x402Version: 1,\n      scheme: \"exact\",\n      network: requirement.network,\n      payload: {\n        signature: signed.signature,\n        authorization: {\n          from: signed.fromAddress,\n          to: signed.toAddress,\n          value: signed.value,\n          validAfter: signed.validAfter,\n          validBefore: signed.validBefore,\n          nonce: signed.nonce,\n        },\n      },\n    };\n    const headerValue = Buffer.from(JSON.stringify(paymentPayload)).toString(\n      \"base64\",\n    );\n\n    return this.postJson(url, jsonBody, { \"X-PAYMENT\": headerValue });\n  }\n\n  /** Extracts settlement info from SAGG's OWN response headers.\n   *\n   * A real, live-testing-only finding, not something assumed from the\n   * spec or copied from the sibling adapters: the generic x402 spec's\n   * `X-PAYMENT-RESPONSE` header (base64 JSON, what x402-go's OWN stock\n   * middleware sets, and what x402protocol.GetSettlement (client.go)\n   * and the sibling LangChain/CrewAI adapters' get_settlement look for)\n   * is NEVER set by SAGG's actual `/v1/chat/completions` x402 path -\n   * confirmed by inspecting real response headers from a live local\n   * gateway instance, not by reading the handler source alone. SAGG's\n   * x402ChatCompletionsHandler (x402billing.go) is built directly on\n   * DynamicServer (needed for per-request dynamic pricing - x402-go's\n   * own stock middleware only supports one fixed price set at startup),\n   * and sets its OWN plain headers instead:\n   * `X-SAGG-X402-Ceiling-Tx` (always present on a served response) and\n   * `X-SAGG-X402-Refund-Tx` (present only when a refund was actually\n   * sent - absent, not empty, when the refund amount was zero OR when\n   * sending it failed, e.g. the server wallet lacking gas - see this\n   * plugin's README for what that means for a real refund's\n   * observability from the client side). No `success`/`errorReason`\n   * fields exist in this scheme at all - a served 200 response with a\n   * ceiling-tx header IS the success signal. */\n  static getSettlement(response: Response): Settlement | null {\n    const ceilingTx = response.headers.get(\"X-SAGG-X402-Ceiling-Tx\");\n    if (!ceilingTx) {\n      return null;\n    }\n    return {\n      ceilingTx,\n      refundTx: response.headers.get(\"X-SAGG-X402-Refund-Tx\"),\n    };\n  }\n\n  private async postJson(\n    url: string,\n    jsonBody: Record<string, unknown>,\n    extraHeaders?: Record<string, string>,\n  ): Promise<Response> {\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), this.timeoutMs);\n    try {\n      return await fetch(url, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\", ...extraHeaders },\n        body: JSON.stringify(jsonBody),\n        signal: controller.signal,\n      });\n    } finally {\n      clearTimeout(timer);\n    }\n  }\n}\n","/**\n * The actual SAGG-backed TEXT_LARGE/TEXT_SMALL model handler. SAGG's own\n * gateway already does provider tiering/failover server-side (Standard\n * vs Super Deal lines - see the main sagg-project repo) - this plugin\n * deliberately does not reimplement a large/small model distinction of\n * its own; both ModelType.TEXT_LARGE and ModelType.TEXT_SMALL are wired\n * to the SAME handler and the same configured model id (see README's\n * \"What this plugin does NOT do\" for this and other scope calls).\n */\n\nimport type { IAgentRuntime } from \"@elizaos/core\";\nimport type { Hex } from \"viem\";\nimport { SaggX402Client, SaggX402PaymentError } from \"./client.js\";\n\n// The real, documented full-form model id (PROJECT_STATE.md sec 3.164) -\n// NOT the short \"deepseek-v4-flash-0731\" form the sibling LangChain/\n// CrewAI adapters default to. That short form is exactly the class of\n// bug sec 3.164 found and fixed in bench/superdeal_vs_direct.go and\n// cmd/warmup/main.go: it breaks model-name translation for the\n// eterial-deepseek/gonka24-deepseek fallback tiers specifically. Worth\n// fixing in the sibling adapters too, but out of this plugin's own\n// scope - flagged in this plugin's README instead.\nexport const DEFAULT_MODEL = \"deepseek-ai/DeepSeek-V4-Flash-0731\";\nexport const DEFAULT_MAX_AMOUNT_ATOMIC = 1_000_000n; // 1.00 USDC (6 decimals)\nexport const DEFAULT_NETWORK = \"base-sepolia\";\n\ninterface GenerateTextParamsLike {\n  prompt?: string;\n  system?: string;\n  messages?: Array<{ role: string; content: string }>;\n  maxTokens?: number;\n  temperature?: number;\n  stopSequences?: string[];\n}\n\ninterface ChatMessage {\n  role: string;\n  content: string;\n}\n\n/** One client per plugin instance, built lazily from runtime settings on\n * first use rather than in `init()` - a private key that's missing or\n * wrong should surface as a clear error on the first real request, not\n * silently disable the plugin at startup (ElizaOS loads plugins whose\n * `init` throws inconsistently across versions; failing at call time is\n * the more predictable contract). */\nlet cachedClient: SaggX402Client | null = null;\nlet cachedClientKey: string | null = null;\n\nfunction requireSetting(runtime: IAgentRuntime, key: string): string {\n  const value = runtime.getSetting(key);\n  if (value === null || value === undefined || value === \"\") {\n    throw new Error(\n      `plugin-sagg-x402: required setting ${key} is not configured`,\n    );\n  }\n  return String(value);\n}\n\nfunction optionalSetting(runtime: IAgentRuntime, key: string): string | null {\n  const value = runtime.getSetting(key);\n  if (value === null || value === undefined || value === \"\") {\n    return null;\n  }\n  return String(value);\n}\n\nfunction resolvePrivateKey(runtime: IAgentRuntime): Hex {\n  const dedicated = optionalSetting(runtime, \"SAGG_X402_PRIVATE_KEY\");\n  const fallback = dedicated ?? optionalSetting(runtime, \"EVM_PRIVATE_KEY\");\n  if (!fallback) {\n    throw new Error(\n      \"plugin-sagg-x402: neither SAGG_X402_PRIVATE_KEY nor EVM_PRIVATE_KEY is configured\",\n    );\n  }\n  return (fallback.startsWith(\"0x\") ? fallback : `0x${fallback}`) as Hex;\n}\n\nfunction getClient(runtime: IAgentRuntime): SaggX402Client {\n  const privateKey = resolvePrivateKey(runtime);\n  const network = optionalSetting(runtime, \"SAGG_X402_NETWORK\") ?? DEFAULT_NETWORK;\n  const maxAmountSetting = optionalSetting(\n    runtime,\n    \"SAGG_X402_MAX_AMOUNT_ATOMIC\",\n  );\n  const maxAmountAtomic = maxAmountSetting\n    ? BigInt(maxAmountSetting)\n    : DEFAULT_MAX_AMOUNT_ATOMIC;\n\n  // Cache key covers every input that changes what the client does -\n  // a settings change (e.g. rotating the key) must produce a fresh\n  // client, not silently keep signing with a stale one.\n  const cacheKey = `${privateKey}:${network}:${maxAmountAtomic}`;\n  if (cachedClient && cachedClientKey === cacheKey) {\n    return cachedClient;\n  }\n  cachedClient = new SaggX402Client({ privateKey, network, maxAmountAtomic });\n  cachedClientKey = cacheKey;\n  return cachedClient;\n}\n\nfunction buildMessages(params: GenerateTextParamsLike): ChatMessage[] {\n  const messages: ChatMessage[] = [];\n  if (params.system) {\n    messages.push({ role: \"system\", content: params.system });\n  }\n  if (params.messages && params.messages.length > 0) {\n    for (const m of params.messages) {\n      messages.push({ role: m.role, content: m.content });\n    }\n    return messages;\n  }\n  if (params.prompt) {\n    messages.push({ role: \"user\", content: params.prompt });\n    return messages;\n  }\n  throw new Error(\n    \"plugin-sagg-x402: GenerateTextParams carried neither `messages` nor `prompt`\",\n  );\n}\n\n/** The handler wired to ModelType.TEXT_LARGE/TEXT_SMALL in index.ts.\n * Pays via x402 on every call - SAGG's x402 path is a genuinely separate\n * accounting mechanism from its API-key/Stripe path (no quota, no\n * subscription), so there is no \"free\" request to fall back to if a\n * payment fails; a payment/HTTP error here is a real, user-visible\n * failure, not something to swallow. */\nexport async function handleGenerateText(\n  runtime: IAgentRuntime,\n  params: GenerateTextParamsLike,\n): Promise<string> {\n  const saggUrl = requireSetting(runtime, \"SAGG_X402_URL\").replace(/\\/+$/, \"\");\n  const model = optionalSetting(runtime, \"SAGG_X402_MODEL\") ?? DEFAULT_MODEL;\n  const client = getClient(runtime);\n\n  const body: Record<string, unknown> = {\n    model,\n    messages: buildMessages(params),\n  };\n  if (params.maxTokens !== undefined) body.max_tokens = params.maxTokens;\n  if (params.temperature !== undefined) body.temperature = params.temperature;\n  if (params.stopSequences && params.stopSequences.length > 0) {\n    body.stop = params.stopSequences;\n  }\n\n  let response: Response;\n  try {\n    response = await client.postWithPayment(\n      `${saggUrl}/v1/chat/completions`,\n      body,\n    );\n  } catch (err) {\n    if (err instanceof SaggX402PaymentError) {\n      throw new Error(`plugin-sagg-x402: payment refused: ${err.message}`);\n    }\n    throw err;\n  }\n\n  if (!response.ok) {\n    const text = await response.text().catch(() => \"\");\n    throw new Error(\n      `plugin-sagg-x402: SAGG request failed (${response.status}): ${text}`,\n    );\n  }\n\n  const data = (await response.json()) as {\n    choices?: Array<{ message?: { content?: string } }>;\n  };\n  const content = data.choices?.[0]?.message?.content;\n  if (typeof content !== \"string\") {\n    throw new Error(\n      \"plugin-sagg-x402: SAGG response had no choices[0].message.content\",\n    );\n  }\n  return content;\n}\n\n/** Exported for tests only - lets a test reset the module-level cache\n * between cases instead of caching a client across unrelated tests. */\nexport function _resetClientCacheForTests(): void {\n  cachedClient = null;\n  cachedClientKey = null;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "plugin-sagg-x402",
+  "version": "0.1.0",
+  "description": "ElizaOS plugin: pay for SAGG LLM completions per-request via the x402 protocol (signed USDC micropayment) instead of an API key.",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run src/__tests__/signer.test.ts src/__tests__/client.test.ts",
+    "test:live": "vitest run src/__tests__/live.test.ts"
+  },
+  "agentConfig": {
+    "pluginType": "elizaos:plugin:1.0.0",
+    "pluginParameters": {
+      "SAGG_X402_URL": {
+        "type": "string",
+        "description": "Base URL of the SAGG gateway, e.g. https://your-sagg-gateway.example.com (no trailing /v1/...)."
+      },
+      "SAGG_X402_MODEL": {
+        "type": "string",
+        "description": "Model id to request from SAGG. Defaults to deepseek-ai/DeepSeek-V4-Flash-0731."
+      },
+      "SAGG_X402_PRIVATE_KEY": {
+        "type": "string",
+        "description": "Dedicated hex EVM private key for x402 payments (TESTNET ONLY). Recommended over reusing EVM_PRIVATE_KEY so a compromised/overspending LLM-payment key can't touch the agent's other funds."
+      },
+      "EVM_PRIVATE_KEY": {
+        "type": "string",
+        "description": "Fallback: the same private key plugin-evm already reads, used only if SAGG_X402_PRIVATE_KEY is not set."
+      },
+      "SAGG_X402_MAX_AMOUNT_ATOMIC": {
+        "type": "string",
+        "description": "Hard per-call payment ceiling in USDC's smallest unit (6 decimals). Defaults to 1000000 (1.00 USDC). A 402 challenge asking for more is refused before any signature is produced."
+      },
+      "SAGG_X402_NETWORK": {
+        "type": "string",
+        "description": "\"base-sepolia\" (default, the only network this plugin has been tested against) or \"base\" (untested, out of scope as shipped)."
+      }
+    }
+  },
+  "dependencies": {
+    "viem": "^2.21.0"
+  },
+  "peerDependencies": {
+    "@elizaos/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@elizaos/core": "^1.0.0",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "license": "MIT"
+}