@tangle-network/agent-runtime 0.90.0 → 0.91.0

package/dist/agent.d.ts

@@ -1,7 +1,7 @@
 import * as _tangle_network_agent_eval from '@tangle-network/agent-eval';
 import { TraceAnalystKindSpec, AnalystFinding } from '@tangle-network/agent-eval';
 import { A as ArtifactKind, C as CandidateGenerator, P as PromotionGate } from './generator-YkAQrOoD.js';
-import { a as RuntimeStreamEvent, S as SandboxClient, b as OutputAdapter, A as AgentRunSpec } from './types-Dnk189QA.js';
+import { b as RuntimeStreamEvent, S as SandboxClient, c as OutputAdapter, A as AgentRunSpec } from './types-SyuwunY_.js';
 import { A as AgentSurfaces } from './improvement-adapter-CDR8QNVM.js';
 export { C as CreateSurfaceImprovementAdapterOpts, D as DraftPatchInput, a as DraftPatchOutput, R as ResolvedSurface, S as SurfaceImprovementEdit, b as SurfaceValidationIssue, c as createSurfaceImprovementAdapter, r as renderSurfaceIssues, d as resolveSubjectPath, v as validateSurfaces } from './improvement-adapter-CDR8QNVM.js';
 import { K as KnowledgeAdapter, a as RunAnalystLoopResult } from './types-BC3bZpH0.js';

package/dist/agent.js

@@ -1,14 +1,14 @@
-import "./chunk-4IBAMGBE.js";
+import "./chunk-AD7JW4QG.js";
 import {
   createSandboxForSpec
-} from "./chunk-QSNSMJSZ.js";
+} from "./chunk-NC66AM3S.js";
 import "./chunk-DPEUKJRO.js";
-import "./chunk-UD4BHQMI.js";
+import "./chunk-IVGYLCFH.js";
 import "./chunk-BZF3KQ6G.js";
 import {
   mapSandboxEvent
 } from "./chunk-FVJ7M3DA.js";
-import "./chunk-7LO5GMAO.js";
+import "./chunk-CMYMTRGA.js";
 import {
   ValidationError
 } from "./chunk-YEJR7IXO.js";

package/dist/analyst-loop.d.ts

@@ -1,5 +1,5 @@
 import { TraceAnalystByteBudgets, TraceAnalysisStore } from '@tangle-network/agent-eval';
-import { I as Iteration } from './types-Dnk189QA.js';
+import { I as Iteration } from './types-SyuwunY_.js';
 import { R as RunAnalystLoopOpts, a as RunAnalystLoopResult } from './types-BC3bZpH0.js';
 export { A as AnalystLoopEvent, b as AnalystRegistryLike, c as AnalystRegistryStreamingLike, d as AutoApplyPolicy, F as FindingsStoreLike, I as ImprovementAdapter, e as ImprovementEditBatch, f as ImprovementReport, K as KnowledgeAdapter, g as KnowledgeProposalBatch, h as KnowledgeReport } from './types-BC3bZpH0.js';
 import '@tangle-network/sandbox';

package/dist/{chunk-4WXGK6GV.js → chunk-7ON74BQO.js}

@@ -1,7 +1,7 @@
 import {
   buildLoopOtelSpans,
   createOtelExporter
-} from "./chunk-UD4BHQMI.js";
+} from "./chunk-IVGYLCFH.js";
 
 // src/mcp/trace-propagation.ts
 function readTraceContextFromEnv() {
@@ -49,4 +49,4 @@ export {
   createPropagatingTraceEmitter,
   traceContextToEnv
 };
-//# sourceMappingURL=chunk-4WXGK6GV.js.map
+//# sourceMappingURL=chunk-7ON74BQO.js.map

package/dist/{chunk-4IBAMGBE.js → chunk-AD7JW4QG.js}

@@ -15,7 +15,7 @@ import {
   settledToIteration,
   supervise,
   withDriverExecutor
-} from "./chunk-QSNSMJSZ.js";
+} from "./chunk-NC66AM3S.js";
 import {
   addTokenUsage,
   isAbortError,
@@ -2738,20 +2738,29 @@ async function consultAnalyst(task, messages, instruction, opts) {
   const trajectory = compactTrajectory(messages);
   const analystModel = opts.analystModel ?? opts.model;
   const chat = analystChat(opts, analystModel);
+  const consultMessages = trajectory ? [
+    { role: "system", content: instruction },
+    {
+      role: "user",
+      content: `TASK: ${task.userPrompt.slice(0, 1500)}
+
+TRAJECTORY:
+${trajectory}`
+    }
+  ] : [
+    {
+      role: "user",
+      content: `${instruction}
+
+TASK:
+${task.userPrompt.slice(0, 1500)}`
+    }
+  ];
   const res = await chat.chat({
     model: analystModel,
     temperature: 0.2,
     maxTokens: 1024,
-    messages: [
-      { role: "system", content: instruction },
-      {
-        role: "user",
-        content: `TASK: ${task.userPrompt.slice(0, 1500)}
-
-TRAJECTORY:
-${trajectory}`
-      }
-    ]
+    messages: consultMessages
   });
   const usage = res.usage;
   return {
@@ -5029,6 +5038,381 @@ function deriveTurnSignal(callerSignal, timeoutMs) {
   };
 }
 
+// src/runtime/structural-rollout.ts
+import { randomBytes } from "crypto";
+var defaultStructuralRolloutPolicy = {
+  k: 5,
+  repairRounds: 2,
+  testgen: 6
+};
+function resolvePolicy(overrides) {
+  const policy = { ...defaultStructuralRolloutPolicy, ...overrides };
+  if (!Number.isInteger(policy.k) || policy.k < 1) {
+    throw new Error(`structuralRollout: policy.k must be an integer >= 1, got ${policy.k}`);
+  }
+  if (!Number.isInteger(policy.repairRounds) || policy.repairRounds < 0) {
+    throw new Error(
+      `structuralRollout: policy.repairRounds must be an integer >= 0, got ${policy.repairRounds}`
+    );
+  }
+  if (!Number.isInteger(policy.testgen) || policy.testgen < 0) {
+    throw new Error(
+      `structuralRollout: policy.testgen must be an integer >= 0, got ${policy.testgen}`
+    );
+  }
+  return policy;
+}
+var authorInstruction = (count, entry) => `Read the task below. Write exactly ${count} single-line assert statements that test the function \`${entry}\`, based ONLY on the behavior the task itself describes. Each assert must be one physical line of the form \`assert ${entry}(...) == expected\` (or a True/False check). Do NOT implement the function. Do NOT copy shown examples verbatim if you can test other cases too. Output ONLY the assert lines inside a single \`\`\`python code block.`;
+function filterAuthoredAsserts(reply, entrySymbol, count) {
+  const fences = [...reply.matchAll(/```(?:python|py)?\s*\n([\s\S]*?)```/gi)].map(
+    (m) => (m[1] ?? "").trim()
+  );
+  const block = fences.length > 0 ? fences.join("\n") : reply;
+  const balanced = (s) => {
+    let d = 0;
+    for (const ch of s) {
+      if (ch === "(" || ch === "[" || ch === "{") d += 1;
+      else if (ch === ")" || ch === "]" || ch === "}") d -= 1;
+      if (d < 0) return false;
+    }
+    return d === 0;
+  };
+  return block.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("assert ") && l.includes(entrySymbol) && balanced(l)).slice(0, count);
+}
+function modelAuthoredChecks(overrides = {}) {
+  return {
+    async generate(_task, ctx) {
+      const count = overrides.count ?? ctx.count;
+      if (count <= 0 || !ctx.entrySymbol) return [];
+      const entry = ctx.entrySymbol;
+      const reply = await ctx.consult(authorInstruction(count, entry));
+      if (!reply) return [];
+      return filterAuthoredAsserts(reply, entry, count).map((code) => ({
+        code,
+        kind: "authored"
+      }));
+    }
+  };
+}
+function officialChecksFromMeta(key = "visibleChecks") {
+  return {
+    async generate(task) {
+      const raw = task.meta?.[key];
+      if (!Array.isArray(raw)) return [];
+      return raw.filter((c) => typeof c === "string" && c.trim().length > 0).map((code) => ({ code, kind: "official" }));
+    }
+  };
+}
+function composeCheckSources(...sources) {
+  return {
+    async generate(task, ctx) {
+      const all = [];
+      for (const source of sources) all.push(...await source.generate(task, ctx));
+      return all;
+    }
+  };
+}
+function resolveEntrySymbol(task) {
+  const meta = task.meta?.entryPoint;
+  if (typeof meta === "string" && meta.trim().length > 0) return meta.trim();
+  const defs = [...task.userPrompt.matchAll(/(?:^|\n)\s*def\s+([A-Za-z_]\w*)\s*\(/g)];
+  const last = defs[defs.length - 1];
+  return last?.[1];
+}
+function buildCheckProgram(candidate, official, authored, nonce) {
+  const officialB64 = Buffer.from(JSON.stringify(official), "utf8").toString("base64");
+  const authoredB64 = Buffer.from(JSON.stringify(authored), "utf8").toString("base64");
+  return `${candidate}
+
+import base64 as _b64, json as _json, sys as _sys
+_official = _json.loads(_b64.b64decode("${officialB64}").decode("utf8"))
+_authored = _json.loads(_b64.b64decode("${authoredB64}").decode("utf8"))
+_lines = []
+def _run(_tests):
+    _att, _fail = 0, 0
+    for _t in _tests:
+        _att += 1
+        try:
+            exec(_t, dict(globals()))
+        except Exception as _e:
+            _fail += 1
+            _lines.append("CHECK FAILED: %s -> %s: %s" % (_t.strip()[:200], type(_e).__name__, str(_e)[:200]))
+    return _att, _fail
+_o_att, _o_fail = _run(_official)
+_a_att, _a_fail = _run(_authored)
+print("SRCK-${nonce} official=%d/%d authored=%d/%d" % (_o_att - _o_fail, _o_att, _a_att - _a_fail, _a_att))
+_sys.stdout.write("\\n".join(_lines)[-1500:])
+_sys.exit(0 if (_o_fail + _a_fail) == 0 and (_o_att + _a_att) > 0 else 1)
+`;
+}
+function sandboxCheckRunner(options = {}) {
+  const python = options.python ?? "python3";
+  const timeoutMs = options.timeoutMs ?? 2e4;
+  return {
+    async run(candidate, checks, ctx) {
+      if (checks.length === 0) {
+        return {
+          passedOfficial: 0,
+          totalOfficial: 0,
+          passedAuthored: 0,
+          totalAuthored: 0,
+          failureOutput: ""
+        };
+      }
+      const box = ctx.box ?? options.box;
+      if (!box) {
+        throw new Error(
+          "sandboxCheckRunner: no execution channel \u2014 bind one via sandboxCheckRunner({ box }) or CheckRunContext.box (ValidationCtx.box / a sandbox instance). Refusing to score without executing: a silent 0 would poison selection."
+        );
+      }
+      const nonce = randomBytes(8).toString("hex");
+      const official = checks.filter((c) => c.kind === "official").map((c) => c.code);
+      const authored = checks.filter((c) => c.kind === "authored").map((c) => c.code);
+      const program = buildCheckProgram(candidate, official, authored, nonce);
+      const b64 = Buffer.from(program, "utf8").toString("base64");
+      const r = await box.exec(`printf '%s' '${b64}' | base64 -d | ${python} -`, { timeoutMs });
+      const summary = new RegExp(
+        `SRCK-${nonce} official=(\\d+)/(\\d+) authored=(\\d+)/(\\d+)`
+      ).exec(r.stdout);
+      if (!summary) {
+        const detail = (r.stderr || r.stdout).slice(-1500) || "no output (crashed or timed out before the checks could run)";
+        return {
+          passedOfficial: 0,
+          totalOfficial: 0,
+          passedAuthored: 0,
+          totalAuthored: 0,
+          failureOutput: detail,
+          crashed: true
+        };
+      }
+      const failureOutput = r.stdout.replace(summary[0], "").slice(-1500).trim();
+      return {
+        passedOfficial: Number(summary[1]),
+        totalOfficial: Number(summary[2]),
+        passedAuthored: Number(summary[3]),
+        totalAuthored: Number(summary[4]),
+        failureOutput
+      };
+    }
+  };
+}
+var frac = (passed, total) => total > 0 ? passed / total : 0;
+function compareCheckOutcomes(a, b) {
+  const aCrashed = a.crashed === true;
+  const bCrashed = b.crashed === true;
+  if (aCrashed !== bCrashed) return aCrashed ? -1 : 1;
+  if (aCrashed) return 0;
+  const official = frac(a.passedOfficial, a.totalOfficial) - frac(b.passedOfficial, b.totalOfficial);
+  if (official !== 0) return official;
+  return frac(a.passedAuthored, a.totalAuthored) - frac(b.passedAuthored, b.totalAuthored);
+}
+function visibleCheckScore(o) {
+  if (o.crashed) return -1;
+  return frac(o.passedOfficial, o.totalOfficial) + 1e-3 * frac(o.passedAuthored, o.totalAuthored);
+}
+function selectBestIndex(outcomes) {
+  let best = 0;
+  for (let i = 1; i < outcomes.length; i += 1) {
+    if (compareCheckOutcomes(outcomes[i], outcomes[best]) > 0) {
+      best = i;
+    }
+  }
+  return best;
+}
+function canDisplace(challenger, incumbent) {
+  if (challenger.crashed === true) return false;
+  if (challenger.passedOfficial < incumbent.passedOfficial) return false;
+  return compareCheckOutcomes(challenger, incumbent) > 0;
+}
+var totalChecks = (o) => o.totalOfficial + o.totalAuthored;
+var passesAllChecks = (o) => o.crashed !== true && totalChecks(o) > 0 && o.passedOfficial === o.totalOfficial && o.passedAuthored === o.totalAuthored;
+function defaultExtractCandidate(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const calls = messages[i]?.tool_calls;
+    if (!calls) continue;
+    for (let j = calls.length - 1; j >= 0; j -= 1) {
+      const call = calls[j];
+      if (call?.function?.name !== "submit_answer") continue;
+      try {
+        const args = JSON.parse(call.function.arguments ?? "{}");
+        if (typeof args.answer === "string" && args.answer.trim()) return args.answer.trim();
+      } catch {
+      }
+    }
+  }
+  const contents = [];
+  for (const m of messages) {
+    if (m.role === "assistant" && typeof m.content === "string" && m.content.trim()) {
+      contents.push(m.content);
+    }
+  }
+  const fencesOf = (text) => [...text.matchAll(/```(?:python|py)?\s*\n([\s\S]*?)```/gi)].map((m) => (m[1] ?? "").trim());
+  for (let i = contents.length - 1; i >= 0; i -= 1) {
+    const fences = fencesOf(contents[i]);
+    for (let j = fences.length - 1; j >= 0; j -= 1) {
+      if (/(^|\n)\s*def\s+\w+/.test(fences[j])) return fences[j];
+    }
+  }
+  for (let i = contents.length - 1; i >= 0; i -= 1) {
+    const fences = fencesOf(contents[i]);
+    if (fences.length > 0) return fences[fences.length - 1];
+  }
+  return (contents[contents.length - 1] ?? "").trim();
+}
+var DIVERSE_LENSES = [
+  "Answer directly and decisively from what you already know. State the single best answer without hedging.",
+  "Decompose the question into the sub-facts it depends on. Establish each sub-fact explicitly, then compose them into the answer.",
+  "Reason from first principles. Ignore the most obvious or popular guess; derive the answer from underlying facts and relationships.",
+  "Name the most plausible WRONG answer and the trap that makes it tempting. Rule it out, then commit to the answer that survives."
+];
+function slotLens(slot) {
+  const lens = DIVERSE_LENSES[slot % DIVERSE_LENSES.length];
+  const tag = slot < DIVERSE_LENSES.length ? "" : ` (variant ${Math.floor(slot / DIVERSE_LENSES.length) + 1})`;
+  return `${lens}${tag}`;
+}
+function repairSteer(outcome) {
+  return [
+    "Your latest solution failed some of the task-visible checks.",
+    "Result of running the visible checks against it:",
+    "```",
+    outcome.failureOutput.trim() || "(the code crashed before the checks could run)",
+    "```",
+    "Fix the solution so the visible checks pass. Provide the COMPLETE corrected solution the",
+    "same way you provided the original (same tool or format) \u2014 not a fragment or a diff."
+  ].join("\n");
+}
+function describeOutcome(label, o) {
+  if (o.crashed) return `${label}: crashed before the checks could run`;
+  return `${label}: official ${o.passedOfficial}/${o.totalOfficial}, authored ${o.passedAuthored}/${o.totalAuthored}`;
+}
+function structuralRollout(config = {}) {
+  const policy = resolvePolicy(config.policy);
+  const checkSource = config.checkSource ?? composeCheckSources(officialChecksFromMeta(), modelAuthoredChecks());
+  const checkRunner = config.checkRunner ?? sandboxCheckRunner();
+  const extract = config.extractCandidate ?? defaultExtractCandidate;
+  const inner = defineStrategy(
+    "structuralRollout",
+    async (ctx) => {
+      const { task, shot } = ctx;
+      const progression = [];
+      const receipts = [];
+      let completions = 0;
+      let shots = 0;
+      const consult = async (instruction) => {
+        const reply = await ctx.consult([], instruction);
+        completions += 1;
+        return reply;
+      };
+      const entrySymbol = resolveEntrySymbol(task);
+      const checks = await checkSource.generate(task, {
+        count: policy.testgen,
+        ...entrySymbol ? { entrySymbol } : {},
+        consult
+      });
+      const officialChecks = checks.filter((c) => c.kind === "official").length;
+      const authoredChecks = checks.length - officialChecks;
+      const runCtx = { task, ...config.box ? { box: config.box } : {} };
+      const candidates = [];
+      for (let i = 0; i < policy.k; i += 1) {
+        const out = await shot(policy.diverse ? { steer: slotLens(i) } : void 0);
+        if (!out) break;
+        shots += 1;
+        completions += out.completions;
+        progression.push(out.score);
+        const outcome = await checkRunner.run(extract(out.messages), checks, runCtx);
+        candidates.push({
+          index: candidates.length,
+          messages: out.messages,
+          outcome,
+          shotScore: out.score,
+          shotResolved: out.total > 0 && out.passes === out.total
+        });
+      }
+      if (candidates.length === 0) {
+        return {
+          score: 0,
+          resolved: false,
+          completions,
+          progression,
+          shots,
+          selection: receipts,
+          repairStop: "no-candidates",
+          officialChecks,
+          authoredChecks
+        };
+      }
+      let best = candidates[selectBestIndex(candidates.map((c) => c.outcome))];
+      for (const c of candidates) {
+        receipts.push({
+          candidateIndex: c.index,
+          selected: false,
+          score: visibleCheckScore(c.outcome),
+          reason: describeOutcome("sample", c.outcome),
+          selector: "driver"
+        });
+      }
+      let seq = candidates.length;
+      let repairStop = "already-passing";
+      if (!passesAllChecks(best.outcome)) {
+        if (best.outcome.crashed !== true && totalChecks(best.outcome) === 0) {
+          repairStop = "no-signal";
+        } else {
+          repairStop = "rounds-exhausted";
+          for (let r = 0; r < policy.repairRounds; r += 1) {
+            const out = await shot({ messages: best.messages, steer: repairSteer(best.outcome) });
+            if (!out) break;
+            shots += 1;
+            completions += out.completions;
+            progression.push(out.score);
+            const outcome = await checkRunner.run(extract(out.messages), checks, runCtx);
+            const displaced = canDisplace(outcome, best.outcome);
+            const label = displaced ? "repair (displaced the incumbent)" : outcome.crashed !== true && outcome.passedOfficial < best.outcome.passedOfficial ? "repair (held out: passes fewer official checks than the incumbent)" : "repair (held out: no improvement)";
+            receipts.push({
+              candidateIndex: seq,
+              selected: false,
+              score: visibleCheckScore(outcome),
+              reason: describeOutcome(label, outcome),
+              selector: "driver"
+            });
+            if (displaced) {
+              best = {
+                index: seq,
+                messages: out.messages,
+                outcome,
+                shotScore: out.score,
+                shotResolved: out.total > 0 && out.passes === out.total
+              };
+            }
+            seq += 1;
+            if (passesAllChecks(best.outcome)) {
+              repairStop = "repaired-pass";
+              break;
+            }
+          }
+        }
+      }
+      const winner = receipts.find((r) => r.candidateIndex === best.index);
+      if (winner) winner.selected = true;
+      return {
+        score: best.shotScore,
+        resolved: best.shotResolved,
+        completions,
+        progression,
+        shots,
+        selection: receipts,
+        repairStop,
+        officialChecks,
+        authoredChecks
+      };
+    }
+  );
+  if (policy.temperature === void 0) return inner;
+  return {
+    name: inner.name,
+    driver: (surface, task, opts, budget) => inner.driver(surface, task, { ...opts, temperature: policy.temperature }, budget)
+  };
+}
+
 // src/runtime/supervise/detector-monitor.ts
 import {
   argHash,
@@ -5845,6 +6229,30 @@ export {
   createSandboxPromptBackend,
   createOpenAICompatibleBackend,
   normalizeBackendStreamEvent,
+  defaultAnalystInstruction,
+  observe,
+  renderReport,
+  depthStrategy,
+  breadthStrategy,
+  sample,
+  refine,
+  defineStrategy,
+  adaptiveRefine,
+  sampleThenRefine,
+  runAgentic,
+  defaultStructuralRolloutPolicy,
+  filterAuthoredAsserts,
+  modelAuthoredChecks,
+  officialChecksFromMeta,
+  composeCheckSources,
+  resolveEntrySymbol,
+  sandboxCheckRunner,
+  compareCheckOutcomes,
+  visibleCheckScore,
+  selectBestIndex,
+  canDisplace,
+  defaultExtractCandidate,
+  structuralRollout,
   anytimeReport,
   renderAnytimeTable,
   defaultAuditorInstruction,
@@ -5867,9 +6275,6 @@ export {
   naiveDriver,
   dumbDriver,
   defineLeaderboard,
-  defaultAnalystInstruction,
-  observe,
-  renderReport,
   harvestCorpus,
   inProcessSandboxClient,
   createMcpEnvironment,
@@ -5896,14 +6301,6 @@ export {
   trajectoryReport,
   equalKOnCost,
   promotionGate,
-  depthStrategy,
-  breadthStrategy,
-  sample,
-  refine,
-  defineStrategy,
-  adaptiveRefine,
-  sampleThenRefine,
-  runAgentic,
   runBenchmark,
   printBenchmarkReport,
   SandboxRunAbortError,
@@ -5937,4 +6334,4 @@ export {
   computeFindingId,
   makeFinding2 as makeFinding
 };
-//# sourceMappingURL=chunk-4IBAMGBE.js.map
+//# sourceMappingURL=chunk-AD7JW4QG.js.map