@theokit/sdk 2.6.0 → 2.8.0

package/dist/{cron-CM2M9mhB.d.ts → cron-CRPY-aKq.d.cts}

@@ -1,4 +1,4 @@
-import { C as CustomTool, M as ModelSelection, F as SDKUserMessage, H as SendOptions, b as Run, r as RunToCompletionOptions, s as RunToCompletionResult, a as McpServerConfig } from './run-BPRYG1Id.js';
+import { C as CustomTool, M as ModelSelection, F as SDKUserMessage, H as SendOptions, b as Run, r as RunToCompletionOptions, s as RunToCompletionResult, S as SDKMessage, T as StreamToCompletionResult, a as McpServerConfig } from './run-D22b53SU.cjs';
 
 /**
  * Fork primitive public type contracts (T1.2, ADRs D110-D114).
@@ -1473,6 +1473,24 @@ interface SDKAgent {
      * @public
      */
     runToCompletion?(message: string, options?: RunToCompletionOptions): Promise<RunToCompletionResult>;
+    /**
+     * STREAMING continuation driver (V3-4) — the streaming twin of
+     * {@link SDKAgent.runToCompletion}. Returns an `AsyncGenerator` that yields each
+     * round's {@link import("./messages.js").SDKMessage}s LIVE (for a UI), reusing the
+     * same terminal policy (`done`/`step_limit`/`no_progress` + bounded re-prompt).
+     *
+     * The {@link import("./run.js").StreamToCompletionResult} is the generator's RETURN
+     * value — read it via a manual `gen.next()` loop (`while (!res.done) res = await
+     * gen.next()` → `res.value`); a plain `for await...of` consumes the yielded
+     * messages but discards the return value. For the STATELESS path, reconstruct
+     * history with `buildReplayHistory` into a fresh session first.
+     *
+     * Local agents only. Cloud agents throw
+     * {@link import("../errors.js").UnsupportedRunOperationError}.
+     *
+     * @public
+     */
+    streamToCompletion?(message: string, options?: RunToCompletionOptions): AsyncGenerator<SDKMessage, StreamToCompletionResult>;
     /**
      * Direct API to third-party memory adapter(s) registered via
      * `plugins: [...]` (ADR D141 / D142). Returns `null` when no adapter

package/dist/cron.cjs

@@ -1443,7 +1443,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) {
@@ -1472,6 +1480,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, state3) {
   const run = await agent.send(prompt, sendOptions);
   const result = await run.wait();
@@ -1482,19 +1507,21 @@ async function stepRound(agent, prompt, sendOptions, round, maxRounds, state3) {
   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 state3 = { usage: void 0, emptyStreak: 0 };
+  const cfg = resolveContinuation(options);
+  let state3 = cfg.state;
   for (let round = 0; ; round += 1) {
-    const prompt = round === 0 ? message : continuationPrompt;
-    const outcome = await stepRound(agent, prompt, sendOptions, round, maxRounds, state3);
+    const prompt = promptForRound(round, message, cfg.continuationPrompt);
+    const outcome = await stepRound(agent, prompt, cfg.sendOptions, round, cfg.maxRounds, state3);
     if ("terminal" in outcome) return outcome.terminal;
     state3 = outcome.next;
-    await onTruncated?.({ round });
-    if (signal?.aborted === true) {
-      return buildResult("step_limit", round, outcome.lastResult, state3.usage);
-    }
+    const aborted = await continuationTail(
+      round,
+      outcome.lastResult,
+      state3.usage,
+      cfg.onTruncated,
+      cfg.signal
+    );
+    if (aborted !== void 0) return aborted;
   }
 }
 var DEFAULT_MAX_ROUNDS, DEFAULT_CONTINUATION_PROMPT;
@@ -1505,6 +1532,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, state3) {
+  const usage = addUsage(state3.usage, result.usage);
+  const decision = classifyRound(result, round, maxRounds, state3.emptyStreak);
+  if (decision !== "continue") return { terminal: buildResult(decision, round, result, usage) };
+  const emptyStreak = isEmptyRound(result) ? state3.emptyStreak + 1 : 0;
+  return { next: { usage, emptyStreak } };
+}
+async function* streamToCompletionImpl(agent, message, options) {
+  const cfg = resolveContinuation(options);
+  let state3 = 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, state3);
+    if ("terminal" in decision) return decision.terminal;
+    state3 = decision.next;
+    const aborted = await continuationTail(round, result, state3.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, {
@@ -4944,6 +5004,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
@@ -14478,6 +14550,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));
@@ -15022,6 +15098,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();