{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum-service/schemas/service-tools.v1.json",
  "title": "wai.quantum.service-tools/1",
  "description": "The answers of the job service's MCP tools (POST /mcp), each a $def; every tool's outputSchema in tools/list is its answer's schema standing alone. A call the service refuses answers {\"error\"} with isError true. The job and the engine's answers are in wai-quantum's schemas.",
  "$defs": {
    "refused": {
      "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/refusal"
    },
    "job": {
      "description": "A job: queued, running, done with its result and receipt, or failed with its error; a set's job holds the set's result; with dry_run true, what the service would do with it, running nothing.",
      "anyOf": [
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/job.v1.json"
        },
        {
          "$ref": "#/$defs/dry_run"
        },
        {
          "$ref": "#/$defs/refused"
        },
        {
          "type": "object",
          "description": "A job the service no longer holds, known only by its id.",
          "required": [
            "id"
          ],
          "properties": {
            "id": {
              "type": "string"
            }
          }
        }
      ]
    },
    "hybrid_job": {
      "description": "A wasmQ envelope's or a qudit job's job (run_wasmq, run_qudit; POST /v1/wasmq, POST /v1/qudit): queued, running, done with its result and receipt, or failed with its error; or the refusal. Its request is what the receipt binds: for a wasmQ run the contract and the envelope's digest, for a qudit job the request as given.",
      "anyOf": [
        {
          "type": "object",
          "required": [
            "id",
            "status",
            "method",
            "request"
          ],
          "properties": {
            "id": {
              "type": "string"
            },
            "status": {
              "enum": [
                "queued",
                "running",
                "done",
                "failed",
                "cancelled",
                "interrupted"
              ]
            },
            "method": {
              "enum": [
                "wasmq",
                "qudit"
              ]
            },
            "why": {
              "type": "string",
              "description": "What the plan read of it: the profile, the method, the qubits or the register, the shots and the work."
            },
            "estimate": {
              "type": "object",
              "description": "The plan's memory, bytes, and its work: §4.8's operations for a wasmQ run, amplitudes touched for a qudit job.",
              "properties": {
                "memory_bytes": {
                  "type": "integer"
                },
                "work": {
                  "type": "integer"
                }
              }
            },
            "request": {
              "type": "object"
            },
            "result": {
              "anyOf": [
                {
                  "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/wasmq.v1.json#/$defs/result"
                },
                {
                  "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/qudit.v1.json#/$defs/run"
                }
              ]
            },
            "error": {
              "type": "string",
              "description": "Why the job failed: a worker stopped past its admitted memory or the job's time says so, and nothing is sealed."
            },
            "interruptions": {
              "type": "array",
              "items": {
                "type": "integer"
              }
            },
            "submitted_ms": {
              "type": "integer"
            },
            "started_ms": {
              "type": "integer"
            },
            "finished_ms": {
              "type": "integer"
            },
            "peak_rss_bytes": {
              "type": "integer"
            },
            "digests": {
              "type": "object",
              "description": "The BLAKE3 digests the store keeps the job's objects under: its request, its program (a wasmQ run's envelope, under the digest its receipt binds), its result and its receipt."
            }
          }
        },
        {
          "$ref": "#/$defs/refused"
        }
      ]
    },
    "job_or_write": {
      "description": "A job, or a write's job (get_quantum_job reads either by its id).",
      "anyOf": [
        {
          "$ref": "#/$defs/job"
        },
        {
          "$ref": "#/$defs/write"
        }
      ]
    },
    "write": {
      "type": "object",
      "description": "A write's job (POST /v1/write, write_circuit): queued; running, with the attempts checked so far; done, its result the transcript, sealed, with its timing beside it; or failed, cancelled or interrupted, saying why.",
      "required": [
        "id",
        "status",
        "method",
        "why",
        "estimate",
        "request",
        "submitted_ms",
        "digests"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "status": {
          "enum": [
            "queued",
            "running",
            "done",
            "failed",
            "cancelled",
            "interrupted"
          ]
        },
        "method": {
          "const": "write"
        },
        "why": {
          "type": "string"
        },
        "estimate": {
          "type": "object",
          "required": [
            "memory_bytes",
            "work"
          ],
          "properties": {
            "memory_bytes": {
              "type": "integer",
              "minimum": 0,
              "description": "What it holds of the jobs' memory budget: none, since the writer's memory is its own, held to its own cap."
            },
            "work": {
              "type": "integer",
              "minimum": 0,
              "description": "The most tokens its replies may take."
            }
          }
        },
        "request": {
          "$ref": "#/$defs/write_request"
        },
        "submitted_ms": {
          "type": "integer"
        },
        "started_ms": {
          "type": "integer"
        },
        "finished_ms": {
          "type": "integer"
        },
        "peak_rss_bytes": {
          "type": "integer",
          "description": "The most memory the writer process held while it wrote, its model's mapped pages among it."
        },
        "interruptions": {
          "type": "array",
          "items": {
            "type": "integer"
          },
          "description": "Each time the service stopped while the write ran, in milliseconds since 1970; it is run again, once, from its stored request, and gives the same transcript."
        },
        "error": {
          "type": "string"
        },
        "progress": {
          "type": "object",
          "description": "While it runs: how many attempts the engine has checked, and the latest.",
          "required": [
            "attempts",
            "latest"
          ],
          "properties": {
            "attempts": {
              "type": "integer",
              "minimum": 1
            },
            "latest": {
              "$ref": "#/$defs/write_attempt"
            }
          }
        },
        "timing": {
          "type": "array",
          "description": "How long each attempt's reply and its check took, in seconds: beside the result and outside what its receipt seals, since time is the one thing running it again does not reproduce.",
          "items": {
            "type": "object",
            "required": [
              "reply_seconds",
              "check_seconds"
            ],
            "properties": {
              "reply_seconds": {
                "type": "number",
                "minimum": 0
              },
              "check_seconds": {
                "type": "number",
                "minimum": 0
              }
            }
          }
        },
        "result": {
          "$ref": "#/$defs/transcript"
        },
        "digests": {
          "type": "object",
          "description": "The BLAKE3 digests the store keeps the write's objects under: its request, its result and its receipt.",
          "properties": {
            "algorithm": {
              "const": "blake3"
            },
            "request": {
              "type": [
                "string",
                "null"
              ]
            },
            "programs": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "result": {
              "type": "string"
            },
            "receipt": {
              "type": "string"
            }
          }
        }
      }
    },
    "write_request": {
      "type": "object",
      "description": "What a write asks: its task, and how many repairs and tokens a reply may take; kept as its canonical text (RFC 8785), which its receipt binds.",
      "required": [
        "task"
      ],
      "additionalProperties": false,
      "properties": {
        "task": {
          "type": "object",
          "description": "The task: an exercise in the course's form (wai.quantum.exercise/1), with an intent, or cases that each have one.",
          "additionalProperties": true
        },
        "rounds": {
          "type": "integer",
          "minimum": 0,
          "maximum": 4,
          "description": "Repairs after the first attempt (default 4)."
        },
        "max_new": {
          "type": "integer",
          "minimum": 1,
          "maximum": 4000,
          "description": "The most tokens one reply may take, its thinking included (default 3000)."
        }
      }
    },
    "transcript": {
      "type": "object",
      "description": "A write's result: its transcript (wai.quantum.write/1), with the energy the writer spent on it and the service's receipt, which seals the rest with the write's request. The transcript names the task and its digest, the model by its name, licence and the digest of its files with how far they were checked and the arithmetic it ran in, the prompt by its version and digests, the decoding with its thinking cap, the memory each check's run was planned in, the engine, and each attempt with the engine's check; the same model, task, options and engine give the same transcript in the same arithmetic, so anyone who holds the model can write it again on a host whose architecture, operating system, maths library and matmul kernel are the model's here, and compare.",
      "required": [
        "schema",
        "task",
        "task_digest",
        "model",
        "prompt",
        "decoding",
        "engine",
        "passed",
        "passed_round",
        "level",
        "program",
        "program_digest",
        "attempts"
      ],
      "properties": {
        "schema": {
          "const": "wai.quantum.write/1"
        },
        "task": {
          "type": "object",
          "description": "The task, as the model was given it: its canonical form (RFC 8785), read back.",
          "additionalProperties": true
        },
        "task_digest": {
          "type": "string",
          "description": "BLAKE3 over the task's canonical text (RFC 8785)."
        },
        "model": {
          "type": "object",
          "required": [
            "name",
            "licence",
            "digest"
          ],
          "properties": {
            "name": {
              "type": "string"
            },
            "licence": {
              "type": "string"
            },
            "digest": {
              "type": "string",
              "description": "BLAKE3 over the canonical text of the model's file manifest (wai.quantum.model/1: each file's name, size and digest); for a scripted model, over its script."
            },
            "runtime": {
              "type": "string"
            },
            "checked": {
              "enum": [
                "sizes",
                "blake3"
              ],
              "description": "How far the model's files were checked against its manifest before they were loaded: their sizes, or every byte (BLAKE3). The model loads exactly the files the manifest lists either way. A scripted model has none."
            },
            "arch": {
              "type": "string",
              "description": "The architecture the model ran on (Rust's target_arch)."
            },
            "os": {
              "type": "string",
              "description": "The operating system it ran on, whose maths library its exponentials come from."
            },
            "libm": {
              "type": "string",
              "description": "The platform's maths library (glibc's version, or macOS's release and build), whose exponentials and sines shape the logits: part of the arithmetic a replay must match."
            },
            "matmul": {
              "type": "string",
              "description": "The BF16 matmul kernel its projections took there, which fixes the arithmetic of every logit; greedy decoding gives the same tokens again only in the same."
            }
          }
        },
        "prompt": {
          "type": "object",
          "required": [
            "version",
            "system_digest",
            "first_digest"
          ],
          "properties": {
            "version": {
              "type": "string"
            },
            "system_digest": {
              "type": "string"
            },
            "first_digest": {
              "type": "string"
            }
          }
        },
        "decoding": {
          "type": "object",
          "required": [
            "method",
            "max_new",
            "rounds"
          ],
          "properties": {
            "method": {
              "const": "greedy"
            },
            "max_new": {
              "type": "integer",
              "minimum": 1
            },
            "rounds": {
              "type": "integer",
              "minimum": 0
            },
            "think_max": {
              "type": "integer",
              "minimum": 0,
              "description": "The most tokens of a reply that may be thinking: a reply still thinking there has its thinking closed for it and answers in the tokens left."
            }
          }
        },
        "engine": {
          "type": "string",
          "description": "The version of the engine (wai-quantum) that checked each attempt."
        },
        "check_memory_bytes": {
          "type": "integer",
          "minimum": 0,
          "description": "The memory each check's run was planned in: it decides which programs a check runs, and by which method, so two hosts with other limits can check alike only with the same."
        },
        "passed": {
          "type": "boolean"
        },
        "passed_round": {
          "type": [
            "integer",
            "null"
          ],
          "description": "The round whose program passed; null when none did."
        },
        "level": {
          "description": "The level the engine checked the program to; null where there is none.",
          "anyOf": [
            {
              "type": "null"
            },
            {
              "enum": [
                "refused",
                "parsed",
                "executed",
                "evidence",
                "proof"
              ]
            }
          ]
        },
        "program": {
          "type": [
            "string",
            "null"
          ],
          "description": "The last attempt's program."
        },
        "program_digest": {
          "type": [
            "string",
            "null"
          ]
        },
        "attempts": {
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#/$defs/write_attempt"
          }
        },
        "energy": {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/job-result.v1.json#/$defs/energy"
        },
        "receipt": {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/receipt.v2.json"
        }
      }
    },
    "write_attempt": {
      "type": "object",
      "description": "One attempt of a write: the program the model's reply gave, its digest, and the engine's check of it against the task (wai.quantum.course-check/1, its lesson null), whose what_went_wrong went back to the model.",
      "required": [
        "round",
        "answered",
        "program",
        "program_digest",
        "passed",
        "level",
        "check",
        "reply_tokens",
        "thinking_tokens"
      ],
      "properties": {
        "round": {
          "type": "integer",
          "minimum": 0
        },
        "answered": {
          "type": "boolean",
          "description": "Whether the reply gave a program: false for one that ended inside its thinking, of which the engine had nothing to check."
        },
        "program": {
          "type": [
            "string",
            "null"
          ]
        },
        "program_digest": {
          "type": [
            "string",
            "null"
          ],
          "description": "BLAKE3 over the program's text."
        },
        "passed": {
          "type": "boolean"
        },
        "level": {
          "description": "The level the engine checked the program to; null where there is none.",
          "anyOf": [
            {
              "type": "null"
            },
            {
              "enum": [
                "refused",
                "parsed",
                "executed",
                "evidence",
                "proof"
              ]
            }
          ]
        },
        "check": {
          "type": [
            "object",
            "null"
          ],
          "description": "The engine's check of the program against the task (wai.quantum.course-check/1, its lesson null), whose what_went_wrong went back to the model; null when the reply gave no program."
        },
        "reply_tokens": {
          "type": "integer",
          "minimum": 0
        },
        "thinking_tokens": {
          "type": "integer",
          "minimum": 0,
          "description": "The reply's tokens that were thinking, counted on the tokens it gave: up to and including the one that ended its thinking, all of a reply whose thinking did not end."
        },
        "thinking_closed": {
          "type": "boolean",
          "description": "Whether the reply reached the thinking cap still thinking, and had its thinking closed for it."
        }
      }
    },
    "verify": {
      "description": "Whether a result's receipt seals exactly that request and that result, and the key it names; for an estimate, also every estimate's receipt and the request re-run here; for a set, also every item's receipt, the root over them and each item's path.",
      "anyOf": [
        {
          "type": "object",
          "description": "Whether a result's receipt seals exactly that request and that result and every rule of its form holds, and the key it names.",
          "required": [
            "valid"
          ],
          "properties": {
            "valid": {
              "type": "boolean"
            },
            "reasons": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Each rule the receipt breaks (the provider protocol's section 8.4, wasmq_form among them for a wasmQ job): none when it is valid."
            },
            "form": {
              "type": [
                "string",
                "null"
              ],
              "description": "The receipt's form: rfc8785, or first."
            },
            "provider": {
              "type": "object",
              "description": "For a provider's result, what it says of itself."
            },
            "compile": {
              "type": "object",
              "description": "For a sealed compile, or a job that ran compiled and carries its certificate's chain (wai/extensions/quantum-compile.md section 6): what a second look at the certificate found. again is reproduced (compiled again here, the request gives this certificate byte for byte), partly (not reproduced; the output was held to the program here by a tableau, in exact arithmetic or on dense unitaries, and whole says which), host_statement (its form holds, and nothing more could be decided here) or differs (not the certificate the request bears out: the job is then not valid, though its seal holds; differences says why).",
              "required": [
                "again",
                "form",
                "passes",
                "differences",
                "why"
              ],
              "properties": {
                "again": {
                  "enum": [
                    "reproduced",
                    "partly",
                    "host_statement",
                    "differs"
                  ]
                },
                "form": {
                  "enum": [
                    "chained",
                    "earlier"
                  ],
                  "description": "chained: every pass names its digests, its layer and its distance. earlier: sealed before certificates carried them."
                },
                "layer": {
                  "type": [
                    "string",
                    "null"
                  ],
                  "description": "The layer the whole compile stands on, as the certificate states it."
                },
                "weakest": {
                  "type": [
                    "string",
                    "null"
                  ],
                  "description": "The weakest layer among its passes' checks, as the certificate states it."
                },
                "passes": {
                  "type": "integer",
                  "minimum": 0
                },
                "differences": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                },
                "why": {
                  "type": "string"
                },
                "whole": {
                  "type": "object",
                  "description": "With partly: the check of the whole output against the whole program made here, its layer among it."
                }
              }
            },
            "planner": {
              "type": "object",
              "description": "For a job under a contract, what its reasoning says: the route chosen, the class wanted and given, whether the choice depends on the host, what was kept, and the shadow."
            },
            "key": {
              "type": [
                "string",
                "null"
              ]
            },
            "signer": {
              "type": [
                "string",
                "null"
              ],
              "description": "That key as a did:key."
            },
            "answer": {
              "type": "object",
              "description": "For a job whose result seals the engine's verdict of its answer (the provider protocol's section 8.9): the verdict worked out again here. Its level, whether it holds, the layer that decided it with that layer's limits, the result's accuracy class, and again: reproduced, partly, host_statement (nothing of it could be worked out again here: it is the host's statement under its seal) or differs (not the verdict the job bears out: the job is then not valid, though its seal holds).",
              "required": [
                "level",
                "holds",
                "layer",
                "again",
                "checks",
                "differences",
                "statement"
              ],
              "properties": {
                "schema": {
                  "const": "wai.quantum.verdict/1"
                },
                "level": {
                  "type": "string"
                },
                "holds": {
                  "type": [
                    "boolean",
                    "null"
                  ]
                },
                "layer": {
                  "type": "string"
                },
                "limits": {
                  "type": "string"
                },
                "accuracy": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "again": {
                  "enum": [
                    "reproduced",
                    "partly",
                    "host_statement",
                    "differs"
                  ]
                },
                "checks": {
                  "type": "array",
                  "items": {
                    "type": "object"
                  }
                },
                "differences": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                },
                "statement": {
                  "type": "string"
                }
              }
            },
            "wasmq": {
              "type": "object",
              "description": "For a wasmQ job (quantum-wasmq section 6.5), beside the verdict: how the run ended, each rule of the profile's form it breaks, and where the host's unsealed words differ from what is sealed, which change no verdict.",
              "required": [
                "outcome",
                "problems",
                "notes"
              ],
              "additionalProperties": false,
              "properties": {
                "outcome": {
                  "type": [
                    "string",
                    "null"
                  ],
                  "description": "The sealed result's status: ok, or fault."
                },
                "problems": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  },
                  "description": "Each rule of quantum-wasmq section 6.5 the job breaks, in words (the reason wasmq_form): the first 64, then how many more. Empty when it breaks none."
                },
                "notes": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  },
                  "description": "Where the body's unsealed status or method differs from what is sealed or is missing, and members nothing seals: told beside the verdict, and no part of it."
                }
              }
            },
            "time": {
              "type": "object",
              "description": "What the receipt seals of when it was issued (the provider protocol's section 8.2), for a receipt of its form: the time, in milliseconds since 1970 by its signer's clock, or that it seals none.",
              "required": [
                "sealed"
              ],
              "properties": {
                "sealed": {
                  "type": "boolean"
                },
                "issued_ms": {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                "not_after_ms": {
                  "type": [
                    "integer",
                    "null"
                  ],
                  "minimum": 0,
                  "maximum": 9007199254740991,
                  "description": "The first moment the receipt is no longer offered; null when it states none."
                }
              }
            },
            "given": {
              "enum": [
                "text",
                "members",
                "parsed"
              ],
              "description": "How the job was given (section 9): its own text; its members, judged as the message wrote them; or a value already parsed, with no text to judge."
            },
            "not_seen": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "For a job given parsed: what parsing loses, which this verdict could not see."
            }
          }
        },
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/estimate.v1.json#/$defs/verify"
        },
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/set.v1.json#/$defs/verify"
        }
      ]
    },
    "critique": {
      "anyOf": [
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/critique"
        },
        {
          "$ref": "#/$defs/refused"
        }
      ]
    },
    "equivalence": {
      "anyOf": [
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/equivalence"
        },
        {
          "$ref": "#/$defs/refused"
        }
      ]
    },
    "convert": {
      "anyOf": [
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/convert"
        },
        {
          "$ref": "#/$defs/refused"
        }
      ]
    },
    "improve": {
      "anyOf": [
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/improve"
        },
        {
          "$ref": "#/$defs/refused"
        }
      ]
    },
    "shortcuts": {
      "anyOf": [
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/shortcuts"
        },
        {
          "$ref": "#/$defs/refused"
        }
      ]
    },
    "info": {
      "type": "object",
      "description": "What the service can do: its methods and their limits here, the accuracy classes, the conventions, the per-client limits, the current load, its addresses, sets, its store, its energy metering, where its receipt keys are, and its versions.",
      "required": [
        "methods",
        "accuracy_classes",
        "conventions",
        "limits",
        "load",
        "versions"
      ],
      "properties": {
        "methods": {
          "type": "array",
          "items": {
            "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/method"
          }
        },
        "accuracy_classes": {
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "conventions": {
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "limits": {
          "type": "object",
          "additionalProperties": {
            "type": "integer"
          }
        },
        "load": {
          "type": "object",
          "additionalProperties": {
            "type": "integer"
          }
        },
        "api": {
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "versions": {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/versions.v1.json"
        },
        "sets": {
          "type": "object",
          "description": "What a set takes here: the most items, and the fields a set request gives.",
          "additionalProperties": true
        },
        "store": {
          "type": "object",
          "description": "Where the service keeps jobs: the store's kind, whether it outlives a restart, and how it addresses objects.",
          "additionalProperties": true
        },
        "energy": {
          "type": "object",
          "description": "How the service meters a job's energy here, or why it does not.",
          "additionalProperties": true
        },
        "write": {
          "type": "object",
          "description": "Whether the service writes programs for tasks (write_circuit, POST /v1/write): with a model, the model as a transcript names it once it is loaded, where the writer stands and a write's limits; without one, why.",
          "additionalProperties": true
        },
        "receipt_keys": {
          "type": "string",
          "description": "Where the service publishes every key it has signed receipts with (the receipt key set, wai.quantum.receipt-keys/1)."
        },
        "components": {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/components",
          "description": "Every component the service runs through (the built-ins alone), each with its identity: what list_components gives."
        }
      }
    },
    "examples": {
      "type": "object",
      "required": [
        "examples"
      ],
      "properties": {
        "examples": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "name",
              "title",
              "shows",
              "job"
            ],
            "properties": {
              "name": {
                "type": "string"
              },
              "title": {
                "type": "string"
              },
              "shows": {
                "type": "string",
                "description": "What the example shows."
              },
              "job": {
                "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/job-request.v1.json"
              }
            }
          }
        }
      }
    },
    "compile": {
      "description": "A compile sealed with the service's key, or why it was refused.",
      "anyOf": [
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/compile-result.v1.json"
        },
        {
          "$ref": "#/$defs/refused"
        }
      ]
    },
    "diagnostics": {
      "description": "The reader's diagnostic codes, or one code's row; an unknown code is refused.",
      "anyOf": [
        {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/diagnostic_codes"
        },
        {
          "$ref": "#/$defs/refused"
        }
      ]
    },
    "targets": {
      "type": "object",
      "description": "The device targets the service knows by name, all synthetic.",
      "required": [
        "targets"
      ],
      "properties": {
        "targets": {
          "type": "array",
          "items": {
            "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/tools.v1.json#/$defs/target_summary"
          }
        }
      }
    },
    "dry_run": {
      "type": "object",
      "description": "What the service would do with a job or a set, running nothing: the plan's method and why, its qubits, memory and work, the estimated time and energy (each with its basis, or why there is none), the bounds that apply, where the client stands against its limits, each item of a set, and whether the service would take it now, or the refusal it would give.",
      "required": [
        "dry_run",
        "ran",
        "accepted",
        "bounds",
        "client"
      ],
      "properties": {
        "dry_run": {
          "const": true
        },
        "ran": {
          "const": false
        },
        "accepted": {
          "type": "boolean",
          "description": "Whether the service would take it now, by every limit, its reading held to what the submission's would take; the MCP tools plan it as their runs run it, its verdict asked."
        },
        "status": {
          "type": "integer",
          "description": "The HTTP status a refusal would carry."
        },
        "refusal": {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/verdict.v1.json#/properties/refusal"
        },
        "method": {
          "type": "string"
        },
        "why": {
          "type": "string"
        },
        "qubits": {
          "type": "integer",
          "minimum": 0
        },
        "memory_bytes": {
          "type": "integer",
          "minimum": 0
        },
        "work": {
          "type": "integer",
          "minimum": 0
        },
        "within_time_limit": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "time": {
          "type": "object",
          "description": "The estimated time: seconds and its basis, or null and why, with the most the job may take.",
          "properties": {
            "seconds": {
              "type": [
                "number",
                "null"
              ]
            },
            "basis": {
              "type": "string"
            },
            "why": {
              "type": "string"
            },
            "note": {
              "type": "string"
            },
            "at_most": {
              "type": "integer"
            },
            "rate": {
              "type": "object"
            }
          },
          "additionalProperties": true
        },
        "energy": {
          "type": "object",
          "description": "The estimated energy, never a reading of this job: microjoules, its provenance and basis, or why there is none.",
          "properties": {
            "joules_micro_estimate": {
              "type": "integer",
              "minimum": 0
            },
            "energy_provenance": {
              "type": "string"
            },
            "basis": {
              "type": "string"
            },
            "note": {
              "type": "string"
            },
            "unestimated": {
              "type": "string"
            }
          },
          "additionalProperties": true
        },
        "bounds": {
          "type": "object",
          "description": "The bounds that apply here: memory, time, queue, items of a set, and result_bytes, the most a job's or a set's result may take as served.",
          "additionalProperties": true
        },
        "result_bytes": {
          "description": "The most its result takes as served, bytes, bounded before it runs: past bounds.result_bytes the job is refused (422, J031). A pulse run is bounded from its schedule. For a method that gives no bound before it runs (no built-in is such): {\"bytes\": null, \"why\"}, and it is counted at bounds.result_bytes.",
          "oneOf": [
            {
              "type": "integer",
              "minimum": 0
            },
            {
              "type": "object",
              "required": [
                "bytes",
                "why"
              ],
              "properties": {
                "bytes": {
                  "type": "null"
                },
                "why": {
                  "type": "string"
                }
              },
              "additionalProperties": false
            }
          ]
        },
        "client": {
          "type": "object",
          "description": "Where the client stands: its active jobs, the memory they hold, the submissions left in its window and when the window resets.",
          "properties": {
            "active_jobs": {
              "type": "integer"
            },
            "memory_held_bytes": {
              "type": "integer"
            },
            "submissions_left": {
              "type": "integer"
            },
            "window_resets_in_seconds": {
              "type": "integer"
            }
          }
        },
        "target": {
          "type": "object",
          "description": "A job on a device target: the target the plan placed it on."
        },
        "items": {
          "type": "array",
          "description": "A set: each item's plan and estimates.",
          "items": {
            "type": "object",
            "properties": {
              "index": {
                "type": "integer"
              },
              "point": {
                "type": "object"
              },
              "method": {
                "type": "string"
              },
              "why": {
                "type": "string"
              },
              "qubits": {
                "type": "integer"
              },
              "memory_bytes": {
                "type": "integer"
              },
              "work": {
                "type": "integer"
              },
              "time": {
                "type": "object",
                "additionalProperties": true
              },
              "energy": {
                "type": "object",
                "additionalProperties": true
              }
            }
          }
        },
        "planner": {
          "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum/schemas/job-result.v1.json#/$defs/planner"
        }
      }
    },
    "receipt_keys": {
      "$ref": "https://git.transaction.science/Transaction-Science/open-standards/raw/branch/main/wai/wai-quantum-service/schemas/receipt-keys.v1.json"
    }
  }
}