SolveRequest

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://artifacts.apis.io/eccaai-com/json-schema/eccaai-com-solve-request-schema.json",
  "title": "SolveRequest",
  "x-generated": "2026-11-06",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/_original/eccaai-com-api-openapi.json#/components/schemas/SolveRequest",
  "type": "object",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "description": "The question. Truncated to 64000 characters for free callers and 500000 for paid callers; an empty prompt is a 400 empty-prompt."
    },
    "context": {
      "type": "object",
      "description": "Optional context the engines see with the question, as fields: turns (up to the last 3 earlier {q, a} exchanges) and document ({label, text}, text up to 8000 characters). The server builds the engine prompt from them. A shared proof is sealed over the typed question plus this context, stores the context as the engines saw it (capped), and shows it on the public page under What the engines also saw and in /p/<id>.json.",
      "properties": {
        "turns": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string"
              },
              "a": {
                "type": "string"
              }
            }
          }
        },
        "document": {
          "type": "object",
          "properties": {
            "label": {
              "type": "string"
            },
            "text": {
              "type": "string"
            }
          }
        }
      }
    },
    "depth": {
      "type": "string",
      "description": "\"fast\" routes to one cost-optimal engine; \"deep\" is a multi-engine dispatch: paid callers get the full configured matrix; free callers start with two engines and expand on measured divergence, and after the free daily deep solve is spent the request is downgraded to fast with meta.downgraded=true. Accepted aliases: intuitive (fast); standard, executive, pioneer (deep). Any other value is a 400 invalid-depth before any quota is spent.",
      "enum": [
        "fast",
        "deep",
        "intuitive",
        "standard",
        "executive",
        "pioneer"
      ]
    },
    "mode": {
      "type": "string",
      "description": "Answer posture. cothink and socratic are chat lanes that always meter through the deep ladder. stress is a Socratic deep solve plus three probe variants of the question (asked again fresh with the question verbatim, its opposite, one premise changed), dispatched together; it is charged as STRESS_TEST_SOLVE_COST solves (client/ecca_tier_limits.js: the main solve plus one per probe) against the caller's free daily solves and free deep solve, or Pro usage-window solves, all reserved atomically before dispatch or none. If the main solve returns an error, every reserved solve (and the free deep solve) is given back and the error carries stressRefund; a reader who disconnects (client-aborted) after the engines started keeps the charge. It returns meta.stressTest (schema ecca.stress-test.v1): each main-answer claim with how many probes it survives (a matching claim with the same stance in that probe's answers; any matching claim with the opposite stance flips it; a failed probe never counts). Matching is lexical (shared words plus a count of negation words), not semantic. stress is refused with a 400 on depth fast, with a niche, with an adjudication mode, and with an API key. debate runs the question as a live three-round debate: round 1 is the normal deep dispatch (each engine that answers is a debater); in round 2 each debater sees only the other debaters' extracted central claims plus the single largest claim split as the debate question and answers in at most 120 words; in round 3 each returns structured JSON (changed_mind yes/no, a one-sentence final_position, side A/B/neither, dropped_claims naming ids of its own claims it withdraws; ids it was never shown are ignored). Rounds 2 and 3 are each cut off at DEBATE_ROUND_SECONDS (client/ecca_tier_limits.js, at most 25 s); a late engine is recorded as late. It is charged as DEBATE_SOLVE_COST solves, reserved atomically before dispatch like stress; a failed round 1 gives every solve back (debateRefund), and a round no engine answered is given back. It returns meta.debate (schema ecca.debate-live.v1): the rounds, a verdict computed only from the structured fields (changedMind, heldOut, noFinal, claimsDropped, split), the per-engine dropped counts, and finalAnswer: the engine whose final position dropped the fewest of its own claims, ties broken by not having changed its mind (DEBATE_HELD_UP_KEY), among engines shown at least one claim of their own; a remaining tie is reported as a tie, never one answer, and with no qualifying engine there is no final answer. Claims that name a round 3 field or steer the other engines are never shown to another engine; rounds 2 and 3 answer in the question's language. On a stream, debate_round, debate_turn and debate_done events arrive as each round starts and each engine lands. debate is refused with a 400 on depth fast, with a niche, with an adjudication mode, and with an API key. verify, tournament, premortem, audit and check are adjudication modes that also attach a deterministic modeReport. check reruns the question alone (the candidate is never shown to the engines) and returns check: the panel's canonical final answer against the candidate's. tutor is a Socratic solve that writes a hint ladder (Hint, Bigger hint, Show next step, Show answer); it never streams and returns tutor (schema ecca.tutor.v1): an id and the steps' kinds and labels only, never their text. tutor-reveal with tutorId and level returns exactly one step's text, in order (an unopened later step is a 409 tutor-step-order); it dispatches nothing and spends no quota. practice asks for PRACTICE_PROBLEMS similar problems (client/ecca_tier_limits.js), never streams, is charged as PRACTICE_SOLVE_COST solves, and returns practice (schema ecca.practice.v1): each problem with its answer and, when the free calculator checked it, check calculator-holds or calculator-fails. exam-topics reads prompt as a syllabus or study guide (at most EXAM_SYLLABUS_MAX_CHARS characters; blank is a 400 exam-topics-empty, too long a 413 exam-syllabus-too-long, and any context field a 400 exam-topics-no-context, all before any quota is spent), always runs at fast depth, never streams, is charged as EXAM_TOPICS_SOLVE_COST fast solves (never the free deep solve), and returns exam (schema ecca.exam-topics.v1): at most EXAM_MAX_TOPICS topic names and nothing else; when no topics come back (502 exam-topics-none) or the engines fail, the solve is given back and the reply carries refund. The day-by-day plan is built on the device with no request. Omit for the default \"direct\".",
      "enum": [
        "direct",
        "cothink",
        "socratic",
        "stress",
        "debate",
        "verify",
        "tournament",
        "premortem",
        "audit",
        "check",
        "tutor",
        "practice",
        "exam-topics",
        "tutor-reveal"
      ]
    },
    "goal": {
      "type": "string",
      "description": "MCQ goal intake. \"goal:check\" resolves to mode verify."
    },
    "options": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Required by mode tournament: at least two candidate options. Missing options is a 400 tournament-requires-options, never a default ranking."
    },
    "candidate": {
      "type": "string",
      "description": "Required by mode check: the answer another assistant gave to prompt. Never sent to the engines. A missing, blank or non-string candidate is a 400 check-requires-candidate, more than 65536 UTF-8 bytes is a 413 payload-too-large, and in mode check a blank or non-string prompt is a 400 empty-prompt; all are refused before any quota is spent."
    },
    "antagonist_mode": {
      "type": "boolean",
      "description": "Force one engine into an adversarial red-team role on chat lanes (adjudication modes set this themselves)."
    },
    "stream": {
      "type": "boolean",
      "description": "true (or ?stream=true) switches the response to text/event-stream."
    }
  }
}