thursday-agent 0.2.0 → 0.4.0

package/features/ai/tools/memory.tool.ts

@@ -1,22 +1,29 @@
 import { tool } from "ai";
 import * as z from "zod";
-import { appEvents } from "@/app/api/events/app-event.server";
+import { MEMORY_CONVERSATION_PAGE, MEMORY_LIMITS } from "@/config";
+import {
+  callStamp,
+  conversationLines,
+  saidStamp,
+} from "@/features/ai/prompts/prompt-helper";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import {
+  findFactCall,
   forgetFactById,
   readNotes,
   resolveNotePath,
   writeNotes,
 } from "@/features/memory/memory.query";
 import {
-  ALWAYS_LOADED_MAX,
-  isAlwaysListed,
+  APP_NAMED_NOTES,
+  appNoteLine,
+  isAppNamed,
   isMemoryPath,
-  MANY_FACTS,
-  MEMORY_ALWAYS_LISTED,
   MEMORY_INBOX,
+  type MemoryNoteView,
   type MemorySource,
 } from "@/features/memory/memory.schema";
+import { readCallConversation } from "@/features/thursday/thursday.query";
 
 const GONE =
   "Deleted for good. The listing in your instructions is from when this session opened and still shows it that way until the next one.";
@@ -24,16 +31,56 @@ const GONE =
 const WROTE =
   "Saved. The listing in your instructions is from when this session opened and will not show this until the next one — the note below is current.";
 
-/** Attached only when a note past MANY_FACTS is actually opened, instead of a standing rule in the prompt. */
-const tooMany = (path: string, count: number) =>
-  ` ${path} carries ${count} facts — enough that it is worth tidying. Put it on screen with \`${TOOL_NAMES.memory_show}\` and ask which of it they no longer need.`;
+/**
+ * A note as a model reads it: how many facts it holds now, and `said` on each
+ * fact a call wrote — the local time of that call, the same stamp its
+ * conversation opens with, so a fact from a call already in the prompt reads
+ * as that call. Never the Date itself: it would serialise as UTC.
+ */
+const withCount = (note: MemoryNoteView) => ({
+  ...note,
+  facts: note.facts.map(({ saidAt, ...fact }) =>
+    saidAt ? { ...fact, said: saidStamp(saidAt) } : fact,
+  ),
+  factCount: note.facts.length,
+});
+
+/** Why a fact has no conversation to open, by the hand that wrote it. */
+const noConversation = (source: MemorySource | null) =>
+  source === "user"
+    ? "Typed on the screen — there is no conversation behind it."
+    : source === "bot"
+      ? "Saved by a bot during a job — there is no conversation behind it."
+      : "The conversation it was saved in is not kept.";
+
+/**
+ * Said when a note has outgrown the recommended size, and only then — the write
+ * itself always goes through. It names no tool: this one answers the call and a
+ * bot, and how to settle it with the user is the call's to say (prompts/thursday.prompt);
+ * the ask is the same either way, because a bot that turned up a fact can hand
+ * the same request back with it.
+ */
+const overSize = (count: number) =>
+  count > MEMORY_LIMITS.factsPerNote
+    ? ` This note now holds ${count} facts, past the ${MEMORY_LIMITS.factsPerNote} one note holds well. Ask the user which of it is no longer true and delete what they name.`
+    : "";
 
 /**
  * @param source Which hand these writes are recorded under. The runtime knows
- * it without being told — the call, the read-back pass — so no model ever
- * chooses it (load-tools, memory.schema MemorySource).
+ * it without being told, so no model ever chooses it (load-tools,
+ * memory.schema MemorySource).
+ * @param callId The call these tools serve, when there is one: recorded on
+ * what `memory_remember` writes, and the conversation `memory_conversation`
+ * does not hand back because the model is already in it.
+ * @param options.countReads Whether opening a note counts as reading it. The
+ * counts rank notes cold in the call prompt, so only a runtime that recalls on
+ * the user's behalf counts; an edit opening a note to change it does not.
  */
-export const createMemoryTools = (source: MemorySource) => ({
+export const createMemoryTools = (
+  source: MemorySource,
+  callId: string | null = null,
+  { countReads = true }: { countReads?: boolean } = {},
+) => ({
   [TOOL_NAMES.memory_recall]: tool({
     description: "Open one note from the listing, whole.",
     inputSchema: z.object({
@@ -44,14 +91,13 @@ export const createMemoryTools = (source: MemorySource) => ({
         ),
     }),
     execute: async ({ path }) => {
-      const { notes } = await readNotes([path]);
+      const { notes } = await readNotes([path], { touch: countReads });
       const note = notes[0];
       // A missing note is an answer to relay, not a reason to retry spellings
       if (!note)
         return { note: `Nothing on the listing called ${path.trim()}.` };
-      return note.facts.length > MANY_FACTS
-        ? { ...note, note: tooMany(note.path, note.facts.length).trim() }
-        : note;
+      const over = overSize(note.facts.length);
+      return over ? { ...withCount(note), note: over.trim() } : withCount(note);
     },
   }),
 
@@ -67,7 +113,9 @@ export const createMemoryTools = (source: MemorySource) => ({
         .object({
           text: z
             .string()
-            .describe("One statement that stands on its own later."),
+            .describe(
+              'One statement that stands on its own later — a date as a date, never "next week".',
+            ),
           replaces: z
             .number()
             .int()
@@ -79,7 +127,7 @@ export const createMemoryTools = (source: MemorySource) => ({
             .boolean()
             .nullish()
             .describe(
-              `True carries this line into every call's instructions without opening its note — for what to call them, their language and register, a standing rule. At most ${ALWAYS_LOADED_MAX}. Null leaves it; false makes a carried line an ordinary fact.`,
+              `True carries this line into every call's instructions without opening its note — for what every call needs before any note is opened: what to call them, their language and register. At most ${MEMORY_LIMITS.carried}. Null leaves it; false makes a carried line an ordinary fact.`,
             ),
         })
         .array()
@@ -91,7 +139,7 @@ export const createMemoryTools = (source: MemorySource) => ({
         .string()
         .nullish()
         .describe(
-          `One line saying what this note is about, not what it currently says. Give it for a new note, or when the line no longer fits. Null leaves it; ${MEMORY_ALWAYS_LISTED.join(" and ")} keep their own line.`,
+          `One line saying what this note is about, not what it currently says. Give it for a new note, or when the line no longer fits. Null leaves it; ${APP_NAMED_NOTES.join(", ")} keep their own line.`,
         ),
       aliases: z
         .string()
@@ -106,11 +154,15 @@ export const createMemoryTools = (source: MemorySource) => ({
       const said = input.path.trim();
       const known = await resolveNotePath(said);
       const aliases = input.aliases ?? null;
-      // The listing line of the always-listed notes belongs to the app (memory.query ensureRootNotes);
-      // the model's description is ignored there. `alwaysLoad` is not forced on them either:
-      // the first-call opener (thursday.prompt) asks the model to set it.
-      const owned = isAlwaysListed(known ?? said);
-      const description = owned ? null : input.description?.trim() || null;
+      // The listing line of the app-named notes is the app's (memory.schema
+      // isAppNamed); the model's description is ignored there and its own line
+      // written instead, so the inbox cannot end up described by whatever fell
+      // into it. `alwaysLoad` is not forced on them: the first-call opener
+      // (thursday.prompt) asks the model to set it.
+      const target = known ?? said;
+      const description = isAppNamed(target)
+        ? appNoteLine(target)
+        : input.description?.trim() || null;
       const facts = input.facts ?? [];
       if (!facts.length && !description && !aliases) {
         return {
@@ -124,139 +176,151 @@ export const createMemoryTools = (source: MemorySource) => ({
         };
       }
       // A new path outside the convention goes to inbox, which keeps its own line and takes no aliases
-      const filed =
-        known || isMemoryPath(said)
-          ? { path: known ?? said, description, aliases, facts }
-          : {
-              path: MEMORY_INBOX,
-              description: "Facts with nowhere obvious to go",
-              facts,
-            };
+      const toInbox = !known && !isMemoryPath(said);
+      const filed = toInbox
+        ? {
+            path: MEMORY_INBOX,
+            description: appNoteLine(MEMORY_INBOX),
+            facts,
+          }
+        : { path: target, description, aliases, facts };
 
-      const write = await writeNotes([filed], source);
+      const write = await writeNotes([filed], source, callId);
 
       // The write already succeeded; what follows are requests, not failures.
-      // A path filed elsewhere must be said, or the model reports it saved where it asked.
-      const elsewhere =
-        filed.path !== said
-          ? ` Filed under ${filed.path}: "${said}" is not a path this listing can carry. If that is not where it belongs, write it again under one that is.`
-          : "";
+      // Only a path that landed in inbox is said: one reached by a name the
+      // listing carries is where it was asked for, however it was spelled.
+      const elsewhere = toInbox
+        ? ` Filed under ${filed.path}: "${said}" is not a path this listing can carry. If that is not where it belongs, write it again under one that is.`
+        : "";
 
       const unnamed = write.unnamed.length
         ? ` ${write.unnamed[0]} is new and has no line yet — the listing shows its first fact instead. Call again with \`description\` (one line about what it is) and \`aliases\` (the names they say for it).`
         : "";
-      // Carried lines are full: saved as an ordinary fact, and the user picks what to drop (ALWAYS_LOADED_MAX)
+      // Carried lines are full: saved as an ordinary fact, and the user picks what to drop (config MEMORY_LIMITS.carried)
       const notLoaded = write.notLoaded.length
-        ? ` All ${ALWAYS_LOADED_MAX} carried lines are taken, so ${write.notLoaded
+        ? ` All ${MEMORY_LIMITS.carried} carried lines are taken, so ${write.notLoaded
             .map((text) => `"${text}"`)
             .join(
               ", ",
             )} saved as an ordinary fact. Say which carried line you would drop for it and let them choose.`
         : "";
+      const written = withCount(write.notes[0]);
       return {
-        ...write.notes[0],
-        note: `${WROTE}${elsewhere}${unnamed}${notLoaded}`,
+        ...written,
+        note: `${WROTE}${elsewhere}${unnamed}${notLoaded}${overSize(written.factCount)}`,
       };
     },
   }),
 
-  [TOOL_NAMES.memory_show]: tool({
-    description: `Put a note on the user's screen so they can see it while you
-talk about it, and take it away again. They cannot edit it there — they say
-what to drop and you drop it.`,
+  [TOOL_NAMES.memory_conversation]: tool({
+    description:
+      "Open the conversation a fact was saved in, whole: what each side said, and which tools were used.",
     inputSchema: z.object({
-      path: z
-        .string()
-        .nullable()
+      factId: z
+        .number()
+        .int()
+        .describe("The id that came with the fact when its note was opened."),
+      page: z
+        .number()
+        .int()
+        .min(1)
+        .nullish()
         .describe(
-          "The note to put on screen, exactly as the listing writes it. Null takes it away.",
+          `${MEMORY_CONVERSATION_PAGE} turns a page, oldest first. Null for the first.`,
         ),
     }),
-    execute: async ({ path }) => {
-      if (!path?.trim()) {
-        appEvents.emit({ type: "memory-view", path: null });
-        return { note: "Taken off the screen." };
+    execute: async ({ factId, page }) => {
+      const fact = await findFactCall(factId);
+      if (!fact) return { note: `No fact with id ${factId}.` };
+      if (!fact.callId) return { note: noConversation(fact.source) };
+      // Already in the model's context: handing it back only spends it twice
+      if (fact.callId === callId) {
+        return {
+          note: "Said in this call — it is the conversation you are in.",
+        };
       }
-      // The screen gets only the path and reads facts over GET, so deletions show up on their own
-      const { notes } = await readNotes([path], { touch: false });
-      const note = notes[0];
-      if (!note) {
-        return { note: `Nothing on the listing called ${path.trim()}.` };
+
+      const at = page ?? 1;
+      const read = await readCallConversation(
+        fact.callId,
+        at,
+        MEMORY_CONVERSATION_PAGE,
+      );
+      if (!read) return { note: noConversation(fact.source) };
+      const pages = Math.max(
+        1,
+        Math.ceil(read.total / MEMORY_CONVERSATION_PAGE),
+      );
+      if (at > pages) {
+        return {
+          note: `That conversation has ${pages} page${pages > 1 ? "s" : ""}.`,
+        };
       }
-      appEvents.emit({ type: "memory-view", path: note.path });
       return {
-        ...note,
-        note: "It is on their screen now, in this order. Ask what they no longer need, and forget only what they name.",
+        when: callStamp(read.startedAt),
+        page: at,
+        pages,
+        conversation: conversationLines(read.turns),
       };
     },
   }),
 
   [TOOL_NAMES.memory_forget]: tool({
-    description: "Delete one fact for good.",
+    description: "Delete facts for good.",
     inputSchema: z.object({
-      factId: z
+      factIds: z
         .number()
         .int()
-        .describe("The id that came with the fact when the note was opened."),
+        .array()
+        .min(1)
+        .describe(
+          "The ids that came with the facts when their notes were opened — every one to delete, in one call.",
+        ),
     }),
-    execute: async ({ factId }) => {
-      const forgotten = await forgetFactById(factId);
-      if (!forgotten) {
-        return { note: `No fact with id ${factId}. Nothing was deleted.` };
+    execute: async ({ factIds }) => {
+      const missing: number[] = [];
+      /** Notes that lost their last fact, and went with it (memory.query forgetFactById). */
+      const gone: string[] = [];
+      /** Notes that still hold something, handed back as they are now. */
+      const left = new Set<string>();
+      for (const id of new Set(factIds)) {
+        const forgotten = await forgetFactById(id);
+        if (!forgotten) {
+          missing.push(id);
+          continue;
+        }
+        if (forgotten.noteGone) {
+          left.delete(forgotten.path);
+          gone.push(forgotten.path);
+        } else {
+          left.add(forgotten.path);
+        }
       }
 
-      // The note goes with its last fact; the listing still shows it until the next session, so say so
-      if (forgotten.noteGone) {
+      if (!gone.length && !left.size) {
         return {
-          note: `${GONE} That was the last fact under ${forgotten.path}, so the note went with it.`,
+          note: `No fact with id ${missing.join(", ")}. Nothing was deleted.`,
         };
       }
-      const { notes } = await readNotes([forgotten.path], { touch: false });
-      return { ...notes[0], note: GONE };
-    },
-  }),
-});
 
-/**
- * The bot's write. Same act under the same name, without what only the call can
- * do: no `replaces`, no carried lines, no naming a note — a bot has neither the
- * user in front of it nor the listing's history. Rare by nature; what the job
- * turned up belongs in the report, and only what outlives the job comes here.
- */
-export const botRememberTool = tool({
-  description:
-    "Save a lasting fact about the user. Only for what outlives this job; what the job itself turned up goes in the report.",
-  inputSchema: z.object({
-    path: z
-      .string()
-      .describe(
-        "Exactly as the listing writes it, or a new path following the same convention.",
-      ),
-    facts: z
-      .string()
-      .array()
-      .describe("One statement each, standing on its own later."),
+      // The notes that went are still on the listing until the next session, so say so
+      const said = [
+        GONE,
+        gone.length === 1
+          ? `That was the last fact under ${gone[0]}, so the note went with it.`
+          : gone.length
+            ? `That was the last of ${gone.join(", ")}, so those notes went with them.`
+            : "",
+        missing.length
+          ? `No fact with id ${missing.join(", ")}, so those were skipped.`
+          : "",
+      ]
+        .filter(Boolean)
+        .join(" ");
+      if (!left.size) return { note: said };
+      const { notes } = await readNotes([...left], { touch: false });
+      return { notes: notes.map(withCount), note: said };
+    },
   }),
-  execute: async ({ path, facts }) => {
-    const said = path.trim();
-    const written = facts.map((text) => text.trim()).filter(Boolean);
-    if (!written.length) return { note: "Nothing to write: send a fact." };
-
-    const known = await resolveNotePath(said);
-    // A path outside the convention goes to inbox, as it does for the call
-    const filed = known || isMemoryPath(said) ? (known ?? said) : MEMORY_INBOX;
-
-    await writeNotes(
-      [{ path: filed, facts: written.map((text) => ({ text })) }],
-      "bot",
-    );
-
-    // A write filed elsewhere must be said, or the report claims the wrong place
-    return {
-      note:
-        filed === said
-          ? `Saved to ${filed}.`
-          : `Saved to ${filed}: "${said}" is not a path this listing can carry.`,
-    };
-  },
 });

package/features/ai/tools/search.tool.ts

@@ -1,14 +1,25 @@
 import { generateText, type ToolSet, tool } from "ai";
 import z from "zod";
+import { SEARCH } from "@/config";
 import type { TextModel } from "@/features/ai/model";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
+import { EXA_API_KEY } from "@/features/config/config.const";
+import { readConfig } from "@/features/config/config.query";
 import type { Sandbox } from "@/lib/sandbox";
+import { clip, errorToString } from "@/lib/utils";
 
 /**
- * Web search as one tool with one name. The provider-native search runs one call down on a
- * search-capable model (`resolveSearchModel`), never in the bot's own request: a provider tool
- * cannot be handed to another provider's model, names and result shapes differ per provider,
- * and Google cannot send its search tool alongside function tools in one request.
+ * Web search as one tool with one name, served whichever way this install can.
+ *
+ * Exa when its key is set: one HTTP call, the pages themselves back. Otherwise the run's own
+ * model's native search, one call down on a searcher that sees nothing but the question — a
+ * provider tool cannot be handed to another provider's model, names and result shapes differ
+ * per provider, and Google cannot send its search tool alongside function tools in one request.
+ *
+ * A run whose model has no search of its own (the gateway) and no Exa key gets no search tool:
+ * it goes to the browser. Borrowing whichever provider had a key meant a second model call on a
+ * model nobody picked, which is where the minute-long searches came from — search is one lookup
+ * or it is a job, and a job is what the browser already is.
  */
 
 /** System prompt for the model one call down; it sees nothing but the question. */
@@ -17,57 +28,135 @@ what supports it. Say plainly what you could not find or confirm — do not fill
 the gap with a guess. Every number carries the date you saw it. Be brief: this
 is read by another model, not by a person.`;
 
-/** How many sources are worth carrying back. Past this it is noise. */
-const SOURCE_LIMIT = 8;
+const DESCRIPTION =
+  "Search the web and get back what the pages say, with their links. For a fact, a price, a date, what a page says. Not for a page that has to be clicked, filled, or signed into — that is the browser.";
 
-/** Absent when no provider that searches has a key (features/ai/model); the bot goes to the browser instead. */
-export const createSearchTool = (
-  search: TextModel | null,
+const QUERY = z
+  .string()
+  .describe(
+    "What you want to know, as one full question. Put the place and the time in when they matter — the searcher sees nothing but this line.",
+  );
+
+/** Exa's own endpoint. One POST: the whole point of this path is that it is not a model call. */
+const EXA_URL = "https://api.exa.ai/search";
+
+/** One hit as Exa sends it; only the fields that are read back are named. */
+type ExaHit = {
+  title?: string | null;
+  url?: string | null;
+  publishedDate?: string | null;
+  text?: string | null;
+};
+
+async function exaSearch(
+  apiKey: string,
+  query: string,
+  signal: AbortSignal,
+): Promise<string> {
+  const response = await fetch(EXA_URL, {
+    method: "POST",
+    signal,
+    headers: { "content-type": "application/json", "x-api-key": apiKey },
+    body: JSON.stringify({
+      query,
+      type: "auto",
+      numResults: SEARCH.sources,
+      contents: {
+        text: { maxCharacters: SEARCH.excerptChars },
+        // A page Exa has not cached is fetched now, but one slow site does not hold the search
+        livecrawl: "fallback",
+        livecrawlTimeout: 5_000,
+      },
+    }),
+  });
+  // Exa's own words: only it can say whether the key is wrong, spent or rate-limited
+  if (!response.ok)
+    return `Exa answered ${response.status}: ${clip((await response.text()).trim(), 200)}`;
+
+  const body = (await response.json()) as { results?: ExaHit[] };
+  const hits = body.results ?? [];
+  if (!hits.length)
+    return "Nothing came back for that. Try other words, or open a page in the browser.";
+
+  return hits
+    .map((hit) => {
+      const head = [hit.title?.trim(), hit.url?.trim()]
+        .filter(Boolean)
+        .join(" — ");
+      const date = hit.publishedDate?.slice(0, 10);
+      return [date ? `${head} · ${date}` : head, hit.text?.trim()]
+        .filter(Boolean)
+        .join("\n");
+    })
+    .join("\n\n");
+}
+
+async function askSearcher(
+  searcher: { model: TextModel["model"]; tools: ToolSet },
+  query: string,
+  signal: AbortSignal,
+): Promise<string> {
+  const { text, sources } = await generateText({
+    model: searcher.model,
+    tools: searcher.tools,
+    system: SEARCHER,
+    prompt: query,
+    abortSignal: signal,
+  });
+
+  const urls = [
+    ...new Set(
+      sources.flatMap((source) =>
+        source.sourceType === "url"
+          ? [source.title ? `${source.title} — ${source.url}` : source.url]
+          : [],
+      ),
+    ),
+  ].slice(0, SEARCH.sources);
+
+  return [text.trim(), urls.length ? `Sources:\n${urls.join("\n")}` : ""]
+    .filter(Boolean)
+    .join("\n\n");
+}
+
+/** Absent when there is neither an Exa key nor a run model that searches; the bot goes to the browser instead. */
+export const createSearchTool = async (
+  run: TextModel | null | undefined,
   sandbox: Sandbox,
-): ToolSet => {
-  if (!search?.searchTools) return {};
-  const { model, searchTools } = search;
+): Promise<ToolSet> => {
+  const exaKey = await readConfig(EXA_API_KEY);
+  // This run's own model, never a borrowed one. A const so the closure below keeps the narrowing
+  const native = run?.searchTools
+    ? { model: run.model, tools: run.searchTools }
+    : null;
+
+  const search = exaKey
+    ? (query: string, signal: AbortSignal) => exaSearch(exaKey, query, signal)
+    : native
+      ? (query: string, signal: AbortSignal) =>
+          askSearcher(native, query, signal)
+      : null;
+  if (!search) return {};
 
   return {
     [TOOL_NAMES.web_search]: tool({
-      description:
-        "Search the web and get back an answer with its sources. For a fact, a price, a date, what a page says. Not for a page that has to be clicked, filled, or signed into — that is the browser.",
-      inputSchema: z.object({
-        query: z
-          .string()
-          .describe(
-            "What you want to know, as one full question. Put the place and the time in when they matter — the searcher sees nothing but this line.",
-          ),
-      }),
+      description: DESCRIPTION,
+      inputSchema: z.object({ query: QUERY }),
       execute: async ({ query }, { abortSignal }) => {
-        const { text, sources } = await generateText({
-          model,
-          tools: searchTools,
-          system: SEARCHER,
-          prompt: query,
-          abortSignal,
+        const deadline = AbortSignal.timeout(SEARCH.timeoutMs);
+        const signal = abortSignal
+          ? AbortSignal.any([abortSignal, deadline])
+          : deadline;
+
+        const answer = await search(query, signal).catch((cause: unknown) => {
+          // The job itself was cancelled: that is not a result to hand back
+          if (abortSignal?.aborted) throw cause;
+          if (deadline.aborted)
+            return `The search did not come back in ${SEARCH.timeoutMs / 1000}s. Ask something narrower, or open the page in the browser.`;
+          return `Search failed: ${errorToString(cause)}. The browser is the other way in.`;
         });
 
-        const urls = [
-          ...new Set(
-            sources.flatMap((source) =>
-              source.sourceType === "url"
-                ? [
-                    source.title
-                      ? `${source.title} — ${source.url}`
-                      : source.url,
-                  ]
-                : [],
-            ),
-          ),
-        ].slice(0, SOURCE_LIMIT);
-
-        return sandbox.fold(
-          [text.trim(), urls.length ? `Sources:\n${urls.join("\n")}` : ""]
-            .filter(Boolean)
-            .join("\n\n"),
-          "web-search",
-        );
+        return sandbox.fold(answer, "web-search");
       },
     }),
   };

package/features/ai/tools/tool-name.ts

@@ -7,7 +7,7 @@ export const TOOL_NAMES = {
   memory_recall: "memory_recall",
   memory_remember: "memory_remember",
   memory_forget: "memory_forget",
-  memory_show: "memory_show",
+  memory_conversation: "memory_conversation",
 
   bash: "bash",
   write_file: "write_file",
@@ -24,13 +24,9 @@ export const TOOL_NAMES = {
   ask_bot: "ask_bot",
   ask_thursday: "ask_thursday",
   ask_back: "ask_back",
-  report: "report",
+  answer: "answer",
 
   end_call: "end_call",
-
-  tidy_done: "tidy_done",
-
-  update_notes: "update_notes",
 } as const;
 
 /**