@tanstack/ai-sandbox 0.1.0

package/src/remote-tools.ts

@@ -0,0 +1,180 @@
+/**
+ * Host-tool delegation for the CO-LOCATED ("combined") sandbox model.
+ *
+ * In the co-located model the harness loop AND its MCP tool-bridge run INSIDE
+ * the container (the in-container sandbox is just `local-process`, so the
+ * existing adapter + `nodeHttpBridgeProvisioner` serve the bridge on the
+ * container's own `localhost` with native stdin — nothing new there). The one
+ * thing that still must cross the container→orchestrator boundary is the
+ * **execution** of `chat()`-provided server tools: their `execute()` closures
+ * (DB / secrets / app state) live in the orchestrator, not the container.
+ *
+ * This module is that narrow seam:
+ * - {@link remoteToolStubs} (container side) rebuilds `chat()` tools from
+ *   serialized {@link ToolDescriptor}s; each stub's `execute` delegates to a
+ *   {@link RemoteToolExecutor} instead of running locally. The adapter bridges
+ *   these stubs exactly like real tools.
+ * - {@link httpRemoteToolExecutor} (container side) is the default executor: it
+ *   POSTs `{ name, args }` to the orchestrator's tool-exec endpoint.
+ * - {@link executeHostTool} (orchestrator side) runs the REAL tool and returns
+ *   its raw result — the only host code the container can reach.
+ *
+ * So the public network surface shrinks from "the whole MCP protocol" (served
+ * from the orchestrator in the DO-drives-container model) to "one authenticated
+ * tool-exec call" — the MCP transport itself never leaves the container.
+ */
+import type { AnyTool } from '@tanstack/ai'
+import type { ToolDescriptor } from './tool-bridge'
+
+/** Per-call options forwarded to a {@link RemoteToolExecutor}. */
+export interface RemoteToolExecuteOptions {
+  /** Cancels the in-flight remote call when the in-container run aborts. */
+  signal?: AbortSignal
+}
+
+/** Runs a named host tool with the given args, returning its raw result. */
+export interface RemoteToolExecutor {
+  execute: (
+    name: string,
+    args: unknown,
+    options?: RemoteToolExecuteOptions,
+  ) => Promise<unknown>
+}
+
+/** Wire shape of a tool-exec request the container POSTs to the orchestrator. */
+export interface ToolExecRequest {
+  name: string
+  args: unknown
+}
+
+/** Narrow an unknown body into a {@link ToolExecRequest} (project rule: no `as`). */
+export function isToolExecRequest(value: unknown): value is ToolExecRequest {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'name' in value &&
+    typeof value.name === 'string'
+  )
+}
+
+/**
+ * Rebuild `chat()` tool objects (container side) from serialized descriptors.
+ * Each stub advertises the descriptor's JSON-schema and delegates `execute` to
+ * the executor; the harness adapter bridges them like any other tool. The
+ * harness's `abortSignal` is forwarded so a cancelled run cancels the in-flight
+ * remote call too.
+ */
+export function remoteToolStubs(
+  descriptors: Array<ToolDescriptor>,
+  executor: RemoteToolExecutor,
+): Array<AnyTool> {
+  return descriptors.map((descriptor) => ({
+    name: descriptor.name,
+    description: descriptor.description ?? '',
+    inputSchema: descriptor.inputSchema,
+    execute: (args: unknown, options?: { abortSignal?: AbortSignal }) =>
+      executor.execute(
+        descriptor.name,
+        args,
+        options?.abortSignal !== undefined
+          ? { signal: options.abortSignal }
+          : {},
+      ),
+  }))
+}
+
+/**
+ * Serialize `chat()` tools to wire descriptors to send into the container.
+ * `inputSchema` must already be a plain JSON-schema object (convert Standard
+ * Schemas before calling, the same way harness adapters advertise tools).
+ */
+export function toolDescriptors(tools: Array<AnyTool>): Array<ToolDescriptor> {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: isJsonSchemaObject(tool.inputSchema)
+      ? tool.inputSchema
+      : { type: 'object', properties: {} },
+  }))
+}
+
+function isJsonSchemaObject(
+  value: unknown,
+): value is { type: 'object'; [key: string]: unknown } {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'type' in value &&
+    (value as { type?: unknown }).type === 'object'
+  )
+}
+
+/** Wire shape of a tool-exec response from the orchestrator. */
+interface ToolExecResponse {
+  result: unknown
+}
+
+function isToolExecResponse(value: unknown): value is ToolExecResponse {
+  return value !== null && typeof value === 'object' && 'result' in value
+}
+
+/**
+ * The default {@link RemoteToolExecutor}: POST `{ name, args }` (bearer-gated)
+ * to the orchestrator's tool-exec endpoint and return its `result`. A non-2xx
+ * or malformed response throws (surfaced to the agent as a failed tool call by
+ * the bridge) — never silently swallowed.
+ */
+export function httpRemoteToolExecutor(
+  url: string,
+  token: string,
+): RemoteToolExecutor {
+  return {
+    async execute(name, args, options) {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ name, args }),
+        ...(options?.signal !== undefined ? { signal: options.signal } : {}),
+      })
+      if (!res.ok) {
+        const text = await res.text()
+        throw new Error(
+          `remote tool "${name}" failed: ${res.status} ${text.slice(0, 200)}`,
+        )
+      }
+      const body: unknown = await res.json()
+      if (!isToolExecResponse(body)) {
+        throw new Error(
+          `remote tool "${name}": malformed orchestrator response`,
+        )
+      }
+      return body.result
+    },
+  }
+}
+
+/**
+ * Run a host tool by name with the given args, returning its raw result
+ * (orchestrator side of {@link httpRemoteToolExecutor}). Throws for an unknown
+ * tool or one with no `execute` — the orchestrator surfaces that as a 4xx/5xx.
+ */
+export function executeHostTool(
+  tools: Array<AnyTool>,
+  name: string,
+  args: unknown,
+  options: { context?: unknown; signal?: AbortSignal } = {},
+): Promise<unknown> {
+  const tool = tools.find((candidate) => candidate.name === name)
+  if (!tool?.execute) {
+    return Promise.reject(new Error(`Unknown tool: ${name}`))
+  }
+  return Promise.resolve(
+    tool.execute(args ?? {}, {
+      context: options.context,
+      abortSignal: options.signal,
+    }),
+  )
+}

package/src/run-log.ts

@@ -0,0 +1,224 @@
+/**
+ * Resumable run event-log — the primitive that lets a trigger (e.g. a
+ * Cloudflare Worker) start an agent run and return immediately while a durable
+ * orchestrator (e.g. a Durable Object) drives the run and persists every
+ * emitted {@link StreamChunk} under a monotonic `seq`.
+ *
+ * Clients tail the log from a cursor (`fromSeq`), so a dropped connection, a new
+ * browser tab, or an orchestrator that hibernated between chunks all reconnect
+ * cleanly: replay everything after the client's last-seen `seq`, then live-tail
+ * until the run reaches a terminal status. The *run* never depends on any single
+ * connection staying open — that is what makes the serverless/edge model work.
+ *
+ * This module is transport- and storage-agnostic. {@link InMemoryRunEventLog} is
+ * the default (single-process / tests); a durable backend (DO storage, KV, SQL)
+ * implements the same {@link RunEventLog} interface — see the Cloudflare example.
+ */
+import type { StreamChunk } from '@tanstack/ai'
+
+/** A terminal run status: no further events will be appended. */
+export type TerminalRunStatus = 'done' | 'error' | 'aborted'
+
+/** Lifecycle status of a run. `done`/`error`/`aborted` are terminal. */
+export type RunStatus = 'running' | TerminalRunStatus
+
+const TERMINAL: ReadonlySet<RunStatus> = new Set<RunStatus>([
+  'done',
+  'error',
+  'aborted',
+])
+
+/** Whether a run status is terminal (no further events will be appended). */
+export function isTerminalRunStatus(status: RunStatus): boolean {
+  return TERMINAL.has(status)
+}
+
+export interface RunError {
+  message: string
+  code?: string
+}
+
+/** Durable bookkeeping for a single run. */
+export interface RunRecord {
+  runId: string
+  threadId?: string
+  status: RunStatus
+  /** Seq of the last appended event, or `-1` when no events yet. */
+  lastSeq: number
+  error?: RunError
+  createdAt: number
+  updatedAt: number
+}
+
+/** One persisted event: a chunk plus its monotonic, gap-free sequence number. */
+export interface RunEvent {
+  seq: number
+  chunk: StreamChunk
+}
+
+export interface RunEventLogReadOptions {
+  /**
+   * Exclusive cursor: only events with `seq > fromSeq` are yielded. Pass the
+   * client's last-seen `seq` to resume; omit (or `-1`) to replay from the start.
+   */
+  fromSeq?: number
+  /** Stop tailing when this fires (e.g. the client disconnected). */
+  signal?: AbortSignal
+}
+
+/**
+ * Append-only, `seq`-indexed log of a run's stream, with resumable reads.
+ *
+ * Contract:
+ * - `append` assigns the next `seq` (0, 1, 2, …) and returns it.
+ * - `read` yields the backlog after `fromSeq` in order, then live-tails new
+ *   events, and RETURNS once the run is terminal and the cursor has caught up.
+ * - All methods reject for an unknown `runId` except `get`, which resolves null.
+ */
+export interface RunEventLog {
+  /** Idempotently create (or return) the run record. */
+  open: (input: { runId: string; threadId?: string }) => Promise<RunRecord>
+  /** Append one chunk; resolves with its assigned `seq`. */
+  append: (runId: string, chunk: StreamChunk) => Promise<number>
+  /** Move the run to a terminal status. Idempotent for the same status. */
+  finish: (
+    runId: string,
+    status: TerminalRunStatus,
+    error?: RunError,
+  ) => Promise<void>
+  /** Current record, or null if the run is unknown. */
+  get: (runId: string) => Promise<RunRecord | null>
+  /** Replay-then-tail events with `seq > fromSeq` until the run is terminal. */
+  read: (
+    runId: string,
+    options?: RunEventLogReadOptions,
+  ) => AsyncIterable<RunEvent>
+}
+
+/** Per-run state for the in-memory log. */
+interface RunState {
+  record: RunRecord
+  chunks: Array<StreamChunk>
+  /** Resolved (and cleared) whenever an event is appended or status changes. */
+  waiters: Set<() => void>
+}
+
+/**
+ * Single-process {@link RunEventLog}. Backs `read`'s live-tail with an internal
+ * waiter set: `append`/`finish` wake every blocked reader. Suitable for a
+ * long-running Node host, tests, and as the reference implementation a durable
+ * backend mirrors.
+ */
+export class InMemoryRunEventLog implements RunEventLog {
+  private readonly runs = new Map<string, RunState>()
+
+  private now(): number {
+    return Date.now()
+  }
+
+  private require(runId: string): RunState {
+    const state = this.runs.get(runId)
+    if (!state) throw new Error(`run-log: unknown runId "${runId}"`)
+    return state
+  }
+
+  private wake(state: RunState): void {
+    const waiters = [...state.waiters]
+    state.waiters.clear()
+    for (const resolve of waiters) resolve()
+  }
+
+  // Mutators return a Promise without `async` so contract violations REJECT
+  // (rather than throwing synchronously from a Promise-typed method — a
+  // `.catch()` footgun) without an `await`-less async body.
+  open(input: { runId: string; threadId?: string }): Promise<RunRecord> {
+    const existing = this.runs.get(input.runId)
+    if (existing) return Promise.resolve({ ...existing.record })
+    const now = this.now()
+    const record: RunRecord = {
+      runId: input.runId,
+      ...(input.threadId !== undefined ? { threadId: input.threadId } : {}),
+      status: 'running',
+      lastSeq: -1,
+      createdAt: now,
+      updatedAt: now,
+    }
+    this.runs.set(input.runId, { record, chunks: [], waiters: new Set() })
+    return Promise.resolve({ ...record })
+  }
+
+  append(runId: string, chunk: StreamChunk): Promise<number> {
+    const state = this.runs.get(runId)
+    if (!state) {
+      return Promise.reject(new Error(`run-log: unknown runId "${runId}"`))
+    }
+    if (isTerminalRunStatus(state.record.status)) {
+      return Promise.reject(
+        new Error(
+          `run-log: cannot append to terminal run "${runId}" (status=${state.record.status})`,
+        ),
+      )
+    }
+    // Derive seq from the record's cursor (not `chunks.length`) so the gap-free
+    // invariant holds the same way the durable backend computes it, even if the
+    // backlog is ever trimmed/compacted.
+    const seq = state.record.lastSeq + 1
+    state.chunks.push(chunk)
+    state.record.lastSeq = seq
+    state.record.updatedAt = this.now()
+    this.wake(state)
+    return Promise.resolve(seq)
+  }
+
+  finish(
+    runId: string,
+    status: TerminalRunStatus,
+    error?: RunError,
+  ): Promise<void> {
+    const state = this.runs.get(runId)
+    if (!state) {
+      return Promise.reject(new Error(`run-log: unknown runId "${runId}"`))
+    }
+    if (isTerminalRunStatus(state.record.status)) return Promise.resolve()
+    state.record.status = status
+    if (error !== undefined) state.record.error = error
+    state.record.updatedAt = this.now()
+    this.wake(state)
+    return Promise.resolve()
+  }
+
+  get(runId: string): Promise<RunRecord | null> {
+    const state = this.runs.get(runId)
+    return Promise.resolve(state ? { ...state.record } : null)
+  }
+
+  async *read(
+    runId: string,
+    options?: RunEventLogReadOptions,
+  ): AsyncIterable<RunEvent> {
+    const state = this.require(runId)
+    const signal = options?.signal
+    let cursor = options?.fromSeq ?? -1
+    while (!signal?.aborted) {
+      while (cursor < state.record.lastSeq) {
+        cursor += 1
+        const chunk = state.chunks[cursor]
+        if (chunk !== undefined) yield { seq: cursor, chunk }
+      }
+      if (isTerminalRunStatus(state.record.status)) return
+      await this.waitForChange(state, signal)
+    }
+  }
+
+  private waitForChange(state: RunState, signal?: AbortSignal): Promise<void> {
+    return new Promise<void>((resolve) => {
+      const wake = (): void => {
+        state.waiters.delete(wake)
+        if (signal) signal.removeEventListener('abort', wake)
+        resolve()
+      }
+      state.waiters.add(wake)
+      if (signal) signal.addEventListener('abort', wake, { once: true })
+    })
+  }
+}

package/src/run.ts

@@ -0,0 +1,167 @@
+/**
+ * The "run driver" for the inverted/serverless sandbox model: pump a `chat()`
+ * stream into a {@link RunEventLog} so a trigger can return immediately while a
+ * durable orchestrator drives the run and clients tail from a cursor.
+ *
+ * The key inversion vs. a classic request/response handler: there is no caller
+ * holding the stream open, so nothing to throw an error *back to*. The log is
+ * the only channel — every chunk (including a terminal {@link EventType.RUN_ERROR})
+ * is persisted under a `seq`, and a thrown stream error is recorded as a
+ * synthesized `RUN_ERROR` event plus the record's `error` field. Tailing clients
+ * therefore always observe failures; {@link pipeToRunLog} never rejects.
+ */
+import { EventType } from '@tanstack/ai'
+import type { StreamChunk } from '@tanstack/ai'
+import type { RunError, RunEvent, RunEventLog, RunRecord } from './run-log'
+
+/** Whether a chunk is the terminal error event the chat engine emits. */
+function isRunErrorChunk(
+  chunk: StreamChunk,
+): chunk is StreamChunk & { message: string; code?: string } {
+  return chunk.type === EventType.RUN_ERROR
+}
+
+/** Pull `{ message, code }` off a RUN_ERROR chunk for the run record. */
+function runErrorFromChunk(
+  chunk: StreamChunk & { message: string; code?: string },
+): RunError {
+  return chunk.code !== undefined
+    ? { message: chunk.message, code: chunk.code }
+    : { message: chunk.message }
+}
+
+/** Render an unknown thrown value as a stable error message. */
+function messageOf(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/** Build the synthetic RUN_ERROR chunk appended when the stream throws. */
+function syntheticRunError(message: string): StreamChunk {
+  const chunk: { type: EventType.RUN_ERROR; message: string } = {
+    type: EventType.RUN_ERROR,
+    message,
+  }
+  return chunk
+}
+
+export interface PipeToRunLogOptions {
+  log: RunEventLog
+  runId: string
+  threadId?: string
+  /** Abort consumption mid-stream; the run finishes as `aborted`. */
+  signal?: AbortSignal
+}
+
+/**
+ * Open the run, append every chunk from `stream`, and finish with the right
+ * terminal status. Resolves with the final {@link RunRecord} and never rejects:
+ * a thrown stream error is surfaced as a `RUN_ERROR` event + the record's
+ * `error`, which is what tailing clients see.
+ *
+ * - normal completion → `finish('done')`
+ * - a `RUN_ERROR` chunk → append it, then `finish('error', { message, code })`
+ * - the stream throws → append a synthesized `RUN_ERROR`, then `finish('error')`
+ * - `signal` aborts mid-stream → stop consuming, `finish('aborted')`
+ */
+export async function pipeToRunLog(
+  stream: AsyncIterable<StreamChunk>,
+  opts: PipeToRunLogOptions,
+): Promise<RunRecord> {
+  const { log, runId, threadId, signal } = opts
+  await log.open(threadId !== undefined ? { runId, threadId } : { runId })
+  if (signal?.aborted) {
+    await log.finish(runId, 'aborted')
+    return reread(log, runId)
+  }
+
+  try {
+    for await (const chunk of stream) {
+      if (signal?.aborted) {
+        await log.finish(runId, 'aborted')
+        return reread(log, runId)
+      }
+      await log.append(runId, chunk)
+      if (isRunErrorChunk(chunk)) {
+        await log.finish(runId, 'error', runErrorFromChunk(chunk))
+        return reread(log, runId)
+      }
+    }
+  } catch (error) {
+    // Detached run: no caller to throw to. Record the failure in the log so
+    // tailing clients observe it, then return — do NOT rethrow.
+    const message = messageOf(error)
+    await log.append(runId, syntheticRunError(message))
+    await log.finish(runId, 'error', { message })
+    return reread(log, runId)
+  }
+
+  await log.finish(runId, 'done')
+  return reread(log, runId)
+}
+
+/** Re-read the now-terminal record; the run was just driven, so it must exist. */
+async function reread(log: RunEventLog, runId: string): Promise<RunRecord> {
+  const latest = await log.get(runId)
+  if (!latest) throw new Error(`run: record for "${runId}" vanished mid-run`)
+  return latest
+}
+
+export interface RunControllerStartInput {
+  runId: string
+  threadId?: string
+  stream: AsyncIterable<StreamChunk>
+  /** Abort consumption mid-stream; the run finishes as `aborted`. */
+  signal?: AbortSignal
+}
+
+export interface RunHandle {
+  runId: string
+  /** Resolves with the final record once the run reaches a terminal status. */
+  done: Promise<RunRecord>
+}
+
+/**
+ * Thin orchestration helper over a {@link RunEventLog}: fire-and-track a run via
+ * {@link pipeToRunLog}, tail it from a cursor, and `drain()` all in-flight runs
+ * (e.g. inside a `ctx.waitUntil`). Holds no run state of its own beyond the set
+ * of currently in-flight `done` promises.
+ */
+export class RunController {
+  private readonly inFlight = new Set<Promise<RunRecord>>()
+
+  constructor(private readonly log: RunEventLog) {}
+
+  /**
+   * Kick off `pipeToRunLog` without awaiting it and return the `runId`
+   * immediately plus a `done` promise the orchestrator may await or detach.
+   */
+  start(input: RunControllerStartInput): RunHandle {
+    const done = pipeToRunLog(input.stream, {
+      log: this.log,
+      runId: input.runId,
+      ...(input.threadId !== undefined ? { threadId: input.threadId } : {}),
+      ...(input.signal !== undefined ? { signal: input.signal } : {}),
+    })
+    this.inFlight.add(done)
+    void done.finally(() => this.inFlight.delete(done))
+    return { runId: input.runId, done }
+  }
+
+  /** Resumable client tail — replay from `fromSeq`, then live-tail to terminal. */
+  attach(
+    runId: string,
+    opts?: { fromSeq?: number; signal?: AbortSignal },
+  ): AsyncIterable<RunEvent> {
+    return this.log.read(runId, opts)
+  }
+
+  /** Current run record, or null if the run is unknown. */
+  status(runId: string): Promise<RunRecord | null> {
+    return this.log.get(runId)
+  }
+
+  /** Await every currently in-flight run's `done` promise. */
+  async drain(): Promise<void> {
+    await Promise.all([...this.inFlight])
+  }
+}

package/src/runner.ts

@@ -0,0 +1,99 @@
+/**
+ * The reusable "run an agent CLI inside a sandbox and stream its events out"
+ * primitive. Harness adapters (claude-code, codex, …) spawn their CLI via the
+ * uniform {@link SandboxHandle} and consume newline-delimited JSON from stdout,
+ * which they then translate into AG-UI StreamChunks.
+ *
+ * This is intentionally transport-minimal: a stdout NDJSON pipe. Multi-client
+ * reconnect / replay belongs to the persistence/EventLog layer, not here.
+ */
+import type { ProcessOptions, SandboxHandle } from './contracts'
+
+export interface SpawnNdjsonOptions extends ProcessOptions {
+  /**
+   * Called for each raw stdout line that is non-empty but fails JSON parsing
+   * (e.g. a CLI banner). Defaults to ignoring it. Stderr is never parsed.
+   */
+  onNonJsonLine?: (line: string) => void
+  /**
+   * Written to the process stdin (then stdin is closed) right after spawn —
+   * e.g. the agent prompt for `claude -p`. Avoids putting the prompt in argv.
+   */
+  input?: string
+}
+
+/** Split a stream of arbitrary string chunks into complete lines. */
+export async function* toLines(
+  chunks: AsyncIterable<string>,
+): AsyncIterable<string> {
+  let buffer = ''
+  for await (const chunk of chunks) {
+    buffer += chunk
+    let newlineIndex = buffer.indexOf('\n')
+    while (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex)
+      buffer = buffer.slice(newlineIndex + 1)
+      yield line
+      newlineIndex = buffer.indexOf('\n')
+    }
+  }
+  if (buffer.length > 0) yield buffer
+}
+
+/**
+ * Spawn `command` in the sandbox and yield each stdout line parsed as JSON.
+ * Resolves the spawn handle's exit via `wait()` after stdout closes; a non-zero
+ * exit with no events surfaced is the adapter's concern to detect.
+ */
+export async function* spawnNdjson(
+  handle: SandboxHandle,
+  command: string,
+  options: SpawnNdjsonOptions = {},
+): AsyncIterable<unknown> {
+  const { onNonJsonLine, input, ...processOptions } = options
+  const proc = await handle.process.spawn(command, processOptions)
+
+  if (input !== undefined) {
+    await proc.stdin.write(input)
+    await proc.stdin.end()
+  }
+
+  // Drain stderr concurrently. A CLI that fails before producing stdout (a
+  // broken install, an auth/permission refusal, …) prints to stderr and exits
+  // non-zero; without this, stdout-only parsing yields nothing and the failure
+  // vanishes. Capturing it lets us surface the cause below.
+  const stderrChunks: Array<string> = []
+  const stderrDrained = (async () => {
+    try {
+      for await (const chunk of proc.stderr) stderrChunks.push(chunk)
+    } catch {
+      // stderr stream torn down — use whatever was captured
+    }
+  })()
+
+  for await (const line of toLines(proc.stdout)) {
+    const trimmed = line.trim()
+    if (trimmed === '') continue
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(trimmed)
+    } catch {
+      onNonJsonLine?.(trimmed)
+      continue
+    }
+    yield parsed
+  }
+
+  const exitCode = await proc.wait()
+  await stderrDrained
+  // A non-zero exit means the agent CLI itself failed. Throw so the adapter's
+  // catch turns it into a RUN_ERROR the UI can show, instead of ending the
+  // stream silently with no events.
+  if (exitCode !== 0) {
+    const stderr = stderrChunks.join('').trim()
+    throw new Error(
+      `Agent process exited with code ${exitCode}` +
+        (stderr ? `: ${stderr.slice(0, 1000)}` : ''),
+    )
+  }
+}