tinker-agent 2.13.0 → 3.0.0

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);
+}

package/src/client/model-catalog.ts

@@ -0,0 +1,15 @@
+import type { ModelProfile } from "../cli/model-profiles";
+
+/** Display data only. Provider endpoints and credentials never cross the client boundary. */
+export type ClientModelProfile = Pick<
+  ModelProfile,
+  "name" | "model" | "contextWindowTokens" | "maxSupportedOutputTokens"
+>;
+export type ClientModelCatalog = {
+  defaultProfile: string;
+  profiles: readonly ClientModelProfile[];
+};
+export type ClientModelProfiles = {
+  defaultProfile: string;
+  profiles: ReadonlyMap<string, ClientModelProfile>;
+};

package/src/client/remote-images.ts

@@ -0,0 +1,80 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import path from "node:path";
+import { IMAGE_INPUT_POLICY } from "../image/image-input-policy";
+import { probeImageBytes } from "../image/image-probe";
+import type { ImportedImageAsset } from "../image/image-asset-store";
+import type { ImageAssetRef } from "../image/image-types";
+import type { RemoteClient } from "../remote/client";
+
+/** Relative @-mentions name service workspace files; absolute paths name client files. */
+export class RemoteImages {
+  constructor(
+    private readonly transport: RemoteClient,
+    private readonly sessionId: string,
+    private readonly lifetime: AbortSignal,
+  ) {}
+  async import(
+    sourcePath: string,
+    signal: AbortSignal,
+    count: number,
+  ): Promise<ImportedImageAsset> {
+    const combined = AbortSignal.any([signal, this.lifetime]);
+    combined.throwIfAborted();
+    if (!path.isAbsolute(sourcePath))
+      return this.transport.request(
+        `/v1/sessions/${this.sessionId}/images`,
+        { sourcePath, count },
+        combined,
+      );
+    const stat = await lstat(sourcePath);
+    if (
+      !stat.isFile() ||
+      stat.isSymbolicLink() ||
+      stat.size < 1 ||
+      stat.size > IMAGE_INPUT_POLICY.maxBytesPerImage
+    )
+      throw new Error(
+        "Image must be a regular non-symlink file within the image size limit.",
+      );
+    const file = await open(sourcePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    let bytes: Buffer;
+    try {
+      const opened = await file.stat();
+      if (opened.dev !== stat.dev || opened.ino !== stat.ino || !opened.isFile())
+        throw new Error("Image file changed while opening.");
+      // A bounded read also protects against a file growing after stat().
+      bytes = Buffer.alloc(IMAGE_INPUT_POLICY.maxBytesPerImage + 1);
+      let used = 0;
+      while (used < bytes.length) {
+        combined.throwIfAborted();
+        const read = await file.read(bytes, used, bytes.length - used, used);
+        if (read.bytesRead === 0) break;
+        used += read.bytesRead;
+      }
+      bytes = bytes.subarray(0, used);
+    } finally {
+      await file.close();
+    }
+    await probeImageBytes(bytes, {
+      fullDecode: true,
+      sourceName: path.basename(sourcePath),
+    });
+    return this.transport.request(
+      `/v1/sessions/${this.sessionId}/images`,
+      {
+        bytes: bytes.toString("base64"),
+        originalName: path.basename(sourcePath),
+        count,
+      },
+      combined,
+    );
+  }
+  async verify(assets: readonly ImageAssetRef[], signal: AbortSignal): Promise<void> {
+    await this.transport.request(
+      `/v1/sessions/${this.sessionId}/verify-images`,
+      { assets },
+      AbortSignal.any([signal, this.lifetime]),
+    );
+  }
+}