@theokit/sdk 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 2.3.0
+
+### Minor Changes
+
+- d7d5215: M1-3 — `buildReplayHistory(base, events, options)` pure stateless continuation-history rebuild (plan `m1-continuation-history`).
+
+  The stateless complement to M1 Phase 3's `runToCompletion` (which covers the stateful-session path). For a server / serverless handler that re-runs an agent on a fresh request and must reconstruct working memory from persisted stream events, `buildReplayHistory` serializes a round's `SDKMessage[]` into a bounded `StoredMessage[]` you can replay as prior history:
+
+  - maps assistant text → `assistant`; tool `running` → `tool_call` (args); tool `completed`/`error` → `tool_result` (carrying the result content the continued model needs);
+  - drops the oldest turns — pair-safe (a `tool_call` and its `tool_result` are never split) — until the total fits a context-window-derived char budget, keeping ≥ 1;
+  - truncates an oversized single turn (reusing the SDK's `truncateWithMarker`) rather than dropping it;
+  - pure, synchronous, dependency-free; a non-finite `contextWindowTokens` collapses to budget 0 (never returns an unbounded history).
+
+  Exported from `@theokit/sdk` with `ReplayHistoryOptions`. Replaces the outer-loop history rebuild a code-assistant server otherwise hand-rolls.
+
+- f218630: M1 Phase 3 — `agent.runToCompletion()` continuation driver (plan `m1-run-to-completion`).
+
+  Builds on M1-2's `RunResult.stoppedAtIterationLimit` signal: a single `agent.send()` truncates when the model still wants tools at the loop's iteration ceiling. `runToCompletion(message, options?)` re-sends a short continuation prompt — the agent's stateful session preserves the conversation — until a genuine terminal:
+
+  - `done` — a round finished without truncating.
+  - `step_limit` — `maxRounds` (default 5) exhausted, or aborted via `signal`, while still truncating.
+  - `no_progress` — two consecutive rounds produced empty output.
+
+  Returns `{ terminal, rounds, lastResult, usage }` with token usage summed across rounds. Options: `maxRounds`, `continuationPrompt`, `onTruncated`, `signal`, `sendOptions`. Local agents only — cloud agents throw `UnsupportedRunOperationError` (the cloud runtime manages continuation server-side). This replaces the outer continuation loop a code-assistant builder would otherwise hand-roll.
+
 ## 2.2.0
 
 ### Minor Changes

package/dist/a2a/index.cjs

@@ -3003,6 +3003,18 @@ var init_cloud_agent = __esm({
           "fork"
         );
       }
+      /**
+       * The continuation driver re-sends against a stateful local session; the
+       * cloud runtime manages its own continuation policy server-side (M1 Phase 3).
+       *
+       * @public
+       */
+      runToCompletion() {
+        throw new UnsupportedRunOperationError(
+          "Agent.runToCompletion() is not supported on cloud agents. Cloud runtime manages continuation server-side. Use a local agent.",
+          "runToCompletion"
+        );
+      }
       /**
        * Personality presets require consistent server-side enforcement that
        * the cloud runtime (pre-release) does not yet provide. Reject explicitly
@@ -14190,6 +14202,71 @@ var init_agent_factory_registry = __esm({
   }
 });
 
+// src/internal/runtime/lifecycle/run-to-completion.ts
+var run_to_completion_exports = {};
+__export(run_to_completion_exports, {
+  classifyRound: () => classifyRound,
+  runToCompletionImpl: () => runToCompletionImpl
+});
+function isEmptyRound(result) {
+  return (result.result ?? "").trim() === "";
+}
+function classifyRound(result, round, maxRounds, emptyStreak) {
+  if (result.stoppedAtIterationLimit !== true) return "done";
+  if (isEmptyRound(result) && emptyStreak >= 1) return "no_progress";
+  if (round >= maxRounds) return "step_limit";
+  return "continue";
+}
+function addUsage(acc, u) {
+  if (u === void 0) return acc;
+  const inputTokens = (acc?.inputTokens ?? 0) + u.inputTokens;
+  const outputTokens = (acc?.outputTokens ?? 0) + u.outputTokens;
+  const sumOpt = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    cacheReadTokens: sumOpt(acc?.cacheReadTokens, u.cacheReadTokens),
+    cacheWriteTokens: sumOpt(acc?.cacheWriteTokens, u.cacheWriteTokens),
+    reasoningTokens: sumOpt(acc?.reasoningTokens, u.reasoningTokens)
+  };
+}
+function buildResult(terminal, rounds, lastResult, usage) {
+  return { terminal, rounds, lastResult, ...usage !== void 0 ? { usage } : {} };
+}
+async function stepRound(agent, prompt, sendOptions, round, maxRounds, state2) {
+  const run = await agent.send(prompt, sendOptions);
+  const result = await run.wait();
+  const usage = addUsage(state2.usage, result.usage);
+  const decision = classifyRound(result, round, maxRounds, state2.emptyStreak);
+  if (decision !== "continue") return { terminal: buildResult(decision, round, result, usage) };
+  const emptyStreak = isEmptyRound(result) ? state2.emptyStreak + 1 : 0;
+  return { next: { usage, emptyStreak }, lastResult: result };
+}
+async function runToCompletionImpl(agent, message, options) {
+  const maxRounds = options?.maxRounds ?? DEFAULT_MAX_ROUNDS;
+  const continuationPrompt = options?.continuationPrompt ?? DEFAULT_CONTINUATION_PROMPT;
+  const { onTruncated, signal, sendOptions } = options ?? {};
+  let state2 = { usage: void 0, emptyStreak: 0 };
+  for (let round = 0; ; round += 1) {
+    const prompt = round === 0 ? message : continuationPrompt;
+    const outcome = await stepRound(agent, prompt, sendOptions, round, maxRounds, state2);
+    if ("terminal" in outcome) return outcome.terminal;
+    state2 = outcome.next;
+    await onTruncated?.({ round });
+    if (signal?.aborted === true) {
+      return buildResult("step_limit", round, outcome.lastResult, state2.usage);
+    }
+  }
+}
+var DEFAULT_MAX_ROUNDS, DEFAULT_CONTINUATION_PROMPT;
+var init_run_to_completion = __esm({
+  "src/internal/runtime/lifecycle/run-to-completion.ts"() {
+    DEFAULT_MAX_ROUNDS = 5;
+    DEFAULT_CONTINUATION_PROMPT = "Continue from where you left off and finish the task. If it is already complete, give the final answer.";
+  }
+});
+
 // src/internal/runtime/lifecycle/fork-agent.ts
 var fork_agent_exports = {};
 __export(fork_agent_exports, {
@@ -14270,6 +14347,13 @@ function localAgentRunUntil(agent, goal, options) {
   }
   return wrap();
 }
+function localAgentRunToCompletion(agent, message, options) {
+  async function run() {
+    const { runToCompletionImpl: runToCompletionImpl2 } = await Promise.resolve().then(() => (init_run_to_completion(), run_to_completion_exports));
+    return runToCompletionImpl2({ send: (m, o) => agent.send(m, o) }, message, options);
+  }
+  return run();
+}
 async function localAgentFork(parent, options) {
   const { forkAgentImpl: forkAgentImpl2 } = await Promise.resolve().then(() => (init_fork_agent(), fork_agent_exports));
   const { getAgentFacade: getAgentFacade2 } = await Promise.resolve().then(() => (init_agent_factory_registry(), agent_factory_registry_exports));
@@ -15404,6 +15488,10 @@ var init_local_agent = __esm({
       fork(options) {
         return localAgentFork({ agentId: this.agentId, options: this.options, personalitySlugSnapshot: this.personalityStore.active(this.agentId) }, options);
       }
+      // biome-ignore format: G8 budget — see runUntil comment above.
+      runToCompletion(message, options) {
+        return localAgentRunToCompletion(this, message, options);
+      }
     };
   }
 });