@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/server/conversation/providers/opencodeDriver.js

@@ -1,81 +1,57 @@
 import { randomUUID } from "node:crypto";
-import { jsonHash as hash } from "../normalize.js";
-import { mkdir, realpath, rm } from "node:fs/promises";
+import { mkdir, realpath } from "node:fs/promises";
 import path from "node:path";
-import { isDeepStrictEqual } from "node:util";
 import { createLocalConversationExecution } from "../localExecution.js";
-import { createOpenCodeConversationServer, openCodeConversationAgent } from "../openCodeProcess.js";
-import { createOpenCodeSharedRuntime, ensureOpenCodeSession, openCodeServerForDirectory } from "../openCodeRuntime.js";
-import { openCodeAssistantMessageText, retireOpenCodeConversationHistory } from "../openCodeClient.js";
-import { inspectOpenCodeMessageAdmission, observeOpenCodeEvents, openCodeRowsForInput,
-  openCodeDetachedPrompt, openCodeStructuredOutput, readOpenCodeMessagesUntil } from "../openCodeTurn.js";
+import { ignoreReceipt } from "../nativeCommandCallbacks.js";
+import { openCodeServerForDirectory } from "../openCodeNativeSession.js";
+import { retireOpenCodeConversationHistory } from "../openCodeNativeHistory.js";
+import { recoverWithoutProjection } from "../openCodeTurn.js";
 import { createOpenCodeToolBridge } from "../openCodeTools.js";
-import { validateConversationConfiguration, validateConnectionModel } from "../configuration.js";
+import { validateConversationConfiguration } from "../configuration.js";
 import { createScopedConversationHandle } from "./scoped.js";
+import { executeOpenCodeApplicationTool, openStandaloneOpenCodeConversation } from "./opencodeStandalone.js";
 
-const nativeMessageId = id => `msg_jskit_${hash(id).slice(0, 40)}`;
+/** A runtime given no host runs OpenCode in the process's working directory, with local execution and the `opencode` command. */
+const LOCAL_HOST = Object.freeze({});
 
-// Original standalone native-use validation and authored admission, shared by
-// explicitly supplied bound tools without transferring native process ownership.
-async function executeOpenCodeApplicationTool({ active, turn, target, sessionId, assertCurrent }, input, signal) {
-  if (!active?.tools || input.sessionId !== sessionId ||
-      [input.id, input.name, input.messageId].some(value => typeof value !== "string" || !value || value.length > 256)) {
-    throw new Error("This OpenCode tool call does not belong to the active conversation.");
-  }
-  if (!turn?.abortController) {
-    throw new Error("This OpenCode tool call does not belong to an admitted conversation.");
-  }
-  assertCurrent?.();
-  const observed = AbortSignal.any([signal, turn.abortController.signal]);
-  await turn.admission?.promise;
-  observed.throwIfAborted();
-  // Read back to an admitted input that precedes the native tool use.
-  const messages = await readOpenCodeMessagesUntil(target.server.client, sessionId, rows => {
-    const index = rows.findIndex(row => row.id === input.messageId);
-    return index >= 0 && rows.slice(0, index).some(row => active.messageIds.has(row.id));
-  }, { signal: observed });
-  let message;
-  let owner;
-  for (const [nativeId, authored] of active.messageIds) {
-    message = openCodeRowsForInput(messages, nativeId).find(message => message.id === input.messageId && message.type === "assistant");
-    if (message) { owner = authored; break; }
-  }
-  const tool = message?.content.find(part => part.type === "tool" && part.callID === input.id);
-  if (!tool || tool.tool !== input.name || !isDeepStrictEqual(tool.state?.input, input.input)) {
-    throw new Error("OpenCode's application call does not match an admitted native tool use.");
-  }
-  if (!owner.committed) throw new Error("This OpenCode tool call has no durable authored admission.");
-  await owner.committed;
-  observed.throwIfAborted();
-  assertCurrent?.(true, owner);
-  try {
-    return await active.tools.execute({ id: input.id, name: input.name, arguments: JSON.stringify(input.input) }, { signal: observed, messageId: owner.messageId });
-  } catch (error) {
-    if (!assertCurrent || assertCurrent(false, owner)) turn.abortController.abort(error);
-    throw error;
-  }
-}
-
-/** Uses the application's authorized API connection; native state stays server-side. */
-export function createOpenCodeConversationDriver({ connections, host = {}, limits = {} } = {}) {
+/**
+ * Uses the application's authorized API connection; native state stays server-side.
+ * @param {{
+ *   connections?: { resolve(request: { context: object, integrationId: string }): Promise<object> },
+ *   host?: {
+ *     env?: import("@jskit-ai/kernel/server/types").RuntimeEnv,
+ *     workdir?: string,
+ *     stateDirectory?: string,
+ *     execution?: import("../localExecution.js").ConversationExecution,
+ *     nativeTools?: boolean,
+ *     conversation?: Function,
+ *     opencode?: Function,
+ *     commands?: { opencode?: string },
+ *     limits?: object,
+ *     commandWrapper?: object
+ *   },
+ *   limits?: Record<string, number>
+ * }} options
+ */
+export function createOpenCodeConversationDriver({
+  connections,
+  host = LOCAL_HOST,
+  limits = {}
+}) {
+  // readable-check: allow method-probe - input validation: a host that does not open its own conversations requires the application's AI connection resolver
   if (!host.conversation && typeof connections?.resolve !== "function") throw new TypeError("OpenCode conversations require an authorized AI connection resolver.");
   const workdir = path.resolve(host.workdir || process.cwd());
   const stateDirectory = path.resolve(host.stateDirectory || path.join(workdir, ".assistant", "native", "opencode"));
   const execution = host.execution || createLocalConversationExecution();
   const nativeTools = host.nativeTools === true;
+  if (nativeTools && !host.env) {
+    throw new TypeError("An OpenCode conversation's host requires the application's environment, such as process.env, for native tools.");
+  }
   const maximumOutput = limits.maxOutputCharacters ?? 64_000;
   if (!Number.isSafeInteger(maximumOutput) || maximumOutput < 1) throw new TypeError("Invalid OpenCode output limit.");
   if (limits.maxOutputTokens !== undefined && (!Number.isSafeInteger(limits.maxOutputTokens) || limits.maxOutputTokens < 1)) {
     throw new TypeError("Invalid OpenCode token limit.");
   }
-  function prompt(input, configuration) {
-    const text = `${input.text || ""}${input.attachmentManifest || ""}`;
-    if (!configuration.outputSchema) return { text, content: input.content };
-    const prepared = openCodeDetachedPrompt({ prompt: text, outputSchema: configuration.outputSchema });
-    if (prepared.length > (limits.maxInputCharacters ?? 32_000)) throw new Error("OpenCode structured input exceeded the configured limit.");
-    return { text: prepared, content: input.content };
-  }
-
   function withNativeStorageTarget({ native, context }, operation) {
     const prepared = native.preparation.storage(context);
     return native.owner.withStorageProcess(async () =>
@@ -87,635 +63,321 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
     return native.owner.closeSession(prepared.sessionId, prepared.options, prepared.application);
   }
 
-  return Object.freeze({
-    toolDiscovery: true,
-    attachmentTypes: ["text", "image", "localFile"],
-    capabilities: Object.freeze({ streaming: true, cancellation: true, history: true,
-      instructions: true, configuration: true, steering: true, goals: false, attachments: true, tools: true, nativeTools, structuredOutput: true }),
-    validateConfiguration(configuration) {
-      validateConversationConfiguration(configuration, { engine: "OpenCode", connections, connectionRequired: true,
-        structuredOutput: true, maxOutputCharacters: maximumOutput });
-    },
-    async readState({ conversation, context, representation }) {
-      const { owner, preparation } = conversation.native;
-      const nativeResult = await owner.readSessionState(context, preparation.state);
-      return conversation.read(context, representation, nativeResult);
-    },
-    inspectTemporaryActivity({ native }) {
-      return native.owner.hasActiveTemporaryConversation(native.sessionId);
-    },
-    releaseRenewalPredecessorProcessExitProof({ native }) {
-      return native.owner.releaseRenewalPredecessorProcessExitProof(native.preparation);
-    },
-    releaseRenewalSuccessorProcessExitProof({ native }) {
-      return native.owner.releaseProcessExitProof(native.preparation.sessionId);
-    },
-    async generateRenewalHandover({ native, input, context }) {
-      return native.owner.runPreparedRenewalTurn(await native.preparation.handover(input, context));
-    },
-    async seedRenewalHandover({ native, input, context }) {
-      return native.owner.runPreparedRenewalTurn(await native.preparation.seed(input, context));
-    },
-    async ensureConversation({ native, context }) {
-      return native.owner.ensurePreparedSessionReadiness(await native.preparation.readiness(context));
-    },
-    disposeNative,
-    async interruptDetachedConversation({ native, input, context }) {
-      return native.owner.stopPreparedConversation(await native.preparation.existing(input, context), input);
-    },
-    async deleteDetachedConversation({ native, input, context }) {
-      const prepared = await native.preparation.existing(input, context, { operation: "delete" });
-      return native.owner.deletePreparedConversation(prepared, input);
-    },
-    listConversationStorage(prepared) {
-      const { binding, context } = prepared;
-      return withNativeStorageTarget(prepared, async target =>
-        (await target.server.client.listConversationsForDirectory(binding.workdir, { signal: context.signal }))
-          .map((row) => ({ ...binding, conversationId: row.id })));
-    },
-    retireConversationHistory(prepared) {
-      return withNativeStorageTarget(prepared, target => {
-        // Native status is scoped to the saved project instance, not the control server.
-        const client = openCodeServerForDirectory(target.server, prepared.binding.workdir).client;
-        return retireOpenCodeConversationHistory(target.server.client, client, prepared.binding, prepared.context);
+  function validateConfiguration(configuration) {
+    validateConversationConfiguration(configuration, { engine: "OpenCode", connections, connectionRequired: true,
+      structuredOutput: true, maxOutputCharacters: maximumOutput });
+  }
+
+  async function readState({ conversation, context, representation }) {
+    const { owner, preparation } = conversation.native;
+    const nativeResult = await owner.readSessionState(context, preparation.state);
+    return conversation.read(context, representation, nativeResult);
+  }
+
+  function inspectTemporaryActivity({ native }) {
+    return native.owner.hasActiveTemporaryConversation(native.sessionId);
+  }
+
+  function releaseRenewalPredecessorProcessExitProof({ native }) {
+    return native.owner.releaseRenewalPredecessorProcessExitProof(native.preparation);
+  }
+
+  function releaseRenewalSuccessorProcessExitProof({ native }) {
+    return native.owner.releaseProcessExitProof(native.preparation.sessionId);
+  }
+
+  async function generateRenewalHandover({ native, input, context }) {
+    return native.owner.runPreparedRenewalTurn(await native.preparation.handover(input, context));
+  }
+
+  async function seedRenewalHandover({ native, input, context }) {
+    return native.owner.runPreparedRenewalTurn(await native.preparation.seed(input, context));
+  }
+
+  async function ensureConversation({ native, context }) {
+    return native.owner.ensurePreparedSessionReadiness(await native.preparation.readiness(context));
+  }
+
+  async function interruptDetachedConversation({ native, input, context }) {
+    return native.owner.stopPreparedConversation(await native.preparation.existing(input, context), input);
+  }
+
+  async function deleteDetachedConversation({ native, input, context }) {
+    const prepared = await native.preparation.existing(input, context, { operation: "delete" });
+    return native.owner.deletePreparedConversation(prepared, input);
+  }
+
+  function listConversationStorage(prepared) {
+    const { binding, context } = prepared;
+    return withNativeStorageTarget(prepared, async target =>
+      (await target.server.client.listConversationsForDirectory(binding.workdir, { signal: context.signal }))
+        .map((row) => ({ ...binding, conversationId: row.id })));
+  }
+
+  function retireConversationHistory(prepared) {
+    return withNativeStorageTarget(prepared, target => {
+      // Native status is scoped to the saved project instance, not the control server.
+      const client = openCodeServerForDirectory(target.server, prepared.binding.workdir).client;
+      return retireOpenCodeConversationHistory(target.server.client, client, prepared.binding, prepared.context);
+    });
+  }
+
+  function closeProject({ native, input }) {
+    return native.owner.closeProject(input, native.preparation.projectCleanup());
+  }
+
+  function invalidateRuntimes({ native, input }) {
+    return native.owner.invalidateRuntimes(input, native.preparation);
+  }
+
+  function reconcileSessions({ native, sessions, options }) {
+    return native.owner.reconcileSessions(sessions, options, native.preparation);
+  }
+
+  async function createConversation({ native, input, context }) {
+    return native.owner.createPreparedConversation(await native.preparation.creation(input, context));
+  }
+
+  async function runDetachedConversation({ native, input, options }) {
+    return native.owner.runPreparedConversationTurn(await native.preparation.turn(input, options));
+  }
+
+  async function createBinding() {
+    const directory = path.join(stateDirectory, randomUUID());
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    return { sessionId: "", workdir: await realpath(workdir), directory, executionId: "", processDirectory: "" };
+  }
+
+  async function open({ binding, writeBinding, onFailure: reportFailure, conversation }) {
+    if (conversation?.native?.scoped) {
+      const supplied = conversation.native;
+      const { owner, preparation } = supplied;
+      const { conversationId, context: openingContext } = supplied.scoped;
+      return createScopedConversationHandle({ conversationId,
+        sendNative: async (input, context) => owner.runPreparedConversationTurn(await preparation.turn(input, context)),
+        readNative: async (input, context) => owner.readPreparedConversation(await preparation.existing(input, context), input),
+        waitNative: async (input, context) => owner.waitPreparedConversationTurn(await preparation.existing(input, context), input),
+        cancel: async (input, context) => owner.stopPreparedConversation(await preparation.existing(input, context), input),
+        deleteConversation: async (input, context) => owner.deletePreparedConversation(
+          await preparation.existing(input, context, { operation: "delete" }), input),
+        disposeOpening: () => disposeNative({ native: supplied, options: openingContext })
       });
-    },
-    closeProject({ native, input }) {
-      return native.owner.closeProject(input, native.preparation.projectCleanup());
-    },
-    invalidateRuntimes({ native, input }) {
-      return native.owner.invalidateRuntimes(input, native.preparation);
-    },
-    reconcileSessions({ native, sessions, options }) {
-      return native.owner.reconcileSessions(sessions, options, native.preparation);
-    },
-    async createConversation({ native, input, context }) {
-      return native.owner.createPreparedConversation(await native.preparation.creation(input, context));
-    },
-    async runDetachedConversation({ native, input, options }) {
-      return native.owner.runPreparedConversationTurn(await native.preparation.turn(input, options));
-    },
-    async createBinding() {
-      const directory = path.join(stateDirectory, randomUUID());
-      await mkdir(directory, { recursive: true, mode: 0o700 });
-      return { sessionId: "", workdir: await realpath(workdir), directory, executionId: "", processDirectory: "" };
-    },
-    async open({ binding, writeBinding, onFailure: reportFailure, conversation }) {
-      if (conversation?.native?.scoped) {
-        const supplied = conversation.native;
-        const { owner, preparation } = supplied;
-        const { conversationId, context: openingContext } = supplied.scoped;
-        return createScopedConversationHandle({ conversationId,
-          sendNative: async (input, context) => owner.runPreparedConversationTurn(await preparation.turn(input, context)),
-          readNative: async (input, context) => owner.readPreparedConversation(await preparation.existing(input, context), input),
-          waitNative: async (input, context) => owner.waitPreparedConversationTurn(await preparation.existing(input, context), input),
-          cancel: async (input, context) => owner.stopPreparedConversation(await preparation.existing(input, context), input),
-          deleteConversation: async (input, context) => owner.deletePreparedConversation(
-            await preparation.existing(input, context, { operation: "delete" }), input),
-          disposeOpening: () => disposeNative({ native: supplied, options: openingContext })
-        });
-      }
-      if (conversation?.native) {
-        const supplied = conversation.native;
-        let current;
-        let disposed = false;
-        let cleanupFailure;
-        let toolBridge;
-        async function interrupt(context) {
-          try {
-            const acquired = await supplied.acquire(context || current?.context);
-            const value = await supplied.owner.interruptPreparedTurn(await supplied.preparation.interruption(acquired.options));
-            if (toolBridge) { await toolBridge.close(); toolBridge = null; }
-            if (cleanupFailure) {
-              await reportFailure(cleanupFailure, { recovered: true });
-              cleanupFailure = null;
-            }
-            return value;
-          } catch (error) {
-            error.cleanupFailed = true;
-            cleanupFailure = error;
-            current?.failure.reject(error);
-            await reportFailure(error);
-            throw error;
-          }
-        }
-        async function send(command) {
-          const { input, context, signal, beforeDispatch, accept } = command;
-          signal.throwIfAborted();
-          const acquired = await supplied.acquire(context);
-          const active = current;
-          if (active?.tools) signal.throwIfAborted();
-          if (active?.tools && !toolBridge) {
-            toolBridge = await createOpenCodeToolBridge({ schemas: active.tools.schemas,
-              maxArgumentBytes: active.tools.maximumArgumentBytes, execute(input, signal) {
-                const turn = supplied.owner.turns.get(acquired.key);
-                const target = supplied.owner.processes.get(acquired.key);
-                const execute = () => executeOpenCodeApplicationTool({ active: current, turn, target,
-                  sessionId: target?.upstreamSessionId,
-                  assertCurrent(throwFailure = true, authored) {
-                    const owned = !disposed && current === active && active.turn === turn && turn?.active &&
-                      (!authored || active.messageIds.get(turn.inputMessageId) === authored) &&
-                      supplied.owner.turns.get(acquired.key) === turn && supplied.owner.processes.get(acquired.key) === target;
-                    if (!owned && throwFailure) throw new Error("This OpenCode tool call belongs to a retired native turn.");
-                    return owned;
-                  }
-                }, input, signal);
-                return typeof acquired.runInContext === "function" ? acquired.runInContext(execute) : execute();
-              }
-            });
-          }
-          const options = active?.tools ? { ...acquired.options, applicationTools: toolBridge.configuration } : acquired.options;
-          let prepared;
-          const dispatch = active?.tools ? async identity => {
-            await beforeDispatch(identity);
-            signal.throwIfAborted();
-            active.turn = supplied.owner.turns.get(acquired.key);
-            active.messageIds.set(prepared.input.id, { messageId: input.messageId, committed: command.deliveryCommitted });
-          } : beforeDispatch;
-          prepared = await supplied.preparation.message({ ...input.nativeMessage, onPromptSending: dispatch }, options);
-          if (prepared.application?.commit) {
-            const application = prepared.application;
-            prepared.application = { ...application, async commit(admitted) {
-              command.onNativeReceipt?.();
-              const result = await application.commit(admitted);
-              command.onReceiptPersisted?.();
-              return result;
-            } };
-          }
-          if (active?.tools && prepared.application?.monitor) {
-            const monitor = prepared.application.monitor;
-            const create = monitor.create;
-            prepared.application = { ...prepared.application, monitor: { ...monitor,
-              create(...args) {
-                const projection = create(...args);
-                const finalResponse = projection.finalResponse;
-                return { ...projection, finalResponse: { ...finalResponse,
-                  async beforeRecovery(completion) {
-                    active.messageIds.set(finalResponse.recoveryMessageId, active.messageIds.get(completion.inputMessageId));
-                    await finalResponse.beforeRecovery?.(completion);
-                  }
-                } };
-              }
-            } };
-          }
-          const value = await supplied.owner.sendPreparedMessage(prepared, options);
-          const delivered = { value, completion: value.conversationTurn ? supplied.owner.monitors.get(acquired.key) : null };
-          if (value.delivered === true && value.conversationTurn) {
-            if (current) current.delivery = delivered;
-            await accept({ nativeResult: { value }, conversationTurn: value.conversationTurn, nativeTurnId: value.turn?.id });
-          } else if (active?.tools) active.messageIds.delete(prepared.input.id);
-          return delivered;
-        }
-        return Object.freeze({
-          publishNative: event => conversation.publish(event),
-          async inspectAdmission({ context, representation, ...input }) {
-            const acquired = await supplied.acquire(context);
-            const result = await supplied.owner.inspectPreparedMessage(await supplied.preparation.inspection(input, acquired.options));
-            return representation === "native" ? result : { accepted: result.admission === "accepted" };
-          },
-          async run(command) {
-            if (disposed || current) throw new Error("This OpenCode conversation is closed or already working.");
-            const active = { context: command.context, failure: Promise.withResolvers(),
-              ...(command.tools ? { tools: command.tools, messageIds: new Map() } : {}) };
-            let failure;
-            active.failure.promise.catch(error => { failure = error; });
-            current = active;
-            let cancellation;
-            const abort = () => {
-              cancellation ||= interrupt(command.context).then(() => { throw command.signal.reason; });
-              cancellation.catch(active.failure.reject);
-            };
-            command.signal.addEventListener("abort", abort, { once: true });
-            try {
-              let delivered;
-              let dispatchFailure;
-              try { delivered = await send(command); }
-              catch (error) { dispatchFailure = error; }
-              for (;;) {
-                const settling = active.delivery;
-                let result;
-                let problem = dispatchFailure || failure;
-                if (!problem && settling?.completion) {
-                  try { result = await Promise.race([settling.completion, active.failure.promise]); }
-                  catch (error) { problem = error; }
-                }
-                if (command.finishIfCurrent && !await command.finishIfCurrent(() => active.delivery === settling)) {
-                  // The original sender admitted another invocation and returned
-                  // its exact monitor. Keep the same completion and Stop owner.
-                  continue;
-                }
-                problem = dispatchFailure || failure || problem;
-                if (!problem && result?.error) {
-                  problem = Object.assign(new Error(result.error), { status: result.status });
-                  if (result.active && result.status === "observation_lost") {
-                    problem.cleanupFailed = true;
-                    cleanupFailure = problem;
-                    await reportFailure(problem);
-                  }
-                }
-                if (problem) throw problem;
-                return { value: delivered.value };
-              }
-            } finally {
-              command.signal.removeEventListener("abort", abort);
-              await cancellation?.catch(() => {});
-              if (toolBridge) { await toolBridge.close(); toolBridge = null; }
-              if (current === active) current = null;
-            }
-          },
-          async steer(command) { return { value: (await send(command)).value }; },
-          async cancel({ context, representation } = {}) {
-            const value = await interrupt(context);
-            return representation === "native" ? { value } : value;
-          },
-          async dispose(options) {
-            try {
-              const result = await disposeNative({ native: supplied, options });
-              if (result?.ok === false) throw Object.assign(new Error(result.error || "OpenCode cleanup could not be confirmed."), result);
-              if (toolBridge) { await toolBridge.close(); toolBridge = null; }
-              disposed = true;
-              return result;
-            } catch (error) {
-              error.cleanupFailed = true;
-              current?.failure.reject(error);
-              throw error;
-            }
-          }
-        });
-      }
-      if (!binding || typeof binding.sessionId !== "string" || binding.workdir !== await realpath(workdir) ||
-          path.dirname(binding.directory || "") !== stateDirectory) {
-        throw new Error("This OpenCode conversation belongs to another working directory or native state directory. Restore its original host configuration.");
-      }
-      let native;
-      let toolBridge;
-      let facilities;
-      let processVariants = {};
+    }
+    if (conversation?.native) {
+      const supplied = conversation.native;
       let current;
-      let stopping;
       let disposed = false;
-      async function updateBinding(patch) {
-        const next = { ...binding, ...patch };
-        await writeBinding(next);
-        binding = next;
-      }
-      async function stopRecordedExecution() {
-        const proof = await execution.stop(binding.executionId);
-        if (!proof?.scopeEmpty) throw new Error("OpenCode process cleanup could not be confirmed. Restore its execution host before continuing.");
-        if (binding.processDirectory) {
-          if (path.dirname(binding.processDirectory) !== (binding.runtimeDirectory || stateDirectory) || !path.basename(binding.processDirectory).startsWith("process-")) {
-            throw new Error("OpenCode's private process directory does not belong to this host.");
-          }
-          await rm(binding.processDirectory, { recursive: true, force: true });
-        }
-        await updateBinding({ executionId: "", processDirectory: "" });
-      }
-      async function stop() {
-        if (stopping) return stopping;
-        stopping = (async () => {
-          await toolBridge?.close();
-          toolBridge = null;
-          if (facilities?.runtime.cleanupPending) {
-            await facilities.runtime.stop("opencode-startup-cleanup");
-            await updateBinding({ executionId: "", processDirectory: "" });
-          }
-          if (native) {
-            await facilities.runtime.releaseTarget(native, {
-              onRemoved: () => facilities.runtime.writeBindings(facilities.registryPath, binding.directory, [])
-            });
-            facilities.runtime.turns.delete(binding.directory);
-            await updateBinding({ executionId: "", processDirectory: "" });
-            native = null;
-          } else if (binding.executionId && facilities && !host.opencode &&
-              !facilities.runtime.current && !facilities.runtime.processStarts.size) {
-            // Only our unfinished standalone startup belongs to this handle.
-            // A saved shared-server reference is not authority to stop a peer's
-            // service before this conversation has acquired its owner.
-            await stopRecordedExecution();
+      let cleanupFailure;
+      let toolBridge;
+      async function interrupt(context) {
+        try {
+          const acquired = await supplied.acquire(context || current?.context);
+          const value = await supplied.owner.interruptPreparedTurn(await supplied.preparation.interruption(acquired.options));
+          if (toolBridge) { await toolBridge.close(); toolBridge = null; }
+          if (cleanupFailure) {
+            await reportFailure(cleanupFailure, { recovered: true });
+            cleanupFailure = null;
           }
-          if (current?.finished) current = null;
-        })().catch(error => {
+          return value;
+        } catch (error) {
           error.cleanupFailed = true;
-          if (error.code === "assistant_opencode_stop_unverified") {
-            error.message = "OpenCode process cleanup could not be confirmed. Restore its execution host before continuing.";
-          }
+          cleanupFailure = error;
+          current?.failure.reject(error);
+          await reportFailure(error);
           throw error;
-        }).finally(() => { stopping = null; });
-        return stopping;
-      }
-      async function resolvePreparation(configuration, context, signal, requireBound = false, receiptBinding, authoredPreparation = false) {
-        const connection = await connections.resolve({ context, integrationId: configuration.integrationId });
-        signal.throwIfAborted();
-        validateConnectionModel(configuration, connection);
-        const identity = hash([connection.providerId, connection.baseURL || "", connection.apiKey]);
-        if (requireBound && !receiptBinding?.accountIdentity) throw new Error("The completed OpenCode response has no saved account fingerprint.");
-        if (requireBound && (binding.accountIdentity !== receiptBinding.accountIdentity || identity !== receiptBinding.accountIdentity)) {
-          throw new Error("The completed OpenCode response belongs to a different account binding.");
         }
-        // The existing managed host reauthorizes its own connection on every preparation.
-        // A key change can rotate an authored run only inside the same native storage/runtime scope.
-        const preparedFacilities = host.opencode ? await host.opencode({ connection, context }) : facilities;
+      }
+      async function send(command) {
+        const {
+          input,
+          context,
+          signal,
+          beforeDispatch,
+          accept,
+          onNativeReceipt = ignoreReceipt,
+          onReceiptPersisted = ignoreReceipt
+        } = command;
         signal.throwIfAborted();
-        if (host.opencode && (
-          binding.databasePath && binding.databasePath !== preparedFacilities.databasePath ||
-          binding.runtimeDirectory && binding.runtimeDirectory !== preparedFacilities.runtimeDirectory ||
-          facilities && facilities.runtime !== preparedFacilities.runtime
-        )) {
-          throw new Error("This OpenCode conversation belongs to another native history store or runtime. Restore its original host configuration.");
-        }
-        const allowCredentialRefresh = authoredPreparation && host.opencode && preparedFacilities.allowCredentialRefresh === true;
-        if (binding.accountIdentity && identity !== binding.accountIdentity && !allowCredentialRefresh) {
-          throw new Error("This conversation belongs to another OpenCode account. Restore that connection or start a new conversation.");
-        }
-        if (binding.accountIdentity !== identity) await updateBinding({ accountIdentity: identity });
-        const model = { providerID: connection.providerId, id: connection.model };
-        const agent = openCodeConversationAgent({ nativeTools, tools: Boolean(current?.tools) });
-        if (current) current.agent = agent;
-        if (binding.sessionId && !binding.databasePath) {
-          throw new Error("This OpenCode conversation uses the earlier private native history layout. Run the offline native-history upgrade before continuing; no history was changed.");
-        }
-        if (!facilities || host.opencode) {
-          if (host.opencode) facilities = preparedFacilities;
-          else {
-            const runtimeDirectory = path.join(stateDirectory, "shared", hash([identity, host.commands?.opencode || "opencode"]));
-            const selected = { modelProviderId: connection.providerId, canonicalUrl: connection.baseURL || "",
-              endpointCode: connection.sdkPackage || "", fingerprint: identity };
-            facilities = { runtime: createOpenCodeSharedRuntime({ scope: runtimeDirectory }), runtimeDirectory,
-              registryPath: path.join(runtimeDirectory, "session-environments.json"),
-              databasePath: path.join(runtimeDirectory, "opencode.db"), selected,
-              async start({ signal, connection }) {
-                if (binding.executionId && !facilities.runtime.processes.has(binding.directory)) await stopRecordedExecution();
-                const starting = new AbortController();
-                const abortUnusedStartup = () => {
-                  if (facilities.runtime.processStarts.size === 1 && facilities.runtime.processes.size === 0) starting.abort(signal.reason);
-                };
-                signal.addEventListener("abort", abortUnusedStartup, { once: true });
-                if (signal.aborted) abortUnusedStartup();
-                try {
-                  const server = await createOpenCodeConversationServer({ command: host.commands?.opencode || "opencode",
-                    execution, env: host.env || process.env, workdir: binding.workdir, stateDirectory: runtimeDirectory,
-                    databasePath: facilities.databasePath, sessionEnvironmentRegistry: facilities.registryPath, connection,
-                    maxOutputTokens: limits.maxOutputTokens, executionLimits: host.limits, signal: starting.signal,
-                    onStarted: (executionId, processDirectory) => updateBinding({ executionId, processDirectory }),
-                    async onFailure(error) {
-                      for (const target of facilities.runtime.processes.values()) target.abortController.abort(error);
-                      try { await facilities.runtime.stop("opencode-process-exited"); }
-                      catch (cleanupError) { await reportFailure(cleanupError); }
-                    }
-                  });
-                  return { server, connections: [selected] };
-                } finally { signal.removeEventListener("abort", abortUnusedStartup); }
-              }
-            };
-          }
-          if (binding.databasePath && binding.databasePath !== facilities.databasePath) {
-            throw new Error("This OpenCode conversation belongs to another native history store. Restore its original host configuration.");
-          }
-          await updateBinding({ databasePath: facilities.databasePath, runtimeDirectory: facilities.runtimeDirectory });
-        }
-        if (!toolBridge && current?.tools) {
-          toolBridge = await createOpenCodeToolBridge({
-            schemas: current.tools.schemas, maxArgumentBytes: current.tools.maximumArgumentBytes,
-            async execute(input, signal) {
-              return executeOpenCodeApplicationTool({ active: current,
-                turn: facilities.runtime.turns.get(binding.directory), target: native, sessionId: binding.sessionId }, input, signal);
+        const acquired = await supplied.acquire(context);
+        const active = current;
+        if (active?.tools) signal.throwIfAborted();
+        if (active?.tools && !toolBridge) {
+          toolBridge = await createOpenCodeToolBridge({ schemas: active.tools.schemas,
+            maxArgumentBytes: active.tools.maximumArgumentBytes, execute(input, signal) {
+              const turn = supplied.owner.turns.get(acquired.key);
+              const target = supplied.owner.processes.get(acquired.key);
+              const execute = () => executeOpenCodeApplicationTool({ active: current, turn, target,
+                sessionId: target?.upstreamSessionId,
+                assertCurrent(throwFailure = true, authored) {
+                  const owned = !disposed && current === active && active.turn === turn && turn?.active &&
+                    (!authored || active.messageIds.get(turn.inputMessageId) === authored) &&
+                    supplied.owner.turns.get(acquired.key) === turn && supplied.owner.processes.get(acquired.key) === target;
+                  if (!owned && throwFailure) throw new Error("This OpenCode tool call belongs to a retired native turn.");
+                  return owned;
+                }
+              }, input, signal);
+              // readable-check: allow method-probe - optional operation: an acquisition that runs inside its request's context supplies runInContext
+              return typeof acquired.runInContext === "function" ? acquired.runInContext(execute) : execute();
             }
           });
         }
-        return { configuration, signal, model, agent, connection };
-      }
-
-      async function prepare({ configuration, signal, model, agent, connection }) {
-        try {
-          const start = host.opencode
-            ? async () => facilities.runtime.startPreparedProcess(await facilities.prepareServer())
-            : () => facilities.start({ signal, connection });
-          // A managed host's saved connections reach its running server in place.
-          const savedConnections = host.opencode ? async () => (await facilities.prepareServer()).connections : null;
-          if (!native) {
-            native = await facilities.runtime.acquire(binding.directory, async () => {
-              const shared = await facilities.runtime.ensure(facilities.selected, start, savedConnections);
-              return { key: binding.directory, workdir: binding.workdir, upstreamSessionId: binding.sessionId,
-                abortController: new AbortController(), server: openCodeServerForDirectory(shared.server, binding.workdir) };
-            });
-          } else await facilities.runtime.ensure(facilities.selected, start, savedConnections);
+        const options = active?.tools ? { ...acquired.options, applicationTools: toolBridge.configuration } : acquired.options;
+        let prepared;
+        const dispatch = active?.tools ? async identity => {
+          await beforeDispatch(identity);
           signal.throwIfAborted();
-          await updateBinding({ executionId: native.server.executionId, processDirectory: native.server.privateRoot || "" });
-          const catalogue = await native.server.client.providers({ signal });
-          const selected = catalogue.all.find(provider => provider.id === connection.providerId)?.models?.[connection.model];
-          if (selected?.id !== connection.model) throw new Error("OpenCode could not load the configured model definition. Check the selected integration before sending.");
-          processVariants = selected.variants || {};
-        } catch (error) {
-          if (error.stopProof?.scopeEmpty) await updateBinding({ executionId: "", processDirectory: "" });
-          throw error;
-        }
-        if (configuration.effort) {
-          if (!Object.hasOwn(processVariants, configuration.effort)) throw new Error("The selected OpenCode model does not support this reasoning effort.");
-          model.variant = configuration.effort;
+          active.turn = supplied.owner.turns.get(acquired.key);
+          active.messageIds.set(prepared.input.id, { messageId: input.messageId, committed: command.deliveryCommitted });
+        } : beforeDispatch;
+        prepared = await supplied.preparation.message({ ...input.nativeMessage, onPromptSending: dispatch }, options);
+        if (prepared.application?.commit) {
+          const application = prepared.application;
+          prepared.application = { ...application, async commit(admitted) {
+            onNativeReceipt();
+            const result = await application.commit(admitted);
+            onReceiptPersisted();
+            return result;
+          } };
         }
-        const retainedId = binding.sessionId;
-        if (retainedId && (await native.server.client.sessionStatus(retainedId, { signal })).type !== "idle") {
-          throw new Error("The native OpenCode conversation is still working. Stop or inspect it before sending another message.");
-        }
-        const session = {
-          selection: { agentId: agent, modelId: model.id, modelProviderId: model.providerID, variantId: model.variant || "" },
-          model, workdir: binding.workdir, signal,
-          invalidIdentity: () => new Error("OpenCode did not acknowledge a native conversation."),
-          identity: {
-            async write(nativeId) {
-              if (retainedId && nativeId !== retainedId) throw new Error("The saved OpenCode conversation is unavailable. Restore its native history before continuing.");
-              if (binding.sessionId !== nativeId) await updateBinding({ sessionId: nativeId });
-            },
-            publish(nativeId) {
-              return facilities.runtime.writeBindings(facilities.registryPath, binding.directory, [{
-                upstreamSessionId: nativeId, workdir: binding.workdir, modelProviderId: connection.providerId,
-                ...(nativeTools ? { env: host.env || process.env } : {}),
-                conversation: { systemPrompt: configuration.systemPrompt, nativeTools,
-                  commandWrapper: host.commandWrapper, tools: current?.tools ? toolBridge?.configuration : undefined }
-              }]);
-            }
-          }
-        };
-        return { target: native, session, model };
-      }
-
-      function messageMonitor(active, command) {
-        return {
-          prepare() { return { fields: {} }; },
-          create(target, turn, _metadata, options) {
-            const abort = () => turn.abortController.abort(command.signal.reason);
-            command.signal.addEventListener("abort", abort, { once: true });
-            if (command.signal.aborted) abort();
-            const recoveryMessageId = nativeMessageId(`${command.input.messageId}:final-response`);
-            return {
-              observe(_turn, signal) {
-                return observeOpenCodeEvents(target.server.client, target.upstreamSessionId, {
-                  abortController: turn.abortController, signal, eventStartedAt: turn.eventStartedAt,
-                  async onEvent(summary, event) {
-                    if (summary.type === "session.status") {
-                      const status = event.data.properties?.status?.type;
-                      if (status === "retry" || status === "busy") {
-                        await turn.admission?.promise;
-                        await active.deliveryCommitted;
-                        signal.throwIfAborted();
-                        await active.onEvent({ type: "phase", phase: status === "retry" ? "retrying" : "working" });
-                      }
-                    }
-                  }
-                });
-              },
-              eventReady: options.eventReady,
-              readiness: { timeoutMs: limits.admissionTimeoutMs || 120_000,
-                timeoutError: new Error("OpenCode's event connection was not ready before the admission deadline.") },
-              finalResponse: {
-                agent: active.agent, model: active.prepared.model, recoveryMessageId,
-                beforeRecovery() {
-                  active.messageIds.set(recoveryMessageId, active.messageIds.get(turn.inputMessageId));
-                }
-              },
-              async writeRun(observed, state) {
-                if (state === "active") await active.onEvent({ type: "phase", phase: observed.phase || "working" });
-              },
-              async projectMessages(messages, { inputMessageId }) {
-                await active.deliveryCommitted;
-                if (inputMessageId !== turn.inputMessageId) return { failure: "", providerApiFailure: false };
-                return facilities.runtime.projectConversationMessages(messages, inputMessageId, {
-                  maximumOutput, outputSchema: active.configuration.outputSchema,
-                  previous: active.previous, onMessage: active.onMessage
-                });
-              },
-              completeResult(_turn, { failure }) { return failure; },
-              onRetired() { command.signal.removeEventListener("abort", abort); }
-            };
-          },
-          onError(error) { active.failure ||= error; }
-        };
-      }
-
-      async function send(command) {
-        const active = current;
-        const id = nativeMessageId(command.input.messageId);
-        const previousOwner = active.messageIds.get(id);
-        let accepted = false;
-        let value;
-        try {
-          value = await facilities.runtime.sendMessage(binding.directory, {
-            id, threadId: binding.sessionId, workdir: binding.workdir
-          }, { promptTimeoutMs: limits.admissionTimeoutMs || 30_000 }, {
-            async writeRun() {},
-            async prepare({ overwrite }) {
-              const signal = active.prepared
-                ? AbortSignal.any([command.signal, AbortSignal.timeout(120_000)])
-                : active.resolved.signal;
-              if (overwrite || !active.prepared) active.prepared = await prepare({ ...active.resolved, signal });
-              return { ...active.prepared, session: { ...active.prepared.session, signal } };
-            },
-            prompt() {
-              native.abortController.signal.throwIfAborted();
-              return {
-                agent: active.agent, model: active.prepared.model,
-                prompt: prompt(command.input, active.configuration), attachments: command.input.localFiles,
-                authorizeAttachments: true,
-                async beforeDispatch(threadId) {
-                  await command.beforeDispatch({ threadId });
-                  command.signal.throwIfAborted();
-                  active.messageIds.set(id, {
-                    messageId: command.input.messageId, committed: command.deliveryCommitted
-                  });
+        if (active?.tools && prepared.application?.monitor) {
+          const monitor = prepared.application.monitor;
+          const create = monitor.create;
+          prepared.application = { ...prepared.application, monitor: { ...monitor,
+            create(...args) {
+              const projection = create(...args);
+              const finalResponse = projection.finalResponse;
+              return { ...projection, finalResponse: { ...finalResponse,
+                async beforeRecovery(completion) {
+                  active.messageIds.set(finalResponse.recoveryMessageId, active.messageIds.get(completion.inputMessageId));
+                  const { beforeRecovery = recoverWithoutProjection } = finalResponse;
+                  await beforeRecovery(completion);
                 }
-              };
-            },
-            async commit() {
-              command.onNativeReceipt?.();
-              await command.accept();
-              command.onReceiptPersisted?.();
-              active.deliveryCommitted = command.deliveryCommitted;
-              accepted = true;
-            },
-            monitor: messageMonitor(active, command)
-          });
-          if (value.failure) throw value.failure.error;
-          if (!value.delivered) throw new Error("OpenCode did not acknowledge the message.");
-        } catch (error) {
-          const turn = facilities.runtime.turns.get(binding.directory);
-          const attempted = value?.failure ? value.failure.attempted : turn?.promptAttempted === true;
-          if (attempted && !accepted && !(error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 408)) {
-            error.delivery = "uncertain";
-            turn?.abortController?.abort(error);
-            // Join the same owner's recovery before releasing its process target.
-            await facilities.runtime.monitors.get(binding.directory);
-          } else if (previousOwner) active.messageIds.set(id, previousOwner);
-          else active.messageIds.delete(id);
-          if (turn?.active && turn.observationError) error.cleanupFailed = true;
-          throw error;
+              } };
+            }
+          } };
         }
-        active.delivery = { turn: facilities.runtime.turns.get(binding.directory),
-          completion: facilities.runtime.monitors.get(binding.directory) };
-        return value;
+        const value = await supplied.owner.sendPreparedMessage(prepared, options);
+        const delivered = { value, completion: value.conversationTurn ? supplied.owner.monitors.get(acquired.key) : null };
+        if (value.delivered === true && value.conversationTurn) {
+          if (current) current.delivery = delivered;
+          await accept({ nativeResult: { value }, conversationTurn: value.conversationTurn, nativeTurnId: value.turn?.id });
+        } else if (active?.tools) active.messageIds.delete(prepared.input.id);
+        return delivered;
       }
-
       return Object.freeze({
-        async inspectAdmission({ messageId, threadId, configuration, context, verifyAccount = false, receiptBinding }) {
-          if (verifyAccount === true && (!receiptBinding || threadId !== binding.sessionId || receiptBinding.sessionId !== binding.sessionId ||
-              receiptBinding.workdir !== binding.workdir || receiptBinding.directory !== binding.directory ||
-              receiptBinding.databasePath !== binding.databasePath || receiptBinding.runtimeDirectory !== binding.runtimeDirectory)) {
-            throw new Error("The completed OpenCode response belongs to a different native conversation or host scope.");
-          }
-          if (!binding.sessionId) return { accepted: false, messages: [] };
-          const prepared = await prepare(await resolvePreparation(configuration, context, AbortSignal.timeout(120_000), verifyAccount === true, receiptBinding));
-          await ensureOpenCodeSession(prepared.target, prepared.session);
-          const id = nativeMessageId(messageId);
-          const { accepted = false, messages = [] } = await inspectOpenCodeMessageAdmission(native.server.client, binding.sessionId, id) || {};
-          return { accepted,
-            messages: openCodeRowsForInput(messages, id).filter(message => message.type === "assistant" && !message.summary)
-              .map(message => ({ id: message.id, outputId: `${message.id}:assistant`, role: "assistant",
-                text: configuration.outputSchema ? openCodeStructuredOutput(openCodeAssistantMessageText(message)) : openCodeAssistantMessageText(message) })) };
-        },
-        steer(command) {
-          if (!current || current.finished) throw new Error("OpenCode has no active turn to steer.");
-          return send(command);
+        publishNative: event => conversation.publish(event),
+        async inspectAdmission({ context, representation, ...input }) {
+          const acquired = await supplied.acquire(context);
+          const result = await supplied.owner.inspectPreparedMessage(await supplied.preparation.inspection(input, acquired.options));
+          return representation === "native" ? result : { accepted: result.admission === "accepted" };
         },
         async run(command) {
           if (disposed || current) throw new Error("This OpenCode conversation is closed or already working.");
-          const active = current = { tools: command.tools, configuration: command.configuration,
-            onMessage: command.onMessage, onEvent: command.onEvent, messageIds: new Map(), previous: new Map() };
-          let problem;
+          const active = { context: command.context, failure: Promise.withResolvers(),
+            ...(command.tools ? { tools: command.tools, messageIds: new Map() } : {}) };
+          let failure;
+          active.failure.promise.catch(error => { failure = error; });
+          current = active;
+          let cancellation;
+          const abort = () => {
+            cancellation ||= interrupt(command.context).then(() => { throw command.signal.reason; });
+            cancellation.catch(active.failure.reject);
+          };
+          command.signal.addEventListener("abort", abort, { once: true });
           try {
-            active.resolved = await resolvePreparation(command.configuration, command.context,
-              AbortSignal.any([command.signal, AbortSignal.timeout(120_000)]), false, undefined, true);
+            let delivered;
             let dispatchFailure;
-            try { await send(command); }
+            try { delivered = await send(command); }
             catch (error) { dispatchFailure = error; }
             for (;;) {
               const settling = active.delivery;
               let result;
-              let failure = dispatchFailure || active.failure;
-              if (!failure && settling?.completion) {
-                try { result = await settling.completion; }
-                catch (error) { failure = error; }
-              } else if (!failure && settling) result = facilities.runtime.turnSnapshot(settling.turn, binding.sessionId);
-              if (command.finishIfCurrent && !await command.finishIfCurrent(() => active.delivery === settling)) continue;
-              failure = dispatchFailure || active.failure || failure;
-              if (!failure && result?.error) {
-                failure = Object.assign(new Error(result.error), { status: result.status });
-                if (result.active && result.status === "observation_lost") failure.cleanupFailed = true;
+              let problem = dispatchFailure || failure;
+              if (!problem && settling?.completion) {
+                try { result = await Promise.race([settling.completion, active.failure.promise]); }
+                catch (error) { problem = error; }
               }
-              if (failure) throw failure;
-              break;
+              if (command.finishIfCurrent && !await command.finishIfCurrent(() => active.delivery === settling)) {
+                // The original sender admitted another invocation and returned
+                // its exact monitor. Keep the same completion and Stop owner.
+                continue;
+              }
+              problem = dispatchFailure || failure || problem;
+              if (!problem && result?.error) {
+                // readable-check: allow patched-error - data: status is the native turn's state, not an HTTP status
+                problem = Object.assign(new Error(result.error), { status: result.status });
+                if (result.active && result.status === "observation_lost") {
+                  problem.cleanupFailed = true;
+                  cleanupFailure = problem;
+                  await reportFailure(problem);
+                }
+              }
+              if (problem) throw problem;
+              return { value: delivered.value };
             }
-          } catch (error) {
-            problem = error.cleanupFailed ? error : command.signal.aborted ? command.signal.reason : error;
-            if (problem.cleanupFailed) problem.message = "OpenCode process cleanup could not be confirmed. Restore its execution host before continuing.";
+          } finally {
+            command.signal.removeEventListener("abort", abort);
+            await cancellation?.catch(() => {});
+            if (toolBridge) { await toolBridge.close(); toolBridge = null; }
+            if (current === active) current = null;
           }
-          active.finished = true;
-          try { if (!problem?.cleanupFailed && (problem || command.signal.aborted)) await stop(); }
-          catch (error) { problem = error; }
-          finally { await toolBridge?.whenIdle(); if (!problem?.cleanupFailed) current = null; }
-          if (problem) throw problem;
         },
-        cancel: stop,
-        async dispose() { await stop(); disposed = true; }
+        async steer(command) { return { value: (await send(command)).value }; },
+        async cancel({ context, representation } = {}) {
+          const value = await interrupt(context);
+          return representation === "native" ? { value } : value;
+        },
+        async dispose(options) {
+          try {
+            const result = await disposeNative({ native: supplied, options });
+            if (result?.ok === false) throw Object.assign(new Error(result.error || "OpenCode cleanup could not be confirmed."), result);
+            if (toolBridge) { await toolBridge.close(); toolBridge = null; }
+            disposed = true;
+            return result;
+          } catch (error) {
+            error.cleanupFailed = true;
+            current?.failure.reject(error);
+            throw error;
+          }
+        }
       });
     }
+    return openStandaloneOpenCodeConversation({
+      connections,
+      host,
+      limits,
+      workdir,
+      stateDirectory,
+      execution,
+      nativeTools,
+      maximumOutput
+    }, { binding, writeBinding, reportFailure });
+  }
+
+  return Object.freeze({
+    toolDiscovery: true,
+    attachmentTypes: ["text", "image", "localFile"],
+    capabilities: Object.freeze({ streaming: true, cancellation: true, history: true,
+      instructions: true, configuration: true, steering: true, goals: false, attachments: true, tools: true, nativeTools, structuredOutput: true }),
+    validateConfiguration,
+    readState,
+    inspectTemporaryActivity,
+    releaseRenewalPredecessorProcessExitProof,
+    releaseRenewalSuccessorProcessExitProof,
+    generateRenewalHandover,
+    seedRenewalHandover,
+    ensureConversation,
+    disposeNative,
+    interruptDetachedConversation,
+    deleteDetachedConversation,
+    listConversationStorage,
+    retireConversationHistory,
+    closeProject,
+    invalidateRuntimes,
+    reconcileSessions,
+    createConversation,
+    runDetachedConversation,
+    createBinding,
+    open
   });
 }