@the-open-engine/zeroshot 6.30.1 → 6.31.0

package/src/agent-cli-provider/omp/rpc-driver-dispatch.ts

@@ -0,0 +1,177 @@
+import { MAX_PENDING_REQUESTS } from './rpc-bounds';
+import {
+  DEFAULT_OMP_RPC_DECODER_LIMITS,
+  OmpRpcProtocolError,
+  assertNoPreNegotiationRpcChunk,
+  type OmpRpcInboundFrame,
+} from './rpc-protocol';
+import { normalizeOmpRpcFrame } from './rpc-events';
+import { getArray, getBoolean, getNumber, getRecord, getString } from '../json';
+import type { OmpRpcChannel } from './rpc-driver-channel';
+import {
+  OmpRpcTaskFailure,
+  sessionEvidenceFromState,
+  sessionFieldsFromRecord,
+  type DriverState,
+  type OmpRpcTaskHooks,
+  type OmpRpcTaskRequest,
+} from './rpc-driver-state';
+import type { OutputEvent } from '../types';
+
+interface DispatchContext {
+  readonly request: OmpRpcTaskRequest;
+  readonly hooks: OmpRpcTaskHooks;
+  readonly state: DriverState;
+  readonly channel: OmpRpcChannel;
+  readonly spawnHook: Promise<void>;
+  readonly pushEvent: (event: OutputEvent) => void;
+  readonly fail: (stopReason: string, message: string) => void;
+  readonly agentEnd: () => void;
+}
+
+export class OmpRpcDispatcher {
+  constructor(private readonly context: DispatchContext) {}
+
+  enqueue(frame: OmpRpcInboundFrame): void {
+    const { state } = this.context;
+    if (state.queuedFrames >= MAX_PENDING_REQUESTS) {
+      this.context.fail(
+        'pending-request-exceeded',
+        `More than ${MAX_PENDING_REQUESTS} RPC frames are queued awaiting dispatch.`
+      );
+      return;
+    }
+    state.queuedFrames += 1;
+    state.chain = state.chain
+      .then(() => this.dispatchFrame(frame))
+      .catch((error: unknown) => this.failFrom(error))
+      .finally(() => {
+        state.queuedFrames -= 1;
+      });
+  }
+
+  private failFrom(error: unknown): void {
+    if (error instanceof OmpRpcProtocolError) this.context.fail(error.code, error.message);
+    else if (error instanceof OmpRpcTaskFailure) {
+      this.context.fail(error.stopReason, error.message);
+    } else {
+      this.context.fail('driver-error', error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  private dispatchReadyFrame(frame: OmpRpcInboundFrame): void {
+    const { state } = this.context;
+    state.readyReceived = true;
+    if (frame.type !== 'ready') {
+      throw new OmpRpcTaskFailure(
+        'unsupported-protocol',
+        `Expected an initial ready frame, got "${frame.type}".`
+      );
+    }
+    const supportedVersions = getArray(frame, 'supportedProtocolVersions');
+    if (!supportedVersions.includes(2)) {
+      throw new OmpRpcTaskFailure(
+        'unsupported-protocol',
+        `OMP ready frame did not advertise protocol v2 (supportedProtocolVersions=${JSON.stringify(supportedVersions)}).`
+      );
+    }
+    const maxFrameBytes = getNumber(frame, 'maxFrameBytes');
+    const maxReassembledFrameBytes = getNumber(frame, 'maxReassembledFrameBytes');
+    if (
+      maxFrameBytes === null ||
+      maxFrameBytes > DEFAULT_OMP_RPC_DECODER_LIMITS.maxPhysicalFrameBytes ||
+      maxReassembledFrameBytes === null ||
+      maxReassembledFrameBytes > DEFAULT_OMP_RPC_DECODER_LIMITS.maxReassembledFrameBytes
+    ) {
+      throw new OmpRpcTaskFailure(
+        'unsupported-limits',
+        `OMP ready frame advertised limits above the pinned decoder caps (maxFrameBytes=${String(maxFrameBytes)}, maxReassembledFrameBytes=${String(maxReassembledFrameBytes)}).`
+      );
+    }
+    void this.negotiateAndPrompt().catch((error: unknown) => this.failFrom(error));
+  }
+
+  private async negotiateAndPrompt(): Promise<void> {
+    const { state, request, hooks, channel } = this.context;
+    await this.context.spawnHook;
+    if (state.settled) return;
+    const negotiateResponse = await channel.sendCommand({
+      id: 'zs-1',
+      type: 'negotiate_protocol',
+      protocolVersion: 2,
+    });
+    channel.assertSuccessfulResponse(negotiateResponse, 'negotiate_protocol', 'zs-1');
+    state.negotiatedV2 = true;
+
+    const stateResponse = await channel
+      .sendCommand({ id: 'zs-state', type: 'get_state' })
+      .catch(() => null);
+    state.sessionEvidence = sessionEvidenceFromState(stateResponse);
+    await hooks.onSession({ ...state.sessionEvidence, phase: 'ready' });
+
+    state.promptSent = true;
+    const ack = await channel.sendCommand({ id: 'zs-2', type: 'prompt', message: request.prompt });
+    channel.assertSuccessfulResponse(ack, 'prompt', 'zs-2');
+    const data = getRecord(ack, 'data');
+    if (data !== null && getBoolean(data, 'agentInvoked') === false) {
+      throw new OmpRpcTaskFailure(
+        'local-only-prompt',
+        'OMP resolved the prompt without invoking the agent (no agent turn).'
+      );
+    }
+  }
+
+  private handlePromptResultFrame(frame: OmpRpcInboundFrame): void {
+    if (getString(frame, 'id') !== 'zs-2') return;
+    if (getBoolean(frame, 'agentInvoked') === true) return;
+    throw new OmpRpcTaskFailure(
+      'local-only-prompt',
+      'OMP resolved the prompt without invoking the agent (no agent turn).'
+    );
+  }
+
+  private handleSessionInfoUpdate(frame: OmpRpcInboundFrame): Promise<void> | void {
+    const updates = sessionFieldsFromRecord(frame);
+    if (Object.keys(updates).length === 0) return;
+    const { state, hooks } = this.context;
+    state.sessionEvidence = { ...state.sessionEvidence, ...updates };
+    return hooks.onSession({ ...state.sessionEvidence, phase: 'ready' });
+  }
+
+  private dispatchFrame(frame: OmpRpcInboundFrame): void | Promise<void> {
+    const { state, channel } = this.context;
+    if (state.terminal) return;
+    if (!state.readyReceived) return this.dispatchReadyFrame(frame);
+    assertNoPreNegotiationRpcChunk(frame.type, state.negotiatedV2);
+    switch (frame.type) {
+      case 'response':
+        return channel.handleResponse(frame);
+      case 'extension_ui_request':
+        return channel.handleExtensionUiRequest(frame);
+      case 'host_tool_call':
+        return channel.handleHostToolCall(frame);
+      case 'host_uri_request':
+        return channel.handleHostUriRequest(frame);
+      case 'host_tool_cancel':
+      case 'host_uri_cancel':
+        return;
+      case 'extension_error':
+        throw new OmpRpcTaskFailure(
+          'extension-error',
+          getString(frame, 'error') ?? 'OMP extension runner reported an error.'
+        );
+      case 'prompt_result':
+        return this.handlePromptResultFrame(frame);
+      case 'agent_end':
+        return this.context.agentEnd();
+      case 'session_info_update':
+        return this.handleSessionInfoUpdate(frame);
+      default:
+        if (state.promptSent) {
+          for (const event of normalizeOmpRpcFrame(frame, state.eventState)) {
+            this.context.pushEvent(event);
+          }
+        }
+    }
+  }
+}

package/src/agent-cli-provider/omp/rpc-driver-runner.ts

@@ -0,0 +1,199 @@
+import { spawn } from 'node:child_process';
+
+import { omitProcessControlEnv, omitUnsafeProviderEnv } from '../env-safety';
+import { MAX_STDERR_TAIL_BYTES } from './rpc-bounds';
+import { OmpRpcProtocolError } from './rpc-protocol';
+import { OmpRpcChannel } from './rpc-driver-channel';
+import { OmpRpcDispatcher } from './rpc-driver-dispatch';
+import {
+  OmpRpcTaskFailure,
+  createDriverState,
+  type OmpRpcTaskHooks,
+  type OmpRpcTaskRequest,
+  type OmpRpcTaskResult,
+} from './rpc-driver-state';
+import type { OutputEvent } from '../types';
+
+export function runOmpRpcTask(
+  request: OmpRpcTaskRequest,
+  hooks: OmpRpcTaskHooks
+): Promise<OmpRpcTaskResult> {
+  return new Promise<OmpRpcTaskResult>((resolvePromise, rejectPromise) => {
+    const { commandSpec } = request;
+    const state = createDriverState();
+    const child = spawn(commandSpec.binary, [...commandSpec.args], {
+      shell: false,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...(commandSpec.cwd === undefined ? {} : { cwd: commandSpec.cwd }),
+      detached: process.platform !== 'win32',
+      windowsHide: true,
+      env: { ...omitProcessControlEnv(process.env), ...omitUnsafeProviderEnv(commandSpec.env) },
+    });
+
+    let abortTimer: NodeJS.Timeout | undefined;
+    let timeoutTimer: NodeJS.Timeout | undefined;
+    const clearTimers = (): void => {
+      if (abortTimer !== undefined) clearTimeout(abortTimer);
+      if (timeoutTimer !== undefined) clearTimeout(timeoutTimer);
+    };
+    const deriveStopReason = (): string => {
+      const lastResult = [...state.events].reverse().find((event) => event.type === 'result');
+      return lastResult?.type === 'result' && lastResult.success === false
+        ? 'turn-failed'
+        : 'completed';
+    };
+    const finish = (stopReason: string): void => {
+      if (state.settled) return;
+      state.settled = true;
+      clearTimers();
+      resolvePromise({
+        events: state.events,
+        text: state.textParts.join(''),
+        session: { ...state.sessionEvidence, phase: 'terminal' },
+        stopReason,
+        exitCode: state.processExit?.exitCode ?? null,
+        signal: state.processExit?.signal ?? null,
+      });
+    };
+    const pushEvent = (event: OutputEvent): void => {
+      state.events.push(event);
+      if (event.type === 'text') state.textParts.push(event.text);
+      void hooks.onEvent(event).catch(() => {});
+    };
+    const hasExited = (): boolean => child.exitCode !== null || child.signalCode !== null;
+    const terminateOwnedBoundary = (): void => {
+      if (state.terminationStarted || child.pid === undefined || hasExited()) return;
+      state.terminationStarted = true;
+      const pid = child.pid;
+      try {
+        if (process.platform === 'win32') child.kill('SIGTERM');
+        else process.kill(-pid, 'SIGTERM');
+      } catch {
+        // Process may already be gone.
+      }
+      setTimeout(() => {
+        if (hasExited()) return;
+        try {
+          if (process.platform === 'win32') child.kill('SIGKILL');
+          else process.kill(-pid, 'SIGKILL');
+        } catch {
+          // Process may already be gone.
+        }
+      }, request.exitGraceMs);
+    };
+    const failPermanently = (stopReason: string, message: string): void => {
+      if (state.terminal) return;
+      state.terminal = true;
+      state.pendingStopReason = stopReason;
+      pushEvent({
+        type: 'result',
+        success: false,
+        result: null,
+        error: `${stopReason}: ${message}`,
+      });
+      terminateOwnedBoundary();
+    };
+
+    const spawnHookPromise = new Promise<void>((resolveSpawnHook) => {
+      child.once('spawn', () => {
+        const pid = child.pid;
+        if (pid === undefined) {
+          failPermanently('spawn-hook-failed', 'Process spawned without a pid.');
+          resolveSpawnHook();
+          return;
+        }
+        hooks
+          .onSpawn({
+            pid,
+            processGroupId: process.platform === 'win32' ? null : pid,
+            terminationStrategy: process.platform === 'win32' ? 'process-tree' : 'process-group',
+          })
+          .then(resolveSpawnHook, (error: unknown) => {
+            failPermanently(
+              'spawn-hook-failed',
+              error instanceof Error ? error.message : String(error)
+            );
+            resolveSpawnHook();
+          });
+      });
+    });
+
+    const channel = new OmpRpcChannel(child, state);
+    const agentEnd = (): void => {
+      if (state.terminal) return;
+      state.terminal = true;
+      state.pendingStopReason = deriveStopReason();
+      child.stdin.end();
+      setTimeout(terminateOwnedBoundary, request.exitGraceMs);
+    };
+    const dispatcher = new OmpRpcDispatcher({
+      request,
+      hooks,
+      state,
+      channel,
+      spawnHook: spawnHookPromise,
+      pushEvent,
+      fail: failPermanently,
+      agentEnd,
+    });
+
+    child.stdout.on('data', (chunk: Buffer) => {
+      try {
+        for (const frame of state.decoder.push(chunk, state.negotiatedV2))
+          dispatcher.enqueue(frame);
+      } catch (error) {
+        if (error instanceof OmpRpcProtocolError) failPermanently(error.code, error.message);
+        else
+          failPermanently('decoder-error', error instanceof Error ? error.message : String(error));
+      }
+    });
+    child.stderr.on('data', (chunk: Buffer) => {
+      state.stderrTail = (state.stderrTail + chunk.toString('utf8')).slice(-MAX_STDERR_TAIL_BYTES);
+    });
+    child.once('error', (error) => {
+      if (state.settled) return;
+      state.settled = true;
+      clearTimers();
+      rejectPromise(error);
+    });
+    child.once('close', (exitCode, signal) => {
+      state.processExit = { exitCode, signal: signal ?? null };
+      for (const command of state.pending.values()) {
+        command.reject(
+          new OmpRpcTaskFailure('process-closed', 'child process ended before a response arrived.')
+        );
+      }
+      state.pending.clear();
+      if (state.terminal) return finish(state.pendingStopReason ?? deriveStopReason());
+      state.terminal = true;
+      let detail: string;
+      try {
+        state.decoder.finish();
+        detail = `OMP process exited (code=${exitCode ?? 'null'}, signal=${signal ?? 'null'}) before a terminal RPC frame arrived.`;
+      } catch (error) {
+        detail = error instanceof OmpRpcProtocolError ? error.message : String(error);
+      }
+      if (state.stderrTail) detail += ` stderr: ${state.stderrTail}`;
+      const stopReason = state.abortStopReason ?? 'stream-ended-before-terminal';
+      pushEvent({
+        type: 'result',
+        success: false,
+        result: null,
+        error: `${stopReason}: ${detail}`,
+      });
+      finish(stopReason);
+    });
+
+    const beginAbort = (stopReason: string): void => {
+      if (state.settled || state.terminal || state.abortStopReason !== null) return;
+      state.abortStopReason = stopReason;
+      channel.writeFrame({ id: 'zs-abort', type: 'abort' });
+      abortTimer = setTimeout(() => {
+        if (!state.terminal) terminateOwnedBoundary();
+      }, request.abortGraceMs);
+    };
+    if (request.signal.aborted) beginAbort('cancelled');
+    else request.signal.addEventListener('abort', () => beginAbort('cancelled'), { once: true });
+    timeoutTimer = setTimeout(() => beginAbort('timeout'), request.timeoutMs);
+  });
+}

package/src/agent-cli-provider/omp/rpc-driver-state.ts

@@ -0,0 +1,165 @@
+import {
+  DEFAULT_OMP_RPC_DECODER_LIMITS,
+  OmpRpcFrameDecoder,
+  type OmpRpcCommand,
+} from './rpc-protocol';
+import { createOmpRpcEventState } from './rpc-events';
+import { getBoolean, getRecord, getString } from '../json';
+import type { OmpSessionLaunch } from './rpc-session';
+import type { CommandSpec, OutputEvent } from '../types';
+
+export interface OmpRpcSpawnEvidence {
+  readonly pid: number;
+  readonly processGroupId: number | null;
+  readonly terminationStrategy: 'process-group' | 'process-tree';
+}
+
+export interface OmpRpcSessionEvidence {
+  readonly phase: 'ready' | 'terminal';
+  readonly sessionId: string | null;
+  readonly sessionFile: string | null;
+  readonly selectedProvider: string;
+  readonly selectedModel: string;
+  readonly thinkingLevel: string;
+}
+
+export interface OmpRpcTaskRequest {
+  readonly commandSpec: CommandSpec;
+  readonly prompt: string;
+  readonly expectedVersion: string;
+  readonly session: OmpSessionLaunch;
+  readonly signal: AbortSignal;
+  readonly timeoutMs: number;
+  readonly abortGraceMs: number;
+  readonly exitGraceMs: number;
+}
+
+export interface OmpRpcTaskHooks {
+  readonly onSpawn: (evidence: OmpRpcSpawnEvidence) => Promise<void>;
+  readonly onEvent: (event: OutputEvent) => Promise<void>;
+  readonly onSession: (evidence: OmpRpcSessionEvidence) => Promise<void>;
+}
+
+export interface OmpRpcTaskResult {
+  readonly events: readonly OutputEvent[];
+  readonly text: string;
+  readonly session: OmpRpcSessionEvidence;
+  readonly stopReason: string;
+  readonly exitCode: number | null;
+  readonly signal: string | null;
+}
+
+export const UNKNOWN_SESSION_EVIDENCE: Omit<OmpRpcSessionEvidence, 'phase'> = {
+  sessionId: null,
+  sessionFile: null,
+  selectedProvider: '',
+  selectedModel: '',
+  thinkingLevel: '',
+};
+
+type UiResponder = (id: string) => OmpRpcCommand;
+
+// extension_ui_request method table (docs/rpc.md "Extension UI Sub-Protocol"). Zeroshot has no
+// interactive host surface, so every method resolves to a cancelled/no-op response instead of
+// blocking the child indefinitely.
+export const UI_RESPONDERS: Readonly<Record<string, UiResponder>> = {
+  confirm: (id) => ({ type: 'extension_ui_response', id, confirmed: false, cancelled: true }),
+  select: (id) => ({ type: 'extension_ui_response', id, cancelled: true }),
+  input: (id) => ({ type: 'extension_ui_response', id, cancelled: true }),
+  editor: (id) => ({ type: 'extension_ui_response', id, cancelled: true }),
+  open_url: (id) => ({ type: 'extension_ui_response', id, cancelled: true }),
+  notify: (id) => ({ type: 'extension_ui_response', id, cancelled: false }),
+  setStatus: (id) => ({ type: 'extension_ui_response', id, cancelled: false }),
+  setWidget: (id) => ({ type: 'extension_ui_response', id, cancelled: false }),
+  setTitle: (id) => ({ type: 'extension_ui_response', id, cancelled: false }),
+  set_editor_text: (id) => ({ type: 'extension_ui_response', id, cancelled: false }),
+  cancel: (id) => ({ type: 'extension_ui_response', id, cancelled: false }),
+};
+
+export class OmpRpcTaskFailure extends Error {
+  readonly stopReason: string;
+
+  constructor(stopReason: string, message: string) {
+    super(message);
+    this.name = 'OmpRpcTaskFailure';
+    this.stopReason = stopReason;
+  }
+}
+
+export interface PendingCommand {
+  readonly resolve: (frame: Record<string, unknown>) => void;
+  readonly reject: (error: Error) => void;
+}
+
+export interface DriverState {
+  readonly decoder: OmpRpcFrameDecoder;
+  readonly eventState: ReturnType<typeof createOmpRpcEventState>;
+  readonly pending: Map<string, PendingCommand>;
+  readonly lifetimeRequestIds: Set<string>;
+  queuedFrames: number;
+  readonly events: OutputEvent[];
+  readonly textParts: string[];
+  stderrTail: string;
+  negotiatedV2: boolean;
+  readyReceived: boolean;
+  promptSent: boolean;
+  terminal: boolean;
+  settled: boolean;
+  abortStopReason: string | null;
+  pendingStopReason: string | null;
+  terminationStarted: boolean;
+  sessionEvidence: Omit<OmpRpcSessionEvidence, 'phase'>;
+  processExit: { exitCode: number | null; signal: string | null } | null;
+  chain: Promise<void>;
+}
+
+export function createDriverState(): DriverState {
+  return {
+    decoder: new OmpRpcFrameDecoder(DEFAULT_OMP_RPC_DECODER_LIMITS),
+    eventState: createOmpRpcEventState(),
+    pending: new Map(),
+    lifetimeRequestIds: new Set(),
+    queuedFrames: 0,
+    events: [],
+    textParts: [],
+    stderrTail: '',
+    negotiatedV2: false,
+    readyReceived: false,
+    promptSent: false,
+    terminal: false,
+    settled: false,
+    abortStopReason: null,
+    pendingStopReason: null,
+    terminationStarted: false,
+    sessionEvidence: UNKNOWN_SESSION_EVIDENCE,
+    processExit: null,
+    chain: Promise.resolve(),
+  };
+}
+
+export function sessionFieldsFromRecord(
+  record: Record<string, unknown>
+): Partial<Pick<OmpRpcSessionEvidence, 'sessionId' | 'sessionFile'>> {
+  const sessionId = getString(record, 'sessionId');
+  const sessionFile = getString(record, 'sessionFile');
+  return {
+    ...(sessionId !== null ? { sessionId } : {}),
+    ...(sessionFile !== null ? { sessionFile } : {}),
+  };
+}
+
+export function sessionEvidenceFromState(
+  stateResponse: Record<string, unknown> | null
+): Omit<OmpRpcSessionEvidence, 'phase'> {
+  if (stateResponse === null || getBoolean(stateResponse, 'success') !== true)
+    return UNKNOWN_SESSION_EVIDENCE;
+  const data = getRecord(stateResponse, 'data');
+  const model = data ? getRecord(data, 'model') : null;
+  return {
+    ...UNKNOWN_SESSION_EVIDENCE,
+    ...(data ? sessionFieldsFromRecord(data) : {}),
+    selectedProvider: (model ? getString(model, 'provider') : null) ?? '',
+    selectedModel: (model ? getString(model, 'id') : null) ?? '',
+    thinkingLevel: (data ? getString(data, 'thinkingLevel') : null) ?? '',
+  };
+}

package/src/agent-cli-provider/omp/rpc-driver.ts

@@ -0,0 +1,8 @@
+export { runOmpRpcTask } from './rpc-driver-runner';
+export type {
+  OmpRpcSessionEvidence,
+  OmpRpcSpawnEvidence,
+  OmpRpcTaskHooks,
+  OmpRpcTaskRequest,
+  OmpRpcTaskResult,
+} from './rpc-driver-state';

package/src/agent-cli-provider/omp/rpc-event-lines.ts

@@ -0,0 +1,58 @@
+import { getNumber, getOptionalString, getString, isRecord, tryParseJson } from '../json';
+import type { ProviderParseResult, ProviderParserState } from '../types';
+
+/**
+ * Parse one line of the rpc-stdio lane's already-normalized OutputEvent JSON stream. The driver
+ * normalizes raw RPC frames once; this validating passthrough keeps generic log and attach tooling
+ * on the provider adapter contract without re-deriving events from raw frames.
+ */
+export function parseNormalizedOmpRpcEventLine(
+  line: string,
+  _state: ProviderParserState
+): ProviderParseResult {
+  const parsed = tryParseJson(line);
+  if (!isRecord(parsed)) return null;
+  switch (parsed.type) {
+    case 'text':
+    case 'thinking': {
+      const text = getString(parsed, 'text');
+      return text === null ? null : { type: parsed.type, text };
+    }
+    case 'tool_call':
+      return {
+        type: 'tool_call',
+        toolName: getOptionalString(parsed, 'toolName'),
+        toolId: getOptionalString(parsed, 'toolId'),
+        input: parsed.input,
+      };
+    case 'tool_result':
+      return {
+        type: 'tool_result',
+        toolId: getOptionalString(parsed, 'toolId'),
+        content: parsed.content,
+        isError: parsed.isError,
+      };
+    case 'result': {
+      if (typeof parsed.success !== 'boolean') return null;
+      const inputTokens = getNumber(parsed, 'inputTokens');
+      const outputTokens = getNumber(parsed, 'outputTokens');
+      const cacheReadInputTokens = getNumber(parsed, 'cacheReadInputTokens');
+      const cacheCreationInputTokens = getNumber(parsed, 'cacheCreationInputTokens');
+      return {
+        type: 'result',
+        success: parsed.success,
+        result: parsed.result,
+        error: parsed.error,
+        cost: parsed.cost,
+        duration: parsed.duration,
+        ...(inputTokens === null ? {} : { inputTokens }),
+        ...(outputTokens === null ? {} : { outputTokens }),
+        ...(cacheReadInputTokens === null ? {} : { cacheReadInputTokens }),
+        ...(cacheCreationInputTokens === null ? {} : { cacheCreationInputTokens }),
+        modelUsage: parsed.modelUsage,
+      };
+    }
+    default:
+      return null;
+  }
+}