cortena-ui 1.4.2 → 1.5.0

package/src/agent-chat/store.ts

@@ -0,0 +1,738 @@
+"use client";
+
+/**
+ * The chat state, and the hook that drives an `AgentChatClient` from React.
+ *
+ * The accumulation rules are ported from `cortena-shared/src/stores/use-chat.ts`
+ * (Cortena monorepo) so a run leaves this state in the same place it leaves
+ * cortenaweb's. The ones that are not obvious, and that a rewrite gets wrong:
+ *
+ * - A `delta` carries a snapshot, so text and A2UI blocks are **replaced**, not
+ *   appended. Appending doubles every character.
+ * - Thinking is never replaced by something shorter. The upstream emitter can
+ *   fall back to increments when a snapshot is unavailable, and treating one of
+ *   those as a snapshot truncates the accumulated chain of thought.
+ * - On `final`, a second assistant message in the same turn folds the previous
+ *   visible text into the chain of thought rather than adding a second bubble,
+ *   and keeps the A2UI blocks of the message it folded away — the surface is
+ *   still on screen and still interactive.
+ * - A reply that is only a drawn surface has no text, so `text || a2ui.length`
+ *   is the test for "there is something to show". Testing text alone silently
+ *   dropped everything the agent drew.
+ */
+
+import * as React from "react";
+import { type A2UIChatBlock, extractA2UIBlocks, foldA2UIBlocks } from "./a2ui-block";
+import {
+  isProvisionalSessionKey,
+  isSessionOfAgent,
+  mintSessionKey,
+  parseHistoryMessages,
+  readStoredSessionKey,
+  separateThinking,
+  wouldShrinkHistory,
+  writeStoredSessionKey,
+} from "./session";
+import type {
+  AgentApprovalDecision,
+  AgentApprovalRequest,
+  AgentChatClient,
+  AgentChatEvent,
+  AgentChatHistoryResponse,
+  AgentChatMessage,
+  AgentSession,
+  AgentSessionsListResponse,
+  AgentToolEvent,
+} from "./types";
+
+export interface AgentToolEntry {
+  id: string;
+  name: string;
+  status: "running" | "complete" | "error";
+  input?: unknown;
+  output?: unknown;
+  startedAt: number;
+  completedAt?: number;
+}
+
+export interface AgentChatState {
+  sessionKey: string | null;
+  messages: AgentChatMessage[];
+  streaming: boolean;
+  streamText: string;
+  streamThinkingText: string;
+  streamA2ui: A2UIChatBlock[];
+  runId: string | null;
+  hasMoreHistory: boolean;
+  loadingHistory: boolean;
+  toolOrder: string[];
+  tools: Record<string, AgentToolEntry>;
+  approvals: AgentApprovalRequest[];
+  /**
+   * Transcript RECORDS loaded, which is not `messages.length`.
+   *
+   * `parseHistoryMessages` folds a turn — an assistant preamble, the tool call,
+   * the tool result, the answer — into one visible message, so the two numbers
+   * diverge on the very first agent turn. `offset` is an offset into the
+   * server's records, and paging with the folded count asked for records the
+   * screen already had and skipped the ones it did not: "load older" silently
+   * lost messages the further back a user read.
+   */
+  historyCount: number;
+  sessions: AgentSession[];
+  loadingSessions: boolean;
+  /** A failure the user has to be told about, e.g. no template for the slug. */
+  error: string | null;
+}
+
+const EMPTY: AgentChatState = {
+  sessionKey: null,
+  messages: [],
+  streaming: false,
+  streamText: "",
+  streamThinkingText: "",
+  streamA2ui: [],
+  runId: null,
+  hasMoreHistory: false,
+  loadingHistory: false,
+  toolOrder: [],
+  tools: {},
+  approvals: [],
+  historyCount: 0,
+  sessions: [],
+  loadingSessions: false,
+  error: null,
+};
+
+type Action =
+  | { kind: "chat"; event: AgentChatEvent }
+  | { kind: "tool"; event: AgentToolEvent }
+  | { kind: "approval/request"; request: AgentApprovalRequest }
+  | { kind: "approval/resolved"; id: string }
+  | { kind: "approval/failed"; request: AgentApprovalRequest; message: string }
+  | { kind: "session"; key: string | null }
+  | { kind: "send"; message: AgentChatMessage | null; runId: string; sessionKey: string }
+  | { kind: "send/failed"; message: string }
+  | { kind: "abort" }
+  | { kind: "history/loading" }
+  | {
+      kind: "history/loaded";
+      sessionKey: string;
+      messages: AgentChatMessage[];
+      hasMore: boolean;
+      records: number;
+    }
+  | { kind: "history/older"; messages: AgentChatMessage[]; hasMore: boolean; records: number }
+  | { kind: "history/failed" }
+  | { kind: "sessions/loading" }
+  | { kind: "sessions/loaded"; sessions: AgentSession[] }
+  | { kind: "error"; message: string | null };
+
+function generateId(): string {
+  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+
+function extractText(message?: AgentChatEvent["message"]): string {
+  return (message?.content ?? [])
+    .filter((c) => c.type === "text" && c.text)
+    .map((c) => c.text!)
+    .join("");
+}
+
+function extractThinking(message?: AgentChatEvent["message"]): string {
+  const blocks = (message?.content ?? [])
+    .filter((c) => c.type === "thinking")
+    .map((c) => c.thinking ?? c.text ?? "")
+    .filter(Boolean);
+  return blocks.join("\n\n");
+}
+
+function reduce(state: AgentChatState, action: Action): AgentChatState {
+  switch (action.kind) {
+    case "chat":
+      return reduceChat(state, action.event);
+    case "tool":
+      return reduceTool(state, action.event);
+    case "approval/request":
+      return state.approvals.some((r) => r.id === action.request.id)
+        ? state
+        : { ...state, approvals: [...state.approvals, action.request] };
+    case "approval/resolved":
+      return { ...state, approvals: state.approvals.filter((r) => r.id !== action.id) };
+    case "approval/failed":
+      // The decision did not land, so the card comes back — with the reason on
+      // it. Removing it optimistically and then swallowing the failure left
+      // the user certain they had answered and the run paused for ever.
+      return state.approvals.some((r) => r.id === action.request.id)
+        ? state
+        : {
+            ...state,
+            approvals: [...state.approvals, { ...action.request, error: action.message }],
+          };
+    case "session":
+      return action.key === state.sessionKey
+        ? state
+        : { ...EMPTY, sessions: state.sessions, sessionKey: action.key };
+    case "send":
+      return {
+        ...state,
+        sessionKey: action.sessionKey,
+        messages: action.message ? [...state.messages, action.message] : state.messages,
+        streaming: true,
+        streamText: "",
+        streamThinkingText: "",
+        streamA2ui: [],
+        runId: action.runId,
+        toolOrder: [],
+        tools: {},
+        // A new run is a new set of pending decisions. An approval card left
+        // over from the previous run points at a run that is over, and
+        // answering it sends a decision nothing is waiting for.
+        approvals: [],
+        error: null,
+      };
+    case "send/failed":
+      return {
+        ...state,
+        streaming: false,
+        runId: null,
+        messages: [
+          ...state.messages,
+          {
+            id: generateId(),
+            role: "assistant",
+            text: action.message,
+            timestamp: Date.now(),
+            isError: true,
+          },
+        ],
+      };
+    case "abort":
+      // Reset immediately so the composer flips Stop -> Send without waiting on
+      // a server event an aborted run does not reliably send.
+      return {
+        ...state,
+        streaming: false,
+        streamText: "",
+        streamThinkingText: "",
+        streamA2ui: [],
+        runId: null,
+        // The run they belonged to is gone; the decisions go with it.
+        approvals: [],
+      };
+    case "history/loading":
+      return { ...state, loadingHistory: true };
+    case "history/loaded":
+      if (
+        wouldShrinkHistory({
+          currentSessionKey: state.sessionKey,
+          loadedSessionKey: action.sessionKey,
+          currentCount: state.messages.length,
+          loadedCount: action.messages.length,
+        })
+      ) {
+        return {
+          ...state,
+          sessionKey: action.sessionKey,
+          hasMoreHistory: action.hasMore,
+          loadingHistory: false,
+          historyCount: action.records,
+        };
+      }
+      return {
+        ...state,
+        sessionKey: action.sessionKey,
+        messages: action.messages,
+        hasMoreHistory: action.hasMore,
+        loadingHistory: false,
+        historyCount: action.records,
+        // Avoids an orphan streaming bubble beside reloaded history.
+        streaming: false,
+        streamText: "",
+        streamThinkingText: "",
+        streamA2ui: [],
+      };
+    case "history/older":
+      return {
+        ...state,
+        messages: [...action.messages, ...state.messages],
+        hasMoreHistory: action.hasMore,
+        loadingHistory: false,
+        historyCount: state.historyCount + action.records,
+      };
+    case "history/failed":
+      return { ...state, loadingHistory: false };
+    case "sessions/loading":
+      return { ...state, loadingSessions: true };
+    case "sessions/loaded":
+      return { ...state, sessions: action.sessions, loadingSessions: false };
+    case "error":
+      return { ...state, error: action.message };
+    default:
+      return state;
+  }
+}
+
+function reduceChat(state: AgentChatState, event: AgentChatEvent): AgentChatState {
+  // Events from another session are dropped, or one window's run leaks into
+  // another window's transcript. A provisional key is the exception: the server
+  // echoes it back today, but if it ever canonicalised the key instead, dropping
+  // the event would silently kill the whole first turn.
+  if (event.sessionKey && state.sessionKey && event.sessionKey !== state.sessionKey) {
+    if (!isProvisionalSessionKey(state.sessionKey)) {
+      return state;
+    }
+    state = { ...state, sessionKey: event.sessionKey };
+  } else if (event.sessionKey && !state.sessionKey) {
+    state = { ...state, sessionKey: event.sessionKey };
+  }
+
+  switch (event.state) {
+    case "delta": {
+      const text = extractText(event.message);
+      const thinking = extractThinking(event.message);
+      const a2ui = extractA2UIBlocks(event.message);
+      const next: AgentChatState = { ...state, streaming: true };
+      if (text) {
+        next.streamText = text;
+      }
+      if (a2ui.length > 0) {
+        next.streamA2ui = a2ui;
+      }
+      // Never replace accumulated thinking with something shorter.
+      const acceptThinking = !!thinking && thinking.length >= state.streamThinkingText.length;
+      if (acceptThinking) {
+        next.streamThinkingText = thinking;
+      }
+      return text || acceptThinking || a2ui.length > 0 ? next : state;
+    }
+    case "final": {
+      const finalText = extractText(event.message);
+      const finalThinking = extractThinking(event.message);
+      const finalA2ui = extractA2UIBlocks(event.message);
+      const text = finalText || state.streamText;
+      const thinkingFromBlocks = finalThinking || state.streamThinkingText;
+      const a2ui = foldA2UIBlocks(finalA2ui.length > 0 ? finalA2ui : state.streamA2ui);
+      // The run id deliberately SURVIVES a final. A run can end more than
+      // once — an interrupt for an approval, then the continuation — and
+      // clearing it here meant the second final saw `runId: null`, could not
+      // fold, and pushed a second bubble: one answer to one question, drawn
+      // as two. `send` sets the next run's id, and `abort`, `error` and
+      // `send/failed` each clear it, so nothing outlives the turn it belongs
+      // to.
+      const cleared = {
+        streaming: false,
+        streamText: "",
+        streamThinkingText: "",
+        streamA2ui: [] as A2UIChatBlock[],
+      };
+
+      if (!text && a2ui.length === 0) {
+        // No text and nothing drawn: fold whatever thinking accumulated into
+        // the previous turn rather than dropping it.
+        const accumulated = state.streamThinkingText;
+        const last = state.messages[state.messages.length - 1];
+        if (!accumulated || !foldsInto(last, state.runId)) {
+          return { ...state, ...cleared };
+        }
+        const messages = [...state.messages];
+        messages[messages.length - 1] = {
+          ...last,
+          timestamp: Date.now(),
+          thinkingText: [last.thinkingText ?? "", accumulated].filter(Boolean).join("\n\n"),
+        };
+        return { ...state, ...cleared, messages };
+      }
+
+      const { thinkingText: tagThinking, mainText } = separateThinking(text);
+      const thinkingText = thinkingFromBlocks || tagThinking;
+      const displayText = thinkingFromBlocks ? text : mainText;
+      const messages = [...state.messages];
+      const last = messages[messages.length - 1];
+
+      if (foldsInto(last, state.runId)) {
+        const combined = [last.thinkingText ?? "", last.text.trim()].filter(Boolean).join("\n\n");
+        const updated = [combined, thinkingText].filter(Boolean).join("\n\n");
+        messages[messages.length - 1] = {
+          ...last,
+          text: displayText,
+          timestamp: Date.now(),
+          ...(updated ? { thinkingText: updated } : { thinkingText: undefined }),
+          ...(a2ui.length > 0 || last.a2ui?.length
+            ? { a2ui: foldA2UIBlocks([...(last.a2ui ?? []), ...a2ui]) }
+            : {}),
+        };
+      } else {
+        messages.push({
+          id: generateId(),
+          role: "assistant",
+          text: displayText,
+          timestamp: Date.now(),
+          // The run this bubble belongs to, so the NEXT run's `final` cannot
+          // fold its answer into it.
+          ...(state.runId ? { runId: state.runId } : {}),
+          ...(thinkingText ? { thinkingText } : {}),
+          ...(a2ui.length > 0 ? { a2ui } : {}),
+        });
+      }
+      return { ...state, ...cleared, messages };
+    }
+    case "error":
+      return {
+        ...state,
+        streaming: false,
+        streamText: "",
+        streamThinkingText: "",
+        streamA2ui: [],
+        runId: null,
+        messages: [
+          ...state.messages,
+          {
+            id: generateId(),
+            role: "assistant",
+            text: event.errorMessage ?? "An error occurred",
+            timestamp: Date.now(),
+            isError: true,
+          },
+        ],
+      };
+    default:
+      return state;
+  }
+}
+
+/**
+ * May a `final` fold into this message?
+ *
+ * Only when it is an assistant bubble from the SAME run. Two assistant
+ * messages in one turn are one answer with an interruption in the middle, and
+ * folding them is right. Two assistant messages from different runs are two
+ * answers to two questions, and folding them rewrote the earlier answer with
+ * the later one — visibly, in a transcript the user had already read.
+ *
+ * A message with no `runId` is history, which never folds either.
+ */
+function foldsInto(
+  last: AgentChatMessage | undefined,
+  runId: string | null,
+): last is AgentChatMessage {
+  return (
+    last !== undefined &&
+    last.role === "assistant" &&
+    !last.isError &&
+    runId !== null &&
+    last.runId === runId
+  );
+}
+
+function reduceTool(state: AgentChatState, event: AgentToolEvent): AgentChatState {
+  const id = event.data.id;
+  if (!id) {
+    return state;
+  }
+  const existing = state.tools[id];
+  const base: AgentToolEntry = existing ?? {
+    id,
+    name: event.data.name ?? "tool",
+    status: "running",
+    startedAt: event.data.startedAt ?? Date.now(),
+  };
+  let entry: AgentToolEntry;
+  switch (event.event) {
+    case "tool.start":
+      entry = { ...base, name: event.data.name ?? base.name, status: "running" };
+      break;
+    case "tool.args":
+      entry = { ...base, input: event.data.input };
+      break;
+    case "tool.progress":
+      entry = { ...base, output: event.data.output };
+      break;
+    case "tool.complete":
+      entry = {
+        ...base,
+        status: "complete",
+        output: event.data.output,
+        completedAt: event.data.completedAt ?? Date.now(),
+      };
+      break;
+    case "tool.error":
+      entry = {
+        ...base,
+        status: "error",
+        output: event.data.output,
+        completedAt: event.data.completedAt ?? Date.now(),
+      };
+      break;
+    default:
+      return state;
+  }
+  return {
+    ...state,
+    tools: { ...state.tools, [id]: entry },
+    toolOrder: state.toolOrder.includes(id) ? state.toolOrder : [...state.toolOrder, id],
+  };
+}
+
+/* ── the hook ────────────────────────────────────────────────────────────── */
+
+export interface UseAgentChatOptions {
+  client: AgentChatClient;
+  /**
+   * Names the `sessionStorage` slot the current session key lives in. Two
+   * pop-ups with different scopes never share a key, which is what keeps one
+   * extension's chat out of another's.
+   */
+  storageScope: string;
+  /** Skip reading and writing `sessionStorage`; for a transient mount. */
+  ephemeral?: boolean;
+  thinking?: "low" | "medium" | "high";
+}
+
+export interface UseAgentChatResult extends AgentChatState {
+  send: (text: string, attachments?: unknown[]) => void;
+  sendAction: (action: NonNullable<Parameters<AgentChatClient["send"]>[0]["a2uiAction"]>) => void;
+  abort: () => void;
+  resolveApproval: (id: string, decision: AgentApprovalDecision) => void;
+  newSession: () => void;
+  resumeSession: (key: string) => void;
+  loadOlder: () => void;
+  refreshSessions: () => void;
+}
+
+export function useAgentChat({
+  client,
+  storageScope,
+  ephemeral,
+  thinking,
+}: UseAgentChatOptions): UseAgentChatResult {
+  const [state, dispatch] = React.useReducer(reduce, EMPTY);
+  const stateRef = React.useRef(state);
+  stateRef.current = state;
+
+  // Subscribe once per client. A pop-up that collapses unmounts the surface but
+  // keeps the client, so a run started before the collapse still lands.
+  React.useEffect(() => {
+    const offChat = client.onChat((event) => dispatch({ kind: "chat", event }));
+    const offTool = client.onTool((event) => dispatch({ kind: "tool", event }));
+    const offApproval = client.onApproval((event) => {
+      if (event.type === "request") {
+        dispatch({ kind: "approval/request", request: event.request });
+      } else {
+        dispatch({ kind: "approval/resolved", id: event.id });
+      }
+    });
+    return () => {
+      offChat();
+      offTool();
+      offApproval();
+    };
+  }, [client]);
+
+  const refreshSessions = React.useCallback(() => {
+    dispatch({ kind: "sessions/loading" });
+    void client
+      .request<AgentSessionsListResponse>("sessions.list", { includeDerivedTitles: true })
+      .then((response) => {
+        // Filtered to this agent: a shared control plane lists every session on
+        // the pod, and an extension must never show another agent's chats.
+        const sessions = (response?.sessions ?? []).filter((s) =>
+          isSessionOfAgent(s.key, client.agentId),
+        );
+        dispatch({ kind: "sessions/loaded", sessions });
+      })
+      .catch((err: unknown) => {
+        dispatch({ kind: "sessions/loaded", sessions: [] });
+        dispatch({ kind: "error", message: errorText(err) });
+      });
+  }, [client]);
+
+  const loadHistory = React.useCallback(
+    (sessionKey: string) => {
+      dispatch({ kind: "history/loading" });
+      void client
+        .request<AgentChatHistoryResponse>("chat.history", { sessionKey, limit: 100 })
+        .then((response) => {
+          const records = response?.messages ?? [];
+          dispatch({
+            kind: "history/loaded",
+            sessionKey,
+            messages: parseHistoryMessages(records),
+            hasMore: response?.hasMore ?? false,
+            records: records.length,
+          });
+        })
+        .catch(() => dispatch({ kind: "history/failed" }));
+    },
+    [client],
+  );
+
+  // Restore this window's session, or mint one. `sessionStorage`, not
+  // `localStorage`: a second window must not adopt the first window's session.
+  const restored = React.useRef(false);
+  React.useEffect(() => {
+    if (restored.current) {
+      return;
+    }
+    restored.current = true;
+    const stored = ephemeral ? null : readStoredSessionKey(storageScope);
+    const key = stored && isSessionOfAgent(stored, client.agentId) ? stored : null;
+    if (key) {
+      dispatch({ kind: "session", key });
+      loadHistory(key);
+    }
+    refreshSessions();
+  }, [client, ephemeral, loadHistory, refreshSessions, storageScope]);
+
+  const setSession = React.useCallback(
+    (key: string) => {
+      dispatch({ kind: "session", key });
+      if (!ephemeral) {
+        writeStoredSessionKey(storageScope, key);
+      }
+    },
+    [ephemeral, storageScope],
+  );
+
+  const run = React.useCallback(
+    (text: string, extra: Partial<Parameters<AgentChatClient["send"]>[0]> = {}) => {
+      const current = stateRef.current;
+      // One run at a time. A second `send` on a streaming session opens a
+      // second stream into one store: two sets of deltas overwrite each
+      // other's snapshot, `final` folds one run's answer into the other's
+      // bubble, and `abort` can only reach whichever the client thinks is
+      // active. The composer disables Send while a run is live; this is the
+      // same rule for Enter, for a2ui actions and for a caller of the hook.
+      if (current.streaming) {
+        return;
+      }
+      const sessionKey = current.sessionKey ?? mintSessionKey(client.agentId);
+      if (!current.sessionKey && !ephemeral) {
+        writeStoredSessionKey(storageScope, sessionKey);
+      }
+      const runId = generateId();
+      // An action with no typed text is a click, not a sentence: a user bubble
+      // for it would put `{"name":"createTask"}` in the transcript as though
+      // the user had said it.
+      const message: AgentChatMessage | null =
+        text || (!extra.a2uiAction && !extra.mcpAppAction)
+          ? { id: runId, role: "user", text, timestamp: Date.now(), runId }
+          : null;
+      dispatch({ kind: "send", message, runId, sessionKey });
+      void client
+        .send({
+          sessionKey,
+          message: text,
+          runId,
+          ...(thinking ? { thinking } : {}),
+          ...extra,
+        })
+        .then(() => refreshSessions())
+        .catch((err: unknown) => dispatch({ kind: "send/failed", message: errorText(err) }));
+    },
+    [client, ephemeral, refreshSessions, storageScope, thinking],
+  );
+
+  const send = React.useCallback(
+    (text: string, attachments?: unknown[]) => {
+      run(text, attachments?.length ? { attachments } : {});
+    },
+    [run],
+  );
+
+  const sendAction = React.useCallback(
+    (a2uiAction: NonNullable<Parameters<AgentChatClient["send"]>[0]["a2uiAction"]>) => {
+      run("", { a2uiAction });
+    },
+    [run],
+  );
+
+  const abort = React.useCallback(() => {
+    const { runId, sessionKey } = stateRef.current;
+    dispatch({ kind: "abort" });
+    void client
+      .abort({
+        ...(runId ? { runId } : {}),
+        ...(sessionKey ? { sessionKey } : {}),
+      })
+      .catch(() => {
+        // Best-effort: local state is already reset, and dropping the stream
+        // aborts the run server-side anyway.
+      });
+  }, [client]);
+
+  const resolveApproval = React.useCallback(
+    (id: string, decision: AgentApprovalDecision) => {
+      const request = stateRef.current.approvals.find((r) => r.id === id);
+      if (!request) {
+        return;
+      }
+      dispatch({ kind: "approval/resolved", id });
+      // Bound to the run and the session the REQUEST arrived on, never to
+      // whatever is in flight now. The two come apart the moment a user opens
+      // another session while a command waits for an answer.
+      void client
+        .resolveApproval(id, decision, {
+          runId: request.runId,
+          sessionKey: request.sessionKey,
+        })
+        .catch((err: unknown) => {
+          dispatch({ kind: "approval/failed", request, message: errorText(err) });
+        });
+    },
+    [client],
+  );
+
+  const newSession = React.useCallback(() => {
+    setSession(mintSessionKey(client.agentId));
+  }, [client, setSession]);
+
+  const resumeSession = React.useCallback(
+    (key: string) => {
+      setSession(key);
+      loadHistory(key);
+    },
+    [loadHistory, setSession],
+  );
+
+  const loadOlder = React.useCallback(() => {
+    const current = stateRef.current;
+    if (!current.sessionKey || current.loadingHistory || !current.hasMoreHistory) {
+      return;
+    }
+    dispatch({ kind: "history/loading" });
+    void client
+      .request<AgentChatHistoryResponse>("chat.history", {
+        sessionKey: current.sessionKey,
+        limit: 100,
+        // Records, not bubbles. See `historyCount`.
+        offset: current.historyCount,
+      })
+      .then((response) => {
+        const records = response?.messages ?? [];
+        dispatch({
+          kind: "history/older",
+          messages: parseHistoryMessages(records),
+          hasMore: response?.hasMore ?? false,
+          records: records.length,
+        });
+      })
+      .catch(() => dispatch({ kind: "history/failed" }));
+  }, [client]);
+
+  return {
+    ...state,
+    send,
+    sendAction,
+    abort,
+    resolveApproval,
+    newSession,
+    resumeSession,
+    loadOlder,
+    refreshSessions,
+  };
+}
+
+function errorText(err: unknown): string {
+  return err instanceof Error ? err.message : "The agent could not be reached";
+}