arisa 5.2.7 → 5.2.19

package/src/core/agent/pi-auth-login.js

@@ -1,13 +1,6 @@
-import { AuthStorage } from "@earendil-works/pi-coding-agent";
-import { piAuthFile } from "../../platform/paths.js";
+import { createPiRuntime, supportsProviderOAuth } from "./pi-runtime.js";
 
 export function createPiOAuthLogin({ provider, onAuth, onDeviceCode, onPrompt, onProgress, onSelect } = {}) {
-  const authStorage = AuthStorage.create(piAuthFile);
-  const oauthProvider = authStorage.getOAuthProviders().find((item) => item.id === provider);
-  if (!oauthProvider) {
-    throw new Error(`No internal OAuth login flow is available for ${provider}.`);
-  }
-
   let resolveManualCode;
   const manualCodePromise = new Promise((resolve) => {
     resolveManualCode = resolve;
@@ -15,7 +8,6 @@ export function createPiOAuthLogin({ provider, onAuth, onDeviceCode, onPrompt, o
 
   const controller = {
     provider,
-    oauthProvider,
     manualInputRequested: false,
     submitManualCode(value) {
       if (!resolveManualCode) return false;
@@ -31,25 +23,33 @@ export function createPiOAuthLogin({ provider, onAuth, onDeviceCode, onPrompt, o
     promise: null
   };
 
-  controller.promise = authStorage.login(provider, {
-    onAuth: async (params) => {
-      await onAuth?.({ ...params, controller });
-    },
-    onDeviceCode: async (params) => {
-      await onDeviceCode?.({ ...params, controller });
-    },
-    onPrompt: async (params) => {
-      if (!onPrompt) return "";
-      return onPrompt({ ...params, controller });
-    },
-    onProgress: (message) => {
-      onProgress?.(message);
-    },
-    onSelect: async (params) => {
-      if (!onSelect) return params.options?.[0]?.id;
-      return onSelect({ ...params, controller });
-    },
-    onManualCodeInput: () => controller.waitForManualCode()
+  controller.promise = createPiRuntime().then(async (runtime) => {
+    if (!supportsProviderOAuth(provider, runtime)) {
+      throw new Error(`No internal OAuth login flow is available for ${provider}.`);
+    }
+    let notifications = Promise.resolve();
+    let notificationError;
+    const credential = await runtime.login(provider, "oauth", {
+      notify(event) {
+        notifications = notifications.then(async () => {
+          if (event.type === "auth_url") await onAuth?.({ ...event, controller });
+          else if (event.type === "device_code") await onDeviceCode?.({ ...event, controller });
+          else await onProgress?.(event.message);
+        }).catch((error) => { notificationError = error; });
+      },
+      async prompt(params) {
+        await notifications;
+        if (notificationError) throw notificationError;
+        if (params.type === "select") {
+          return onSelect ? onSelect({ ...params, controller }) : params.options?.[0]?.id;
+        }
+        if (params.type === "manual_code") return controller.waitForManualCode();
+        return onPrompt ? onPrompt({ ...params, controller }) : "";
+      }
+    });
+    await notifications;
+    if (notificationError) throw notificationError;
+    return credential;
   }).finally(() => {
     controller.submitManualCode("");
   });

package/src/core/agent/pi-capability-tools.js

@@ -18,7 +18,7 @@ function nativeTools(policy) {
   }];
 }
 
-export function createPiCapabilityTools({ capabilityService, telegram, chatId, policy, logger }) {
+export function createPiCapabilityTools({ capabilityService, telegram, chatId, policy, logger, toolFanout }) {
   if (!capabilityService?.execute) throw new Error("Pi capability tools require CapabilityService");
 
   const baseContext = {
@@ -38,6 +38,7 @@ export function createPiCapabilityTools({ capabilityService, telegram, chatId, p
     }
   };
 
+  const runWithFanout = (work) => toolFanout?.run ? toolFanout.run(work) : work();
   const execute = (actorToolName, method, params = {}, context = {}) => capabilityService.execute({
     method,
     actorToolName,
@@ -46,6 +47,7 @@ export function createPiCapabilityTools({ capabilityService, telegram, chatId, p
     context: {
       ...baseContext,
       taskContext: telegram.getTaskContext(),
+      agentTaskExecution: telegram.getAgentTaskExecution?.() || null,
       ...context
     }
   });
@@ -113,12 +115,14 @@ export function createPiCapabilityTools({ capabilityService, telegram, chatId, p
         args: Type.Optional(Type.Record(Type.String(), Type.String())),
         deliver: Type.Optional(Type.Boolean())
       }),
-      execute: async (_id, params) => jsonResult(await execute("run_tool", "tools.run", params))
+      execute: async (_id, params) => jsonResult(await runWithFanout(
+        () => execute("run_tool", "tools.run", params)
+      ))
     }),
     defineTool({
       name: "list_scheduled_tasks",
       label: "List scheduled tasks",
-      description: "List scheduled async tasks for the current Telegram chat. Results default to 50 tasks, always include pending/running tasks, and accept an optional limit up to 100.",
+      description: "List scheduled async tasks for the current Telegram chat. Results default to 50 tasks, always include pending, running, and authentication-blocked tasks, and accept an optional limit up to 100.",
       parameters: Type.Object({
         status: Type.Optional(Type.String()),
         limit: Type.Optional(Type.Integer({ minimum: 1, maximum: maxScheduledTaskListLimit }))
@@ -135,7 +139,7 @@ export function createPiCapabilityTools({ capabilityService, telegram, chatId, p
     defineTool({
       name: "cancel_all_scheduled_tasks",
       label: "Cancel all scheduled tasks",
-      description: "Cancel all pending or running async tasks for the current Telegram chat.",
+      description: "Cancel all active async tasks, including authentication-blocked tasks, for the current Telegram chat.",
       parameters: Type.Object({}),
       execute: async () => jsonResult(await execute("cancel_all_scheduled_tasks", "tasks.cancelAll"))
     }),

package/src/core/agent/pi-runtime.js

@@ -1,34 +1,29 @@
-import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import { piAuthFile } from "../../platform/paths.js";
 
 function compareText(a, b) {
   return a.localeCompare(b, undefined, { sensitivity: "base", numeric: true });
 }
 
-export function createPiRuntime({ provider, apiKey } = {}) {
-  const authStorage = AuthStorage.create(piAuthFile);
+export async function createPiRuntime({ provider, apiKey } = {}) {
+  const runtime = await ModelRuntime.create({ authPath: piAuthFile });
   if (provider && apiKey) {
-    authStorage.setRuntimeApiKey(provider, apiKey);
+    await runtime.setRuntimeApiKey(provider, apiKey);
   }
-  const modelRegistry = ModelRegistry.create(authStorage);
-  const oauthProviders = authStorage.getOAuthProviders();
-  return { authStorage, modelRegistry, oauthProviders };
+  return runtime;
 }
 
-export function hasProviderAuth(provider, { authStorage, modelRegistry }) {
-  return modelRegistry.hasConfiguredAuth(provider) || authStorage.hasAuth(provider);
+export function hasProviderAuth(provider, runtime) {
+  return runtime.getProviderAuthStatus(provider).configured;
 }
 
-export function supportsProviderOAuth(provider, { oauthProviders }) {
-  return oauthProviders.some((item) => item.id === provider);
+export function supportsProviderOAuth(provider, runtime) {
+  return Boolean(runtime.getProvider(provider)?.auth.oauth);
 }
 
-export function listPiProviders(runtime = createPiRuntime()) {
-  const { modelRegistry, oauthProviders } = runtime;
-  const allModels = modelRegistry.getAll();
-  const oauthIds = new Set(oauthProviders.map((item) => item.id));
+export function listPiProviders(runtime) {
   const counts = new Map();
-  for (const model of allModels) {
+  for (const model of runtime.getModels()) {
     counts.set(model.provider, (counts.get(model.provider) || 0) + 1);
   }
 
@@ -36,7 +31,7 @@ export function listPiProviders(runtime = createPiRuntime()) {
     .map((provider) => ({
       provider,
       authConfigured: hasProviderAuth(provider, runtime),
-      supportsOAuth: oauthIds.has(provider),
+      supportsOAuth: supportsProviderOAuth(provider, runtime),
       modelCount: counts.get(provider) || 0
     }))
     .sort((a, b) => {
@@ -46,10 +41,8 @@ export function listPiProviders(runtime = createPiRuntime()) {
     });
 }
 
-export function listProviderModels(provider, runtime = createPiRuntime()) {
-  return runtime.modelRegistry
-    .getAll()
-    .filter((model) => model.provider === provider)
+export function listProviderModels(provider, runtime) {
+  return [...runtime.getModels(provider)]
     .sort((a, b) => compareText(a.name || a.id, b.name || b.id));
 }
 

package/src/core/agent/session-history-reader.js

@@ -0,0 +1,168 @@
+import { closeSync, openSync, readSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+const readBufferBytes = 1024 * 1024;
+const supportedSessionVersion = 3;
+
+function parseEntry(line) {
+  if (!line.trim()) return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+function readSessionHeader(filePath) {
+  const descriptor = openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(4096);
+    const bytesRead = readSync(descriptor, buffer, 0, buffer.length, 0);
+    const line = buffer.toString("utf8", 0, bytesRead).split("\n", 1)[0];
+    const header = parseEntry(line);
+    return header?.type === "session" ? header : null;
+  } catch {
+    return null;
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+export function findMostRecentSessionFile(sessionDir, cwd) {
+  const expectedCwd = path.resolve(cwd);
+  try {
+    return readdirSync(sessionDir)
+      .filter((name) => name.endsWith(".jsonl"))
+      .map((name) => path.join(sessionDir, name))
+      .map((filePath) => ({ filePath, header: readSessionHeader(filePath) }))
+      .filter(({ header }) => header && typeof header.cwd === "string" && path.resolve(header.cwd) === expectedCwd)
+      .map(({ filePath }) => ({ filePath, mtimeMs: statSync(filePath).mtimeMs }))
+      .sort((left, right) => right.mtimeMs - left.mtimeMs)[0]?.filePath || null;
+  } catch {
+    return null;
+  }
+}
+
+export function streamSessionEntries(filePath, visit) {
+  const descriptor = openSync(filePath, "r");
+  try {
+    const decoder = new StringDecoder("utf8");
+    const buffer = Buffer.allocUnsafe(readBufferBytes);
+    let pending = "";
+    while (true) {
+      const bytesRead = readSync(descriptor, buffer, 0, buffer.length, null);
+      if (!bytesRead) break;
+      pending += decoder.write(buffer.subarray(0, bytesRead));
+      let newline = pending.indexOf("\n");
+      while (newline !== -1) {
+        const entry = parseEntry(pending.slice(0, newline));
+        if (entry) visit(entry);
+        pending = pending.slice(newline + 1);
+        newline = pending.indexOf("\n");
+      }
+    }
+    pending += decoder.end();
+    const entry = parseEntry(pending);
+    if (entry) visit(entry);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function traceActivePath(entries, leafId) {
+  const reversed = [];
+  const seen = new Set();
+  let currentId = leafId;
+  while (currentId) {
+    if (seen.has(currentId)) return null;
+    seen.add(currentId);
+    const entry = entries.get(currentId);
+    if (!entry) return null;
+    reversed.push(entry);
+    currentId = entry.parentId || null;
+  }
+  return reversed.reverse();
+}
+
+function findLatestValidCompaction(path) {
+  const pathIndex = new Map(path.map((entry, index) => [entry.id, index]));
+  for (let index = path.length - 1; index >= 0; index -= 1) {
+    const entry = path[index];
+    if (entry.type !== "compaction" || !entry.hasSummary) continue;
+    if (!entry.firstKeptEntryId) return { entry, index, firstKeptIndex: index };
+    const firstKeptIndex = pathIndex.get(entry.firstKeptEntryId);
+    if (firstKeptIndex !== undefined && firstKeptIndex < index) {
+      return { entry, index, firstKeptIndex };
+    }
+  }
+  return null;
+}
+
+function inspectSessionGraph(filePath) {
+  let header = null;
+  let firstEntry = true;
+  let invalidHeader = false;
+  let leafId = null;
+  let duplicateId = false;
+  const entries = new Map();
+  streamSessionEntries(filePath, (entry) => {
+    if (firstEntry) {
+      firstEntry = false;
+      header = entry.type === "session" ? entry : null;
+      invalidHeader = !header;
+      return;
+    }
+    if (invalidHeader) return;
+    if (!entry.id || entry.type === "session") return;
+    if (entries.has(entry.id)) duplicateId = true;
+    entries.set(entry.id, {
+      id: entry.id,
+      parentId: entry.parentId || null,
+      type: entry.type,
+      firstKeptEntryId: entry.type === "compaction" ? entry.firstKeptEntryId || null : null,
+      hasSummary: entry.type === "compaction" && Boolean(String(entry.summary || "").trim())
+    });
+    leafId = entry.id;
+  });
+  if (invalidHeader || !header || header.version !== supportedSessionVersion || duplicateId || !leafId) return null;
+  const path = traceActivePath(entries, leafId);
+  if (!path) return null;
+  const compaction = findLatestValidCompaction(path);
+  if (!compaction) return null;
+  return { header, path, compaction };
+}
+
+function loadMigrationPayload(filePath, path, compaction) {
+  const before = path.slice(compaction.firstKeptIndex, compaction.index);
+  const after = path.slice(compaction.index + 1);
+  const contextIds = [...before, ...after].map((entry) => entry.id);
+  const wanted = new Set(contextIds);
+  const loaded = new Map();
+  let summary = "";
+  streamSessionEntries(filePath, (entry) => {
+    if (entry.id === compaction.entry.id) summary = String(entry.summary || "").trim();
+    if (wanted.has(entry.id)) loaded.set(entry.id, entry);
+  });
+  if (!summary || loaded.size !== wanted.size) return null;
+  return {
+    summary,
+    contextEntries: contextIds.map((id) => loaded.get(id))
+  };
+}
+
+export function inspectSessionForPreloadMigration(filePath, maxPersistedBytes) {
+  const sourceBytes = statSync(filePath).size;
+  if (sourceBytes <= Math.max(1, Number(maxPersistedBytes) || 1)) return null;
+  const graph = inspectSessionGraph(filePath);
+  if (!graph) return null;
+  const payload = loadMigrationPayload(filePath, graph.path, graph.compaction);
+  if (!payload) return null;
+  return {
+    sourceFile: filePath,
+    sourceBytes,
+    header: graph.header,
+    compactionId: graph.compaction.entry.id,
+    ...payload
+  };
+}

package/src/core/agent/session-preload-migration.js

@@ -0,0 +1,162 @@
+import {
+  closeSync,
+  fsyncSync,
+  openSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import {
+  findMostRecentSessionFile,
+  inspectSessionForPreloadMigration
+} from "./session-history-reader.js";
+import { normalizeSessionRotationPolicy } from "./session-rotation.js";
+
+const contextEntryTypes = new Set([
+  "message",
+  "custom_message",
+  "branch_summary",
+  "thinking_level_change",
+  "model_change"
+]);
+
+function createEntry(type, parentId, fields = {}) {
+  return {
+    type,
+    ...fields,
+    id: randomUUID(),
+    parentId,
+    timestamp: fields.timestamp || new Date().toISOString()
+  };
+}
+
+function appendDurably(filePath, entry) {
+  writeFileSync(filePath, `${JSON.stringify(entry)}\n`, { encoding: "utf8", flag: "a" });
+}
+
+function syncFile(filePath) {
+  const descriptor = openSync(filePath, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function syncDirectory(directory) {
+  const descriptor = openSync(directory, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function migratedEntry(source, parentId) {
+  const { id: _id, parentId: _parentId, ...fields } = source;
+  return createEntry(source.type, parentId, fields);
+}
+
+export function createPreloadMigrationChild({
+  sessionDir,
+  cwd,
+  migration,
+  operationalNotes = "",
+  now = new Date()
+}) {
+  const timestamp = now.toISOString();
+  const sessionId = randomUUID();
+  const filenameTimestamp = timestamp.replace(/[:.]/g, "-");
+  const targetFile = path.join(sessionDir, `${filenameTimestamp}_${sessionId}.jsonl`);
+  const temporaryFile = path.join(sessionDir, `.session-migration-${sessionId}.tmp`);
+  const header = {
+    type: "session",
+    version: 3,
+    id: sessionId,
+    timestamp,
+    cwd,
+    parentSession: migration.sourceFile
+  };
+  let parentId = null;
+  let copiedEntries = 0;
+
+  try {
+    writeFileSync(temporaryFile, `${JSON.stringify(header)}\n`, { encoding: "utf8", flag: "wx" });
+    const notes = String(operationalNotes || "").trim();
+    if (notes) {
+      const entry = createEntry("custom_message", parentId, {
+        customType: "arisa-operational-notes",
+        content: notes,
+        display: false,
+        details: { source: "session-start" }
+      });
+      appendDurably(temporaryFile, entry);
+      parentId = entry.id;
+    }
+    const handoff = createEntry("custom_message", parentId, {
+      customType: "arisa-session-handoff",
+      content: [
+        "Automatic session migration before loading. Continue from this checkpoint:",
+        "",
+        migration.summary
+      ].join("\n"),
+      display: false,
+      details: { source: "preload-migration" }
+    });
+    appendDurably(temporaryFile, handoff);
+    parentId = handoff.id;
+
+    for (const sourceEntry of migration.contextEntries) {
+      if (!contextEntryTypes.has(sourceEntry.type)) continue;
+      const entry = migratedEntry(sourceEntry, parentId);
+      appendDurably(temporaryFile, entry);
+      parentId = entry.id;
+      copiedEntries += 1;
+    }
+
+    syncFile(temporaryFile);
+    renameSync(temporaryFile, targetFile);
+    syncDirectory(sessionDir);
+    return {
+      sourceFile: migration.sourceFile,
+      sourceBytes: migration.sourceBytes,
+      targetFile,
+      targetBytes: statSync(targetFile).size,
+      copiedEntries
+    };
+  } catch (error) {
+    try {
+      unlinkSync(temporaryFile);
+    } catch {}
+    throw error;
+  }
+}
+
+export function migrateRecentSessionBeforeLoad({
+  sessionDir,
+  cwd,
+  policy,
+  operationalNotes = ""
+}) {
+  const normalized = normalizeSessionRotationPolicy(policy);
+  if (!normalized.enabled) return null;
+  const sourceFile = findMostRecentSessionFile(sessionDir, cwd);
+  if (!sourceFile) return null;
+  const sourceBytes = statSync(sourceFile).size;
+  if (sourceBytes <= normalized.maxPersistedBytes) return null;
+  const migration = inspectSessionForPreloadMigration(sourceFile, normalized.maxPersistedBytes);
+  if (!migration) {
+    const error = new Error("Oversized Pi session could not be migrated safely before loading");
+    error.code = "PI_SESSION_PRELOAD_MIGRATION_UNAVAILABLE";
+    throw error;
+  }
+  return createPreloadMigrationChild({
+    sessionDir,
+    cwd,
+    migration,
+    operationalNotes
+  });
+}

package/src/core/agent/session-rotation.js

@@ -0,0 +1,29 @@
+const defaultCompactAtPersistedBytes = 24 * 1024 * 1024;
+const defaultMaxPersistedBytes = 32 * 1024 * 1024;
+
+export function normalizeSessionRotationPolicy(policy = {}) {
+  const maxPersistedBytes = Math.max(1, Number(policy?.maxPersistedBytes) || defaultMaxPersistedBytes);
+  return {
+    enabled: policy?.enabled !== false,
+    compactAtPersistedBytes: Math.min(
+      maxPersistedBytes,
+      Math.max(1, Number(policy?.compactAtPersistedBytes) || defaultCompactAtPersistedBytes)
+    ),
+    maxPersistedBytes
+  };
+}
+
+export function compactionRotationRequest(event, persistedBytes, policy = {}) {
+  const normalized = normalizeSessionRotationPolicy(policy);
+  if (!normalized.enabled || event?.type !== "compaction_end" || event.aborted || event.errorMessage) return null;
+  const summary = String(event.result?.summary || "").trim();
+  if (!summary || Math.max(0, Number(persistedBytes) || 0) <= normalized.compactAtPersistedBytes) return null;
+  return {
+    handoff: [
+      "Automatic session rotation after compaction. Continue from this checkpoint:",
+      "",
+      summary
+    ].join("\n"),
+    persistedBytes: Math.max(0, Number(persistedBytes) || 0)
+  };
+}

package/src/core/agent/worker-tool-fanout.js

@@ -0,0 +1,117 @@
+const defaults = Object.freeze({
+  enabled: true,
+  maxConcurrent: 2,
+  pressureConcurrent: 1,
+  serializePercent: 60
+});
+
+function boundedInteger(value, fallback, minimum, maximum) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.min(maximum, Math.max(minimum, Math.floor(number))) : fallback;
+}
+
+function boundedPercent(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.min(99, Math.max(1, number)) : fallback;
+}
+
+export function normalizeToolFanoutConfig(config = {}) {
+  const maxConcurrent = boundedInteger(config.maxConcurrent, defaults.maxConcurrent, 1, 16);
+  return {
+    enabled: config.enabled !== false,
+    maxConcurrent,
+    pressureConcurrent: Math.min(
+      maxConcurrent,
+      boundedInteger(config.pressureConcurrent, defaults.pressureConcurrent, 1, 16)
+    ),
+    serializePercent: boundedPercent(config.serializePercent, defaults.serializePercent)
+  };
+}
+
+export class WorkerToolFanoutController {
+  constructor({ heapCircuitBreaker, logger, config = {} }) {
+    this.heapCircuitBreaker = heapCircuitBreaker;
+    this.logger = logger;
+    this.active = 0;
+    this.queue = [];
+    this.draining = false;
+    this.metrics = {
+      peakActive: 0,
+      peakQueued: 0,
+      pressureSerializations: 0,
+      rejectedAdmissions: 0,
+      completed: 0
+    };
+    this.setConfig(config);
+  }
+
+  setConfig(config = {}) {
+    this.config = normalizeToolFanoutConfig(config);
+    this.drain();
+  }
+
+  capacity() {
+    if (!this.config.enabled) return Number.POSITIVE_INFINITY;
+    const pressure = this.heapCircuitBreaker.sample();
+    if (pressure.percent >= this.config.serializePercent) {
+      this.metrics.pressureSerializations += 1;
+      return this.config.pressureConcurrent;
+    }
+    return this.config.maxConcurrent;
+  }
+
+  async drain() {
+    if (this.draining) return;
+    this.draining = true;
+    try {
+      while (this.queue.length && this.active < this.capacity()) {
+        const job = this.queue.shift();
+        try {
+          await this.heapCircuitBreaker.admit();
+        } catch (error) {
+          this.metrics.rejectedAdmissions += 1;
+          job.reject(error);
+          continue;
+        }
+        this.active += 1;
+        this.metrics.peakActive = Math.max(this.metrics.peakActive, this.active);
+        job.resolve();
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+
+  acquire() {
+    if (!this.config.enabled) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      this.queue.push({ resolve, reject });
+      this.metrics.peakQueued = Math.max(this.metrics.peakQueued, this.queue.length);
+      this.drain();
+    });
+  }
+
+  release() {
+    if (this.config.enabled) this.active = Math.max(0, this.active - 1);
+    this.metrics.completed += 1;
+    this.drain();
+  }
+
+  async run(work) {
+    await this.acquire();
+    try {
+      return await work();
+    } finally {
+      this.release();
+    }
+  }
+
+  getDiagnostic() {
+    return {
+      ...this.config,
+      active: this.active,
+      queued: this.queue.length,
+      ...this.metrics
+    };
+  }
+}