@theokit/sdk 4.63.3 → 5.0.0-next.1

package/dist/{inject-session-DAR7OUCW.js → inject-session-SUM6TDJF.js}

@@ -1,10 +1,10 @@
-import { enqueueSessionWrite } from './chunk-4FFBAUFS.js';
-import { invalidateSessionCache } from './chunk-WTMU7J4U.js';
-import './chunk-N2U4AZGB.js';
-import { SessionTranscript } from './chunk-UMP6OJIM.js';
-import './chunk-2GUYQR5P.js';
-import './chunk-D4CUGAKZ.js';
-import './chunk-XEQ3TM66.js';
+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) {
@@ -23,5 +23,5 @@ async function injectSessionTurn(opts) {
 }
 
 export { injectSessionTurn };
-//# sourceMappingURL=inject-session-DAR7OUCW.js.map
-//# sourceMappingURL=inject-session-DAR7OUCW.js.map
+//# sourceMappingURL=inject-session-SUM6TDJF.js.map
+//# sourceMappingURL=inject-session-SUM6TDJF.js.map

package/dist/{inject-session-DAR7OUCW.js.map → inject-session-SUM6TDJF.js.map}

@@ -1 +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-DAR7OUCW.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"]}
+{"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-WQKMC3GR.cjs.map → inject-session-W6A46J3E.cjs.map}

@@ -1 +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-WQKMC3GR.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"]}
+{"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

@@ -1,18 +1,24 @@
 'use strict';
 
+var chunkJ7J7J2GN_cjs = require('../chunk-J7J7J2GN.cjs');
+require('../chunk-6LHQPOMI.cjs');
+
 // src/interactive/types.ts
-var InteractiveUnavailableError = class extends Error {
+var InteractiveUnavailableError = class extends chunkJ7J7J2GN_cjs.TheokitAgentError {
+  name = "InteractiveUnavailableError";
   code = "interactive_unavailable";
   constructor(message) {
-    super(message);
-    this.name = "InteractiveUnavailableError";
+    super(message, { code: "interactive_unavailable", isRetryable: false });
   }
 };
-var NoSuchSessionError = class extends Error {
+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)`);
-    this.name = "NoSuchSessionError";
+    super(`no such live session "${sessionId}" (it may have exited or been killed)`, {
+      code: "no_such_session",
+      isRetryable: false
+    });
   }
 };
 var InteractiveBackend = class {

package/dist/interactive/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/interactive/types.ts"],"names":[],"mappings":";;;AAkBO,IAAM,2BAAA,GAAN,cAA0C,KAAA,CAAM;AAAA,EAC5C,IAAA,GAAO,yBAAA;AAAA,EAChB,YAAY,OAAA,EAAiB;AAC3B,IAAA,KAAA,CAAM,OAAO,CAAA;AACb,IAAA,IAAA,CAAK,IAAA,GAAO,6BAAA;AAAA,EACd;AACF;AAIO,IAAM,kBAAA,GAAN,cAAiC,KAAA,CAAM;AAAA,EACnC,IAAA,GAAO,iBAAA;AAAA,EAChB,YAAY,SAAA,EAAmB;AAC7B,IAAA,KAAA,CAAM,CAAA,sBAAA,EAAyB,SAAS,CAAA,qCAAA,CAAuC,CAAA;AAC/E,IAAA,IAAA,CAAK,IAAA,GAAO,oBAAA;AAAA,EACd;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\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. */\nexport class InteractiveUnavailableError extends Error {\n  readonly code = \"interactive_unavailable\" as const;\n  constructor(message: string) {\n    super(message);\n    this.name = \"InteractiveUnavailableError\";\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. */\nexport class NoSuchSessionError extends Error {\n  readonly code = \"no_such_session\" as const;\n  constructor(sessionId: string) {\n    super(`no such live session \"${sessionId}\" (it may have exited or been killed)`);\n    this.name = \"NoSuchSessionError\";\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"]}
+{"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.js

@@ -1,16 +1,22 @@
+import { TheokitAgentError } from '../chunk-ALUN2B4W.js';
+import '../chunk-CZJ6Q7CW.js';
+
 // src/interactive/types.ts
-var InteractiveUnavailableError = class extends Error {
+var InteractiveUnavailableError = class extends TheokitAgentError {
+  name = "InteractiveUnavailableError";
   code = "interactive_unavailable";
   constructor(message) {
-    super(message);
-    this.name = "InteractiveUnavailableError";
+    super(message, { code: "interactive_unavailable", isRetryable: false });
   }
 };
-var NoSuchSessionError = class extends Error {
+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)`);
-    this.name = "NoSuchSessionError";
+    super(`no such live session "${sessionId}" (it may have exited or been killed)`, {
+      code: "no_such_session",
+      isRetryable: false
+    });
   }
 };
 var InteractiveBackend = class {

package/dist/interactive/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/interactive/types.ts"],"names":[],"mappings":";AAkBO,IAAM,2BAAA,GAAN,cAA0C,KAAA,CAAM;AAAA,EAC5C,IAAA,GAAO,yBAAA;AAAA,EAChB,YAAY,OAAA,EAAiB;AAC3B,IAAA,KAAA,CAAM,OAAO,CAAA;AACb,IAAA,IAAA,CAAK,IAAA,GAAO,6BAAA;AAAA,EACd;AACF;AAIO,IAAM,kBAAA,GAAN,cAAiC,KAAA,CAAM;AAAA,EACnC,IAAA,GAAO,iBAAA;AAAA,EAChB,YAAY,SAAA,EAAmB;AAC7B,IAAA,KAAA,CAAM,CAAA,sBAAA,EAAyB,SAAS,CAAA,qCAAA,CAAuC,CAAA;AAC/E,IAAA,IAAA,CAAK,IAAA,GAAO,oBAAA;AAAA,EACd;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\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. */\nexport class InteractiveUnavailableError extends Error {\n  readonly code = \"interactive_unavailable\" as const;\n  constructor(message: string) {\n    super(message);\n    this.name = \"InteractiveUnavailableError\";\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. */\nexport class NoSuchSessionError extends Error {\n  readonly code = \"no_such_session\" as const;\n  constructor(sessionId: string) {\n    super(`no such live session \"${sessionId}\" (it may have exited or been killed)`);\n    this.name = \"NoSuchSessionError\";\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"]}
+{"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

@@ -12,16 +12,26 @@
  *
  * @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. */
-export declare class InteractiveUnavailableError extends Error {
+ *  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. */
-export declare class NoSuchSessionError extends Error {
+ *  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);
 }

package/dist/interactive/types.d.ts

@@ -12,16 +12,26 @@
  *
  * @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. */
-export declare class InteractiveUnavailableError extends Error {
+ *  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. */
-export declare class NoSuchSessionError extends Error {
+ *  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);
 }

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

@@ -1,2 +1,2 @@
-import type { AgentLoopInputs } from "./loop-types.js";
+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.d.ts

@@ -1,6 +1,6 @@
 import { type LoopContext } from "./loop-context-init.js";
 import { type LlmTurnOutput } from "./loop-llm-stream.js";
-import type { AgentLoopInputs, AgentLoopOutput } from "./loop-types.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>;

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

@@ -1,6 +1,6 @@
 import type { SDKAssistantMessage, SDKThinkingMessage, SDKUserMessageEvent } from "../../types/messages.js";
 import type { LlmMessage, LlmThinkingPart, LlmToolCallPart } from "../llm/types.js";
-import type { AgentLoopInputs } from "./loop-types.js";
+import type { AgentLoopInputs } from "./types.js";
 export declare function buildUserEvent(inputs: AgentLoopInputs): SDKUserMessageEvent;
 export declare function buildAssistantEvent(inputs: AgentLoopInputs, text: string): SDKAssistantMessage;
 /**

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[];

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

@@ -1,7 +1,7 @@
 import type { SDKMessage } from "../../types/messages.js";
 import type { LlmContentPart, LlmToolCallPart } from "../llm/types.js";
-import type { AgentLoopInputs, ResolvedTool } from "./loop-types.js";
-export type { ResolvedTool } from "./loop-types.js";
+import type { AgentLoopInputs, ResolvedTool } from "./types.js";
+export type { ResolvedTool } from "./types.js";
 /**
  * T2.4 — Parallel tool dispatch with bounded concurrency (DR2 finding #4).
  *

package/dist/internal/agent-loop/usage-and-cost.d.ts

@@ -13,7 +13,7 @@
  * @internal
  */
 import type { UsageAccumulator } from "../budget/usage-accumulator.js";
-import type { AgentLoopInputs } from "./loop-types.js";
+import type { AgentLoopInputs } from "./types.js";
 export interface LlmTurnUsage {
     inputTokens?: number;
     outputTokens?: number;

package/dist/internal/auth/credential-availability.d.ts

@@ -0,0 +1,61 @@
+/**
+ * "Does this process hold a REAL provider credential?" — one question, one home.
+ *
+ * It used to live in `runtime/fixtures/fixture-mode.ts`, a 229-line module answering three unrelated
+ * questions. This one spans AWS Bedrock (env var, access key, profile, `~/.aws/credentials` on
+ * disk), GCP Vertex (ADC), a stored OAuth credential read off disk, and three named provider env
+ * vars — a credential policy, filed under a name about test fixtures. Its dependency already pointed
+ * here: `internal/auth/credential-store.js`.
+ *
+ * Every predicate is SYNCHRONOUS and checks a signal, never a live endpoint. Probing would be async
+ * and would make a decision that belongs at request time — an unreachable Ollama or an expired token
+ * must surface as a typed error from the call, not as a silent fall-through to fixture data.
+ *
+ * @internal
+ */
+/**
+ * The provider credentials `shouldUseRealLocalRuntime` consults by name.
+ *
+ * Exported so the "Missing API key" refusal can name the ones the caller actually set (#338 item
+ * 5). The list used to live only inside the predicate below, which meant a caller with
+ * `OPENROUTER_API_KEY` set and `THEOKIT_API_KEY` unset was refused by a message naming neither —
+ * the SDK checks this exact variable a few lines down to decide the runtime, so the environment
+ * looks configured to the person who set it up. Reported as a three-hour diagnosis.
+ *
+ * One list, two readers: a variable added here is recognised by the predicate AND named by the
+ * error on the same commit, which is the only way the two stay in step.
+ */
+export declare const PROVIDER_CREDENTIAL_ENV_VARS: readonly string[];
+/** Those of {@link PROVIDER_CREDENTIAL_ENV_VARS} that are non-empty in this process. */
+export declare function presentProviderCredentialEnvVars(): readonly string[];
+/**
+ * ADRs D286-D287: Bedrock green-lights real runtime when EITHER
+ * `AWS_BEARER_TOKEN_BEDROCK` is set explicitly OR the standard AWS
+ * credential chain (`AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` /
+ * `AWS_PROFILE` / instance role) can mint a Bearer via
+ * `@aws/bedrock-token-generator`. We only check synchronous signals here;
+ * the actual token resolution happens lazily in
+ * `BedrockAnthropicClient.stream`.
+ */
+export declare function isAwsBedrockAuthAvailable(): boolean;
+/**
+ * ADR D288: Vertex green-lights real runtime when EITHER
+ * `GOOGLE_APPLICATION_CREDENTIALS` is set OR `GOOGLE_CLOUD_PROJECT` is set
+ * (ADC will use gcloud user creds / metadata server). The actual token
+ * resolution happens lazily in `VertexAnthropicClient.stream` /
+ * `VertexGeminiClient.stream`.
+ */
+export declare function isGcpVertexAuthAvailable(): boolean;
+/**
+ * ADR D182 / T1.2: **always `true`.** Zero-config local providers (`authType: "none"`) need no
+ * credential — Ollama defaults to localhost:11434, LM Studio to localhost:1234, llama.cpp to
+ * localhost:8080 — and the SDK ships Ollama as a builtin, so one is always nominally available.
+ * Nothing is probed here; probing would be async. If no daemon is up, the first real LLM call
+ * surfaces `ollama_unreachable` via the typed mapper.
+ *
+ * This used to say it returned true "when ANY of the documented local hosts is reachable in spirit",
+ * which reads as a probe and is not a testable statement. The body has always been `return true`.
+ * The distinction matters because of where this sits — see the note on the `||` chain in
+ * `shouldUseRealLocalRuntime`.
+ */
+export declare function isLocalNoAuthProviderAvailable(): boolean;

package/dist/internal/auth/credential-store.d.ts

@@ -19,7 +19,7 @@ import { AuthenticationError } from "../../errors.js";
  * `.d.ts`, leaving the types it binds unresolvable for any consumer running type-aware lint
  * (usetheodev/theokit-sdk#283 records the same trap on a declaration).
  */
-import type { CredentialStoreConfig, StoredCredential, StoredOAuthCredential } from "./auth-types.js";
+import type { CredentialStoreConfig, StoredCredential, StoredOAuthCredential } from "./types.js";
 /** The store directory, honoring an optional `homeEnvVar` override. */
 export declare function credentialHome(config: CredentialStoreConfig, env?: Record<string, string | undefined>): string;
 /** The credential file path inside the (possibly overridden) store directory. */

package/dist/internal/auth/oauth-device.d.ts

@@ -1,4 +1,4 @@
-import type { DeviceCodeGrant, DeviceDeps, DeviceOAuthConfig, OAuthTokens, OpenAIDeviceConfig } from "./auth-types.js";
+import type { DeviceCodeGrant, DeviceDeps, DeviceOAuthConfig, OAuthTokens, OpenAIDeviceConfig } from "./types.js";
 /** Step 1 — request a device code. POSTs `{client_id, scope}` to the device endpoint. */
 export declare function requestDeviceCode(config: DeviceOAuthConfig, deps: Pick<DeviceDeps, "fetch">): Promise<DeviceCodeGrant>;
 /**

package/dist/internal/auth/oauth-engine.d.ts

@@ -1,4 +1,4 @@
-import type { CredentialStoreConfig, HttpDeps, OAuthProviderConfig, OAuthTokens, ResolvedCredential } from "./auth-types.js";
+import type { CredentialStoreConfig, HttpDeps, OAuthProviderConfig, OAuthTokens, ResolvedCredential } from "./types.js";
 /** Exchange an authorization `code` (+ PKCE verifier) for the token pair. */
 export declare function exchangeCode(config: OAuthProviderConfig, input: {
     code: string;

package/dist/internal/auth/resolve-credential.d.ts

@@ -17,7 +17,7 @@
  * `.d.ts`, leaving the types it binds unresolvable for any consumer running type-aware lint
  * (usetheodev/theokit-sdk#283 records the same trap on a declaration).
  */
-import type { CredentialStoreConfig, OAuthProviderConfig, ResolvedCredential } from "./auth-types.js";
+import type { CredentialStoreConfig, OAuthProviderConfig, ResolvedCredential } from "./types.js";
 /**
  * Input to `resolveCredential`: which provider, which store, and what to inject.
  *

package/dist/internal/base-url.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `THEOKIT_API_BASE_URL`, read in one place.
+ *
+ * A leaf on purpose: `internal/http.ts` resolves the SDK's endpoint from it, and so do the cloud
+ * agent and `internal/agent/helpers.ts`. It used to live in `runtime/fixtures/fixture-mode.ts`,
+ * which meant a production HTTP module resolved its base URL out of a module named for test
+ * fixtures. `fixture-mode.ts` is now one of its four consumers rather than its owner — it needs the
+ * value because an explicitly configured base URL short-circuits fixture mode.
+ *
+ * Nothing is imported here beyond the environment, so no consumer risks a cycle through it.
+ *
+ * @internal
+ */
+export {};

package/dist/internal/cloud-agent/cloud-config-serializer.d.ts

@@ -1,3 +1,3 @@
 import type { AgentOptions } from "../../types/agent.js";
-import type { CloudAgentPayload } from "./cloud-payload-types.js";
+import type { CloudAgentPayload } from "./types.js";
 export declare function serializeCloudAgentConfig(options: AgentOptions): CloudAgentPayload;

package/dist/internal/{runtime/concurrency → concurrency}/subagent-credentials.d.ts

@@ -32,8 +32,8 @@
  *
  * @internal
  */
-import type { ModelSelection } from "../../../types/agent-prims.js";
-import type { Plugin } from "../../plugins/types.js";
+import type { ModelSelection } from "../../types/agent-prims.js";
+import type { Plugin } from "../plugins/types.js";
 /**
  * Credentials a parent agent hands down to its subagent tools so the child inherits the parent's
  * auth (and, absent an explicit `spec.model`, its model).

package/dist/internal/emit-run-event.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The fail-safe emitter for the `RunEvent` stream — runtime, deliberately NOT in `types/`.
+ *
+ * Eleven modules across `agent-loop/`, `runtime/`, `task/` and `local-agent/` call it; the type it
+ * carries stays in `types/run-events.ts`, which is what `types/` is for. Sibling of
+ * `internal/diagnostics.ts`, which swallows sink failures on the same principle and for the same
+ * reason: observability degrades what you can SEE, never what the agent DOES.
+ *
+ * @internal
+ */
+/**
+ * SE2 — emit a {@link RunEvent} to an optional sink, swallowing any sink error so
+ * observability can never break the run (fail-safe, mirrors the EventBus EC-2
+ * contract). No-op when the sink is absent.
+ */
+export declare function emitRunEvent(sink: RunEventSink | undefined, event: RunEvent): void;

package/dist/internal/error-mappers/shared.d.ts

@@ -1,4 +1,5 @@
 /**
+import type { ErrorCode } from "../../errors.js";
  * Helpers shared between provider HTTP error mappers (ADR D67).
  *
  * Extracted to dedupe identical logic in `anthropic.ts` and
@@ -7,4 +8,16 @@
  *
  * @internal
  */
-export {};
+export declare function httpStatusToErrorCode(status: number): HttpStatusErrorCode;
+/**
+ * Reads an error body that may arrive already parsed, as a JSON string, or as neither.
+ *
+ * This is TRANSPORT knowledge, not vendor knowledge: it describes how `fetch` surfaces a body, which
+ * is the same whichever provider sent it. It lived twice, character-for-character, in bedrock.ts and
+ * vertex.ts — identical once the return type name was substituted. They had not drifted, so the cost
+ * was only latent: a fix to one would have missed the other silently.
+ *
+ * Unparseable input yields `{}` rather than throwing, because a mapper's job is to classify a
+ * failure that already happened; failing to read the body is not a second failure to report.
+ */
+export declare function parseErrorBody<T>(body: unknown): T;

package/dist/internal/eval/assert.d.ts

@@ -9,9 +9,10 @@
  *
  * @public
  */
+import { TheokitAgentError } from "../../errors.js";
 import type { EvalRun, EvalThresholdFailure, EvalThresholds } from "../../types/eval.js";
 /** Thrown by {@link assertEval} when a run misses one or more thresholds. */
-export declare class EvalThresholdError extends Error {
+export declare class EvalThresholdError extends TheokitAgentError {
     readonly name = "EvalThresholdError";
     /** The eval's name (`EvalRun.name`). */
     readonly evalName: string;

package/dist/internal/eval/single-flight.d.ts

@@ -1,3 +1,4 @@
+import { TheokitAgentError } from "../../errors-base.js";
 /**
  * D213 — single-flight guard for `Eval.run`. Module-level `Set<string>`
  * tracks running names; `acquire` throws on collision; `release` is
@@ -5,7 +6,7 @@
  *
  * @internal
  */
-export declare class EvalAlreadyRunningError extends Error {
+export declare class EvalAlreadyRunningError extends TheokitAgentError {
     readonly name = "EvalAlreadyRunningError";
     readonly evalName: string;
     constructor(evalName: string);

package/dist/internal/global-singleton.d.ts

@@ -6,8 +6,11 @@
  * `const x = new Map()` produces TWO caches that cannot see each other. `Symbol.for` uses the global
  * symbol registry, which belongs to the realm and not the module, so every copy converges on one instance.
  *
- * It was copied verbatim into `providers/discovery.ts` and `providers/catalog-loader.ts`. That is
- * duplicated KNOWLEDGE, not a coincidence of shape: the two copies have to agree on the
- * mechanism, and one fixed without the other produces exactly the bug the function exists to avoid.
+ * It WAS copied verbatim into `providers/discovery.ts` and `providers/catalog-loader.ts`; both now
+ * import it, as does `providers/registry.ts`. That was duplicated KNOWLEDGE rather than a
+ * coincidence of shape — the copies had to agree on the mechanism, and one fixed without the other
+ * reproduced exactly the bug this function exists to avoid. The paragraph is kept in the past tense
+ * because it is the REASON the helper exists, not a defect report: the previous wording described
+ * the duplication as live, long after it was removed.
  */
 export declare function globalSingleton<T>(key: string, create: () => T): T;