oh-my-fable 0.1.0

package/dist/index.cjs

@@ -0,0 +1,920 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AnthropicProvider: () => AnthropicProvider,
+  ContextManager: () => ContextManager,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  Executor: () => Executor,
+  FileStore: () => FileStore,
+  MemoryStore: () => MemoryStore,
+  Planner: () => Planner,
+  Reflector: () => Reflector,
+  ScriptedProvider: () => ScriptedProvider,
+  ToolRegistry: () => ToolRegistry,
+  checkBudget: () => checkBudget,
+  createContext: () => createContext,
+  defineTool: () => defineTool,
+  estimateTokens: () => estimateTokens,
+  genId: () => genId,
+  nextPendingStep: () => nextPendingStep,
+  reply: () => reply,
+  resolveSerializable: () => resolveSerializable,
+  resume: () => resume,
+  run: () => run,
+  runLoop: () => runLoop,
+  runWith: () => runWith,
+  withRetry: () => withRetry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  maxSteps: 50,
+  maxTokens: 2e6,
+  maxWallClockMs: 30 * 60 * 1e3,
+  maxStepAttempts: 3,
+  maxReplans: 12,
+  contextTokenLimit: 1e5,
+  keepRecent: 8,
+  temperature: 0.2,
+  maxStepTokens: 4096
+};
+function resolveSerializable(config) {
+  return {
+    maxSteps: config.maxSteps ?? DEFAULT_CONFIG.maxSteps,
+    maxTokens: config.maxTokens ?? DEFAULT_CONFIG.maxTokens,
+    maxWallClockMs: config.maxWallClockMs ?? DEFAULT_CONFIG.maxWallClockMs,
+    maxStepAttempts: config.maxStepAttempts ?? DEFAULT_CONFIG.maxStepAttempts,
+    maxReplans: config.maxReplans ?? DEFAULT_CONFIG.maxReplans,
+    contextTokenLimit: config.contextTokenLimit ?? DEFAULT_CONFIG.contextTokenLimit,
+    keepRecent: config.keepRecent ?? DEFAULT_CONFIG.keepRecent,
+    temperature: config.temperature ?? DEFAULT_CONFIG.temperature,
+    maxStepTokens: config.maxStepTokens ?? DEFAULT_CONFIG.maxStepTokens
+  };
+}
+
+// src/run/context.ts
+function genId(prefix = "run") {
+  const t = Date.now().toString(36);
+  const r = Math.floor(Math.random() * 36 ** 5).toString(36).padStart(5, "0");
+  return `${prefix}_${t}${r}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createContext(goal, config) {
+  const ts = nowIso();
+  return {
+    runId: genId(),
+    goal,
+    plan: { goal: goal.description, steps: [], status: "active", revision: 0 },
+    history: [],
+    digests: [],
+    budget: { steps: 0, tokens: 0, startedAtMs: Date.now(), replans: 0 },
+    config,
+    createdAt: ts,
+    updatedAt: ts,
+    meta: {}
+  };
+}
+function touch(ctx) {
+  ctx.updatedAt = nowIso();
+}
+function nextPendingStep(ctx) {
+  const done = new Set(ctx.plan.steps.filter((s) => s.status === "done").map((s) => s.id));
+  for (const step of ctx.plan.steps) {
+    if (step.status !== "pending") continue;
+    const deps = step.dependsOn ?? [];
+    if (deps.every((d) => done.has(d))) return step;
+  }
+  return null;
+}
+function findStep(ctx, id) {
+  return ctx.plan.steps.find((s) => s.id === id);
+}
+
+// src/memory/store.ts
+var import_promises = require("fs/promises");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var FileStore = class {
+  constructor(dir = "runs") {
+    this.dir = dir;
+  }
+  dir;
+  async ensureDir() {
+    if (!(0, import_node_fs.existsSync)(this.dir)) await (0, import_promises.mkdir)(this.dir, { recursive: true });
+  }
+  path(runId) {
+    return (0, import_node_path.join)(this.dir, `${runId.replace(/[^\w.-]/g, "_")}.json`);
+  }
+  async save(ctx) {
+    await this.ensureDir();
+    const file = this.path(ctx.runId);
+    const tmp = `${file}.tmp`;
+    await (0, import_promises.writeFile)(tmp, JSON.stringify(ctx, null, 2), "utf8");
+    await (0, import_promises.rename)(tmp, file);
+  }
+  async load(runId) {
+    const file = this.path(runId);
+    if (!(0, import_node_fs.existsSync)(file)) return null;
+    try {
+      return JSON.parse(await (0, import_promises.readFile)(file, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  async list() {
+    if (!(0, import_node_fs.existsSync)(this.dir)) return [];
+    const files = (await (0, import_promises.readdir)(this.dir)).filter((f) => f.endsWith(".json"));
+    const out = [];
+    for (const f of files) {
+      try {
+        const ctx = JSON.parse(await (0, import_promises.readFile)((0, import_node_path.join)(this.dir, f), "utf8"));
+        out.push({
+          runId: ctx.runId,
+          goal: ctx.goal.description,
+          planStatus: ctx.plan.status,
+          steps: ctx.plan.steps.length,
+          updatedAt: ctx.updatedAt
+        });
+      } catch {
+      }
+    }
+    return out.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1);
+  }
+};
+var MemoryStore = class {
+  map = /* @__PURE__ */ new Map();
+  async save(ctx) {
+    this.map.set(ctx.runId, JSON.stringify(ctx));
+  }
+  async load(runId) {
+    const raw = this.map.get(runId);
+    return raw ? JSON.parse(raw) : null;
+  }
+  async list() {
+    return [...this.map.values()].map((raw) => {
+      const ctx = JSON.parse(raw);
+      return { runId: ctx.runId, goal: ctx.goal.description, planStatus: ctx.plan.status, steps: ctx.plan.steps.length, updatedAt: ctx.updatedAt };
+    });
+  }
+};
+
+// src/executor/tools.ts
+var ToolRegistry = class {
+  map = /* @__PURE__ */ new Map();
+  constructor(tools = []) {
+    for (const t of tools) this.register(t);
+  }
+  register(tool) {
+    this.map.set(tool.name, tool);
+  }
+  get(name) {
+    return this.map.get(name);
+  }
+  schemas() {
+    return [...this.map.values()].map((t) => t.schema);
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** Run a tool, turning any thrown error into a ToolResult — the loop never dies on a tool. */
+  async run(name, input) {
+    const tool = this.map.get(name);
+    if (!tool) return { ok: false, output: "", error: `unknown tool: ${name}` };
+    try {
+      return await tool.handler(input);
+    } catch (err) {
+      return { ok: false, output: "", error: err.message ?? "tool threw" };
+    }
+  }
+};
+function defineTool(name, description, parameters, handler) {
+  return { name, description, schema: { name, description, parameters }, handler };
+}
+
+// src/core/json.ts
+function extractJson(raw) {
+  let s = raw.trim();
+  const fence = s.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence) s = fence[1].trim();
+  const start = s.search(/[[{]/);
+  if (start > 0) s = s.slice(start);
+  const open = s[0];
+  if (open === "{" || open === "[") {
+    const close = open === "{" ? "}" : "]";
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = 0; i < s.length; i++) {
+      const c = s[i];
+      if (inStr) {
+        if (esc) esc = false;
+        else if (c === "\\") esc = true;
+        else if (c === '"') inStr = false;
+      } else if (c === '"') inStr = true;
+      else if (c === open) depth++;
+      else if (c === close) {
+        depth--;
+        if (depth === 0) return s.slice(0, i + 1);
+      }
+    }
+  }
+  return s;
+}
+function tryParse(raw) {
+  try {
+    return JSON.parse(extractJson(raw));
+  } catch {
+    return null;
+  }
+}
+async function parseWithRepair(raw, provider, validate) {
+  const first = tryParse(raw);
+  if (first !== null && (!validate || validate(first))) return first;
+  const repaired = await provider.complete({
+    responseFormat: "json",
+    temperature: 0,
+    messages: [
+      { role: "system", content: "You convert a malformed response into valid JSON. Output ONLY the JSON \u2014 no prose, no code fences." },
+      { role: "user", content: raw }
+    ]
+  });
+  const second = tryParse(repaired.content);
+  if (second !== null && (!validate || validate(second))) return second;
+  return null;
+}
+
+// src/planner/prompts.ts
+var PLAN_SYSTEM = `You are a planning module. Decompose a goal into an ordered list of executable steps.
+
+Rules:
+- Each step has a single, verifiable intent.
+- If a step is too big, split it further.
+- Never create a step that violates a constraint.
+- Order matters; use dependsOn (step ids) when a step needs an earlier one.
+- Respond with ONLY this JSON. No prose, no code fences:
+{ "steps": [ { "id": "s1", "intent": "...", "dependsOn": [] } ] }`;
+function planPrompt(goal) {
+  return [
+    { role: "system", content: PLAN_SYSTEM },
+    {
+      role: "user",
+      content: [
+        `Goal: ${goal.description}`,
+        goal.constraints?.length ? `Constraints: ${goal.constraints.join("; ")}` : "",
+        goal.successCriteria?.length ? `Done when: ${goal.successCriteria.join("; ")}` : ""
+      ].filter(Boolean).join("\n")
+    }
+  ];
+}
+var REPLAN_SYSTEM = `You are a planning module revising a plan that hit an obstacle.
+
+CRITICAL: steps already completed are DONE \u2014 do not redo them. Their results are given.
+Produce ONLY the steps still needed to reach the goal from the current state.
+Account for the obstacle so the new steps actually get unblocked.
+Respond with ONLY this JSON. No prose, no code fences:
+{ "steps": [ { "id": "n1", "intent": "...", "dependsOn": [] } ] }`;
+function replanPrompt(plan, obs, notes, goal) {
+  const done = plan.steps.filter((s) => s.status === "done");
+  const blocked = plan.steps.find((s) => s.id === obs.stepId);
+  return [
+    { role: "system", content: REPLAN_SYSTEM },
+    {
+      role: "user",
+      content: [
+        `Goal: ${goal.description}`,
+        goal.successCriteria?.length ? `Done when: ${goal.successCriteria.join("; ")}` : "",
+        "",
+        "Already completed (do NOT redo):",
+        done.length ? done.map((s) => `  \u2713 [${s.id}] ${s.intent}${s.result ? ` \u2192 ${s.result}` : ""}`).join("\n") : "  (nothing yet)",
+        "",
+        `The step that got stuck: ${blocked ? blocked.intent : obs.stepId}`,
+        `What happened: ${obs.error ?? obs.output}`,
+        `Reflection: ${notes}`,
+        "",
+        "Give the remaining steps from here."
+      ].join("\n")
+    }
+  ];
+}
+
+// src/planner/planner.ts
+function coerceSteps(raw, idPrefix) {
+  const steps = [];
+  const seen = /* @__PURE__ */ new Set();
+  let n = 0;
+  for (const s of raw?.steps ?? []) {
+    if (typeof s?.intent !== "string" || s.intent.trim() === "") continue;
+    let id = typeof s.id === "string" && s.id.trim() ? s.id.trim() : `${idPrefix}${++n}`;
+    while (seen.has(id)) id = `${idPrefix}${++n}`;
+    seen.add(id);
+    const dependsOn = Array.isArray(s.dependsOn) ? s.dependsOn.filter((d) => typeof d === "string") : void 0;
+    steps.push({ id, intent: s.intent.trim(), dependsOn, status: "pending", attempts: 0 });
+  }
+  return steps;
+}
+var Planner = class {
+  constructor(provider, temperature) {
+    this.provider = provider;
+    this.temperature = temperature;
+  }
+  provider;
+  temperature;
+  async plan(goal) {
+    const res = await this.provider.complete({ messages: planPrompt(goal), responseFormat: "json", temperature: this.temperature });
+    const raw = await parseWithRepair(res.content, this.provider, (v) => Array.isArray(v.steps));
+    let steps = coerceSteps(raw, "s");
+    if (steps.length === 0) {
+      steps = [{ id: "s1", intent: goal.description, status: "pending", attempts: 0 }];
+    }
+    return { goal: goal.description, steps, status: "active", revision: 0 };
+  }
+  /**
+   * Accumulate, never reset: completed steps are preserved verbatim; only the
+   * remaining work is regenerated from the point of failure. This is what lets
+   * a long task make forward progress instead of restarting forever.
+   */
+  async replan(plan, obs, ctx) {
+    const notes = String(ctx.meta["lastReflectionNotes"] ?? "");
+    const res = await this.provider.complete({
+      messages: replanPrompt(plan, obs, notes, ctx.goal),
+      responseFormat: "json",
+      temperature: this.temperature
+    });
+    const raw = await parseWithRepair(res.content, this.provider, (v) => Array.isArray(v.steps));
+    const revision = plan.revision + 1;
+    const done = plan.steps.filter((s) => s.status === "done");
+    const doneIds = new Set(done.map((s) => s.id));
+    let fresh = coerceSteps(raw, `r${revision}s`).filter((s) => !doneIds.has(s.id));
+    if (fresh.length === 0) {
+      fresh = [{ id: `r${revision}s1`, intent: `Make progress toward: ${ctx.goal.description}`, status: "pending", attempts: 0 }];
+    }
+    return { goal: plan.goal, steps: [...done, ...fresh], status: "active", revision };
+  }
+};
+
+// src/executor/executor.ts
+var EXEC_SYSTEM = `You are the execution module of an autonomous agent. You are given the overall goal for context and exactly ONE step to perform now.
+
+- Do only this step. Don't get ahead of the plan.
+- If a tool would help and tools are available, call it.
+- Respond with the concrete result of the step \u2014 what you produced, found, or decided. Be specific and concise; this becomes the step's recorded result.`;
+var MAX_TOOL_HOPS = 8;
+function background(ctx) {
+  const g = ctx.goal;
+  const done = ctx.plan.steps.filter((s) => s.status === "done");
+  const pending = ctx.plan.steps.filter((s) => s.status === "pending");
+  const lines = [`Goal: ${g.description}`];
+  if (g.constraints?.length) lines.push(`Constraints: ${g.constraints.join("; ")}`);
+  if (g.successCriteria?.length) lines.push(`Done when: ${g.successCriteria.join("; ")}`);
+  if (ctx.digests.length) {
+    lines.push("", "Summary of earlier work:");
+    for (const d of ctx.digests) lines.push(`  ${d.summary}`);
+  }
+  if (done.length) {
+    lines.push("", "Completed steps:");
+    for (const s of done) lines.push(`  \u2713 ${s.intent}${s.result ? ` \u2192 ${s.result}` : ""}`);
+  }
+  if (pending.length) {
+    lines.push("", "Still to do:");
+    for (const s of pending) lines.push(`  \u2022 ${s.intent}`);
+  }
+  return lines.join("\n");
+}
+var Executor = class {
+  constructor(provider, registry, opts) {
+    this.provider = provider;
+    this.opts = opts;
+    this.registry = registry;
+  }
+  provider;
+  opts;
+  registry;
+  async execute(step, ctx) {
+    const tools = this.registry.size > 0 ? this.registry.schemas() : void 0;
+    const local = [
+      { role: "system", content: EXEC_SYSTEM },
+      { role: "user", content: background(ctx) },
+      ...ctx.history,
+      { role: "user", content: `Now do this step:
+[${step.id}] ${step.intent}` }
+    ];
+    let tokensUsed = 0;
+    const allToolCalls = [];
+    let toolError;
+    try {
+      let result = await this.provider.complete({
+        messages: local,
+        tools,
+        temperature: this.opts.temperature,
+        maxTokens: this.opts.maxStepTokens
+      });
+      tokensUsed += result.tokensIn + result.tokensOut;
+      let hops = 0;
+      while (result.stopReason === "tool_use" && result.toolCalls?.length && hops < MAX_TOOL_HOPS) {
+        hops++;
+        const resultsText = [];
+        for (const call of result.toolCalls) {
+          allToolCalls.push(call);
+          const out = await this.registry.run(call.name, call.input);
+          if (!out.ok) toolError = out.error;
+          resultsText.push(`- ${call.name}: ${out.ok ? out.output : `ERROR: ${out.error}`}`);
+        }
+        local.push({ role: "assistant", content: result.content || `(requested: ${result.toolCalls.map((c) => c.name).join(", ")})` });
+        local.push({ role: "user", content: `Tool results:
+${resultsText.join("\n")}
+
+Continue the step with these.` });
+        result = await this.provider.complete({ messages: local, tools, temperature: this.opts.temperature, maxTokens: this.opts.maxStepTokens });
+        tokensUsed += result.tokensIn + result.tokensOut;
+      }
+      const ok = result.stopReason !== "error";
+      const output = result.content.trim() || (ok ? "(step produced no text output)" : "");
+      ctx.history.push({ role: "user", content: `Step [${step.id}]: ${step.intent}` });
+      ctx.history.push({ role: "assistant", content: output });
+      return {
+        stepId: step.id,
+        ok,
+        output,
+        toolCalls: allToolCalls.length ? allToolCalls : void 0,
+        error: ok ? toolError : `model error (stopReason=${result.stopReason})`,
+        tokensUsed
+      };
+    } catch (err) {
+      return {
+        stepId: step.id,
+        ok: false,
+        output: "",
+        error: err.message ?? "execution failed",
+        tokensUsed
+      };
+    }
+  }
+};
+
+// src/reflector/prompts.ts
+var REFLECT_SYSTEM = `You are the progress supervisor of an autonomous agent. You just saw the result of one step. Judge what should happen next \u2014 pick exactly ONE:
+
+- goal_met     \u2014 the goal's success criteria are ALL satisfied. (Allowed even if planned steps remain \u2014 don't pad work that's already done.)
+- needs_replan \u2014 the step worked, but its result changed the assumptions the remaining plan was built on. The plan needs revising.
+- blocked      \u2014 the same obstacle keeps recurring, or there is no path forward with the current plan.
+- on_track     \u2014 normal forward progress; continue to the next step.
+
+Respond with ONLY this JSON. No prose, no code fences:
+{ "progress": "on_track" | "needs_replan" | "blocked" | "goal_met", "notes": "1-2 sentence reason", "confidence": 0.0 }`;
+function planSummary(plan) {
+  const done = plan.steps.filter((s) => s.status === "done");
+  const pending = plan.steps.filter((s) => s.status === "pending");
+  const lines = [];
+  if (done.length) lines.push("Done:", ...done.map((s) => `  \u2713 ${s.intent}`));
+  if (pending.length) lines.push("Remaining:", ...pending.map((s) => `  \u2022 ${s.intent}`));
+  return lines.join("\n") || "(no steps)";
+}
+function reflectPrompt(plan, obs, goal, step) {
+  return [
+    { role: "system", content: REFLECT_SYSTEM },
+    {
+      role: "user",
+      content: [
+        `Goal: ${goal.description}`,
+        goal.successCriteria?.length ? `Done when: ${goal.successCriteria.join("; ")}` : "",
+        "",
+        "Current plan:",
+        planSummary(plan),
+        "",
+        `Step just run: ${step ? step.intent : obs.stepId}`,
+        `Succeeded: ${obs.ok}`,
+        `Result: ${obs.error ? `ERROR \u2014 ${obs.error}` : obs.output}`
+      ].filter(Boolean).join("\n")
+    }
+  ];
+}
+
+// src/reflector/reflector.ts
+var PROGRESS_VALUES = ["on_track", "needs_replan", "blocked", "goal_met"];
+var Reflector = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  provider;
+  async reflect(plan, obs, ctx) {
+    const step = findStep(ctx, obs.stepId);
+    if (!obs.ok && step) {
+      step.attempts += 1;
+      if (step.attempts >= ctx.config.maxStepAttempts) {
+        return {
+          progress: "blocked",
+          notes: `Step failed ${step.attempts} times in a row (last error: ${obs.error ?? "unknown"}). No path with the current plan.`,
+          confidence: 0.95
+        };
+      }
+    }
+    const res = await this.provider.complete({
+      messages: reflectPrompt(plan, obs, ctx.goal, step),
+      responseFormat: "json",
+      temperature: 0
+    });
+    const raw = await parseWithRepair(res.content, this.provider, (v) => typeof v.progress === "string");
+    if (!raw || typeof raw.progress !== "string" || !PROGRESS_VALUES.includes(raw.progress)) {
+      return { progress: "needs_replan", notes: "Could not parse a verdict; replanning conservatively." };
+    }
+    return {
+      progress: raw.progress,
+      notes: typeof raw.notes === "string" ? raw.notes : "",
+      confidence: typeof raw.confidence === "number" ? raw.confidence : void 0
+    };
+  }
+};
+
+// src/memory/context.ts
+var FOLD_SYSTEM = `You compress an agent's conversation log. Keep ONLY: key decisions made, concrete results/outputs produced, and any open or unresolved items. Drop chit-chat and restating. Be terse \u2014 this summary replaces the raw log.`;
+var DIGEST_CHAR_LIMIT = 6e3;
+var ContextManager = class {
+  constructor(provider, config) {
+    this.provider = provider;
+    this.config = config;
+  }
+  provider;
+  config;
+  overBudget(ctx) {
+    return this.provider.estimateTokens(ctx.history) >= this.config.contextTokenLimit * 0.8;
+  }
+  /** Fold all but the most recent K messages into a digest; return the new (short) history. */
+  async compact(ctx) {
+    const keep = this.config.keepRecent;
+    if (ctx.history.length <= keep) return ctx.history;
+    const recent = ctx.history.slice(-keep);
+    const toFold = ctx.history.slice(0, -keep);
+    const folded = await this.provider.complete({
+      temperature: 0,
+      messages: [
+        { role: "system", content: FOLD_SYSTEM },
+        { role: "user", content: toFold.map((m) => `[${m.role}] ${m.content}`).join("\n\n") }
+      ]
+    });
+    ctx.digests.push({ summary: folded.content.trim(), coversUntil: nowIso() });
+    const totalDigestChars = ctx.digests.reduce((n, d) => n + d.summary.length, 0);
+    if (totalDigestChars > DIGEST_CHAR_LIMIT && ctx.digests.length > 1) {
+      const merged = await this.provider.complete({
+        temperature: 0,
+        messages: [
+          { role: "system", content: FOLD_SYSTEM },
+          { role: "user", content: ctx.digests.map((d) => d.summary).join("\n\n") }
+        ]
+      });
+      ctx.digests = [{ summary: merged.content.trim(), coversUntil: nowIso() }];
+    }
+    return recent;
+  }
+};
+
+// src/run/budget.ts
+function checkBudget(ctx) {
+  const c = ctx.config;
+  const b = ctx.budget;
+  if (b.steps >= c.maxSteps) {
+    return { exceeded: true, reason: `step budget exhausted (${b.steps}/${c.maxSteps} steps)` };
+  }
+  if (b.tokens >= c.maxTokens) {
+    return { exceeded: true, reason: `token budget exhausted (${b.tokens}/${c.maxTokens} tokens)` };
+  }
+  const elapsed = Date.now() - b.startedAtMs;
+  if (elapsed >= c.maxWallClockMs) {
+    return { exceeded: true, reason: `wall-clock budget exhausted (${Math.round(elapsed / 1e3)}s/${Math.round(c.maxWallClockMs / 1e3)}s)` };
+  }
+  if (b.replans >= c.maxReplans) {
+    return { exceeded: true, reason: `replan budget exhausted (${b.replans}/${c.maxReplans} replans)` };
+  }
+  return { exceeded: false };
+}
+
+// src/core/loop.ts
+function applyReflection(ctx, step, obs, reflection) {
+  ctx.meta["lastReflectionNotes"] = reflection.notes;
+  ctx.budget.tokens += obs.tokensUsed;
+  ctx.budget.steps += 1;
+  if (obs.ok) {
+    step.status = "done";
+    step.result = obs.output.slice(0, 600);
+  } else if (reflection.progress === "on_track") {
+    step.status = "pending";
+  } else {
+    step.status = "failed";
+  }
+}
+async function runLoop(ctx, deps) {
+  const { planner, executor, reflector, contextManager, store, onEvent } = deps;
+  if (ctx.plan.steps.length === 0) {
+    ctx.plan = await planner.plan(ctx.goal);
+    touch(ctx);
+    await store.save(ctx);
+    onEvent({ type: "plan_created", plan: ctx.plan });
+  }
+  while (true) {
+    const guard = checkBudget(ctx);
+    if (guard.exceeded) {
+      ctx.plan.status = "failed";
+      touch(ctx);
+      await store.save(ctx);
+      onEvent({ type: "halted", reason: guard.reason });
+      return { status: "halted", reason: guard.reason, ctx };
+    }
+    const step = nextPendingStep(ctx);
+    if (step === null) {
+      ctx.plan.status = "done";
+      touch(ctx);
+      await store.save(ctx);
+      onEvent({ type: "done", reason: "all steps complete" });
+      return { status: "done", reason: "all steps complete", ctx };
+    }
+    if (contextManager.overBudget(ctx)) {
+      const before = ctx.history.length;
+      ctx.history = await contextManager.compact(ctx);
+      onEvent({
+        type: "compaction",
+        foldedMessages: before - ctx.history.length,
+        digestChars: ctx.digests.reduce((n, d) => n + d.summary.length, 0)
+      });
+    }
+    step.status = "running";
+    onEvent({ type: "step_start", step });
+    const obs = await executor.execute(step, ctx);
+    const reflection = await reflector.reflect(ctx.plan, obs, ctx);
+    applyReflection(ctx, step, obs, reflection);
+    onEvent({ type: "step_done", step, observation: obs });
+    onEvent({ type: "reflection", reflection, step });
+    touch(ctx);
+    await store.save(ctx);
+    onEvent({ type: "checkpoint", runId: ctx.runId });
+    switch (reflection.progress) {
+      case "goal_met": {
+        ctx.plan.status = "done";
+        touch(ctx);
+        await store.save(ctx);
+        onEvent({ type: "done", reason: reflection.notes || "goal met" });
+        return { status: "done", reason: reflection.notes || "goal met", ctx };
+      }
+      case "needs_replan": {
+        ctx.budget.replans += 1;
+        ctx.plan = await planner.replan(ctx.plan, obs, ctx);
+        touch(ctx);
+        await store.save(ctx);
+        onEvent({ type: "replan", revision: ctx.plan.revision, reason: reflection.notes });
+        break;
+      }
+      case "blocked": {
+        onEvent({ type: "escalation", step, notes: reflection.notes });
+        ctx.budget.replans += 1;
+        ctx.plan = await planner.replan(ctx.plan, obs, ctx);
+        touch(ctx);
+        await store.save(ctx);
+        onEvent({ type: "replan", revision: ctx.plan.revision, reason: `recovering from blocked: ${reflection.notes}` });
+        break;
+      }
+      case "on_track":
+      default:
+        break;
+    }
+  }
+}
+
+// src/providers/provider.ts
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages) chars += m.content.length;
+  return Math.ceil(chars / 4);
+}
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function withRetry(fn, opts = {}) {
+  const retries = opts.retries ?? 4;
+  const base = opts.baseDelayMs ?? 500;
+  const sleep = opts.sleep ?? defaultSleep;
+  const retryable = opts.isRetryable ?? (() => true);
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (attempt === retries || !retryable(err)) break;
+      await sleep(base * 2 ** attempt);
+    }
+  }
+  throw lastErr;
+}
+function fill(partial, req) {
+  const content = partial.content ?? "";
+  return {
+    content,
+    toolCalls: partial.toolCalls,
+    tokensIn: partial.tokensIn ?? estimateTokens(req.messages),
+    tokensOut: partial.tokensOut ?? Math.ceil(content.length / 4),
+    stopReason: partial.stopReason ?? (partial.toolCalls && partial.toolCalls.length > 0 ? "tool_use" : "end")
+  };
+}
+var ScriptedProvider = class {
+  constructor(responses) {
+    this.responses = responses;
+  }
+  responses;
+  name = "scripted";
+  index = 0;
+  /** Every request the loop made — handy for assertions. */
+  requests = [];
+  async complete(req) {
+    this.requests.push(req);
+    const r = this.responses[this.index];
+    if (this.index < this.responses.length) this.index++;
+    const resolved = typeof r === "function" ? r(req) : r ?? { content: "", stopReason: "end" };
+    return fill(resolved, req);
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+};
+var reply = {
+  plan(steps) {
+    return { content: JSON.stringify({ steps }), stopReason: "end" };
+  },
+  reflection(progress, notes = "", confidence = 0.9) {
+    return { content: JSON.stringify({ progress, notes, confidence }), stopReason: "end" };
+  },
+  text(content) {
+    return { content, stopReason: "end" };
+  },
+  toolUse(calls, content = "") {
+    return { content, toolCalls: calls, stopReason: "tool_use" };
+  }
+};
+
+// src/providers/anthropic.ts
+function coalesce(messages) {
+  const out = [];
+  for (const m of messages) {
+    const last = out[out.length - 1];
+    if (last && last.role === m.role) last.content += "\n\n" + m.content;
+    else out.push({ ...m });
+  }
+  if (out.length === 0 || out[0].role !== "user") out.unshift({ role: "user", content: "(begin)" });
+  return out;
+}
+var AnthropicProvider = class {
+  name = "anthropic";
+  apiKey;
+  model;
+  baseUrl;
+  version;
+  maxRetries;
+  defaultMaxTokens;
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey ?? process.env["ANTHROPIC_API_KEY"] ?? "";
+    this.model = opts.model ?? "claude-sonnet-4-6";
+    this.baseUrl = opts.baseUrl ?? "https://api.anthropic.com";
+    this.version = opts.version ?? "2023-06-01";
+    this.maxRetries = opts.maxRetries ?? 4;
+    this.defaultMaxTokens = opts.defaultMaxTokens ?? 4096;
+    if (!this.apiKey) {
+      throw new Error("AnthropicProvider needs an API key (pass { apiKey } or set ANTHROPIC_API_KEY).");
+    }
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const system = req.messages.filter((m) => m.role === "system").map((m) => m.content).join("\n\n");
+    const convo = coalesce(
+      req.messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }))
+    );
+    const body = {
+      model: this.model,
+      max_tokens: req.maxTokens ?? this.defaultMaxTokens,
+      temperature: req.temperature ?? 1,
+      messages: convo
+    };
+    let sys = system;
+    if (req.responseFormat === "json") sys = (sys ? sys + "\n\n" : "") + "Output ONLY valid JSON. No prose, no code fences.";
+    if (sys) body["system"] = sys;
+    if (req.tools?.length) {
+      body["tools"] = req.tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.parameters }));
+    }
+    const data = await withRetry(
+      async () => {
+        const res = await fetch(`${this.baseUrl}/v1/messages`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": this.apiKey,
+            "anthropic-version": this.version
+          },
+          body: JSON.stringify(body)
+        });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          const err = new Error(`Anthropic ${res.status}: ${text.slice(0, 300)}`);
+          err.status = res.status;
+          throw err;
+        }
+        return await res.json();
+      },
+      {
+        retries: this.maxRetries,
+        isRetryable: (e) => {
+          const status = e.status;
+          return status === void 0 || status === 429 || status >= 500 && status < 600;
+        }
+      }
+    );
+    let content = "";
+    const toolCalls = [];
+    for (const block of data.content ?? []) {
+      if (block.type === "text" && block.text) content += block.text;
+      else if (block.type === "tool_use" && block.name) toolCalls.push({ id: block.id ?? block.name, name: block.name, input: block.input });
+    }
+    const map = { end_turn: "end", tool_use: "tool_use", max_tokens: "max_tokens", stop_sequence: "end" };
+    return {
+      content,
+      toolCalls: toolCalls.length ? toolCalls : void 0,
+      tokensIn: data.usage?.input_tokens ?? 0,
+      tokensOut: data.usage?.output_tokens ?? 0,
+      stopReason: map[data.stop_reason ?? ""] ?? "end"
+    };
+  }
+};
+
+// src/index.ts
+function buildDeps(config, serializable) {
+  const provider = config.provider;
+  const store = config.store ?? new FileStore(config.runsDir);
+  const registry = new ToolRegistry(config.tools ?? []);
+  return {
+    planner: new Planner(provider, serializable.temperature),
+    executor: new Executor(provider, registry, { temperature: serializable.temperature, maxStepTokens: serializable.maxStepTokens }),
+    reflector: new Reflector(provider),
+    contextManager: new ContextManager(provider, serializable),
+    store,
+    onEvent: config.onEvent ?? (() => {
+    })
+  };
+}
+async function run(goal, config) {
+  const g = typeof goal === "string" ? { description: goal } : goal;
+  const serializable = resolveSerializable(config);
+  const ctx = createContext(g, serializable);
+  return runLoop(ctx, buildDeps(config, serializable));
+}
+async function resume(runId, config) {
+  const store = config.store ?? new FileStore(config.runsDir);
+  const ctx = await store.load(runId);
+  if (!ctx) throw new Error(`No saved run found for "${runId}".`);
+  return runLoop(ctx, buildDeps({ ...config, store }, ctx.config));
+}
+async function runWith(ctx, config) {
+  return runLoop(ctx, buildDeps(config, ctx.config));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicProvider,
+  ContextManager,
+  DEFAULT_CONFIG,
+  Executor,
+  FileStore,
+  MemoryStore,
+  Planner,
+  Reflector,
+  ScriptedProvider,
+  ToolRegistry,
+  checkBudget,
+  createContext,
+  defineTool,
+  estimateTokens,
+  genId,
+  nextPendingStep,
+  reply,
+  resolveSerializable,
+  resume,
+  run,
+  runLoop,
+  runWith,
+  withRetry
+});