@athenaintel/react 0.57.2 → 0.60.0

package/dist/agent-runtime/src/named-agents.cjs

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react");
+const addressedAgents = require("./addressed-agents.cjs");
+const MAX_DEEP_AGENT_NAMED_AGENTS = 8;
+const OWN_ASSISTANT_AGENT_REF = "assistant";
+const COLLAB_AGENT_REF_PREFIX = "collab_agent:";
+const NO_NAMED_AGENTS = Object.freeze([]);
+function normalizeNamedAgents(agents) {
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const agent of agents) {
+    const ref = agent.ref.trim();
+    if (!ref || seen.has(ref)) continue;
+    seen.add(ref);
+    normalized.push(ref === agent.ref ? agent : { ...agent, ref });
+    if (normalized.length === MAX_DEEP_AGENT_NAMED_AGENTS) break;
+  }
+  return normalized.length === 0 ? NO_NAMED_AGENTS : normalized;
+}
+function sameNamedAgents(a, b) {
+  return a.length === b.length && a.every(
+    (agent, index) => {
+      var _a, _b, _c;
+      return agent.ref === ((_a = b[index]) == null ? void 0 : _a.ref) && agent.name === ((_b = b[index]) == null ? void 0 : _b.name) && agent.assetId === ((_c = b[index]) == null ? void 0 : _c.assetId);
+    }
+  );
+}
+function namedAgentRefs(agents) {
+  const refs = [];
+  for (const agent of agents) {
+    const ref = agent.ref.trim();
+    if (!ref || refs.includes(ref)) continue;
+    refs.push(ref);
+    if (refs.length === MAX_DEEP_AGENT_NAMED_AGENTS) break;
+  }
+  return refs;
+}
+function setBounded(map, key, value, limit) {
+  map.delete(key);
+  map.set(key, value);
+  while (map.size > limit) {
+    const oldest = map.keys().next();
+    if (oldest.done) break;
+    map.delete(oldest.value);
+  }
+}
+function createNamedAgentsStore(initial) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get state() {
+      return state;
+    },
+    setState(update) {
+      const next = update(state);
+      if (Object.is(next, state)) return;
+      state = next;
+      for (const listener of [...listeners]) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+const deepAgentNamedAgentsStore = createNamedAgentsStore({
+  byThread: {}
+});
+const namedAgentsSeen = /* @__PURE__ */ new Map();
+const NAMED_AGENTS_SEEN_KEPT = 200;
+function writeNamedAgents(threadId, agents) {
+  for (const agent of agents) setBounded(namedAgentsSeen, agent.ref, agent, NAMED_AGENTS_SEEN_KEPT);
+  deepAgentNamedAgentsStore.setState((state) => {
+    if (sameNamedAgents(state.byThread[threadId] ?? NO_NAMED_AGENTS, agents)) return state;
+    const byThread = { ...state.byThread };
+    if (agents.length === 0) delete byThread[threadId];
+    else byThread[threadId] = agents;
+    return { byThread };
+  });
+}
+function useDeepAgentNamedAgents(threadId) {
+  const read = () => readDeepAgentNamedAgents(threadId);
+  return require$$0.useSyncExternalStore(deepAgentNamedAgentsStore.subscribe, read, read);
+}
+function readDeepAgentNamedAgents(threadId) {
+  return deepAgentNamedAgentsStore.state.byThread[threadId] ?? NO_NAMED_AGENTS;
+}
+function addDeepAgentNamedAgent({
+  threadId,
+  agent
+}) {
+  const current = readDeepAgentNamedAgents(threadId);
+  const ref = agent.ref.trim();
+  if (!threadId || !ref || current.length >= MAX_DEEP_AGENT_NAMED_AGENTS || current.some((named) => named.ref === ref)) {
+    return false;
+  }
+  writeNamedAgents(threadId, normalizeNamedAgents([...current, agent]));
+  return true;
+}
+function removeDeepAgentNamedAgent({
+  threadId,
+  ref
+}) {
+  const current = readDeepAgentNamedAgents(threadId);
+  if (!current.some((agent) => agent.ref === ref)) return;
+  writeNamedAgents(threadId, normalizeNamedAgents(current.filter((agent) => agent.ref !== ref)));
+}
+const SENT_TEXTS_KEPT_PER_THREAD = 20;
+const THREADS_WITH_SENT_TEXTS_KEPT = 50;
+const WITHDRAWAL_RESTORES_KEPT = 20;
+const sentTextNamedAgents = /* @__PURE__ */ new Map();
+const withdrawalRestores = /* @__PURE__ */ new Map();
+function rememberDeepAgentSentNamedAgents({
+  threadId,
+  text,
+  agents
+}) {
+  if (!threadId) return;
+  const named = normalizeNamedAgents(agents);
+  const texts = sentTextNamedAgents.get(threadId);
+  if (named.length === 0) {
+    texts == null ? void 0 : texts.delete(text);
+    return;
+  }
+  const kept = texts ?? /* @__PURE__ */ new Map();
+  setBounded(kept, text, named, SENT_TEXTS_KEPT_PER_THREAD);
+  setBounded(sentTextNamedAgents, threadId, kept, THREADS_WITH_SENT_TEXTS_KEPT);
+}
+function restoreDeepAgentSentNamedAgents({
+  threadId,
+  text,
+  withdrawnMessageId
+}) {
+  var _a;
+  const named = ((_a = sentTextNamedAgents.get(threadId)) == null ? void 0 : _a.get(text)) ?? NO_NAMED_AGENTS;
+  const restored = named.filter((agent) => addDeepAgentNamedAgent({ threadId, agent }));
+  if (withdrawnMessageId !== void 0 && restored.length > 0) {
+    setBounded(
+      withdrawalRestores,
+      withdrawnMessageId,
+      { threadId, agents: restored },
+      WITHDRAWAL_RESTORES_KEPT
+    );
+  }
+  return restored;
+}
+const NAMED_AGENTS_STAGED_TTL_MS = 1e4;
+const stagedForSend = /* @__PURE__ */ new Map();
+function stageDeepAgentNamedAgentsForSend({
+  threadId,
+  agents
+}) {
+  if (!threadId) return;
+  const refs = namedAgentRefs(agents);
+  if (refs.length === 0) {
+    stagedForSend.delete(threadId);
+    return;
+  }
+  stagedForSend.set(threadId, { refs, stagedAt: Date.now() });
+}
+function takeStagedDeepAgentNamedAgents(threadId) {
+  const staged = stagedForSend.get(threadId);
+  stagedForSend.delete(threadId);
+  if (staged === void 0 || Date.now() - staged.stagedAt > NAMED_AGENTS_STAGED_TTL_MS) {
+    return void 0;
+  }
+  return staged.refs;
+}
+function stagedNamedAgentsMessageMetadata(threadId) {
+  return addressedAgents.withAddressedAgents(void 0, takeStagedDeepAgentNamedAgents(threadId));
+}
+function deepAgentOutboxAddressedAgents(agents) {
+  const refs = namedAgentRefs(agents);
+  return refs.length === 0 ? void 0 : refs;
+}
+function namedAgentsForRefsSeen(refs) {
+  const agents = [];
+  for (const ref of refs) {
+    const seen = namedAgentsSeen.get(ref);
+    if (seen) agents.push(seen);
+    else if (ref === OWN_ASSISTANT_AGENT_REF) {
+      agents.push({ ref, name: OWN_ASSISTANT_DISPLAY_NAME, assetId: null });
+    } else if (ref.startsWith(COLLAB_AGENT_REF_PREFIX)) {
+      agents.push({ ref, name: "Untitled agent", assetId: ref.slice(COLLAB_AGENT_REF_PREFIX.length) });
+    }
+  }
+  return agents;
+}
+function giveBackDeepAgentOutboxNamedAgents(entry, {
+  namedAgentsForRefs = namedAgentsForRefsSeen
+} = {}) {
+  const refs = addressedAgents.readAddressedAgents(entry.metadata);
+  if (!refs || refs.length === 0) return NO_NAMED_AGENTS;
+  return namedAgentsForRefs(refs).filter(
+    (agent) => addDeepAgentNamedAgent({ threadId: entry.threadId, agent })
+  );
+}
+function chatAgentNamingOffered({ isAdmin }) {
+  return isAdmin;
+}
+const OWN_ASSISTANT_DISPLAY_NAME = "Athena";
+const OWN_ASSISTANT_OFFERED_AGENT = Object.freeze({
+  ref: OWN_ASSISTANT_AGENT_REF,
+  name: OWN_ASSISTANT_DISPLAY_NAME,
+  assetId: null,
+  icon: "Bot"
+});
+function collabAgentOfferedAgent({
+  assetId,
+  name,
+  icon
+}) {
+  return {
+    ref: `${COLLAB_AGENT_REF_PREFIX}${assetId}`,
+    name: name || "Untitled agent",
+    assetId,
+    icon: icon || "Bot"
+  };
+}
+function offeredDeepAgentNamedAgents({
+  collabAgents,
+  named
+}) {
+  if (named.length >= MAX_DEEP_AGENT_NAMED_AGENTS) return [];
+  const taken = new Set(named.map((agent) => agent.ref));
+  const offered = [];
+  for (const agent of [OWN_ASSISTANT_OFFERED_AGENT, ...collabAgents]) {
+    if (taken.has(agent.ref)) continue;
+    taken.add(agent.ref);
+    offered.push(agent);
+  }
+  return offered;
+}
+function namedAgentsLimitMessage(leftOut) {
+  const names = new Intl.ListFormat("en", { style: "long", type: "conjunction" }).format(leftOut);
+  return `A message names at most ${MAX_DEEP_AGENT_NAMED_AGENTS} agents, so ${names} ${leftOut.length === 1 ? "wasn't" : "weren't"} added.`;
+}
+function nameDeepAgentMentionedAgents({
+  threadId,
+  agents
+}) {
+  const leftOut = [];
+  for (const agent of agents) {
+    const named = readDeepAgentNamedAgents(threadId);
+    if (named.some((entry) => entry.ref === agent.ref.trim())) continue;
+    if (named.length >= MAX_DEEP_AGENT_NAMED_AGENTS) {
+      leftOut.push(agent.name);
+      continue;
+    }
+    addDeepAgentNamedAgent({
+      threadId,
+      agent: { ref: agent.ref, name: agent.name, assetId: agent.assetId }
+    });
+  }
+  return leftOut;
+}
+let namedAgentsIdentity = null;
+function forgetAllDeepAgentNamedAgents() {
+  stagedForSend.clear();
+  sentTextNamedAgents.clear();
+  withdrawalRestores.clear();
+  namedAgentsSeen.clear();
+  namedAgentsIdentity = null;
+  deepAgentNamedAgentsStore.setState(() => ({ byThread: {} }));
+}
+function keepDeepAgentNamedAgentsForIdentity(identity) {
+  if (namedAgentsIdentity !== null && namedAgentsIdentity !== identity) {
+    forgetAllDeepAgentNamedAgents();
+  }
+  namedAgentsIdentity = identity;
+}
+exports.COLLAB_AGENT_REF_PREFIX = COLLAB_AGENT_REF_PREFIX;
+exports.MAX_DEEP_AGENT_NAMED_AGENTS = MAX_DEEP_AGENT_NAMED_AGENTS;
+exports.NAMED_AGENTS_STAGED_TTL_MS = NAMED_AGENTS_STAGED_TTL_MS;
+exports.OWN_ASSISTANT_AGENT_REF = OWN_ASSISTANT_AGENT_REF;
+exports.OWN_ASSISTANT_DISPLAY_NAME = OWN_ASSISTANT_DISPLAY_NAME;
+exports.OWN_ASSISTANT_OFFERED_AGENT = OWN_ASSISTANT_OFFERED_AGENT;
+exports.addDeepAgentNamedAgent = addDeepAgentNamedAgent;
+exports.chatAgentNamingOffered = chatAgentNamingOffered;
+exports.collabAgentOfferedAgent = collabAgentOfferedAgent;
+exports.deepAgentNamedAgentsStore = deepAgentNamedAgentsStore;
+exports.deepAgentOutboxAddressedAgents = deepAgentOutboxAddressedAgents;
+exports.forgetAllDeepAgentNamedAgents = forgetAllDeepAgentNamedAgents;
+exports.giveBackDeepAgentOutboxNamedAgents = giveBackDeepAgentOutboxNamedAgents;
+exports.keepDeepAgentNamedAgentsForIdentity = keepDeepAgentNamedAgentsForIdentity;
+exports.nameDeepAgentMentionedAgents = nameDeepAgentMentionedAgents;
+exports.namedAgentRefs = namedAgentRefs;
+exports.namedAgentsLimitMessage = namedAgentsLimitMessage;
+exports.offeredDeepAgentNamedAgents = offeredDeepAgentNamedAgents;
+exports.readDeepAgentNamedAgents = readDeepAgentNamedAgents;
+exports.rememberDeepAgentSentNamedAgents = rememberDeepAgentSentNamedAgents;
+exports.removeDeepAgentNamedAgent = removeDeepAgentNamedAgent;
+exports.restoreDeepAgentSentNamedAgents = restoreDeepAgentSentNamedAgents;
+exports.stageDeepAgentNamedAgentsForSend = stageDeepAgentNamedAgentsForSend;
+exports.stagedNamedAgentsMessageMetadata = stagedNamedAgentsMessageMetadata;
+exports.takeStagedDeepAgentNamedAgents = takeStagedDeepAgentNamedAgents;
+exports.useDeepAgentNamedAgents = useDeepAgentNamedAgents;
+//# sourceMappingURL=named-agents.cjs.map

package/dist/agent-runtime/src/named-agents.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"named-agents.cjs","sources":["../../../../agent-runtime/src/named-agents.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react';\nimport { ADDRESSED_AGENTS_METADATA_KEY, readAddressedAgents, withAddressedAgents } from './addressed-agents';\nimport type { ChatOutboxEntry } from './chat-outbox-entry';\n\n/**\n * The agents a message names (identity v7 D13): one conversation has many participants, and\n * each message goes to the agents it names, each answering in its own turn, in the order named.\n * agora reads the names from the message itself (`message.metadata.addressedAgents`,\n * `addressed-agents.ts`) ahead of the run config's `addressed_agents`, and checks every one of them\n * (the collab overlay's VIEW gate, a colleague's assistant refused, the history re-check), so the\n * client only presents what the person can pick and never gates.\n *\n * Every chat that names agents runs on this one module: Olympus's deep-agent composer (whose\n * `deep-agent-named-agents.ts` re-exports it) and the SDK's `AthenaChat` (and so Athena Desktop),\n * so naming an agent means the same thing, and reaches agora as the same payload, in both. What a\n * composer's `@` menu offers to name is {@link offeredDeepAgentNamedAgents}.\n *\n * - **The chips.** The agents the composer's To line names for each thread, in the order named\n *   (`set` / `add` / `remove` / `clear`, read with {@link useDeepAgentNamedAgents}). They stay\n *   for every message until the person changes them. Anything may set a thread's chips; its\n *   composer shows them. Kept in memory for the page, and dropped when the signed-in identity\n *   changes ({@link keepDeepAgentNamedAgentsForIdentity}).\n * - **The send.** statewire captures a new message's metadata once, as it journals it\n *   (`getMessageMetadata`), without saying which message it is for. So the composer stages the\n *   chips for its next send right before `aui.composer.send`\n *   ({@link stageDeepAgentNamedAgentsForSend}), and the runtime's getter takes them for the message\n *   that follows ({@link takeStagedDeepAgentNamedAgents}, {@link stagedNamedAgentsMessageMetadata}).\n *   The names then travel with the message: a send that waits, is retried after a failure, or is\n *   posted again by a page reloaded meanwhile names its own agents, whatever the conversation's\n *   context says by then, so no send waits for another's. A slot nobody takes expires.\n * - **The chat outbox.** A message held while Athena can't be reached carries its names on its\n *   message the same way (`ChatOutbox.hold({ addressedAgents })`,\n *   {@link deepAgentOutboxAddressedAgents}); its Cancel gives them back as chips with its text\n *   ({@link giveBackDeepAgentOutboxNamedAgents}).\n *\n * Text a send carried that comes back to the composer (a failed send handed back, an early Stop)\n * brings its chips back ({@link restoreDeepAgentSentNamedAgents}).\n *\n * State is per copy of this module: Olympus runs agent-runtime from source, and the SDK bundles\n * its own copy, whose composer and runtime share it.\n */\n\n/**\n * The message metadata key of the agents a message names (agora:\n * `agent_refs.ADDRESSED_AGENTS_METADATA_KEY`, read in place of the run config's and never kept on\n * the turn the transcript records).\n */\nexport const DEEP_AGENT_MESSAGE_ADDRESSED_AGENTS_KEY = ADDRESSED_AGENTS_METADATA_KEY;\n\nexport interface DeepAgentNamedAgent {\n  /** What the send names: `collab_agent:<asset id>`, or `assistant` (the sender's own assistant). */\n  ref: string;\n  /** What the chip shows. */\n  name: string;\n  /** The collab agent asset behind `ref`; `null` for the sender's own assistant. */\n  assetId: string | null;\n}\n\n/** agora takes at most this many names on one message. */\nexport const MAX_DEEP_AGENT_NAMED_AGENTS = 8;\n\n/** The ref of the sender's own assistant. */\nexport const OWN_ASSISTANT_AGENT_REF = 'assistant';\n\n/** The prefix of a collab agent's ref (`collab_agent:<asset id>`). */\nexport const COLLAB_AGENT_REF_PREFIX = 'collab_agent:';\n\nconst NO_NAMED_AGENTS: readonly DeepAgentNamedAgent[] = Object.freeze([]);\n\n/** Each agent once (by ref, the first kept), in the order named, at most eight; blank refs dropped. */\nfunction normalizeNamedAgents(\n  agents: readonly DeepAgentNamedAgent[]\n): readonly DeepAgentNamedAgent[] {\n  const seen = new Set<string>();\n  const normalized: DeepAgentNamedAgent[] = [];\n  for (const agent of agents) {\n    const ref = agent.ref.trim();\n    if (!ref || seen.has(ref)) continue;\n    seen.add(ref);\n    normalized.push(ref === agent.ref ? agent : { ...agent, ref });\n    if (normalized.length === MAX_DEEP_AGENT_NAMED_AGENTS) break;\n  }\n  return normalized.length === 0 ? NO_NAMED_AGENTS : normalized;\n}\n\nfunction sameNamedAgents(\n  a: readonly DeepAgentNamedAgent[],\n  b: readonly DeepAgentNamedAgent[]\n): boolean {\n  return (\n    a.length === b.length &&\n    a.every(\n      (agent, index) =>\n        agent.ref === b[index]?.ref &&\n        agent.name === b[index]?.name &&\n        agent.assetId === b[index]?.assetId\n    )\n  );\n}\n\n/** The refs a message naming `agents` sends: in the order named, each once, at most eight. */\nexport function namedAgentRefs(agents: readonly Pick<DeepAgentNamedAgent, 'ref'>[]): string[] {\n  const refs: string[] = [];\n  for (const agent of agents) {\n    const ref = agent.ref.trim();\n    if (!ref || refs.includes(ref)) continue;\n    refs.push(ref);\n    if (refs.length === MAX_DEEP_AGENT_NAMED_AGENTS) break;\n  }\n  return refs;\n}\n\n/** What a send naming `agents` names, as one key: two sends name the same agents when equal. */\nexport function namedAgentsKey(agents: readonly Pick<DeepAgentNamedAgent, 'ref'>[]): string {\n  return namedAgentRefs(agents).join('\\n');\n}\n\n/**\n * Named agents read back from storage (a draft kept across a reload, a message waiting in the chat\n * outbox): a list of `{ ref, name, assetId }` with a non-empty ref and name and an asset id that is\n * a string or `null`, each agent once, at most eight. Anything else reads as naming none, entry by\n * entry, so a newer build's extra fields never break an older reader.\n */\nexport function parseDeepAgentNamedAgents(value: unknown): readonly DeepAgentNamedAgent[] {\n  if (!Array.isArray(value)) return NO_NAMED_AGENTS;\n  const agents: DeepAgentNamedAgent[] = [];\n  for (const item of value) {\n    if (typeof item !== 'object' || item === null) continue;\n    const ref: unknown = Reflect.get(item, 'ref');\n    const name: unknown = Reflect.get(item, 'name');\n    const assetId: unknown = Reflect.get(item, 'assetId');\n    if (typeof ref !== 'string' || !ref.trim() || typeof name !== 'string' || !name.trim())\n      continue;\n    if (assetId !== null && typeof assetId !== 'string') continue;\n    agents.push({ ref, name, assetId });\n  }\n  return normalizeNamedAgents(agents);\n}\n\n/** A small map that keeps its newest `limit` entries (insertion order is age). */\nfunction setBounded<K, V>(map: Map<K, V>, key: K, value: V, limit: number): void {\n  map.delete(key);\n  map.set(key, value);\n  while (map.size > limit) {\n    const oldest = map.keys().next();\n    if (oldest.done) break;\n    map.delete(oldest.value);\n  }\n}\n\n// ── The stores ──────────────────────────────────────────────────────────────\n\n/** A value its readers follow: a write that changes it tells every listener, synchronously. */\nexport interface NamedAgentsStore<T> {\n  readonly state: T;\n  /** Replace the value with what `update` returns; returning the value it was given changes nothing. */\n  setState: (update: (state: T) => T) => void;\n  /** Called after every change; returns the unsubscribe function. */\n  subscribe: (listener: () => void) => () => void;\n}\n\nfunction createNamedAgentsStore<T>(initial: T): NamedAgentsStore<T> {\n  let state = initial;\n  const listeners = new Set<() => void>();\n  return {\n    get state() {\n      return state;\n    },\n    setState(update) {\n      const next = update(state);\n      if (Object.is(next, state)) return;\n      state = next;\n      for (const listener of [...listeners]) listener();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n  };\n}\n\n// ── The chips ───────────────────────────────────────────────────────────────\n\ninterface DeepAgentNamedAgentsState {\n  /** Each thread's named agents (its composer's chips), in the order named. */\n  byThread: Readonly<Record<string, readonly DeepAgentNamedAgent[]>>;\n}\n\nexport const deepAgentNamedAgentsStore = createNamedAgentsStore<DeepAgentNamedAgentsState>({\n  byThread: {},\n});\n\n// process-local: client-only — the last name and asset this page gave each agent it named, so a\n// message given back with only its refs comes back with the chips it was sent with.\nconst namedAgentsSeen = new Map<string, DeepAgentNamedAgent>();\nconst NAMED_AGENTS_SEEN_KEPT = 200;\n\nfunction writeNamedAgents(threadId: string, agents: readonly DeepAgentNamedAgent[]): void {\n  for (const agent of agents) setBounded(namedAgentsSeen, agent.ref, agent, NAMED_AGENTS_SEEN_KEPT);\n  deepAgentNamedAgentsStore.setState((state) => {\n    if (sameNamedAgents(state.byThread[threadId] ?? NO_NAMED_AGENTS, agents)) return state;\n    const byThread = { ...state.byThread };\n    if (agents.length === 0) delete byThread[threadId];\n    else byThread[threadId] = agents;\n    return { byThread };\n  });\n}\n\n/** The agents `threadId`'s composer names for its next message, in the order named. */\nexport function useDeepAgentNamedAgents(threadId: string): readonly DeepAgentNamedAgent[] {\n  const read = (): readonly DeepAgentNamedAgent[] => readDeepAgentNamedAgents(threadId);\n  return useSyncExternalStore(deepAgentNamedAgentsStore.subscribe, read, read);\n}\n\n/** Imperative read of {@link useDeepAgentNamedAgents} (for send paths and handlers). */\nexport function readDeepAgentNamedAgents(threadId: string): readonly DeepAgentNamedAgent[] {\n  return deepAgentNamedAgentsStore.state.byThread[threadId] ?? NO_NAMED_AGENTS;\n}\n\n/**\n * Listen for `threadId`'s chips changing (the composer keeps them with its draft). Another\n * thread's change notifies nothing. Returns the unsubscribe function.\n */\nexport function subscribeDeepAgentNamedAgents({\n  threadId,\n  listener,\n}: {\n  threadId: string;\n  listener: () => void;\n}): () => void {\n  let agents = readDeepAgentNamedAgents(threadId);\n  return deepAgentNamedAgentsStore.subscribe(() => {\n    const next = readDeepAgentNamedAgents(threadId);\n    if (next === agents) return;\n    agents = next;\n    listener();\n  });\n}\n\n/** Name exactly `agents` for `threadId`'s next message (each once, in order, at most eight). */\nexport function setDeepAgentNamedAgents({\n  threadId,\n  agents,\n}: {\n  threadId: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): void {\n  if (!threadId) return;\n  writeNamedAgents(threadId, normalizeNamedAgents(agents));\n}\n\n/**\n * Name one more agent, after those already named. `false` when nothing changed: it is named\n * already, eight are named, or its ref is blank.\n */\nexport function addDeepAgentNamedAgent({\n  threadId,\n  agent,\n}: {\n  threadId: string;\n  agent: DeepAgentNamedAgent;\n}): boolean {\n  const current = readDeepAgentNamedAgents(threadId);\n  const ref = agent.ref.trim();\n  if (\n    !threadId ||\n    !ref ||\n    current.length >= MAX_DEEP_AGENT_NAMED_AGENTS ||\n    current.some((named) => named.ref === ref)\n  ) {\n    return false;\n  }\n  writeNamedAgents(threadId, normalizeNamedAgents([...current, agent]));\n  return true;\n}\n\nexport function removeDeepAgentNamedAgent({\n  threadId,\n  ref,\n}: {\n  threadId: string;\n  ref: string;\n}): void {\n  const current = readDeepAgentNamedAgents(threadId);\n  if (!current.some((agent) => agent.ref === ref)) return;\n  writeNamedAgents(threadId, normalizeNamedAgents(current.filter((agent) => agent.ref !== ref)));\n}\n\nexport function clearDeepAgentNamedAgents({ threadId }: { threadId: string }): void {\n  writeNamedAgents(threadId, NO_NAMED_AGENTS);\n}\n\n/**\n * Clear `threadId`'s chips once the message that named `agents` has left, but only while they\n * still are those agents: names changed since the message was sent (while it waited behind a\n * loading conversation) belong to the next message and stay. Returns whether they were cleared.\n */\nexport function clearDeepAgentNamedAgentsIfUnchanged({\n  threadId,\n  agents,\n}: {\n  threadId: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): boolean {\n  const current = readDeepAgentNamedAgents(threadId);\n  if (current.length === 0) return false;\n  if (namedAgentRefs(current).join('\\n') !== namedAgentRefs(agents).join('\\n')) return false;\n  clearDeepAgentNamedAgents({ threadId });\n  return true;\n}\n\n// ── Text that comes back to the composer ────────────────────────────────────\n\n/** How many sent texts each thread remembers the names of, and how many threads. */\nconst SENT_TEXTS_KEPT_PER_THREAD = 20;\nconst THREADS_WITH_SENT_TEXTS_KEPT = 50;\nconst WITHDRAWAL_RESTORES_KEPT = 20;\n\n// process-local: client-only — the names each recent send carried, per thread by its sent text\n// (the verbatim text the runtime hands back), so text that comes back brings its chips back.\nconst sentTextNamedAgents = new Map<string, Map<string, readonly DeepAgentNamedAgent[]>>();\n\n// process-local: client-only — the chips an early Stop gave back, by the withdrawn message, so a\n// contradicted withdrawal takes them away again.\nconst withdrawalRestores = new Map<\n  string,\n  { threadId: string; agents: readonly DeepAgentNamedAgent[] }\n>();\n\n/** Remember the names a send of `text` carried (a send naming none forgets earlier ones). */\nexport function rememberDeepAgentSentNamedAgents({\n  threadId,\n  text,\n  agents,\n}: {\n  threadId: string;\n  text: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): void {\n  if (!threadId) return;\n  const named = normalizeNamedAgents(agents);\n  const texts = sentTextNamedAgents.get(threadId);\n  if (named.length === 0) {\n    texts?.delete(text);\n    return;\n  }\n  const kept = texts ?? new Map<string, readonly DeepAgentNamedAgent[]>();\n  setBounded(kept, text, named, SENT_TEXTS_KEPT_PER_THREAD);\n  setBounded(sentTextNamedAgents, threadId, kept, THREADS_WITH_SENT_TEXTS_KEPT);\n}\n\n/**\n * Text a send carried came back to `threadId`'s composer (a failed send handed back, an early\n * Stop): the names it carried come back as chips, after any named since (each once, at most\n * eight). `withdrawnMessageId` marks an early Stop's turn, whose chips go again if the run\n * answers it after all ({@link undoDeepAgentWithdrawalNamedAgents}). Returns the agents put back.\n */\nexport function restoreDeepAgentSentNamedAgents({\n  threadId,\n  text,\n  withdrawnMessageId,\n}: {\n  threadId: string;\n  text: string;\n  withdrawnMessageId?: string;\n}): readonly DeepAgentNamedAgent[] {\n  const named = sentTextNamedAgents.get(threadId)?.get(text) ?? NO_NAMED_AGENTS;\n  const restored = named.filter((agent) => addDeepAgentNamedAgent({ threadId, agent }));\n  if (withdrawnMessageId !== undefined && restored.length > 0) {\n    setBounded(\n      withdrawalRestores,\n      withdrawnMessageId,\n      { threadId, agents: restored },\n      WITHDRAWAL_RESTORES_KEPT\n    );\n  }\n  return restored;\n}\n\n/**\n * The run answered a turn its sender took back after all (an early Stop contradicted): the chips\n * that came back with its text go again, except any taken off since.\n */\nexport function undoDeepAgentWithdrawalNamedAgents({ messageId }: { messageId: string }): void {\n  const restore = withdrawalRestores.get(messageId);\n  if (!restore) return;\n  withdrawalRestores.delete(messageId);\n  for (const agent of restore.agents) {\n    removeDeepAgentNamedAgent({ threadId: restore.threadId, ref: agent.ref });\n  }\n}\n\n/** A withdrawal settled without undoing its restore (the editor changed since): forget it. */\nexport function forgetDeepAgentWithdrawalNamedAgents({ messageId }: { messageId: string }): void {\n  withdrawalRestores.delete(messageId);\n}\n\n// ── The send ────────────────────────────────────────────────────────────────\n\n/** How long staged names wait for the message they were staged for before they expire. */\nexport const NAMED_AGENTS_STAGED_TTL_MS = 10_000;\n\n// process-local: client-only — the names each thread's composer staged for the message it submits\n// next, taken once by the runtime's `getMessageMetadata`.\nconst stagedForSend = new Map<string, { refs: readonly string[]; stagedAt: number }>();\n\n/**\n * Stage `agents` as the names of the message `threadId`'s composer submits next. Call right before\n * the send (`aui.composer.send`): the runtime's `getMessageMetadata` takes them for that message\n * ({@link takeStagedDeepAgentNamedAgents}). A send naming none stages nothing and lets an earlier\n * slot go.\n */\nexport function stageDeepAgentNamedAgentsForSend({\n  threadId,\n  agents,\n}: {\n  threadId: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): void {\n  if (!threadId) return;\n  const refs = namedAgentRefs(agents);\n  if (refs.length === 0) {\n    stagedForSend.delete(threadId);\n    return;\n  }\n  stagedForSend.set(threadId, { refs, stagedAt: Date.now() });\n}\n\n/**\n * The refs staged for the message `threadId` journals now, taking the slot (`undefined`: none\n * staged, or staged more than {@link NAMED_AGENTS_STAGED_TTL_MS} ago).\n */\nexport function takeStagedDeepAgentNamedAgents(threadId: string): readonly string[] | undefined {\n  const staged = stagedForSend.get(threadId);\n  stagedForSend.delete(threadId);\n  if (staged === undefined || Date.now() - staged.stagedAt > NAMED_AGENTS_STAGED_TTL_MS) {\n    return undefined;\n  }\n  return staged.refs;\n}\n\n/**\n * The metadata of the message `threadId` journals now, for a runtime's `getMessageMetadata` (the\n * SDK's): the names staged for it under {@link DEEP_AGENT_MESSAGE_ADDRESSED_AGENTS_KEY}, taking the\n * slot, or `undefined` when none are staged (the message then names none of its own). Olympus's\n * runtime takes the slot itself, falling back to the conversation's default agent.\n */\nexport function stagedNamedAgentsMessageMetadata(\n  threadId: string\n): Record<string, unknown> | undefined {\n  return withAddressedAgents(undefined, takeStagedDeepAgentNamedAgents(threadId));\n}\n\n// ── The chat outbox ─────────────────────────────────────────────────────────\n\n/**\n * The agents a message held in the chat outbox names (`ChatOutbox.hold`'s `addressedAgents`, kept\n * on its message): its chips' refs, or `undefined` when it names none (it then goes out as a send\n * naming none does).\n */\nexport function deepAgentOutboxAddressedAgents(\n  agents: readonly DeepAgentNamedAgent[]\n): string[] | undefined {\n  const refs = namedAgentRefs(agents);\n  return refs.length === 0 ? undefined : refs;\n}\n\n/**\n * The chips for refs a message carries, named as this page last named those agents: the person's\n * own assistant as the menu names it, a collab agent the page never named as \"Untitled agent\",\n * and any other ref not at all.\n */\nfunction namedAgentsForRefsSeen(refs: readonly string[]): DeepAgentNamedAgent[] {\n  const agents: DeepAgentNamedAgent[] = [];\n  for (const ref of refs) {\n    const seen = namedAgentsSeen.get(ref);\n    if (seen) agents.push(seen);\n    else if (ref === OWN_ASSISTANT_AGENT_REF) {\n      agents.push({ ref, name: OWN_ASSISTANT_DISPLAY_NAME, assetId: null });\n    } else if (ref.startsWith(COLLAB_AGENT_REF_PREFIX)) {\n      agents.push({ ref, name: 'Untitled agent', assetId: ref.slice(COLLAB_AGENT_REF_PREFIX.length) });\n    }\n  }\n  return agents;\n}\n\n/**\n * A waiting message went back to the composer (Cancel, or the ask's Edit): the agents it named\n * (`message.metadata.addressedAgents`) come back as chips with its text, after any named since.\n * The message keeps only refs, so each chip is named by `namedAgentsForRefs` (a host's agent list,\n * as its `@` menu names them), else as this page last named it. Returns the agents put back.\n */\nexport function giveBackDeepAgentOutboxNamedAgents(\n  entry: Pick<ChatOutboxEntry, 'threadId' | 'metadata'>,\n  {\n    namedAgentsForRefs = namedAgentsForRefsSeen,\n  }: { namedAgentsForRefs?: (refs: readonly string[]) => readonly DeepAgentNamedAgent[] } = {}\n): readonly DeepAgentNamedAgent[] {\n  const refs = readAddressedAgents(entry.metadata);\n  if (!refs || refs.length === 0) return NO_NAMED_AGENTS;\n  return namedAgentsForRefs(refs).filter((agent) =>\n    addDeepAgentNamedAgent({ threadId: entry.threadId, agent })\n  );\n}\n\n// ── What a composer's `@` menu offers ───────────────────────────────────────\n\n/**\n * Whether the `@` menu's Agents section is offered to Athena admins alone, for now (#50245). One\n * switch for every chat that names agents (Olympus's composer, the SDK's `AthenaChat`): while it\n * is `true`, only an admin is offered the section, and only an admin's root search finds an agent.\n * It decides who is offered the menu, nothing more: agora checks every name a message carries.\n */\nexport const CHAT_AGENT_NAMING_ADMIN_ONLY = true;\n\n/** Whether a viewer is offered the `@` menu's Agents section ({@link CHAT_AGENT_NAMING_ADMIN_ONLY}). */\nexport function chatAgentNamingOffered({ isAdmin }: { isAdmin: boolean }): boolean {\n  return !CHAT_AGENT_NAMING_ADMIN_ONLY || isAdmin;\n}\n\n/** An agent a composer's `@` menu offers to name. */\nexport interface DeepAgentOfferedAgent extends DeepAgentNamedAgent {\n  /** A Lucide icon name for the menu row. */\n  icon: string;\n}\n\n/** What the person's own assistant is called in the menu and on its chip. */\nexport const OWN_ASSISTANT_DISPLAY_NAME = 'Athena';\n\n/** The person's own assistant, as the menu offers it. */\nexport const OWN_ASSISTANT_OFFERED_AGENT: DeepAgentOfferedAgent = Object.freeze({\n  ref: OWN_ASSISTANT_AGENT_REF,\n  name: OWN_ASSISTANT_DISPLAY_NAME,\n  assetId: null,\n  icon: 'Bot',\n});\n\n/** A collab agent as the menu offers it: its ref, its name (else \"Untitled agent\"), its icon (else a bot). */\nexport function collabAgentOfferedAgent({\n  assetId,\n  name,\n  icon,\n}: {\n  assetId: string;\n  name: string;\n  icon?: string | null;\n}): DeepAgentOfferedAgent {\n  return {\n    ref: `${COLLAB_AGENT_REF_PREFIX}${assetId}`,\n    name: name || 'Untitled agent',\n    assetId,\n    icon: icon || 'Bot',\n  };\n}\n\n/**\n * The agents a composer's `@` menu offers to name: the person's own assistant\n * ({@link OWN_ASSISTANT_OFFERED_AGENT}), then `collabAgents` (the collab agents the composer's agent\n * picker lists) in their order, each once, minus the ones already named; none once eight are named.\n */\nexport function offeredDeepAgentNamedAgents({\n  collabAgents,\n  named,\n}: {\n  collabAgents: readonly DeepAgentOfferedAgent[];\n  named: readonly DeepAgentNamedAgent[];\n}): DeepAgentOfferedAgent[] {\n  if (named.length >= MAX_DEEP_AGENT_NAMED_AGENTS) return [];\n  const taken = new Set(named.map((agent) => agent.ref));\n  const offered: DeepAgentOfferedAgent[] = [];\n  for (const agent of [OWN_ASSISTANT_OFFERED_AGENT, ...collabAgents]) {\n    if (taken.has(agent.ref)) continue;\n    taken.add(agent.ref);\n    offered.push(agent);\n  }\n  return offered;\n}\n\n/** What the composer says when a choice would name more agents than one message takes. */\nexport function namedAgentsLimitMessage(leftOut: readonly string[]): string {\n  const names = new Intl.ListFormat('en', { style: 'long', type: 'conjunction' }).format(leftOut);\n  return `A message names at most ${MAX_DEEP_AGENT_NAMED_AGENTS} agents, so ${names} ${\n    leftOut.length === 1 ? \"wasn't\" : \"weren't\"\n  } added.`;\n}\n\n/**\n * Name `agents` for `threadId`'s next message, in the order given, after those already named.\n * Returns the names of the ones left out because eight were named; an agent named already is\n * not left out, it simply stays where it is.\n */\nexport function nameDeepAgentMentionedAgents({\n  threadId,\n  agents,\n}: {\n  threadId: string;\n  agents: readonly DeepAgentNamedAgent[];\n}): string[] {\n  const leftOut: string[] = [];\n  for (const agent of agents) {\n    const named = readDeepAgentNamedAgents(threadId);\n    if (named.some((entry) => entry.ref === agent.ref.trim())) continue;\n    if (named.length >= MAX_DEEP_AGENT_NAMED_AGENTS) {\n      leftOut.push(agent.name);\n      continue;\n    }\n    addDeepAgentNamedAgent({\n      threadId,\n      agent: { ref: agent.ref, name: agent.name, assetId: agent.assetId },\n    });\n  }\n  return leftOut;\n}\n\n// ── The signed-in identity ──────────────────────────────────────────────────\n\n// process-local: client-only — the signed-in identity this page's names were made under.\nlet namedAgentsIdentity: string | null = null;\n\n/** Drop every chip, staged send and remembered name in this page. */\nexport function forgetAllDeepAgentNamedAgents(): void {\n  stagedForSend.clear();\n  sentTextNamedAgents.clear();\n  withdrawalRestores.clear();\n  namedAgentsSeen.clear();\n  namedAgentsIdentity = null;\n  deepAgentNamedAgentsStore.setState(() => ({ byThread: {} }));\n}\n\n/**\n * `identity` is signed in (Olympus's `DeepAgentSessionLoginReset`, the SDK's `AthenaChat`): names\n * this page made under another identity (an account switch in the page or another tab, an\n * impersonation starting or ending, someone else signing in without a reload) are not this\n * person's to send, so they all go.\n */\nexport function keepDeepAgentNamedAgentsForIdentity(identity: string): void {\n  if (namedAgentsIdentity !== null && namedAgentsIdentity !== identity) {\n    forgetAllDeepAgentNamedAgents();\n  }\n  namedAgentsIdentity = identity;\n}\n"],"names":["useSyncExternalStore","withAddressedAgents","readAddressedAgents"],"mappings":"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"}

package/dist/agent-runtime/src/named-agents.d.ts

@@ -0,0 +1,246 @@
+import type { ChatOutboxEntry } from './chat-outbox-entry';
+/**
+ * The agents a message names (identity v7 D13): one conversation has many participants, and
+ * each message goes to the agents it names, each answering in its own turn, in the order named.
+ * agora reads the names from the message itself (`message.metadata.addressedAgents`,
+ * `addressed-agents.ts`) ahead of the run config's `addressed_agents`, and checks every one of them
+ * (the collab overlay's VIEW gate, a colleague's assistant refused, the history re-check), so the
+ * client only presents what the person can pick and never gates.
+ *
+ * Every chat that names agents runs on this one module: Olympus's deep-agent composer (whose
+ * `deep-agent-named-agents.ts` re-exports it) and the SDK's `AthenaChat` (and so Athena Desktop),
+ * so naming an agent means the same thing, and reaches agora as the same payload, in both. What a
+ * composer's `@` menu offers to name is {@link offeredDeepAgentNamedAgents}.
+ *
+ * - **The chips.** The agents the composer's To line names for each thread, in the order named
+ *   (`set` / `add` / `remove` / `clear`, read with {@link useDeepAgentNamedAgents}). They stay
+ *   for every message until the person changes them. Anything may set a thread's chips; its
+ *   composer shows them. Kept in memory for the page, and dropped when the signed-in identity
+ *   changes ({@link keepDeepAgentNamedAgentsForIdentity}).
+ * - **The send.** statewire captures a new message's metadata once, as it journals it
+ *   (`getMessageMetadata`), without saying which message it is for. So the composer stages the
+ *   chips for its next send right before `aui.composer.send`
+ *   ({@link stageDeepAgentNamedAgentsForSend}), and the runtime's getter takes them for the message
+ *   that follows ({@link takeStagedDeepAgentNamedAgents}, {@link stagedNamedAgentsMessageMetadata}).
+ *   The names then travel with the message: a send that waits, is retried after a failure, or is
+ *   posted again by a page reloaded meanwhile names its own agents, whatever the conversation's
+ *   context says by then, so no send waits for another's. A slot nobody takes expires.
+ * - **The chat outbox.** A message held while Athena can't be reached carries its names on its
+ *   message the same way (`ChatOutbox.hold({ addressedAgents })`,
+ *   {@link deepAgentOutboxAddressedAgents}); its Cancel gives them back as chips with its text
+ *   ({@link giveBackDeepAgentOutboxNamedAgents}).
+ *
+ * Text a send carried that comes back to the composer (a failed send handed back, an early Stop)
+ * brings its chips back ({@link restoreDeepAgentSentNamedAgents}).
+ *
+ * State is per copy of this module: Olympus runs agent-runtime from source, and the SDK bundles
+ * its own copy, whose composer and runtime share it.
+ */
+/**
+ * The message metadata key of the agents a message names (agora:
+ * `agent_refs.ADDRESSED_AGENTS_METADATA_KEY`, read in place of the run config's and never kept on
+ * the turn the transcript records).
+ */
+export declare const DEEP_AGENT_MESSAGE_ADDRESSED_AGENTS_KEY = "addressedAgents";
+export interface DeepAgentNamedAgent {
+    /** What the send names: `collab_agent:<asset id>`, or `assistant` (the sender's own assistant). */
+    ref: string;
+    /** What the chip shows. */
+    name: string;
+    /** The collab agent asset behind `ref`; `null` for the sender's own assistant. */
+    assetId: string | null;
+}
+/** agora takes at most this many names on one message. */
+export declare const MAX_DEEP_AGENT_NAMED_AGENTS = 8;
+/** The ref of the sender's own assistant. */
+export declare const OWN_ASSISTANT_AGENT_REF = "assistant";
+/** The prefix of a collab agent's ref (`collab_agent:<asset id>`). */
+export declare const COLLAB_AGENT_REF_PREFIX = "collab_agent:";
+/** The refs a message naming `agents` sends: in the order named, each once, at most eight. */
+export declare function namedAgentRefs(agents: readonly Pick<DeepAgentNamedAgent, 'ref'>[]): string[];
+/** What a send naming `agents` names, as one key: two sends name the same agents when equal. */
+export declare function namedAgentsKey(agents: readonly Pick<DeepAgentNamedAgent, 'ref'>[]): string;
+/**
+ * Named agents read back from storage (a draft kept across a reload, a message waiting in the chat
+ * outbox): a list of `{ ref, name, assetId }` with a non-empty ref and name and an asset id that is
+ * a string or `null`, each agent once, at most eight. Anything else reads as naming none, entry by
+ * entry, so a newer build's extra fields never break an older reader.
+ */
+export declare function parseDeepAgentNamedAgents(value: unknown): readonly DeepAgentNamedAgent[];
+/** A value its readers follow: a write that changes it tells every listener, synchronously. */
+export interface NamedAgentsStore<T> {
+    readonly state: T;
+    /** Replace the value with what `update` returns; returning the value it was given changes nothing. */
+    setState: (update: (state: T) => T) => void;
+    /** Called after every change; returns the unsubscribe function. */
+    subscribe: (listener: () => void) => () => void;
+}
+interface DeepAgentNamedAgentsState {
+    /** Each thread's named agents (its composer's chips), in the order named. */
+    byThread: Readonly<Record<string, readonly DeepAgentNamedAgent[]>>;
+}
+export declare const deepAgentNamedAgentsStore: NamedAgentsStore<DeepAgentNamedAgentsState>;
+/** The agents `threadId`'s composer names for its next message, in the order named. */
+export declare function useDeepAgentNamedAgents(threadId: string): readonly DeepAgentNamedAgent[];
+/** Imperative read of {@link useDeepAgentNamedAgents} (for send paths and handlers). */
+export declare function readDeepAgentNamedAgents(threadId: string): readonly DeepAgentNamedAgent[];
+/**
+ * Listen for `threadId`'s chips changing (the composer keeps them with its draft). Another
+ * thread's change notifies nothing. Returns the unsubscribe function.
+ */
+export declare function subscribeDeepAgentNamedAgents({ threadId, listener, }: {
+    threadId: string;
+    listener: () => void;
+}): () => void;
+/** Name exactly `agents` for `threadId`'s next message (each once, in order, at most eight). */
+export declare function setDeepAgentNamedAgents({ threadId, agents, }: {
+    threadId: string;
+    agents: readonly DeepAgentNamedAgent[];
+}): void;
+/**
+ * Name one more agent, after those already named. `false` when nothing changed: it is named
+ * already, eight are named, or its ref is blank.
+ */
+export declare function addDeepAgentNamedAgent({ threadId, agent, }: {
+    threadId: string;
+    agent: DeepAgentNamedAgent;
+}): boolean;
+export declare function removeDeepAgentNamedAgent({ threadId, ref, }: {
+    threadId: string;
+    ref: string;
+}): void;
+export declare function clearDeepAgentNamedAgents({ threadId }: {
+    threadId: string;
+}): void;
+/**
+ * Clear `threadId`'s chips once the message that named `agents` has left, but only while they
+ * still are those agents: names changed since the message was sent (while it waited behind a
+ * loading conversation) belong to the next message and stay. Returns whether they were cleared.
+ */
+export declare function clearDeepAgentNamedAgentsIfUnchanged({ threadId, agents, }: {
+    threadId: string;
+    agents: readonly DeepAgentNamedAgent[];
+}): boolean;
+/** Remember the names a send of `text` carried (a send naming none forgets earlier ones). */
+export declare function rememberDeepAgentSentNamedAgents({ threadId, text, agents, }: {
+    threadId: string;
+    text: string;
+    agents: readonly DeepAgentNamedAgent[];
+}): void;
+/**
+ * Text a send carried came back to `threadId`'s composer (a failed send handed back, an early
+ * Stop): the names it carried come back as chips, after any named since (each once, at most
+ * eight). `withdrawnMessageId` marks an early Stop's turn, whose chips go again if the run
+ * answers it after all ({@link undoDeepAgentWithdrawalNamedAgents}). Returns the agents put back.
+ */
+export declare function restoreDeepAgentSentNamedAgents({ threadId, text, withdrawnMessageId, }: {
+    threadId: string;
+    text: string;
+    withdrawnMessageId?: string;
+}): readonly DeepAgentNamedAgent[];
+/**
+ * The run answered a turn its sender took back after all (an early Stop contradicted): the chips
+ * that came back with its text go again, except any taken off since.
+ */
+export declare function undoDeepAgentWithdrawalNamedAgents({ messageId }: {
+    messageId: string;
+}): void;
+/** A withdrawal settled without undoing its restore (the editor changed since): forget it. */
+export declare function forgetDeepAgentWithdrawalNamedAgents({ messageId }: {
+    messageId: string;
+}): void;
+/** How long staged names wait for the message they were staged for before they expire. */
+export declare const NAMED_AGENTS_STAGED_TTL_MS = 10000;
+/**
+ * Stage `agents` as the names of the message `threadId`'s composer submits next. Call right before
+ * the send (`aui.composer.send`): the runtime's `getMessageMetadata` takes them for that message
+ * ({@link takeStagedDeepAgentNamedAgents}). A send naming none stages nothing and lets an earlier
+ * slot go.
+ */
+export declare function stageDeepAgentNamedAgentsForSend({ threadId, agents, }: {
+    threadId: string;
+    agents: readonly DeepAgentNamedAgent[];
+}): void;
+/**
+ * The refs staged for the message `threadId` journals now, taking the slot (`undefined`: none
+ * staged, or staged more than {@link NAMED_AGENTS_STAGED_TTL_MS} ago).
+ */
+export declare function takeStagedDeepAgentNamedAgents(threadId: string): readonly string[] | undefined;
+/**
+ * The metadata of the message `threadId` journals now, for a runtime's `getMessageMetadata` (the
+ * SDK's): the names staged for it under {@link DEEP_AGENT_MESSAGE_ADDRESSED_AGENTS_KEY}, taking the
+ * slot, or `undefined` when none are staged (the message then names none of its own). Olympus's
+ * runtime takes the slot itself, falling back to the conversation's default agent.
+ */
+export declare function stagedNamedAgentsMessageMetadata(threadId: string): Record<string, unknown> | undefined;
+/**
+ * The agents a message held in the chat outbox names (`ChatOutbox.hold`'s `addressedAgents`, kept
+ * on its message): its chips' refs, or `undefined` when it names none (it then goes out as a send
+ * naming none does).
+ */
+export declare function deepAgentOutboxAddressedAgents(agents: readonly DeepAgentNamedAgent[]): string[] | undefined;
+/**
+ * A waiting message went back to the composer (Cancel, or the ask's Edit): the agents it named
+ * (`message.metadata.addressedAgents`) come back as chips with its text, after any named since.
+ * The message keeps only refs, so each chip is named by `namedAgentsForRefs` (a host's agent list,
+ * as its `@` menu names them), else as this page last named it. Returns the agents put back.
+ */
+export declare function giveBackDeepAgentOutboxNamedAgents(entry: Pick<ChatOutboxEntry, 'threadId' | 'metadata'>, { namedAgentsForRefs, }?: {
+    namedAgentsForRefs?: (refs: readonly string[]) => readonly DeepAgentNamedAgent[];
+}): readonly DeepAgentNamedAgent[];
+/**
+ * Whether the `@` menu's Agents section is offered to Athena admins alone, for now (#50245). One
+ * switch for every chat that names agents (Olympus's composer, the SDK's `AthenaChat`): while it
+ * is `true`, only an admin is offered the section, and only an admin's root search finds an agent.
+ * It decides who is offered the menu, nothing more: agora checks every name a message carries.
+ */
+export declare const CHAT_AGENT_NAMING_ADMIN_ONLY = true;
+/** Whether a viewer is offered the `@` menu's Agents section ({@link CHAT_AGENT_NAMING_ADMIN_ONLY}). */
+export declare function chatAgentNamingOffered({ isAdmin }: {
+    isAdmin: boolean;
+}): boolean;
+/** An agent a composer's `@` menu offers to name. */
+export interface DeepAgentOfferedAgent extends DeepAgentNamedAgent {
+    /** A Lucide icon name for the menu row. */
+    icon: string;
+}
+/** What the person's own assistant is called in the menu and on its chip. */
+export declare const OWN_ASSISTANT_DISPLAY_NAME = "Athena";
+/** The person's own assistant, as the menu offers it. */
+export declare const OWN_ASSISTANT_OFFERED_AGENT: DeepAgentOfferedAgent;
+/** A collab agent as the menu offers it: its ref, its name (else "Untitled agent"), its icon (else a bot). */
+export declare function collabAgentOfferedAgent({ assetId, name, icon, }: {
+    assetId: string;
+    name: string;
+    icon?: string | null;
+}): DeepAgentOfferedAgent;
+/**
+ * The agents a composer's `@` menu offers to name: the person's own assistant
+ * ({@link OWN_ASSISTANT_OFFERED_AGENT}), then `collabAgents` (the collab agents the composer's agent
+ * picker lists) in their order, each once, minus the ones already named; none once eight are named.
+ */
+export declare function offeredDeepAgentNamedAgents({ collabAgents, named, }: {
+    collabAgents: readonly DeepAgentOfferedAgent[];
+    named: readonly DeepAgentNamedAgent[];
+}): DeepAgentOfferedAgent[];
+/** What the composer says when a choice would name more agents than one message takes. */
+export declare function namedAgentsLimitMessage(leftOut: readonly string[]): string;
+/**
+ * Name `agents` for `threadId`'s next message, in the order given, after those already named.
+ * Returns the names of the ones left out because eight were named; an agent named already is
+ * not left out, it simply stays where it is.
+ */
+export declare function nameDeepAgentMentionedAgents({ threadId, agents, }: {
+    threadId: string;
+    agents: readonly DeepAgentNamedAgent[];
+}): string[];
+/** Drop every chip, staged send and remembered name in this page. */
+export declare function forgetAllDeepAgentNamedAgents(): void;
+/**
+ * `identity` is signed in (Olympus's `DeepAgentSessionLoginReset`, the SDK's `AthenaChat`): names
+ * this page made under another identity (an account switch in the page or another tab, an
+ * impersonation starting or ending, someone else signing in without a reload) are not this
+ * person's to send, so they all go.
+ */
+export declare function keepDeepAgentNamedAgentsForIdentity(identity: string): void;
+export {};