tinker-agent 2.12.0 → 3.0.0

package/src/cli/service-upgrade.ts

@@ -0,0 +1,106 @@
+import { createConnection } from "node:net";
+import { randomUUID } from "node:crypto";
+import { lstat, readdir, realpath, readFile } from "node:fs/promises";
+import path from "node:path";
+import {
+  localServicePaths,
+  type LocalServiceInstance,
+} from "../remote/local-service-discovery";
+
+/** Check every live service using this installation, including explicit non-default state directories. */
+export async function assertServiceUpgradeSafe(packageRoot: string): Promise<void> {
+  if (process.platform === "win32") return;
+  const root = path.dirname(localServicePaths("").socket);
+  let entries: string[];
+  try {
+    const info = await lstat(root);
+    if (
+      !info.isDirectory() ||
+      info.isSymbolicLink() ||
+      info.uid !== process.getuid?.() ||
+      info.mode & 0o077
+    )
+      throw new Error(
+        "Unsafe local service discovery directory; cannot verify upgrade safety.",
+      );
+    entries = await readdir(root);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+    throw error;
+  }
+  const canonical = await realpath(packageRoot);
+  for (const entry of entries.filter((name) =>
+    /^[a-f0-9]{32}\.sock\.json$/.test(name),
+  )) {
+    const instance = JSON.parse(
+      await readFile(path.join(root, entry), "utf8"),
+    ) as LocalServiceInstance;
+    if (
+      instance.packageRoot === canonical &&
+      (await Bun.file(
+        path.join(instance.stateDirectory, "supervisor.enabled"),
+      ).exists())
+    )
+      throw new Error(
+        `Disable the supervised service before upgrading: tinker serve --config ${instance.configPath} --stop.`,
+      );
+  }
+  for (const entry of entries.filter((name) => /^[a-f0-9]{32}\.sock$/.test(name))) {
+    const instance = await probe(path.join(root, entry));
+    if (instance && (!instance.packageRoot || instance.packageRoot === canonical))
+      throw new Error(
+        `Stop the running service before upgrading: tinker serve --config ${instance.configPath} --stop. Upgrade does not interrupt work or replace a live runtime.`,
+      );
+  }
+}
+function probe(socketPath: string): Promise<LocalServiceInstance | undefined> {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(socketPath);
+    const nonce = randomUUID();
+    let content = "";
+    let finished = false;
+    const done = (instance?: LocalServiceInstance, error?: Error) => {
+      if (finished) return;
+      finished = true;
+      socket.destroy();
+      if (error) reject(error);
+      else resolve(instance);
+    };
+    socket.setEncoding("utf8");
+    socket.setTimeout(1000, () =>
+      done(
+        undefined,
+        new Error(
+          "A local service is unresponsive; stop it explicitly before upgrading.",
+        ),
+      ),
+    );
+    socket.once("connect", () => socket.write(`${nonce}\n`));
+    socket.once("error", (error: NodeJS.ErrnoException) =>
+      ["ENOENT", "ECONNREFUSED"].includes(error.code ?? "")
+        ? done()
+        : done(undefined, error),
+    );
+    socket.once("end", () => done());
+    socket.on("data", (chunk: string) => {
+      content += chunk;
+      if (content.length > 16384)
+        return done(undefined, new Error("Invalid service upgrade probe response."));
+      if (!content.includes("\n")) return;
+      try {
+        const response = JSON.parse(content.trim()) as {
+          nonce: string;
+          instance: LocalServiceInstance;
+        };
+        if (response.nonce !== nonce || response.instance?.version !== 1)
+          throw new Error("Invalid service upgrade probe response.");
+        done(response.instance);
+      } catch (error) {
+        done(
+          undefined,
+          error instanceof Error ? error : new Error("Invalid service response."),
+        );
+      }
+    });
+  });
+}

package/src/cli/tui-runner.tsx

@@ -1,54 +1,20 @@
 import { render } from "ink";
 import { realpath } from "node:fs/promises";
-import {
-  createRuntimeSession,
-  type RuntimeSession,
-  type SessionDisposeReason,
-} from "../agent/runtime-session";
-import type { EventSink } from "../events/event-sink";
-import type { AgentEvent } from "../events/types";
-import type {
-  AssistantTextDeltaSink,
-  AssistantTextDeltaUpdate,
-} from "../agent/assistant-text-delta";
-import { createUuidV7 } from "../ids/uuid-v7";
-import type { SessionId } from "../ids/runtime-id";
-import {
-  buildSystemPrompt,
-  loadProjectInstructions,
-  projectInstructionManifest,
-} from "../instructions/project-instructions";
-import { ResumeProjectionReader } from "../session/resume-projection";
-import { SessionCatalog } from "../session/session-catalog";
+import type { ClientCloseReason } from "../client/session-client";
+import { createLocalTuiClient } from "./local-tui-client";
 import { App } from "../tui/app";
 import { readCurrentGitBranch } from "../tui/git-branch";
 import { PromptHistory } from "../tui/prompt-history";
-import { TuiProjectionStore } from "../tui/tui-projection-store";
-import {
-  DefaultTuiSessionController,
-  managedTuiBinding,
-  type ManagedTuiSessionBinding,
-  type TuiSessionBinding,
-} from "../tui/tui-session-controller";
 import {
   promptHistoryPath,
-  deriveRunnerConfig,
   type ResolvedPublicConfig,
   type RunnerConfig,
 } from "./config";
-import {
-  createRunnerModelClient,
-  createWebFetchRefiner,
-  RUNTIME_INSTRUCTIONS,
-} from "./runner-dependencies";
-import { resolveSessionProfileName, type ModelProfile } from "./model-profiles";
-import { loadSkillCatalog } from "../skills/skill-loader";
 import { loadProjectSlashCommands } from "../tui/project-slash-commands";
 import { createWorkspaceFileLister } from "../tui/workspace-file-search";
 import { clipboardWriterForEnvironment } from "../tui/clipboard";
 import { listMemoryFiles } from "../memory/memory-files";
 import { prepareShikiHighlighter } from "../tui/shiki-highlighter";
-import { createReasoningEffortController } from "../model/reasoning-effort";
 
 export type RunTuiOptions = {
   readonly publicConfig: ResolvedPublicConfig;
@@ -63,212 +29,23 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
     options.publicConfig.mode === "profile" ? options.publicConfig.profiles : undefined;
   const config = options.initialRunnerConfig;
   const workspaceRoot = await realpath(config.workspaceRoot);
-  let controller: DefaultTuiSessionController | undefined;
+  let connection: Awaited<ReturnType<typeof createLocalTuiClient>> | undefined;
   let instance: ReturnType<typeof render> | undefined;
-  let disposeReason: SessionDisposeReason = { type: "tui_exit" };
+  let closeReason: ClientCloseReason = { type: "client_exit" };
   let primaryError: unknown;
   let quitRequested = false;
 
   try {
     const projectSlashCommands = await loadProjectSlashCommands(workspaceRoot);
-    const createSessionForConfig = async (
-      sessionConfig: RunnerConfig,
-      mode: "new" | "resume",
-      sessionId: SessionId,
-      sink: EventSink & AssistantTextDeltaSink,
-    ): Promise<RuntimeSession> => {
-      const reasoningEffort = createReasoningEffortController(sessionConfig.reasoning);
-      const modelClient = createRunnerModelClient(
-        sessionConfig,
-        undefined,
-        options.env,
-        reasoningEffort,
-      );
-      const projectInstructions = await loadProjectInstructions(workspaceRoot);
-      const skillCatalog = await loadSkillCatalog({ workspaceRoot });
-      const common = {
-        workspaceRoot,
-        modelName: sessionConfig.modelName,
-        profileName: sessionConfig.profileName,
-        maxIterations: sessionConfig.maxIterations,
-        includeReasoningContent: sessionConfig.includeReasoningContent,
-        contextProfile: sessionConfig.contextProfile,
-        contextBudget: sessionConfig.contextBudget,
-        modelClient,
-        systemPrompt: buildSystemPrompt({
-          workspaceRoot,
-          runtimeInstructions: RUNTIME_INSTRUCTIONS(workspaceRoot),
-          projectInstructions,
-        }),
-        projectInstruction: projectInstructionManifest(projectInstructions),
-        skillCatalog,
-        presentationSinks: [sink],
-        assistantTextDeltaSink: sink,
-        webFetchRefiner: createWebFetchRefiner(
-          sessionConfig,
-          options.env,
-          reasoningEffort,
-        ),
-        toolingConfig: options.publicConfig.tooling,
-        enableTurnUndo: true,
-        enableAskUser: true,
-        enableProviderRetryPrompt: true,
-        bashGuard: {
-          mode: sessionConfig.bashGuardMode,
-          source: sessionConfig.bashGuardSource,
-          surface: "tui" as const,
-        },
-      };
-      if (mode === "resume") {
-        return createRuntimeSession({
-          ...common,
-          selection: { mode, sessionId },
-        });
-      }
-
-      return createRuntimeSession({
-        ...common,
-        selection: { mode, sessionId },
-      });
-    };
-
-    const projectionStore = new TuiProjectionStore({
-      sessionId: config.sessionId,
-      modelName: config.modelName,
-      workspaceRoot,
-    });
-    const initialSession = await createSessionForConfig(
-      config,
-      "new",
-      config.sessionId,
-      projectionStore,
-    );
+    connection = await createLocalTuiClient({ ...options, workspaceRoot });
     const promptHistory = await PromptHistory.load(
       await promptHistoryPath(workspaceRoot),
     );
-    const catalog = new SessionCatalog({ workspaceRoot });
-
-    const openStoredSession = async (
-      sessionId: SessionId,
-    ): Promise<ManagedTuiSessionBinding> => {
-      const deferred = new DeferredProjectionSink();
-      const summary = await catalog.get(sessionId);
-      const resumeConfig = deriveRunnerConfig(options.publicConfig, {
-        sessionId,
-        ...(profiles === undefined
-          ? {}
-          : { profileName: resolveSessionProfileName(profiles, summary) }),
-      });
-      const runtimeSession = await createSessionForConfig(
-        resumeConfig,
-        "resume",
-        sessionId,
-        deferred,
-      );
-      const targetProjection = new TuiProjectionStore({
-        sessionId,
-        modelName: resumeConfig.modelName,
-        workspaceRoot,
-      });
-      try {
-        targetProjection.hydrate(
-          await ResumeProjectionReader.read({
-            workspaceRoot,
-            sessionId,
-            modelName: resumeConfig.modelName,
-          }),
-        );
-        await deferred.attach(targetProjection);
-      } catch (error) {
-        await runtimeSession
-          .dispose({ type: "runner_failed", error: errorMessage(error) })
-          .catch(() => undefined);
-        throw error;
-      }
-      return managedTuiBinding({
-        runtimeSession,
-        modelName: resumeConfig.modelName,
-        workspaceRoot,
-        profileName: resumeConfig.profileName,
-        projectionStore: targetProjection,
-      });
-    };
-
-    const createNewSessionBinding = async (
-      sessionConfig: RunnerConfig,
-    ): Promise<ManagedTuiSessionBinding> => {
-      const freshProjectionStore = new TuiProjectionStore({
-        sessionId: sessionConfig.sessionId,
-        modelName: sessionConfig.modelName,
-        workspaceRoot,
-      });
-      const runtimeSession = await createSessionForConfig(
-        sessionConfig,
-        "new",
-        sessionConfig.sessionId,
-        freshProjectionStore,
-      );
-      return managedTuiBinding({
-        runtimeSession,
-        modelName: sessionConfig.modelName,
-        workspaceRoot,
-        profileName: sessionConfig.profileName,
-        projectionStore: freshProjectionStore,
-      });
-    };
-
-    const createSessionWithProfile = async (
-      profile: ModelProfile,
-    ): Promise<ManagedTuiSessionBinding> => {
-      if (profiles === undefined) {
-        throw new Error("Model profiles are not configured.");
-      }
-      return createNewSessionBinding(
-        deriveRunnerConfig(options.publicConfig, {
-          sessionId: createUuidV7() as SessionId,
-          profileName: profile.name,
-        }),
-      );
-    };
-
-    const createFreshSession = async (
-      current: TuiSessionBinding,
-    ): Promise<ManagedTuiSessionBinding> => {
-      const sessionId = createUuidV7() as SessionId;
-      if (profiles === undefined) {
-        return createNewSessionBinding(
-          deriveRunnerConfig(options.publicConfig, { sessionId }),
-        );
-      }
-      if (current.profileName === undefined) {
-        throw new Error("Current session does not have a model profile.");
-      }
-      return createNewSessionBinding(
-        deriveRunnerConfig(options.publicConfig, {
-          sessionId,
-          profileName: current.profileName,
-        }),
-      );
-    };
-
-    controller = new DefaultTuiSessionController(
-      managedTuiBinding({
-        runtimeSession: initialSession,
-        modelName: config.modelName,
-        workspaceRoot,
-        profileName: config.profileName,
-        projectionStore,
-      }),
-      catalog,
-      openStoredSession,
-      createSessionWithProfile,
-      createFreshSession,
-    );
 
     await shikiPreparation;
     instance = render(
       <App
-        sessionController={controller}
+        sessionController={connection.client}
         version={options.version}
         readGitBranch={readCurrentGitBranch}
         history={promptHistory}
@@ -295,13 +72,13 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
     await instance.waitUntilExit();
   } catch (error) {
     primaryError = error;
-    disposeReason = { type: "runner_failed", error: errorMessage(error) };
+    closeReason = { type: "client_failed", error: errorMessage(error) };
   } finally {
     instance?.unmount();
     restoreStdin();
-    if (controller !== undefined) {
+    if (connection !== undefined) {
       try {
-        await controller.dispose(disposeReason);
+        await connection.close(closeReason);
       } catch (error) {
         primaryError =
           primaryError === undefined
@@ -322,35 +99,6 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
   }
 }
 
-class DeferredProjectionSink implements EventSink, AssistantTextDeltaSink {
-  readonly name = "deferred-tui-projection";
-  private target?: TuiProjectionStore;
-  private readonly buffered: AgentEvent[] = [];
-
-  async append(event: AgentEvent): Promise<void> {
-    if (this.target === undefined) {
-      this.buffered.push(event);
-      return;
-    }
-    await this.target.append(event);
-  }
-
-  updateAssistantTextDelta(update: AssistantTextDeltaUpdate): void {
-    this.target?.updateAssistantTextDelta(update);
-  }
-
-  async attach(target: TuiProjectionStore): Promise<void> {
-    if (this.target !== undefined) {
-      throw new Error("Deferred projection sink is already attached.");
-    }
-    this.target = target;
-    for (const event of this.buffered) {
-      await target.append(event);
-    }
-    this.buffered.length = 0;
-  }
-}
-
 function restoreStdin(): void {
   if (process.stdin.isTTY) {
     process.stdin.setRawMode(false);

package/src/cli/update-runner.ts

@@ -1,3 +1,4 @@
+import { assertServiceUpgradeSafe } from "./service-upgrade";
 import { spawn } from "node:child_process";
 import { lstat, realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -26,6 +27,7 @@ type NpmCommandInput = {
 
 export type UpdateRunnerDependencies = {
   readonly packageRoot: string;
+  readonly assertServiceUpgradeSafe: (packageRoot: string) => Promise<void>;
   readonly npmCwd: string;
   readonly runNpm: (input: NpmCommandInput) => Promise<NpmCommandResult>;
   readonly canonicalizePath: (filePath: string) => Promise<string>;
@@ -41,6 +43,7 @@ type UpdateInput = {
 };
 
 const DEFAULT_DEPENDENCIES: UpdateRunnerDependencies = {
+  assertServiceUpgradeSafe,
   packageRoot: path.resolve(fileURLToPath(new URL("../../", import.meta.url))),
   npmCwd: tmpdir(),
   runNpm,
@@ -116,6 +119,7 @@ export async function runUpdate(
     return 0;
   }
 
+  await dependencies.assertServiceUpgradeSafe(dependencies.packageRoot);
   await writeCliOutput(input.stdout, `Updating to ${latestVersion}...\n`);
   await runNpmChecked(
     dependencies,

package/src/client/local-workspace-client.ts

@@ -0,0 +1,238 @@
+import type {
+  RuntimeSession,
+  SessionDisposeReason,
+  ExecuteTurnInput,
+} from "../agent/runtime-session";
+import type { SessionId } from "../ids/runtime-id";
+import { createUuidV7 } from "../ids/uuid-v7";
+import type { ClientModelProfile } from "./model-catalog";
+import type { SessionCatalog, SessionSummary } from "../session/session-catalog";
+import { readLastAssistantResponse } from "../session/session-last-response-reader";
+import type {
+  ContextCompactionResult,
+  ContextRetirementResult,
+} from "../context/context-manager";
+import type { TurnUndoResult } from "../tools/turn-undo-manager";
+import type { SessionClient, WorkspaceClient } from "./session-client";
+
+export type OwnedSessionBinding<View> = {
+  client: SessionClient<View>;
+  runtimeSession: RuntimeSession;
+};
+
+export class LocalWorkspaceClient<View> implements WorkspaceClient<View> {
+  private readonly listeners = new Set<() => void>();
+  private binding: OwnedSessionBinding<View>;
+  private operation?: Promise<unknown>;
+
+  constructor(
+    initial: OwnedSessionBinding<View>,
+    private readonly catalog: SessionCatalog,
+    private readonly openSession: (
+      sessionId: SessionId,
+    ) => Promise<OwnedSessionBinding<View>>,
+    private readonly createSessionWithProfile: (
+      profile: ClientModelProfile,
+    ) => Promise<OwnedSessionBinding<View>>,
+    private readonly createFreshSession: (
+      current: SessionClient<View>,
+    ) => Promise<OwnedSessionBinding<View>>,
+  ) {
+    this.binding = initial;
+  }
+
+  readonly getBinding = (): SessionClient<View> => this.binding.client;
+
+  readonly subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  listSessions(): Promise<readonly SessionSummary[]> {
+    return this.catalog.listAll(this.binding.client.sessionId);
+  }
+
+  compact(): Promise<ContextCompactionResult> {
+    return this.serialize(() => this.binding.runtimeSession.compactContext());
+  }
+
+  retire(): Promise<ContextRetirementResult> {
+    return this.serialize(() => this.binding.runtimeSession.retireContext());
+  }
+
+  undo(): Promise<TurnUndoResult> {
+    return this.serialize(() =>
+      this.binding.runtimeSession.undoLatestFileMutationTurn(),
+    );
+  }
+
+  fork(beforeCommit?: () => void): Promise<SessionId> {
+    return this.serialize(async () => {
+      const targetSessionId = createUuidV7() as SessionId;
+      await this.replaceSession(
+        "Cannot clone the session while a turn, context operation, or background task is active.",
+        async (current) => {
+          await current.runtimeSession.cloneSession(targetSessionId);
+          return this.openSession(targetSessionId);
+        },
+        beforeCommit,
+      );
+      return targetSessionId;
+    });
+  }
+
+  clear(beforeCommit?: () => void): Promise<void> {
+    return this.serialize(() =>
+      this.replaceSession(
+        "Cannot clear the session while a turn, context operation, or background task is active.",
+        (current) => this.createFreshSession(current.client),
+        beforeCommit,
+      ),
+    );
+  }
+
+  resume(sessionId: SessionId, beforeCommit?: () => void): Promise<void> {
+    return this.serialize(async () => {
+      if (sessionId === this.binding.client.sessionId) {
+        throw new Error(`Session ${sessionId} is already current.`);
+      }
+      await this.replaceSession(
+        "Cannot switch sessions while a turn or background task is active.",
+        () => this.openSession(sessionId),
+        beforeCommit,
+      );
+    });
+  }
+
+  delete(sessionId: SessionId): Promise<void> {
+    return this.serialize(() =>
+      this.catalog.delete(sessionId, this.binding.client.sessionId),
+    );
+  }
+
+  switchModel(profile: ClientModelProfile, beforeCommit?: () => void): Promise<void> {
+    return this.serialize(() =>
+      this.replaceSession(
+        "Cannot switch models while a turn or background task is active.",
+        () => this.createSessionWithProfile(profile),
+        beforeCommit,
+      ),
+    );
+  }
+
+  dispose(reason: SessionDisposeReason): Promise<void> {
+    return this.binding.runtimeSession.dispose(reason);
+  }
+
+  private async replaceSession(
+    unavailableMessage: string,
+    createTarget: (
+      current: OwnedSessionBinding<View>,
+    ) => Promise<OwnedSessionBinding<View>>,
+    beforeCommit?: () => void,
+  ): Promise<void> {
+    const current = this.binding;
+    if (!current.runtimeSession.canSwitchSession()) {
+      throw new Error(unavailableMessage);
+    }
+
+    const target = await createTarget(current);
+    try {
+      await current.runtimeSession.dispose({ type: "session_switch" });
+    } catch (error) {
+      await target.runtimeSession
+        .dispose({ type: "runner_failed", error: errorMessage(error) })
+        .catch(() => undefined);
+      throw error;
+    }
+    beforeCommit?.();
+    this.binding = target;
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+
+  private serialize<T>(operation: () => Promise<T>): Promise<T> {
+    if (this.operation !== undefined) {
+      return Promise.reject(new Error("Another session operation is already running."));
+    }
+    const pending = operation().finally(() => {
+      if (this.operation === pending) {
+        this.operation = undefined;
+      }
+    });
+    this.operation = pending;
+    return pending;
+  }
+}
+
+export function createLocalSessionBinding<View>(input: {
+  runtimeSession: RuntimeSession;
+  modelName: string;
+  workspaceRoot: string;
+  profileName?: string;
+  projectionStore: View;
+}): OwnedSessionBinding<View> {
+  return {
+    runtimeSession: input.runtimeSession,
+    client: {
+      sessionId: input.runtimeSession.sessionId,
+      modelName: input.modelName,
+      workspaceRoot: input.workspaceRoot,
+      profileName: input.profileName,
+      projectionStore: input.projectionStore,
+      readLastResponse: () =>
+        readLastAssistantResponse({
+          workspaceRoot: input.workspaceRoot,
+          sessionId: input.runtimeSession.sessionId,
+        }),
+      skills: () => input.runtimeSession.skills(),
+      mcp: () => input.runtimeSession.mcp(),
+      reasoningEffort: () => input.runtimeSession.reasoningEffort(),
+      setReasoningEffort: async (effort) =>
+        input.runtimeSession.setReasoningEffort(effort),
+      resetReasoningEffort: async () => input.runtimeSession.resetReasoningEffort(),
+      supportsImageInput: () => input.runtimeSession.supportsImageInput(),
+      importImage: (sourcePath, signal, prospectiveMessageImageCount) =>
+        input.runtimeSession.importImage(
+          sourcePath,
+          signal,
+          prospectiveMessageImageCount,
+        ),
+      verifyImageAssets: (assets, signal) =>
+        input.runtimeSession.verifyImageAssets(assets, signal),
+      admitTurn: (userMessage, signal) =>
+        input.runtimeSession.admitTurn({ userMessage, signal }),
+      executeTurn: (userMessage, signal) =>
+        input.runtimeSession.executeTurn({
+          userMessage,
+          signal,
+        } satisfies ExecuteTurnInput),
+      promptScheduler: () => input.runtimeSession.promptScheduler(),
+      subscribePromptScheduler: (listener) =>
+        input.runtimeSession.subscribePromptScheduler(listener),
+      queueFollowUp: async (userMessage) =>
+        input.runtimeSession.queueFollowUp(userMessage),
+      bashGuard: () => input.runtimeSession.bashGuard(),
+      subscribeBashGuard: (listener) =>
+        input.runtimeSession.subscribeBashGuard(listener),
+      setYoloMode: async (enabled) => input.runtimeSession.setYoloMode(enabled),
+      resolveBashConfirmation: (decision) =>
+        input.runtimeSession.resolveBashConfirmation(decision),
+      providerRetry: () => input.runtimeSession.providerRetry(),
+      subscribeProviderRetry: (listener) =>
+        input.runtimeSession.subscribeProviderRetry(listener),
+      resolveProviderRetry: (requestId, decision) =>
+        input.runtimeSession.resolveProviderRetry(requestId, decision),
+      askUser: () => input.runtimeSession.askUser(),
+      subscribeAskUser: (listener) => input.runtimeSession.subscribeAskUser(listener),
+      resolveAskUser: (response) => input.runtimeSession.resolveAskUser(response),
+    },
+  };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}