@abot-ai/runtime 1.2.0 → 1.3.0

package/dist/src/web-ui/app/lib/context-window-snapshot-order.js

@@ -0,0 +1,31 @@
+function positiveSequence(value) {
+  return Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+
+function comparableSequenceDifference(previous, incoming) {
+  const previousOriginal = positiveSequence(previous?.eventSequence);
+  const incomingOriginal = positiveSequence(incoming?.eventSequence);
+  if (previousOriginal !== null && incomingOriginal !== null) {
+    return incomingOriginal - previousOriginal;
+  }
+  const previousTransport = positiveSequence(
+    previous?.seqNo ?? previous?.lastSeqNo,
+  );
+  const incomingTransport = positiveSequence(
+    incoming?.seqNo ?? incoming?.lastSeqNo,
+  );
+  if (previousTransport === null || incomingTransport === null) return null;
+  return incomingTransport - previousTransport;
+}
+
+export function canReplaceContextWindowEvidence(previous, incoming) {
+  const difference = comparableSequenceDifference(previous, incoming);
+  if (difference === null) return true;
+  return difference > 0;
+}
+
+export function isEventAfterContextWindowSnapshot(snapshot, event) {
+  const difference = comparableSequenceDifference(snapshot, event);
+  if (difference === null) return false;
+  return difference > 0;
+}

package/dist/src/web-ui/app/lib/conversation-role-model.d.ts

@@ -1,4 +1,12 @@
-export type ConversationRole = "supervisor" | "planner" | "worker" | "reviewer";
+import type { ConversationToolAction } from "./tool-activity-model.js";
+
+export type ConversationRole =
+  | "supervisor"
+  | "planner"
+  | "worker"
+  | "researcher"
+  | "reviewer"
+  | "unknown";
 
 export interface ConversationRoleCard {
   id: string;
@@ -8,6 +16,7 @@ export interface ConversationRoleCard {
   phaseLabel: string;
   summary: string;
   facts: string[];
+  toolActions?: ConversationToolAction[];
   active: boolean;
   tone: "active" | "failed" | "recorded";
 }

package/dist/src/web-ui/app/lib/conversation-role-model.js

@@ -6,22 +6,36 @@ import {
 } from "./event-presentation.js";
 import { textOf } from "./text-format.js";
 import { countToolInvocations } from "./tool-invocation-count.js";
+import { projectToolActivityEvent } from "./tool-activity-event.js";
+import {
+  buildConversationToolActions,
+  summarizeConversationTools,
+} from "./tool-activity-model.js";
 
 const ROLE_TITLES = Object.freeze({
   supervisor: "Supervisor",
   planner: "Planner",
   worker: "Worker",
+  researcher: "Researcher",
   reviewer: "Reviewer",
+  unknown: "Unattributed actions",
 });
 
 const ROLE_RESPONSIBILITIES = Object.freeze({
   supervisor: "Coordinates the request",
   planner: "Plans the work",
   worker: "Performs assigned tasks",
+  researcher: "Investigates assigned questions",
   reviewer: "Reviews the result",
+  unknown: "Executor not recorded",
 });
 
 function latestRoleAction(group) {
+  if (group.toolActions.some((action) => !action.legacy)) {
+    return group.latestRoleEvent
+      ? roleActivitySummary(group.latestRoleEvent)
+      : "";
+  }
   const toolEvent = group.toolEvents.at(-1);
   return roleActivitySummary(toolEvent || group.latestEvent);
 }
@@ -89,6 +103,11 @@ function isToolActivityEvent(event) {
   return activityEventName(event).startsWith("tool.");
 }
 
+function roleActivityStage(event) {
+  if (isToolActivityEvent(event)) return "";
+  return textOf(event.stage).trim();
+}
+
 function hasSupportedRoleStage(stage) {
   return Object.hasOwn(ROLE_TITLES, stage);
 }
@@ -106,7 +125,14 @@ function roleActivitySummary(event) {
 }
 
 function createRoleGroup(role, event) {
-  return { role, phase: "", latestEvent: event, toolEvents: [] };
+  return {
+    role,
+    phase: "",
+    latestEvent: event,
+    latestRoleEvent: null,
+    toolEvents: [],
+    toolActions: [],
+  };
 }
 
 function isActiveRoleActivity(group, activeRole, streaming) {
@@ -124,18 +150,24 @@ function buildRoleCard(group, activeRole, streaming) {
   const failed = isFailedRoleActivity(group.latestEvent);
   const active = isActiveRoleActivity(group, activeRole, streaming);
   const toolCount = countToolInvocations(group.toolEvents);
+  const toolSummary = summarizeConversationTools(group.toolActions);
   let tone = "recorded";
   if (active) tone = "active";
   if (failed) tone = "failed";
   return {
     id: group.role,
     role: group.role,
-    title: ROLE_TITLES[group.role],
+    title:
+      group.role === "supervisor" && !group.latestRoleEvent
+        ? "Root agent"
+        : ROLE_TITLES[group.role],
     responsibility: ROLE_RESPONSIBILITIES[group.role],
     phaseLabel: titleCaseEventValue(group.phase),
     summary: latestRoleAction(group),
-    facts:
-      toolCount > 0
+    toolActions: group.toolActions,
+    facts: toolSummary
+      ? [toolSummary]
+      : toolCount > 0
         ? [`${toolCount} tool call${toolCount === 1 ? "" : "s"}`]
         : [],
     active,
@@ -155,32 +187,56 @@ export function buildConversationRoleCards({
   let activeRole = "";
   let terminalSeen = false;
   const activityEvents = Array.isArray(events) ? events : [];
-  for (const event of orderedRequestActivity(
+  const orderedEvents = orderedRequestActivity(
     activityEvents,
     normalizedRequestId,
-  )) {
+  );
+  const executionOwners = recordedExecutionOwners(orderedEvents);
+  const toolEvents = [];
+  for (const event of orderedEvents) {
     if (isRequestTerminalEvent(event)) {
       terminalSeen = true;
       activeRole = "";
       continue;
     }
 
-    const stage = textOf(event.stage).trim();
+    const stage = roleActivityStage(event);
     if (stage) {
       activeRole = "";
-      if (!hasSupportedRoleStage(stage)) continue;
-      activeRole = stage;
-      const group = groups.get(stage) || createRoleGroup(stage, event);
-      group.phase = textOf(event.phase);
-      group.latestEvent = event;
-      groups.set(stage, group);
+      if (hasSupportedRoleStage(stage)) {
+        activeRole = stage;
+        const group = groups.get(stage) || createRoleGroup(stage, event);
+        group.phase = textOf(event.phase);
+        group.latestEvent = event;
+        group.latestRoleEvent = event;
+        groups.set(stage, group);
+      }
     }
 
-    if (!activeRole) continue;
     if (!isToolActivityEvent(event)) continue;
-    const group = groups.get(activeRole);
+    const evidence = event.toolActivity || projectToolActivityEvent(event);
+    const owner = toolExecutorRole(evidence, executionOwners, activeRole);
+    if (evidence)
+      toolEvents.push({
+        ...event,
+        toolActivity: { ...evidence, executorRole: owner },
+      });
+    if (!owner) continue;
+    const group = groups.get(owner) || createRoleGroup(owner, event);
     group.latestEvent = event;
     group.toolEvents.push({ ...event, eventName: activityEventName(event) });
+    groups.set(owner, group);
+  }
+
+  for (const action of buildConversationToolActions({
+    requestId: normalizedRequestId,
+    events: toolEvents,
+    streaming,
+  })) {
+    const owner = action.executorRole || "unknown";
+    const group = groups.get(owner) || createRoleGroup(owner, {});
+    group.toolActions.push(action);
+    groups.set(owner, group);
   }
 
   return [...groups.values()].map((group) =>
@@ -191,3 +247,29 @@ export function buildConversationRoleCards({
     ),
   );
 }
+
+function recordedExecutionOwners(events) {
+  const owners = new Map();
+  for (const event of events) {
+    const evidence = event.toolActivity || projectToolActivityEvent(event);
+    if (!evidence?.executionId || !evidence.executorRole) continue;
+    const role = hasSupportedRoleStage(evidence.executorRole)
+      ? evidence.executorRole
+      : "unknown";
+    owners.set(evidence.executionId, role);
+  }
+  return owners;
+}
+
+function toolExecutorRole(evidence, executionOwners, activeRole) {
+  if (evidence?.executionId && executionOwners.has(evidence.executionId)) {
+    return executionOwners.get(evidence.executionId);
+  }
+  if (evidence?.executorRole) {
+    return hasSupportedRoleStage(evidence.executorRole)
+      ? evidence.executorRole
+      : "unknown";
+  }
+  if (evidence?.executionId) return "unknown";
+  return activeRole;
+}

package/dist/src/web-ui/app/lib/conversation-status-model.d.ts

@@ -0,0 +1,12 @@
+export interface ConversationStatus {
+  label: string;
+  animate: boolean;
+}
+
+export declare function buildConversationStatus(input?: {
+  requestId?: string;
+  streaming?: boolean;
+  connected?: boolean;
+  contextWindow?: Record<string, unknown> | null;
+  events?: Record<string, unknown>[];
+}): ConversationStatus | null;

package/dist/src/web-ui/app/lib/conversation-status-model.js

@@ -0,0 +1,116 @@
+import { buildConversationToolActions } from "./tool-activity-model.js";
+import { isEventAfterContextWindowSnapshot } from "./context-window-snapshot-order.js";
+import { textOf } from "./text-format.js";
+
+const MODEL_STEP_LABELS = Object.freeze({
+  "supervisor.decision": "Making a decision",
+  "execution.decision": "Making a decision",
+  "worker.decision": "Making a decision",
+  "capability.controls": "Making a decision",
+  "planner.decision": "Planning",
+  "planner.graph": "Planning",
+  "reviewer.decision": "Reviewing",
+  "auditor.decision": "Reviewing",
+  "worker.result": "Summarizing results",
+  "supervisor.response": "Preparing response",
+  "execution.response": "Preparing response",
+  "degraded.finalization": "Preparing response",
+  "context.compact": "Compacting context",
+  "tool_payload.raw": "Working",
+});
+
+const SETTLED_TOOL_EVENTS = new Set([
+  "tool.completed",
+  "tool.failed",
+  "tool.payload.failed",
+  "tool.approval.rejected",
+]);
+
+function hasToolStatus(actions, status) {
+  return actions.some((action) => action.status === status);
+}
+
+function hasMatchingContextRequest(contextWindow, requestId) {
+  return textOf(contextWindow?.requestId) === requestId;
+}
+
+function hasPendingRequestCompaction(contextWindow, requestId) {
+  if (!hasMatchingContextRequest(contextWindow, requestId)) return false;
+  return Boolean(contextWindow.pendingCompaction);
+}
+
+function hasAcceptedRequestSnapshot(contextWindow, requestId) {
+  if (!hasMatchingContextRequest(contextWindow, requestId)) return false;
+  const snapshot = contextWindow.snapshot;
+  if (!snapshot) return false;
+  if (textOf(snapshot.requestId) !== requestId) return false;
+  return snapshot.admissionOutcome === "accepted";
+}
+
+function isSettledToolAfterSnapshot(event, snapshot) {
+  const name = textOf(
+    event.toolActivity?.name ||
+      event.eventName ||
+      event.name ||
+      event.rawType ||
+      event.type,
+  );
+  if (!SETTLED_TOOL_EVENTS.has(name)) return false;
+  return isEventAfterContextWindowSnapshot(snapshot, event);
+}
+
+function hasUsageForCurrentInvocation(contextWindow) {
+  const invocationId = textOf(contextWindow.snapshot?.invocationId);
+  if (!invocationId) return false;
+  return textOf(contextWindow.providerUsage?.invocationId) === invocationId;
+}
+
+function activeStatus(label) {
+  return { label, animate: true };
+}
+
+function modelStepLabel(modelStep) {
+  if (!Object.hasOwn(MODEL_STEP_LABELS, modelStep)) return "Working";
+  return MODEL_STEP_LABELS[modelStep];
+}
+
+export function buildConversationStatus({
+  requestId,
+  streaming = false,
+  connected = true,
+  contextWindow = null,
+  events = [],
+} = {}) {
+  const activeRequestId = textOf(requestId).trim();
+  if (!activeRequestId) return null;
+  if (!streaming) return null;
+  if (!connected) return { label: "Reconnecting", animate: false };
+
+  const scopedEvents = events.filter(
+    (event) => event.requestId === activeRequestId,
+  );
+  const tools = buildConversationToolActions({
+    requestId: activeRequestId,
+    streaming: true,
+    events: scopedEvents,
+  });
+  if (hasToolStatus(tools, "awaiting_approval")) {
+    return { label: "Waiting for approval", animate: false };
+  }
+  if (hasToolStatus(tools, "running")) return activeStatus("Running tool");
+  if (hasPendingRequestCompaction(contextWindow, activeRequestId)) {
+    return activeStatus("Compacting context");
+  }
+  if (hasToolStatus(tools, "preparing")) return activeStatus("Working");
+  if (!hasAcceptedRequestSnapshot(contextWindow, activeRequestId)) {
+    return activeStatus("Working");
+  }
+  const snapshot = contextWindow.snapshot;
+  const settledAfterSnapshot = scopedEvents.some((event) =>
+    isSettledToolAfterSnapshot(event, snapshot),
+  );
+  if (settledAfterSnapshot) return activeStatus("Working");
+  if (hasUsageForCurrentInvocation(contextWindow))
+    return activeStatus("Working");
+  return activeStatus(modelStepLabel(snapshot.modelStep));
+}

package/dist/src/web-ui/app/lib/dashboard-job-templates.js

@@ -0,0 +1,41 @@
+const templates = [
+  {
+    id: "briefing",
+    title: "Morning briefing",
+    description: "A concise roundup of the day's important news.",
+    timingLabel: "Daily · 08:00",
+    schedule: { kind: "daily", at: "08:00" },
+    prompt: "Find the five most significant world news developments from the past 24 hours. Give each a short headline, a two-sentence factual summary, and a link to a reliable source. Keep the briefing under 400 words.",
+  },
+  {
+    id: "learning",
+    title: "Learn something new",
+    description: "One useful idea, with an example to make it stick.",
+    timingLabel: "Weekdays · 12:00",
+    schedule: { kind: "weekly", at: "12:00", weekdays: [1, 2, 3, 4, 5] },
+    prompt: "Teach me one useful idea from science, history, technology, or everyday life in under 250 words. Explain it in plain language, give one concrete example, and finish with a question I can think about.",
+  },
+  {
+    id: "reflection",
+    title: "Weekly reflection",
+    description: "Pause, reflect, and choose a priority for next week.",
+    timingLabel: "Sunday · 18:00",
+    schedule: { kind: "weekly", at: "18:00", weekdays: [0] },
+    prompt: "Create a short weekly reflection exercise: three questions about what went well, what was difficult, and what to change next week. Finish with a simple template for choosing one priority. Do not assume anything about my work or personal circumstances.",
+  },
+];
+
+export function getDashboardJobTemplates() {
+  return structuredClone(templates);
+}
+
+export function dashboardJobInitialValues(templateId, modelProfileId) {
+  const template = templates.find((item) => item.id === templateId);
+  return {
+    ...(template ? structuredClone(template) : {}),
+    newConversation: true,
+    modelProfileId,
+    agentMode: "reasoning",
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+  };
+}

package/dist/src/web-ui/app/lib/dashboard-presentation.js

@@ -0,0 +1,126 @@
+import { formatTime, textOf } from "./text-format.js";
+import { isSessionReadStateUnavailable } from "./session-read-state.js";
+
+function timestampValue(value) {
+  if (value === null || value === undefined || value === "") return 0;
+  const normalized =
+    typeof value === "string" && /^\d+$/u.test(value) ? Number(value) : value;
+  const timestamp = new Date(normalized).getTime();
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
+
+function dashboardKnownUnreadCount(session) {
+  const count = Number(session.unreadCount);
+  if (Number.isFinite(count) && count > 0) return Math.floor(count);
+  return session.hasUnread === true ? 1 : 0;
+}
+
+export function dashboardUnreadCount(session) {
+  if (isSessionReadStateUnavailable(session)) return null;
+  return dashboardKnownUnreadCount(session);
+}
+
+function compareConversationRecency(left, right) {
+  return timestampValue(right.updatedAt) - timestampValue(left.updatedAt);
+}
+
+export function projectDashboardConversations(sessions = [], recentLimit = 6) {
+  const unique = new Map();
+  for (const session of [...sessions].sort(compareConversationRecency)) {
+    const id = textOf(session.id);
+    if (!id || unique.has(id)) continue;
+    unique.set(id, {
+      id,
+      title: textOf(session.displayName || session.title || id),
+      preview: textOf(session.lastMessagePreview),
+      updatedAt: session.updatedAt,
+      unreadCount: dashboardUnreadCount(session),
+      readStateUnavailable: isSessionReadStateUnavailable(session),
+      hasKnownUnreadMessages: dashboardKnownUnreadCount(session) > 0,
+    });
+  }
+  const conversations = [...unique.values()];
+  const unread = conversations.filter(
+    (session) => session.hasKnownUnreadMessages,
+  );
+  const read = conversations.filter(
+    (session) => !session.hasKnownUnreadMessages,
+  );
+  const availableReadSlots = Math.max(0, recentLimit - unread.length);
+  return {
+    conversations: [...unread, ...read.slice(0, availableReadSlots)],
+    totalCount: conversations.length,
+    hasUnavailableReadState: conversations.some(
+      (session) => session.readStateUnavailable,
+    ),
+    unreadCount: unread.reduce(
+      (total, session) => total + (session.unreadCount ?? 0),
+      0,
+    ),
+  };
+}
+
+const runOutcomes = {
+  pending: { label: "Waiting to run", tone: "neutral" },
+  running: { label: "Running", tone: "active" },
+  succeeded: { label: "Completed", tone: "success" },
+  failed: { label: "Failed", tone: "failed" },
+  cancelled: { label: "Cancelled", tone: "neutral" },
+  interrupted: { label: "Interrupted", tone: "failed" },
+  missed: { label: "Missed", tone: "neutral" },
+};
+
+function activityTimestamp(run) {
+  return run.scheduledAt;
+}
+
+export function projectDashboardActivity(runs = [], limit = 6) {
+  const ordered = [...runs].sort(
+    (left, right) =>
+      timestampValue(activityTimestamp(right)) -
+      timestampValue(activityTimestamp(left)),
+  );
+  const unique = new Map();
+  for (const run of ordered) {
+    const id = textOf(run.id);
+    if (!id || unique.has(id)) continue;
+    const outcome = runOutcomes[run.status] || {
+      label: "Status unavailable",
+      tone: "neutral",
+    };
+    unique.set(id, {
+      id,
+      title: textOf(run.title) || "Scheduled task",
+      sessionId: textOf(run.sessionId),
+      requestId: textOf(run.requestId),
+      timestamp: activityTimestamp(run),
+      statusLabel: outcome.label,
+      tone: outcome.tone,
+    });
+  }
+  return [...unique.values()].slice(0, limit);
+}
+
+export function dashboardTimePresentation(value, now = Date.now()) {
+  const timestamp = timestampValue(value);
+  if (!timestamp) return null;
+  const elapsed = now - timestamp;
+  const date = new Date(timestamp);
+  const presentation = {
+    dateTime: date.toISOString(),
+    title: formatTime(timestamp),
+    label: date.toLocaleDateString(undefined, {
+      month: "short",
+      day: "numeric",
+    }),
+  };
+  if (elapsed < 0) return { ...presentation, label: formatTime(timestamp) };
+  if (elapsed < 60000) return { ...presentation, label: "Just now" };
+  if (elapsed < 3600000)
+    return { ...presentation, label: `${Math.floor(elapsed / 60000)}m ago` };
+  if (elapsed < 86400000)
+    return { ...presentation, label: `${Math.floor(elapsed / 3600000)}h ago` };
+  if (elapsed < 604800000)
+    return { ...presentation, label: `${Math.floor(elapsed / 86400000)}d ago` };
+  return presentation;
+}

package/dist/src/web-ui/app/lib/message-markdown.d.ts

@@ -0,0 +1,5 @@
+export declare function renderMarkdown(raw: unknown): string;
+export declare function extractMessageLinks(raw: unknown): Array<{
+  url: string;
+  label: string;
+}>;

package/dist/src/web-ui/app/lib/message-markdown.js

@@ -0,0 +1,99 @@
+import MarkdownIt from "../vendor/markdown-it.js";
+import { safeLinkHref } from "./message-url-policy.js";
+import { parseWebSourceUrl } from "./source-url-policy.js";
+
+const markdown = new MarkdownIt({
+  html: false,
+  breaks: true,
+  linkify: true,
+  typographer: false,
+});
+
+markdown.linkify.set({ fuzzyLink: true });
+
+// Leave parsing to the Markdown grammar, then apply the stricter display
+// policy. Rejecting a valid Markdown token during parsing can make linkify
+// reinterpret only a fragment of its destination as an unrelated URL.
+markdown.renderer.rules.link_open = (tokens, index, options, env, renderer) => {
+  const token = tokens[index];
+  if (!safeLinkHref(token.attrGet("href"))) {
+    const closing = tokens
+      .slice(index + 1)
+      .find((item) => item.type === "link_close");
+    if (closing) closing.hidden = true;
+    return "";
+  }
+  token.attrSet("target", "_blank");
+  token.attrSet("rel", "noopener noreferrer");
+  return renderer.renderToken(tokens, index, options);
+};
+markdown.renderer.rules.table_open = () =>
+  '<div class="markdown-table-scroll" role="region" aria-label="Message table" tabindex="0"><table>\n';
+markdown.renderer.rules.table_close = () => "</table></div>\n";
+
+function isImageInsideLink(tokens, index) {
+  const boundary = tokens
+    .slice(0, index)
+    .findLast(
+      (token) => token.type === "link_open" || token.type === "link_close",
+    );
+  return boundary?.type === "link_open";
+}
+
+// Remote images use the bounded preview path too: rendering a message must
+// never issue an unchecked image request to an arbitrary host.
+markdown.renderer.rules.image = (tokens, index) => {
+  const token = tokens[index];
+  const label = markdown.utils.escapeHtml(token.content || "Image");
+  if (isImageInsideLink(tokens, index)) return label;
+  const href = safeLinkHref(token.attrGet("src"));
+  if (!href) return label;
+  return `<a href="${markdown.utils.escapeHtml(href)}" target="_blank" rel="noopener noreferrer">${label}</a>`;
+};
+
+function messageSource(raw) {
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" || typeof raw === "boolean") return String(raw);
+  return "";
+}
+
+export function renderMarkdown(raw) {
+  return markdown.render(messageSource(raw));
+}
+
+function inlineLinkLabel(tokens, start) {
+  const label = [];
+  for (let index = start + 1; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token.type === "link_close") break;
+    if (token.content) label.push(token.content);
+  }
+  return label.join("");
+}
+
+export function extractMessageLinks(raw) {
+  const links = [];
+  const seen = new Set();
+  const blocks = markdown.parse(messageSource(raw), {});
+  for (const block of blocks) {
+    if (block.type !== "inline") continue;
+    const tokens = block.children || [];
+    for (const [index, token] of tokens.entries()) {
+      const isImage = token.type === "image";
+      if (token.type !== "link_open" && !isImage) continue;
+      if (isImage && isImageInsideLink(tokens, index)) continue;
+      const url = parseWebSourceUrl(token.attrGet(isImage ? "src" : "href"));
+      if (!url) continue;
+      const key = new URL(url.href);
+      key.hash = "";
+      if (seen.has(key.href)) continue;
+      seen.add(key.href);
+      links.push({
+        url: url.href,
+        label: isImage ? token.content : inlineLinkLabel(tokens, index),
+      });
+      if (links.length === 3) return links;
+    }
+  }
+  return links;
+}

package/dist/src/web-ui/app/lib/message-url-policy.d.ts

@@ -0,0 +1 @@
+export declare function safeLinkHref(value: unknown, baseHref?: string): string;

package/dist/src/web-ui/app/lib/message-url-policy.js

@@ -0,0 +1,13 @@
+export function safeLinkHref(value, baseHref = globalThis.location?.href) {
+  if (typeof value !== "string" || !value.trim()) return "";
+  if (value.length > 4_096 || /[\u0000-\u0020\u007f]/u.test(value)) return "";
+  try {
+    const url = new URL(value, baseHref);
+    if (url.username || url.password) return "";
+    if (url.protocol === "http:" || url.protocol === "https:") return url.href;
+    if (url.protocol === "mailto:") return url.href;
+    return "";
+  } catch {
+    return "";
+  }
+}