Skip to main content
Glama

Check claim values against a ruleset

dsail_check

Check extracted values against a written policy and get the same answer every time, with the rule that decided.

Use when reviewers disagree about applying decided rules to the same facts, or repeated reviews give inconsistent answers. Takes the ruleset and claim values extracted by the caller's own model.

Validates a claim dictionary and solves it against a ruleset, in one call.

Takes ruleset_hash (a compiled ruleset's content hash) or source. claims maps every declared claim name to a value; a claim that could not be determined is the string "unknown", which the rules treat as a first-class answer rather than a guess.

Returns every rule with the assertions it states, each carrying the engine's own result — TRUE (it holds), FALSE (it is violated), UNKNOWN (a claim it needs was not determined) or AMBIGUOUS (its evidence was contradicted), with the assertion's name and source text, and which claims had no value. AMBIGUOUS is reserved: it needs several answers for one claim, and a claim dictionary holds one, so no check sent here returns it. A rejected dictionary names every failing field at once as {field, expected, received}.

There is no overall verdict, by design: the four per-assertion words are the whole answer, and what a FALSE costs is a decision for whoever reads it.

This is the one metered call. It counts against the account's allowance of Jaxon Verified Units: one rule checked against up to 1,000 characters is one JVU, so a call carrying more rules or more text counts as more than one. When the allowance is used it answers ENTITLEMENT_EXCEEDED, and everything except checking keeps working.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
labelNoOptional application-domain label: `{"topic": "<a few words on what the policy governs>"}`, or `{"declined": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal.
claimsYesThe claim dictionary to evaluate: one entry per declared claim, keyed by claim name, values as the prompt pack specifies (`"120 USD"`, `true`, `"unknown"` for a value the extractor could not determine). A JSON object, or the same object as a JSON string.
sourceNoDSAIL source text, byte for byte as compiled. Give this OR `ruleset_hash`; prefer the hash for anything already compiled.
ruleset_hashNoThe content hash of an already compiled ruleset (from `dsail_compile` or a saved name). Give this OR `source`, not both.

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed2 schema fields changed
    • changedOutput schema / description
      Previous value: -"Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — with a counterexample where an assertion is violated. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it."New value: +"Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — each naming the assertion that decided it. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it."
    • changedOutput schema / oneOf
      Previous value: -[
      -  {
      -    "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
      -    "properties": {
      -      "claims": {
      -        "properties": {
      -          "bound": {
      -            "items": {
      -              "type": "string"
      -            },
      -            "type": "array"
      -          },
      -          "quantities": {
      -            "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
      -            "items": {
      -              "properties": {
      -                "bound": {
      -                  "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
      -                  "type": "string"
      -                },
      -                "claim": {
      -                  "type": "string"
      -                },
      -                "conversion": {
      -                  "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
      -                  "properties": {
      -                    "by": {
      -                      "const": "engine",
      -                      "type": "string"
      -                    },
      -                    "factor": {
      -                      "type": "number"
      -                    },
      -                    "from": {
      -                      "type": "string"
      -                    },
      -                    "status": {
      -                      "type": "string"
      -                    },
      -                    "to": {
      -                      "type": "string"
      -                    }
      -                  },
      -                  "required": [
      -                    "from",
      -                    "to",
      -                    "by",
      -                    "status"
      -                  ],
      -                  "type": "object"
      -                },
      -                "measured_in": {
      -                  "description": "The claim's declared @unit, if any.",
      -                  "type": [
      -                    "string",
      -                    "null"
      -                  ]
      -                },
      -                "submitted": {
      -                  "description": "The value as the caller sent it.",
      -                  "type": "string"
      -                }
      -              },
      -              "required": [
      -                "claim",
      -                "submitted",
      -                "bound",
      -                "measured_in"
      -              ],
      -              "type": "object"
      -            },
      -            "type": "array"
      -          },
      -          "unbound": {
      -            "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
      -            "items": {
      -              "type": "string"
      -            },
      -            "type": "array"
      -          }
      -        },
      -        "required": [
      -          "bound",
      -          "unbound"
      -        ],
      -        "type": "object"
      -      },
      -      "ok": {
      -        "const": true,
      -        "type": "boolean"
      -      },
      -      "rules": {
      -        "items": {
      -          "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
      -          "properties": {
      -            "assertions": {
      -              "items": {
      -                "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
      -                "properties": {
      -                  "check": {
      -                    "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
      -                    "enum": [
      -                      "TRUE",
      -                      "FALSE",
      -                      "UNKNOWN",
      -                      "AMBIGUOUS"
      -                    ],
      -                    "type": "string"
      -                  },
      -                  "counterexample": {
      -                    "description": "The assignment that violates this assertion, from the solver. Present only on FALSE: for an UNKNOWN the solver's witness is merely a model in which the assertion could fail, and publishing it would state a determination this service did not make.",
      -                    "type": "string"
      -                  },
      -                  "name": {
      -                    "type": "string"
      -                  },
      -                  "reason_unknown": {
      -                    "type": "string"
      -                  },
      -                  "source": {
      -                    "type": [
      -                      "string",
      -                      "null"
      -                    ]
      -                  },
      -                  "unbridged_units": {
      -                    "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
      -                    "items": {
      -                      "properties": {
      -                        "from": {
      -                          "type": "string"
      -                        },
      -                        "to": {
      -                          "type": "string"
      -                        }
      -                      },
      -                      "required": [
      -                        "from",
      -                        "to"
      -                      ],
      -                      "type": "object"
      -                    },
      -                    "type": "array"
      -                  },
      -                  "unknown_policy": {
      -                    "type": "string"
      -                  }
      -                },
      -                "required": [
      -                  "name",
      -                  "check"
      -                ],
      -                "type": "object"
      -              },
      -              "type": "array"
      -            },
      -            "rule": {
      -              "type": "string"
      -            }
      -          },
      -          "required": [
      -            "rule",
      -            "assertions"
      -          ],
      -          "type": "object"
      -        },
      -        "type": "array"
      -      },
      -      "ruleset_hash": {
      -        "type": "string"
      -      },
      -      "unit_library_hash": {
      -        "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
      -        "type": [
      -          "string",
      -          "null"
      -        ]
      -      },
      -      "versions": {
      -        "description": "Which engine and which wire contract produced this response.",
      -        "properties": {
      -          "engine": {
      -            "example": "dsail-core",
      -            "type": "string"
      -          },
      -          "engine_version": {
      -            "type": "string"
      -          },
      -          "language_version": {
      -            "description": "DSAIL language version.",
      -            "type": "string"
      -          },
      -          "service_version": {
      -            "type": "string"
      -          },
      -          "supported_language_versions": {
      -            "items": {
      -              "type": "string"
      -            },
      -            "type": "array"
      -          },
      -          "wire_version": {
      -            "type": "string"
      -          }
      -        },
      -        "required": [
      -          "engine",
      -          "engine_version",
      -          "language_version",
      -          "service_version",
      -          "wire_version"
      -        ],
      -        "type": "object"
      -      }
      -    },
      -    "required": [
      -      "ok",
      -      "ruleset_hash",
      -      "unit_library_hash",
      -      "rules",
      -      "claims",
      -      "versions"
      -    ],
      -    "type": "object"
      -  },
      -  {
      -    "properties": {
      -      "error": {
      -        "properties": {
      -          "actual": {
      -            "type": "integer"
      -          },
      -          "budget": {
      -            "type": "string"
      -          },
      -          "code": {
      -            "enum": [
      -              "VALIDATION_REJECTED",
      -              "COMPILE_FAILED",
      -              "BUDGET_EXCEEDED",
      -              "RULESET_NOT_FOUND",
      -              "ENGINE_ERROR",
      -              "BAD_REQUEST",
      -              "CREDENTIAL_REQUIRED",
      -              "CREDENTIAL_INVALID",
      -              "CREDENTIAL_SCOPE",
      -              "EVALUATION_LIMIT",
      -              "ENTITLEMENT_EXCEEDED",
      -              "TIER_UNAVAILABLE"
      -            ],
      -            "type": "string"
      -          },
      -          "diagnostics": {
      -            "items": {
      -              "properties": {
      -                "line": {
      -                  "type": [
      -                    "integer",
      -                    "null"
      -                  ]
      -                },
      -                "message": {
      -                  "type": "string"
      -                },
      -                "severity": {
      -                  "enum": [
      -                    "error",
      -                    "warning"
      -                  ],
      -                  "type": "string"
      -                }
      -              },
      -              "required": [
      -                "severity",
      -                "message"
      -              ],
      -              "type": "object"
      -            },
      -            "type": "array"
      -          },
      -          "docs": {
      -            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
      -            "format": "uri",
      -            "type": "string"
      -          },
      -          "failure_count": {
      -            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
      -            "type": "integer"
      -          },
      -          "failures": {
      -            "description": "EVERY failing field, not the first one.",
      -            "items": {
      -              "properties": {
      -                "expected": {
      -                  "type": "string"
      -                },
      -                "field": {
      -                  "type": "string"
      -                },
      -                "received": {
      -                  "type": "string"
      -                }
      -              },
      -              "required": [
      -                "field",
      -                "expected",
      -                "received"
      -              ],
      -              "type": "object"
      -            },
      -            "type": "array"
      -          },
      -          "hint": {
      -            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
      -            "type": "string"
      -          },
      -          "limit": {
      -            "type": "integer"
      -          },
      -          "message": {
      -            "type": "string"
      -          }
      -        },
      -        "required": [
      -          "code",
      -          "message"
      -        ],
      -        "type": "object"
      -      },
      -      "ok": {
      -        "const": false,
      -        "type": "boolean"
      -      },
      -      "versions": {
      -        "description": "Which engine and which wire contract produced this response.",
      -        "properties": {
      -          "engine": {
      -            "example": "dsail-core",
      -            "type": "string"
      -          },
      -          "engine_version": {
      -            "type": "string"
      -          },
      -          "language_version": {
      -            "description": "DSAIL language version.",
      -            "type": "string"
      -          },
      -          "service_version": {
      -            "type": "string"
      -          },
      -          "supported_language_versions": {
      -            "items": {
      -              "type": "string"
      -            },
      -            "type": "array"
      -          },
      -          "wire_version": {
      -            "type": "string"
      -          }
      -        },
      -        "required": [
      -          "engine",
      -          "engine_version",
      -          "language_version",
      -          "service_version",
      -          "wire_version"
      -        ],
      -        "type": "object"
      -      }
      -    },
      -    "required": [
      -      "ok",
      -      "error",
      -      "versions"
      -    ],
      -    "type": "object"
      -  }
      -]New value: +[
      +  {
      +    "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
      +    "properties": {
      +      "claims": {
      +        "properties": {
      +          "bound": {
      +            "items": {
      +              "type": "string"
      +            },
      +            "type": "array"
      +          },
      +          "quantities": {
      +            "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
      +            "items": {
      +              "properties": {
      +                "bound": {
      +                  "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
      +                  "type": "string"
      +                },
      +                "claim": {
      +                  "type": "string"
      +                },
      +                "conversion": {
      +                  "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
      +                  "properties": {
      +                    "by": {
      +                      "const": "engine",
      +                      "type": "string"
      +                    },
      +                    "factor": {
      +                      "type": "number"
      +                    },
      +                    "from": {
      +                      "type": "string"
      +                    },
      +                    "status": {
      +                      "type": "string"
      +                    },
      +                    "to": {
      +                      "type": "string"
      +                    }
      +                  },
      +                  "required": [
      +                    "from",
      +                    "to",
      +                    "by",
      +                    "status"
      +                  ],
      +                  "type": "object"
      +                },
      +                "measured_in": {
      +                  "description": "The claim's declared @unit, if any.",
      +                  "type": [
      +                    "string",
      +                    "null"
      +                  ]
      +                },
      +                "submitted": {
      +                  "description": "The value as the caller sent it.",
      +                  "type": "string"
      +                }
      +              },
      +              "required": [
      +                "claim",
      +                "submitted",
      +                "bound",
      +                "measured_in"
      +              ],
      +              "type": "object"
      +            },
      +            "type": "array"
      +          },
      +          "unbound": {
      +            "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
      +            "items": {
      +              "type": "string"
      +            },
      +            "type": "array"
      +          }
      +        },
      +        "required": [
      +          "bound",
      +          "unbound"
      +        ],
      +        "type": "object"
      +      },
      +      "ok": {
      +        "const": true,
      +        "type": "boolean"
      +      },
      +      "rules": {
      +        "items": {
      +          "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
      +          "properties": {
      +            "assertions": {
      +              "items": {
      +                "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
      +                "properties": {
      +                  "check": {
      +                    "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
      +                    "enum": [
      +                      "TRUE",
      +                      "FALSE",
      +                      "UNKNOWN",
      +                      "AMBIGUOUS"
      +                    ],
      +                    "type": "string"
      +                  },
      +                  "name": {
      +                    "type": "string"
      +                  },
      +                  "reason_unknown": {
      +                    "type": "string"
      +                  },
      +                  "source": {
      +                    "type": [
      +                      "string",
      +                      "null"
      +                    ]
      +                  },
      +                  "unbridged_units": {
      +                    "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
      +                    "items": {
      +                      "properties": {
      +                        "from": {
      +                          "type": "string"
      +                        },
      +                        "to": {
      +                          "type": "string"
      +                        }
      +                      },
      +                      "required": [
      +                        "from",
      +                        "to"
      +                      ],
      +                      "type": "object"
      +                    },
      +                    "type": "array"
      +                  },
      +                  "unknown_policy": {
      +                    "type": "string"
      +                  }
      +                },
      +                "required": [
      +                  "name",
      +                  "check"
      +                ],
      +                "type": "object"
      +              },
      +              "type": "array"
      +            },
      +            "rule": {
      +              "type": "string"
      +            }
      +          },
      +          "required": [
      +            "rule",
      +            "assertions"
      +          ],
      +          "type": "object"
      +        },
      +        "type": "array"
      +      },
      +      "ruleset_hash": {
      +        "type": "string"
      +      },
      +      "unit_library_hash": {
      +        "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
      +        "type": [
      +          "string",
      +          "null"
      +        ]
      +      },
      +      "versions": {
      +        "description": "Which engine and which wire contract produced this response.",
      +        "properties": {
      +          "engine": {
      +            "example": "dsail-core",
      +            "type": "string"
      +          },
      +          "engine_version": {
      +            "type": "string"
      +          },
      +          "language_version": {
      +            "description": "DSAIL language version.",
      +            "type": "string"
      +          },
      +          "service_version": {
      +            "type": "string"
      +          },
      +          "supported_language_versions": {
      +            "items": {
      +              "type": "string"
      +            },
      +            "type": "array"
      +          },
      +          "wire_version": {
      +            "type": "string"
      +          }
      +        },
      +        "required": [
      +          "engine",
      +          "engine_version",
      +          "language_version",
      +          "service_version",
      +          "wire_version"
      +        ],
      +        "type": "object"
      +      }
      +    },
      +    "required": [
      +      "ok",
      +      "ruleset_hash",
      +      "unit_library_hash",
      +      "rules",
      +      "claims",
      +      "versions"
      +    ],
      +    "type": "object"
      +  },
      +  {
      +    "properties": {
      +      "error": {
      +        "properties": {
      +          "actual": {
      +            "description": "How much the request used, where that is known. Absent for solver_memory_mb: the solver stops at the limit.",
      +            "type": "integer"
      +          },
      +          "budget": {
      +            "type": "string"
      +          },
      +          "code": {
      +            "enum": [
      +              "VALIDATION_REJECTED",
      +              "COMPILE_FAILED",
      +              "BUDGET_EXCEEDED",
      +              "RULESET_NOT_FOUND",
      +              "ENGINE_ERROR",
      +              "ENGINE_BUSY",
      +              "BAD_REQUEST",
      +              "CREDENTIAL_REQUIRED",
      +              "CREDENTIAL_INVALID",
      +              "CREDENTIAL_SCOPE",
      +              "EVALUATION_LIMIT",
      +              "ENTITLEMENT_EXCEEDED",
      +              "TIER_UNAVAILABLE"
      +            ],
      +            "type": "string"
      +          },
      +          "diagnostics": {
      +            "items": {
      +              "properties": {
      +                "line": {
      +                  "type": [
      +                    "integer",
      +                    "null"
      +                  ]
      +                },
      +                "message": {
      +                  "type": "string"
      +                },
      +                "severity": {
      +                  "enum": [
      +                    "error",
      +                    "warning"
      +                  ],
      +                  "type": "string"
      +                }
      +              },
      +              "required": [
      +                "severity",
      +                "message"
      +              ],
      +              "type": "object"
      +            },
      +            "type": "array"
      +          },
      +          "docs": {
      +            "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
      +            "format": "uri",
      +            "type": "string"
      +          },
      +          "failure_count": {
      +            "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
      +            "type": "integer"
      +          },
      +          "failures": {
      +            "description": "EVERY failing field, not the first one.",
      +            "items": {
      +              "properties": {
      +                "expected": {
      +                  "type": "string"
      +                },
      +                "field": {
      +                  "type": "string"
      +                },
      +                "received": {
      +                  "type": "string"
      +                }
      +              },
      +              "required": [
      +                "field",
      +                "expected",
      +                "received"
      +              ],
      +              "type": "object"
      +            },
      +            "type": "array"
      +          },
      +          "hint": {
      +            "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
      +            "type": "string"
      +          },
      +          "limit": {
      +            "type": "integer"
      +          },
      +          "message": {
      +            "type": "string"
      +          },
      +          "retry_after_ms": {
      +            "description": "ENGINE_BUSY only: when to retry. The REST door also sends it, in seconds, as Retry-After.",
      +            "type": "integer"
      +          }
      +        },
      +        "required": [
      +          "code",
      +          "message"
      +        ],
      +        "type": "object"
      +      },
      +      "ok": {
      +        "const": false,
      +        "type": "boolean"
      +      },
      +      "versions": {
      +        "description": "Which engine and which wire contract produced this response.",
      +        "properties": {
      +          "engine": {
      +            "example": "dsail-core",
      +            "type": "string"
      +          },
      +          "engine_version": {
      +            "type": "string"
      +          },
      +          "language_version": {
      +            "description": "DSAIL language version.",
      +            "type": "string"
      +          },
      +          "service_version": {
      +            "type": "string"
      +          },
      +          "supported_language_versions": {
      +            "items": {
      +              "type": "string"
      +            },
      +            "type": "array"
      +          },
      +          "wire_version": {
      +            "type": "string"
      +          }
      +        },
      +        "required": [
      +          "engine",
      +          "engine_version",
      +          "language_version",
      +          "service_version",
      +          "wire_version"
      +        ],
      +        "type": "object"
      +      }
      +    },
      +    "required": [
      +      "ok",
      +      "error",
      +      "versions"
      +    ],
      +    "type": "object"
      +  }
      +]
  2. Changed5 schema fields changed
    • addedInput schema / properties / claims / description
      Added value: +"The claim dictionary to evaluate: one entry per declared claim, keyed by claim name, values as the prompt pack specifies (`\"120 USD\"`, `true`, `\"unknown\"` for a value the extractor could not determine). A JSON object, or the same object as a JSON string."
    • addedInput schema / properties / label / description
      Added value: +"Optional application-domain label: `{\"topic\": \"<a few words on what the policy governs>\"}`, or `{\"declined\": true}`. Matched against the published vocabulary and then discarded; never stored on the ruleset. Omitting it leaves the ruleset unlabeled, which is normal."
    • addedInput schema / properties / ruleset_hash / description
      Added value: +"The content hash of an already compiled ruleset (from `dsail_compile` or a saved name). Give this OR `source`, not both."
    • addedInput schema / properties / source / description
      Added value: +"DSAIL source text, byte for byte as compiled. Give this OR `ruleset_hash`; prefer the hash for anything already compiled."
    • changedOutput schema / (root)
      Previous value: -nullNew value: +{
      +  "description": "Per-rule, per-assertion results — TRUE, FALSE, UNKNOWN or AMBIGUOUS — with a counterexample where an assertion is violated. No overall verdict. On failure `ok` is false and `error` carries `code`, `message` and `docs`, the URL of the page that resolves it.",
      +  "oneOf": [
      +    {
      +      "description": "Every rule in the ruleset with every assertion's own result, and nothing combined on top of them. Pure over its inputs: no timestamps, no durations, no request id, so the same ruleset and claim dictionary always produce the same bytes — through either door.",
      +      "properties": {
      +        "claims": {
      +          "properties": {
      +            "bound": {
      +              "items": {
      +                "type": "string"
      +              },
      +              "type": "array"
      +            },
      +            "quantities": {
      +              "description": "What each numeric claim was worth. Without it a check names the claims it bound and nothing about their values, so an answer of '30000 CAD' judged against a policy written in USD leaves no trace of the currency it arrived in.",
      +              "items": {
      +                "properties": {
      +                  "bound": {
      +                    "description": "The DSAIL literal it became. Verbatim: the host performs no unit arithmetic.",
      +                    "type": "string"
      +                  },
      +                  "claim": {
      +                    "type": "string"
      +                  },
      +                  "conversion": {
      +                    "description": "Present only when the submitted unit differs from the declared one. 'by' is always 'engine': Z3 applies the factor as an exact rational, and the factor here is reported from the same registry for a human to check, never used to compute anything.",
      +                    "properties": {
      +                      "by": {
      +                        "const": "engine",
      +                        "type": "string"
      +                      },
      +                      "factor": {
      +                        "type": "number"
      +                      },
      +                      "from": {
      +                        "type": "string"
      +                      },
      +                      "status": {
      +                        "type": "string"
      +                      },
      +                      "to": {
      +                        "type": "string"
      +                      }
      +                    },
      +                    "required": [
      +                      "from",
      +                      "to",
      +                      "by",
      +                      "status"
      +                    ],
      +                    "type": "object"
      +                  },
      +                  "measured_in": {
      +                    "description": "The claim's declared @unit, if any.",
      +                    "type": [
      +                      "string",
      +                      "null"
      +                    ]
      +                  },
      +                  "submitted": {
      +                    "description": "The value as the caller sent it.",
      +                    "type": "string"
      +                  }
      +                },
      +                "required": [
      +                  "claim",
      +                  "submitted",
      +                  "bound",
      +                  "measured_in"
      +                ],
      +                "type": "object"
      +              },
      +              "type": "array"
      +            },
      +            "unbound": {
      +              "description": "Claims the engine had no value for — submitted as unknown, or absent. Why an assertion answered UNKNOWN is readable here.",
      +              "items": {
      +                "type": "string"
      +              },
      +              "type": "array"
      +            }
      +          },
      +          "required": [
      +            "bound",
      +            "unbound"
      +          ],
      +          "type": "object"
      +        },
      +        "ok": {
      +          "const": true,
      +          "type": "boolean"
      +        },
      +        "rules": {
      +          "items": {
      +            "description": "One rule's assertions, each with its own result. There is no rule-level conclusion: joining assertions is the reader's call, and the platform's own join (bit-pair, in ``common.multi_instance.verifier_ref``) is the way to do it.",
      +            "properties": {
      +              "assertions": {
      +                "items": {
      +                  "description": "What the engine concluded about one assertion. Exactly that, and nothing derived from it: this service publishes no severity, no effect and no verdict, so what a FALSE should cost is the reader's decision.",
      +                  "properties": {
      +                    "check": {
      +                      "description": "The engine's own result, in the same four words the platform's run results use. TRUE = the assertion holds. FALSE = the assertion is violated. UNKNOWN = a claim the assertion needs was not determined. AMBIGUOUS = the assertion's evidence was contradicted — reserved: it needs an instance axis carrying several answers for one claim, and a claim dictionary holds one value per claim, so nothing produces it yet. Handle it now and a later release costs you no change.",
      +                      "enum": [
      +                        "TRUE",
      +                        "FALSE",
      +                        "UNKNOWN",
      +                        "AMBIGUOUS"
      +                      ],
      +                      "type": "string"
      +                    },
      +                    "counterexample": {
      +                      "description": "The assignment that violates this assertion, from the solver. Present only on FALSE: for an UNKNOWN the solver's witness is merely a model in which the assertion could fail, and publishing it would state a determination this service did not make.",
      +                      "type": "string"
      +                    },
      +                    "name": {
      +                      "type": "string"
      +                    },
      +                    "reason_unknown": {
      +                      "type": "string"
      +                    },
      +                    "source": {
      +                      "type": [
      +                        "string",
      +                        "null"
      +                      ]
      +                    },
      +                    "unbridged_units": {
      +                      "description": "Unit pairs this assertion compares that no loaded converter bridges — the engine's own account of why it answered UNKNOWN.",
      +                      "items": {
      +                        "properties": {
      +                          "from": {
      +                            "type": "string"
      +                          },
      +                          "to": {
      +                            "type": "string"
      +                          }
      +                        },
      +                        "required": [
      +                          "from",
      +                          "to"
      +                        ],
      +                        "type": "object"
      +                      },
      +                      "type": "array"
      +                    },
      +                    "unknown_policy": {
      +                      "type": "string"
      +                    }
      +                  },
      +                  "required": [
      +                    "name",
      +                    "check"
      +                  ],
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              "rule": {
      +                "type": "string"
      +              }
      +            },
      +            "required": [
      +              "rule",
      +              "assertions"
      +            ],
      +            "type": "object"
      +          },
      +          "type": "array"
      +        },
      +        "ruleset_hash": {
      +          "type": "string"
      +        },
      +        "unit_library_hash": {
      +          "description": "The other half of a result's provenance. DSAIL numerics are dimensional, and a project may add unit converters that change what a comparison resolves to, so the ruleset hash alone no longer identifies every input. Null means no project library, which is itself reproducible: it selects the six built-in standard libraries.",
      +          "type": [
      +            "string",
      +            "null"
      +          ]
      +        },
      +        "versions": {
      +          "description": "Which engine and which wire contract produced this response.",
      +          "properties": {
      +            "engine": {
      +              "example": "dsail-core",
      +              "type": "string"
      +            },
      +            "engine_version": {
      +              "type": "string"
      +            },
      +            "language_version": {
      +              "description": "DSAIL language version.",
      +              "type": "string"
      +            },
      +            "service_version": {
      +              "type": "string"
      +            },
      +            "supported_language_versions": {
      +              "items": {
      +                "type": "string"
      +              },
      +              "type": "array"
      +            },
      +            "wire_version": {
      +              "type": "string"
      +            }
      +          },
      +          "required": [
      +            "engine",
      +            "engine_version",
      +            "language_version",
      +            "service_version",
      +            "wire_version"
      +          ],
      +          "type": "object"
      +        }
      +      },
      +      "required": [
      +        "ok",
      +        "ruleset_hash",
      +        "unit_library_hash",
      +        "rules",
      +        "claims",
      +        "versions"
      +      ],
      +      "type": "object"
      +    },
      +    {
      +      "properties": {
      +        "error": {
      +          "properties": {
      +            "actual": {
      +              "type": "integer"
      +            },
      +            "budget": {
      +              "type": "string"
      +            },
      +            "code": {
      +              "enum": [
      +                "VALIDATION_REJECTED",
      +                "COMPILE_FAILED",
      +                "BUDGET_EXCEEDED",
      +                "RULESET_NOT_FOUND",
      +                "ENGINE_ERROR",
      +                "BAD_REQUEST",
      +                "CREDENTIAL_REQUIRED",
      +                "CREDENTIAL_INVALID",
      +                "CREDENTIAL_SCOPE",
      +                "EVALUATION_LIMIT",
      +                "ENTITLEMENT_EXCEEDED",
      +                "TIER_UNAVAILABLE"
      +              ],
      +              "type": "string"
      +            },
      +            "diagnostics": {
      +              "items": {
      +                "properties": {
      +                  "line": {
      +                    "type": [
      +                      "integer",
      +                      "null"
      +                    ]
      +                  },
      +                  "message": {
      +                    "type": "string"
      +                  },
      +                  "severity": {
      +                    "enum": [
      +                      "error",
      +                      "warning"
      +                    ],
      +                    "type": "string"
      +                  }
      +                },
      +                "required": [
      +                  "severity",
      +                  "message"
      +                ],
      +                "type": "object"
      +              },
      +              "type": "array"
      +            },
      +            "docs": {
      +              "description": "The docs-site page that resolves this code (markdown). Fetch it before retrying blind.",
      +              "format": "uri",
      +              "type": "string"
      +            },
      +            "failure_count": {
      +              "description": "How many fields failed in total. Equal to the length of `failures` unless a very large rejection was truncated, which the message says.",
      +              "type": "integer"
      +            },
      +            "failures": {
      +              "description": "EVERY failing field, not the first one.",
      +              "items": {
      +                "properties": {
      +                  "expected": {
      +                    "type": "string"
      +                  },
      +                  "field": {
      +                    "type": "string"
      +                  },
      +                  "received": {
      +                    "type": "string"
      +                  }
      +                },
      +                "required": [
      +                  "field",
      +                  "expected",
      +                  "received"
      +                ],
      +                "type": "object"
      +              },
      +              "type": "array"
      +            },
      +            "hint": {
      +              "description": "The grammar guide, carried on compile failures so the next call can succeed without a human.",
      +              "type": "string"
      +            },
      +            "limit": {
      +              "type": "integer"
      +            },
      +            "message": {
      +              "type": "string"
      +            }
      +          },
      +          "required": [
      +            "code",
      +            "message"
      +          ],
      +          "type": "object"
      +        },
      +        "ok": {
      +          "const": false,
      +          "type": "boolean"
      +        },
      +        "versions": {
      +          "description": "Which engine and which wire contract produced this response.",
      +          "properties": {
      +            "engine": {
      +              "example": "dsail-core",
      +              "type": "string"
      +            },
      +            "engine_version": {
      +              "type": "string"
      +            },
      +            "language_version": {
      +              "description": "DSAIL language version.",
      +              "type": "string"
      +            },
      +            "service_version": {
      +              "type": "string"
      +            },
      +            "supported_language_versions": {
      +              "items": {
      +                "type": "string"
      +              },
      +              "type": "array"
      +            },
      +            "wire_version": {
      +              "type": "string"
      +            }
      +          },
      +          "required": [
      +            "engine",
      +            "engine_version",
      +            "language_version",
      +            "service_version",
      +            "wire_version"
      +          ],
      +          "type": "object"
      +        }
      +      },
      +      "required": [
      +        "ok",
      +        "error",
      +        "versions"
      +      ],
      +      "type": "object"
      +    }
      +  ],
      +  "type": "object"
      +}
  3. First observed

TDQS

Score is being calculated.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.