@theokit/sdk 0.0.0-compat-580-20260905204608

package/dist/inject-session-SUM6TDJF.js

@@ -0,0 +1,27 @@
+import { enqueueSessionWrite } from './chunk-AWINL3ZC.js';
+import { invalidateSessionCache } from './chunk-2XC6KDJM.js';
+import './chunk-2WXHA33T.js';
+import { SessionTranscript } from './chunk-JOFVLOFY.js';
+import './chunk-3JHIFQ4I.js';
+import './chunk-AGACYRJ2.js';
+import './chunk-CZJ6Q7CW.js';
+
+// src/internal/session/inject-session.ts
+async function injectSessionTurn(opts) {
+  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {
+    const prior = await opts.store.readRecords(opts.loc.agentId);
+    const transcript = SessionTranscript.fromRecords(prior, {
+      cwd: opts.loc.cwd,
+      sessionId: opts.sessionId,
+      model: opts.loc.model ?? "unknown"
+    });
+    transcript.appendUserTurn(opts.userText);
+    transcript.appendAssistantTurn({ text: opts.assistantText });
+    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));
+    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);
+  });
+}
+
+export { injectSessionTurn };
+//# sourceMappingURL=inject-session-SUM6TDJF.js.map
+//# sourceMappingURL=inject-session-SUM6TDJF.js.map

package/dist/inject-session-SUM6TDJF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/session/inject-session.ts"],"names":[],"mappings":";;;;;;;;;AAWA,eAAsB,kBAAkB,IAAA,EAMtB;AAChB,EAAA,MAAM,oBAAoB,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,GAAA,CAAI,SAAS,YAAY;AACpE,IAAA,MAAM,QAAQ,MAAM,IAAA,CAAK,MAAM,WAAA,CAAY,IAAA,CAAK,IAAI,OAAO,CAAA;AAC3D,IAAA,MAAM,UAAA,GAAa,iBAAA,CAAkB,WAAA,CAAY,KAAA,EAAO;AAAA,MACtD,GAAA,EAAK,KAAK,GAAA,CAAI,GAAA;AAAA,MACd,WAAW,IAAA,CAAK,SAAA;AAAA,MAChB,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,KAAA,IAAS;AAAA,KAC1B,CAAA;AACD,IAAA,UAAA,CAAW,cAAA,CAAe,KAAK,QAAQ,CAAA;AACvC,IAAA,UAAA,CAAW,mBAAA,CAAoB,EAAE,IAAA,EAAM,IAAA,CAAK,eAAe,CAAA;AAC3D,IAAA,MAAM,IAAA,CAAK,KAAA,CAAM,aAAA,CAAc,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,UAAA,CAAW,OAAA,EAAQ,CAAE,KAAA,CAAM,KAAA,CAAM,MAAM,CAAC,CAAA;AACzF,IAAA,sBAAA,CAAuB,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,EACvD,CAAC,CAAA;AACH","file":"inject-session-SUM6TDJF.js","sourcesContent":["/**\n * M51 (agent-builder) — inject a SYNTHETIC user+assistant pair into a session's persisted transcript\n * WITHOUT running an LLM turn. This is the Codex review-exit mechanism (`exit_success.xml` appended to\n * the parent thread history so follow-ups like \"fix finding 2\" work): the pair chains onto the DAG\n * leaf (M50 pattern) and the in-memory cache is invalidated so the NEXT send re-hydrates with it.\n */\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { SessionTranscript } from \"../persistence/session-transcript.js\";\nimport { enqueueSessionWrite, invalidateSessionCache } from \"./agent-session.js\";\nimport type { CompactLocation } from \"./compact-session.js\";\n\nexport async function injectSessionTurn(opts: {\n  store: SessionStore;\n  loc: CompactLocation;\n  sessionId: string;\n  userText: string;\n  assistantText: string;\n}): Promise<void> {\n  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {\n    const prior = await opts.store.readRecords(opts.loc.agentId);\n    const transcript = SessionTranscript.fromRecords(prior, {\n      cwd: opts.loc.cwd,\n      sessionId: opts.sessionId,\n      model: opts.loc.model ?? \"unknown\",\n    });\n    transcript.appendUserTurn(opts.userText);\n    transcript.appendAssistantTurn({ text: opts.assistantText });\n    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));\n    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);\n  });\n}\n"]}

package/dist/inject-session-W6A46J3E.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var chunkY2KYR2ED_cjs = require('./chunk-Y2KYR2ED.cjs');
+var chunkYJNYDJ2T_cjs = require('./chunk-YJNYDJ2T.cjs');
+require('./chunk-YIFFF23U.cjs');
+var chunkGZV6AVRL_cjs = require('./chunk-GZV6AVRL.cjs');
+require('./chunk-JLRLCBJ4.cjs');
+require('./chunk-NVXXWAU7.cjs');
+require('./chunk-6LHQPOMI.cjs');
+
+// src/internal/session/inject-session.ts
+async function injectSessionTurn(opts) {
+  await chunkY2KYR2ED_cjs.enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {
+    const prior = await opts.store.readRecords(opts.loc.agentId);
+    const transcript = chunkGZV6AVRL_cjs.SessionTranscript.fromRecords(prior, {
+      cwd: opts.loc.cwd,
+      sessionId: opts.sessionId,
+      model: opts.loc.model ?? "unknown"
+    });
+    transcript.appendUserTurn(opts.userText);
+    transcript.appendAssistantTurn({ text: opts.assistantText });
+    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));
+    chunkYJNYDJ2T_cjs.invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);
+  });
+}
+
+exports.injectSessionTurn = injectSessionTurn;
+//# sourceMappingURL=inject-session-W6A46J3E.cjs.map
+//# sourceMappingURL=inject-session-W6A46J3E.cjs.map

package/dist/inject-session-W6A46J3E.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/session/inject-session.ts"],"names":["enqueueSessionWrite","SessionTranscript","invalidateSessionCache"],"mappings":";;;;;;;;;;;AAWA,eAAsB,kBAAkB,IAAA,EAMtB;AAChB,EAAA,MAAMA,sCAAoB,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,GAAA,CAAI,SAAS,YAAY;AACpE,IAAA,MAAM,QAAQ,MAAM,IAAA,CAAK,MAAM,WAAA,CAAY,IAAA,CAAK,IAAI,OAAO,CAAA;AAC3D,IAAA,MAAM,UAAA,GAAaC,mCAAA,CAAkB,WAAA,CAAY,KAAA,EAAO;AAAA,MACtD,GAAA,EAAK,KAAK,GAAA,CAAI,GAAA;AAAA,MACd,WAAW,IAAA,CAAK,SAAA;AAAA,MAChB,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,KAAA,IAAS;AAAA,KAC1B,CAAA;AACD,IAAA,UAAA,CAAW,cAAA,CAAe,KAAK,QAAQ,CAAA;AACvC,IAAA,UAAA,CAAW,mBAAA,CAAoB,EAAE,IAAA,EAAM,IAAA,CAAK,eAAe,CAAA;AAC3D,IAAA,MAAM,IAAA,CAAK,KAAA,CAAM,aAAA,CAAc,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,UAAA,CAAW,OAAA,EAAQ,CAAE,KAAA,CAAM,KAAA,CAAM,MAAM,CAAC,CAAA;AACzF,IAAAC,wCAAA,CAAuB,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,EACvD,CAAC,CAAA;AACH","file":"inject-session-W6A46J3E.cjs","sourcesContent":["/**\n * M51 (agent-builder) — inject a SYNTHETIC user+assistant pair into a session's persisted transcript\n * WITHOUT running an LLM turn. This is the Codex review-exit mechanism (`exit_success.xml` appended to\n * the parent thread history so follow-ups like \"fix finding 2\" work): the pair chains onto the DAG\n * leaf (M50 pattern) and the in-memory cache is invalidated so the NEXT send re-hydrates with it.\n */\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { SessionTranscript } from \"../persistence/session-transcript.js\";\nimport { enqueueSessionWrite, invalidateSessionCache } from \"./agent-session.js\";\nimport type { CompactLocation } from \"./compact-session.js\";\n\nexport async function injectSessionTurn(opts: {\n  store: SessionStore;\n  loc: CompactLocation;\n  sessionId: string;\n  userText: string;\n  assistantText: string;\n}): Promise<void> {\n  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {\n    const prior = await opts.store.readRecords(opts.loc.agentId);\n    const transcript = SessionTranscript.fromRecords(prior, {\n      cwd: opts.loc.cwd,\n      sessionId: opts.sessionId,\n      model: opts.loc.model ?? \"unknown\",\n    });\n    transcript.appendUserTurn(opts.userText);\n    transcript.appendAssistantTurn({ text: opts.assistantText });\n    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));\n    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);\n  });\n}\n"]}

package/dist/interactive/index.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var chunkJ7J7J2GN_cjs = require('../chunk-J7J7J2GN.cjs');
+require('../chunk-6LHQPOMI.cjs');
+
+// src/interactive/types.ts
+var InteractiveUnavailableError = class extends chunkJ7J7J2GN_cjs.TheokitAgentError {
+  name = "InteractiveUnavailableError";
+  code = "interactive_unavailable";
+  constructor(message) {
+    super(message, { code: "interactive_unavailable", isRetryable: false });
+  }
+};
+var NoSuchSessionError = class extends chunkJ7J7J2GN_cjs.TheokitAgentError {
+  name = "NoSuchSessionError";
+  code = "no_such_session";
+  constructor(sessionId) {
+    super(`no such live session "${sessionId}" (it may have exited or been killed)`, {
+      code: "no_such_session",
+      isRetryable: false
+    });
+  }
+};
+var InteractiveBackend = class {
+};
+async function resolveInteractive(provider, ctx) {
+  return provider instanceof InteractiveBackend ? provider : provider(ctx);
+}
+
+exports.InteractiveBackend = InteractiveBackend;
+exports.InteractiveUnavailableError = InteractiveUnavailableError;
+exports.NoSuchSessionError = NoSuchSessionError;
+exports.resolveInteractive = resolveInteractive;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/interactive/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/interactive/types.ts"],"names":["TheokitAgentError"],"mappings":";;;;;;AAyBO,IAAM,2BAAA,GAAN,cAA0CA,mCAAA,CAAkB;AAAA,EAC/C,IAAA,GAAO,6BAAA;AAAA,EACP,IAAA,GAAO,yBAAA;AAAA,EACzB,YAAY,OAAA,EAAiB;AAE3B,IAAA,KAAA,CAAM,SAAS,EAAE,IAAA,EAAM,yBAAA,EAA2B,WAAA,EAAa,OAAO,CAAA;AAAA,EACxE;AACF;AAMO,IAAM,kBAAA,GAAN,cAAiCA,mCAAA,CAAkB;AAAA,EACtC,IAAA,GAAO,oBAAA;AAAA,EACP,IAAA,GAAO,iBAAA;AAAA,EACzB,YAAY,SAAA,EAAmB;AAE7B,IAAA,KAAA,CAAM,CAAA,sBAAA,EAAyB,SAAS,CAAA,qCAAA,CAAA,EAAyC;AAAA,MAC/E,IAAA,EAAM,iBAAA;AAAA,MACN,WAAA,EAAa;AAAA,KACd,CAAA;AAAA,EACH;AACF;AA2CO,IAAe,qBAAf,MAAkC;AAmBzC;AAcA,eAAsB,kBAAA,CACpB,UACA,GAAA,EAC6B;AAC7B,EAAA,OAAO,QAAA,YAAoB,kBAAA,GAAqB,QAAA,GAAW,QAAA,CAAS,GAAG,CAAA;AACzE","file":"index.cjs","sourcesContent":["/**\n * Interactive-session backend protocol — the streaming twin of `SandboxBackend`\n * (which is one-shot `execute`). A surface-agnostic contract for driving a\n * long-lived interactive process (a REPL, `git rebase -i`, any command that\n * PROMPTS for stdin): start → `session_id`, write to stdin, read incremental\n * output, kill.\n *\n * Injected exactly like {@link FilesystemProvider} (SE31) — the tool depends on\n * the interface, the HOST supplies the implementation, so the SAME tool runs on\n * a local PTY (`@theokit/sdk-pty`), a container/E2B backend (cluster/web), or a\n * desktop backend (Tauri) with NO tool change and NO native dependency in core.\n *\n * @public\n */\n\nimport { TheokitAgentError } from \"../errors.js\";\n\n/** Thrown when the interactive path is requested but no backend can provide it\n *  (no provider injected, or a local backend whose native module / spawn failed).\n *  The caller falls back to non-interactive exec.\n *\n *  Extends {@link TheokitAgentError} like every other typed error the SDK publishes: it used to\n *  extend bare `Error`, so a consumer catching `TheokitAgentError` — the documented way to catch\n *  anything this SDK throws — missed it, and it carried no `isRetryable`. Additive: `instanceof\n *  Error` and the `code` literal are unchanged. */\nexport class InteractiveUnavailableError extends TheokitAgentError {\n  override readonly name = \"InteractiveUnavailableError\";\n  override readonly code = \"interactive_unavailable\" as const;\n  constructor(message: string) {\n    // Not retryable: no backend is a configuration fact, and retrying re-asks the same question.\n    super(message, { code: \"interactive_unavailable\", isRetryable: false });\n  }\n}\n\n/** Thrown (typed) when a write/kill targets an unknown or already-exited session,\n *  so callers branch on the type instead of string-matching a message.\n *\n *  Extends {@link TheokitAgentError} — see {@link InteractiveUnavailableError} for why. */\nexport class NoSuchSessionError extends TheokitAgentError {\n  override readonly name = \"NoSuchSessionError\";\n  override readonly code = \"no_such_session\" as const;\n  constructor(sessionId: string) {\n    // Not retryable: the session is gone, and it does not come back.\n    super(`no such live session \"${sessionId}\" (it may have exited or been killed)`, {\n      code: \"no_such_session\",\n      isRetryable: false,\n    });\n  }\n}\n\n/** Result of starting a session: its id + whatever the program printed on startup. */\nexport interface StartInteractiveResult {\n  sessionId: string;\n  output: string;\n}\n\n/** Result of writing to a session: the output produced during the yield window + liveness. */\nexport interface WriteStdinResult {\n  output: string;\n  alive: boolean;\n}\n\n/** Bounds a start call. All optional; a backend clamps/defaults each. */\nexport interface StartInteractiveOptions {\n  /** Working directory for the session. Defaults to the backend's root. */\n  cwd?: string;\n  /** How long to wait, in ms, before returning the startup output (clamped by the backend). */\n  yieldMs?: number;\n  /** Idle time, in ms, after which the backend reaps a forgotten session. */\n  ttlMs?: number;\n  /** Cap on the returned output bytes (tail kept). */\n  maxBytes?: number;\n  /** Terminal geometry, when the backend allocates a real TTY. */\n  cols?: number;\n  rows?: number;\n}\n\n/** Bounds a write call. */\nexport interface WriteStdinOptions {\n  yieldMs?: number;\n  ttlMs?: number;\n  maxBytes?: number;\n}\n\n/**\n * Pluggable interactive-session backend. Implement the three abstract methods.\n * A backend that cannot provide interactive sessions should not be constructed —\n * callers detect absence by catching {@link InteractiveUnavailableError}.\n *\n * @public\n */\nexport abstract class InteractiveBackend {\n  /** Spawn `command` as an interactive session; resolve after the yield window with the\n   *  `session_id` + startup output. Throws {@link InteractiveUnavailableError} when the\n   *  session cannot be allocated. */\n  abstract startInteractive(\n    command: string,\n    opts?: StartInteractiveOptions,\n  ): Promise<StartInteractiveResult>;\n\n  /** Write `chars` to a live session's stdin; resolve after the yield window with the output it\n   *  produced + whether it is still alive. Throws {@link NoSuchSessionError} on an unknown session. */\n  abstract writeStdin(\n    sessionId: string,\n    chars: string,\n    opts?: WriteStdinOptions,\n  ): Promise<WriteStdinResult>;\n\n  /** Kill a session (idempotent) and free its slot. */\n  abstract kill(sessionId: string): void;\n}\n\n/**\n * A backend OR a per-request resolver of one — mirrors {@link FilesystemProvider}. A resolver runs\n * at tool-execution time (request scope), so multi-tenant / multi-role agents get a distinct backend\n * per request without a shared mutable one.\n *\n * @public\n */\nexport type InteractiveProvider<Ctx = unknown> =\n  | InteractiveBackend\n  | ((ctx: Ctx) => InteractiveBackend | Promise<InteractiveBackend>);\n\n/** Resolve an {@link InteractiveProvider} to a concrete backend for `ctx`. */\nexport async function resolveInteractive<Ctx>(\n  provider: InteractiveProvider<Ctx>,\n  ctx: Ctx,\n): Promise<InteractiveBackend> {\n  return provider instanceof InteractiveBackend ? provider : provider(ctx);\n}\n"]}

package/dist/interactive/index.d.cts

@@ -0,0 +1,12 @@
+/**
+ * `@theokit/sdk/interactive` — pluggable interactive-session backend seam.
+ *
+ * The streaming twin of `@theokit/sdk/sandbox` (one-shot `execute`) and sibling
+ * of `@theokit/sdk/filesystem`. Ship an `InteractiveBackend` (e.g. the local
+ * `@theokit/sdk-pty`, a container/E2B backend for the cluster, or a Tauri
+ * backend) to give agent shell tools a surface-agnostic REPL/stdin capability —
+ * with NO native dependency in core.
+ *
+ * @public
+ */
+export { InteractiveBackend, type InteractiveProvider, InteractiveUnavailableError, NoSuchSessionError, resolveInteractive, type StartInteractiveOptions, type StartInteractiveResult, type WriteStdinOptions, type WriteStdinResult, } from "./types.js";

package/dist/interactive/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@theokit/sdk/interactive` — pluggable interactive-session backend seam.
+ *
+ * The streaming twin of `@theokit/sdk/sandbox` (one-shot `execute`) and sibling
+ * of `@theokit/sdk/filesystem`. Ship an `InteractiveBackend` (e.g. the local
+ * `@theokit/sdk-pty`, a container/E2B backend for the cluster, or a Tauri
+ * backend) to give agent shell tools a surface-agnostic REPL/stdin capability —
+ * with NO native dependency in core.
+ *
+ * @public
+ */
+export { InteractiveBackend, type InteractiveProvider, InteractiveUnavailableError, NoSuchSessionError, resolveInteractive, type StartInteractiveOptions, type StartInteractiveResult, type WriteStdinOptions, type WriteStdinResult, } from "./types.js";

package/dist/interactive/index.js

@@ -0,0 +1,30 @@
+import { TheokitAgentError } from '../chunk-ALUN2B4W.js';
+import '../chunk-CZJ6Q7CW.js';
+
+// src/interactive/types.ts
+var InteractiveUnavailableError = class extends TheokitAgentError {
+  name = "InteractiveUnavailableError";
+  code = "interactive_unavailable";
+  constructor(message) {
+    super(message, { code: "interactive_unavailable", isRetryable: false });
+  }
+};
+var NoSuchSessionError = class extends TheokitAgentError {
+  name = "NoSuchSessionError";
+  code = "no_such_session";
+  constructor(sessionId) {
+    super(`no such live session "${sessionId}" (it may have exited or been killed)`, {
+      code: "no_such_session",
+      isRetryable: false
+    });
+  }
+};
+var InteractiveBackend = class {
+};
+async function resolveInteractive(provider, ctx) {
+  return provider instanceof InteractiveBackend ? provider : provider(ctx);
+}
+
+export { InteractiveBackend, InteractiveUnavailableError, NoSuchSessionError, resolveInteractive };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/interactive/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/interactive/types.ts"],"names":[],"mappings":";;;;AAyBO,IAAM,2BAAA,GAAN,cAA0C,iBAAA,CAAkB;AAAA,EAC/C,IAAA,GAAO,6BAAA;AAAA,EACP,IAAA,GAAO,yBAAA;AAAA,EACzB,YAAY,OAAA,EAAiB;AAE3B,IAAA,KAAA,CAAM,SAAS,EAAE,IAAA,EAAM,yBAAA,EAA2B,WAAA,EAAa,OAAO,CAAA;AAAA,EACxE;AACF;AAMO,IAAM,kBAAA,GAAN,cAAiC,iBAAA,CAAkB;AAAA,EACtC,IAAA,GAAO,oBAAA;AAAA,EACP,IAAA,GAAO,iBAAA;AAAA,EACzB,YAAY,SAAA,EAAmB;AAE7B,IAAA,KAAA,CAAM,CAAA,sBAAA,EAAyB,SAAS,CAAA,qCAAA,CAAA,EAAyC;AAAA,MAC/E,IAAA,EAAM,iBAAA;AAAA,MACN,WAAA,EAAa;AAAA,KACd,CAAA;AAAA,EACH;AACF;AA2CO,IAAe,qBAAf,MAAkC;AAmBzC;AAcA,eAAsB,kBAAA,CACpB,UACA,GAAA,EAC6B;AAC7B,EAAA,OAAO,QAAA,YAAoB,kBAAA,GAAqB,QAAA,GAAW,QAAA,CAAS,GAAG,CAAA;AACzE","file":"index.js","sourcesContent":["/**\n * Interactive-session backend protocol — the streaming twin of `SandboxBackend`\n * (which is one-shot `execute`). A surface-agnostic contract for driving a\n * long-lived interactive process (a REPL, `git rebase -i`, any command that\n * PROMPTS for stdin): start → `session_id`, write to stdin, read incremental\n * output, kill.\n *\n * Injected exactly like {@link FilesystemProvider} (SE31) — the tool depends on\n * the interface, the HOST supplies the implementation, so the SAME tool runs on\n * a local PTY (`@theokit/sdk-pty`), a container/E2B backend (cluster/web), or a\n * desktop backend (Tauri) with NO tool change and NO native dependency in core.\n *\n * @public\n */\n\nimport { TheokitAgentError } from \"../errors.js\";\n\n/** Thrown when the interactive path is requested but no backend can provide it\n *  (no provider injected, or a local backend whose native module / spawn failed).\n *  The caller falls back to non-interactive exec.\n *\n *  Extends {@link TheokitAgentError} like every other typed error the SDK publishes: it used to\n *  extend bare `Error`, so a consumer catching `TheokitAgentError` — the documented way to catch\n *  anything this SDK throws — missed it, and it carried no `isRetryable`. Additive: `instanceof\n *  Error` and the `code` literal are unchanged. */\nexport class InteractiveUnavailableError extends TheokitAgentError {\n  override readonly name = \"InteractiveUnavailableError\";\n  override readonly code = \"interactive_unavailable\" as const;\n  constructor(message: string) {\n    // Not retryable: no backend is a configuration fact, and retrying re-asks the same question.\n    super(message, { code: \"interactive_unavailable\", isRetryable: false });\n  }\n}\n\n/** Thrown (typed) when a write/kill targets an unknown or already-exited session,\n *  so callers branch on the type instead of string-matching a message.\n *\n *  Extends {@link TheokitAgentError} — see {@link InteractiveUnavailableError} for why. */\nexport class NoSuchSessionError extends TheokitAgentError {\n  override readonly name = \"NoSuchSessionError\";\n  override readonly code = \"no_such_session\" as const;\n  constructor(sessionId: string) {\n    // Not retryable: the session is gone, and it does not come back.\n    super(`no such live session \"${sessionId}\" (it may have exited or been killed)`, {\n      code: \"no_such_session\",\n      isRetryable: false,\n    });\n  }\n}\n\n/** Result of starting a session: its id + whatever the program printed on startup. */\nexport interface StartInteractiveResult {\n  sessionId: string;\n  output: string;\n}\n\n/** Result of writing to a session: the output produced during the yield window + liveness. */\nexport interface WriteStdinResult {\n  output: string;\n  alive: boolean;\n}\n\n/** Bounds a start call. All optional; a backend clamps/defaults each. */\nexport interface StartInteractiveOptions {\n  /** Working directory for the session. Defaults to the backend's root. */\n  cwd?: string;\n  /** How long to wait, in ms, before returning the startup output (clamped by the backend). */\n  yieldMs?: number;\n  /** Idle time, in ms, after which the backend reaps a forgotten session. */\n  ttlMs?: number;\n  /** Cap on the returned output bytes (tail kept). */\n  maxBytes?: number;\n  /** Terminal geometry, when the backend allocates a real TTY. */\n  cols?: number;\n  rows?: number;\n}\n\n/** Bounds a write call. */\nexport interface WriteStdinOptions {\n  yieldMs?: number;\n  ttlMs?: number;\n  maxBytes?: number;\n}\n\n/**\n * Pluggable interactive-session backend. Implement the three abstract methods.\n * A backend that cannot provide interactive sessions should not be constructed —\n * callers detect absence by catching {@link InteractiveUnavailableError}.\n *\n * @public\n */\nexport abstract class InteractiveBackend {\n  /** Spawn `command` as an interactive session; resolve after the yield window with the\n   *  `session_id` + startup output. Throws {@link InteractiveUnavailableError} when the\n   *  session cannot be allocated. */\n  abstract startInteractive(\n    command: string,\n    opts?: StartInteractiveOptions,\n  ): Promise<StartInteractiveResult>;\n\n  /** Write `chars` to a live session's stdin; resolve after the yield window with the output it\n   *  produced + whether it is still alive. Throws {@link NoSuchSessionError} on an unknown session. */\n  abstract writeStdin(\n    sessionId: string,\n    chars: string,\n    opts?: WriteStdinOptions,\n  ): Promise<WriteStdinResult>;\n\n  /** Kill a session (idempotent) and free its slot. */\n  abstract kill(sessionId: string): void;\n}\n\n/**\n * A backend OR a per-request resolver of one — mirrors {@link FilesystemProvider}. A resolver runs\n * at tool-execution time (request scope), so multi-tenant / multi-role agents get a distinct backend\n * per request without a shared mutable one.\n *\n * @public\n */\nexport type InteractiveProvider<Ctx = unknown> =\n  | InteractiveBackend\n  | ((ctx: Ctx) => InteractiveBackend | Promise<InteractiveBackend>);\n\n/** Resolve an {@link InteractiveProvider} to a concrete backend for `ctx`. */\nexport async function resolveInteractive<Ctx>(\n  provider: InteractiveProvider<Ctx>,\n  ctx: Ctx,\n): Promise<InteractiveBackend> {\n  return provider instanceof InteractiveBackend ? provider : provider(ctx);\n}\n"]}

package/dist/interactive/types.d.cts

@@ -0,0 +1,95 @@
+/**
+ * Interactive-session backend protocol — the streaming twin of `SandboxBackend`
+ * (which is one-shot `execute`). A surface-agnostic contract for driving a
+ * long-lived interactive process (a REPL, `git rebase -i`, any command that
+ * PROMPTS for stdin): start → `session_id`, write to stdin, read incremental
+ * output, kill.
+ *
+ * Injected exactly like {@link FilesystemProvider} (SE31) — the tool depends on
+ * the interface, the HOST supplies the implementation, so the SAME tool runs on
+ * a local PTY (`@theokit/sdk-pty`), a container/E2B backend (cluster/web), or a
+ * desktop backend (Tauri) with NO tool change and NO native dependency in core.
+ *
+ * @public
+ */
+import { TheokitAgentError } from "../errors.js";
+/** Thrown when the interactive path is requested but no backend can provide it
+ *  (no provider injected, or a local backend whose native module / spawn failed).
+ *  The caller falls back to non-interactive exec.
+ *
+ *  Extends {@link TheokitAgentError} like every other typed error the SDK publishes: it used to
+ *  extend bare `Error`, so a consumer catching `TheokitAgentError` — the documented way to catch
+ *  anything this SDK throws — missed it, and it carried no `isRetryable`. Additive: `instanceof
+ *  Error` and the `code` literal are unchanged. */
+export declare class InteractiveUnavailableError extends TheokitAgentError {
+    readonly name = "InteractiveUnavailableError";
+    readonly code: "interactive_unavailable";
+    constructor(message: string);
+}
+/** Thrown (typed) when a write/kill targets an unknown or already-exited session,
+ *  so callers branch on the type instead of string-matching a message.
+ *
+ *  Extends {@link TheokitAgentError} — see {@link InteractiveUnavailableError} for why. */
+export declare class NoSuchSessionError extends TheokitAgentError {
+    readonly name = "NoSuchSessionError";
+    readonly code: "no_such_session";
+    constructor(sessionId: string);
+}
+/** Result of starting a session: its id + whatever the program printed on startup. */
+export interface StartInteractiveResult {
+    sessionId: string;
+    output: string;
+}
+/** Result of writing to a session: the output produced during the yield window + liveness. */
+export interface WriteStdinResult {
+    output: string;
+    alive: boolean;
+}
+/** Bounds a start call. All optional; a backend clamps/defaults each. */
+export interface StartInteractiveOptions {
+    /** Working directory for the session. Defaults to the backend's root. */
+    cwd?: string;
+    /** How long to wait, in ms, before returning the startup output (clamped by the backend). */
+    yieldMs?: number;
+    /** Idle time, in ms, after which the backend reaps a forgotten session. */
+    ttlMs?: number;
+    /** Cap on the returned output bytes (tail kept). */
+    maxBytes?: number;
+    /** Terminal geometry, when the backend allocates a real TTY. */
+    cols?: number;
+    rows?: number;
+}
+/** Bounds a write call. */
+export interface WriteStdinOptions {
+    yieldMs?: number;
+    ttlMs?: number;
+    maxBytes?: number;
+}
+/**
+ * Pluggable interactive-session backend. Implement the three abstract methods.
+ * A backend that cannot provide interactive sessions should not be constructed —
+ * callers detect absence by catching {@link InteractiveUnavailableError}.
+ *
+ * @public
+ */
+export declare abstract class InteractiveBackend {
+    /** Spawn `command` as an interactive session; resolve after the yield window with the
+     *  `session_id` + startup output. Throws {@link InteractiveUnavailableError} when the
+     *  session cannot be allocated. */
+    abstract startInteractive(command: string, opts?: StartInteractiveOptions): Promise<StartInteractiveResult>;
+    /** Write `chars` to a live session's stdin; resolve after the yield window with the output it
+     *  produced + whether it is still alive. Throws {@link NoSuchSessionError} on an unknown session. */
+    abstract writeStdin(sessionId: string, chars: string, opts?: WriteStdinOptions): Promise<WriteStdinResult>;
+    /** Kill a session (idempotent) and free its slot. */
+    abstract kill(sessionId: string): void;
+}
+/**
+ * A backend OR a per-request resolver of one — mirrors {@link FilesystemProvider}. A resolver runs
+ * at tool-execution time (request scope), so multi-tenant / multi-role agents get a distinct backend
+ * per request without a shared mutable one.
+ *
+ * @public
+ */
+export type InteractiveProvider<Ctx = unknown> = InteractiveBackend | ((ctx: Ctx) => InteractiveBackend | Promise<InteractiveBackend>);
+/** Resolve an {@link InteractiveProvider} to a concrete backend for `ctx`. */
+export declare function resolveInteractive<Ctx>(provider: InteractiveProvider<Ctx>, ctx: Ctx): Promise<InteractiveBackend>;

package/dist/interactive/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Interactive-session backend protocol — the streaming twin of `SandboxBackend`
+ * (which is one-shot `execute`). A surface-agnostic contract for driving a
+ * long-lived interactive process (a REPL, `git rebase -i`, any command that
+ * PROMPTS for stdin): start → `session_id`, write to stdin, read incremental
+ * output, kill.
+ *
+ * Injected exactly like {@link FilesystemProvider} (SE31) — the tool depends on
+ * the interface, the HOST supplies the implementation, so the SAME tool runs on
+ * a local PTY (`@theokit/sdk-pty`), a container/E2B backend (cluster/web), or a
+ * desktop backend (Tauri) with NO tool change and NO native dependency in core.
+ *
+ * @public
+ */
+import { TheokitAgentError } from "../errors.js";
+/** Thrown when the interactive path is requested but no backend can provide it
+ *  (no provider injected, or a local backend whose native module / spawn failed).
+ *  The caller falls back to non-interactive exec.
+ *
+ *  Extends {@link TheokitAgentError} like every other typed error the SDK publishes: it used to
+ *  extend bare `Error`, so a consumer catching `TheokitAgentError` — the documented way to catch
+ *  anything this SDK throws — missed it, and it carried no `isRetryable`. Additive: `instanceof
+ *  Error` and the `code` literal are unchanged. */
+export declare class InteractiveUnavailableError extends TheokitAgentError {
+    readonly name = "InteractiveUnavailableError";
+    readonly code: "interactive_unavailable";
+    constructor(message: string);
+}
+/** Thrown (typed) when a write/kill targets an unknown or already-exited session,
+ *  so callers branch on the type instead of string-matching a message.
+ *
+ *  Extends {@link TheokitAgentError} — see {@link InteractiveUnavailableError} for why. */
+export declare class NoSuchSessionError extends TheokitAgentError {
+    readonly name = "NoSuchSessionError";
+    readonly code: "no_such_session";
+    constructor(sessionId: string);
+}
+/** Result of starting a session: its id + whatever the program printed on startup. */
+export interface StartInteractiveResult {
+    sessionId: string;
+    output: string;
+}
+/** Result of writing to a session: the output produced during the yield window + liveness. */
+export interface WriteStdinResult {
+    output: string;
+    alive: boolean;
+}
+/** Bounds a start call. All optional; a backend clamps/defaults each. */
+export interface StartInteractiveOptions {
+    /** Working directory for the session. Defaults to the backend's root. */
+    cwd?: string;
+    /** How long to wait, in ms, before returning the startup output (clamped by the backend). */
+    yieldMs?: number;
+    /** Idle time, in ms, after which the backend reaps a forgotten session. */
+    ttlMs?: number;
+    /** Cap on the returned output bytes (tail kept). */
+    maxBytes?: number;
+    /** Terminal geometry, when the backend allocates a real TTY. */
+    cols?: number;
+    rows?: number;
+}
+/** Bounds a write call. */
+export interface WriteStdinOptions {
+    yieldMs?: number;
+    ttlMs?: number;
+    maxBytes?: number;
+}
+/**
+ * Pluggable interactive-session backend. Implement the three abstract methods.
+ * A backend that cannot provide interactive sessions should not be constructed —
+ * callers detect absence by catching {@link InteractiveUnavailableError}.
+ *
+ * @public
+ */
+export declare abstract class InteractiveBackend {
+    /** Spawn `command` as an interactive session; resolve after the yield window with the
+     *  `session_id` + startup output. Throws {@link InteractiveUnavailableError} when the
+     *  session cannot be allocated. */
+    abstract startInteractive(command: string, opts?: StartInteractiveOptions): Promise<StartInteractiveResult>;
+    /** Write `chars` to a live session's stdin; resolve after the yield window with the output it
+     *  produced + whether it is still alive. Throws {@link NoSuchSessionError} on an unknown session. */
+    abstract writeStdin(sessionId: string, chars: string, opts?: WriteStdinOptions): Promise<WriteStdinResult>;
+    /** Kill a session (idempotent) and free its slot. */
+    abstract kill(sessionId: string): void;
+}
+/**
+ * A backend OR a per-request resolver of one — mirrors {@link FilesystemProvider}. A resolver runs
+ * at tool-execution time (request scope), so multi-tenant / multi-role agents get a distinct backend
+ * per request without a shared mutable one.
+ *
+ * @public
+ */
+export type InteractiveProvider<Ctx = unknown> = InteractiveBackend | ((ctx: Ctx) => InteractiveBackend | Promise<InteractiveBackend>);
+/** Resolve an {@link InteractiveProvider} to a concrete backend for `ctx`. */
+export declare function resolveInteractive<Ctx>(provider: InteractiveProvider<Ctx>, ctx: Ctx): Promise<InteractiveBackend>;

package/dist/internal/agent/batch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `Agent.batch(prompts, options)` core (ADRs D134-D140).
+ *
+ * Fans out N prompts via bounded concurrency, isolates failures per-prompt,
+ * preserves input order in the result array, supports streaming callbacks
+ * + AbortSignal. The credential pool (D131) is shared across all
+ * in-flight agents via `withCredentialPool` ALS scope (EC-A fix).
+ *
+ * @internal
+ */
+export {};

package/dist/internal/agent/helpers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/agent-loop/budget-gate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/agent-loop/doom-loop-tracker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Doom-loop guard — detects consecutive IDENTICAL tool calls (same name + same canonical input)
+ * and escalates `ok` → `soft` (one-time nudge) → `hard` (stop). Inspection is TOTAL — `signatureOf`
+ * and `inspect` never throw on any tool-call input. The constructor validates thresholds and throws
+ * a typed `ConfigurationError` on invalid config (fail-fast at the boundary — a 0/negative/non-integer
+ * threshold is a caller bug, not a loop input). Ported in shape from a peer `LoopDetectionTracker`.
+ * Complements the empty-round `no_progress` terminal (a DIFFERENT failure mode: model stuck repeating
+ * vs model gone silent).
+ * @internal
+ */
+/** Verdict from {@link DoomLoopTracker.inspect}. `soft` carries a guidance message, `hard` a stop message. */
+export interface DoomLoopVerdict {
+    kind: "ok" | "soft" | "hard";
+    message?: string;
+}
+/** Consecutive-identical thresholds. `soft` fires once (at exactly the count); `hard` stops. */
+export interface DoomLoopConfig {
+    softThreshold: number;
+    hardThreshold: number;
+}
+/** Public config on a send: `false` disables the guard; an object tunes the thresholds; absent = on. */
+export type DoomLoopOption = false | Partial<DoomLoopConfig>;

package/dist/internal/agent-loop/live-events.d.ts

@@ -0,0 +1,46 @@
+import type { SDKMessage } from "../../types/messages.js";
+/**
+ * theokit#140 — the loop's event log, reporting each event AS IT HAPPENS.
+ *
+ * ## The defect this closes
+ *
+ * `runAgentLoop` collected events into a plain array and returned it, so nothing reached the run
+ * until the loop had finished. `RealLocalRun.applyAgentLoopOutput` then copied the whole batch in
+ * one pass. Meanwhile `SendOptions.onDelta` fired live from inside that same loop.
+ *
+ * Two clocks, one of which does not start until the other has stopped. A consumer that wanted tool
+ * calls interleaved with tokens in true order had to fuse both surfaces itself — which is exactly
+ * what `@theokit/agents` was doing, and the documented root of its ordering bug (theokit#47), its
+ * namespace-dedup bug (theokit#138) and its missing terminal frame (theokit#142).
+ *
+ * ## Why a subclass, and not a callback threaded through nine call sites
+ *
+ * The events are appended from nine places across `loop.ts`, `loop-llm-stream.ts` and
+ * `tool-dispatch.ts`. Threading an `onEvent` parameter to each would touch every one of them and,
+ * worse, would leave the NEXT `events.push(...)` silently un-notified — a defect that reintroduces
+ * itself by omission, which is the failure mode this whole issue is about.
+ *
+ * Extending `Array` moves the decision to the single place the log is CREATED. Every existing push
+ * becomes live with no call-site change, and any push added later is live for free.
+ *
+ * It stays a real `Array`: `AgentLoopOutput.events` is still `SDKMessage[]`, `instanceof Array`
+ * still holds, and every downstream consumer — including the batch copy in `applyAgentLoopOutput` —
+ * is unchanged. This is additive; nothing that worked before observes a difference.
+ *
+ * `push` is the only override, deliberately. The loop only ever appends; overriding the rest of the
+ * mutation surface would be guarding against callers that do not exist (YAGNI), and a subscriber
+ * that must reason about splices is a worse contract than one that receives appends.
+ */
+export declare class LiveEventLog extends Array<SDKMessage> {
+    #private;
+    /** Attach the live subscriber. One sink: the run that owns this loop. */
+    subscribe(sink: (event: SDKMessage) => void): void;
+    push(...events: SDKMessage[]): number;
+}
+/**
+ * Build the loop's event log, seeded with the events that exist before the loop starts.
+ *
+ * `LiveEventLog.from` rather than `new LiveEventLog(...seed)`: the `Array` constructor treats a
+ * single numeric argument as a length, and a seed is a list of events, never a count.
+ */
+export declare function createEventLog(seed: readonly SDKMessage[]): LiveEventLog;

package/dist/internal/agent-loop/loop-context-init.d.ts

@@ -0,0 +1,2 @@
+import type { AgentLoopInputs } from "./types.js";
+export declare function initLoopContext(inputs: AgentLoopInputs): Promise<LoopContext>;

package/dist/internal/agent-loop/loop-finalize.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The tail of `runAgentLoop`: everything that happens after its last turn.
+ *
+ * Its own module rather than four more functions in `loop.ts` for two reasons that agree. The file
+ * was 12 logical lines over the 400-line budget with them inline, and more importantly the split is
+ * real: nothing here runs during a turn, so none of it is covered by the argument the loop's
+ * `biome-ignore` makes about keeping the streaming contract linear.
+ *
+ * @internal
+ */
+import type { LoopContext } from "./loop-context-init.js";
+import type { AgentLoopInputs, AgentLoopOutput } from "./types.js";
+/** The span type the telemetry handle hands back, or nothing when telemetry is off. */
+export type SendSpan = ReturnType<NonNullable<AgentLoopInputs["telemetry"]>["startSpan"]> | undefined;
+/**
+ * Everything `runAgentLoop` does AFTER its last turn: diagnose why the loop ended, stamp the span,
+ * total usage and cost, flush the memory provider, and shape the output.
+ *
+ * Extracted because the biome-ignore on `runAgentLoop` argues that context build, LLM round trip,
+ * tool dispatch, stop condition and span lifecycle stay co-located so the streaming contract reads
+ * linearly — and that argument, which has real force, covers none of this. None of it runs during a
+ * turn, so removing it takes roughly 55 of the function's 123 lines and 12 of its decision points
+ * out of the narrative the ignore defends, without moving a single branch of the round trip.
+ */
+export declare function finalizeLoopOutput(inputs: AgentLoopInputs, ctx: LoopContext, budget: IterationBudget, sendSpan: SendSpan, lastTurnDecision: "continue" | "done" | "error" | undefined): Promise<AgentLoopOutput>;

package/dist/internal/agent-loop/loop-llm-stream.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/agent-loop/loop-thinking-steps.d.ts

@@ -0,0 +1,28 @@
+/**
+ * theokit#122 — where a round's thinking block becomes a conversation step.
+ *
+ * Extracted from `loop.ts` when it crossed the G8 400-LoC cap. These two belong together: both
+ * answer "the round produced a thinking block — where does it land in the persisted conversation",
+ * and the answer differs by which path closes the round.
+ *
+ * @internal
+ */
+import type { LlmThinkingPart } from "../llm/types.js";
+import type { LoopContext } from "./loop-context-init.js";
+/**
+ * theokit#122 — the round's thinking block as a conversation step.
+ *
+ * Shared by the two paths that can close a round: the assistant-text path and the tool_use path.
+ * The tool_use path is the one that matters — a round of thinking + a tool call with NO preamble
+ * text is the common Anthropic shape, and it is exactly the case the first version of this fix
+ * dropped (the block stayed on the context and was persisted against the NEXT round's text).
+ */
+export declare function thinkingStep(thinking: LlmThinkingPart): ConversationStep;
+/**
+ * theokit#122 — persist the block for a round that called a tool and said nothing.
+ *
+ * Such a round emits no assistant-text step, so without this the block is never recorded for it —
+ * which is exactly how the first version of this fix let round N's signature reach round N+1.
+ * No-op when the round had text (the text path already recorded it) or produced no thinking.
+ */
+export declare function recordThinkingOnSilentToolRound(ctx: LoopContext, text: string, thinking: LlmThinkingPart | undefined): void;

package/dist/internal/agent-loop/loop.d.ts

@@ -0,0 +1,7 @@
+import { type LoopContext } from "./loop-context-init.js";
+import { type LlmTurnOutput } from "./loop-llm-stream.js";
+import type { AgentLoopInputs, AgentLoopOutput } from "./types.js";
+/** M1-4 — maximum number of `stop`-hook feedback re-prompts (reflection ceiling), mirroring MAX_NUDGE_ATTEMPTS. */
+export declare const MAX_STOP_FEEDBACK_ATTEMPTS = 2;
+export declare function runAgentLoop(inputs: AgentLoopInputs): Promise<AgentLoopOutput>;
+export declare function continueOrTerminate(inputs: AgentLoopInputs, ctx: LoopContext, llmOutput: LlmTurnOutput): Promise<"continue" | "done" | "error">;

package/dist/internal/agent-loop/message-builders.d.ts

@@ -0,0 +1,21 @@
+import type { SDKAssistantMessage, SDKThinkingMessage, SDKUserMessageEvent } from "../../types/messages.js";
+import type { LlmMessage, LlmThinkingPart, LlmToolCallPart } from "../llm/types.js";
+import type { AgentLoopInputs } from "./types.js";
+export declare function buildUserEvent(inputs: AgentLoopInputs): SDKUserMessageEvent;
+export declare function buildAssistantEvent(inputs: AgentLoopInputs, text: string): SDKAssistantMessage;
+/**
+ * issue #47: the reasoning the model produced this turn, as a `thinking` SDKMessage.
+ * issue #48: when the reasoning duration was measured, carry it as `thinking_duration_ms`
+ * so a `Run.stream()` replay can render how long the model reasoned.
+ */
+export declare function buildThinkingEvent(inputs: AgentLoopInputs, text: string, thinkingDurationMs?: number, signature?: string): SDKThinkingMessage;
+/**
+ * theokit#122 — `thinking` is FIRST, and that ordering is a provider requirement, not a preference.
+ *
+ * Anthropic verifies the signed block on the next request and requires it to lead the assistant
+ * message it belongs to. Omitting it (which this builder did until theokit#122's follow-up) makes
+ * round 2 of any thinking + tools run fail with `400 "thinking blocks cannot be modified"` — the
+ * exact failure the issue exists to remove. An unsigned block is passed through here and dropped at
+ * the wire by `thinkingToWireBlock`, which is where that policy belongs.
+ */
+export declare function buildAssistantTurn(text: string, toolCalls: LlmToolCallPart[], thinking?: LlmThinkingPart): LlmMessage;

package/dist/internal/agent-loop/replay-messages.d.ts

@@ -0,0 +1,41 @@
+import type { SessionMessage } from "../../types/session-message.js";
+import type { LlmMessage } from "../llm/types.js";
+/**
+ * Rebuild the model's history from a session's stored turns.
+ *
+ * ## Why this exists
+ *
+ * The replay used to be one line — `content: [{ type: "text", text: msg.text }]` — and `text` is the
+ * FLAT projection, in which a tool call folds to `[tool call] NAME` and a result to
+ * `[tool result] <body>`. So a resumed session showed the model its own prior turn as prose
+ * containing a marker, and the model did the reasonable thing with a pattern it is shown: it wrote
+ * the marker instead of calling the tool (usetheokit/theokit#631). A consumer saw
+ * `"…report its output.[tool call] run_shell"` in the assistant's reply, with no tool call behind it.
+ *
+ * The structured projection was already there. `narrowToSessionMessage` returns BOTH `text` and
+ * `parts`, and `parts` carries the call id, the tool name and the arguments — everything the flat
+ * form destroys. Nothing read it: `msg.parts` appeared nowhere in the shipped bundle.
+ *
+ * ## The shape it produces
+ *
+ * `SessionMessagePart` and `LlmContentPart` agree field for field on all three cases, which is what
+ * makes this a mapping rather than a translation. What does NOT carry over is the grouping: a
+ * `tool_result` may not travel in an assistant message. The live loop already settles that —
+ * `loop.ts` pushes results as `{ role: "user", content: toolResults }` — so a replayed turn is split
+ * the same way rather than inventing a second convention for the same provider wire.
+ *
+ * ## When it falls back
+ *
+ * `parts` is optional and its absence means "this projection carries no structure", never "this turn
+ * had none" — a `SessionMessage` built in memory during a live turn has only `text`. So a message
+ * without parts replays exactly as before. That is also what keeps this safe for a session stored by
+ * an older SDK: those rows have no `parts`, and they keep the behaviour they were written under.
+ *
+ * ## An empty text part is dropped
+ *
+ * A `{ type: "text", text: "" }` survives the projection — a turn that was only a tool call has one,
+ * because `partToText` folds the call and leaves the text empty. Several provider wires reject an
+ * empty text block outright, and none of them need it, so it does not travel. Dropping it is also
+ * what makes the `own.length > 0` guard below meaningful rather than incidental.
+ */
+export declare function replayMessages(prior: readonly SessionMessage[]): LlmMessage[];