@tabai/sdk 0.2.0

package/dist/mcp/registry-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-client.js","sourceRoot":"","sources":["../../src/mcp/registry-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The keyless read client for the Tab registry read API.\n *\n * `tab_discover` and `tab_status` answer questions about chain state -- which\n * Services are registered, what each tool costs, what an Agent owes -- and every\n * one of those answers is a public fact. Nothing here signs, nothing here\n * authenticates, and nothing here writes. That is why `tab connect` can wire a\n * client up without ever touching a key, and why `tab doctor` can check a\n * deployment end to end from a laptop that holds none.\n *\n * ## Why the read API rather than the chain\n *\n * A Credit Limit is not a storage slot. It is `LimitLib` recomputed over an\n * Agent's committed Settlement history and the Bond ledger, cross-checked\n * against `TabBook.creditLimit` at the same block before it is served. A Bond\n * figure is a sum of `Bond`'s own events, checked against `Bond.ledgerOf`. An\n * MCP server that read the chain directly would have to restate both, and a\n * second restatement that drifts from the first is worse than one source of\n * truth: it would put two different Credit Limits in front of the same model.\n * So the figures come from the one process that already computes and checks\n * them, and this client's whole job is to fetch and not to interpret.\n *\n * The consequence is stated rather than hidden: with no registry read API\n * configured, `tab_discover` and `tab_status` fail with `UPSTREAM` and say so.\n * `tab_call` does not go through here at all -- it reads its figures off the\n * Service's own charge headers -- so a model can still call and be metered while\n * the index is down.\n *\n * ## Structural web types\n *\n * This package compiles against ES2023 with no DOM types, so `fetch`, its\n * response, and the abort signal are described by the shapes this module\n * touches, exactly as `client-402.ts` does. A host `fetch`, `undici`, and a test\n * closure all satisfy {@link RegistryFetch} without any of them being named.\n *\n * Requirements: 24.1, 24.4, 25.1, 25.3\n */\n\nimport type { Result, TabError } from \"../_shared/index.js\";\nimport { ok } from \"../_shared/index.js\";\n\nimport { tabError, upstreamError, validationError } from \"../errors.js\";\nimport { defaultLogger, type Logger } from \"../logger.js\";\nimport { asString, isRecord } from \"./json.js\";\n\n/** The two fields of a response this client reads. */\nexport interface RegistryResponse {\n  readonly status: number;\n  json(): Promise<unknown>;\n}\n\n/** The `fetch` this client calls. A host `fetch` satisfies it as it stands. */\nexport type RegistryFetch = (url: string, init: Readonly<Record<string, unknown>>) => Promise<RegistryResponse>;\n\nexport interface RegistryReadClientOptions {\n  /** Absolute base URL of the read API, with or without a trailing slash. */\n  readonly baseUrl: string;\n  readonly fetchImpl?: RegistryFetch;\n  /** How long one read may take. Defaults to 10 seconds. */\n  readonly timeoutMs?: number;\n  readonly logger?: Logger;\n}\n\n/** Every read `tab_discover` and `tab_status` make, and nothing else. */\nexport interface RegistryReadClient {\n  /** The base URL reads go to, normalised, so an error message can name it. */\n  readonly baseUrl: string;\n  /** `GET /healthz`, which is what `doctor` asks before it trusts anything else. */\n  health(): Promise<Result<unknown>>;\n  /** A page of registered Services, hydrated with prices, collections and Bond. */\n  services(limit: number): Promise<Result<unknown>>;\n  /** One Service, or `NOT_FOUND` when nothing ever registered under the id. */\n  service(serviceId: string): Promise<Result<unknown>>;\n  /** One Agent's credit picture per Asset. An address with no history is a 200 with empty arrays. */\n  agent(address: string): Promise<Result<unknown>>;\n  /** Settlements, newest first, filtered by Agent and optionally by Asset. */\n  settlements(query: SettlementQuery): Promise<Result<unknown>>;\n  /** One Settlement with the transaction that paid it, named by its `settlementId`. */\n  settlement(settlementId: string): Promise<Result<unknown>>;\n}\n\nexport interface SettlementQuery {\n  readonly agent: string;\n  /** The token address alone, which is how the index keys an Asset. */\n  readonly asset?: string;\n  readonly limit: number;\n}\n\n/** Drops a trailing slash so path joining never produces a double one. */\nexport const normaliseBaseUrl = (baseUrl: string): string => baseUrl.replace(/\\/+$/, \"\");\n\n/**\n * An abort signal that fires after `ms`, when the host has one.\n *\n * Described structurally rather than typed as `AbortSignal`, for the same reason\n * `fetch` is: no DOM types here. A host without `AbortSignal.timeout` gets no\n * signal and the read runs to whatever timeout its transport imposes, which is\n * worse than a bounded read but better than a failure to construct one.\n */\nconst timeoutSignal = (ms: number): unknown => {\n  const ctor = (globalThis as { AbortSignal?: { timeout?: (ms: number) => unknown } }).AbortSignal;\n  return typeof ctor?.timeout === \"function\" ? ctor.timeout(ms) : undefined;\n};\n\nconst hostFetch = (): RegistryFetch | undefined => {\n  const candidate = (globalThis as { fetch?: unknown }).fetch;\n  return typeof candidate === \"function\" ? (candidate as RegistryFetch) : undefined;\n};\n\nconst CATEGORIES = [\"VALIDATION\", \"NOT_FOUND\", \"CONFLICT\", \"UPSTREAM\", \"CHAIN\", \"TIMEOUT\", \"INTERNAL\"] as const;\n\n/**\n * Reads the read API's own error body back into a `TabError`.\n *\n * Every route there fails with `{ error: { category, code, message } }` in this\n * package's own vocabulary, so a 404 for an unregistered serviceId arrives here\n * as `NOT_FOUND` / `SERVICE_NOT_REGISTERED` and reaches the model unchanged.\n * Rewriting it as a generic upstream failure would throw away the one part a\n * caller can act on.\n */\nfunction upstreamFailure(url: string, status: number, body: unknown): Result<never> {\n  const error = isRecord(body) ? body[\"error\"] : undefined;\n  if (isRecord(error)) {\n    const category = asString(error[\"category\"], \"\");\n    if ((CATEGORIES as readonly string[]).includes(category)) {\n      return {\n        ok: false,\n        error: tabError(\n          category as TabError[\"category\"],\n          asString(error[\"code\"], \"REGISTRY_READ_FAILED\"),\n          asString(error[\"message\"], `the registry read API answered ${status} for ${url}`),\n          { details: { url, status } },\n        ),\n      };\n    }\n  }\n  return upstreamError(\n    \"REGISTRY_READ_FAILED\",\n    `the registry read API answered ${status} for ${url}`,\n    { retryable: status >= 500, details: { url, status } },\n  );\n}\n\n/**\n * Builds the client.\n *\n * Construction is total, like every other factory in this package: an unusable\n * base URL is reported by the first read, which is the only place a caller can\n * act on it.\n */\nexport function createRegistryReadClient(options: RegistryReadClientOptions): RegistryReadClient {\n  const baseUrl = normaliseBaseUrl(options.baseUrl);\n  const timeoutMs = options.timeoutMs ?? 10_000;\n  const logger = options.logger ?? defaultLogger;\n\n  const get = async (pathname: string, query: Readonly<Record<string, string | undefined>> = {}): Promise<Result<unknown>> => {\n    if (!/^https?:\\/\\/[^\\s]+$/.test(baseUrl)) {\n      return validationError(\n        \"REGISTRY_URL_INVALID\",\n        `the registry read API base URL must be an absolute http or https URL, received \\`${options.baseUrl}\\``,\n        { details: { baseUrl: options.baseUrl } },\n      );\n    }\n    const send = options.fetchImpl ?? hostFetch();\n    if (send === undefined) {\n      return upstreamError(\n        \"FETCH_UNAVAILABLE\",\n        \"this host has no global fetch; supply fetchImpl, or run on Node 20.10 or later\",\n      );\n    }\n\n    const search = Object.entries(query)\n      .filter((entry): entry is [string, string] => entry[1] !== undefined)\n      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)\n      .join(\"&\");\n    const url = `${baseUrl}${pathname}${search === \"\" ? \"\" : `?${search}`}`;\n\n    const signal = timeoutSignal(timeoutMs);\n    let response: RegistryResponse;\n    try {\n      response = await send(url, {\n        method: \"GET\",\n        headers: { accept: \"application/json\" },\n        ...(signal === undefined ? {} : { signal }),\n      });\n    } catch (error) {\n      const reason = error instanceof Error ? error.message : String(error);\n      // A transport failure and a timeout are the same shape here and different\n      // things to a caller, so the category splits on the abort name.\n      const timedOut = error instanceof Error && (error.name === \"TimeoutError\" || error.name === \"AbortError\");\n      logger.warn(\"registry read failed\", { url, reason });\n      // Both are UPSTREAM: the category vocabulary has no timeout of its own, and a\n      // read API that answered nothing in time is an upstream failure whichever way\n      // it failed. The code is what tells the two apart, and both are retryable.\n      return timedOut\n        ? upstreamError(\n            \"REGISTRY_READ_TIMEOUT\",\n            `the registry read API at ${url} did not answer within ${timeoutMs}ms`,\n            { retryable: true, details: { url, timeoutMs } },\n          )\n        : upstreamError(\"REGISTRY_UNREACHABLE\", `the registry read API at ${url} could not be reached: ${reason}`, {\n            retryable: true,\n            details: { url },\n          });\n    }\n\n    let body: unknown;\n    try {\n      body = await response.json();\n    } catch (error) {\n      const reason = error instanceof Error ? error.message : String(error);\n      return upstreamError(\n        \"REGISTRY_BODY_UNREADABLE\",\n        `the registry read API at ${url} answered ${response.status} with a body that is not JSON: ${reason}`,\n        { details: { url, status: response.status } },\n      );\n    }\n\n    if (response.status < 200 || response.status >= 300) return upstreamFailure(url, response.status, body);\n    return ok(body);\n  };\n\n  return {\n    baseUrl,\n    health: () => get(\"/healthz\"),\n    services: (limit) => get(\"/services\", { limit: String(limit) }),\n    service: (serviceId) => get(`/services/${encodeURIComponent(serviceId.toLowerCase())}`),\n    agent: (address) => get(`/agents/${encodeURIComponent(address.toLowerCase())}`),\n    settlements: (query) =>\n      get(\"/settlements\", {\n        agent: query.agent.toLowerCase(),\n        asset: query.asset?.toLowerCase(),\n        limit: String(query.limit),\n      }),\n    settlement: (settlementId) => get(`/settlements/${encodeURIComponent(settlementId.toLowerCase())}`),\n  };\n}\n"]}

package/dist/mcp/schemas.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The four MCP tools, declared. (R25.1, R25.2)
+ *
+ * This file is the contract. A model reads these schemas to decide what to send
+ * and what it will get back, `tools/list` serves them verbatim, every tool
+ * validates its input against the schema here before doing any work, and the
+ * task 16.3 tests validate every output against it. There is one declaration of
+ * each shape and it lives here, so the published contract and the enforced
+ * contract cannot drift apart.
+ *
+ * ## Amounts are decimal strings, never numbers
+ *
+ * Every field whose name ends in `BaseUnits` is a string of digits matching
+ * {@link BASE_UNITS_PATTERN}. A `uint256` does not survive a double: 2^53 base
+ * units of a 6-decimal Asset is about 9 billion units of that Asset, which is
+ * inside the range a Credit Limit can reach, and a rounded amount that still
+ * looks plausible is the worst possible failure for a billing surface. JSON has
+ * no integer type wide enough, so the wire form is a string and the boundary
+ * converts.
+ *
+ * ## Failure is a value, not an exception
+ *
+ * Every output schema carries an optional `error` object of
+ * `{ category, code, message }`. Nothing in this package throws across the MCP
+ * boundary, so a tool that cannot do its job returns a schema-valid payload
+ * whose `error` says why, and the model can act on it. `tab_call` and
+ * `tab_settle` additionally carry a required `ok` boolean, because those two
+ * change state and "did it happen" is the first thing a caller must read.
+ *
+ * `LIMIT_EXCEEDED` is the case the design singles out: the Agent has no headroom
+ * for the Asset, so the tool answers `ok: false` with both `requiredBaseUnits`
+ * and `headroomBaseUnits` populated. That is the difference between a model that
+ * decides to settle and a model that guesses. (R21.5)
+ *
+ * Requirements: 21.5, 25.1, 25.2, 25.3, 25.4
+ */
+import type { JsonObjectSchema, JsonSchema } from "./json-schema.js";
+/** A `uint256` in decimal, as a string. 78 digits is the ceiling; 39 covers every real amount. */
+export declare const BASE_UNITS_PATTERN = "^[0-9]{1,39}$";
+/** A 20-byte address. */
+export declare const ADDRESS_PATTERN = "^0x[a-fA-F0-9]{40}$";
+/** A 32-byte word: a serviceId, a tool key, a tabId, a settlement id. */
+export declare const WORD_PATTERN = "^0x[a-fA-F0-9]{64}$";
+/** An Asset named with its network: the decimal EVM chain id, a colon, the token address. */
+export declare const ASSET_PATTERN = "^[0-9]+:0x[a-fA-F0-9]{40}$";
+/**
+ * The failure block every tool can return.
+ *
+ * `category` is the same seven-value vocabulary `../_shared/index.js` uses everywhere
+ * else, so a code path that maps a category to an HTTP status on one surface
+ * maps it the same way here. `requiredBaseUnits` and `headroomBaseUnits` are
+ * present only on `LIMIT_EXCEEDED`.
+ */
+export declare const ERROR_SCHEMA: JsonSchema;
+export declare const TAB_DISCOVER_INPUT: JsonObjectSchema;
+export declare const TAB_DISCOVER_OUTPUT: JsonObjectSchema;
+export declare const TAB_CALL_INPUT: JsonObjectSchema;
+export declare const TAB_CALL_OUTPUT: JsonObjectSchema;
+export declare const TAB_STATUS_INPUT: JsonObjectSchema;
+export declare const TAB_STATUS_OUTPUT: JsonObjectSchema;
+export declare const TAB_SETTLE_INPUT: JsonObjectSchema;
+export declare const TAB_SETTLE_OUTPUT: JsonObjectSchema;
+/** One tool as `tools/list` serves it. */
+export interface TabToolDeclaration {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly inputSchema: JsonObjectSchema;
+    readonly outputSchema: JsonObjectSchema;
+    /** MCP behaviour hints. `tab_settle` is the only tool that is not read-only. */
+    readonly annotations: {
+        readonly readOnlyHint: boolean;
+        readonly destructiveHint: boolean;
+        readonly idempotentHint: boolean;
+        readonly openWorldHint: boolean;
+    };
+}
+export declare const TAB_TOOLS: readonly TabToolDeclaration[];
+/** The tool names, in the order `tools/list` serves them. */
+export declare const TAB_TOOL_NAMES: string[];
+export declare const tabToolByName: (name: string) => TabToolDeclaration | undefined;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/mcp/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/mcp/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAErE,kGAAkG;AAClG,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAClD,yBAAyB;AACzB,eAAO,MAAM,eAAe,wBAAwB,CAAC;AACrD,yEAAyE;AACzE,eAAO,MAAM,YAAY,wBAAwB,CAAC;AAClD,6FAA6F;AAC7F,eAAO,MAAM,aAAa,+BAA+B,CAAC;AA2B1D;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,UA4B1B,CAAC;AAIF,eAAO,MAAM,kBAAkB,EAAE,gBAuBhC,CAAC;AA8FF,eAAO,MAAM,mBAAmB,EAAE,gBA2CjC,CAAC;AAIF,eAAO,MAAM,cAAc,EAAE,gBAiB5B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,gBAiD7B,CAAC;AAIF,eAAO,MAAM,gBAAgB,EAAE,gBAU9B,CAAC;AAmEF,eAAO,MAAM,iBAAiB,EAAE,gBAgB/B,CAAC;AAIF,eAAO,MAAM,gBAAgB,EAAE,gBAiB9B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,gBAoB/B,CAAC;AAIF,0CAA0C;AAC1C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,gFAAgF;IAChF,QAAQ,CAAC,WAAW,EAAE;QACpB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;QAC/B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;QAClC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;QACjC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;KACjC,CAAC;CACH;AASD,eAAO,MAAM,SAAS,EAAE,SAAS,kBAAkB,EA+ClD,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,cAAc,UAAqC,CAAC;AAEjE,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,kBAAkB,GAAG,SACpB,CAAC"}

package/dist/mcp/schemas.js

@@ -0,0 +1,493 @@
+/**
+ * The four MCP tools, declared. (R25.1, R25.2)
+ *
+ * This file is the contract. A model reads these schemas to decide what to send
+ * and what it will get back, `tools/list` serves them verbatim, every tool
+ * validates its input against the schema here before doing any work, and the
+ * task 16.3 tests validate every output against it. There is one declaration of
+ * each shape and it lives here, so the published contract and the enforced
+ * contract cannot drift apart.
+ *
+ * ## Amounts are decimal strings, never numbers
+ *
+ * Every field whose name ends in `BaseUnits` is a string of digits matching
+ * {@link BASE_UNITS_PATTERN}. A `uint256` does not survive a double: 2^53 base
+ * units of a 6-decimal Asset is about 9 billion units of that Asset, which is
+ * inside the range a Credit Limit can reach, and a rounded amount that still
+ * looks plausible is the worst possible failure for a billing surface. JSON has
+ * no integer type wide enough, so the wire form is a string and the boundary
+ * converts.
+ *
+ * ## Failure is a value, not an exception
+ *
+ * Every output schema carries an optional `error` object of
+ * `{ category, code, message }`. Nothing in this package throws across the MCP
+ * boundary, so a tool that cannot do its job returns a schema-valid payload
+ * whose `error` says why, and the model can act on it. `tab_call` and
+ * `tab_settle` additionally carry a required `ok` boolean, because those two
+ * change state and "did it happen" is the first thing a caller must read.
+ *
+ * `LIMIT_EXCEEDED` is the case the design singles out: the Agent has no headroom
+ * for the Asset, so the tool answers `ok: false` with both `requiredBaseUnits`
+ * and `headroomBaseUnits` populated. That is the difference between a model that
+ * decides to settle and a model that guesses. (R21.5)
+ *
+ * Requirements: 21.5, 25.1, 25.2, 25.3, 25.4
+ */
+/** A `uint256` in decimal, as a string. 78 digits is the ceiling; 39 covers every real amount. */
+export const BASE_UNITS_PATTERN = "^[0-9]{1,39}$";
+/** A 20-byte address. */
+export const ADDRESS_PATTERN = "^0x[a-fA-F0-9]{40}$";
+/** A 32-byte word: a serviceId, a tool key, a tabId, a settlement id. */
+export const WORD_PATTERN = "^0x[a-fA-F0-9]{64}$";
+/** An Asset named with its network: the decimal EVM chain id, a colon, the token address. */
+export const ASSET_PATTERN = "^[0-9]+:0x[a-fA-F0-9]{40}$";
+const baseUnits = (description) => ({
+    type: "string",
+    pattern: BASE_UNITS_PATTERN,
+    description,
+});
+/**
+ * An amount the source may be unable to serve.
+ *
+ * Null is "this figure was withheld", never "zero". The registry read API
+ * withholds a Credit Limit it could not cross-check against `TabBook` rather
+ * than serving an unchecked one, and a zero in its place would read as an Agent
+ * with no credit -- the opposite of what a withheld figure means.
+ */
+const nullableBaseUnits = (description) => ({
+    type: ["string", "null"],
+    pattern: BASE_UNITS_PATTERN,
+    description,
+});
+const address = (description) => ({ type: "string", pattern: ADDRESS_PATTERN, description });
+const word = (description) => ({ type: "string", pattern: WORD_PATTERN, description });
+const assetRef = (description) => ({ type: "string", pattern: ASSET_PATTERN, description });
+const nullableString = (description) => ({ type: ["string", "null"], description });
+/**
+ * The failure block every tool can return.
+ *
+ * `category` is the same seven-value vocabulary `../_shared/index.js` uses everywhere
+ * else, so a code path that maps a category to an HTTP status on one surface
+ * maps it the same way here. `requiredBaseUnits` and `headroomBaseUnits` are
+ * present only on `LIMIT_EXCEEDED`.
+ */
+export const ERROR_SCHEMA = {
+    type: "object",
+    description: "Why the call did not do what was asked. Absent when it did.",
+    properties: {
+        category: {
+            type: "string",
+            enum: [
+                "VALIDATION",
+                "AUTHORISATION",
+                "NOT_FOUND",
+                "LIMIT",
+                "CHAIN",
+                "UPSTREAM",
+                "CONFLICT",
+                "UNAVAILABLE",
+                "INTERNAL",
+            ],
+            description: "The failure class, in the vocabulary the rest of Tab uses. VALIDATION and NOT_FOUND are the caller's to fix; LIMIT means the Credit Limit or the headroom is exhausted.",
+        },
+        code: { type: "string", description: "A stable machine-readable code, such as LIMIT_EXCEEDED." },
+        message: { type: "string", description: "One sentence a model or a person can act on." },
+        retryable: { type: "boolean", description: "Whether repeating the identical call could succeed." },
+        requiredBaseUnits: baseUnits("LIMIT_EXCEEDED only: what the call needed, in Asset base units."),
+        headroomBaseUnits: baseUnits("LIMIT_EXCEEDED only: what the Agent had, in Asset base units."),
+    },
+    required: ["category", "code", "message"],
+    additionalProperties: false,
+};
+// ---------------------------------------------------------------- tab_discover
+export const TAB_DISCOVER_INPUT = {
+    type: "object",
+    description: "Filters over the registered Services. Every field is optional; no filter lists everything.",
+    properties: {
+        asset: assetRef("Keep only Services that accept this Asset, as `chainId:tokenAddress`, for example `143:0x7547...b603`."),
+        tier: {
+            type: "string",
+            enum: ["curated", "permissionless", "any"],
+            default: "any",
+            description: "Curation tier. A Curated Service carries more Credit Limit weight; a Permissionless one is registered and unreviewed.",
+        },
+        search: {
+            type: "string",
+            maxLength: 128,
+            description: "Case-insensitive substring matched against the Service name and its serviceId.",
+        },
+        limit: { type: "integer", minimum: 1, maximum: 100, default: 25, description: "How many Services to return." },
+    },
+    required: [],
+    additionalProperties: false,
+};
+const SERVICE_ASSET_SCHEMA = {
+    type: "object",
+    properties: {
+        chainId: { type: "integer", description: "The EVM chain id: 143 is Monad Mainnet, 10143 is Monad Testnet." },
+        address: address("The token contract on that chain."),
+        symbol: nullableString("Null when this package ships no descriptor for the Asset."),
+        decimals: { type: ["integer", "null"], description: "Null when this package ships no descriptor for the Asset." },
+        collectionAddress: {
+            type: ["string", "null"],
+            pattern: ADDRESS_PATTERN,
+            description: "Where the Service collects Settlements of this Asset. Null when no Tab Collection resolves.",
+        },
+        curatedAsset: {
+            type: "boolean",
+            description: "True when this package ships a descriptor for the pair, which is what supplies symbol and decimals. False means the Asset is accepted on chain but unknown here, so its symbol and decimals are null and a caller must not assume six decimals.",
+        },
+    },
+    required: ["chainId", "address", "symbol", "decimals", "collectionAddress", "curatedAsset"],
+    additionalProperties: false,
+};
+const SERVICE_TOOL_SCHEMA = {
+    type: "object",
+    properties: {
+        tool: word("The tool key: the tool name, left-aligned and zero-padded to 32 bytes."),
+        toolName: nullableString("The ascii the tool key decodes to, when it decodes to printable ascii."),
+        asset: assetRef("The Asset this price is denominated in."),
+        priceBaseUnits: baseUnits("What one call costs, in Asset base units."),
+    },
+    required: ["tool", "toolName", "asset", "priceBaseUnits"],
+    additionalProperties: false,
+};
+const SERVICE_BOND_SCHEMA = {
+    type: "object",
+    properties: {
+        asset: assetRef("The Asset the stake is denominated in."),
+        stakedBaseUnits: baseUnits("Total Bond staked for this Asset."),
+        freeBaseUnits: baseUnits("Stake the Service can still withdraw. It is what caps the credit its history backs."),
+    },
+    required: ["asset", "stakedBaseUnits", "freeBaseUnits"],
+    additionalProperties: false,
+};
+const PENDING_CHANGE_SCHEMA = {
+    type: ["object", "null"],
+    description: "The next queued registry change, or null when nothing is queued.",
+    properties: {
+        changeId: word("The id the RegistryChangeQueued event reported."),
+        kind: nullableString("Tier, SettlementWindow, ToolPrice, and so on."),
+        etaIso: nullableString("When the timelock lets the change apply."),
+    },
+    required: ["changeId", "kind", "etaIso"],
+    additionalProperties: false,
+};
+const HUB_ENDPOINT_SCHEMA = {
+    type: "object",
+    properties: {
+        endpoint: { type: "string", description: "The provider-relative path, for example `/get_current_weather`." },
+        name: nullableString("The Hub's display name for the endpoint."),
+        description: nullableString("What the endpoint does, as the Hub describes it."),
+        priceType: {
+            type: "string",
+            description: "How the Hub prices it: PER_CALL, PER_RESULT, PER_UNIT or PER_UNIT_MATRIX. Only PER_CALL has a fixed base-unit price.",
+        },
+        priceUsd: nullableString("The Hub's decimal USD figure. The metered charge is this plus the fronting Service's margin."),
+        priceBaseUnits: nullableBaseUnits("The USD figure as six-decimal base units, for PER_CALL only. Null otherwise."),
+        networks: { type: "array", items: { type: "string" }, description: "CAIP-2 networks the Hub takes payment on." },
+    },
+    required: ["endpoint", "name", "description", "priceType", "priceUsd", "priceBaseUnits", "networks"],
+    additionalProperties: false,
+};
+const SERVICE_HUB_SCHEMA = {
+    type: "object",
+    description: "The API Hub provider this Service fronts, when it fronts one. Each endpoint is called through the Service at `<endpoint>/hub/<prefix><endpoint path>`, paid upstream by the Service and metered onto the Agent's Open Tab for the upstream price plus the Service's margin.",
+    properties: {
+        provider: { type: "string", description: "The Hub provider slug." },
+        prefix: { type: "string", description: "The mount under the Service endpoint: `/hub/<prefix>`." },
+        endpoints: { type: "array", items: HUB_ENDPOINT_SCHEMA },
+        total: { type: "integer", description: "How many endpoints the Hub lists for the provider." },
+        error: ERROR_SCHEMA,
+    },
+    required: ["provider", "prefix", "endpoints", "total"],
+    additionalProperties: false,
+};
+export const TAB_DISCOVER_OUTPUT = {
+    type: "object",
+    properties: {
+        services: {
+            type: "array",
+            description: "The matching Services. Empty on failure, with `error` populated.",
+            items: {
+                type: "object",
+                properties: {
+                    serviceId: word("The Service's 32-byte registry key."),
+                    name: nullableString("The ascii the serviceId decodes to, when it decodes to printable ascii."),
+                    endpoint: nullableString("Where tab_call sends requests. Null when nothing configured one: the chain records no endpoint, so it comes from tab.config or from the server options."),
+                    tier: { type: "string", enum: ["curated", "permissionless", "unknown"] },
+                    settlementWindowSeconds: {
+                        type: "integer",
+                        description: "How long after a Metered Delivery the Agent has to settle before the tab is delinquent.",
+                    },
+                    assets: { type: "array", items: SERVICE_ASSET_SCHEMA },
+                    tools: { type: "array", items: SERVICE_TOOL_SCHEMA },
+                    bonds: { type: "array", items: SERVICE_BOND_SCHEMA },
+                    pendingChange: PENDING_CHANGE_SCHEMA,
+                    hub: SERVICE_HUB_SCHEMA,
+                },
+                required: [
+                    "serviceId",
+                    "name",
+                    "endpoint",
+                    "tier",
+                    "settlementWindowSeconds",
+                    "assets",
+                    "tools",
+                    "bonds",
+                    "pendingChange",
+                ],
+                additionalProperties: false,
+            },
+        },
+        error: ERROR_SCHEMA,
+    },
+    required: ["services"],
+    additionalProperties: false,
+};
+// ---------------------------------------------------------------- tab_call
+export const TAB_CALL_INPUT = {
+    type: "object",
+    description: "Calls one tool on one Service. The call is metered onto the Agent's Open Tab and paid for later.",
+    properties: {
+        serviceId: word("The Service to call, as reported by tab_discover."),
+        tool: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+            description: "The tool name, for example `quote.generate`. A 32-byte hex word is accepted too.",
+        },
+        asset: assetRef("Which Asset to meter in. Defaults to the Service's only priced Asset when it has one."),
+        arguments: { type: "object", description: "The tool's own arguments, passed through untouched." },
+        timeoutMs: { type: "integer", minimum: 1000, maximum: 120000, default: 30000 },
+    },
+    required: ["serviceId", "tool"],
+    additionalProperties: false,
+};
+export const TAB_CALL_OUTPUT = {
+    type: "object",
+    properties: {
+        ok: { type: "boolean", description: "Whether the Service served the call and it was metered." },
+        result: { description: "Whatever the Service returned. Absent when ok is false." },
+        charge: {
+            type: "object",
+            description: "What this call cost. Present whenever the Service reported a charge block.",
+            properties: {
+                amountBaseUnits: baseUnits("Charged when ok is true; required but not charged when ok is false."),
+                asset: assetRef("The Asset the charge is denominated in."),
+                tool: word("The tool key that was metered."),
+            },
+            required: ["amountBaseUnits", "asset", "tool"],
+            additionalProperties: false,
+        },
+        tab: {
+            type: "object",
+            description: "The Agent's position for this Asset, as the Service reported it on this response.",
+            properties: {
+                openTabBaseUnits: baseUnits("What the Agent now owes for this Asset."),
+                headroomBaseUnits: baseUnits("What the Agent may still spend before the Credit Limit binds."),
+                creditLimitBaseUnits: baseUnits("The Credit Limit for this Asset, when the response carried one."),
+                asset: assetRef("The Asset these figures are denominated in."),
+                settlementDueIso: nullableString("When the Settlement Window closes on this tab."),
+            },
+            required: ["openTabBaseUnits", "headroomBaseUnits", "asset"],
+            additionalProperties: false,
+        },
+        x402: {
+            type: "object",
+            description: "Present when the Service refused the call on credit and it was prepaid through x402 instead, with the signer tab.config's `x402` factory built. Nothing landed on the Open Tab: the call was paid in full, once, by this transaction.",
+            properties: {
+                txHash: { type: "string", description: "The settlement transaction the facilitator broadcast. Empty when it reported none." },
+                network: { type: "string", description: "The CAIP-2 network it settled on, for example `eip155:10143`." },
+                amountBaseUnits: baseUnits("What was paid, in atomic units of the asset."),
+                asset: assetRef("The token the payment was made in."),
+                payTo: address("Where the funds went: the Service's Collection address."),
+                payer: address("Who signed: the x402 signer's address."),
+                explorerUrl: nullableString("A link to the transaction on the configured explorer."),
+            },
+            required: ["txHash", "network", "amountBaseUnits", "asset", "payTo", "payer", "explorerUrl"],
+            additionalProperties: false,
+        },
+        error: ERROR_SCHEMA,
+    },
+    required: ["ok"],
+    additionalProperties: false,
+};
+// ---------------------------------------------------------------- tab_status
+export const TAB_STATUS_INPUT = {
+    type: "object",
+    description: "The Agent's credit picture: what it owes, what it may still spend, and what has settled.",
+    properties: {
+        agent: address("The Agent's Monad address. Defaults to the Agent this server is configured for."),
+        asset: assetRef("Report only this Asset. Omitted reports every Asset the Agent has touched."),
+        historyLimit: { type: "integer", minimum: 0, maximum: 200, default: 20 },
+    },
+    required: [],
+    additionalProperties: false,
+};
+const PER_ASSET_SCHEMA = {
+    type: "object",
+    properties: {
+        asset: assetRef("The Asset these figures are denominated in."),
+        creditLimitBaseUnits: nullableBaseUnits("What this Agent may owe for this Asset at once. Null when the source withheld the figure because it could not cross-check it against TabBook."),
+        openTabBaseUnits: baseUnits("What it owes now."),
+        prepaidBaseUnits: nullableBaseUnits("Credit paid in ahead of use, which is drawn on before the Credit Limit. Null when the source serves only cumulative settlement totals and no live balance."),
+        headroomBaseUnits: nullableBaseUnits("What it may still spend. Null whenever the Credit Limit is null."),
+        delinquent: { type: "boolean", description: "True while a Settlement Window has closed on an unsettled tab." },
+        tabs: {
+            type: "array",
+            description: "The tabs behind the figures, newest first, capped by historyLimit.",
+            items: {
+                type: "object",
+                properties: {
+                    tabId: {
+                        type: ["string", "null"],
+                        pattern: WORD_PATTERN,
+                        description: "The tab's identity on TabBook. Null when the source reports the observation by Agent, Service and Asset without naming the tab.",
+                    },
+                    serviceId: word("The Service the tab is with."),
+                    openBaseUnits: baseUnits("The Open Tab last observed on this tab. A lower bound: a Metered Delivery raises a tab without an indexed event, so the per-Asset figure above is the one to trust."),
+                    dueIso: nullableString("When this tab's Settlement Window closes."),
+                },
+                required: ["tabId", "serviceId", "openBaseUnits", "dueIso"],
+                additionalProperties: false,
+            },
+        },
+    },
+    required: [
+        "asset",
+        "creditLimitBaseUnits",
+        "openTabBaseUnits",
+        "prepaidBaseUnits",
+        "headroomBaseUnits",
+        "delinquent",
+        "tabs",
+    ],
+    additionalProperties: false,
+};
+const SETTLEMENT_SCHEMA = {
+    type: "object",
+    description: "A Settlement the Agent paid on Monad: the Asset moved to the Service and the Open Tab fell in one transaction.",
+    properties: {
+        settlementId: word("The Settlement's identity, assigned by TabBook when it was applied."),
+        txHash: word("The Monad transaction that paid it."),
+        serviceId: word("The Service that was paid."),
+        asset: assetRef("The Asset that was paid."),
+        amountBaseUnits: baseUnits("How much was paid."),
+        appliedBaseUnits: baseUnits("How much of it lowered the Open Tab."),
+        prepaidBaseUnits: baseUnits("How much of it was banked as prepaid credit."),
+        explorerUrl: nullableString("The transaction on the Monad explorer."),
+    },
+    required: ["settlementId", "txHash", "serviceId", "asset", "amountBaseUnits", "appliedBaseUnits", "prepaidBaseUnits", "explorerUrl"],
+    additionalProperties: false,
+};
+export const TAB_STATUS_OUTPUT = {
+    type: "object",
+    properties: {
+        agent: address("The Agent these figures are about."),
+        indexedBlock: {
+            type: ["integer", "null"],
+            minimum: 0,
+            description: "The Monad block every figure is as at. A Settlement sent a moment ago sits in a later block and is not yet reflected; read again after the index passes it. Null when the index has never ticked.",
+        },
+        perAsset: { type: "array", items: PER_ASSET_SCHEMA },
+        settlements: { type: "array", items: SETTLEMENT_SCHEMA },
+        error: ERROR_SCHEMA,
+    },
+    required: ["agent", "indexedBlock", "perAsset"],
+    additionalProperties: false,
+};
+// ---------------------------------------------------------------- tab_settle
+export const TAB_SETTLE_INPUT = {
+    type: "object",
+    description: "Pays down an Open Tab by calling TabSettlement.settle on Monad with the Agent's own key. This spends real funds unless dryRun is set.",
+    properties: {
+        serviceId: word("The Service being paid."),
+        asset: assetRef("The Asset to pay in, as `chainId:tokenAddress`."),
+        amountBaseUnits: baseUnits("How much to pay, in Asset base units."),
+        strategyId: { type: "string", maxLength: 64, description: "Which registered payment strategy to settle through." },
+        dryRun: {
+            type: "boolean",
+            default: false,
+            description: "Build and validate the Settlement, report what would be sent, and broadcast nothing.",
+        },
+    },
+    required: ["serviceId", "asset", "amountBaseUnits"],
+    additionalProperties: false,
+};
+export const TAB_SETTLE_OUTPUT = {
+    type: "object",
+    properties: {
+        ok: { type: "boolean", description: "Whether the Settlement was sent, or would have been on a dry run." },
+        dryRun: { type: "boolean", description: "True when nothing was sent." },
+        txHash: nullableString("The Monad transaction. Null on a dry run and on failure."),
+        chainId: { type: ["integer", "null"] },
+        amountBaseUnits: baseUnits("What was paid, echoed from the request."),
+        settlementId: {
+            type: ["string", "null"],
+            pattern: WORD_PATTERN,
+            description: "The Settlement's identity from the receipt. Null on a dry run, and null when the receipt was not awaited.",
+        },
+        appliedBaseUnits: nullableString("How much lowered the Open Tab, from the receipt."),
+        prepaidBaseUnits: nullableString("How much was banked as prepaid credit, from the receipt."),
+        explorerUrl: nullableString("The transaction on the Monad explorer."),
+        error: ERROR_SCHEMA,
+    },
+    required: ["ok", "dryRun", "amountBaseUnits"],
+    additionalProperties: false,
+};
+const READ_ONLY = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+};
+export const TAB_TOOLS = [
+    {
+        name: "tab_discover",
+        title: "Discover Tab Services",
+        description: "Lists Services registered on Monad, with the Assets each accepts, what each tool costs, and how much stake each has posted. Read-only and keyless. Start here: tab_call needs a serviceId from this list.",
+        inputSchema: TAB_DISCOVER_INPUT,
+        outputSchema: TAB_DISCOVER_OUTPUT,
+        annotations: READ_ONLY,
+    },
+    {
+        name: "tab_call",
+        title: "Call a metered tool",
+        description: "Calls a tool on a Service. Nothing is paid at call time: the charge lands on the Agent's Open Tab and is settled later with tab_settle. When the Agent has no headroom the call returns ok false with code LIMIT_EXCEEDED and both requiredBaseUnits and headroomBaseUnits, which is the signal to settle rather than retry. If tab.config declares an x402 signer and the Service offered x402 on that refusal, the call is prepaid instead and the output carries an x402 block naming the transaction.",
+        inputSchema: TAB_CALL_INPUT,
+        outputSchema: TAB_CALL_OUTPUT,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: "tab_status",
+        title: "Read the Agent's credit picture",
+        description: "Reports the Agent's Credit Limit, Open Tab, prepaid credit and headroom per Asset, plus its recent Settlements. Read-only and keyless.",
+        inputSchema: TAB_STATUS_INPUT,
+        outputSchema: TAB_STATUS_OUTPUT,
+        annotations: READ_ONLY,
+    },
+    {
+        name: "tab_settle",
+        title: "Settle an Open Tab",
+        description: "Pays down an Open Tab by sending a Settlement on Monad with the Agent's own key. This spends real funds. Set dryRun to build and check the Settlement without sending it.",
+        inputSchema: TAB_SETTLE_INPUT,
+        outputSchema: TAB_SETTLE_OUTPUT,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    },
+];
+/** The tool names, in the order `tools/list` serves them. */
+export const TAB_TOOL_NAMES = TAB_TOOLS.map((tool) => tool.name);
+export const tabToolByName = (name) => TAB_TOOLS.find((tool) => tool.name === name);
+//# sourceMappingURL=schemas.js.map