addrbookFor publishers
← The evidence ledger

Evidence row 258008

Observed , by probe.mcp/1.

Kind
mcp.tools
About
endpoint d908f896-b033-475f-9038-e157db1a1c1d
Recorded
Previous row
None: the first of its kind about this subject
Body SHA-256
bff818f31c938c235c82a4733aea4199d64e9ad033cdb17b470a8dc5eb91bd4c
Leaf
0xb812abd069f21eeba7cbf245ee79902a1ba38b23e7ed1d6d45382fc4281d3d4c

What was observed

{
  "count": 44,
  "tools": [
    {
      "description": "Analyze source files directly and generate the full 152-artifact AXIS bundle without using GitHub. Returns snapshot_id plus artifact listing; use this for local, generated, or unsaved code. Requires Authorization: Bearer <api_key>. Pricing: $3.00 standard, $25 engineer per run (same tiers as analyze_repo). Lite mode is retired — it now returns the free artifact set at no charge. Can return authentication, quota, payment-required, file-limit, or validation errors. Use analyze_repo for GitHub URLs or improve_my_agent_with_axis for recommendation-first agent hardening.",
      "inputSchema": {
        "properties": {
          "files": {
            "description": "Source files to analyze",
            "items": {
              "properties": {
                "content": {
                  "description": "File content (UTF-8)",
                  "type": "string"
                },
                "path": {
                  "description": "File path relative to project root",
                  "type": "string"
                }
              },
              "required": [
                "path",
                "content"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "frameworks": {
            "description": "Detected or known frameworks",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "goals": {
            "description": "Analysis goals",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "project_name": {
            "description": "Name of the project",
            "type": "string"
          },
          "project_type": {
            "description": "Project type (web_application, api_service, cli_tool, library, monorepo)",
            "type": "string"
          }
        },
        "required": [
          "project_name",
          "project_type",
          "frameworks",
          "goals",
          "files"
        ],
        "type": "object"
      },
      "name": "analyze_files"
    },
    {
      "description": "Analyze a GitHub repository and generate 152 structured AXIS artifacts across 21 programs. Returns snapshot_id plus an artifacts listing; use get_artifact to read files and get_snapshot to re-enumerate outputs without re-running analysis. Requires Authorization: Bearer <api_key>. Use this when the source of truth is a GitHub repo URL. Pricing: $3.00 standard, $25 engineer per repo. Lite mode is retired — it now returns the free artifact set at no charge. Engineer mode (X-Agent-Mode: engineer — Living Architecture) adds a verified LLM specificity pass: a living-architecture.md whose every architectural claim is grounded in the repo's extracted facts or dropped. This is the paid path for full repo analysis and can return authentication, quota, payment-required, invalid-URL, or GitHub-fetch errors. private repos require a stored GitHub token. Use analyze_files instead for inline file payloads or list_programs/search_and_discover_tools when you are still selecting a workflow.",
      "inputSchema": {
        "properties": {
          "github_url": {
            "description": "GitHub repository URL (https://github.com/owner/repo)",
            "type": "string"
          }
        },
        "required": [
          "github_url"
        ],
        "type": "object"
      },
      "name": "analyze_repo"
    },
    {
      "description": "Assemble a Visa Compelling Evidence 3.0 packet + eligibility verdict for a disputed card-absent-fraud (reason code 10.4) transaction using the real assembleCe3 engine: finds prior undisputed transactions in the caller-supplied history that share >=2 qualified data elements (device_id / ip_address / email / shipping_address / login_id) and fall 120-365 days before the disputed transaction, per CE 3.0 rules. Returns {eligible, qualifying_priors, matched_element_union, rejection_reason?, evidence_packet, caveat} plus a sha256 reproducibility proof. Free, no auth, deterministic, no side effects. HONESTY: CE 3.0 applies to reason code 10.4 ONLY (10.2/10.3 are card-present conditions), and this is ASSEMBLY ONLY — not a submission to VROL/Verifi (use assemble_representment for the Stripe representment path). AXIS does not publish win-rate estimates.",
      "inputSchema": {
        "properties": {
          "dispute": {
            "description": "{txn: {id, amount_minor, currency, created_at, disputed, device_id?, ip_address?, email?, shipping_address?, login_id?}, reason_code: string (CE 3.0 requires '10.4'), disputed_at: ISO timestamp}",
            "type": "object"
          },
          "transaction_history": {
            "description": "Candidate prior transactions (same Txn shape, max 500). Undisputed priors sharing >=2 qualified elements qualify.",
            "type": "array"
          }
        },
        "required": [
          "dispute"
        ],
        "type": "object"
      },
      "name": "assemble_ce3_evidence"
    },
    {
      "description": "Turn a webhook-ingested dispute (charge.dispute.* events persist DisputeRecords server-side) into a Stripe representment: qualifies CE 3.0 priors from your supplied transaction history (assembleCe3), builds the Stripe `evidence` hash (buildStripeRepresentment), walks the dispute state machine (needs_response → evidence_assembling → evidence_submitted) with a full transition ledger, and — when submit=true and Stripe is configured — submits the evidence through the live Stripe disputes API. Requires Authorization: Bearer <api_key>; metered ($1.00 standard, $0.50 lite) through the standard authorize/capture path — a failed assembly never charges. Returns {dispute, evidence, ce3, ce3_eligible, submitted, disclaimer}. HONESTY: the dispute lifecycle is LIVE on the Stripe rail only; VROL/RDR/CDRN (Verifi/Ethoca) is integration-ready code gated on acquirer provisioning (AXIS_ENABLE_VROL) and never fakes a submission. AXIS does not publish win-rate estimates.",
      "inputSchema": {
        "properties": {
          "dispute_id": {
            "description": "Provider dispute id (Stripe dp_...) previously ingested by the charge.dispute.created webhook.",
            "type": "string"
          },
          "disputed_txn": {
            "description": "Optional CE 3.0 data elements of the disputed transaction: {device_id?, ip_address?, email?, shipping_address?, login_id?}.",
            "type": "object"
          },
          "evidence_inputs": {
            "description": "{customerEmail?, shippingAddress?, billingAddress?, serviceDate?, productDescription?, deliveryTracking?, threeDsAuthenticated?} — merchant-supplied evidence fields.",
            "type": "object"
          },
          "submit": {
            "description": "true → submit the built evidence to the Stripe disputes API (requires STRIPE_SECRET_KEY server-side). Default false (assemble only).",
            "type": "boolean"
          },
          "transaction_history": {
            "description": "Candidate prior transactions for CE 3.0 qualification (Txn shape, max 500).",
            "type": "array"
          }
        },
        "required": [
          "dispute_id"
        ],
        "type": "object"
      },
      "name": "assemble_representment"
    },
    {
      "description": "Compare two avatar contracts; returns similarity score and section-level diffs. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.",
      "inputSchema": {
        "properties": {
          "file_a": {
            "description": "Path to first mesh file",
            "type": "string"
          },
          "file_b": {
            "description": "Path to second mesh file",
            "type": "string"
          },
          "sections": {
            "description": "Limit comparison to specific contract sections",
            "type": "array"
          }
        },
        "required": [
          "file_a",
          "file_b"
        ],
        "type": "object"
      },
      "name": "axis_compare"
    },
    {
      "description": "Inspect an avatar's contract state and provenance chain. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.",
      "inputSchema": {
        "properties": {
          "file_path": {
            "description": "Path to mesh file (.glb, .obj, .stl, etc.)",
            "type": "string"
          }
        },
        "required": [
          "file_path"
        ],
        "type": "object"
      },
      "name": "axis_inspect"
    },
    {
      "description": "Verify an export manifest's integrity and optionally check content hash. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.",
      "inputSchema": {
        "properties": {
          "expected_hash": {
            "description": "Expected content hash for verification",
            "type": "string"
          },
          "manifest": {
            "description": "Export manifest JSON object",
            "type": "object"
          }
        },
        "required": [
          "manifest"
        ],
        "type": "object"
      },
      "name": "axis_manifest_verify"
    },
    {
      "description": "Validate an avatar mesh against 38 rules; returns pass/warn/fail counts. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.",
      "inputSchema": {
        "properties": {
          "file_path": {
            "description": "Path to mesh file (.glb, .obj, .stl, etc.)",
            "type": "string"
          },
          "platform": {
            "description": "Target platform for platform-specific validation",
            "enum": [
              "unity",
              "unreal",
              "godot",
              "roblox",
              "axis_engine"
            ],
            "type": "string"
          },
          "profile": {
            "description": "Validation strictness profile",
            "enum": [
              "default",
              "strict",
              "lenient"
            ],
            "type": "string"
          }
        },
        "required": [
          "file_path"
        ],
        "type": "object"
      },
      "name": "axis_validate"
    },
    {
      "description": "Validate, canonically encode, and optionally Ed25519-sign an AP2 mandate (Intent / Cart / Payment) using the real @axis/ap2 codecs — schema validation (including cart-total arithmetic and intent cross-references), RFC 8785 JCS-style canonical JSON encoding, and detached-JWS EdDSA signing over node:crypto. Pass seed_hex (64 hex chars = 32 bytes) to sign deterministically client-side-supplied key material — AXIS stores no keys; omit it for an unsigned template with encoding only. The signed envelope round-trips through verifyMandate before it is returned. Free, no auth, deterministic (Ed25519 signatures are deterministic per RFC 8032), no side effects. SCOPE HONESTY: conformant to AXIS's TypeScript encoding of the public AP2 mandate schema, verified against self-authored golden vectors — NOT certified against an official AP2 conformance suite or a live network counterparty.",
      "inputSchema": {
        "properties": {
          "intent_context": {
            "description": "Optional IntentMandate to cross-reference a cart's intent_ref against.",
            "type": "object"
          },
          "mandate": {
            "description": "An AP2 mandate object: {kind: 'intent'|'cart'|'payment', version: 'ap2/1', id, created_at, ...kind-specific fields (intent: user_id/description/constraints.max_amount/expires_at; cart: intent_ref/merchant_id/items[]/total; payment: cart_ref/method/amount)}.",
            "type": "object"
          },
          "seed_hex": {
            "description": "Optional 64-char hex (32-byte) Ed25519 seed to sign with. Caller-supplied key material — AXIS stores no keys. Omit for an unsigned template.",
            "type": "string"
          }
        },
        "required": [
          "mandate"
        ],
        "type": "object"
      },
      "name": "build_ap2_mandate"
    },
    {
      "description": "Package an existing AXIS snapshot (create one first via analyze_repo, analyze_files, or prepare_agentic_purchasing) into complete professional packaging + marketplace certification artifacts so a 70-80%-complete project is ready to ship and sell. Requires Authorization: Bearer <api_key> on an ALREADY-PAID Starter/Pro/Growth (or suite) account. Unlike most metered AXIS tools, a free-tier account cannot unlock this per call with an MPP payment credential — there is no pay-per-call path here, only 'upgrade at iliad.trustfabric.ai/billing'. Once unlocked, billed $1.00 per call from the account's plan credits. Lite mode carries no discount here — the bundle is identical in both modes.",
      "inputSchema": {
        "properties": {
          "product_name": {
            "description": "Optional branding override for product name",
            "type": "string"
          },
          "project_root": {
            "description": "Optional local project root path hint (metadata only in remote MCP mode)",
            "type": "string"
          },
          "snapshot_id": {
            "description": "Existing AXIS snapshot_id to package into a distributable product",
            "type": "string"
          },
          "tagline": {
            "description": "Optional branding tagline",
            "type": "string"
          },
          "target_marketplaces": {
            "description": "Optional marketplaces list (e.g. npm, unreal, vscode, dockerhub, github-marketplace)",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "snapshot_id"
        ],
        "type": "object"
      },
      "name": "closer"
    },
    {
      "description": "Permanently delete a snapshot and everything derived from it (context map, repo profile, generated artifacts, search index entries). Same account scoping as get_snapshot: an anonymous (never-authenticated) snapshot is freely deletable by any caller, but an account-owned one requires the same Authorization: Bearer <api_key> used to create it — a mismatched or missing key fails with the same not-found error a nonexistent snapshot_id would, so a caller can't learn whether a snapshot they don't own even exists. This cannot be undone. MCP-layer equivalent of DELETE /v1/snapshots/:id.",
      "inputSchema": {
        "properties": {
          "snapshot_id": {
            "description": "Snapshot ID returned by analyze_repo, analyze_files, or get_snapshot",
            "type": "string"
          }
        },
        "required": [
          "snapshot_id"
        ],
        "type": "object"
      },
      "name": "delete_snapshot"
    },
    {
      "description": "Generate a zero-pipeline-minutes deploy bundle: stack-aware Dockerfile, .dockerignore, dev compose, render.yaml (Render existing-image), wrangler.pages.toml + wrangler.containers.toml + worker.ts (Cloudflare), bash/PowerShell push scripts, and a qualification report. The project builds locally in VSCode, pushes images to GHCR or via wrangler, and Render/Cloudflare just pulls — no GitHub Actions minutes, no Render build pipeline minutes, no CF build minutes. Requires Authorization: Bearer <api_key> on an ALREADY-PAID Starter/Pro/Growth (or suite) account. Unlike most metered AXIS tools, a free-tier account cannot unlock this per call with an MPP payment credential — there is no pay-per-call path here, only 'upgrade at iliad.trustfabric.ai/billing'. Once unlocked, billed $1.00 per call from the account's plan credits. Lite mode carries no discount here — the bundle is identical in both modes.",
      "inputSchema": {
        "properties": {
          "snapshot_id": {
            "description": "Existing AXIS snapshot_id to package into deploy artifacts",
            "type": "string"
          }
        },
        "required": [
          "snapshot_id"
        ],
        "type": "object"
      },
      "name": "deploy"
    },
    {
      "description": "Discover the best AXIS workflow for a purchasing or compliance task. Free, no auth, and logs lightweight task metadata for intent analytics. Example: task_description='prepare for autonomous Visa checkout'. Use this when you need commerce-specific triage and next-step guidance. Use search_and_discover_tools instead for non-commerce keyword routing across all programs.",
      "inputSchema": {
        "properties": {
          "current_readiness": {
            "description": "Optional: current Purchasing Readiness Score (0-100) if known",
            "type": "number"
          },
          "focus_areas": {
            "description": "Optional: specific areas to focus on",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "task_description": {
            "description": "What the agent is trying to accomplish",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "discover_agentic_purchasing_needs"
    },
    {
      "description": "List sibling AXIS properties (payments via PAI'D, 3D avatar generation via AXIS Foundry, and more) — each entry gives its own MCP endpoint, auth mode, and vendored tool prices, so you can call them directly. Free, no auth, no side effects. Same data as GET /.well-known/axis-estate.json. Use this when the task needs a capability Iliad itself does not own (e.g. payment execution, 3D asset generation).",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "discover_estate_tools"
    },
    {
      "description": "Read one generated artifact by snapshot_id and path. Requires access to the snapshot and may return snapshot-not-found, invalid-path, or artifact-not-found errors. Example: snapshot_id=abc-123, path=AGENTS.md. Use this when you need the full text of one artifact. Use get_snapshot instead when you first need the artifact list.",
      "inputSchema": {
        "properties": {
          "path": {
            "description": "Artifact file path as returned in the artifacts list",
            "type": "string"
          },
          "snapshot_id": {
            "description": "Snapshot ID",
            "type": "string"
          }
        },
        "required": [
          "snapshot_id",
          "path"
        ],
        "type": "object"
      },
      "name": "get_artifact"
    },
    {
      "description": "Get AXIS install metadata, pricing, and a shareable manifest for onboarding a new integration — MCP endpoint, per-client config for Claude Desktop/Cursor/VS Code, and the full tool catalog with pricing. Free, no auth, and no mutation beyond read access. Example: call before wiring AXIS into an MCP client for the first time. Use this when you need setup/ecosystem details, not tool discovery. Use search_and_discover_tools instead for keyword routing across programs, or discover_agentic_purchasing_needs for purchasing-task triage.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "get_install_manifest"
    },
    {
      "description": "Get or create the caller's AXIS referral token. Requires Authorization: Bearer <api_key>, has no usage charge, and may persist a new referral code if one does not exist yet. Example: call before sharing AXIS with another agent or workspace. Use this when you need the shareable token itself. Use get_referral_credits instead when you need balances, milestones, and discount status.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "get_referral_code"
    },
    {
      "description": "Get the caller's referral earnings, milestones, and free-call status. Requires Authorization: Bearer <api_key>, has no usage charge, and returns the current discount ledger without creating a new analysis. Example: call after a referral campaign to inspect earned credits. Use this when you need balances and milestones. Use get_referral_code instead when you only need the shareable token.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "get_referral_credits"
    },
    {
      "description": "Retrieve status and the full artifact listing for a prior analysis by snapshot_id. Use this to re-enumerate artifact paths without re-running analysis. Snapshots created with an API key are scoped to that same account — pass the same Authorization: Bearer <api_key> used to create it, or retrieval fails with a not-found error. Only anonymous (never-authenticated) snapshots are freely retrievable by any caller. The response's content_discarded_at is non-null if the owning account's web session has since logged out — source content is gone (closer/deploy/skills/search_index calls on this snapshot will fail with content_discarded until it's re-uploaded), though this call itself still succeeds and generated artifacts remain listable. Use delete_snapshot to permanently remove a snapshot you no longer need.",
      "inputSchema": {
        "properties": {
          "snapshot_id": {
            "description": "Snapshot ID returned by analyze_repo or analyze_files",
            "type": "string"
          }
        },
        "required": [
          "snapshot_id"
        ],
        "type": "object"
      },
      "name": "get_snapshot"
    },
    {
      "description": "Run the real 8-check AP2/Visa compliance grading engine (gradeCompliance — the same engine behind computeComplianceGrade and the commerce registry's verified_decisions block) over an inline file set. Each of the 8 validators (SCA/3DS2 readiness, AP2 mandate validity, tokenization posture, CE 3.0 readiness, dispute rail wiring, idempotency/receipt hygiene, budget negotiation, refund/cancel path) is a multi-signal check with weight, evidence trail, and remediation. Returns grade A-D, score, checks_passed/8, the full checks[] detail, detected commerce signals, and a sha256 reproducibility proof. Free, no auth, deterministic, no snapshot persisted. Hard caps: 25 files / 50KB per file / 1MB total. HONESTY: deterministic static source-signal analysis — a checklist starting point, NOT a certification, audit, PCI assessment, or card-network certification.",
      "inputSchema": {
        "properties": {
          "files": {
            "description": "Source files to grade (max 25 files, 50KB each, 1MB total)",
            "items": {
              "properties": {
                "content": {
                  "type": "string"
                },
                "path": {
                  "type": "string"
                }
              },
              "required": [
                "path",
                "content"
              ],
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "files"
        ],
        "type": "object"
      },
      "name": "grade_compliance"
    },
    {
      "description": "AXIS-owned product analytics. Two operations: `capture` (insert events) and `query` (aggregations). Capture accepts a single `event` or a batch via `events[]` (max 500). Query kinds: `count` (total events), `count_by_event` (top events by frequency), `distinct_users` (unique user_id count), `count_by_bucket` (time-series with minute/hour/day buckets). All queries support optional `event`, `from_ts`, `to_ts`, and `property_filter` filters. Namespaces are account-scoped server-side (`acct:<account_id>:<namespace>`). Persistent across restarts via Postgres (the shared @axis/snapshots database). Pricing: $0.01 standard, free in lite mode. Requires Authorization: Bearer <api_key>. Best for funnels, cohorts, and retention on workloads up to ~1M events per account.",
      "inputSchema": {
        "properties": {
          "event": {
            "description": "Single event payload {event, user_id?, properties?, timestamp?} — used in capture mode.",
            "type": "object"
          },
          "events": {
            "description": "Batch of event payloads (max 500). Transactional — partial inserts never persist.",
            "type": "array"
          },
          "namespace": {
            "description": "Logical isolation key. Defaults to 'default'. Account id is always prepended server-side.",
            "type": "string"
          },
          "operation": {
            "description": "capture or query.",
            "enum": [
              "capture",
              "query"
            ],
            "type": "string"
          },
          "query": {
            "description": "{kind, event?, from_ts?, to_ts?, property_filter?, bucket?, limit?} — used in query mode.",
            "type": "object"
          }
        },
        "required": [
          "operation"
        ],
        "type": "object"
      },
      "name": "iliad_analytics"
    },
    {
      "description": "AXIS-owned secure code execution. Each call spawns a fresh ephemeral Docker container with hardened isolation: no network, read-only root filesystem, all Linux capabilities dropped, no-new-privileges, PID/memory/CPU limits, tmpfs /tmp only, runs as nobody:nobody. Container is force-removed after each call. Supports python | node | bash via the multi-runtime image `nikolaik/python-nodejs:python3.12-nodejs22-slim` (operator can override via AXIS_CODE_SANDBOX_IMAGE). Returns stdout/stderr/exit_code/timed_out/duration_ms/image. Wall-clock timeout enforced via SIGKILL + force-remove. Source is fed via stdin (no fs write to the read-only root). Code body capped at 256 KiB; stdin at 1 MiB; timeout 1-600 seconds (default 30); stdout/stderr each capped at 1 MiB output. Pricing: $0.05 standard, $0.02 lite — billed whenever a container actually ran, including a timeout or non-zero exit code. Not billed when the call instead returns `_not_configured: true`: no Docker daemon reachable (Render standard services don't expose /var/run/docker.sock), the operator has set AXIS_CODE_SANDBOX_DISABLED=1, or more than AXIS_SANDBOX_MAX_CONCURRENT (default 4) runs are already in flight (reason sandbox_busy — transient, retry shortly). Engineer mode (X-Agent-Mode: engineer — Verified Exec, $0.25): the result includes an Ed25519-signed attestation binding code-hash → output-hash + a per-account hash-chain entry, so another agent that pins AXIS's published key can verify the run without re-executing it. Requires Authorization: Bearer <api_key>.",
      "inputSchema": {
        "properties": {
          "code": {
            "description": "Source code to execute. Fed via stdin to the interpreter. Max 256 KiB.",
            "type": "string"
          },
          "language": {
            "description": "Runtime language.",
            "enum": [
              "python",
              "node",
              "bash"
            ],
            "type": "string"
          },
          "stdin": {
            "description": "Optional additional stdin appended after the code body. Max 1 MiB.",
            "type": "string"
          },
          "timeout_seconds": {
            "description": "Wall-clock limit. Defaults 30, max 600. SIGKILL on overrun.",
            "type": "number"
          }
        },
        "required": [
          "language",
          "code"
        ],
        "type": "object"
      },
      "name": "iliad_code_sandbox"
    },
    {
      "description": "AXIS-owned document → Markdown extractor. Accepts either `document_url` (https fetch + 50 MiB cap + 60s timeout) or `document_base64` (inline bytes, 50 MiB decoded cap) — exactly one. Optional `mime_type` hint (application/pdf, application/vnd.openxmlformats-officedocument.wordprocessingml.document, text/html, text/markdown, text/plain); we sniff from magic bytes + URL extension when omitted. Format dispatch: PDF → pdfjs-dist text extraction (one block per page with `--- page N ---` separators); DOCX → mammoth → markdown (tables preserved); HTML → tag-strip with heading + list + entity handling (NOT a full HTML→MD converter — bring turndown if you need fancier); plain text + markdown → passthrough. Returns `{markdown, format_detected, byte_size, page_count, table_count, truncated}`. Output capped at 1 MiB markdown with a truncation marker. Pricing: $0.02 standard, $0.01 lite. Engineer mode (X-Agent-Mode: engineer — Document Intelligence, $0.10): adds an `engineer` block with retrieval chunks (heading-aware, overlapping) + extract-to-caller-schema (pass `json_schema` → a grammar-constrained, validated typed object) + image OCR (image/* via document_base64, capped at 10 MiB — smaller than the 50 MiB document cap; an OCR failure or oversized image returns a descriptive `reason` that may not match the standard-mode enum) — typed data, not just markdown. document_url accepts a signed GET URL minted by iliad_object_storage; chain the extracted markdown into iliad_embeddings + iliad_vector_database to build a RAG index. Requires Authorization: Bearer <api_key>.",
      "inputSchema": {
        "properties": {
          "document_base64": {
            "description": "Base64-encoded document bytes. Use this OR document_url, not both.",
            "type": "string"
          },
          "document_url": {
            "description": "https URL to a document. Use this OR document_base64, not both.",
            "type": "string"
          },
          "json_schema": {
            "description": "Engineer mode: a JSON Schema. The document is extracted into a validated object matching it (returned in engineer.extracted).",
            "type": "object"
          },
          "mime_type": {
            "description": "Optional MIME-type hint. When omitted we sniff from magic bytes + URL extension. Engineer mode: an image/* mime triggers OCR.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "iliad_document_parsing"
    },
    {
      "description": "Convert text into dense vectors. Accepts a single string or a batch (max 2048). Returns one vector per input. AXIS-owned in-process inference by default (node-llama-cpp + an embedding-capable GGUF at AXIS_EMBEDDING_MODEL_PATH — no upstream provider call); an optional OpenAI /v1/embeddings backend is available behind AXIS_EMBEDDING_BACKEND=openai (model: text-embedding-3-small by default, overridable via OPENAI_EMBEDDING_MODEL; reports token usage). Requires Authorization: Bearer <api_key> to call. Pricing: $0.05 standard, $0.02 lite. When the selected backend is not provisioned (local: GGUF file absent; openai: OPENAI_API_KEY unset), returns a structured `_not_configured: true` envelope naming the backend and remediation, and is not billed. Pairs natively with iliad_vector_database — feed `vectors` from this tool's output into `vector` of the vector_database upsert/query calls. Engineer mode (X-Agent-Mode: engineer — Domain Embeddings, $0.08): pass `dimensions` (Matryoshka truncation → smaller vectors) and/or `corpus_adapter: true` (mean-center the batch to sharpen retrieval on your data); returns an `engineer` block with the fitted adapter_mean for query alignment.",
      "inputSchema": {
        "properties": {
          "corpus_adapter": {
            "description": "Engineer mode: mean-center the batch (all-but-the-mean) to sharpen retrieval; returns the fitted adapter_mean.",
            "type": "boolean"
          },
          "dimensions": {
            "description": "Engineer mode: truncate each vector to this many leading dims (Matryoshka) + renormalize. Smaller, cheaper vectors.",
            "type": "number"
          },
          "input": {
            "description": "A single string or an array of strings to embed. Empty strings and entries > 32k chars are rejected (chunk before calling).",
            "type": [
              "string",
              "array"
            ]
          }
        },
        "required": [
          "input"
        ],
        "type": "object"
      },
      "name": "iliad_embeddings"
    },
    {
      "description": "AXIS-owned workspace hygiene grader. Analyzes an inline file set [{path,content}] and returns a letter grade (A-F) across a closed set of dimensions plus structured findings. Two modes: mode='scan' (DEFAULT, FREE) returns grade + findings (committed-secret scan, .env/secret-file detection, .gitignore gaps for build/scratch artifacts, oversized blobs, stub/placeholder markers, byte-identical duplicate files, source test-peer coverage, TODO/FIXME debt); mode='fix' (METERED, $0.05 standard / $0.02 lite) adds a prioritized remediation plan with ready-to-apply .gitignore additions and per-finding actions. Sending X-Agent-Mode: engineer always bills the fix-mode price, even if mode is 'scan' or omitted. Deterministic, dependency-free, never mutates your repo (fix returns a PLAN). Rules needing a live git checkout/toolchain (worktree pruning, build/vet, governance-source-of-truth checks, route-registration dup-handler analysis, ROI-queue coherence) are reported as repo_only_rules, not run. Engineer mode (X-Agent-Mode: engineer — Security Engineer, $5): the fix arrives as a git-applyable unified-diff patch (`patch`) + a SARIF 2.1.0 log for CI code-scanning (`sarif`). Requires Authorization: Bearer <api_key>.",
      "inputSchema": {
        "properties": {
          "config": {
            "description": "Optional threshold overrides: maxFileBytes, coverageA, coverageB, coverageC, todoDebtThreshold.",
            "type": "object"
          },
          "files": {
            "description": "Inline files [{path, content}] to scan (non-empty; each content <= 5 MB).",
            "type": "array"
          },
          "mode": {
            "description": "scan (free grade+findings, default) | fix (metered, adds remediation plan).",
            "enum": [
              "scan",
              "fix"
            ],
            "type": "string"
          }
        },
        "required": [
          "files"
        ],
        "type": "object"
      },
      "name": "iliad_hygiene"
    },
    {
      "description": "AXIS-hosted LLM chat-completion via node-llama-cpp + a small GGUF model loaded in-process. Two input shapes accepted: `prompt` (single string) or `messages` (chat-style array of {role, content}). Sampling controls: `max_tokens` (≤2048), `temperature` (0-2), `top_k`, `top_p`, `seed` (threaded through for more deterministic output — NOT a proven byte-identical guarantee; thread count isn't pinned and GGML's multi-threaded matmul reduction order isn't guaranteed bit-exact across runs), `stop` (string[]). Inference runs in-process — no upstream LLM provider call — but this AXIS tool call is still billed: $0.02 standard, $0.01 lite. Operator sets AXIS_LLM_MODEL_PATH to point at a Phi-3-mini / TinyLlama / Llama-3.2-1B GGUF; if missing, the tool returns a `_not_configured: true` envelope and is not billed. Engineer mode (X-Agent-Mode: engineer — Constrained Inference, $0.10): pass a `json_schema` and decoding is grammar-constrained to it AND the output is validated against it (returns a `structured` block with valid + parsed + schema_errors) — guaranteed-valid structured output. Requires Authorization: Bearer <api_key>.",
      "inputSchema": {
        "properties": {
          "json_schema": {
            "description": "Engineer mode (required): a JSON Schema. Decoding is grammar-constrained to it and the output is validated against it; returns a `structured` block.",
            "type": "object"
          },
          "max_tokens": {
            "description": "Max tokens to generate. Defaults 512, hard cap 2048.",
            "type": "number"
          },
          "messages": {
            "description": "Chat-style input. Array of {role: system|user|assistant, content: string}.",
            "type": "array"
          },
          "prompt": {
            "description": "Single-prompt completion input. Use either this OR messages, not both.",
            "type": "string"
          },
          "seed": {
            "description": "Optional seed, threaded through with temperature for more deterministic output. Not a proven byte-identical guarantee (thread count/matmul reduction order isn't pinned) — see the tool description.",
            "type": "number"
          },
          "stop": {
            "description": "Stop sequences. Generation halts when any string in the array is produced.",
            "type": "array"
          },
          "system": {
            "description": "Optional system prompt (prompt mode only). For messages mode, use role=system entries.",
            "type": "string"
          },
          "temperature": {
            "description": "Sampling temperature in [0, 2]. Defaults 0.7.",
            "type": "number"
          },
          "top_k": {
            "description": "Top-k sampling (positive integer). Defaults 40.",
            "type": "number"
          },
          "top_p": {
            "description": "Top-p nucleus sampling in (0, 1]. Defaults 0.95.",
            "type": "number"
          }
        },
        "type": "object"
      },
      "name": "iliad_llm_inference"
    },
    {
      "description": "Network-tokenization capability. (1) `lifecycle`: an EXECUTABLE TAP-style token-lifecycle state machine (provision → activate → suspend → resume → delete; deleted is terminal; illegal transitions are rejected with an error, not silently accepted) — pure simulation, no real payment method involved. (2) `capabilities` reports which providers are configured (env-derived). (3) `read` and (4) `provision` are TEMPORARILY DISABLED: both would resolve a caller-supplied payment_method_id/pan_source against the platform's Stripe account, and this service has no way yet to verify that id belongs to the calling AXIS account — calling either always returns a structured `_not_configured: true` envelope explaining this, never real payment-method data. (For context once re-enabled: `read`'s underlying Stripe adapter is fully implemented; direct VTS/MDES `provision` is additionally capability-gated behind a network-issued Token Requestor ID — AXIS_VTS_TOKEN_REQUESTOR_ID / AXIS_MDES_TOKEN_REQUESTOR_ID — plus network onboarding, and NEVER fakes a token.) Raw PANs are never accepted even when disabled (pan_source is documented as an opaque reference only). Free (unmetered); requires Authorization: Bearer <api_key>.",
      "inputSchema": {
        "properties": {
          "event": {
            "description": "lifecycle: single-event shorthand for `events: [event]`.",
            "type": "string"
          },
          "events": {
            "description": "lifecycle: ordered TokenEvent list (provision|activate|suspend|resume|delete), max 100. Must start from provision; illegal transitions throw.",
            "type": "array"
          },
          "operation": {
            "description": "read (default, disabled) | provision (disabled) | lifecycle | capabilities.",
            "enum": [
              "read",
              "provision",
              "lifecycle",
              "capabilities"
            ],
            "type": "string"
          },
          "pan_source": {
            "description": "provision: ignored — this operation is disabled and always returns _not_configured. NEVER a raw PAN in any case.",
            "type": "string"
          },
          "payment_method_id": {
            "description": "read: ignored — this operation is disabled and always returns _not_configured.",
            "type": "string"
          },
          "provider": {
            "description": "provision: ignored — this operation is disabled and always returns _not_configured.",
            "enum": [
              "stripe",
              "vts",
              "mdes"
            ],
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "iliad_network_tokenization"
    },
    {
      "description": "AXIS-owned signed-URL minter backed by Cloudflare R2. Returns a pre-signed PUT or GET URL scoped to the calling account (keys are prefixed with `accounts/<account_id>/` server-side, so accounts can't reach each other's objects). Requires Authorization: Bearer <api_key>. Returns the URL plus expires_at (ISO 8601), bucket, and scoped_key. Returns `{_not_configured: true, ...}` when the operator has not provisioned R2_* env vars (no crash, no leaked secrets); not billed when not configured. Pricing: $0.01 standard, free in lite mode. TTL is capped at 86400 seconds (24h). Engineer mode (X-Agent-Mode: engineer — Managed Bucket, $0.05): adds delete + list + copy (server-side, no bytes through the agent) operations, content-addressed dedup keys (content_sha256), and mint-time PUT policy (pin content_type / exact content_length as signed headers R2 enforces). A signed GET URL minted here can be passed directly as iliad_document_parsing's document_url or iliad_speech_to_text's audio_url.",
      "inputSchema": {
        "properties": {
          "content_length": {
            "description": "Engineer mode (put): pin the EXACT byte size the upload must be (signed; ≤5 GiB). Pairs with content_sha256 for verified content-addressed writes.",
            "type": "number"
          },
          "content_sha256": {
            "description": "Engineer mode: 64-char hex sha256 of the bytes you'll PUT. When set, the object lands under accounts/<id>/cas/<sha256> so identical content dedupes.",
            "type": "string"
          },
          "content_type": {
            "description": "Engineer mode (put): pin the Content-Type the upload must send (signed; R2 rejects a mismatch). Printable ASCII type/subtype, ≤255 chars. Echo via required_headers.",
            "type": "string"
          },
          "ext": {
            "description": "Engineer mode: optional extension appended to the content-addressed key (e.g. 'png').",
            "type": "string"
          },
          "key": {
            "description": "Object key (max 1024 chars), or the prefix for operation=list. Path traversal and leading-/ are rejected.",
            "type": "string"
          },
          "operation": {
            "description": "put / get (standard). delete / list / copy and content-addressed put require X-Agent-Mode: engineer (Managed Bucket).",
            "enum": [
              "put",
              "get",
              "delete",
              "list",
              "copy"
            ],
            "type": "string"
          },
          "source_key": {
            "description": "Engineer mode (operation=copy): source object key to copy from, scoped to your account; `key` is the destination. Echo the returned required_headers on the PUT.",
            "type": "string"
          },
          "ttl_seconds": {
            "description": "Signed-URL lifetime, 1..86400. Defaults to 3600.",
            "type": "number"
          }
        },
        "required": [
          "key",
          "operation"
        ],
        "type": "object"
      },
      "name": "iliad_object_storage"
    },
    {
      "description": "AXIS-owned audio transcription via whisper.cpp + ffmpeg-static. Accepts either `audio_url` (https URL we fetch, max 100 MiB, 60s download timeout) or `audio_base64` (inline bytes, max 100 MiB decoded) — exactly one. Accepts any audio format ffmpeg can decode (mp3, wav, m4a, opus, ogg, flac); we resample to 16 kHz mono WAV internally. Optional `language` (ISO-639-1 like \"en\" / \"fr\" / \"ja\", or \"auto\" — default). Optional `initial_prompt` (≤512 chars; biases spelling of rare names). Optional `word_timestamps` boolean. Returns `{text, segments: [{start, end, text}], language_detected, duration_seconds, model_used}`. Pricing: $0.03 standard, $0.01 lite. When operator hasn't installed whisper-cli or placed the GGML model file at AXIS_WHISPER_MODEL_PATH (default `models/ggml-base.en.bin`), returns `{_not_configured: true, reason, detail, remediation}` and is not billed. Engineer mode (X-Agent-Mode: engineer — Diarization, $0.10): the response adds `diarization` — speaker turns grouped from the segments by inter-segment pause gaps (tune with diarization_gap_seconds / max_speakers; this is pause-based turn segmentation, not acoustic speaker ID). Use iliad_text_to_speech to synthesize speech from text. Requires Authorization: Bearer <api_key>.",
      "inputSchema": {
        "properties": {
          "audio_base64": {
            "description": "Base64-encoded audio bytes. Use this OR audio_url, not both.",
            "type": "string"
          },
          "audio_url": {
            "description": "https URL to an audio file. Use this OR audio_base64, not both.",
            "type": "string"
          },
          "diarization_gap_seconds": {
            "description": "Engineer mode: pause (seconds) between segments that starts a new speaker turn. Defaults 0.75.",
            "type": "number"
          },
          "initial_prompt": {
            "description": "Optional bias prompt (≤512 chars) — useful for spelling of rare names.",
            "type": "string"
          },
          "language": {
            "description": "ISO-639-1 language code (en, fr, ja, ...) or 'auto' to autodetect. Defaults 'auto'.",
            "type": "string"
          },
          "max_speakers": {
            "description": "Engineer mode: max alternating speaker labels. Defaults 2.",
            "type": "number"
          },
          "word_timestamps": {
            "description": "Emit word-level timestamps within segments. Defaults false.",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "name": "iliad_speech_to_text"
    },
    {
      "description": "AXIS-owned voice synthesis via Piper (rhasspy/piper) + ffmpeg-static. Accepts `text` (1-5000 chars), optional `voice` slug (filename without extension; defaults to AXIS_PIPER_DEFAULT_VOICE or the first available voice), optional `format` (wav | mp3 | opus; defaults wav), optional `sentence_silence` (0-5 seconds, default 0.2). Returns `{audio_base64, format, voice_used, sample_rate, duration_seconds, byte_size}`. Inference runs in-process — no upstream provider call — but this AXIS tool call is still billed: $0.02 standard, $0.01 lite. When operator hasn't installed piper or placed voice .onnx + .onnx.json files in AXIS_PIPER_VOICE_DIR (default models/piper/), returns `{_not_configured: true, reason, detail, remediation}` and is not billed. format=mp3/opus additionally requires ffmpeg-static. Engineer mode (X-Agent-Mode: engineer — Brand Voice, $0.10): requires `brand_text` (a brand / voice-and-tone artifact — the call throws without it in engineer mode) and AXIS auto-derives the voice persona (Piper voice slug + sentence pacing) and synthesizes in it; the persona is echoed in the response. Use iliad_speech_to_text to transcribe audio back to text. Requires Authorization: Bearer <api_key>.",
      "inputSchema": {
        "properties": {
          "brand_text": {
            "description": "Required when X-Agent-Mode: engineer is set (the call throws without it); ignored otherwise. Brand / voice-and-tone artifact — AXIS derives a voice persona from it and synthesizes in that voice (overrides voice/sentence_silence).",
            "type": "string"
          },
          "format": {
            "description": "Audio codec.",
            "enum": [
              "wav",
              "mp3",
              "opus"
            ],
            "type": "string"
          },
          "gender": {
            "description": "Engineer mode: persona gender override.",
            "enum": [
              "female",
              "male"
            ],
            "type": "string"
          },
          "locale": {
            "description": "Engineer mode: persona locale override.",
            "enum": [
              "us",
              "gb"
            ],
            "type": "string"
          },
          "sentence_silence": {
            "description": "Per-sentence silence in seconds (0-5). Defaults 0.2.",
            "type": "number"
          },
          "text": {
            "description": "Text to speak. 1-5000 chars after trim.",
            "type": "string"
          },
          "voice": {
            "description": "Voice slug (filename without extension, e.g. 'en_US-amy-medium'). Defaults to first available voice or AXIS_PIPER_DEFAULT_VOICE.",
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "iliad_text_to_speech"
    },
    {
      "description": "Send a single transactional email. Requires Authorization: Bearer <api_key>. Provide either body_html, body_text, or both (Resend will pick the best variant per recipient). All emails ship from RESEND_FROM_ADDRESS — operator must verify that domain in Resend before sending. Returns the provider-assigned message_id plus the accepted recipient list. Pricing: $0.02 standard, $0.01 lite. Returns a structured _not_configured envelope when RESEND_API_KEY or RESEND_FROM_ADDRESS is missing, and is not billed. Recipients capped at 50 per call; subject capped at 998 chars; bodies capped at 1 MB. Engineer mode (X-Agent-Mode: engineer — Deliverability, $0.50): instead of sending, pass a `domain` and get a full SPF/DKIM/DMARC setup (fresh DKIM keypair) + sender warmup schedule + verification checklist — no email sent, no ESP key needed.",
      "inputSchema": {
        "properties": {
          "body_html": {
            "description": "HTML body. At least one of body_html / body_text required.",
            "type": "string"
          },
          "body_text": {
            "description": "Plaintext body. At least one of body_html / body_text required.",
            "type": "string"
          },
          "dkim_selector": {
            "description": "Engineer mode: DKIM selector (alphanumeric/hyphen, 1-32). Defaults 'axis'.",
            "type": "string"
          },
          "dmarc_policy": {
            "description": "Engineer mode: DMARC policy none|quarantine|reject. Defaults none (monitoring).",
            "type": "string"
          },
          "domain": {
            "description": "Engineer mode (Deliverability): domain to generate SPF/DKIM/DMARC setup for. Replaces the send.",
            "type": "string"
          },
          "provider": {
            "description": "Engineer mode: ESP for the SPF include (resend/sendgrid/mailgun/postmark/ses/google). Defaults resend.",
            "type": "string"
          },
          "reply_to": {
            "description": "Optional Reply-To address.",
            "type": "string"
          },
          "subject": {
            "description": "Email subject (max 998 chars, RFC 5322).",
            "type": "string"
          },
          "to": {
            "description": "Recipient address or array of addresses (max 50). Required for a send (standard mode).",
            "type": [
              "string",
              "array"
            ]
          }
        },
        "type": "object"
      },
      "name": "iliad_transactional_email"
    },
    {
      "description": "AXIS-owned vector store. Two operations: `upsert` (insert or replace vectors) and `query` (cosine top-k nearest neighbors). Namespaces are account-scoped server-side (`acct:<account_id>:<namespace>`), so tenants cannot read each other's vectors. Persistent across restarts via Postgres. Requires Authorization: Bearer <api_key>. Pricing: $0.01 standard, free in lite mode. Best for RAG retrievers, deduplication, and similarity search. Use iliad_embeddings to turn text into the vectors this tool stores and queries. Engineer mode (X-Agent-Mode: engineer — Managed Memory, $0.05): query runs a pgvector/HNSW ANN candidate pool with optional recency-decay reranking (recency_half_life_days — managed forgetting), RRF hybrid fusion (sparse_ids), and metadata filter; upsert applies intra-batch semantic-dedup (dedup_threshold).",
      "inputSchema": {
        "properties": {
          "dedup_threshold": {
            "description": "Engineer upsert: cosine threshold for intra-batch semantic-dedup (default 0.97).",
            "type": "number"
          },
          "namespace": {
            "description": "Logical isolation key. Defaults to 'default'. Account ID is always prepended server-side.",
            "type": "string"
          },
          "operation": {
            "description": "upsert (insert/replace) or query (top-k cosine).",
            "enum": [
              "upsert",
              "query"
            ],
            "type": "string"
          },
          "query": {
            "description": "{vector: number[], top_k?: number, filter?: object}. Engineer mode also reads recency_half_life_days (number — exponential recency decay) and sparse_ids (string[] — RRF hybrid fusion). Required for query.",
            "type": "object"
          },
          "semantic_dedup": {
            "description": "Engineer upsert: set false to disable dedup (default on).",
            "type": "boolean"
          },
          "vectors": {
            "description": "Array of {id, vector, metadata?} — required for upsert.",
            "type": "array"
          }
        },
        "required": [
          "operation"
        ],
        "type": "object"
      },
      "name": "iliad_vector_database"
    },
    {
      "description": "Scrape a single URL with AXIS's owned crawler (SSRF-guarded fetch, robots.txt-aware, readability extraction — no third-party key) and return markdown-formatted content. Honest scope: fetches static HTML only, no JavaScript rendering, so client-rendered SPA pages may extract thin content. Returns markdown body, extracted metadata, and title. Best for research, documentation reading, or SEO analysis. Requires Authorization: Bearer <api_key>. Pricing: $0.10 per page. Lite mode carries no discount here — the markdown output is identical in both modes. If the operator's backend configuration is incomplete, this call returns {_not_configured:true} instead of scraping, and is not billed. Use iliad_web_research_crawl for crawling multiple pages or link following. To make a scraped page searchable later, index it with iliad_web_search.",
      "inputSchema": {
        "properties": {
          "only_main_content": {
            "default": true,
            "description": "Extract only the main content (default: true)",
            "type": "boolean"
          },
          "url": {
            "description": "The URL to scrape (http or https)",
            "type": "string"
          }
        },
        "required": [
          "url"
        ],
        "type": "object"
      },
      "name": "iliad_web_research"
    },
    {
      "description": "Crawl a domain with AXIS's owned crawler — a same-origin BFS frontier with robots.txt compliance and per-host politeness, no third-party key — and scrape multiple pages. Honest scope: static HTML only, no JavaScript rendering. Returns array of scraped pages with markdown content. Best for site mapping, content audits, or bulk research. Requires Authorization: Bearer <api_key>. Pricing: $0.01/page beyond your account's shared 100-page/month free pool (standard and lite) — a crawl fully covered by the free pool costs $0.00; a fully-paid 100-page crawl costs up to $1.00. If the operator's backend configuration is incomplete, this call returns {_not_configured:true} instead of crawling, and is not billed. Use iliad_web_research for single-page scrapes. To make crawled pages searchable later, index them with iliad_web_search.",
      "inputSchema": {
        "properties": {
          "limit": {
            "default": 10,
            "description": "Maximum pages to crawl (1-100, default: 10)",
            "maximum": 100,
            "minimum": 1,
            "type": "number"
          },
          "url": {
            "description": "The domain/URL to crawl (http or https)",
            "type": "string"
          }
        },
        "required": [
          "url"
        ],
        "type": "object"
      },
      "name": "iliad_web_research_crawl"
    },
    {
      "description": "AXIS-owned BM25 search engine over the corpus YOUR account has indexed. NOT a Google/Bing scraper — agents build their own searchable index by first calling operation='index' with documents (often pages fetched via iliad_web_research), then querying with operation='search'. Five operations: `index` (insert one or many documents), `search` (BM25 top-k ranked hits with snippet + score + metadata), `delete` (drop one doc), `delete_namespace` (drop all), `count`. Namespaces are account-scoped server-side (`acct:<id>:<namespace>`). Persistent across restarts via Postgres (the shared @axis/snapshots database). Search supports `max_results` (default 10, max 100) and `site` (restrict to a single URL host, case-insensitive). Only operation='search' is billed ($0.01 standard, free in lite mode) — index, delete, delete_namespace, and count are always free. Engineer mode (X-Agent-Mode: engineer — Answer Engine, $0.25): search also returns a grounded extractive answer with [n] citation spans over your corpus, reranked, refusing on weak evidence. Requires Authorization: Bearer <api_key>.",
      "inputSchema": {
        "properties": {
          "doc_id": {
            "description": "Document id to remove. Required in delete mode.",
            "type": "string"
          },
          "document": {
            "description": "Single document {doc_id, url?, title?, content, metadata?} — used in index mode (alternative to documents[]).",
            "type": "object"
          },
          "documents": {
            "description": "Batch of documents (max 100). Transactional — malformed entry aborts the whole call.",
            "type": "array"
          },
          "max_results": {
            "description": "Cap on hits returned. Defaults 10, max 100.",
            "type": "number"
          },
          "namespace": {
            "description": "Logical isolation key. Defaults 'default'. Account id is always prepended server-side.",
            "type": "string"
          },
          "operation": {
            "description": "index | search | delete | delete_namespace | count.",
            "enum": [
              "index",
              "search",
              "delete",
              "delete_namespace",
              "count"
            ],
            "type": "string"
          },
          "query": {
            "description": "Search query (1-1024 chars). Required in search mode.",
            "type": "string"
          },
          "site": {
            "description": "Filter to a single URL host (e.g. 'docs.python.org', case-insensitive).",
            "type": "string"
          }
        },
        "required": [
          "operation"
        ],
        "type": "object"
      },
      "name": "iliad_web_search"
    },
    {
      "description": "Analyze an agent codebase and return a prioritized AXIS hardening plan. Requires Authorization: Bearer <api_key> but has no usage charge on any tier — free and unmetered, unlike most AXIS tools. This creates a snapshot and may return auth, quota, file-limit, or validation errors. Example: pass your agent source files to see missing AGENTS.md, CLAUDE.md, and MCP config gaps. Use this when you want recommendations and missing-context detection. Use analyze_files instead when you want the full artifact bundle directly (paid: $3.00 standard).",
      "inputSchema": {
        "properties": {
          "files": {
            "description": "Source files of the agent to analyze",
            "items": {
              "properties": {
                "content": {
                  "description": "File content (UTF-8)",
                  "type": "string"
                },
                "path": {
                  "description": "File path relative to project root",
                  "type": "string"
                }
              },
              "required": [
                "path",
                "content"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "project_name": {
            "description": "Name of the agent/project to improve",
            "type": "string"
          }
        },
        "required": [
          "project_name",
          "files"
        ],
        "type": "object"
      },
      "name": "improve_my_agent_with_axis"
    },
    {
      "description": "Inventory mode. List all 21 AXIS programs, their generators, pricing tier, and artifact paths. Free, no auth, and no side effects. Use search_and_discover_tools instead when you only have a keyword, or get_install_manifest when you need install and onboarding metadata.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "list_programs"
    },
    {
      "description": "Exercise the real x402 payment-flow loop at a nominal $0.01 — the cheapest metered call on this server, priced just above $0 so the probe can't be run up for free without limit. Call it once with no payment credential (no auth required) to receive a 402-style payment_required challenge (the exact same shape every real paid tool returns, and requesting it is itself free); retry the same tools/call carrying a payment credential in Authorization (with your API key moved to X-Axis-Key) to settle at $0.01 and get a success envelope. Learn the vocabulary here before paying real money for prepare_agentic_purchasing or analyze_repo. No side effects on any other tool, no real payment rail is ever touched.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "ping_payment"
    },
    {
      "description": "Prepare a codebase for agentic purchasing and return a readiness score plus commerce artifacts. Requires Authorization: Bearer <api_key>; paid analysis records a new snapshot and may return auth, quota, payment, file-limit, or validation errors. Pricing: $3.00 standard, $1.00 lite budget mode, $250 engineer per run. Lite mode returns the readiness score + top 3 gaps only, with an artifacts_note pointing at standard mode for the full artifact bundle — it does NOT include the artifacts themselves. Standard and engineer modes return the full bundle. focus_areas is recorded and echoed back in the response for the caller's own bookkeeping; it does not filter which artifacts are generated. Use this when you need AP2/UCP/Visa, CE 3.0 dispute evidence, checkout, dispute, and negotiation hardening. Engineer mode (X-Agent-Mode: engineer — Commerce Integration) also emits a deployable x402/AP2/PAI'D endpoint + a runnable sandbox test + a schema-validatable CE 3.0 pack + a transparent dispute-readiness score (a working integration, not just a score), plus a deployable Stripe network-token read adapter when a stripe signal is detected. Use discover_agentic_purchasing_needs instead when you only need workflow triage.",
      "inputSchema": {
        "properties": {
          "agent_type": {
            "description": "Consuming agent type hint",
            "type": "string"
          },
          "budget_per_run_cents": {
            "description": "Agent budget for this call in cents",
            "type": "number"
          },
          "files": {
            "description": "Array of {path, content} objects representing source files",
            "items": {
              "properties": {
                "content": {
                  "type": "string"
                },
                "path": {
                  "type": "string"
                }
              },
              "required": [
                "path",
                "content"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "focus": {
            "description": "Analysis focus (default: purchasing)",
            "enum": [
              "full",
              "purchasing",
              "security",
              "optimization"
            ],
            "type": "string"
          },
          "focus_areas": {
            "description": "Compliance focus areas, recorded and echoed back in the response for the caller's own reference — does not filter which artifacts are generated.",
            "items": {
              "enum": [
                "sca",
                "dispute",
                "mandate",
                "tap",
                "tokenization"
              ],
              "type": "string"
            },
            "type": "array"
          },
          "frameworks": {
            "description": "Detected or known frameworks",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "goals": {
            "description": "Project goals",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "project_name": {
            "description": "Name of the project",
            "type": "string"
          },
          "project_type": {
            "description": "Project type (web_application, api_service, cli_tool, library, monorepo)",
            "type": "string"
          },
          "referral_token": {
            "description": "Optional referral token from another agent",
            "type": "string"
          },
          "spending_window": {
            "description": "Agent spending window",
            "enum": [
              "per_call",
              "hourly",
              "daily",
              "monthly"
            ],
            "type": "string"
          }
        },
        "required": [
          "project_name",
          "project_type",
          "frameworks",
          "goals",
          "files"
        ],
        "type": "object"
      },
      "name": "prepare_agentic_purchasing"
    },
    {
      "description": "Compute a free Purchasing Readiness Score (0-100) and gap list for a codebase without generating artifacts. No auth, no charge, no snapshot persisted. Hard caps: 25 files / 50KB per file / 1MB total. Returns score, risk_level, top gaps, frameworks detected, and which AXIS programs would close which gaps. Use this to triage 'should I pay for the full hardening bundle?' before calling prepare_agentic_purchasing. The paid version generates the full artifact bundle including CE 3.0 dispute evidence, SCA exemption matrix, and TAP interop.",
      "inputSchema": {
        "properties": {
          "files": {
            "description": "Source files to triage (max 25 files, 50KB each, 1MB total)",
            "items": {
              "properties": {
                "content": {
                  "type": "string"
                },
                "path": {
                  "type": "string"
                }
              },
              "required": [
                "path",
                "content"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "frameworks": {
            "description": "Optional framework hints",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "project_name": {
            "description": "Name of the project being previewed",
            "type": "string"
          },
          "project_type": {
            "description": "Optional project type hint (web_application, api_service, cli_tool, library, monorepo)",
            "type": "string"
          }
        },
        "required": [
          "project_name",
          "files"
        ],
        "type": "object"
      },
      "name": "prepare_agentic_purchasing_preview"
    },
    {
      "description": "Run Roblox R15 compliance checks against a mesh. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.",
      "inputSchema": {
        "properties": {
          "file_path": {
            "description": "Path to mesh file (.glb, .obj, .stl, etc.)",
            "type": "string"
          }
        },
        "required": [
          "file_path"
        ],
        "type": "object"
      },
      "name": "roblox_compliance_check"
    },
    {
      "description": "Decide the lighter-SCA path for a single transaction using AXIS's published 7-priority PSD2 exemption matrix (the same decideScaExemption engine that renders the SCA Exemption Decision Matrix in generated artifacts). Input: amount_eur (required, PSD2 thresholds are EUR-denominated — convert before calling) plus optional context flags (secure corporate program, MIT, fixed recurring + prior SCA, trusted beneficiary + prior SCA, one-leg-out, acquirer TRA fraud rate in basis points). Returns the chosen exemption, its priority, sca_required, rationale, fallback path, all applicable candidates, the rendered priority matrix, and a sha256 reproducibility proof. Free, no auth, deterministic, no side effects. HONESTY: decision-support only, NOT an authorization oracle — final exemption eligibility is decided by the acquirer/issuer; TRA caps use published EBA RTS Art. 15 bands, not your acquirer's live fraud rate.",
      "inputSchema": {
        "properties": {
          "amount_eur": {
            "description": "Transaction amount in EUR (PSD2 thresholds are EUR-denominated).",
            "type": "number"
          },
          "has_prior_sca": {
            "description": "A prior SCA exists — gates recurring_fixed and trusted_beneficiary.",
            "type": "boolean"
          },
          "is_merchant_initiated": {
            "description": "MIT with stored credential + original SCA reference (out of SCA scope).",
            "type": "boolean"
          },
          "is_one_leg_out": {
            "description": "Payer or payee outside the EEA (territorial scope, not a formal exemption).",
            "type": "boolean"
          },
          "is_recurring_fixed": {
            "description": "Fixed-amount subsequent collection (RTS Art. 13). Requires has_prior_sca.",
            "type": "boolean"
          },
          "is_secure_corporate": {
            "description": "Dedicated/lodged corporate card program (RTS Art. 16).",
            "type": "boolean"
          },
          "is_trusted_beneficiary": {
            "description": "Merchant on the cardholder's trusted list (RTS Art. 12). Requires has_prior_sca.",
            "type": "boolean"
          },
          "tra_acquirer_fraud_bps": {
            "description": "Acquirer reference fraud rate in basis points (EBA RTS Art. 15 bands: <=1 → €500 cap, <=6 → €250, <=13 → €100).",
            "type": "number"
          }
        },
        "required": [
          "amount_eur"
        ],
        "type": "object"
      },
      "name": "sca_exemption_decision"
    },
    {
      "description": "Score how ready a disputed transaction's EVIDENCE FILE is for representment, per Visa reason-code family, using the transparent scoreWinProbability heuristic (win-prob-v0: hand-set, documented logistic coefficients — exported, inspectable, monotonic in evidence). Input: reason_code + the evidence on file (CE 3.0 eligibility, matching data elements, prior undisputed transactions, delivery proof, AVS/CVV, 3DS, signed mandate, customer communication). Returns the heuristic score, band, top missing evidence (what to capture next), recommended action, rationale, model version, and a sha256 reproducibility proof. Free, no auth, deterministic. HONESTY (read this): this scores evidence-capture readiness and is NOT a dispute-win prediction — the v0 heuristic is NOT empirically calibrated against real network outcomes, is NOT a Visa-published or Visa-endorsed win rate, and AXIS does not publish win-rate estimates. Treat it as a prioritization signal for evidence gathering only; always follow your operator's dispute policy.",
      "inputSchema": {
        "properties": {
          "evidence": {
            "description": "Evidence on file: {ce3Eligible?, matchingDataElements? (0-5), priorUndisputedTransactions? (0-10), hasDeliveryProof?, hasAvsMatch?, hasCvvMatch?, has3dsAuthenticated?, hasSignedMandate?, hasCustomerCommunication?}. Omitted fields default to false/0.",
            "type": "object"
          },
          "reason_code": {
            "description": "Visa dispute reason code (e.g. '10.4', '13.1', '12.5'). Unknown codes fall back to a documented default family.",
            "type": "string"
          }
        },
        "required": [
          "reason_code"
        ],
        "type": "object"
      },
      "name": "score_dispute_readiness"
    },
    {
      "description": "Search AXIS programs by keyword and return ranked matches with artifact paths. Free, no auth, and no stateful side effects. Example: q=checkout returns commerce-relevant programs first. Use this when you know the outcome you want but not the right program. Use list_programs instead for the full catalog, get_install_manifest for install metadata, or discover_agentic_purchasing_needs for purchasing-specific triage.",
      "inputSchema": {
        "properties": {
          "program": {
            "description": "Optional: filter results to a specific program name",
            "type": "string"
          },
          "q": {
            "description": "Search query — keyword or phrase",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "search_and_discover_tools"
    }
  ]
}

What the leaf hashes

{"body":"bff818f31c938c235c82a4733aea4199d64e9ad033cdb17b470a8dc5eb91bd4c","id":258008,"kind":"mcp.tools","method":"probe.mcp/1","observed_us":1793029883440595,"prev":null,"subject":"d908f896-b033-475f-9038-e157db1a1c1d","subject_kind":"endpoint"}

Proof

Fold these into the leaf in order, hashing each sorted pair with keccak256, to reach the root of (296695 rows).

  1. 0xb8128acb7554ad54ae0f819c3d5e5a236708725e17d76e20e3147fd111cf1e74
  2. 0xa045813914ec9e93bb2351119016ba03b5067f8b45069951589cbb6a1738dcb4
  3. 0x8cb1c2f38d71403dc9cfbf529986a2736427dbc7b907ba3433abb33e58cbbdc1
  4. 0x108a361cbc3b08a8b94703e3b7962840dcf2ca6cf5ace2208ba299c1f01dc5d3
  5. 0xcd2c42f1fd5b74289316d4a137e2617c0950477d5d1adfb66516eb7ad79c404b
  6. 0xbb1229ad2aacfe1d12197a8769e7656a5b291687761984b1088e8e173f62aa12
  7. 0x5df37581b42e7ffc304d3deae4a80d088799e6eb71a46e2af1c88fc0429e3fd9
  8. 0x6d223b1b369764c0bea30a3b91a88ed777e129aa51aedf54703c0d7dd72ea660
  9. 0x0e1debecbced8f0b1b591e77cca2b2c23f479b10b92a14c2b121216973d8dd9c
  10. 0xa4be442ac364076ac81def5d874f026f701ed9c8fce453af09052efe34f0c7ee
  11. 0x930671b38b693880d085315beda88a1c227f3639e9a0e0be6b0665bb173a65db
  12. 0xb6efd79902cac6d5a402ebecb8069402f00961ab80cd71b4d647fbc686d975ec
  13. 0x2f43fe2b2533a5f40c107c114e458e226102f5f8ae91f097e964345880e30928
  14. 0xf692ce2b0a640ec9f75aa960e5fb1c2c7091a04e24881798735752c19014e519
  15. 0x9f68b5e15459cb62b8c0cd4c124fa61c74147b4a5755a200fbecd21a581635d1
  16. 0x123ec8bee20ddc55223eeef5a4f4d6c4b6416515adbb911c56759f5cde56e452
  17. 0xd0651cb9bc8155eb52b5247d506e74b8a935057dc190ba52091702ac25ed3a40
  18. 0x9a9024edb5069d88a324facb310a5ce8e495214bbaa968f077bede437390194f
  19. 0x9b9ce5b74b9bab5121612ef6b64920a8d453cbf311096a423eef9702747e868a
Day root
0xf43e8dcc3d451a4788b26be904c55e8c4c0fa75c9666796c51db38d37e2c0df8
Chained
0x702d5ac508f08b0d1accf36af25822d8e5660367494edd17a642fb61e158a57a
Published
On Arc Testnet, block 69251483: 0x495162f8936e19f0039918feebe6c307f327cd6bf8c37219620b1970041fa9ae

How to check it · This row as JSON