@springbrand/agent-runtime 0.2.0-alpha.72 → 0.3.0-alpha.10

package/src/harness/session-harness.ts

@@ -0,0 +1,562 @@
+import {
+  AgentHarness,
+  type AgentMessage,
+  type AgentHarness as PiAgentHarness,
+  type AgentHarnessOptions,
+  type AgentLane,
+  type DriveOutcome,
+  type DriveOptions,
+  type OpenOperation,
+  type OperationRequest,
+} from "@earendil-works/pi-agent-core";
+import type { Context } from "@earendil-works/pi-agent-core/harness/context";
+import type { Entry, SettledAssistantMessage } from "@earendil-works/pi-agent-core/harness/session";
+import {
+  isModelStreamStallMessage,
+  isOpenRouterServerToolTimeout,
+  isRecoverableAssistantError,
+} from "../models";
+import { projectToolOutputForModel } from "../context/memory/budget/gate";
+import type { ArtifactRef } from "../lib/artifacts";
+
+export interface SessionHarnessLimits {
+  /** Complete model turns committed before one Worker instance releases. */
+  modelTurnsPerSlice?: number;
+  /** Complete working turns allowed before the no-tool final response. */
+  maxModelTurns?: number;
+  /** Maximum text turns allowed after the working or Tool failure budget. */
+  maxWrapUpModelTurns?: number;
+  wrapUpInstruction?: string;
+}
+
+export interface SessionHarnessOptions<TContext extends object | undefined>
+  extends AgentHarnessOptions<TContext> {
+  limits?: SessionHarnessLimits;
+  modelToolResultExemptions?: readonly string[];
+  /** Base provider Session identity, retained except after a server Tool timeout. */
+  modelSessionId?: string;
+}
+
+export type SessionHarnessRunResult = DriveOutcome | {
+  kind: "released";
+  operationId: string;
+  reason: "slice" | "budget" | "tool-failure" | "approval" | "interaction";
+};
+
+const DEFAULT_MODEL_TURNS_PER_SLICE = 30;
+const DEFAULT_MAX_MODEL_TURNS = 300;
+const DEFAULT_MAX_WRAP_UP_MODEL_TURNS = 2;
+const RECOVERY_MAX_FAILURES = 5;
+const STALL_MAX_FAILURES = 3;
+const SERVER_TOOL_TIMEOUT_MAX_FAILURES = 2;
+const DEFAULT_WRAP_UP_INSTRUCTION =
+  "Finish this request now without using tools. Summarize the completed work and any remaining limitation.";
+const TOOL_FAILURE_WRAP_UP_INSTRUCTION =
+  "This turn reached its tool failure limit. Stop calling tools now. Reply with a final message that explains what failed and the exact next step the user should take. Do not start new work.";
+const MAX_TOOL_RETRIES = 3;
+const TURN_FAILURE_CEILING = 8;
+const ARTIFACT_MANIFEST_MAX_CHARS = 12 * 1024;
+
+function canonicalJson(value: unknown): string {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value)
+      .filter(([, item]) => item !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+
+function toolCallKey(toolName: string, args: unknown): string {
+  return `${toolName}\0${canonicalJson(args)}`;
+}
+
+function projectToolResultsForModel(
+  messages: readonly AgentMessage[],
+  exemptions: ReadonlySet<string>,
+): AgentMessage[] {
+  let changed = false;
+  const projected = messages.map((message) => {
+    if (
+      message.role !== "toolResult" ||
+      exemptions.has(message.toolName)
+    ) return message;
+    const payload = { content: message.content, details: message.details };
+    const next = projectToolOutputForModel(payload) as typeof payload;
+    if (next === payload) return message;
+    changed = true;
+    return { ...message, content: next.content, details: next.details };
+  });
+  return changed ? projected : [...messages];
+}
+
+function artifactRefFromMessage(message: AgentMessage): ArtifactRef | undefined {
+  if (message.role !== "toolResult" || message.details === null ||
+    typeof message.details !== "object" ||
+    (message.details as { kind?: unknown }).kind !== "artifact_ref") {
+    return undefined;
+  }
+  const ref = message.details as Partial<ArtifactRef>;
+  if (typeof ref.path !== "string" || typeof ref.hash !== "string" ||
+    typeof ref.bytes !== "number" || typeof ref.preview !== "string" ||
+    typeof ref.note !== "string") return undefined;
+  return {
+    kind: "artifact_ref",
+    artifactId: typeof ref.artifactId === "string"
+      ? ref.artifactId
+      : `artifact_${ref.hash.slice(0, 24)}`,
+    path: ref.path,
+    bytes: ref.bytes,
+    hash: ref.hash,
+    workspaceRevision: typeof ref.workspaceRevision === "string"
+      ? ref.workspaceRevision
+      : "unknown",
+    availability: ref.availability === "unavailable"
+      ? "unavailable"
+      : "available",
+    preview: ref.preview,
+    note: ref.note,
+  };
+}
+
+function artifactManifestMessage(
+  refs: ReadonlyMap<string, ArtifactRef>,
+): AgentMessage | undefined {
+  if (refs.size === 0) return undefined;
+  const lines = [
+    "<workspace_artifact_manifest>",
+    "These are lightweight references to prior Tool output. Do not treat previews as complete. Read an available artifact with the Workspace readFile/readFilePage tool only when the current request needs its evidence.",
+  ];
+  let omitted = 0;
+  for (const ref of refs.values()) {
+    const preview = ref.preview.replace(/[\r\n]+/g, " ").slice(0, 240);
+    const line = [
+      `artifactId=${ref.artifactId}`,
+      `path=${ref.path}`,
+      `hash=${ref.hash}`,
+      `bytes=${ref.bytes}`,
+      `workspaceRevision=${ref.workspaceRevision}`,
+      `availability=${ref.availability}`,
+      `preview=${preview}`,
+    ].join(" ");
+    if ([...lines, line, "</workspace_artifact_manifest>"].join("\n").length > ARTIFACT_MANIFEST_MAX_CHARS) {
+      omitted += 1;
+      continue;
+    }
+    lines.push(line);
+  }
+  if (omitted > 0) lines.push(`omitted=${omitted} older artifact references due to manifest budget`);
+  lines.push("</workspace_artifact_manifest>");
+  return {
+    role: "user",
+    content: lines.join("\n"),
+    timestamp: 1,
+  };
+}
+
+function deferred<T>(): {
+  promise: Promise<T>;
+  resolve(value: T): void;
+} {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+function positiveInteger(value: number | undefined, fallback: number): number {
+  const resolved = value ?? fallback;
+  if (!Number.isInteger(resolved) || resolved <= 0) {
+    throw new Error("Harness model turn limits must be positive integers");
+  }
+  return resolved;
+}
+
+/**
+ * The only adapter that owns a live Pi AgentHarness for a Session.
+ *
+ * Submission and Cloudflare lifecycle code may accept, drive, abort, watch, or
+ * close through this object. It deliberately does not know how Host config or
+ * business repositories are loaded.
+ */
+export class SessionHarness<TContext extends object | undefined> {
+  private _openOperation: OpenOperation | null;
+  private readonly modelTurnsPerSlice: number;
+  private readonly maxModelTurns: number;
+  private readonly maxWrapUpModelTurns: number;
+  private readonly modelSessionId: string | undefined;
+  private readonly wrapUpInstruction: string;
+  private readonly configuredToolNames: string[];
+  private readonly modelToolResultExemptions: ReadonlySet<string>;
+  private readonly toolFailures = new Map<string, number>();
+  private totalToolFailures = 0;
+  private toolFailureWrapUp = false;
+  private toolFailureWrapUpAt: number | undefined;
+  private operationStartTip: string | null = null;
+  private turnsAtOpen = 0;
+  private wrappingUp = false;
+  private releaseReason:
+    | "slice"
+    | "budget"
+    | "tool-failure"
+    | "approval"
+    | "interaction"
+    | undefined;
+  private readonly releaseRequest = deferred<"approval" | "interaction">();
+  private readonly activeTools = new Set<string>();
+  private readonly toolsIdle = new Set<() => void>();
+  private readonly artifactRefs = new Map<string, ArtifactRef>();
+
+  private constructor(
+    readonly harness: PiAgentHarness<TContext>,
+    readonly lane: AgentLane,
+    openOperation: OpenOperation | null,
+    options: SessionHarnessOptions<TContext>,
+  ) {
+    this._openOperation = openOperation;
+    this.modelTurnsPerSlice = positiveInteger(
+      options.limits?.modelTurnsPerSlice,
+      DEFAULT_MODEL_TURNS_PER_SLICE,
+    );
+    this.maxModelTurns = positiveInteger(
+      options.limits?.maxModelTurns,
+      DEFAULT_MAX_MODEL_TURNS,
+    );
+    this.maxWrapUpModelTurns = positiveInteger(
+      options.limits?.maxWrapUpModelTurns,
+      DEFAULT_MAX_WRAP_UP_MODEL_TURNS,
+    );
+    this.modelSessionId = options.modelSessionId;
+    this.wrapUpInstruction = options.limits?.wrapUpInstruction ??
+      DEFAULT_WRAP_UP_INSTRUCTION;
+    this.configuredToolNames = options.activeToolNames ??
+      (options.tools ?? []).map(({ name }) => name);
+    this.modelToolResultExemptions = new Set(
+      options.modelToolResultExemptions ?? [],
+    );
+  }
+
+  private async operationEntries(context: Context): Promise<Entry[]> {
+    // Stop boundaries follow traversal order; walk back from the current tip.
+    const entries = await this.lane.findEntries({
+      ...(this.operationStartTip === null ? {} : { stopAtId: this.operationStartTip }),
+      type: "message",
+      order: "newestFirst",
+    }, context);
+    return entries.filter(({ id }) => id !== this.operationStartTip).reverse();
+  }
+
+  private async restoreToolGovernance(context: Context): Promise<void> {
+    this.toolFailures.clear();
+    this.totalToolFailures = 0;
+    this.toolFailureWrapUp = false;
+    this.toolFailureWrapUpAt = undefined;
+    let turns = 0;
+    for (const entry of await this.operationEntries(context)) {
+      if (entry.type !== "message") continue;
+      const message = entry.message;
+      if (message.role === "assistant") {
+        turns += 1;
+        continue;
+      }
+      this.recordCanonicalToolOutcome(entry);
+      if (this.toolFailureWrapUp) this.toolFailureWrapUpAt ??= turns;
+    }
+  }
+
+  private recordCanonicalToolOutcome(entry: Entry): void {
+    if (entry.type !== "message" || entry.message.role !== "toolResult") return;
+    const message = entry.message;
+    if (entry.toolExecution?.status === "executed") {
+      this.recordToolOutcome(message.toolName, entry.toolExecution.args, message.isError);
+    } else if (entry.toolExecution?.status === "blocked" && entry.toolExecution.args !== undefined) {
+      const key = toolCallKey(message.toolName, entry.toolExecution.args);
+      if ((this.toolFailures.get(key) ?? 0) >= MAX_TOOL_RETRIES) this.toolFailureWrapUp = true;
+    }
+  }
+
+  private recordToolOutcome(toolName: string, args: unknown, isError: boolean): void {
+    const key = toolCallKey(toolName, args);
+    if (!isError) {
+      this.toolFailures.delete(key);
+      return;
+    }
+    this.toolFailures.set(key, (this.toolFailures.get(key) ?? 0) + 1);
+    this.totalToolFailures += 1;
+    if (this.totalToolFailures >= TURN_FAILURE_CEILING) this.toolFailureWrapUp = true;
+  }
+
+  private async shouldRetry(
+    message: SettledAssistantMessage,
+    context: Context,
+    recovery: boolean,
+  ): Promise<boolean> {
+    const stalled = isModelStreamStallMessage(message.errorMessage);
+    const serverToolTimeout = isOpenRouterServerToolTimeout(message);
+    if (!recovery && !stalled && !serverToolTimeout && !isRecoverableAssistantError(message)) return false;
+    const failures = 1 + (await this.operationEntries(context)).filter((entry) =>
+      entry.type === "message" && entry.message.role === "assistant" && entry.message.stopReason === "error"
+    ).length;
+    return failures < (stalled ? STALL_MAX_FAILURES
+      : serverToolTimeout ? SERVER_TOOL_TIMEOUT_MAX_FAILURES : RECOVERY_MAX_FAILURES);
+  }
+
+  private async shouldFinishRun(context: Context): Promise<boolean> {
+    const wrapUpAt = Math.min(this.maxModelTurns, this.toolFailureWrapUpAt ?? Infinity);
+    return await this.completedModelTurns(context) >= wrapUpAt + this.maxWrapUpModelTurns;
+  }
+
+  get openOperation(): OpenOperation | null {
+    return this._openOperation;
+  }
+
+  static async open<TContext extends object | undefined>(
+    options: SessionHarnessOptions<TContext>,
+    context: Context,
+  ): Promise<SessionHarness<TContext>> {
+    const {
+      limits: _limits,
+      modelToolResultExemptions: _modelToolResultExemptions,
+      modelSessionId: _modelSessionId,
+      ...harnessOptions
+    } = options;
+    let runtime!: SessionHarness<TContext>;
+    const { harness, open } = await AgentHarness.create({
+      ...harnessOptions,
+      retry: options.retry ?? { enabled: true, maxRetries: RECOVERY_MAX_FAILURES - 1, baseDelayMs: 1_000 },
+      recoveryPolicy: async (event, policyContext) =>
+        await runtime.shouldRetry(event.message, policyContext, event.recovery) &&
+        (options.recoveryPolicy === undefined || await options.recoveryPolicy(event, policyContext)),
+      shouldFinishRun: async (event, policyContext) =>
+        await runtime.shouldFinishRun(policyContext) ||
+        (options.shouldFinishRun !== undefined && await options.shouldFinishRun(event, policyContext)),
+    }, context);
+    const foreign = open.find((operation) => operation.lane !== "main");
+    if (foreign) {
+      await harness.close(context);
+      throw new Error(`Unexpected open Harness lane: ${foreign.lane}`);
+    }
+    if (open.length > 1) {
+      await harness.close(context);
+      throw new Error("Session has multiple open operations on the main lane");
+    }
+    runtime = new SessionHarness(
+      harness,
+      await harness.lane("main", context),
+      open[0] ?? null,
+      options,
+    );
+    await runtime.install(context);
+    return runtime;
+  }
+
+  private async install(context: Context): Promise<void> {
+    for (const entry of await this.lane.findEntries({ type: "message", order: "oldestFirst" }, context)) {
+      if (entry.type === "message") {
+        const ref = artifactRefFromMessage(entry.message);
+        if (ref) this.artifactRefs.set(ref.artifactId, ref);
+      }
+    }
+    if (this._openOperation) {
+      const watch = await this.lane.watch(context);
+      this.operationStartTip = watch.snapshot.operation?.fromTipId ?? null;
+      watch.unsubscribe();
+      await this.restoreToolGovernance(context);
+      this.turnsAtOpen = await this.completedModelTurns(context);
+      if (this.turnsAtOpen >= this.maxModelTurns) {
+        this.wrappingUp = true;
+      }
+      if (this.wrappingUp || this.toolFailureWrapUp) {
+        await this.lane.setActiveTools([], context);
+      }
+    }
+    this.harness.hooks.on("before_request", async (event, requestContext) => {
+      if (event.step !== "assistant") return;
+      const resets = (await this.operationEntries(requestContext)).filter((entry) =>
+        entry.type === "message" && entry.message.role === "assistant" && isOpenRouterServerToolTimeout(entry.message)
+      ).length;
+      if (resets > 0) {
+        return { streamOptions: { sessionId: `${this.modelSessionId ?? event.runId}:server-tool-recovery:${resets}` } };
+      }
+      if (this.modelSessionId !== undefined) return { streamOptions: { sessionId: this.modelSessionId } };
+    });
+    this.harness.hooks.on("transform_context", (event) => {
+      const messages = projectToolResultsForModel(
+        event.messages,
+        this.modelToolResultExemptions,
+      );
+      const manifest = artifactManifestMessage(this.artifactRefs);
+      const instruction = this.toolFailureWrapUp
+        ? TOOL_FAILURE_WRAP_UP_INSTRUCTION
+        : this.wrappingUp
+          ? this.wrapUpInstruction
+          : undefined;
+      const contextMessages = manifest ? [...messages, manifest] : messages;
+      return {
+        messages: instruction
+          ? [...contextMessages, {
+              role: "user" as const,
+              content: instruction,
+              timestamp: 1,
+            }]
+          : contextMessages,
+      };
+    });
+    this.harness.hooks.on("before_tool", (event) => {
+      if (this.toolFailureWrapUp) {
+        return {
+          block: {
+            reason: "This turn reached its tool failure limit. Stop calling tools now.",
+            terminate: true,
+          },
+        };
+      }
+      if (
+        (this.toolFailures.get(toolCallKey(event.toolName, event.args)) ?? 0) <
+          MAX_TOOL_RETRIES
+      ) return;
+      this.toolFailureWrapUp = true;
+      return {
+        block: {
+          reason:
+            `This exact ${event.toolName} call has already failed ${MAX_TOOL_RETRIES} times — change the input or approach instead of retrying it verbatim.`,
+        },
+      };
+    });
+    this.harness.events.on("entry_added", (event) => {
+      if (event.lane !== this.lane.name) return;
+      this.recordCanonicalToolOutcome(event.entry);
+      if (event.entry.type === "message") {
+        const ref = artifactRefFromMessage(event.entry.message);
+        if (ref) this.artifactRefs.set(ref.artifactId, ref);
+      }
+    });
+    this.harness.events.on("turn_end", async (_event, eventContext) => {
+      const total = await this.completedModelTurns(eventContext);
+      if (this.toolFailureWrapUp && this.toolFailureWrapUpAt === undefined) {
+        this.toolFailureWrapUpAt = total;
+        this.releaseReason = "tool-failure";
+      } else if (this.wrappingUp || this.toolFailureWrapUp) {
+        return;
+      } else if (total >= this.maxModelTurns) {
+        this.releaseReason = "budget";
+      } else if (total - this.turnsAtOpen >= this.modelTurnsPerSlice) {
+        this.releaseReason = "slice";
+      } else {
+        return;
+      }
+      await this.harness.close(eventContext);
+    });
+    this.harness.events.on("tool_start", (event) => {
+      this.activeTools.add(event.toolCallId);
+    });
+    this.harness.events.on("tool_end", (event) => {
+      this.activeTools.delete(event.toolCallId);
+      if (this.activeTools.size === 0) {
+        for (const resolve of this.toolsIdle) resolve();
+        this.toolsIdle.clear();
+      }
+    });
+  }
+
+  /** Ask the active drive to detach after already-started parallel Tools settle. */
+  requestHumanRelease(reason: "approval" | "interaction"): void {
+    this.releaseRequest.resolve(reason);
+  }
+
+  private async waitForToolsToSettle(): Promise<void> {
+    if (this.activeTools.size === 0) return;
+    await new Promise<void>((resolve) => this.toolsIdle.add(resolve));
+  }
+
+  private async completedModelTurns(context: Context): Promise<number> {
+    return (await this.operationEntries(context)).filter((entry) =>
+      entry.type === "message" && entry.message.role === "assistant"
+    ).length;
+  }
+
+  async run(
+    request: OperationRequest | undefined,
+    context: Context,
+    driveOptions: Omit<DriveOptions, "operationId"> = {},
+  ): Promise<SessionHarnessRunResult> {
+    let operationId = this.openOperation?.operationId;
+    if (request) {
+      if (operationId) {
+        throw new Error(`Harness operation ${operationId} is already open`);
+      }
+      this.operationStartTip = await this.lane.getTipId(context);
+      this.turnsAtOpen = 0;
+      this.wrappingUp = false;
+      this.toolFailures.clear();
+      this.totalToolFailures = 0;
+      this.toolFailureWrapUp = false;
+      this.toolFailureWrapUpAt = undefined;
+      this.releaseReason = undefined;
+      await this.lane.setActiveTools(this.configuredToolNames, context);
+      const admission = await this.lane.accept(request, context);
+      if (!admission.ok) throw admission.error;
+      operationId = admission.value.operationId;
+      this._openOperation = {
+        lane: "main",
+        operationId,
+        kind: admission.value.kind,
+        startedAt: admission.value.startedAt,
+      };
+    }
+    if (!operationId) throw new Error("No Harness operation to drive");
+    try {
+      const driving = this.lane.drive({ ...driveOptions, operationId }, context);
+      const winner = await Promise.race([
+        driving.then((result) => ({ kind: "drive" as const, result })),
+        this.releaseRequest.promise.then((reason) => ({
+          kind: "release" as const,
+          reason,
+        })),
+      ]);
+      if (winner.kind === "release") {
+        this.releaseReason = winner.reason;
+        await this.waitForToolsToSettle();
+        await this.harness.close(context);
+        await driving.catch(() => undefined);
+        return { kind: "released", operationId, reason: winner.reason };
+      }
+      const result = winner.result;
+      if (!result.ok) throw result.error;
+      if (result.value.kind === "settled") {
+        this._openOperation = null;
+      }
+      return result.value;
+    } catch (error) {
+      if (
+        this.releaseReason && error instanceof Error &&
+        error.name === "HarnessClosed"
+      ) {
+        return { kind: "released", operationId, reason: this.releaseReason };
+      }
+      throw error;
+    }
+  }
+
+  async requestAbort(operationId: string, context: Context): Promise<boolean> {
+    const result = await this.lane.requestAbort(operationId, context);
+    if (!result.ok) throw result.error;
+    return result.value.newlyRequested;
+  }
+
+  close(context: Context): Promise<void> {
+    return this.harness.close(context);
+  }
+}
+
+export function openSessionHarness<TContext extends object | undefined>(
+  options: SessionHarnessOptions<TContext>,
+  context: Context,
+): Promise<SessionHarness<TContext>> {
+  return SessionHarness.open(options, context);
+}

package/src/harness/submission-operation.ts

@@ -0,0 +1,49 @@
+import type { OperationRequest, OperationResultRecord } from "@earendil-works/pi-agent-core";
+import type { Context } from "@earendil-works/pi-agent-core/harness/context";
+import type { PiCanonicalUserInput } from "../conversation/message/contract";
+import type { StoredSubmission } from "../submission/repository";
+import type { SessionHarness } from "./session-harness";
+
+/** Recover the stable operation before accepting new input or navigating its branch. */
+export async function prepareSubmissionOperation(
+  runtime: SessionHarness<object | undefined>,
+  submission: Pick<StoredSubmission, "submissionId" | "queuedInputJson" | "regenerateMessageId">,
+  regenerationTarget: (messageId: string) => string | null,
+  context: Context,
+): Promise<{ kind: "run"; request?: OperationRequest } | { kind: "settled"; outcome: OperationResultRecord }> {
+  const id = submission.submissionId;
+  const navigationId = `${id}:regenerate`;
+  if (runtime.openOperation?.operationId === navigationId) {
+    const navigation = await runtime.run(undefined, context);
+    if (navigation.kind !== "settled" || navigation.outcome.status !== "completed") {
+      throw new Error("Could not recover the regeneration branch navigation");
+    }
+  }
+  if (runtime.openOperation) {
+    if (runtime.openOperation.operationId !== id) {
+      throw new Error(`Submission ${id} does not own the open Harness operation`);
+    }
+    return { kind: "run" };
+  }
+  const watch = await runtime.lane.watch(context);
+  const previous = watch.snapshot.lastResult;
+  watch.unsubscribe();
+  if (previous?.operationId === id) return { kind: "settled", outcome: previous };
+  if (!submission.queuedInputJson) {
+    throw new Error(`Submission ${id} has no open Harness operation or queued input`);
+  }
+  const prompt = JSON.parse(submission.queuedInputJson) as PiCanonicalUserInput;
+  if (prompt.role !== "user") throw new Error("Queued SpringBrand user message is invalid");
+  if (submission.regenerateMessageId && previous?.operationId !== navigationId) {
+    const navigation = await runtime.run({
+      kind: "navigation",
+      operationId: navigationId,
+      targetId: regenerationTarget(submission.regenerateMessageId),
+      options: { summarize: false },
+    }, context);
+    if (navigation.kind !== "settled" || navigation.outcome.status !== "completed") {
+      throw new Error("Could not navigate to the regeneration branch");
+    }
+  }
+  return { kind: "run", request: { kind: "prompt", operationId: id, prompt } };
+}