@demlik/tea 0.12.0 → 0.14.0

package/dist/chunk-ZF6WDK2D.js

@@ -1,519 +0,0 @@
-import { createMonitoredRun } from './chunk-WLGO64WC.js';
-import { createLlmCall } from './chunk-ND3DH6KM.js';
-import { createResilientCall } from './chunk-EUF7XOEE.js';
-import { MsgType } from './chunk-JELSZN25.js';
-import { createFanOut, initFanOut } from './chunk-D736QUGF.js';
-import { subscribeDeadline } from './chunk-JGVL3WPL.js';
-import { defineMachine } from './chunk-5EHLEUTL.js';
-
-// src/agent/schema.ts
-function schemaFromGuard(guard, name) {
-  return {
-    parse: (value) => {
-      if (!guard(value)) {
-        throw new Error(`structured-output parse failed: not ${name}`);
-      }
-      return value;
-    }
-  };
-}
-
-// src/agent/compaction.ts
-var COMPACTION_PURPOSE = "$compact";
-function isCompactionSummary(value) {
-  if (value === null || typeof value !== "object") return false;
-  return typeof value.summary === "string";
-}
-var compactionSummarySchema = schemaFromGuard(isCompactionSummary, "a CompactionSummary");
-
-// src/agent/internal.ts
-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 isSettled(s) {
-  return s.run.phase === "done" || s.run.phase === "failed" || s.failure !== null;
-}
-function requireAwaiting(s, kind) {
-  if (isSettled(s)) return null;
-  const conv = s.conversation;
-  if (conv === null || conv.awaiting.kind !== kind) return null;
-  return conv;
-}
-function toCompactRunCmd(cmd) {
-  return {
-    type: MsgType.CompactRun,
-    key: COMPACTION_PURPOSE,
-    input: cmd.input
-  };
-}
-
-// src/agent/machine.ts
-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];
-}
-
-// src/agent/types.ts
-function isToolCall(value) {
-  if (value === null || typeof value !== "object") return false;
-  const t = value;
-  return typeof t.callId === "string" && typeof t.name === "string" && t.args !== null && typeof t.args === "object";
-}
-function isAgentTurn(value) {
-  if (value === null || typeof value !== "object") return false;
-  const t = value;
-  return typeof t.content === "string" && Array.isArray(t.toolCalls) && t.toolCalls.every(isToolCall);
-}
-var agentTurnSchema = schemaFromGuard(
-  isAgentTurn,
-  "an AgentTurn"
-);
-function status(s) {
-  if (s.failure !== null) {
-    return { kind: "failed", failure: s.failure };
-  }
-  if (s.run.phase === "failed") {
-    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" };
-}
-
-// src/agent/index.ts
-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 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 fireBrainCall(s, at) {
-    const call = brainCall(s);
-    const [resilience, cmds] = llm.attempt(s.resilience, call, at);
-    return [{ ...s, resilience }, cmds];
-  }
-  function compactionCall(conv, folding) {
-    const payloadOf = config.compaction?.payloadOf;
-    return {
-      purpose: COMPACTION_PURPOSE,
-      model: config.modelId ?? null,
-      payload: payloadOf ? payloadOf(conv, folding) : null
-    };
-  }
-  function reKeyCompactCmds(result) {
-    const [slice, cmds] = result;
-    return [slice, cmds.map(toCompactRunCmd)];
-  }
-  const compact = {
-    attempt: (slice, key, input, at) => reKeyCompactCmds(compactRc.attempt(slice, key, input, at)),
-    succeed: (slice, key, msg) => reKeyCompactCmds(compactRc.succeed(slice, key, msg)),
-    fail: (slice, key, msg) => reKeyCompactCmds(compactRc.fail(slice, key, msg)),
-    onTimer: (slice, msg) => reKeyCompactCmds(compactRc.onTimer(slice, msg))
-  };
-  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()
-    };
-    return fireBrainCall(withRun, at);
-  }
-  function turn(s, result, at) {
-    const conv = requireAwaiting(s, "llm");
-    if (conv === null) 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 [fired, llmCmds] = fireBrainCall(moved, at);
-    return [fired, [...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) {
-    const conv = requireAwaiting(s, "tools");
-    if (conv === null) 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, llmCmds] = fireBrainCall({ ...drained, run: runSlice }, at);
-    return [fired, [...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 = compactionCall(conv, folding);
-    const [compaction, cmds] = compact.attempt(
-      s.compaction,
-      COMPACTION_PURPOSE,
-      input,
-      at
-    );
-    return [
-      { ...s, run: runSlice, conversation: compactConv, compaction },
-      cmds
-    ];
-  }
-  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] = compact.succeed(s.compaction, key, {
-      type: MsgType.ResilientOk,
-      key: msg.key,
-      result: msg.result,
-      at: msg.at
-    });
-    const settledRetry = { ...s, compaction };
-    const conv = requireAwaiting(settledRetry, "compacting");
-    if (conv === null) return [settledRetry, retryCmds];
-    const folding = conv.awaiting.folding;
-    const summaryTurn = {
-      content: msg.result.output.summary,
-      toolCalls: []
-    };
-    const foldedConv = foldSummary(conv, folding, summaryTurn);
-    const [fired, llmCmds] = fireBrainCall(
-      { ...settledRetry, conversation: foldedConv },
-      at
-    );
-    return [fired, [...retryCmds, ...llmCmds]];
-  }
-  function compactErr(s, key, msg, at) {
-    const [compaction, cmds] = compact.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];
-    }
-    const conv = requireAwaiting(settledRetry, "compacting");
-    if (conv === null) return [settledRetry, cmds];
-    const resumedConv = { ...conv, awaiting: { kind: "llm" } };
-    const [fired, llmCmds] = fireBrainCall(
-      { ...settledRetry, conversation: resumedConv },
-      at
-    );
-    return [fired, [...cmds, ...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] = compact.onTimer(s.compaction, msg);
-      return [{ ...s, compaction }, cmds2];
-    }
-    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") {
-      return fireBrainCall(rebooted, at);
-    }
-    if (conv.awaiting.kind === "compacting") {
-      const input = compactionCall(conv, conv.awaiting.folding);
-      const [compaction, cmds2] = compact.attempt(
-        rebooted.compaction,
-        COMPACTION_PURPOSE,
-        input,
-        at
-      );
-      return [{ ...rebooted, compaction }, cmds2];
-    }
-    const cmds = rebooted.tools.running.map((call) => config.toolOf(call));
-    return [rebooted, cmds];
-  }
-  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
-  };
-}
-
-export { COMPACTION_PURPOSE, agentBootMsg, agentEvents, agentTurnSchema, compactionSummarySchema, createAgent, isAgentTurn, isCompactionSummary, liftAgent, mergeInterpret, status };
-//# sourceMappingURL=chunk-ZF6WDK2D.js.map
-//# sourceMappingURL=chunk-ZF6WDK2D.js.map