crosscheck-mcp 0.2.28 → 0.2.29

package/dist/embed.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/entrypoints/embed.ts
 var embed_exports = {};
 __export(embed_exports, {
+  ACTIVITY_TEXT_CAP: () => ACTIVITY_TEXT_CAP,
   DEFAULT_EXCLUDED_PROVIDERS: () => DEFAULT_EXCLUDED_PROVIDERS,
   DEFAULT_FALLBACKS: () => DEFAULT_FALLBACKS,
   DEFAULT_MODELS: () => DEFAULT_MODELS,
@@ -49,6 +50,7 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/entrypoints/embed.ts
+var import_node_async_hooks2 = require("async_hooks");
 var import_node_fs16 = require("fs");
 var import_node_path15 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
@@ -533,6 +535,52 @@ function rejectsDisabledThinking(model) {
   const m = model.toLowerCase();
   return ADAPTIVE_THINKING_PREFIXES.some((p) => m.startsWith(p));
 }
+var NO_FORCED_TOOL_PREFIXES = [
+  "claude-fable-5-1",
+  "claude-mythos-5-1",
+  "claude-opus-5-5",
+  "claude-sonnet-5-5"
+];
+function rejectsForcedToolUse(model) {
+  const m = model.toLowerCase();
+  return NO_FORCED_TOOL_PREFIXES.some((p) => m.startsWith(p));
+}
+var UNSUPPORTED_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "minProperties",
+  "maxProperties",
+  "$schema"
+]);
+function toStructuredOutputSchema(schema) {
+  const walk = (node) => {
+    if (Array.isArray(node)) return node.map(walk);
+    if (!node || typeof node !== "object") return node;
+    const out = {};
+    for (const [k, v] of Object.entries(node)) {
+      if (UNSUPPORTED_SCHEMA_KEYS.has(k)) continue;
+      if (k === "properties" && v && typeof v === "object") {
+        out[k] = Object.fromEntries(Object.entries(v).map(([pk, pv]) => [pk, walk(pv)]));
+      } else if (["items", "anyOf", "allOf", "oneOf", "not", "$defs", "definitions"].includes(k)) {
+        out[k] = k === "$defs" || k === "definitions" ? Object.fromEntries(Object.entries(v ?? {}).map(([dk, dv]) => [dk, walk(dv)])) : walk(v);
+      } else {
+        out[k] = v;
+      }
+    }
+    if (out["type"] === "object" || "properties" in out) out["additionalProperties"] = false;
+    return out;
+  };
+  return walk(schema);
+}
 var ANTHROPIC_STRUCTURED_TOOL_NAME = "structured_output";
 function applyPromptCaching(body, env = process.env) {
   const flag = (env["CROSSCHECK_ANTHROPIC_PROMPT_CACHE"] ?? "").trim();
@@ -584,7 +632,12 @@ function buildAnthropicRequest(opts) {
       body.thinking = { type: "disabled" };
     }
   }
-  if (opts.jsonSchema) {
+  if (opts.jsonSchema && rejectsForcedToolUse(opts.model)) {
+    body.output_config = {
+      ...body.output_config ?? {},
+      format: { type: "json_schema", schema: toStructuredOutputSchema(opts.jsonSchema) }
+    };
+  } else if (opts.jsonSchema) {
     body.tools = [{
       name: ANTHROPIC_STRUCTURED_TOOL_NAME,
       description: "Emit a single JSON object matching the requested schema.",
@@ -985,7 +1038,15 @@ function buildOpenAICompatibleRequest(opts) {
       json_schema: {
         name: "structured_output",
         schema: opts.jsonSchema,
-        strict: true
+        // NOT strict. Strict mode requires `additionalProperties: false` on
+        // every object and every property listed in `required` — the
+        // engine's schemas don't meet that, so every structured OpenAI call
+        // (planner, judges, synthesis) was a 400, unnoticed until the canary
+        // grew a structured check (2026-10-11). Non-strict still shapes the
+        // reply to the schema, and structured.ts validates it against the
+        // full schema regardless, so strictness added a failure mode and no
+        // safety.
+        strict: false
       }
     };
   }
@@ -1273,7 +1334,7 @@ var import_zod = require("zod");
 
 // src/server-meta.ts
 var SERVER_NAME = "crosscheck-agent";
-var SERVER_VERSION = true ? "0.2.28" : "0.0.0-dev";
+var SERVER_VERSION = true ? "0.2.29" : "0.0.0-dev";
 
 // src/tools/audit.ts
 var import_node_fs4 = require("fs");
@@ -6369,6 +6430,19 @@ var import_node_perf_hooks6 = require("perf_hooks");
 var import_node_async_hooks = require("async_hooks");
 var import_node_perf_hooks5 = require("perf_hooks");
 var progressStorage = new import_node_async_hooks.AsyncLocalStorage();
+async function withProgress(token, sendNotification, fn) {
+  if (token === void 0 || token === null) {
+    return fn();
+  }
+  const ctx = {
+    token,
+    wallStart: import_node_perf_hooks5.performance.now(),
+    cpuStart: process.cpuUsage(),
+    step: { value: 0 },
+    sendNotification
+  };
+  return progressStorage.run(ctx, fn);
+}
 async function emitProgress(message, opts) {
   const ctx = progressStorage.getStore();
   const wallStart = ctx ? ctx.wallStart : import_node_perf_hooks5.performance.now();
@@ -7888,6 +7962,16 @@ function buildCallContext(args) {
 var CREATE_DOC_MAX_BYTES = 32 * 1024;
 var CREATE_AUDIT_THRESHOLD = 0.7;
 async function runCreate(args, opts) {
+  const subEnvelopes = [];
+  const tracked = (fn) => async (...a) => {
+    const out = await fn(...a);
+    subEnvelopes.push(out);
+    return out;
+  };
+  const confer = tracked(runConfer);
+  const orchestrate = tracked(runOrchestrate);
+  const review = tracked(runReview);
+  const audit = tracked(runAudit);
   const instruction = typeof args["instruction"] === "string" ? args["instruction"] : String(args["instruction"] ?? "");
   if (!instruction) {
     return errorEnvelope6(
@@ -7924,7 +8008,7 @@ ${constraints}
 
 ` : "") + `DOCUMENTS (${okCount} of ${descriptors.length} ingested):
 ${documentsPayload}`;
-  const scope = await runConfer({
+  const scope = await confer({
     question: "We are about to orchestrate a full plan->build->review->audit lifecycle for this instruction. List 3-6 concrete sub-tasks (each with a one-line description and a difficulty: low|med|high), any critical assumptions, and any missing-information risks. Be concise and decisive \u2014 your output will be used to build the orchestration DAG.\n\nINSTRUCTION:\n" + instruction,
     context: contextBlock,
     ...providers !== void 0 ? { providers } : {},
@@ -7951,7 +8035,7 @@ ${scopeAnswer || "(none)"}
   };
   if (providers !== void 0) orchestrateArgs["providers"] = providers;
   if (planOnly) orchestrateArgs["plan_only"] = true;
-  let orchestration = await runOrchestrate(orchestrateArgs, {
+  let orchestration = await orchestrate(orchestrateArgs, {
     providers: opts.providers,
     allowlist: opts.allowlist ?? null,
     moderator,
@@ -7980,7 +8064,7 @@ ${scopeAnswer || "(none)"}
   }
   let reviewEnvelope = null;
   if (!skipReview && typeof orchestration["final"] === "string" && orchestration["final"]) {
-    reviewEnvelope = await runReview({
+    reviewEnvelope = await review({
       snippet: orchestration["final"],
       intent: `final deliverable for: ${instruction}`,
       ...providers !== void 0 ? { providers } : {},
@@ -8000,7 +8084,7 @@ ${scopeAnswer || "(none)"}
     const panelExhausted = producingPanel.length > 0 && producingPanel.every(
       (p) => p in opts.providers || Object.keys(opts.providers).includes(p.toLowerCase())
     ) && producingPanel.length >= Object.keys(opts.providers).length;
-    auditEnvelope = await runAudit({
+    auditEnvelope = await audit({
       output_to_audit: orchestration["final"],
       producing_panelists: producingPanel,
       ...auditRubric !== void 0 ? { rubric: auditRubric } : {},
@@ -8029,7 +8113,7 @@ ${retryConstraints}
 DOCUMENTS:
 ${documentsPayload}`
       };
-      const retryOrchestration = await runOrchestrate(
+      const retryOrchestration = await orchestrate(
         retryOrchestrateArgs,
         {
           providers: opts.providers,
@@ -8043,7 +8127,7 @@ ${documentsPayload}`
       if (typeof retryOrchestration["final"] === "string" && retryOrchestration["final"]) {
         const retryPanel = computeProducingPanel(retryOrchestration);
         const retryPanelExhausted = retryPanel.length > 0 && retryPanel.length >= Object.keys(opts.providers).length;
-        auditEnvelope = await runAudit({
+        auditEnvelope = await audit({
           output_to_audit: retryOrchestration["final"],
           producing_panelists: retryPanel,
           ...auditRubric !== void 0 ? { rubric: auditRubric } : {},
@@ -8118,9 +8202,28 @@ ${documentsPayload}`
       ["auditor", "items", "overall_score", "passed", "rubric"]
     ),
     artifacts,
-    warnings
+    warnings,
+    ...combinedUsage(subEnvelopes)
   };
 }
+function combinedUsage(envelopes) {
+  const usages = [];
+  const byCallTiming = [];
+  let wall = 0, cpu = 0;
+  for (const env of envelopes) {
+    const e = env ?? {};
+    const calls = e["usage"]?.["by_call"] ?? [];
+    const t = e["timing"] ?? {};
+    const timing = Array.isArray(t["by_call"]) ? t["by_call"] : [];
+    if (!Array.isArray(calls) || calls.length === 0) continue;
+    usages.push(...calls);
+    if (timing.length === calls.length) byCallTiming.push(...timing);
+    else for (const c of calls) byCallTiming.push({ provider: c.provider, model: c.model, purpose: c.purpose ?? null, wall_ms: 0, cpu_ms: 0, cache_hit: false });
+    wall += Number(t["wall_ms"] ?? 0) || 0;
+    cpu += Number(t["cpu_ms"] ?? 0) || 0;
+  }
+  return { usage: aggregateUsage(usages), timing: { wall_ms: wall, cpu_ms: cpu, by_call: byCallTiming } };
+}
 async function ingestDocuments(documents, sessionId, opts) {
   if (documents.length === 0) return [];
   const out = [];
@@ -11597,7 +11700,7 @@ var CHECK_INTERVAL_SECONDS = 3 * 24 * 60 * 60;
 var DEFAULT_PACKAGE = "crosscheck-cli";
 var FETCH_TIMEOUT_MS = 3e3;
 function engineVersion() {
-  return true ? "0.2.28" : "0.0.0-dev";
+  return true ? "0.2.29" : "0.0.0-dev";
 }
 function defaultUpdateCachePath() {
   const base = process.env["CROSSCHECK_DATA_DIR"] || import_node_path12.default.join(import_node_os2.default.homedir() || import_node_os2.default.tmpdir(), ".crosscheck");
@@ -13388,6 +13491,107 @@ var ENGINE_TO_VAULT = { xai: "grok" };
 function vaultId(engineName) {
   return ENGINE_TO_VAULT[engineName] ?? engineName;
 }
+var ACTIVITY_TEXT_CAP = 8e3;
+var ASKED_CAP = 280;
+var runContext = new import_node_async_hooks2.AsyncLocalStorage();
+var SYNTHESIS_PURPOSES = /* @__PURE__ */ new Set(["synth", "moderator", "recombine", "judge", "unify"]);
+function exemptFromSkip(ctx, provider, purpose) {
+  return provider === ctx.moderator && SYNTHESIS_PURPOSES.has(purpose);
+}
+function skippedError(provider, why, limitMs) {
+  return new ProviderError(
+    "client",
+    why === "timeout" ? `${provider}: stopped after ${Math.round((limitMs ?? 0) / 1e3)}s (your per-model time limit)` : `${provider}: stopped waiting (you skipped it)`,
+    { transient: false }
+  );
+}
+function lastUserText(args) {
+  const msgs = args.messages;
+  for (let i = msgs.length - 1; i >= 0; i--) {
+    const m = msgs[i];
+    if (m && m.role === "user" && typeof m.content === "string") {
+      const t = m.content.replace(/\s+/g, " ").trim();
+      return t.length > ASKED_CAP ? `${t.slice(0, ASKED_CAP - 1)}\u2026` : t;
+    }
+  }
+  return "";
+}
+function withActivity(p) {
+  const send = p.send.bind(p);
+  return {
+    name: p.name,
+    model: p.model,
+    ...p.fallbackModels ? { fallbackModels: p.fallbackModels } : {},
+    send: async (args) => {
+      const ctx = runContext.getStore();
+      if (!ctx) return send(args);
+      const callId = ctx.nextCallId();
+      const provider = vaultId(p.name);
+      const model = args.modelOverride ?? p.model;
+      const purpose = args.purpose ?? "worker";
+      const started = Date.now();
+      const exempt = exemptFromSkip(ctx, provider, purpose);
+      if (!exempt && ctx.skipped.has(provider)) throw skippedError(provider, "user");
+      ctx.emit({ type: "call.start", runId: ctx.runId, at: started, callId, provider, model, purpose, asked: lastUserText(args) });
+      const controller = new AbortController();
+      if (args.signal) {
+        if (args.signal.aborted) controller.abort(args.signal.reason);
+        else args.signal.addEventListener("abort", () => controller.abort(args.signal.reason), { once: true });
+      }
+      let stopped;
+      if (!exempt) ctx.inflight.set(callId, { provider, purpose, controller });
+      const timer = !exempt && ctx.callTimeoutMs && ctx.callTimeoutMs > 0 ? setTimeout(() => {
+        stopped = "timeout";
+        controller.abort("timeout");
+      }, ctx.callTimeoutMs) : void 0;
+      controller.signal.addEventListener("abort", () => {
+        if (!stopped && controller.signal.reason === "skip") stopped = "user";
+      }, { once: true });
+      try {
+        const res = await send({ ...args, signal: controller.signal });
+        const text = typeof res.text === "string" ? res.text : "";
+        ctx.emit({
+          type: "call.done",
+          runId: ctx.runId,
+          at: Date.now(),
+          callId,
+          provider,
+          model,
+          purpose,
+          ok: true,
+          ms: Date.now() - started,
+          text: text.slice(0, ACTIVITY_TEXT_CAP),
+          truncated: text.length > ACTIVITY_TEXT_CAP,
+          error: null,
+          usage: usageOf(res)
+        });
+        return res;
+      } catch (err) {
+        const out = stopped ? skippedError(provider, stopped, ctx.callTimeoutMs) : err;
+        ctx.emit({
+          type: "call.done",
+          runId: ctx.runId,
+          at: Date.now(),
+          callId,
+          provider,
+          model,
+          purpose,
+          ok: false,
+          ms: Date.now() - started,
+          text: "",
+          truncated: false,
+          error: out instanceof Error ? out.message : String(out),
+          usage: null,
+          ...stopped ? { stopped } : {}
+        });
+        throw out;
+      } finally {
+        if (timer) clearTimeout(timer);
+        ctx.inflight.delete(callId);
+      }
+    }
+  };
+}
 function usageOf(answer) {
   const u = answer["usage"];
   if (!u || typeof u !== "object") return null;
@@ -13423,6 +13627,8 @@ function bundledPricingPath() {
   }
 }
 var runCounter = 0;
+var callCounter = 0;
+var nextCallId = () => ++callCounter;
 function nextRunId() {
   runCounter += 1;
   return `run_${Date.now().toString(36)}_${runCounter}`;
@@ -13441,7 +13647,9 @@ function createEmbeddedEngine(opts) {
     (p) => Boolean(p) && (0, import_node_fs16.existsSync)(p)
   );
   const pricing = pricingPath ? loadPricing(pricingPath) : {};
-  const built = buildProviders({ env, pricing });
+  const built = Object.fromEntries(
+    Object.entries(buildProviders({ env, pricing })).map(([name, p]) => [name, withActivity(p)])
+  );
   const moderator = opts.moderator ?? "anthropic";
   const tools = registerCoreTools({ providers: built, pricing });
   const providerIds = Object.keys(built).map(vaultId).sort();
@@ -13458,7 +13666,8 @@ function createEmbeddedEngine(opts) {
     if (!tool) return Promise.reject(new Error(`unknown tool: ${name}`));
     return Promise.resolve(tool.handler(args));
   };
-  const run = async (name, args, onEvent) => {
+  const liveRuns = /* @__PURE__ */ new Map();
+  const run = async (name, args, onEvent, runOpts = {}) => {
     const runId = nextRunId();
     const started = Date.now();
     const emit = (e) => {
@@ -13467,6 +13676,78 @@ function createEmbeddedEngine(opts) {
       } catch {
       }
     };
+    const ctx = {
+      runId,
+      emit,
+      nextCallId,
+      skipped: /* @__PURE__ */ new Set(),
+      inflight: /* @__PURE__ */ new Map(),
+      moderator: vaultId(moderator),
+      ...runOpts.callTimeoutMs && runOpts.callTimeoutMs > 0 ? { callTimeoutMs: runOpts.callTimeoutMs } : {}
+    };
+    liveRuns.set(runId, ctx);
+    try {
+      return await runContext.run(ctx, () => withProgress(runId, (n) => {
+        if (n.params.message) emit({ type: "progress", runId, at: Date.now(), message: n.params.message });
+      }, () => runInner(name, args, runId, started, emit)));
+    } finally {
+      liveRuns.delete(runId);
+    }
+  };
+  const skip = (runId, provider) => {
+    const ctx = liveRuns.get(runId);
+    if (!ctx) return 0;
+    ctx.skipped.add(provider);
+    let stopped = 0;
+    for (const call2 of ctx.inflight.values()) {
+      if (call2.provider === provider && !exemptFromSkip(ctx, call2.provider, call2.purpose)) {
+        call2.controller.abort("skip");
+        stopped += 1;
+      }
+    }
+    return stopped;
+  };
+  const ask = async (o) => {
+    const engineName = Object.keys(built).find((n) => vaultId(n) === o.provider);
+    const base = engineName ? built[engineName] : void 0;
+    if (!base) {
+      return { ok: false, text: "", json: null, model: o.model ?? "", error: `No ${o.provider} key is configured, so it can't be asked.` };
+    }
+    const provider = o.model && o.model !== base.model ? retargetProvider(base, o.model) : base;
+    const maxTokens = o.maxTokens ?? 8e3;
+    const doAsk = async () => {
+      if (o.schema) {
+        const res = await requestStructured(provider, o.messages, o.schema, { maxTokens, purpose: o.purpose, maxRetries: 1 });
+        return {
+          ok: res.obj !== null,
+          text: res.answer.response ?? "",
+          json: res.obj,
+          error: res.obj !== null ? null : res.answer.error ?? res.errors.join("; ") ?? "invalid reply",
+          model: provider.model
+        };
+      }
+      const a = await askOne(provider, o.messages, { maxTokens, temperature: 0.3, purpose: o.purpose });
+      return { ok: !a.error, text: a.response ?? "", json: null, error: a.error ?? null, model: provider.model };
+    };
+    if (!o.runId || !o.onEvent) return doAsk();
+    const sink = o.onEvent;
+    const emit = (e) => {
+      try {
+        sink(e);
+      } catch {
+      }
+    };
+    const ctx = {
+      runId: o.runId,
+      emit,
+      nextCallId,
+      skipped: /* @__PURE__ */ new Set(),
+      inflight: /* @__PURE__ */ new Map(),
+      moderator: o.provider
+    };
+    return runContext.run(ctx, doAsk);
+  };
+  const runInner = async (name, args, runId, started, emit) => {
     emit({
       type: "run.start",
       runId,
@@ -13544,8 +13825,16 @@ function createEmbeddedEngine(opts) {
     providers: providerIds,
     models,
     listTools: () => [...tools.keys()],
+    requiredArgs: (name) => {
+      const tool = tools.get(name);
+      if (!tool) return null;
+      const req = tool.inputSchema?.required;
+      return Array.isArray(req) ? req.filter((x) => typeof x === "string") : [];
+    },
     call,
     run,
+    skip,
+    ask,
     close: async () => {
       await flush().catch(() => {
       });
@@ -13555,6 +13844,7 @@ function createEmbeddedEngine(opts) {
 var __test_internals = { usageOf, textOf, errorOf, vaultId };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACTIVITY_TEXT_CAP,
   DEFAULT_EXCLUDED_PROVIDERS,
   DEFAULT_FALLBACKS,
   DEFAULT_MODELS,