@demlik/tea 0.2.0 → 0.3.0

package/dist/{chunk-VFGKTGGC.js → chunk-WGGAMW7Y.js}

@@ -1,45 +1,146 @@
-import { createMonitoredRun } from './chunk-ZDRN3YCE.js';
-import { createLlmCall } from './chunk-M6UZT7HS.js';
-import { createResilientCall } from './chunk-6GIGQT6C.js';
+import { createMonitoredRun } from './chunk-CAXMQJJ3.js';
+import { createLlmCall } from './chunk-VBUCHVCV.js';
+import { createResilientCall } from './chunk-IXBKFQH5.js';
 import { MsgType } from './chunk-JELSZN25.js';
-import { createFanOut, initFanOut } from './chunk-UV6UWGEO.js';
-import { subscribeDeadline } from './chunk-SKAMZKTE.js';
-import { defineMachine } from './chunk-6VDCTR7N.js';
+import { createFanOut, initFanOut } from './chunk-D736QUGF.js';
+import { subscribeDeadline } from './chunk-RMX4EOQK.js';
+import { defineMachine } from './chunk-BP2R7TPP.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");
+// 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;
     }
-    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 = {
-  parse: (value) => {
-    if (!isCompactionSummary(value)) {
-      throw new Error(
-        "structured-output parse failed: not a CompactionSummary"
-      );
+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;
     }
-    return value;
-  }
-};
+    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" && s.run.failure !== null) {
+  if (s.run.phase === "failed") {
     return { kind: "failed", failure: s.run.failure };
   }
   if (s.run.phase === "done") {
@@ -50,6 +151,8 @@ function status(s) {
   }
   return { kind: "running" };
 }
+
+// src/agent/index.ts
 function createAgent(config) {
   const rng = config.rng ?? Math.random;
   const run = createMonitoredRun({
@@ -83,38 +186,6 @@ function createAgent(config) {
       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();
@@ -124,6 +195,29 @@ function createAgent(config) {
       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();
@@ -140,14 +234,11 @@ function createAgent(config) {
       // 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];
+    return fireBrainCall(withRun, at);
   }
   function turn(s, result, at) {
-    if (isSettled(s)) return [s, []];
-    const conv = s.conversation;
-    if (conv === null || conv.awaiting.kind !== "llm") return [s, []];
+    const conv = requireAwaiting(s, "llm");
+    if (conv === null) return [s, []];
     const withTurn = {
       ...conv,
       turns: [...conv.turns, result]
@@ -187,9 +278,8 @@ function createAgent(config) {
       conversation,
       tools: initFanOut()
     };
-    const call = brainCall(moved);
-    const [resilience, llmCmds] = llm.attempt(moved.resilience, call, at);
-    return [{ ...moved, resilience }, [...runCmds, ...llmCmds]];
+    const [fired, llmCmds] = fireBrainCall(moved, at);
+    return [fired, [...runCmds, ...llmCmds]];
   }
   function toolOk(s, callId, result, at) {
     return settleTool(s, callId, { kind: "ok", result }, at);
@@ -198,9 +288,8 @@ function createAgent(config) {
     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 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);
@@ -240,10 +329,8 @@ function createAgent(config) {
     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]];
+    const [fired, llmCmds] = fireBrainCall({ ...drained, run: runSlice }, at);
+    return [fired, [...launchCmds, ...llmCmds]];
   }
   function maybeCompact(s, at) {
     const policy = config.compaction;
@@ -257,30 +344,18 @@ function createAgent(config) {
       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(
+    const input = compactionCall(conv, folding);
+    const [compaction, cmds] = compact.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 } }, []];
   }
@@ -297,34 +372,29 @@ function createAgent(config) {
     return [{ ...s, resilience, failure }, cmds];
   }
   function compactOk(s, key, msg, at) {
-    const [compaction, retryCmds] = compactRc.succeed(s.compaction, key, {
+    const [compaction, retryCmds] = compact.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 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 = { ...settledRetry, conversation: foldedConv };
-    const nextCall = brainCall(fired);
-    const [resilience, llmCmds] = llm.attempt(fired.resilience, nextCall, at);
-    return [
-      { ...fired, resilience },
-      [...retryCmds.map(toCompactRunCmd), ...llmCmds]
-    ];
+    const [fired, llmCmds] = fireBrainCall(
+      { ...settledRetry, conversation: foldedConv },
+      at
+    );
+    return [fired, [...retryCmds, ...llmCmds]];
   }
   function compactErr(s, key, msg, at) {
-    const [compaction, cmds] = compactRc.fail(s.compaction, key, {
+    const [compaction, cmds] = compact.fail(s.compaction, key, {
       type: MsgType.ResilientErr,
       key: msg.key,
       error: msg.error,
@@ -333,21 +403,16 @@ function createAgent(config) {
     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)];
+      return [settledRetry, cmds];
     }
+    const conv = requireAwaiting(settledRetry, "compacting");
+    if (conv === null) return [settledRetry, cmds];
     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]
-    ];
+    const [fired, llmCmds] = fireBrainCall(
+      { ...settledRetry, conversation: resumedConv },
+      at
+    );
+    return [fired, [...cmds, ...llmCmds]];
   }
   function onTimer(s, msg) {
     if (msg.id.startsWith("monitored:")) {
@@ -355,8 +420,8 @@ function createAgent(config) {
       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 [compaction, cmds2] = compact.onTimer(s.compaction, msg);
+      return [{ ...s, compaction }, cmds2];
     }
     const [resilience, cmds] = llm.onTimer(s.resilience, msg);
     return [{ ...s, resilience }, cmds];
@@ -368,30 +433,21 @@ function createAgent(config) {
     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];
+      return fireBrainCall(rebooted, at);
     }
     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(
+      const input = compactionCall(conv, conv.awaiting.folding);
+      const [compaction, cmds2] = compact.attempt(
         rebooted.compaction,
         COMPACTION_PURPOSE,
         input,
         at
       );
-      return [{ ...rebooted, compaction }, cmds2.map(toCompactRunCmd)];
+      return [{ ...rebooted, compaction }, cmds2];
     }
     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),
@@ -457,50 +513,7 @@ function createAgent(config) {
     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-VFGKTGGC.js.map
-//# sourceMappingURL=chunk-VFGKTGGC.js.map
+//# sourceMappingURL=chunk-WGGAMW7Y.js.map
+//# sourceMappingURL=chunk-WGGAMW7Y.js.map