@theokit/sdk 2.6.0 → 2.8.0

package/dist/eval.js

@@ -1439,7 +1439,15 @@ var init_agent_factory_registry = __esm({
 // src/internal/runtime/lifecycle/run-to-completion.ts
 var run_to_completion_exports = {};
 __export(run_to_completion_exports, {
+  DEFAULT_CONTINUATION_PROMPT: () => DEFAULT_CONTINUATION_PROMPT,
+  DEFAULT_MAX_ROUNDS: () => DEFAULT_MAX_ROUNDS,
+  addUsage: () => addUsage,
+  buildResult: () => buildResult,
   classifyRound: () => classifyRound,
+  continuationTail: () => continuationTail,
+  isEmptyRound: () => isEmptyRound,
+  promptForRound: () => promptForRound,
+  resolveContinuation: () => resolveContinuation,
   runToCompletionImpl: () => runToCompletionImpl
 });
 function isEmptyRound(result) {
@@ -1468,6 +1476,23 @@ function addUsage(acc, u) {
 function buildResult(terminal, rounds, lastResult, usage) {
   return { terminal, rounds, lastResult, ...usage !== void 0 ? { usage } : {} };
 }
+async function continuationTail(round, lastResult, usage, onTruncated, signal) {
+  await onTruncated?.({ round });
+  return signal?.aborted === true ? buildResult("step_limit", round, lastResult, usage) : void 0;
+}
+function resolveContinuation(options) {
+  return {
+    maxRounds: options?.maxRounds ?? DEFAULT_MAX_ROUNDS,
+    continuationPrompt: options?.continuationPrompt ?? DEFAULT_CONTINUATION_PROMPT,
+    onTruncated: options?.onTruncated,
+    signal: options?.signal,
+    sendOptions: options?.sendOptions,
+    state: { usage: void 0, emptyStreak: 0 }
+  };
+}
+function promptForRound(round, message, continuationPrompt) {
+  return round === 0 ? message : continuationPrompt;
+}
 async function stepRound(agent, prompt, sendOptions, round, maxRounds, state2) {
   const run = await agent.send(prompt, sendOptions);
   const result = await run.wait();
@@ -1478,19 +1503,21 @@ async function stepRound(agent, prompt, sendOptions, round, maxRounds, state2) {
   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 };
+  const cfg = resolveContinuation(options);
+  let state2 = cfg.state;
   for (let round = 0; ; round += 1) {
-    const prompt = round === 0 ? message : continuationPrompt;
-    const outcome = await stepRound(agent, prompt, sendOptions, round, maxRounds, state2);
+    const prompt = promptForRound(round, message, cfg.continuationPrompt);
+    const outcome = await stepRound(agent, prompt, cfg.sendOptions, round, cfg.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);
-    }
+    const aborted = await continuationTail(
+      round,
+      outcome.lastResult,
+      state2.usage,
+      cfg.onTruncated,
+      cfg.signal
+    );
+    if (aborted !== void 0) return aborted;
   }
 }
 var DEFAULT_MAX_ROUNDS, DEFAULT_CONTINUATION_PROMPT;
@@ -1501,6 +1528,39 @@ var init_run_to_completion = __esm({
   }
 });
 
+// src/internal/runtime/lifecycle/stream-to-completion.ts
+var stream_to_completion_exports = {};
+__export(stream_to_completion_exports, {
+  streamToCompletionImpl: () => streamToCompletionImpl
+});
+function decideRound(result, round, maxRounds, state2) {
+  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 } };
+}
+async function* streamToCompletionImpl(agent, message, options) {
+  const cfg = resolveContinuation(options);
+  let state2 = cfg.state;
+  for (let round = 0; ; round += 1) {
+    const prompt = promptForRound(round, message, cfg.continuationPrompt);
+    const run = await agent.send(prompt, cfg.sendOptions);
+    yield* run.stream();
+    const result = await run.wait();
+    const decision = decideRound(result, round, cfg.maxRounds, state2);
+    if ("terminal" in decision) return decision.terminal;
+    state2 = decision.next;
+    const aborted = await continuationTail(round, result, state2.usage, cfg.onTruncated, cfg.signal);
+    if (aborted !== void 0) return aborted;
+  }
+}
+var init_stream_to_completion = __esm({
+  "src/internal/runtime/lifecycle/stream-to-completion.ts"() {
+    init_run_to_completion();
+  }
+});
+
 // src/internal/runtime/lifecycle/fork-agent.ts
 var fork_agent_exports = {};
 __export(fork_agent_exports, {
@@ -4936,6 +4996,18 @@ var CloudAgent = class {
       "runToCompletion"
     );
   }
+  /**
+   * Cloud agents do not expose the streaming continuation driver (V3-4);
+   * the cloud runtime manages continuation server-side.
+   *
+   * @public
+   */
+  streamToCompletion() {
+    throw new UnsupportedRunOperationError(
+      "Agent.streamToCompletion() is not supported on cloud agents. Cloud runtime manages continuation server-side. Use a local agent.",
+      "streamToCompletion"
+    );
+  }
   /**
    * Personality presets require consistent server-side enforcement that
    * the cloud runtime (pre-release) does not yet provide. Reject explicitly
@@ -14470,6 +14542,10 @@ function localAgentRunToCompletion(agent, message, options) {
   }
   return run();
 }
+async function* localAgentStreamToCompletion(agent, message, options) {
+  const { streamToCompletionImpl: streamToCompletionImpl2 } = await Promise.resolve().then(() => (init_stream_to_completion(), stream_to_completion_exports));
+  return yield* streamToCompletionImpl2({ send: (m, o) => agent.send(m, o) }, message, options);
+}
 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));
@@ -15014,6 +15090,10 @@ var LocalAgent = class {
   runToCompletion(message, options) {
     return localAgentRunToCompletion(this, message, options);
   }
+  // biome-ignore format: G8 budget — see runUntil comment above.
+  streamToCompletion(message, options) {
+    return localAgentStreamToCompletion(this, message, options);
+  }
 };
 function resolveCwd(cwd) {
   return (Array.isArray(cwd) ? cwd[0] : cwd) ?? process.cwd();