@demlik/tea 0.1.0 → 0.1.2

package/dist/chunk-S3FQN4SL.js

@@ -0,0 +1,506 @@
+import { createMonitoredRun } from './chunk-7W4LMPUW.js';
+import { createLlmCall } from './chunk-PS23H6KQ.js';
+import { createResilientCall } from './chunk-27N2SPTN.js';
+import { MsgType } from './chunk-JELSZN25.js';
+import { createFanOut, initFanOut } from './chunk-UV6UWGEO.js';
+import { subscribeDeadline } from './chunk-K7Q23EQ4.js';
+import { defineMachine } from './chunk-MMH7CW5K.js';
+
+// src/agent/index.ts
+function isAgentTurn(value) {
+  if (value === null || typeof value !== "object") return false;
+  const t = value;
+  return typeof t.content === "string" && Array.isArray(t.toolCalls);
+}
+var agentTurnSchema = {
+  parse: (value) => {
+    if (!isAgentTurn(value)) {
+      throw new Error("structured-output parse failed: not an AgentTurn");
+    }
+    return value;
+  }
+};
+var COMPACTION_PURPOSE = "$compact";
+function isCompactionSummary(value) {
+  if (value === null || typeof value !== "object") return false;
+  return typeof value.summary === "string";
+}
+var compactionSummarySchema = {
+  parse: (value) => {
+    if (!isCompactionSummary(value)) {
+      throw new Error(
+        "structured-output parse failed: not a CompactionSummary"
+      );
+    }
+    return value;
+  }
+};
+function status(s) {
+  if (s.failure !== null) {
+    return { kind: "failed", failure: s.failure };
+  }
+  if (s.run.phase === "failed" && s.run.failure !== null) {
+    return { kind: "failed", failure: s.run.failure };
+  }
+  if (s.run.phase === "done") {
+    return { kind: "done", output: s.output };
+  }
+  if (s.conversation !== null && s.conversation.awaiting.kind === "tools") {
+    return { kind: "suspended", pending: s.tools.running };
+  }
+  return { kind: "running" };
+}
+function createAgent(config) {
+  const rng = config.rng ?? Math.random;
+  const run = createMonitoredRun({
+    ...config.stages !== void 0 ? { stages: config.stages } : {},
+    ...config.deadlineMs !== void 0 ? { deadlineMs: config.deadlineMs } : {},
+    ...config.snapshotEvery !== void 0 ? { snapshotEvery: config.snapshotEvery } : {}
+  });
+  const llm = createLlmCall(
+    {
+      model: config.model,
+      schemas: config.schemas,
+      ...config.retry !== void 0 ? { retry: config.retry } : {},
+      ...config.loadMessages !== void 0 ? { loadMessages: config.loadMessages } : {}
+    },
+    rng
+  );
+  const compactRc = createResilientCall({ ...config.retry !== void 0 ? { retry: config.retry } : {} }, rng);
+  const fan = createFanOut({
+    concurrency: config.toolConcurrency ?? 1,
+    idOf: (call) => call.callId,
+    of: (call) => config.toolOf(call)
+  });
+  function init() {
+    return {
+      run: run.init(),
+      resilience: llm.init(),
+      tools: initFanOut(),
+      conversation: null,
+      compaction: compactRc.init(),
+      failure: null,
+      output: null
+    };
+  }
+  function freshConversation() {
+    return {
+      turns: [],
+      toolRecords: [],
+      turnCount: 0,
+      awaiting: { kind: "llm" }
+    };
+  }
+  function dedupeByCallId(calls) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const call of calls) {
+      if (seen.has(call.callId)) continue;
+      seen.add(call.callId);
+      out.push(call);
+    }
+    return out;
+  }
+  function foldSummary(conv, folding, summaryTurn) {
+    const shift = folding - 1;
+    const survivingTurns = conv.turns.slice(folding);
+    const survivingRecords = conv.toolRecords.filter((rec) => rec.turn >= folding).map((rec) => ({ ...rec, turn: rec.turn - shift }));
+    return {
+      ...conv,
+      turns: [summaryTurn, ...survivingTurns],
+      toolRecords: survivingRecords,
+      awaiting: { kind: "llm" }
+    };
+  }
+  function currentStage(s) {
+    return s.run.stepStates.find((i) => i.status === "running")?.input;
+  }
+  function brainCall(s) {
+    const stage = currentStage(s);
+    const conversation = s.conversation ?? freshConversation();
+    return {
+      purpose: config.turnOf(stage),
+      model: config.modelId ?? null,
+      payload: config.payloadOf ? config.payloadOf(stage, conversation) : null
+    };
+  }
+  function start(s, runId, at) {
+    const [runSlice] = run.start(s.run, runId, at);
+    const conversation = freshConversation();
+    const withRun = {
+      ...s,
+      run: runSlice,
+      conversation,
+      failure: null,
+      // A restart clears the prior run's terminal output — `result()` reads
+      // `undefined` again until THIS run finishes (#46).
+      output: null,
+      tools: initFanOut(),
+      // A restart also clears any prior compaction slice — a fresh run never
+      // inherits the previous run's summarize retry bookkeeping (#85).
+      compaction: compactRc.init()
+    };
+    const call = brainCall(withRun);
+    const [resilience, cmds] = llm.attempt(withRun.resilience, call, at);
+    return [{ ...withRun, resilience }, cmds];
+  }
+  function turn(s, result, at) {
+    if (isSettled(s)) return [s, []];
+    const conv = s.conversation;
+    if (conv === null || conv.awaiting.kind !== "llm") return [s, []];
+    const withTurn = {
+      ...conv,
+      turns: [...conv.turns, result]
+    };
+    if (result.toolCalls.length === 0) {
+      return advanceStage({ ...s, conversation: withTurn }, result, at);
+    }
+    const batch = dedupeByCallId(result.toolCalls);
+    const [tools, launchCmds] = fan.scatter(
+      initFanOut(),
+      batch
+    );
+    const nextConv = {
+      ...withTurn,
+      awaiting: { kind: "tools", batchTurn: withTurn.turnCount }
+    };
+    const [runSlice] = run.progress(s.run, void 0, at);
+    return [{ ...s, run: runSlice, tools, conversation: nextConv }, launchCmds];
+  }
+  function advanceStage(s, terminatingTurn, at) {
+    const [runSlice, runCmds] = run.advance(
+      s.run,
+      void 0,
+      { kind: "ok" },
+      at
+    );
+    if (runSlice.phase === "done") {
+      return [
+        { ...s, run: runSlice, conversation: null, output: terminatingTurn },
+        runCmds
+      ];
+    }
+    const conversation = freshConversation();
+    const moved = {
+      ...s,
+      run: runSlice,
+      conversation,
+      tools: initFanOut()
+    };
+    const call = brainCall(moved);
+    const [resilience, llmCmds] = llm.attempt(moved.resilience, call, at);
+    return [{ ...moved, resilience }, [...runCmds, ...llmCmds]];
+  }
+  function toolOk(s, callId, result, at) {
+    return settleTool(s, callId, { kind: "ok", result }, at);
+  }
+  function toolErr(s, callId, reason, at) {
+    return settleTool(s, callId, { kind: "error", reason }, at);
+  }
+  function settleTool(s, callId, outcome, at) {
+    if (isSettled(s)) return [s, []];
+    const conv = s.conversation;
+    if (conv === null || conv.awaiting.kind !== "tools") return [s, []];
+    const call = s.tools.running.find((c) => c.callId === callId);
+    if (call === void 0) return [s, []];
+    const [tools, launchCmds] = outcome.kind === "ok" ? fan.itemOk(s.tools, callId, outcome) : fan.itemErr(s.tools, callId, outcome);
+    const foldedConv = {
+      ...conv,
+      // Stamp the producing-turn index on the record (#85, A1). At settle time
+      // `conv.turnCount` equals the index in `turns` of the turn that scattered
+      // this batch (each prior drained batch bumped `turnCount` exactly once, and
+      // each tool-bearing turn appended exactly one entry to `turns`), so a record
+      // carrying `turn: conv.turnCount` is dropped iff its producing turn is folded
+      // (`turn < N`) — the association the fold-back relies on.
+      toolRecords: [
+        ...conv.toolRecords,
+        { call, outcome, turn: conv.turnCount }
+      ]
+    };
+    if (!fan.isComplete(tools)) {
+      const [runSlice2] = run.progress(s.run, void 0, at);
+      return [
+        { ...s, run: runSlice2, tools, conversation: foldedConv },
+        launchCmds
+      ];
+    }
+    const turnedConv = {
+      ...foldedConv,
+      turnCount: foldedConv.turnCount + 1,
+      awaiting: { kind: "llm" }
+    };
+    if (config.maxTurns !== void 0 && turnedConv.turnCount >= config.maxTurns) {
+      return failTurnLimit({ ...s, tools, conversation: turnedConv }, at);
+    }
+    const drained = {
+      ...s,
+      tools: initFanOut(),
+      conversation: turnedConv
+    };
+    const compacting = maybeCompact(drained, at);
+    if (compacting !== null) return compacting;
+    const [runSlice] = run.progress(drained.run, void 0, at);
+    const fired = { ...drained, run: runSlice };
+    const nextCall = brainCall(fired);
+    const [resilience, llmCmds] = llm.attempt(fired.resilience, nextCall, at);
+    return [{ ...fired, resilience }, [...launchCmds, ...llmCmds]];
+  }
+  function maybeCompact(s, at) {
+    const policy = config.compaction;
+    const conv = s.conversation;
+    if (policy === void 0 || conv === null) return null;
+    const requested = policy.planCompaction(conv);
+    const folding = Math.min(requested, conv.turns.length);
+    if (folding < 2) return null;
+    const compactConv = {
+      ...conv,
+      awaiting: { kind: "compacting", folding }
+    };
+    const [runSlice] = run.progress(s.run, void 0, at);
+    const input = {
+      purpose: COMPACTION_PURPOSE,
+      model: config.modelId ?? null,
+      payload: policy.payloadOf ? policy.payloadOf(conv, folding) : null
+    };
+    const [compaction, runCmds] = compactRc.attempt(
+      s.compaction,
+      COMPACTION_PURPOSE,
+      input,
+      at
+    );
+    const cmds = runCmds.map(toCompactRunCmd);
+    return [
+      { ...s, run: runSlice, conversation: compactConv, compaction },
+      cmds
+    ];
+  }
+  function toCompactRunCmd(cmd) {
+    return {
+      type: MsgType.CompactRun,
+      key: COMPACTION_PURPOSE,
+      input: cmd.input
+    };
+  }
+  function failTurnLimit(s, at) {
+    return [{ ...s, failure: { reason: "turn_limit", at } }, []];
+  }
+  function succeed(s, key, msg, at) {
+    const [resilience, retryCmds] = llm.succeed(s.resilience, key, msg);
+    const settled = { ...s, resilience };
+    const [withTurn, turnCmds] = turn(settled, msg.result.output, at);
+    return [withTurn, [...retryCmds, ...turnCmds]];
+  }
+  function fail(s, key, msg, at) {
+    const [resilience, cmds] = llm.fail(s.resilience, key, msg);
+    const call = resilience.calls[key];
+    const failure = call?.phase === "failed" ? { reason: "llm", error: msg.error, at } : s.failure;
+    return [{ ...s, resilience, failure }, cmds];
+  }
+  function compactOk(s, key, msg, at) {
+    const [compaction, retryCmds] = compactRc.succeed(s.compaction, key, {
+      type: MsgType.ResilientOk,
+      key: msg.key,
+      result: msg.result,
+      at: msg.at
+    });
+    const settledRetry = { ...s, compaction };
+    if (isSettled(settledRetry)) return [settledRetry, []];
+    const conv = settledRetry.conversation;
+    if (conv === null || conv.awaiting.kind !== "compacting") {
+      return [settledRetry, retryCmds.map(toCompactRunCmd)];
+    }
+    const folding = conv.awaiting.folding;
+    const summaryTurn = {
+      content: msg.result.output.summary,
+      toolCalls: []
+    };
+    const foldedConv = foldSummary(conv, folding, summaryTurn);
+    const fired = { ...settledRetry, conversation: foldedConv };
+    const nextCall = brainCall(fired);
+    const [resilience, llmCmds] = llm.attempt(fired.resilience, nextCall, at);
+    return [
+      { ...fired, resilience },
+      [...retryCmds.map(toCompactRunCmd), ...llmCmds]
+    ];
+  }
+  function compactErr(s, key, msg, at) {
+    const [compaction, cmds] = compactRc.fail(s.compaction, key, {
+      type: MsgType.ResilientErr,
+      key: msg.key,
+      error: msg.error,
+      at: msg.at
+    });
+    const settledRetry = { ...s, compaction };
+    const call = compaction.calls[key];
+    if (call?.phase === "waiting_retry") {
+      return [settledRetry, cmds.map(toCompactRunCmd)];
+    }
+    if (isSettled(settledRetry)) return [settledRetry, []];
+    const conv = settledRetry.conversation;
+    if (conv === null || conv.awaiting.kind !== "compacting") {
+      return [settledRetry, cmds.map(toCompactRunCmd)];
+    }
+    const resumedConv = { ...conv, awaiting: { kind: "llm" } };
+    const fired = { ...settledRetry, conversation: resumedConv };
+    const nextCall = brainCall(fired);
+    const [resilience, llmCmds] = llm.attempt(fired.resilience, nextCall, at);
+    return [
+      { ...fired, resilience },
+      [...cmds.map(toCompactRunCmd), ...llmCmds]
+    ];
+  }
+  function onTimer(s, msg) {
+    if (msg.id.startsWith("monitored:")) {
+      const [runSlice] = run.onDeadline(s.run, msg);
+      return [{ ...s, run: runSlice }, []];
+    }
+    if (msg.id.endsWith(`:${COMPACTION_PURPOSE}`)) {
+      const [compaction, cmds2] = compactRc.onTimer(s.compaction, msg);
+      return [{ ...s, compaction }, cmds2.map(toCompactRunCmd)];
+    }
+    const [resilience, cmds] = llm.onTimer(s.resilience, msg);
+    return [{ ...s, resilience }, cmds];
+  }
+  function boot(s, at) {
+    const [runSlice] = run.boot(s.run, at);
+    const rebooted = { ...s, run: runSlice };
+    if (isSettled(rebooted)) return [rebooted, []];
+    const conv = rebooted.conversation;
+    if (conv === null) return [rebooted, []];
+    if (conv.awaiting.kind === "llm") {
+      const call = brainCall(rebooted);
+      const [resilience, cmds2] = llm.attempt(rebooted.resilience, call, at);
+      return [{ ...rebooted, resilience }, cmds2];
+    }
+    if (conv.awaiting.kind === "compacting") {
+      const input = {
+        purpose: COMPACTION_PURPOSE,
+        model: config.modelId ?? null,
+        payload: config.compaction?.payloadOf ? config.compaction.payloadOf(conv, conv.awaiting.folding) : null
+      };
+      const [compaction, cmds2] = compactRc.attempt(
+        rebooted.compaction,
+        COMPACTION_PURPOSE,
+        input,
+        at
+      );
+      return [{ ...rebooted, compaction }, cmds2.map(toCompactRunCmd)];
+    }
+    const cmds = rebooted.tools.running.map((call) => config.toolOf(call));
+    return [rebooted, cmds];
+  }
+  function isSettled(s) {
+    return s.run.phase === "done" || s.run.phase === "failed" || s.failure !== null;
+  }
+  function subs(s) {
+    return [
+      ...llm.subs(s.resilience),
+      ...compactRc.subs(s.compaction),
+      ...run.subs(s.run)
+    ];
+  }
+  function unsafeDetachedHandlers(ports) {
+    return llm.handlers(ports);
+  }
+  function brainHandlers() {
+    return llm.handlers();
+  }
+  function toMachine(opts) {
+    const consumerInterpret = opts?.toolInterpret ?? {};
+    const interpret = mergeInterpret(consumerInterpret, brainHandlers());
+    const update = {
+      [MsgType.AgentStart]: (s, m) => start(s, m.runId, m.at),
+      [MsgType.AgentToolOk]: (s, m) => toolOk(s, m.callId, m.result, m.at),
+      [MsgType.AgentToolErr]: (s, m) => toolErr(s, m.callId, m.reason, m.at),
+      // The re-entered brain-call settle Msgs (from `brainHandlers`): success
+      // runs `succeed` (reset retry + fold the turn), failure runs `fail`.
+      [MsgType.ResilientOk]: (s, m) => succeed(s, m.key, m, m.at),
+      [MsgType.ResilientErr]: (s, m) => fail(s, m.key, m, m.at),
+      // The re-entered compaction settle Msgs (from the consumer's `compact_run`
+      // cell, #85): `compact_ok` folds the summary back (drop oldest turns +
+      // their records, fire the next brain call), `compact_err` backs off via the
+      // compaction retry or proceeds without compacting.
+      [MsgType.CompactOk]: (s, m) => compactOk(s, m.key, m, m.at),
+      [MsgType.CompactErr]: (s, m) => compactErr(s, m.key, m, m.at),
+      deadline_exceeded: (s, m) => onTimer(s, m),
+      [MsgType.AgentBoot]: (s, m) => boot(s, m.at)
+    };
+    const machine = {
+      init: (loaded) => loaded !== null ? [loaded, []] : [init(), []],
+      update,
+      subscriptions: (s) => subs(s),
+      subscribe: { deadline: subscribeDeadline },
+      interpret
+    };
+    return defineMachine(machine);
+  }
+  return {
+    init,
+    start,
+    turn,
+    toolOk,
+    toolErr,
+    succeed,
+    fail,
+    compactOk,
+    compactErr,
+    onTimer,
+    boot,
+    isSettled,
+    currentStage,
+    brainCall,
+    subs,
+    // `toMachine` is THE wired path. `unsafeDetachedHandlers` is the
+    // hand-wiring escape hatch — named to advertise the retry-loop gap so it is
+    // never mistaken for the loop driver (#54).
+    toMachine,
+    unsafeDetachedHandlers
+  };
+}
+function agentBootMsg(at) {
+  return { type: MsgType.AgentBoot, at };
+}
+function agentEvents() {
+  return (msg, state) => {
+    const events = [];
+    switch (msg.type) {
+      case MsgType.ResilientOk:
+        events.push({ type: "TurnSettled", turn: msg.result.output });
+        break;
+      case MsgType.AgentToolOk:
+        events.push({
+          type: "ToolSettled",
+          callId: msg.callId,
+          result: msg.result
+        });
+        break;
+      // start / boot / timer / the *_err arms / the compaction settles carry no
+      // public event — return []. (No `default`: the switch is exhaustive over
+      // the Msg discriminant, so a new Msg variant forces a decision here at
+      // compile time.) Compaction is an internal optimization, not a semantic
+      // lifecycle moment a UI folds — its settles are deliberately silent here.
+      case MsgType.AgentStart:
+      case MsgType.AgentToolErr:
+      case MsgType.ResilientErr:
+      case MsgType.CompactOk:
+      case MsgType.CompactErr:
+      case "deadline_exceeded":
+      case MsgType.AgentBoot:
+        break;
+    }
+    if (state.run.phase === "done") {
+      events.push({ type: "RunDone", output: state.output });
+    }
+    return events;
+  };
+}
+function mergeInterpret(a, b) {
+  return { ...a ?? {}, ...b };
+}
+function liftAgent(state, [slice, cmds]) {
+  return [{ ...state, agent: slice }, cmds];
+}
+
+export { COMPACTION_PURPOSE, agentBootMsg, agentEvents, agentTurnSchema, compactionSummarySchema, createAgent, isAgentTurn, isCompactionSummary, liftAgent, mergeInterpret, status };
+//# sourceMappingURL=chunk-S3FQN4SL.js.map
+//# sourceMappingURL=chunk-S3FQN4SL.js.map