Fail an Ask stream cut off before any text, widen Sparring caps, pin the cap math

An Ask stream that spent its whole cap on reasoning now fails so the client
falls back to the structured endpoint, which retries with a larger cap. The
Sparring speech and scorecard caps fit a full-length Hungarian reply. The cap
formula uses integer percentages, and a table test pins it from outside.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Programcode

supabase/functions/_shared/output-caps.test.ts

@@ -0,0 +1,32 @@
+// max_tokens covers reasoning and the reply together, so a wrong formula
+// leaves a model no room to answer. These pin the formula from outside it.
+
+import { assertEquals } from "jsr:@std/assert@1.0.19";
+import { outputTokenLimit, REPLY_TOKEN_CAPS, TRUNCATION_RETRY_FACTOR } from "./output-caps.ts";
+import type { ReasoningEffort } from "./model-catalog.ts";
+
+// OpenRouter's Claude budget: max(max_tokens * share, 1024).
+// https://openrouter.ai/docs/use-cases/reasoning-tokens
+const CLAUDE_SHARE: Record<ReasoningEffort, number> = { low: 0.2, medium: 0.5, high: 0.8 };
+const EFFORTS: ReasoningEffort[] = ["low", "medium", "high"];
+
+Deno.test("max_tokens for a known reply and effort", () => {
+  assertEquals(outputTokenLimit(1_500, "low", 128_000), 3_548);
+  assertEquals(outputTokenLimit(1_500, "medium", 128_000), 5_596);
+  assertEquals(outputTokenLimit(1_500, "high", 128_000), 9_692);
+  assertEquals(outputTokenLimit(6_000, "high", 128_000), 30_000);
+  assertEquals(outputTokenLimit(6_000, "high", 20_000), 20_000);
+});
+
+Deno.test("every cap leaves its full reply after Claude's reasoning budget and after the floor for other models", () => {
+  for (const [cap, reply] of Object.entries(REPLY_TOKEN_CAPS)) {
+    for (const effort of EFFORTS) {
+      for (const replyTokens of [reply, reply * TRUNCATION_RETRY_FACTOR]) {
+        const limit = outputTokenLimit(replyTokens, effort, 128_000);
+        const claudeBudget = Math.max(Math.floor(limit * CLAUDE_SHARE[effort]), 1_024);
+        if (limit - claudeBudget < replyTokens) throw new Error(`${cap} at ${effort}: Claude keeps ${limit - claudeBudget} of ${replyTokens}`);
+        if (limit - replyTokens < 2_048) throw new Error(`${cap} at ${effort}: only ${limit - replyTokens} tokens for reasoning`);
+      }
+    }
+  }
+});

supabase/functions/_shared/output-caps.ts

@@ -15,10 +15,10 @@ export const REPLY_TOKEN_CAPS = {
   crossfireTurn: 1_000,
   /** The turn-cited Crossfire debrief: six arrays of findings. */
   crossfireDebrief: 2_000,
-  /** One Sparring opponent speech. */
-  sparringSpeech: 1_500,
+  /** One Sparring opponent speech: up to 7 minutes, 6,000 characters. */
+  sparringSpeech: 2_500,
   /** The Sparring scorecard: four categories, moments, areas, verdict. */
-  sparringScore: 2_000,
+  sparringScore: 3_000,
   /** A full case, any length setting. */
   generate: 6_000,
   attack: 4_000,
@@ -37,12 +37,12 @@ export type ReplyCap = keyof typeof REPLY_TOKEN_CAPS;
 export const TRUNCATION_RETRY_FACTOR = 2;
 
 /**
- * The share of max_tokens a budget-based model (Claude) may spend on
+ * The percentage of max_tokens a budget-based model (Claude) may spend on
  * reasoning at each effort. OpenRouter sets its budget to
  * max(max_tokens * share, 1024).
  * https://openrouter.ai/docs/use-cases/reasoning-tokens
  */
-const REASONING_SHARE: Record<ReasoningEffort, number> = { low: 0.2, medium: 0.5, high: 0.8 };
+const REASONING_SHARE_PERCENT: Record<ReasoningEffort, number> = { low: 20, medium: 50, high: 80 };
 
 /**
  * Reasoning room kept on top of the reply at each effort. Effort-based models
@@ -62,6 +62,6 @@ export function outputTokenLimit(
   effort: ReasoningEffort,
   modelMaxTokens: number,
 ): number {
-  const afterBudget = Math.ceil(replyTokens / (1 - REASONING_SHARE[effort]));
+  const afterBudget = Math.ceil((replyTokens * 100) / (100 - REASONING_SHARE_PERCENT[effort]));
   return Math.min(modelMaxTokens, Math.max(afterBudget, replyTokens + REASONING_HEADROOM[effort]));
 }

supabase/functions/ai-stream/index.ts

@@ -344,11 +344,14 @@ export async function handleRequest(req: Request): Promise<Response> {
           throw new Error("OpenRouter stream ended before completion");
         }
 
-        // The text already reached the reader, so a cut-off answer cannot be
-        // retried. The flag tells the user it stopped short.
+        // A cut-off answer that already reached the reader cannot be retried;
+        // the flag tells the user it stopped short. One that spent the whole
+        // cap on reasoning sent nothing, so it fails and the client asks the
+        // structured endpoint, which retries with a larger cap.
         const replyTruncated = streamFinishReason === "length";
         if (replyTruncated) {
           console.warn(`[AI_STREAM] Reply hit its ask cap (${REPLY_TOKEN_CAPS.ask} tokens, ${model}, effort ${reasoningEffort})`);
+          if (!accumulated.trim()) throw new Error("OpenRouter reply was cut off before any text");
         }
 
         const output = {

supabase/functions/ai-stream/index_test.ts

@@ -14,7 +14,7 @@ for (const [key, value] of Object.entries({
 
 const { handleRequest } = await import("./index.ts");
 
-type Scenario = "complete" | "audit-error" | "truncated" | "provider-error" | "provider-error-after-finish" | "aborted" | "aborted-after-finish";
+type Scenario = "complete" | "audit-error" | "truncated" | "cut-off" | "cut-off-empty" | "provider-error" | "provider-error-after-finish" | "aborted" | "aborted-after-finish";
 
 const usage = {
   prompt_tokens: 12,
@@ -51,6 +51,15 @@ function framesFor(scenario: Exclude<Scenario, "aborted">): string {
       usageFrame,
     ].join("");
   }
+  // Stopped at max_tokens: after some text, or after reasoning only.
+  if (scenario === "cut-off" || scenario === "cut-off-empty") {
+    return [
+      ...(scenario === "cut-off" ? [`data: ${JSON.stringify({ choices: [{ delta: { content: "Partial" } }] })}\n\n`] : []),
+      `data: ${JSON.stringify({ choices: [{ delta: {}, finish_reason: "length" }] })}\n\n`,
+      usageFrame,
+      "data: [DONE]\n\n",
+    ].join("");
+  }
   if (scenario === "provider-error-after-finish") {
     return [
       usageFrame,
@@ -145,7 +154,7 @@ async function runScenario(scenario: Scenario) {
 }
 
 Deno.test("OpenRouter stream accounting bills only completed work", async () => {
-  for (const scenario of ["complete", "audit-error", "truncated", "provider-error", "provider-error-after-finish", "aborted", "aborted-after-finish"] as const) {
+  for (const scenario of ["complete", "audit-error", "cut-off", "truncated", "cut-off-empty", "provider-error", "provider-error-after-finish", "aborted", "aborted-after-finish"] as const) {
     const result = await runScenario(scenario);
     if (result.providerCalls !== 1) throw new Error(`${scenario}: expected one provider call, got ${result.providerCalls}`);
     if (result.rows.length !== 1) throw new Error(`${scenario}: expected one audit insert, got ${result.rows.length}`);
@@ -160,10 +169,14 @@ Deno.test("OpenRouter stream accounting bills only completed work", async () =>
       throw new Error(`${scenario}: raw provider usage was lost: ${JSON.stringify(row)}`);
     }
 
-    if (scenario === "complete" || scenario === "audit-error") {
+    if (scenario === "complete" || scenario === "audit-error" || scenario === "cut-off") {
       if (row.status !== "success" || row.cost_usd !== usage.cost || !result.body.includes("event: final")) {
         throw new Error(`complete stream was not billed: ${JSON.stringify(row)}\n${result.body}`);
       }
+      // A partial answer is kept and flagged; a full one is not.
+      if (result.body.includes('"replyTruncated":true') !== (scenario === "cut-off")) {
+        throw new Error(`${scenario}: wrong cut-off flag\n${result.body}`);
+      }
       continue;
     }