@apo-ai/sdk 0.11.0 → 0.13.0

package/dist/agent-task/integrations/ai-sdk.d.ts

@@ -1,4 +1,4 @@
-import { A as AgentTaskTraceContext } from '../../tracing-DoIGvJW1.js';
+import { A as AgentTaskTraceContext } from '../../tracing-FqFObrmt.js';
 
 /**
  * Vercel AI SDK tracing integration for apo.

package/dist/agent-task/integrations/anthropic.d.ts

@@ -1,4 +1,4 @@
-import { A as AgentTaskTraceContext } from '../../tracing-DoIGvJW1.js';
+import { A as AgentTaskTraceContext } from '../../tracing-FqFObrmt.js';
 
 /**
  * Anthropic JS SDK tracing integration for apo.

package/dist/agent-task/integrations/anthropic.js

@@ -2,8 +2,8 @@
 // Do not edit by hand — edit the src/ originals and rebuild.
 import {
   createApoAnthropic
-} from "../../chunk-6H2GACBG.js";
-import "../../chunk-Z64A566W.js";
+} from "../../chunk-X73JGMK3.js";
+import "../../chunk-JTWQD27M.js";
 export {
   createApoAnthropic
 };

package/dist/agent-task/integrations/openai.d.ts

@@ -1,4 +1,4 @@
-import { A as AgentTaskTraceContext } from '../../tracing-DoIGvJW1.js';
+import { A as AgentTaskTraceContext } from '../../tracing-FqFObrmt.js';
 
 /**
  * OpenAI JS SDK tracing integration for apo.

package/dist/agent-task/integrations/openai.js

@@ -2,8 +2,8 @@
 // Do not edit by hand — edit the src/ originals and rebuild.
 import {
   createApoOpenAI
-} from "../../chunk-P43KL5AR.js";
-import "../../chunk-Z64A566W.js";
+} from "../../chunk-A3UYQ7M4.js";
+import "../../chunk-JTWQD27M.js";
 export {
   createApoOpenAI
 };

package/dist/agent-task/public.d.ts

@@ -1,4 +1,4 @@
-import { A as AgentTaskTraceContext, a as AgentTaskTraceOptions } from '../tracing-DoIGvJW1.js';
+import { A as AgentTaskTraceContext, a as AgentTaskTraceOptions } from '../tracing-FqFObrmt.js';
 export { CreateApoTracerOptions, createApoTracer } from './integrations/ai-sdk.js';
 export { CreateApoOpenAIOptions, createApoOpenAI } from './integrations/openai.js';
 export { CreateApoAnthropicOptions, createApoAnthropic } from './integrations/anthropic.js';
@@ -673,6 +673,13 @@ type JudgeMetadata = {
      * the decision model, and `response` carries its typed verdict.
      */
     verdict_by?: "second-judge";
+    /**
+     * How many attempts of this call were cut because the judge's stream fell
+     * into a repetition loop (`t.judge` only). Absent = none. 1 with a verdict:
+     * the first draw looped and the retry answered. A call whose last draw
+     * looped has no verdict and is recorded as a judge error.
+     */
+    reasoning_loops?: number;
 };
 /**
  * Evidence from the second grader. `error` is set when the decisions
@@ -2318,8 +2325,8 @@ declare function getActiveApoRun(): ApoRunContext | undefined;
  *
  * Pure, dependency-free canonicalizer. Both this module and its Python twin
  * (`backend/apo/execution/task_revision_manifest.py`) MUST produce
- * byte-identical canonical JSON and digests for every fixture under
- * `specs/contracts/task-revision/v1/cases/`.
+ * byte-identical canonical JSON and digests for any given file tree — the
+ * task-revision identity is content-addressed on both sides of the wire.
  *
  * Canonicalization rules:
  *   - `/` path separators (caller `\` normalized to `/`);

package/dist/agent-task/public.js

@@ -9,20 +9,20 @@ import {
   resolveApoAuthHeaders,
   withApoRun,
   withApoRunSync
-} from "../chunk-LO343UZO.js";
+} from "../chunk-P24ECOI3.js";
 import {
   createApoTracer
 } from "../chunk-OZWOLCJ5.js";
 import "../chunk-HRYXLRXJ.js";
 import {
   createApoOpenAI
-} from "../chunk-P43KL5AR.js";
+} from "../chunk-A3UYQ7M4.js";
 import {
   createApoAnthropic
-} from "../chunk-6H2GACBG.js";
+} from "../chunk-X73JGMK3.js";
 import {
   servingHostFromBaseURL
-} from "../chunk-Z64A566W.js";
+} from "../chunk-JTWQD27M.js";
 
 // src/agent-task/run/steer-scheduler.ts
 var TASK_STEER_SPAN_NAME = "task.steer";
@@ -644,6 +644,158 @@ function levenshtein(a, b) {
 // src/agent-task/checks/judge.ts
 import { createHash } from "crypto";
 
+// src/agent-task/checks/reasoning-loop.ts
+var MAX_UNIT_CHARS = 64;
+var MIN_UNIT_COPIES = 100;
+var MIN_REPEAT_CHARS = 1e3;
+var MAX_CHAR_RUN = 3;
+var GRAM = 24;
+var DIVERSITY_WINDOW = 3e3;
+var MIN_DIVERSITY = 0.1;
+var DIVERSITY_STRIDE = 256;
+var MAX_DIVERSITY_LINE_CHARS = 2e3;
+var RECYCLE_GRAM = 32;
+var RECYCLE_WINDOW = 5e3;
+var MAX_RECYCLED = 0.95;
+var isFoldable = (ch) => /[\p{L}\p{N}]/u.test(ch);
+function foldForRepetition(text) {
+  let out = "";
+  let last = "";
+  let run = 0;
+  for (const raw of text) {
+    if (!isFoldable(raw)) continue;
+    const ch = raw.toLowerCase();
+    run = ch === last ? run + 1 : 1;
+    last = ch;
+    if (run <= MAX_CHAR_RUN) out += ch;
+  }
+  return out;
+}
+function isTableLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.startsWith("|")) return true;
+  return (trimmed.match(/\|/g)?.length ?? 0) >= 3;
+}
+function diversity(folded) {
+  const total = folded.length - GRAM + 1;
+  if (total <= 0) return 1;
+  const grams = /* @__PURE__ */ new Set();
+  for (let i = 0; i < total; i++) grams.add(folded.slice(i, i + GRAM));
+  return grams.size / total;
+}
+var RepetitionGuard = class {
+  constructor(opts) {
+    this.rawChars = 0;
+    // Repeated-unit state: the folded tail, and for each period p the number
+    // of consecutive folded chars equal to the char p before them.
+    this.tail = "";
+    this.lastChar = "";
+    this.charRun = 0;
+    this.periodRuns = new Array(MAX_UNIT_CHARS + 1).fill(0);
+    // Low-diversity state: the current raw line, and the folded window built
+    // from finished lines that are not tables.
+    this.line = "";
+    this.window = "";
+    this.sinceMeasured = 0;
+    // Recycled state: every gram of the filtered folded stream so far, and for
+    // the window's grams whether each had been seen when it arrived.
+    this.seenGrams = /* @__PURE__ */ new Set();
+    this.gramTail = "";
+    this.windowFlags = [];
+    this.flagHead = 0;
+    this.recycledInWindow = 0;
+    this.checkDiversity = opts.diversity;
+  }
+  get tripped() {
+    return this.trip;
+  }
+  push(delta) {
+    if (this.trip || !delta) return this.trip;
+    for (const raw of delta) {
+      this.rawChars++;
+      if (this.checkDiversity) this.pushLineChar(raw);
+      if (isFoldable(raw)) this.pushFolded(raw.toLowerCase());
+      if (this.trip) break;
+    }
+    return this.trip;
+  }
+  pushFolded(ch) {
+    this.charRun = ch === this.lastChar ? this.charRun + 1 : 1;
+    this.lastChar = ch;
+    if (this.charRun > MAX_CHAR_RUN) return;
+    this.tail += ch;
+    const n = this.tail.length - 1;
+    for (let p = 1; p <= MAX_UNIT_CHARS; p++) {
+      this.periodRuns[p] = n >= p && this.tail[n - p] === ch ? this.periodRuns[p] + 1 : 0;
+      const span = this.periodRuns[p] + p;
+      if (span >= MIN_REPEAT_CHARS && span / p >= MIN_UNIT_COPIES) {
+        this.trip = {
+          rule: "repeated-unit",
+          atChar: this.rawChars,
+          unit: this.tail.slice(-p),
+          copies: Math.floor(span / p)
+        };
+        return;
+      }
+    }
+    if (this.tail.length > MAX_UNIT_CHARS * 2) this.tail = this.tail.slice(-MAX_UNIT_CHARS);
+  }
+  pushLineChar(raw) {
+    if (raw !== "\n") {
+      if (this.line.length <= MAX_DIVERSITY_LINE_CHARS) this.line += raw;
+      return;
+    }
+    const line = this.line;
+    this.line = "";
+    if (line.length > MAX_DIVERSITY_LINE_CHARS || isTableLine(line)) return;
+    const folded = foldForRepetition(line);
+    if (!folded) return;
+    this.pushRecycled(folded);
+    this.window = (this.window + folded).slice(-DIVERSITY_WINDOW);
+    this.sinceMeasured += folded.length;
+    if (this.window.length < DIVERSITY_WINDOW || this.sinceMeasured < DIVERSITY_STRIDE) return;
+    this.sinceMeasured = 0;
+    const ratio = diversity(this.window);
+    if (ratio < MIN_DIVERSITY) {
+      this.trip = { rule: "low-diversity", atChar: this.rawChars, diversity: ratio };
+      return;
+    }
+    const windowGrams = this.windowFlags.length - this.flagHead;
+    if (windowGrams < RECYCLE_WINDOW) return;
+    const recycled = this.recycledInWindow / windowGrams;
+    if (recycled >= MAX_RECYCLED) {
+      this.trip = { rule: "recycled", atChar: this.rawChars, recycled };
+    }
+  }
+  pushRecycled(folded) {
+    for (const ch of folded) {
+      this.gramTail = (this.gramTail + ch).slice(-RECYCLE_GRAM);
+      if (this.gramTail.length < RECYCLE_GRAM) continue;
+      const seen = this.seenGrams.has(this.gramTail);
+      if (!seen) this.seenGrams.add(this.gramTail);
+      this.windowFlags.push(seen);
+      if (seen) this.recycledInWindow++;
+      if (this.windowFlags.length - this.flagHead > RECYCLE_WINDOW) {
+        if (this.windowFlags[this.flagHead++]) this.recycledInWindow--;
+      }
+    }
+    if (this.flagHead > RECYCLE_WINDOW * 4) {
+      this.windowFlags.splice(0, this.flagHead);
+      this.flagHead = 0;
+    }
+  }
+};
+function describeTrip(trip) {
+  switch (trip.rule) {
+    case "repeated-unit":
+      return `"${trip.unit}" repeated ${trip.copies}\xD7 at char ${trip.atChar}`;
+    case "low-diversity":
+      return `distinct-${GRAM}-gram ratio ${trip.diversity.toFixed(3)} at char ${trip.atChar}`;
+    case "recycled":
+      return `${Math.round(trip.recycled * 100)}% of the last ${RECYCLE_WINDOW} chars replay earlier reasoning, at char ${trip.atChar}`;
+  }
+}
+
 // src/agent-task/checks/second-judge.ts
 function secondJudgeFacts(check) {
   const sj = check.judge?.secondJudge;
@@ -828,6 +980,16 @@ var JudgeUnavailableError = class extends Error {
     this.name = "JudgeUnavailableError";
   }
 };
+var JudgeReasoningLoopError = class extends JudgeUnavailableError {
+  constructor(trip, channel) {
+    super(`judge reasoning loop: ${channel} ${describeTrip(trip)}`);
+    this.name = "JudgeReasoningLoopError";
+  }
+};
+function isJudgeLoopGuardEnabled() {
+  const value = process.env.APO_JUDGE_LOOP_GUARD?.trim().toLowerCase();
+  return value !== "0" && value !== "false" && value !== "off";
+}
 var QUOTE_RULE = " Inside the reasoning, quote the output with single quotes, never with unescaped double quotes.";
 var VERDICT_FIRST_CONTRACT = 'Respond with ONLY a JSON object: {"pass": true/false, "reasoning": "your reasoning"}.' + QUOTE_RULE;
 var REASONING_FIRST_CONTRACT = 'Respond with ONLY a JSON object: {"reasoning": "your reasoning", "pass": true/false}.' + QUOTE_RULE;
@@ -952,7 +1114,7 @@ function retryDelayMs(retryAfter) {
   if (!Number.isFinite(ms)) return JUDGE_RETRY_DELAY_MS;
   return Math.min(Math.max(ms, JUDGE_RETRY_DELAY_MS), JUDGE_RETRY_AFTER_CAP_MS);
 }
-async function readCompletion(response, onData) {
+async function readCompletion(response, onData, guards) {
   const contentType = response.headers.get("content-type") ?? "";
   if (!contentType.includes("text/event-stream")) {
     const data = await response.json();
@@ -989,7 +1151,15 @@ async function readCompletion(response, onData) {
     }
     if (!chunk) return;
     const choice = chunk.choices?.[0];
-    text += choice?.delta?.content ?? "";
+    const content = choice?.delta?.content ?? "";
+    text += content;
+    if (guards) {
+      const thinking = choice?.delta?.reasoning_content ?? choice?.delta?.reasoning ?? "";
+      const reasoningTrip = guards.reasoning.push(thinking);
+      if (reasoningTrip) throw new JudgeReasoningLoopError(reasoningTrip, "reasoning");
+      const contentTrip = guards.content.push(content);
+      if (contentTrip) throw new JudgeReasoningLoopError(contentTrip, "content");
+    }
     if (choice?.finish_reason) finishReason = choice.finish_reason;
     if (chunk.usage) usage = chunk.usage;
   };
@@ -1023,7 +1193,13 @@ async function readCompletion(response, onData) {
   dispatch();
   return { text, usage, finishReason };
 }
-var prefixQueues = /* @__PURE__ */ new Map();
+var prefixLanes = /* @__PURE__ */ new Map();
+function judgeConcurrency() {
+  const raw = process.env.APO_JUDGE_CONCURRENCY?.trim();
+  if (!raw) return 1;
+  const n = Number(raw);
+  return Number.isInteger(n) && n >= 1 ? n : 1;
+}
 function promptCacheKey(prefix) {
   return `apo-${createHash("sha256").update(prefix).digest("hex").slice(0, 32)}`;
 }
@@ -1055,16 +1231,36 @@ async function fetchWithPromptCacheKey(input, init) {
   return retry;
 }
 function runWithSharedPrefix(key, task2) {
-  const prev = prefixQueues.get(key) ?? Promise.resolve();
-  const next = prev.then(task2, task2);
-  prefixQueues.set(
-    key,
-    next.then(
-      () => void 0,
-      () => void 0
-    )
-  );
-  return next;
+  const existing = prefixLanes.get(key);
+  if (!existing) {
+    const warmer = task2();
+    prefixLanes.set(key, {
+      warmed: warmer.then(
+        () => void 0,
+        () => void 0
+      ),
+      active: 0,
+      waiting: []
+    });
+    return warmer;
+  }
+  const lane = existing;
+  const acquire = () => new Promise((resolve5) => {
+    if (lane.active < judgeConcurrency()) {
+      lane.active += 1;
+      resolve5();
+    } else {
+      lane.waiting.push(() => {
+        lane.active += 1;
+        resolve5();
+      });
+    }
+  });
+  const release = () => {
+    lane.active -= 1;
+    lane.waiting.shift()?.();
+  };
+  return lane.warmed.then(acquire).then(() => task2().finally(release));
 }
 function defaultJudgeBaseURL(baseURL) {
   return baseURL ?? process.env.OPENROUTER_BASE_URL ?? "https://openrouter.ai/api/v1";
@@ -1166,9 +1362,16 @@ async function callJudge(args) {
           ...schema && response.status === 400 && /json_schema|response_format/.test(body) ? { schemaRejected: true } : {}
         };
       }
+      const guards = isJudgeLoopGuardEnabled() ? {
+        reasoning: new RepetitionGuard({ diversity: true }),
+        content: new RepetitionGuard({ diversity: false })
+      } : void 0;
       try {
-        return { kind: "completion", completion: await readCompletion(response, onData) };
+        return { kind: "completion", completion: await readCompletion(response, onData, guards) };
       } catch (error) {
+        if (error instanceof JudgeReasoningLoopError) {
+          return { kind: "unavailable", error, retryable: true, loop: true };
+        }
         return transportFailure("Judge response failed", controller.signal.reason ?? error);
       }
     } finally {
@@ -1202,6 +1405,7 @@ async function callJudge(args) {
       if (result.schemaRejected) schema = false;
       result = await attempt(stream, schema, deadline);
     }
+    let loops = result.kind === "unavailable" && result.loop ? 1 : 0;
     const noVerdict = (r) => r.kind === "completion" && (isTruncated(r.completion) || judgeVerdict(r.completion.text) === void 0);
     const retryable = result.kind === "unavailable" && result.retryable;
     if (noVerdict(result) || retryable) {
@@ -1210,6 +1414,7 @@ async function callJudge(args) {
         await new Promise((resolve5) => setTimeout(resolve5, delay));
         const first = result;
         result = await attempt(stream, schema, deadline);
+        if (result.kind === "unavailable" && result.loop) loops++;
         if (result.kind === "unavailable" && first.kind === "unavailable") {
           result = {
             ...result,
@@ -1220,17 +1425,25 @@ async function callJudge(args) {
         }
       }
     }
-    if (result.kind === "unavailable") throw result.error;
-    const { text, usage } = result.completion;
-    const judge = {
+    const judgeMetadata = async (completion) => ({
       model: args.model,
       contract: judgeContractInUse(),
       prompt: { system: systemPromptText, user: instructionText },
-      response: text,
-      tokens: parseJudgeUsage(usage),
+      ...completion ? { response: completion.text, tokens: parseJudgeUsage(completion.usage) } : {},
       latency_ms: Date.now() - startedAt,
-      secondJudge: await secondJudgePromise
-    };
+      secondJudge: await secondJudgePromise,
+      ...loops > 0 ? { reasoning_loops: loops } : {}
+    });
+    if (result.kind === "unavailable" && result.loop) {
+      return {
+        pass: false,
+        reasoning: `Judge reasoning loop \u2014 the judge's stream degenerated into repetition and was cut${loops > 1 ? ", on the retry too" : ""} (${result.error.message}). The verdict is unknown, so this check is recorded as a judge error, not a verdict.`,
+        judge: await judgeMetadata(),
+        unavailable: true
+      };
+    }
+    if (result.kind === "unavailable") throw result.error;
+    const judge = await judgeMetadata(result.completion);
     if (isTruncated(result.completion)) {
       return {
         pass: false,
@@ -1239,11 +1452,11 @@ async function callJudge(args) {
         unavailable: true
       };
     }
-    const verdict = judgeVerdict(text);
+    const verdict = judgeVerdict(result.completion.text);
     if (verdict === void 0) {
       return {
         pass: false,
-        reasoning: "Judge reply carried no verdict (no boolean `pass`) on two draws. The verdict is unknown, so this check is recorded as a judge error, not a verdict. The raw reply is on the judge metadata.",
+        reasoning: "Judge reply carried no verdict (no boolean `pass`). The verdict is unknown, so this check is recorded as a judge error, not a verdict. The raw reply is on the judge metadata.",
         judge,
         unavailable: true
       };
@@ -1886,10 +2099,15 @@ function buildEvidenceTools(args) {
           }
           const unsupported = rejectUnsupportedPcreConstructs(pattern);
           if (unsupported) return { error: unsupported };
+          let translated;
+          try {
+            translated = stripLeadingPcreFlags(pattern);
+          } catch (error) {
+            return { error: `invalid regex: ${error instanceof Error ? error.message : String(error)}` };
+          }
           let re;
           try {
-            const stripped = stripLeadingPcreFlags(pattern);
-            re = new RegExp(stripped.pattern, stripped.flags);
+            re = new RegExp(translated.pattern, translated.flags);
           } catch (error) {
             return {
               error: `invalid regex: ${error instanceof Error ? error.message : String(error)} \u2014 patterns compile as case-insensitive multiline; leading PCRE flags like (?i) are stripped automatically`
@@ -4410,12 +4628,13 @@ function sleep(ms) {
 
 // src/agent-task/checks/agent-history.ts
 function createBackendReaderFromEnv(env = process.env) {
+  const apiKey = env.APO_API_KEY;
   const token = env.APO_AUTH_TOKEN;
   const publicKey = env.APO_PUBLIC_KEY;
   const secretKey = env.APO_SECRET_KEY;
-  const headers = token ? { Authorization: `Bearer ${token}` } : publicKey && secretKey ? { Authorization: `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString("base64")}` } : void 0;
+  const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : token ? { Authorization: `Bearer ${token}` } : publicKey && secretKey ? { Authorization: `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString("base64")}` } : void 0;
   if (!headers) return void 0;
-  const endpoint = env.APO_BACKEND_URL ?? env.AGENT_TASK_TRACE_ENDPOINT ?? "http://127.0.0.1:8000";
+  const endpoint = env.APO_BACKEND_URL ?? "http://127.0.0.1:8000";
   return {
     async get(path) {
       const res = await fetch(`${endpoint.replace(/\/$/, "")}/v1${path}`, { headers });
@@ -4429,10 +4648,23 @@ function createBackendReaderFromEnv(env = process.env) {
 function freezeHistoryPlane(args) {
   const { reader, taskId, selfRunId } = args;
   const detailCache = /* @__PURE__ */ new Map();
+  const listByTaskId = async (id) => await reader.get(
+    `/agent-task-runs?task_id=${encodeURIComponent(id)}&limit=50`
+  );
   const loadRuns = (async () => {
-    const raw = await reader.get(
-      `/agent-task-runs?task_id=${encodeURIComponent(taskId)}&limit=50`
-    );
+    let raw = await listByTaskId(taskId);
+    if ((raw ?? []).length === 0 && selfRunId) {
+      try {
+        const self = await reader.get(
+          `/agent-task-runs/${encodeURIComponent(selfRunId)}`
+        );
+        const canonical = self?.task_id;
+        if (typeof canonical === "string" && canonical !== taskId) {
+          raw = await listByTaskId(canonical);
+        }
+      } catch {
+      }
+    }
     return (raw ?? []).map(
       (r) => ({
         id: String(r.id),
@@ -4496,7 +4728,9 @@ async function freezeHistoryPlaneFromEnv(taskId, env = process.env) {
       taskId,
       ...env.AGENT_TASK_RUN_ID ? { selfRunId: env.AGENT_TASK_RUN_ID } : {}
     });
-  } catch {
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    console.warn(`apo: judge history plane unavailable \u2014 ${reason}`);
     return void 0;
   }
 }
@@ -6365,6 +6599,9 @@ function createOtelAgentTaskTraceClient(config) {
         params.reasoning_tokens
       );
     }
+    if (params.served_model) {
+      active.span.setAttribute("gen_ai.response.model", params.served_model);
+    }
     if (params.status_message) {
       active.span.setAttribute("apo.status_message", params.status_message);
     }