@athenaintel/react 0.30.0 → 0.35.0

package/README.md

@@ -16,11 +16,10 @@ npm install @propelauth/react
 
 ## Upgrading
 
-SDK0.29.0 uses native Statewire wire2026-09-30 with Athena application2026-09-13
-when installed with public, unpatched dependencies, over HTTP/SSE: published
-statewire0.20.0 pings a WebSocket with empty frames that Athena's hosts reject,
-so the SDK opens a socket only over the patched client the monorepo's own apps
-install. It requires a compatible backend. Publication is temporarily withheld until production HTTP+WebSocket
+SDK0.29.0 uses native Statewire wire2026-09-30 with Athena application2026-09-13.
+With statewire 0.21 it opens a WebSocket on public, unpatched installs too: its
+`{}` ping is answered by Athena's hosts from Python statewire 0.19.1 on. It
+requires a compatible backend. Publication is temporarily withheld until production HTTP+WebSocket
 and authorization tests pass and a compatible backend rollback release is
 retained. The publish workflow requires a manual
 `PRODUCTION_NATIVE_CONTEXT_AND_ROLLBACK_QUALIFIED` acknowledgement; dry runs
@@ -145,6 +144,64 @@ const [thread] = useState(() => ({ threadId: mintThreadId(), isNew: true }));
   embedded frame's text) into the chat the person last focused.
 - `SessionList`'s `onOpenInNewTab` hands the host a session to open in such a chat.
 
+### A model picker, and a session's own model
+
+Pass the picked model as `model`. Changing it while a session is open applies
+to that session's next turn:
+
+- On a session that has not run yet, the next send carries it, and the server
+  keeps it as the session's model.
+- On a session that has run, the server runs every turn with the model the
+  session's server config holds (another client, such as Athena itself, can
+  change it too), so the SDK writes the new model there
+  (`config/patch {model}`). Setting `model` back to `undefined` clears it, so
+  the collab agent's own model, or the default, applies again.
+- The model a session is opened with is never written: opening a session never
+  overrides the model someone chose for it.
+
+Show the session's real model when it opens with `useAthenaThreadModel()`
+(inside `<AthenaProvider>`):
+
+```tsx
+import { useAthenaThreadModel, useAthenaStatewireThreadId } from '@athenaintel/react';
+import { useEffect, useRef } from 'react';
+
+function SessionModelSeed({ onSessionModel }: { onSessionModel: (model: string | null) => void }) {
+  const threadId = useAthenaStatewireThreadId();
+  const { model, configured, ready } = useAthenaThreadModel();
+  const seededFor = useRef<string | null>(null);
+  useEffect(() => {
+    // Once per session, after its snapshot lands; a session without server
+    // config keeps the picker's current value.
+    if (!ready || seededFor.current === threadId) return;
+    seededFor.current = threadId;
+    if (configured) onSessionModel(model); // null: the agent's / default model ("Auto")
+  }, [threadId, model, configured, ready, onSessionModel]);
+  return null;
+}
+```
+
+`model` is `null` when the session pins no model; `configured` is `false` for
+a session without server config yet; wait for `ready` before reading either. A
+refused write (a view-only collaborator, or a workspace whose sessions cannot
+hold server config) is reported as a `statewire.config` diagnostics event, and
+the session keeps running with its own model.
+
+The same holds for `systemPrompt`, `tools` (with the backend-bound
+`frontendTools`), `workbench` and `knowledgeBase`. On a session that has run,
+the server runs every turn with the values its server config holds, so
+changing one of these props while the session is open writes it there: one
+`config/patch` per change, carrying exactly the changed keys (`model`,
+`system_prompt`, `enabled_tools`, `workbench`, `knowledge_base`). A blank
+prompt or an empty list clears its key, so the collab agent's own applies
+again. The values a session is opened with are never written, and a host that
+never changes these props after the first send writes nothing. The
+`statewire.config` event names the refused keys other than the model in
+`config_keys`, never their values.
+
+For a collab agent whose author restricts it to its own models, see
+[Offering an agent's own models](#offering-an-agents-own-models).
+
 If `config.appUrl` is omitted, the provider resolves it from the parent bridge or from the matching Athena environment defaults. Known Athena staging and production `apiUrl` and `backendUrl` values automatically fall back to the corresponding frontend origin.
 
 Use `trustedParentOrigins` when the SDK runs inside an iframe on a private-cloud or custom parent domain and you want to explicitly allow postMessage auth/config from that parent. Only the window that frames the app is heard. By default `athenaintel.com` hosts, localhost and your own origin are trusted, except the hosts that serve customer-written code (`*.app.athenaintel.com`, `*.code-sandpack.athenaintel.com` and friends; see "What's new in 0.28.0").
@@ -214,10 +271,10 @@ What the statewire transport wires up in `AthenaChat`:
   its `classifyToolResult`; the fallback takes host seams (`displayName`,
   `icon`, `extraAction`, `notice`, `renderResult`, `onOpenAsset`,
   `hideInternalIdArgs`) instead of being copied. `@athenaintel/react/super-grouping`
-  exports the grouped ("conversational") view of an assistant turn —
-  `SuperGroupingTranscript` (what `AthenaChat` renders), `SuperGroupingCard`,
-  `SuperGroupingFinalText`, `CollapsibleGroup`, the activity-timeline
-  derivation, and the tool-based grouping function — with
+  exports the collapsed view (previously called the conversational view) of
+  an assistant turn — `SuperGroupingTranscript` (what `AthenaChat` renders),
+  `SuperGroupingCard`, `SuperGroupingFinalText`, `CollapsibleGroup`, the
+  activity-timeline derivation, and the tool-based grouping function — with
   slots for the host's text/tool renderers and controls (`renderHeaderActions`,
   `renderRunningMeta`, `summaryDetails`, `waitingTools`, `expansionKey`), so
   Olympus and the Chrome extension mount one card instead of copies.
@@ -717,6 +774,41 @@ Both use the same bearer / API key as session creation. The full recipe
 template skill `voice-session-guide.md`. `createAthenaVoiceSession` is also
 exported if you hold the bridge state yourself.
 
+## What's new in 0.35.0
+
+**`AthenaAssetEmbed` and `useAssetEmbed` can offer Quick Edit.** Pass `allowQuickEdit` (default `false`) with `readOnly={false}` to mint an editable embed link whose viewer can press ⌘J (Ctrl+J off a Mac), or pick **AI Quick Edit** from the right-click menu, to rewrite a selection in a spreadsheet or Word document. It applies to the `minimal` display mode, where the viewer does not sign in; in `full` mode the signed-in viewer already has Athena's own Quick Edit. The request carries `allow_quick_edit: true` only when you ask, so a backend that predates it never sees the field. Runs are billed to the asset's workspace under the account that created the link, and each link has its own hourly cap. A link minted with `embedUrl` says for itself whether it offers Quick Edit. See the embeds guide in the Athena docs.
+
+**`useAssetEmbed` mints through TanStack Query.** It uses your `QueryClientProvider`'s client when there is one, else one client for the page. As before, embeds of the same asset, mode and identity share one minted link until it expires. A rotated token for the same session mints none, and a link is never minted again while it is valid: no refetch on window focus or reconnect, no retry. The query key carries a fingerprint of the identity, never the token or API key itself.
+
+
+**A prompt, tool list, workbench or knowledge base changed on a session that has run applies.** 0.32.0 did this for `model` only. Once a session has server config, the server runs every turn with the values that config holds and ignores the ones a send carries, so a `systemPrompt`, `tools`/`frontendTools`, `workbench` or `knowledgeBase` changed after the first turn used to be dropped. Changing one while such a session is open now writes it there: one `config/patch` per change, carrying exactly the changed keys (`system_prompt`, `enabled_tools`, `workbench`, `knowledge_base`, beside `model`). A blank prompt or an empty list clears its key, so the collab agent's own applies. As with the model, the values a session is opened with are never written, a host that never changes these props after the first send sees no new writes, and a refused write is a `statewire.config` diagnostics event (`config_keys` names the keys). See [A model picker, and a session's own model](#a-model-picker-and-a-sessions-own-model).
+
+**`ChatModelPicker` follows an agent's "Allow any workspace model" switch.** Restriction is opt-in per agent: with the switch on (the default, and every agent saved before it existed) a chosen agent's picker is the workspace catalog with "Agent's own model", as before, now naming the agent's default (its channel's override on a channel that has one). With the switch off (`allowAnyModel: false` in the published definition), the picker lists exactly the models the agent's author listed, by their labels, with the channel's override as the default there. One option is a label; picking the default hands the host `null` (the existing "Agent's own model"); a session's model outside the list is shown, never replaced. Which agent: `agent`, or `agentSelected` inside the provider, which then reads the provider's own agent and channel. Without an agent the picker is unchanged. **`useAthenaAgentModelOptions({ agent, channel })`** returns the same choices and `allowAnyModel` for a picker of your own. See [Offering an agent's own models](#offering-an-agents-own-models).
+
+**`fetchGraphQL` failures carry their code.** It throws an `AthenaGraphQLError` (exported from `@athenaintel/react/chat-ui`) with the HTTP `status` or the first GraphQL error's `extensions.code`; the messages are unchanged.
+
+## What's new in 0.33.0
+
+**Chat runs over the WebSocket on a plain npm install.** The SDK used to open a socket only over the statewire client the monorepo patched, because published statewire 0.20 pinged with empty frames that Athena's hosts closed. So every app installed from npm fell back to HTTP/SSE. The SDK now depends on statewire 0.21.0 and `@assistant-ui/react-statewire` 0.31.0. Athena's hosts answer the ping, and the SDK opens a WebSocket unless the host asks for SSE (#45143). A rejected model context (for example one over the 64 KiB cap) is reported through `onError`, and sends are held until a valid one is accepted, instead of throwing during render. Nothing to change in your app beyond taking this version; keep `statewire`, `@assistant-ui/react-statewire` and `react` deduplicated as before.
+
+## What's new in 0.32.0
+
+**A model picked after mount reaches the server.** The provider registered its run config once per thread attach, so a `model` (or `channel`, `tools`, `systemPrompt`, …) changed after mount never reached the next send unless something else happened to re-sync the context. The registration is now keyed by the built run config's value: a changed value re-syncs before the next send, while fresh array literals per render still change nothing.
+
+**A model changed on a session that has run applies.** Once a session has server config, the server runs every turn with the model that config holds and ignores the one a send carries, so a picker change after the first turn used to be dropped. Changing `model` while such a session is open now writes it there (`config/patch {model}`; `undefined` clears it so the collab agent's own model applies). The model a session is opened with is never written. See [A model picker, and a session's own model](#a-model-picker-and-a-sessions-own-model).
+
+**`useAthenaThreadModel()`** returns `{ model, configured, ready }`: the model the open session's server config holds, so an app can show a session's real model when it opens. A refused write is reported as the new `statewire.config` diagnostics event.
+
+**A collab agent's session no longer records the SDK default as its model.** With `agent` set and no `model`, the run config's `panel_config` (which the server stores on the session's first run and replays to every client) carried `DEFAULT_STATEWIRE_MODEL`, so Athena showed that model for sessions running the agent's own. It now names no model there.
+
+## What's new in 0.31.0
+
+**Draft tool cards stay in the conversation.** In the grouped view (`groupToolCalls`), a tool flagged `inline` in the shared display registry (`@athenaintel/agent-runtime` `ToolDisplayMeta.inline`; today the email and calendar-event draft tools) renders its card below the activity header, outside the "Used N tools" and "Show tool details" disclosures, and stays mounted whether the card is collapsed or not, so the person can edit and send the draft without opening anything. The call still appears as a step in the timeline, the run does not pause, and the card is not rendered a second time inside the details. The transcript view `AthenaChat` renders (`SuperGroupingTranscript`) does the same per activity segment: the draft card sits under its segment's step row, and a segment whose only step is a draft offers no empty "Show tool details". `SuperGroupingCard` and `SuperGroupingTranscript` take `isInlineTool` to override the registry per host; `excludePartsFromGroups` is exported for hosts that build their own grouped view.
+
+## What's new in 0.30.1
+
+**Spoken words no longer retype from an empty bubble while a voice turn speaks over a run.** In the grouped (conversational) view, the answer below the card is the text after the last tool call plus the words of every spoken voice turn. `SuperGroupingFinalText` used to join those parts into one string, so when a spoken turn kept streaming while the run's own reply streamed after it, the joined text changed in the middle rather than at its end. `MarkdownText`'s streaming reveal restarts whenever its text stops extending what it showed, so the whole answer was wiped and retyped on every spoken word. Each answer part now renders through its own `TextComponent` (keyed by its content index) inside a `data-slot="super-grouping-final-text"` column, and only the last part carries the running status and caret. `getFinalTextParts` (with `FinalTextSegment`) is exported beside `getFinalText`, which still returns the joined string. Nothing to change in your app.
+
 ## What's new in 0.30.0
 
 **Session workbench, closer to Devin's.** The "+" menu now sits right after the tabs and has a search box (Enter opens the first match). Inside `AthenaLayout`, a maximize button gives the workspace the chat's width; the chat stays mounted, hidden, and collapsing a maximized workspace brings it back. With every tab closed, the column lists each pane centred with a one-line `description`, which is a new optional field on `SessionWorkbenchPane` that the built-in panes now carry. Tabs use 13px labels, and the close control stays quiet until the tab is hovered, focused or selected. Pure helper: `filterWorkbenchPanes`.
@@ -1224,6 +1316,63 @@ Pass them only when you deliberately want to override the agent — an explicit
 `model` is honoured as a caller override, with the agent's model as the default
 beneath it.
 
+### Offering an agent's own models
+
+An agent's author lists the models it may run (the agent editor's Models
+section), and decides with its **Allow any workspace model** switch whether
+people may still pick any other. Restriction is opt-in: the switch is on by
+default, and every agent saved before it existed allows any model.
+
+With an agent chosen, `ChatModelPicker` reads the agent's published definition:
+
+- **Allow any workspace model on** (the default; also an agent the person
+  cannot view): the workspace's models and "Agent's own model" (`null`),
+  exactly as before, with the agent's default (its channel's override when the
+  chat runs on a channel that has one) named under "Agent's own model".
+- **Switch off** (`allowAnyModel: false`): exactly the agent's own models, not
+  the workspace's.
+
+```tsx
+<ChatModelPicker
+  value={modelId} // null: the agent's own model
+  onChange={setModelId}
+  defaultModelId="claude-opus-5-5"
+  agent={agentId} // or agentSelected, inside the provider: its own agent and channel
+  channel="askbob_web"
+/>
+```
+
+For an agent with the switch off:
+
+- The options are the agent's labeled models, by the author's labels; an
+  automatic name shows the model's catalog name. A legacy agent with no list
+  offers its single model.
+- The channel's model override is that channel's default, added when the list
+  lacks it. Picking the default hands you `null`: pass `model={undefined}` to
+  the provider, so the agent's (or the channel's) default runs and a session
+  that pinned another model is unpinned. Picking it while the session pins
+  nothing writes nothing. A choice of yours that names the default model is a
+  pin the agent's next default would not follow, so the menu then also offers
+  "Agent's own model" (`null`).
+- A model the session pins outside the list, or a choice of yours the agent
+  does not list, is shown as it is, never replaced.
+- The agent is read again every minute while the picker shows, so a newly
+  published list appears without a reload.
+- One option is a label, not a menu.
+- Until the agent has been read, the workspace menu shows but replaces nothing
+  on your behalf, since your model may be one only the agent offers.
+
+`useAthenaAgentModelOptions({ agent, channel })` is the same data for a picker
+of your own: `{ status, options: [{ model, label, isDefault, pinnedOutside }],
+defaultModel, allowAnyModel }`. Offer only `options` when `allowAnyModel` is
+`false`; it is `true` when the definition says nothing, `null` or `true`.
+`agent` is the asset id or the `collab_agent:<id>` ref. The agent is read
+through the permission-checked asset query (`getAssetById`, VIEW on the agent)
+with the provider's credentials, so `status` is `unavailable` (no options,
+`allowAnyModel: true`, not an error) for a person who cannot view it, or an
+agent never published. The session's pinned model comes from
+`useAthenaThreadModel()`.
+
 ### Failure codes
 
 A refused selection surfaces as an `AthenaSdkError` with
@@ -1364,6 +1513,8 @@ host that opens a cited place in Athena on the web writes it into the Spaces lin
 
 Use `AthenaAssetEmbed` to render a native Athena asset without chat, thread history, tabs, or the SDK split-pane layout. It defaults to the editable, full native asset experience (`readOnly={false}` and `displayMode="full"`). The embed token and the current user must still have edit permission; otherwise Athena renders the asset read-only.
 
+With `displayMode="minimal"`, where the viewer does not sign in, pass `allowQuickEdit` (and `readOnly={false}`) to let the viewer Quick Edit a spreadsheet or Word document with ⌘J. Its runs are billed to the asset's workspace, with an hourly cap per link.
+
 ```tsx
 import { useState } from 'react';
 import {

package/dist/agent-runtime/src/athena-asset-drag.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ATHENA_ASSET_DRAG_MIME = "application/x-athena-asset+json";
+const FLEXLAYOUT_TAB_DRAG_MIME = "application/x-flexlayout-tab";
+const FLEXLAYOUT_DRAG_TEXT_SENTINEL = "--flexlayout--";
+const ATHENA_ASSET_DRAG_TYPES = [
+  ATHENA_ASSET_DRAG_MIME,
+  FLEXLAYOUT_TAB_DRAG_MIME
+];
+function isAthenaAssetDrag(types) {
+  return Array.from(types).some((type) => ATHENA_ASSET_DRAG_TYPES.includes(type));
+}
+function parseAthenaAsset(raw) {
+  if (!raw) return null;
+  try {
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null) return null;
+    const { id, title, assetType } = value;
+    if (typeof id !== "string" || !id) return null;
+    return {
+      id,
+      title: typeof title === "string" && title ? title : "Untitled",
+      assetType: typeof assetType === "string" ? assetType : ""
+    };
+  } catch {
+    return null;
+  }
+}
+function readAthenaAssetDrop(dataTransfer) {
+  const asset = parseAthenaAsset(dataTransfer.getData(ATHENA_ASSET_DRAG_MIME));
+  if (asset) return { kind: "asset", asset };
+  const tabAssetId = dataTransfer.getData(FLEXLAYOUT_TAB_DRAG_MIME);
+  if (tabAssetId) return { kind: "unresolved", assetId: tabAssetId };
+  if (dataTransfer.getData("text/plain") === FLEXLAYOUT_DRAG_TEXT_SENTINEL) {
+    return { kind: "unresolved", assetId: null };
+  }
+  return null;
+}
+exports.ATHENA_ASSET_DRAG_MIME = ATHENA_ASSET_DRAG_MIME;
+exports.FLEXLAYOUT_DRAG_TEXT_SENTINEL = FLEXLAYOUT_DRAG_TEXT_SENTINEL;
+exports.FLEXLAYOUT_TAB_DRAG_MIME = FLEXLAYOUT_TAB_DRAG_MIME;
+exports.isAthenaAssetDrag = isAthenaAssetDrag;
+exports.readAthenaAssetDrop = readAthenaAssetDrop;
+//# sourceMappingURL=athena-asset-drag.cjs.map

package/dist/agent-runtime/src/athena-asset-drag.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"athena-asset-drag.cjs","sources":["../../../../agent-runtime/src/athena-asset-drag.ts"],"sourcesContent":["import type { UploadedChatAsset } from \"./asset-attachment\";\n\n/**\n * Cross-surface drag payload for an Athena asset. Olympus sets it when a\n * Spaces tab or sidebar row starts a native drag so a composer in another\n * document (the Chrome extension side panel, an embedded SDK chat) can insert\n * an asset mention instead of the drag's incidental text.\n */\nexport const ATHENA_ASSET_DRAG_MIME = \"application/x-athena-asset+json\";\n\n/** Olympus's FlexLayout tab drags carry the tab's asset id under this type. */\nexport const FLEXLAYOUT_TAB_DRAG_MIME = \"application/x-flexlayout-tab\";\n\n/** The `text/plain` value FlexLayout writes on every tab drag. */\nexport const FLEXLAYOUT_DRAG_TEXT_SENTINEL = \"--flexlayout--\";\n\nconst ATHENA_ASSET_DRAG_TYPES: readonly string[] = [\n  ATHENA_ASSET_DRAG_MIME,\n  FLEXLAYOUT_TAB_DRAG_MIME,\n];\n\n/** The `DataTransfer` surface read here (agent-runtime has no DOM lib). */\ninterface DragData {\n  getData(format: string): string;\n}\n\nexport function serializeAthenaAssetDrag(asset: UploadedChatAsset): string {\n  return JSON.stringify({\n    id: asset.id,\n    title: asset.title,\n    assetType: asset.assetType,\n  });\n}\n\n/** Whether a drag carries an Athena asset — readable during `dragover`. */\nexport function isAthenaAssetDrag(types: Iterable<string>): boolean {\n  return Array.from(types).some((type) => ATHENA_ASSET_DRAG_TYPES.includes(type));\n}\n\nfunction parseAthenaAsset(raw: string): UploadedChatAsset | null {\n  if (!raw) return null;\n  try {\n    const value: unknown = JSON.parse(raw);\n    if (typeof value !== \"object\" || value === null) return null;\n    const { id, title, assetType } = value as Record<string, unknown>;\n    if (typeof id !== \"string\" || !id) return null;\n    return {\n      id,\n      title: typeof title === \"string\" && title ? title : \"Untitled\",\n      assetType: typeof assetType === \"string\" ? assetType : \"\",\n    };\n  } catch {\n    return null;\n  }\n}\n\nexport type AthenaAssetDrop =\n  | { kind: \"asset\"; asset: UploadedChatAsset }\n  /** An Athena asset drag whose metadata did not travel — swallow it rather\n   * than let the editor paste the sentinel text. */\n  | { kind: \"unresolved\"; assetId: string | null }\n  | null;\n\n/** Reads an Athena asset from a drop, or `null` when the drop is not one. */\nexport function readAthenaAssetDrop(dataTransfer: DragData): AthenaAssetDrop {\n  const asset = parseAthenaAsset(dataTransfer.getData(ATHENA_ASSET_DRAG_MIME));\n  if (asset) return { kind: \"asset\", asset };\n  const tabAssetId = dataTransfer.getData(FLEXLAYOUT_TAB_DRAG_MIME);\n  if (tabAssetId) return { kind: \"unresolved\", assetId: tabAssetId };\n  if (dataTransfer.getData(\"text/plain\") === FLEXLAYOUT_DRAG_TEXT_SENTINEL) {\n    return { kind: \"unresolved\", assetId: null };\n  }\n  return null;\n}\n"],"names":[],"mappings":";;AAQO,MAAM,yBAAyB;AAG/B,MAAM,2BAA2B;AAGjC,MAAM,gCAAgC;AAE7C,MAAM,0BAA6C;AAAA,EACjD;AAAA,EACA;AACF;AAgBO,SAAS,kBAAkB,OAAkC;AAClE,SAAO,MAAM,KAAK,KAAK,EAAE,KAAK,CAAC,SAAS,wBAAwB,SAAS,IAAI,CAAC;AAChF;AAEA,SAAS,iBAAiB,KAAuC;AAC/D,MAAI,CAAC,IAAK,QAAO;AACjB,MAAI;AACF,UAAM,QAAiB,KAAK,MAAM,GAAG;AACrC,QAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,UAAM,EAAE,IAAI,OAAO,UAAA,IAAc;AACjC,QAAI,OAAO,OAAO,YAAY,CAAC,GAAI,QAAO;AAC1C,WAAO;AAAA,MACL;AAAA,MACA,OAAO,OAAO,UAAU,YAAY,QAAQ,QAAQ;AAAA,MACpD,WAAW,OAAO,cAAc,WAAW,YAAY;AAAA,IAAA;AAAA,EAE3D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAUO,SAAS,oBAAoB,cAAyC;AAC3E,QAAM,QAAQ,iBAAiB,aAAa,QAAQ,sBAAsB,CAAC;AAC3E,MAAI,MAAO,QAAO,EAAE,MAAM,SAAS,MAAA;AACnC,QAAM,aAAa,aAAa,QAAQ,wBAAwB;AAChE,MAAI,WAAY,QAAO,EAAE,MAAM,cAAc,SAAS,WAAA;AACtD,MAAI,aAAa,QAAQ,YAAY,MAAM,+BAA+B;AACxE,WAAO,EAAE,MAAM,cAAc,SAAS,KAAA;AAAA,EACxC;AACA,SAAO;AACT;;;;;;"}

package/dist/agent-runtime/src/athena-asset-drag.js

@@ -0,0 +1,44 @@
+const ATHENA_ASSET_DRAG_MIME = "application/x-athena-asset+json";
+const FLEXLAYOUT_TAB_DRAG_MIME = "application/x-flexlayout-tab";
+const FLEXLAYOUT_DRAG_TEXT_SENTINEL = "--flexlayout--";
+const ATHENA_ASSET_DRAG_TYPES = [
+  ATHENA_ASSET_DRAG_MIME,
+  FLEXLAYOUT_TAB_DRAG_MIME
+];
+function isAthenaAssetDrag(types) {
+  return Array.from(types).some((type) => ATHENA_ASSET_DRAG_TYPES.includes(type));
+}
+function parseAthenaAsset(raw) {
+  if (!raw) return null;
+  try {
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null) return null;
+    const { id, title, assetType } = value;
+    if (typeof id !== "string" || !id) return null;
+    return {
+      id,
+      title: typeof title === "string" && title ? title : "Untitled",
+      assetType: typeof assetType === "string" ? assetType : ""
+    };
+  } catch {
+    return null;
+  }
+}
+function readAthenaAssetDrop(dataTransfer) {
+  const asset = parseAthenaAsset(dataTransfer.getData(ATHENA_ASSET_DRAG_MIME));
+  if (asset) return { kind: "asset", asset };
+  const tabAssetId = dataTransfer.getData(FLEXLAYOUT_TAB_DRAG_MIME);
+  if (tabAssetId) return { kind: "unresolved", assetId: tabAssetId };
+  if (dataTransfer.getData("text/plain") === FLEXLAYOUT_DRAG_TEXT_SENTINEL) {
+    return { kind: "unresolved", assetId: null };
+  }
+  return null;
+}
+export {
+  ATHENA_ASSET_DRAG_MIME,
+  FLEXLAYOUT_DRAG_TEXT_SENTINEL,
+  FLEXLAYOUT_TAB_DRAG_MIME,
+  isAthenaAssetDrag,
+  readAthenaAssetDrop
+};
+//# sourceMappingURL=athena-asset-drag.js.map

package/dist/agent-runtime/src/athena-asset-drag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"athena-asset-drag.js","sources":["../../../../agent-runtime/src/athena-asset-drag.ts"],"sourcesContent":["import type { UploadedChatAsset } from \"./asset-attachment\";\n\n/**\n * Cross-surface drag payload for an Athena asset. Olympus sets it when a\n * Spaces tab or sidebar row starts a native drag so a composer in another\n * document (the Chrome extension side panel, an embedded SDK chat) can insert\n * an asset mention instead of the drag's incidental text.\n */\nexport const ATHENA_ASSET_DRAG_MIME = \"application/x-athena-asset+json\";\n\n/** Olympus's FlexLayout tab drags carry the tab's asset id under this type. */\nexport const FLEXLAYOUT_TAB_DRAG_MIME = \"application/x-flexlayout-tab\";\n\n/** The `text/plain` value FlexLayout writes on every tab drag. */\nexport const FLEXLAYOUT_DRAG_TEXT_SENTINEL = \"--flexlayout--\";\n\nconst ATHENA_ASSET_DRAG_TYPES: readonly string[] = [\n  ATHENA_ASSET_DRAG_MIME,\n  FLEXLAYOUT_TAB_DRAG_MIME,\n];\n\n/** The `DataTransfer` surface read here (agent-runtime has no DOM lib). */\ninterface DragData {\n  getData(format: string): string;\n}\n\nexport function serializeAthenaAssetDrag(asset: UploadedChatAsset): string {\n  return JSON.stringify({\n    id: asset.id,\n    title: asset.title,\n    assetType: asset.assetType,\n  });\n}\n\n/** Whether a drag carries an Athena asset — readable during `dragover`. */\nexport function isAthenaAssetDrag(types: Iterable<string>): boolean {\n  return Array.from(types).some((type) => ATHENA_ASSET_DRAG_TYPES.includes(type));\n}\n\nfunction parseAthenaAsset(raw: string): UploadedChatAsset | null {\n  if (!raw) return null;\n  try {\n    const value: unknown = JSON.parse(raw);\n    if (typeof value !== \"object\" || value === null) return null;\n    const { id, title, assetType } = value as Record<string, unknown>;\n    if (typeof id !== \"string\" || !id) return null;\n    return {\n      id,\n      title: typeof title === \"string\" && title ? title : \"Untitled\",\n      assetType: typeof assetType === \"string\" ? assetType : \"\",\n    };\n  } catch {\n    return null;\n  }\n}\n\nexport type AthenaAssetDrop =\n  | { kind: \"asset\"; asset: UploadedChatAsset }\n  /** An Athena asset drag whose metadata did not travel — swallow it rather\n   * than let the editor paste the sentinel text. */\n  | { kind: \"unresolved\"; assetId: string | null }\n  | null;\n\n/** Reads an Athena asset from a drop, or `null` when the drop is not one. */\nexport function readAthenaAssetDrop(dataTransfer: DragData): AthenaAssetDrop {\n  const asset = parseAthenaAsset(dataTransfer.getData(ATHENA_ASSET_DRAG_MIME));\n  if (asset) return { kind: \"asset\", asset };\n  const tabAssetId = dataTransfer.getData(FLEXLAYOUT_TAB_DRAG_MIME);\n  if (tabAssetId) return { kind: \"unresolved\", assetId: tabAssetId };\n  if (dataTransfer.getData(\"text/plain\") === FLEXLAYOUT_DRAG_TEXT_SENTINEL) {\n    return { kind: \"unresolved\", assetId: null };\n  }\n  return null;\n}\n"],"names":[],"mappings":"AAQO,MAAM,yBAAyB;AAG/B,MAAM,2BAA2B;AAGjC,MAAM,gCAAgC;AAE7C,MAAM,0BAA6C;AAAA,EACjD;AAAA,EACA;AACF;AAgBO,SAAS,kBAAkB,OAAkC;AAClE,SAAO,MAAM,KAAK,KAAK,EAAE,KAAK,CAAC,SAAS,wBAAwB,SAAS,IAAI,CAAC;AAChF;AAEA,SAAS,iBAAiB,KAAuC;AAC/D,MAAI,CAAC,IAAK,QAAO;AACjB,MAAI;AACF,UAAM,QAAiB,KAAK,MAAM,GAAG;AACrC,QAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,UAAM,EAAE,IAAI,OAAO,UAAA,IAAc;AACjC,QAAI,OAAO,OAAO,YAAY,CAAC,GAAI,QAAO;AAC1C,WAAO;AAAA,MACL;AAAA,MACA,OAAO,OAAO,UAAU,YAAY,QAAQ,QAAQ;AAAA,MACpD,WAAW,OAAO,cAAc,WAAW,YAAY;AAAA,IAAA;AAAA,EAE3D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAUO,SAAS,oBAAoB,cAAyC;AAC3E,QAAM,QAAQ,iBAAiB,aAAa,QAAQ,sBAAsB,CAAC;AAC3E,MAAI,MAAO,QAAO,EAAE,MAAM,SAAS,MAAA;AACnC,QAAM,aAAa,aAAa,QAAQ,wBAAwB;AAChE,MAAI,WAAY,QAAO,EAAE,MAAM,cAAc,SAAS,WAAA;AACtD,MAAI,aAAa,QAAQ,YAAY,MAAM,+BAA+B;AACxE,WAAO,EAAE,MAAM,cAAc,SAAS,KAAA;AAAA,EACxC;AACA,SAAO;AACT;"}

package/dist/agent-runtime/src/composer-markdown.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"composer-markdown.cjs","sources":["../../../../agent-runtime/src/composer-markdown.ts"],"sourcesContent":["/**\n * The composer markdown a chat message was sent from.\n *\n * The chat composer sends a message's plain text exactly as typed, because the\n * model reads the text literally, and writes real formatting (bold, lists,\n * code, mention chips) as markdown. The sent text alone no longer says which\n * characters are formatting and which were typed: literal `**strong**` and\n * bold `strong` both send `**strong**`, and `List<T>`, `a\\\\b` or `2*3*4` read\n * as markup when the text is rendered as markdown. So the composer also\n * attaches the draft the text was serialized from (the same document with its\n * plain text escaped for markdown) under {@link DEEP_AGENT_COMPOSER_MARKDOWN_KEY}\n * in the message's metadata, and only when the two differ.\n *\n * It rides the statewire message, the queue and steer lanes and the persisted\n * HumanMessage (`additional_kwargs.metadata`, which the converter surfaces as\n * `metadata.custom`). It is display-only: the bubble renders it, and Edit,\n * branch-and-edit and a withdrawn turn load it back into the composer. The\n * model reads the message text, never this. A message without it (older\n * messages, other clients) renders its text as before.\n *\n * agora validates it with the same rule\n * (`agora/graphs/athena_deep_agent/composer_markdown.py`).\n */\nexport const DEEP_AGENT_COMPOSER_MARKDOWN_KEY = 'composer_markdown';\n\nconst DRAFT_CHARACTER_REFERENCES: Readonly<Record<string, string>> = {\n  lt: '<',\n  gt: '>',\n  amp: '&',\n  '#32': ' ',\n  '#9': '\\t',\n};\n\n/**\n * A sent text in comparable form: every backslash dropped (the draft's\n * escapes, and the `\\` before a hard break's newline, are backslashes).\n */\nconst comparableText = (text: string): string => text.replace(/\\\\/g, '');\n\n/**\n * A draft in comparable form: every backslash dropped, then the character\n * references the draft serializer writes decoded in one pass (`&lt;` and\n * `&gt;` for typed `<` and `>`, `&amp;` for a typed `&` that starts a\n * reference, so typed `&lt;` is `&amp;lt;`, and `&#32;` / `&#9;` for the space\n * or tab a line starts with, which markdown would otherwise drop).\n */\nconst comparableDraft = (markdown: string): string =>\n  comparableText(markdown).replace(\n    /&(lt|gt|amp|#32|#9);/g,\n    (reference, name: string) => DRAFT_CHARACTER_REFERENCES[name] ?? reference\n  );\n\n/**\n * Escaping at most turns one character into four (`<` → `&lt;`). A line's\n * first space becomes five (`&#32;`), but only once a line, so a whole line\n * with its line break stays under four a character; the slack covers short\n * texts. agora caps a stored draft the same way.\n */\nconst MAX_EXPANSION = 4;\nconst EXPANSION_SLACK_CHARS = 1024;\n\n/**\n * Whether `markdown` is the draft of `text`: no longer than escaping could make\n * it, and equal to it once backslashes are dropped and the draft's character\n * references decoded. A draft that would show other\n * words than the text the model read (another message's, a client's mistake) is\n * not taken; such a message renders its text as before.\n */\nexport function isComposerMarkdownOfText({\n  markdown,\n  text,\n}: {\n  markdown: string;\n  text: string;\n}): boolean {\n  return (\n    markdown.length <= text.length * MAX_EXPANSION + EXPANSION_SLACK_CHARS &&\n    comparableDraft(markdown) === comparableText(text)\n  );\n}\n\n/** The references a draft writes a line's first space or tab as. */\nconst DRAFT_WHITESPACE_REFERENCES: readonly string[] = ['&#32;', '&#9;'];\n\nconst isWhitespace = (character: string): boolean => /\\s/.test(character);\n\n/** A hard break in a draft: `\\` before the newline (the text holds the newline alone). */\nconst DRAFT_HARD_BREAK = '\\\\\\n';\n\n/** Whether an odd run of backslashes ends at `end`: its last one escapes what follows, not a typed `\\` (`\\\\`). */\nfunction endsInEscapingBackslash({\n  markdown,\n  start,\n  end,\n}: {\n  markdown: string;\n  start: number;\n  end: number;\n}): boolean {\n  let backslashes = 0;\n  while (end - backslashes > start && markdown.charAt(end - backslashes - 1) === '\\\\') {\n    backslashes += 1;\n  }\n  return backslashes % 2 === 1;\n}\n\n/**\n * `markdown`, a draft, trimmed as its text is trimmed (`text.trim()`): a\n * send that trims its text stays a draft of it. `markdown.trim()` would keep\n * the `&#32;` a draft writes for the space its first line starts with, and the\n * `\\` of a line break whose newline it trims.\n */\nexport function trimComposerDraft(markdown: string): string {\n  let start = 0;\n  let end = markdown.length;\n  for (;;) {\n    while (start < end && isWhitespace(markdown.charAt(start))) start += 1;\n    const reference = [...DRAFT_WHITESPACE_REFERENCES, DRAFT_HARD_BREAK].find(\n      (candidate) => start + candidate.length <= end && markdown.startsWith(candidate, start)\n    );\n    if (reference === undefined) break;\n    start += reference.length;\n  }\n  for (;;) {\n    while (end > start && isWhitespace(markdown.charAt(end - 1))) end -= 1;\n    const reference = DRAFT_WHITESPACE_REFERENCES.find(\n      (candidate) => end - candidate.length >= start && markdown.endsWith(candidate, end)\n    );\n    if (reference !== undefined) {\n      end -= reference.length;\n    } else if (\n      markdown.charAt(end) === '\\n' &&\n      endsInEscapingBackslash({ markdown, start, end })\n    ) {\n      // The newline just trimmed was a line break's: its `\\` goes with it.\n      end -= 1;\n    } else {\n      break;\n    }\n  }\n  return markdown.slice(start, end);\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\n/**\n * The composer markdown to render or load for a message whose metadata is\n * `metadata` (a message's `metadata.custom`, or a lane entry's `metadata`) and\n * whose text is `text`; `null` when it carries none, or one that is not a\n * draft of `text`.\n */\nexport function readDeepAgentComposerMarkdown({\n  metadata,\n  text,\n}: {\n  metadata: unknown;\n  text: string;\n}): string | null {\n  if (!isRecord(metadata)) return null;\n  const markdown: unknown = metadata[DEEP_AGENT_COMPOSER_MARKDOWN_KEY];\n  return typeof markdown === 'string' && isComposerMarkdownOfText({ markdown, text })\n    ? markdown\n    : null;\n}\n\n/**\n * How long a staged composer markdown waits for its submission\n * ({@link stageComposerMarkdown}).\n */\nexport const STAGED_COMPOSER_MARKDOWN_TTL_MS = 10_000;\n\ninterface StagedComposerMarkdown {\n  readonly markdown: string;\n  readonly stagedAt: number;\n}\n\n/**\n * The staged drafts live on `globalThis`, not in module scope, because two\n * copies of this module run in one page: the SDK bundles agent-runtime into its\n * dist, so its composer stages through the SDK's copy, while the Chrome\n * extension and the Office add-in build their runtime on agent-runtime directly\n * and take the draft through their own (see `asset-attachment.ts`).\n */\nconst STAGED_COMPOSER_MARKDOWN = Symbol.for('@athenaintel/agent-runtime/staged-composer-markdown');\n\ntype StagedComposerMarkdownHost = typeof globalThis & {\n  [STAGED_COMPOSER_MARKDOWN]?: Map<string, StagedComposerMarkdown>;\n};\n\nfunction stagedComposerMarkdownByThread(): Map<string, StagedComposerMarkdown> {\n  const host = globalThis as StagedComposerMarkdownHost;\n  return (host[STAGED_COMPOSER_MARKDOWN] ??= new Map());\n}\n\n/**\n * Stage the draft `markdown` of `text` for `threadId`'s next submission.\n *\n * statewire captures message metadata once per new user message\n * (`getMessageMetadata`, patched into `@assistant-ui/react-statewire@0.30.0`)\n * without saying which message it is for, so a composer stages its draft right\n * before it sends and the runtime's getter takes it for the submission that\n * follows ({@link withStagedComposerMarkdown}). A draft equal to its text adds\n * nothing and clears the slot. A slot nobody takes within\n * {@link STAGED_COMPOSER_MARKDOWN_TTL_MS} expires; one a submission the\n * composer did not make takes is harmless, since a composer markdown that is\n * not a draft of the message's own text is neither kept by agora nor rendered.\n */\nexport function stageComposerMarkdown({\n  threadId,\n  text,\n  markdown,\n  now = Date.now(),\n}: {\n  threadId: string;\n  text: string;\n  markdown: string;\n  /** Test seam: the time of the send. */\n  now?: number;\n}): void {\n  const staged = stagedComposerMarkdownByThread();\n  if (markdown === text) {\n    staged.delete(threadId);\n    return;\n  }\n  staged.set(threadId, { markdown, stagedAt: now });\n}\n\n/**\n * The message metadata for `threadId`'s submission now being journaled: the\n * staged composer markdown, if one is waiting and fresh. Takes the slot.\n */\nexport function takeStagedComposerMarkdownMetadata(\n  threadId: string,\n  now: number = Date.now()\n): Record<string, unknown> | undefined {\n  const staged = stagedComposerMarkdownByThread();\n  const entry = staged.get(threadId);\n  staged.delete(threadId);\n  if (entry === undefined || now - entry.stagedAt > STAGED_COMPOSER_MARKDOWN_TTL_MS) {\n    return undefined;\n  }\n  return { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: entry.markdown };\n}\n\ntype MessageMetadataGetter = () =>\n  | Record<string, unknown>\n  | undefined\n  | Promise<Record<string, unknown> | undefined>;\n\n/**\n * A runtime's `getMessageMetadata` that also carries the composer markdown a\n * composer staged for `threadId` ({@link stageComposerMarkdown}), on top of the\n * host's own metadata (`getMessageMetadata`, when it has one). The slot is\n * taken synchronously at submission, before the host's capture resolves, so a\n * draft never rides a later message. With nothing staged the host's own value\n * is returned as is.\n */\nexport function withStagedComposerMarkdown({\n  threadId,\n  getMessageMetadata,\n}: {\n  threadId: string;\n  getMessageMetadata?: MessageMetadataGetter | undefined;\n}): MessageMetadataGetter {\n  return () => {\n    const staged = takeStagedComposerMarkdownMetadata(threadId);\n    const captured = getMessageMetadata?.();\n    if (staged === undefined) return captured;\n    const merge = (host: Record<string, unknown> | undefined): Record<string, unknown> => ({\n      ...host,\n      ...staged,\n    });\n    return captured instanceof Promise ? captured.then(merge) : merge(captured);\n  };\n}\n\n/** Test seam: drop every staged composer markdown. */\nexport function resetStagedComposerMarkdown(): void {\n  stagedComposerMarkdownByThread().clear();\n}\n\n/**\n * `metadata` with the composer markdown set to the draft `markdown` of `text`,\n * or without it when the draft equals the text (it adds nothing then).\n * Returns `undefined` when nothing is left.\n */\nexport function withDeepAgentComposerMarkdown({\n  metadata,\n  text,\n  markdown,\n}: {\n  metadata: Readonly<Record<string, unknown>> | undefined;\n  text: string;\n  markdown: string;\n}): Record<string, unknown> | undefined {\n  const { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: _previous, ...rest } = metadata ?? {};\n  const next: Record<string, unknown> =\n    markdown === text ? rest : { ...rest, [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: markdown };\n  return Object.keys(next).length > 0 ? next : undefined;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"composer-markdown.cjs","sources":["../../../../agent-runtime/src/composer-markdown.ts"],"sourcesContent":["/**\n * The composer markdown a chat message was sent from.\n *\n * The chat composer sends a message's plain text exactly as typed, because the\n * model reads the text literally, and writes real formatting (bold, lists,\n * code, mention chips) as markdown. The sent text alone no longer says which\n * characters are formatting and which were typed: literal `**strong**` and\n * bold `strong` both send `**strong**`, and `List<T>`, `a\\\\b` or `2*3*4` read\n * as markup when the text is rendered as markdown. So the composer also\n * attaches the draft the text was serialized from (the same document with its\n * plain text escaped for markdown) under {@link DEEP_AGENT_COMPOSER_MARKDOWN_KEY}\n * in the message's metadata, and only when the two differ.\n *\n * It rides the statewire message, the queue and steer lanes and the persisted\n * HumanMessage (`additional_kwargs.metadata`, which the converter surfaces as\n * `metadata.custom`). It is display-only: the bubble renders it, and Edit,\n * branch-and-edit and a withdrawn turn load it back into the composer. The\n * model reads the message text, never this. A message without it (older\n * messages, other clients) renders its text as before.\n *\n * agora validates it with the same rule\n * (`agora/graphs/athena_deep_agent/composer_markdown.py`).\n */\nexport const DEEP_AGENT_COMPOSER_MARKDOWN_KEY = 'composer_markdown';\n\nconst DRAFT_CHARACTER_REFERENCES: Readonly<Record<string, string>> = {\n  lt: '<',\n  gt: '>',\n  amp: '&',\n  '#32': ' ',\n  '#9': '\\t',\n};\n\n/**\n * A sent text in comparable form: every backslash dropped (the draft's\n * escapes, and the `\\` before a hard break's newline, are backslashes).\n */\nconst comparableText = (text: string): string => text.replace(/\\\\/g, '');\n\n/**\n * A draft in comparable form: every backslash dropped, then the character\n * references the draft serializer writes decoded in one pass (`&lt;` and\n * `&gt;` for typed `<` and `>`, `&amp;` for a typed `&` that starts a\n * reference, so typed `&lt;` is `&amp;lt;`, and `&#32;` / `&#9;` for the space\n * or tab a line starts with, which markdown would otherwise drop).\n */\nconst comparableDraft = (markdown: string): string =>\n  comparableText(markdown).replace(\n    /&(lt|gt|amp|#32|#9);/g,\n    (reference, name: string) => DRAFT_CHARACTER_REFERENCES[name] ?? reference\n  );\n\n/**\n * Escaping at most turns one character into four (`<` → `&lt;`). A line's\n * first space becomes five (`&#32;`), but only once a line, so a whole line\n * with its line break stays under four a character; the slack covers short\n * texts. agora caps a stored draft the same way.\n */\nconst MAX_EXPANSION = 4;\nconst EXPANSION_SLACK_CHARS = 1024;\n\n/**\n * Whether `markdown` is the draft of `text`: no longer than escaping could make\n * it, and equal to it once backslashes are dropped and the draft's character\n * references decoded. A draft that would show other\n * words than the text the model read (another message's, a client's mistake) is\n * not taken; such a message renders its text as before.\n */\nexport function isComposerMarkdownOfText({\n  markdown,\n  text,\n}: {\n  markdown: string;\n  text: string;\n}): boolean {\n  return (\n    markdown.length <= text.length * MAX_EXPANSION + EXPANSION_SLACK_CHARS &&\n    comparableDraft(markdown) === comparableText(text)\n  );\n}\n\n/** The references a draft writes a line's first space or tab as. */\nconst DRAFT_WHITESPACE_REFERENCES: readonly string[] = ['&#32;', '&#9;'];\n\nconst isWhitespace = (character: string): boolean => /\\s/.test(character);\n\n/** A hard break in a draft: `\\` before the newline (the text holds the newline alone). */\nconst DRAFT_HARD_BREAK = '\\\\\\n';\n\n/** Whether an odd run of backslashes ends at `end`: its last one escapes what follows, not a typed `\\` (`\\\\`). */\nfunction endsInEscapingBackslash({\n  markdown,\n  start,\n  end,\n}: {\n  markdown: string;\n  start: number;\n  end: number;\n}): boolean {\n  let backslashes = 0;\n  while (end - backslashes > start && markdown.charAt(end - backslashes - 1) === '\\\\') {\n    backslashes += 1;\n  }\n  return backslashes % 2 === 1;\n}\n\n/**\n * `markdown`, a draft, trimmed as its text is trimmed (`text.trim()`): a\n * send that trims its text stays a draft of it. `markdown.trim()` would keep\n * the `&#32;` a draft writes for the space its first line starts with, and the\n * `\\` of a line break whose newline it trims.\n */\nexport function trimComposerDraft(markdown: string): string {\n  let start = 0;\n  let end = markdown.length;\n  for (;;) {\n    while (start < end && isWhitespace(markdown.charAt(start))) start += 1;\n    const reference = [...DRAFT_WHITESPACE_REFERENCES, DRAFT_HARD_BREAK].find(\n      (candidate) => start + candidate.length <= end && markdown.startsWith(candidate, start)\n    );\n    if (reference === undefined) break;\n    start += reference.length;\n  }\n  for (;;) {\n    while (end > start && isWhitespace(markdown.charAt(end - 1))) end -= 1;\n    const reference = DRAFT_WHITESPACE_REFERENCES.find(\n      (candidate) => end - candidate.length >= start && markdown.endsWith(candidate, end)\n    );\n    if (reference !== undefined) {\n      end -= reference.length;\n    } else if (\n      markdown.charAt(end) === '\\n' &&\n      endsInEscapingBackslash({ markdown, start, end })\n    ) {\n      // The newline just trimmed was a line break's: its `\\` goes with it.\n      end -= 1;\n    } else {\n      break;\n    }\n  }\n  return markdown.slice(start, end);\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\n/**\n * The composer markdown to render or load for a message whose metadata is\n * `metadata` (a message's `metadata.custom`, or a lane entry's `metadata`) and\n * whose text is `text`; `null` when it carries none, or one that is not a\n * draft of `text`.\n */\nexport function readDeepAgentComposerMarkdown({\n  metadata,\n  text,\n}: {\n  metadata: unknown;\n  text: string;\n}): string | null {\n  if (!isRecord(metadata)) return null;\n  const markdown: unknown = metadata[DEEP_AGENT_COMPOSER_MARKDOWN_KEY];\n  return typeof markdown === 'string' && isComposerMarkdownOfText({ markdown, text })\n    ? markdown\n    : null;\n}\n\n/**\n * How long a staged composer markdown waits for its submission\n * ({@link stageComposerMarkdown}).\n */\nexport const STAGED_COMPOSER_MARKDOWN_TTL_MS = 10_000;\n\ninterface StagedComposerMarkdown {\n  readonly markdown: string;\n  readonly stagedAt: number;\n}\n\n/**\n * The staged drafts live on `globalThis`, not in module scope, because two\n * copies of this module run in one page: the SDK bundles agent-runtime into its\n * dist, so its composer stages through the SDK's copy, while the Chrome\n * extension and the Office add-in build their runtime on agent-runtime directly\n * and take the draft through their own (see `asset-attachment.ts`).\n */\nconst STAGED_COMPOSER_MARKDOWN = Symbol.for('@athenaintel/agent-runtime/staged-composer-markdown');\n\ntype StagedComposerMarkdownHost = typeof globalThis & {\n  [STAGED_COMPOSER_MARKDOWN]?: Map<string, StagedComposerMarkdown>;\n};\n\nfunction stagedComposerMarkdownByThread(): Map<string, StagedComposerMarkdown> {\n  const host = globalThis as StagedComposerMarkdownHost;\n  return (host[STAGED_COMPOSER_MARKDOWN] ??= new Map());\n}\n\n/**\n * Stage the draft `markdown` of `text` for `threadId`'s next submission.\n *\n * statewire captures message metadata once per new user message\n * (`getMessageMetadata`, patched into `@assistant-ui/react-statewire@0.31.0`)\n * without saying which message it is for, so a composer stages its draft right\n * before it sends and the runtime's getter takes it for the submission that\n * follows ({@link withStagedComposerMarkdown}). A draft equal to its text adds\n * nothing and clears the slot. A slot nobody takes within\n * {@link STAGED_COMPOSER_MARKDOWN_TTL_MS} expires; one a submission the\n * composer did not make takes is harmless, since a composer markdown that is\n * not a draft of the message's own text is neither kept by agora nor rendered.\n */\nexport function stageComposerMarkdown({\n  threadId,\n  text,\n  markdown,\n  now = Date.now(),\n}: {\n  threadId: string;\n  text: string;\n  markdown: string;\n  /** Test seam: the time of the send. */\n  now?: number;\n}): void {\n  const staged = stagedComposerMarkdownByThread();\n  if (markdown === text) {\n    staged.delete(threadId);\n    return;\n  }\n  staged.set(threadId, { markdown, stagedAt: now });\n}\n\n/**\n * The message metadata for `threadId`'s submission now being journaled: the\n * staged composer markdown, if one is waiting and fresh. Takes the slot.\n */\nexport function takeStagedComposerMarkdownMetadata(\n  threadId: string,\n  now: number = Date.now()\n): Record<string, unknown> | undefined {\n  const staged = stagedComposerMarkdownByThread();\n  const entry = staged.get(threadId);\n  staged.delete(threadId);\n  if (entry === undefined || now - entry.stagedAt > STAGED_COMPOSER_MARKDOWN_TTL_MS) {\n    return undefined;\n  }\n  return { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: entry.markdown };\n}\n\ntype MessageMetadataGetter = () =>\n  | Record<string, unknown>\n  | undefined\n  | Promise<Record<string, unknown> | undefined>;\n\n/**\n * A runtime's `getMessageMetadata` that also carries the composer markdown a\n * composer staged for `threadId` ({@link stageComposerMarkdown}), on top of the\n * host's own metadata (`getMessageMetadata`, when it has one). The slot is\n * taken synchronously at submission, before the host's capture resolves, so a\n * draft never rides a later message. With nothing staged the host's own value\n * is returned as is.\n */\nexport function withStagedComposerMarkdown({\n  threadId,\n  getMessageMetadata,\n}: {\n  threadId: string;\n  getMessageMetadata?: MessageMetadataGetter | undefined;\n}): MessageMetadataGetter {\n  return () => {\n    const staged = takeStagedComposerMarkdownMetadata(threadId);\n    const captured = getMessageMetadata?.();\n    if (staged === undefined) return captured;\n    const merge = (host: Record<string, unknown> | undefined): Record<string, unknown> => ({\n      ...host,\n      ...staged,\n    });\n    return captured instanceof Promise ? captured.then(merge) : merge(captured);\n  };\n}\n\n/** Test seam: drop every staged composer markdown. */\nexport function resetStagedComposerMarkdown(): void {\n  stagedComposerMarkdownByThread().clear();\n}\n\n/**\n * `metadata` with the composer markdown set to the draft `markdown` of `text`,\n * or without it when the draft equals the text (it adds nothing then).\n * Returns `undefined` when nothing is left.\n */\nexport function withDeepAgentComposerMarkdown({\n  metadata,\n  text,\n  markdown,\n}: {\n  metadata: Readonly<Record<string, unknown>> | undefined;\n  text: string;\n  markdown: string;\n}): Record<string, unknown> | undefined {\n  const { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: _previous, ...rest } = metadata ?? {};\n  const next: Record<string, unknown> =\n    markdown === text ? rest : { ...rest, [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: markdown };\n  return Object.keys(next).length > 0 ? next : undefined;\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/composer-markdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"composer-markdown.js","sources":["../../../../agent-runtime/src/composer-markdown.ts"],"sourcesContent":["/**\n * The composer markdown a chat message was sent from.\n *\n * The chat composer sends a message's plain text exactly as typed, because the\n * model reads the text literally, and writes real formatting (bold, lists,\n * code, mention chips) as markdown. The sent text alone no longer says which\n * characters are formatting and which were typed: literal `**strong**` and\n * bold `strong` both send `**strong**`, and `List<T>`, `a\\\\b` or `2*3*4` read\n * as markup when the text is rendered as markdown. So the composer also\n * attaches the draft the text was serialized from (the same document with its\n * plain text escaped for markdown) under {@link DEEP_AGENT_COMPOSER_MARKDOWN_KEY}\n * in the message's metadata, and only when the two differ.\n *\n * It rides the statewire message, the queue and steer lanes and the persisted\n * HumanMessage (`additional_kwargs.metadata`, which the converter surfaces as\n * `metadata.custom`). It is display-only: the bubble renders it, and Edit,\n * branch-and-edit and a withdrawn turn load it back into the composer. The\n * model reads the message text, never this. A message without it (older\n * messages, other clients) renders its text as before.\n *\n * agora validates it with the same rule\n * (`agora/graphs/athena_deep_agent/composer_markdown.py`).\n */\nexport const DEEP_AGENT_COMPOSER_MARKDOWN_KEY = 'composer_markdown';\n\nconst DRAFT_CHARACTER_REFERENCES: Readonly<Record<string, string>> = {\n  lt: '<',\n  gt: '>',\n  amp: '&',\n  '#32': ' ',\n  '#9': '\\t',\n};\n\n/**\n * A sent text in comparable form: every backslash dropped (the draft's\n * escapes, and the `\\` before a hard break's newline, are backslashes).\n */\nconst comparableText = (text: string): string => text.replace(/\\\\/g, '');\n\n/**\n * A draft in comparable form: every backslash dropped, then the character\n * references the draft serializer writes decoded in one pass (`&lt;` and\n * `&gt;` for typed `<` and `>`, `&amp;` for a typed `&` that starts a\n * reference, so typed `&lt;` is `&amp;lt;`, and `&#32;` / `&#9;` for the space\n * or tab a line starts with, which markdown would otherwise drop).\n */\nconst comparableDraft = (markdown: string): string =>\n  comparableText(markdown).replace(\n    /&(lt|gt|amp|#32|#9);/g,\n    (reference, name: string) => DRAFT_CHARACTER_REFERENCES[name] ?? reference\n  );\n\n/**\n * Escaping at most turns one character into four (`<` → `&lt;`). A line's\n * first space becomes five (`&#32;`), but only once a line, so a whole line\n * with its line break stays under four a character; the slack covers short\n * texts. agora caps a stored draft the same way.\n */\nconst MAX_EXPANSION = 4;\nconst EXPANSION_SLACK_CHARS = 1024;\n\n/**\n * Whether `markdown` is the draft of `text`: no longer than escaping could make\n * it, and equal to it once backslashes are dropped and the draft's character\n * references decoded. A draft that would show other\n * words than the text the model read (another message's, a client's mistake) is\n * not taken; such a message renders its text as before.\n */\nexport function isComposerMarkdownOfText({\n  markdown,\n  text,\n}: {\n  markdown: string;\n  text: string;\n}): boolean {\n  return (\n    markdown.length <= text.length * MAX_EXPANSION + EXPANSION_SLACK_CHARS &&\n    comparableDraft(markdown) === comparableText(text)\n  );\n}\n\n/** The references a draft writes a line's first space or tab as. */\nconst DRAFT_WHITESPACE_REFERENCES: readonly string[] = ['&#32;', '&#9;'];\n\nconst isWhitespace = (character: string): boolean => /\\s/.test(character);\n\n/** A hard break in a draft: `\\` before the newline (the text holds the newline alone). */\nconst DRAFT_HARD_BREAK = '\\\\\\n';\n\n/** Whether an odd run of backslashes ends at `end`: its last one escapes what follows, not a typed `\\` (`\\\\`). */\nfunction endsInEscapingBackslash({\n  markdown,\n  start,\n  end,\n}: {\n  markdown: string;\n  start: number;\n  end: number;\n}): boolean {\n  let backslashes = 0;\n  while (end - backslashes > start && markdown.charAt(end - backslashes - 1) === '\\\\') {\n    backslashes += 1;\n  }\n  return backslashes % 2 === 1;\n}\n\n/**\n * `markdown`, a draft, trimmed as its text is trimmed (`text.trim()`): a\n * send that trims its text stays a draft of it. `markdown.trim()` would keep\n * the `&#32;` a draft writes for the space its first line starts with, and the\n * `\\` of a line break whose newline it trims.\n */\nexport function trimComposerDraft(markdown: string): string {\n  let start = 0;\n  let end = markdown.length;\n  for (;;) {\n    while (start < end && isWhitespace(markdown.charAt(start))) start += 1;\n    const reference = [...DRAFT_WHITESPACE_REFERENCES, DRAFT_HARD_BREAK].find(\n      (candidate) => start + candidate.length <= end && markdown.startsWith(candidate, start)\n    );\n    if (reference === undefined) break;\n    start += reference.length;\n  }\n  for (;;) {\n    while (end > start && isWhitespace(markdown.charAt(end - 1))) end -= 1;\n    const reference = DRAFT_WHITESPACE_REFERENCES.find(\n      (candidate) => end - candidate.length >= start && markdown.endsWith(candidate, end)\n    );\n    if (reference !== undefined) {\n      end -= reference.length;\n    } else if (\n      markdown.charAt(end) === '\\n' &&\n      endsInEscapingBackslash({ markdown, start, end })\n    ) {\n      // The newline just trimmed was a line break's: its `\\` goes with it.\n      end -= 1;\n    } else {\n      break;\n    }\n  }\n  return markdown.slice(start, end);\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\n/**\n * The composer markdown to render or load for a message whose metadata is\n * `metadata` (a message's `metadata.custom`, or a lane entry's `metadata`) and\n * whose text is `text`; `null` when it carries none, or one that is not a\n * draft of `text`.\n */\nexport function readDeepAgentComposerMarkdown({\n  metadata,\n  text,\n}: {\n  metadata: unknown;\n  text: string;\n}): string | null {\n  if (!isRecord(metadata)) return null;\n  const markdown: unknown = metadata[DEEP_AGENT_COMPOSER_MARKDOWN_KEY];\n  return typeof markdown === 'string' && isComposerMarkdownOfText({ markdown, text })\n    ? markdown\n    : null;\n}\n\n/**\n * How long a staged composer markdown waits for its submission\n * ({@link stageComposerMarkdown}).\n */\nexport const STAGED_COMPOSER_MARKDOWN_TTL_MS = 10_000;\n\ninterface StagedComposerMarkdown {\n  readonly markdown: string;\n  readonly stagedAt: number;\n}\n\n/**\n * The staged drafts live on `globalThis`, not in module scope, because two\n * copies of this module run in one page: the SDK bundles agent-runtime into its\n * dist, so its composer stages through the SDK's copy, while the Chrome\n * extension and the Office add-in build their runtime on agent-runtime directly\n * and take the draft through their own (see `asset-attachment.ts`).\n */\nconst STAGED_COMPOSER_MARKDOWN = Symbol.for('@athenaintel/agent-runtime/staged-composer-markdown');\n\ntype StagedComposerMarkdownHost = typeof globalThis & {\n  [STAGED_COMPOSER_MARKDOWN]?: Map<string, StagedComposerMarkdown>;\n};\n\nfunction stagedComposerMarkdownByThread(): Map<string, StagedComposerMarkdown> {\n  const host = globalThis as StagedComposerMarkdownHost;\n  return (host[STAGED_COMPOSER_MARKDOWN] ??= new Map());\n}\n\n/**\n * Stage the draft `markdown` of `text` for `threadId`'s next submission.\n *\n * statewire captures message metadata once per new user message\n * (`getMessageMetadata`, patched into `@assistant-ui/react-statewire@0.30.0`)\n * without saying which message it is for, so a composer stages its draft right\n * before it sends and the runtime's getter takes it for the submission that\n * follows ({@link withStagedComposerMarkdown}). A draft equal to its text adds\n * nothing and clears the slot. A slot nobody takes within\n * {@link STAGED_COMPOSER_MARKDOWN_TTL_MS} expires; one a submission the\n * composer did not make takes is harmless, since a composer markdown that is\n * not a draft of the message's own text is neither kept by agora nor rendered.\n */\nexport function stageComposerMarkdown({\n  threadId,\n  text,\n  markdown,\n  now = Date.now(),\n}: {\n  threadId: string;\n  text: string;\n  markdown: string;\n  /** Test seam: the time of the send. */\n  now?: number;\n}): void {\n  const staged = stagedComposerMarkdownByThread();\n  if (markdown === text) {\n    staged.delete(threadId);\n    return;\n  }\n  staged.set(threadId, { markdown, stagedAt: now });\n}\n\n/**\n * The message metadata for `threadId`'s submission now being journaled: the\n * staged composer markdown, if one is waiting and fresh. Takes the slot.\n */\nexport function takeStagedComposerMarkdownMetadata(\n  threadId: string,\n  now: number = Date.now()\n): Record<string, unknown> | undefined {\n  const staged = stagedComposerMarkdownByThread();\n  const entry = staged.get(threadId);\n  staged.delete(threadId);\n  if (entry === undefined || now - entry.stagedAt > STAGED_COMPOSER_MARKDOWN_TTL_MS) {\n    return undefined;\n  }\n  return { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: entry.markdown };\n}\n\ntype MessageMetadataGetter = () =>\n  | Record<string, unknown>\n  | undefined\n  | Promise<Record<string, unknown> | undefined>;\n\n/**\n * A runtime's `getMessageMetadata` that also carries the composer markdown a\n * composer staged for `threadId` ({@link stageComposerMarkdown}), on top of the\n * host's own metadata (`getMessageMetadata`, when it has one). The slot is\n * taken synchronously at submission, before the host's capture resolves, so a\n * draft never rides a later message. With nothing staged the host's own value\n * is returned as is.\n */\nexport function withStagedComposerMarkdown({\n  threadId,\n  getMessageMetadata,\n}: {\n  threadId: string;\n  getMessageMetadata?: MessageMetadataGetter | undefined;\n}): MessageMetadataGetter {\n  return () => {\n    const staged = takeStagedComposerMarkdownMetadata(threadId);\n    const captured = getMessageMetadata?.();\n    if (staged === undefined) return captured;\n    const merge = (host: Record<string, unknown> | undefined): Record<string, unknown> => ({\n      ...host,\n      ...staged,\n    });\n    return captured instanceof Promise ? captured.then(merge) : merge(captured);\n  };\n}\n\n/** Test seam: drop every staged composer markdown. */\nexport function resetStagedComposerMarkdown(): void {\n  stagedComposerMarkdownByThread().clear();\n}\n\n/**\n * `metadata` with the composer markdown set to the draft `markdown` of `text`,\n * or without it when the draft equals the text (it adds nothing then).\n * Returns `undefined` when nothing is left.\n */\nexport function withDeepAgentComposerMarkdown({\n  metadata,\n  text,\n  markdown,\n}: {\n  metadata: Readonly<Record<string, unknown>> | undefined;\n  text: string;\n  markdown: string;\n}): Record<string, unknown> | undefined {\n  const { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: _previous, ...rest } = metadata ?? {};\n  const next: Record<string, unknown> =\n    markdown === text ? rest : { ...rest, [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: markdown };\n  return Object.keys(next).length > 0 ? next : undefined;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"composer-markdown.js","sources":["../../../../agent-runtime/src/composer-markdown.ts"],"sourcesContent":["/**\n * The composer markdown a chat message was sent from.\n *\n * The chat composer sends a message's plain text exactly as typed, because the\n * model reads the text literally, and writes real formatting (bold, lists,\n * code, mention chips) as markdown. The sent text alone no longer says which\n * characters are formatting and which were typed: literal `**strong**` and\n * bold `strong` both send `**strong**`, and `List<T>`, `a\\\\b` or `2*3*4` read\n * as markup when the text is rendered as markdown. So the composer also\n * attaches the draft the text was serialized from (the same document with its\n * plain text escaped for markdown) under {@link DEEP_AGENT_COMPOSER_MARKDOWN_KEY}\n * in the message's metadata, and only when the two differ.\n *\n * It rides the statewire message, the queue and steer lanes and the persisted\n * HumanMessage (`additional_kwargs.metadata`, which the converter surfaces as\n * `metadata.custom`). It is display-only: the bubble renders it, and Edit,\n * branch-and-edit and a withdrawn turn load it back into the composer. The\n * model reads the message text, never this. A message without it (older\n * messages, other clients) renders its text as before.\n *\n * agora validates it with the same rule\n * (`agora/graphs/athena_deep_agent/composer_markdown.py`).\n */\nexport const DEEP_AGENT_COMPOSER_MARKDOWN_KEY = 'composer_markdown';\n\nconst DRAFT_CHARACTER_REFERENCES: Readonly<Record<string, string>> = {\n  lt: '<',\n  gt: '>',\n  amp: '&',\n  '#32': ' ',\n  '#9': '\\t',\n};\n\n/**\n * A sent text in comparable form: every backslash dropped (the draft's\n * escapes, and the `\\` before a hard break's newline, are backslashes).\n */\nconst comparableText = (text: string): string => text.replace(/\\\\/g, '');\n\n/**\n * A draft in comparable form: every backslash dropped, then the character\n * references the draft serializer writes decoded in one pass (`&lt;` and\n * `&gt;` for typed `<` and `>`, `&amp;` for a typed `&` that starts a\n * reference, so typed `&lt;` is `&amp;lt;`, and `&#32;` / `&#9;` for the space\n * or tab a line starts with, which markdown would otherwise drop).\n */\nconst comparableDraft = (markdown: string): string =>\n  comparableText(markdown).replace(\n    /&(lt|gt|amp|#32|#9);/g,\n    (reference, name: string) => DRAFT_CHARACTER_REFERENCES[name] ?? reference\n  );\n\n/**\n * Escaping at most turns one character into four (`<` → `&lt;`). A line's\n * first space becomes five (`&#32;`), but only once a line, so a whole line\n * with its line break stays under four a character; the slack covers short\n * texts. agora caps a stored draft the same way.\n */\nconst MAX_EXPANSION = 4;\nconst EXPANSION_SLACK_CHARS = 1024;\n\n/**\n * Whether `markdown` is the draft of `text`: no longer than escaping could make\n * it, and equal to it once backslashes are dropped and the draft's character\n * references decoded. A draft that would show other\n * words than the text the model read (another message's, a client's mistake) is\n * not taken; such a message renders its text as before.\n */\nexport function isComposerMarkdownOfText({\n  markdown,\n  text,\n}: {\n  markdown: string;\n  text: string;\n}): boolean {\n  return (\n    markdown.length <= text.length * MAX_EXPANSION + EXPANSION_SLACK_CHARS &&\n    comparableDraft(markdown) === comparableText(text)\n  );\n}\n\n/** The references a draft writes a line's first space or tab as. */\nconst DRAFT_WHITESPACE_REFERENCES: readonly string[] = ['&#32;', '&#9;'];\n\nconst isWhitespace = (character: string): boolean => /\\s/.test(character);\n\n/** A hard break in a draft: `\\` before the newline (the text holds the newline alone). */\nconst DRAFT_HARD_BREAK = '\\\\\\n';\n\n/** Whether an odd run of backslashes ends at `end`: its last one escapes what follows, not a typed `\\` (`\\\\`). */\nfunction endsInEscapingBackslash({\n  markdown,\n  start,\n  end,\n}: {\n  markdown: string;\n  start: number;\n  end: number;\n}): boolean {\n  let backslashes = 0;\n  while (end - backslashes > start && markdown.charAt(end - backslashes - 1) === '\\\\') {\n    backslashes += 1;\n  }\n  return backslashes % 2 === 1;\n}\n\n/**\n * `markdown`, a draft, trimmed as its text is trimmed (`text.trim()`): a\n * send that trims its text stays a draft of it. `markdown.trim()` would keep\n * the `&#32;` a draft writes for the space its first line starts with, and the\n * `\\` of a line break whose newline it trims.\n */\nexport function trimComposerDraft(markdown: string): string {\n  let start = 0;\n  let end = markdown.length;\n  for (;;) {\n    while (start < end && isWhitespace(markdown.charAt(start))) start += 1;\n    const reference = [...DRAFT_WHITESPACE_REFERENCES, DRAFT_HARD_BREAK].find(\n      (candidate) => start + candidate.length <= end && markdown.startsWith(candidate, start)\n    );\n    if (reference === undefined) break;\n    start += reference.length;\n  }\n  for (;;) {\n    while (end > start && isWhitespace(markdown.charAt(end - 1))) end -= 1;\n    const reference = DRAFT_WHITESPACE_REFERENCES.find(\n      (candidate) => end - candidate.length >= start && markdown.endsWith(candidate, end)\n    );\n    if (reference !== undefined) {\n      end -= reference.length;\n    } else if (\n      markdown.charAt(end) === '\\n' &&\n      endsInEscapingBackslash({ markdown, start, end })\n    ) {\n      // The newline just trimmed was a line break's: its `\\` goes with it.\n      end -= 1;\n    } else {\n      break;\n    }\n  }\n  return markdown.slice(start, end);\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value);\n\n/**\n * The composer markdown to render or load for a message whose metadata is\n * `metadata` (a message's `metadata.custom`, or a lane entry's `metadata`) and\n * whose text is `text`; `null` when it carries none, or one that is not a\n * draft of `text`.\n */\nexport function readDeepAgentComposerMarkdown({\n  metadata,\n  text,\n}: {\n  metadata: unknown;\n  text: string;\n}): string | null {\n  if (!isRecord(metadata)) return null;\n  const markdown: unknown = metadata[DEEP_AGENT_COMPOSER_MARKDOWN_KEY];\n  return typeof markdown === 'string' && isComposerMarkdownOfText({ markdown, text })\n    ? markdown\n    : null;\n}\n\n/**\n * How long a staged composer markdown waits for its submission\n * ({@link stageComposerMarkdown}).\n */\nexport const STAGED_COMPOSER_MARKDOWN_TTL_MS = 10_000;\n\ninterface StagedComposerMarkdown {\n  readonly markdown: string;\n  readonly stagedAt: number;\n}\n\n/**\n * The staged drafts live on `globalThis`, not in module scope, because two\n * copies of this module run in one page: the SDK bundles agent-runtime into its\n * dist, so its composer stages through the SDK's copy, while the Chrome\n * extension and the Office add-in build their runtime on agent-runtime directly\n * and take the draft through their own (see `asset-attachment.ts`).\n */\nconst STAGED_COMPOSER_MARKDOWN = Symbol.for('@athenaintel/agent-runtime/staged-composer-markdown');\n\ntype StagedComposerMarkdownHost = typeof globalThis & {\n  [STAGED_COMPOSER_MARKDOWN]?: Map<string, StagedComposerMarkdown>;\n};\n\nfunction stagedComposerMarkdownByThread(): Map<string, StagedComposerMarkdown> {\n  const host = globalThis as StagedComposerMarkdownHost;\n  return (host[STAGED_COMPOSER_MARKDOWN] ??= new Map());\n}\n\n/**\n * Stage the draft `markdown` of `text` for `threadId`'s next submission.\n *\n * statewire captures message metadata once per new user message\n * (`getMessageMetadata`, patched into `@assistant-ui/react-statewire@0.31.0`)\n * without saying which message it is for, so a composer stages its draft right\n * before it sends and the runtime's getter takes it for the submission that\n * follows ({@link withStagedComposerMarkdown}). A draft equal to its text adds\n * nothing and clears the slot. A slot nobody takes within\n * {@link STAGED_COMPOSER_MARKDOWN_TTL_MS} expires; one a submission the\n * composer did not make takes is harmless, since a composer markdown that is\n * not a draft of the message's own text is neither kept by agora nor rendered.\n */\nexport function stageComposerMarkdown({\n  threadId,\n  text,\n  markdown,\n  now = Date.now(),\n}: {\n  threadId: string;\n  text: string;\n  markdown: string;\n  /** Test seam: the time of the send. */\n  now?: number;\n}): void {\n  const staged = stagedComposerMarkdownByThread();\n  if (markdown === text) {\n    staged.delete(threadId);\n    return;\n  }\n  staged.set(threadId, { markdown, stagedAt: now });\n}\n\n/**\n * The message metadata for `threadId`'s submission now being journaled: the\n * staged composer markdown, if one is waiting and fresh. Takes the slot.\n */\nexport function takeStagedComposerMarkdownMetadata(\n  threadId: string,\n  now: number = Date.now()\n): Record<string, unknown> | undefined {\n  const staged = stagedComposerMarkdownByThread();\n  const entry = staged.get(threadId);\n  staged.delete(threadId);\n  if (entry === undefined || now - entry.stagedAt > STAGED_COMPOSER_MARKDOWN_TTL_MS) {\n    return undefined;\n  }\n  return { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: entry.markdown };\n}\n\ntype MessageMetadataGetter = () =>\n  | Record<string, unknown>\n  | undefined\n  | Promise<Record<string, unknown> | undefined>;\n\n/**\n * A runtime's `getMessageMetadata` that also carries the composer markdown a\n * composer staged for `threadId` ({@link stageComposerMarkdown}), on top of the\n * host's own metadata (`getMessageMetadata`, when it has one). The slot is\n * taken synchronously at submission, before the host's capture resolves, so a\n * draft never rides a later message. With nothing staged the host's own value\n * is returned as is.\n */\nexport function withStagedComposerMarkdown({\n  threadId,\n  getMessageMetadata,\n}: {\n  threadId: string;\n  getMessageMetadata?: MessageMetadataGetter | undefined;\n}): MessageMetadataGetter {\n  return () => {\n    const staged = takeStagedComposerMarkdownMetadata(threadId);\n    const captured = getMessageMetadata?.();\n    if (staged === undefined) return captured;\n    const merge = (host: Record<string, unknown> | undefined): Record<string, unknown> => ({\n      ...host,\n      ...staged,\n    });\n    return captured instanceof Promise ? captured.then(merge) : merge(captured);\n  };\n}\n\n/** Test seam: drop every staged composer markdown. */\nexport function resetStagedComposerMarkdown(): void {\n  stagedComposerMarkdownByThread().clear();\n}\n\n/**\n * `metadata` with the composer markdown set to the draft `markdown` of `text`,\n * or without it when the draft equals the text (it adds nothing then).\n * Returns `undefined` when nothing is left.\n */\nexport function withDeepAgentComposerMarkdown({\n  metadata,\n  text,\n  markdown,\n}: {\n  metadata: Readonly<Record<string, unknown>> | undefined;\n  text: string;\n  markdown: string;\n}): Record<string, unknown> | undefined {\n  const { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: _previous, ...rest } = metadata ?? {};\n  const next: Record<string, unknown> =\n    markdown === text ? rest : { ...rest, [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: markdown };\n  return Object.keys(next).length > 0 ? next : undefined;\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/config-mutations.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ENABLED_TOOLS = "enabled_tools";
+const EXCLUDED_TOOLS = "excluded_tools";
+const DECLINED_TOOLKITS = "declined_toolkit_ids";
+const PANEL_CONFIG = "panel_config";
+const stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+const uniqueIds = (ids) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const id of ids) {
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+};
+function applyConfigPatch(custom, patch) {
+  const next = { ...custom };
+  for (const [key, value] of Object.entries(patch)) {
+    if (key === PANEL_CONFIG) continue;
+    if (value === null || value === void 0) delete next[key];
+    else next[key] = value;
+  }
+  return next;
+}
+function applyToolsEnable(custom, toolIds) {
+  const ids = uniqueIds(toolIds);
+  if (ids.length === 0) return { ...custom };
+  const next = { ...custom };
+  const adding = new Set(ids);
+  next[ENABLED_TOOLS] = uniqueIds([...stringList(custom[ENABLED_TOOLS]), ...ids]);
+  for (const key of [EXCLUDED_TOOLS, DECLINED_TOOLKITS]) {
+    if (!(key in custom)) continue;
+    const kept = stringList(custom[key]).filter((id) => !adding.has(id));
+    if (kept.length > 0) next[key] = kept;
+    else delete next[key];
+  }
+  return next;
+}
+function applyToolsDisable(custom, toolIds) {
+  const ids = uniqueIds(toolIds);
+  if (ids.length === 0) return { ...custom };
+  const next = { ...custom };
+  const removing = new Set(ids);
+  const explicit = Array.isArray(custom[ENABLED_TOOLS]);
+  const enabled = stringList(custom[ENABLED_TOOLS]);
+  const present = new Set(enabled);
+  if (explicit) next[ENABLED_TOOLS] = enabled.filter((id) => !removing.has(id));
+  const declined = ids.filter((id) => !present.has(id));
+  if (declined.length > 0) {
+    next[DECLINED_TOOLKITS] = uniqueIds([...stringList(custom[DECLINED_TOOLKITS]), ...declined]);
+  }
+  return next;
+}
+exports.applyConfigPatch = applyConfigPatch;
+exports.applyToolsDisable = applyToolsDisable;
+exports.applyToolsEnable = applyToolsEnable;
+//# sourceMappingURL=config-mutations.cjs.map

package/dist/agent-runtime/src/config-mutations.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-mutations.cjs","sources":["../../../../agent-runtime/src/config-mutations.ts"],"sourcesContent":["import {\n  RUN_CONFIG_PER_SEND_CUSTOM_KEY_SET,\n  THREAD_CONFIG_CUSTOM_KEY_SET,\n} from './generated/runconfig-contract';\n\n/**\n * Pure transforms behind the `config/*` command family — the client-side\n * mirror of `agora/agora/graphs/athena_deep_agent/thread_config.py`\n * (`apply_config_patch` / `apply_tools_enable` / `apply_tools_disable`).\n *\n * The hook folds these over `state.config.custom` while a command is in\n * flight so the UI reflects the write immediately; the server applies the same\n * transform under the config row's lock, so the optimistic and the durable\n * result agree whenever no other device wrote in between — and compose\n * (rather than conflict) when one did.\n */\n\nexport type ThreadConfigCustom = Record<string, unknown>;\n\n/** A `config/patch` payload: `null` unsets the key. */\nexport type ThreadConfigPatch = Record<string, unknown | null>;\n\nconst ENABLED_TOOLS = 'enabled_tools';\nconst EXCLUDED_TOOLS = 'excluded_tools';\nconst DECLINED_TOOLKITS = 'declined_toolkit_ids';\nconst PANEL_CONFIG = 'panel_config';\n\nconst stringList = (value: unknown): string[] =>\n  Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];\n\nconst uniqueIds = (ids: Iterable<string>): string[] => {\n  const seen = new Set<string>();\n  const out: string[] = [];\n  for (const id of ids) {\n    if (!id || seen.has(id)) continue;\n    seen.add(id);\n    out.push(id);\n  }\n  return out;\n};\n\n/** Set / unset top-level keys. `panel_config` is never part of the server config. */\nexport function applyConfigPatch(\n  custom: ThreadConfigCustom,\n  patch: ThreadConfigPatch\n): ThreadConfigCustom {\n  const next: ThreadConfigCustom = { ...custom };\n  for (const [key, value] of Object.entries(patch)) {\n    if (key === PANEL_CONFIG) continue;\n    if (value === null || value === undefined) delete next[key];\n    else next[key] = value;\n  }\n  return next;\n}\n\n/**\n * Append ids to `enabled_tools` (deduplicated, order preserved) and lift\n * them out of `excluded_tools` / `declined_toolkit_ids`.\n */\nexport function applyToolsEnable(\n  custom: ThreadConfigCustom,\n  toolIds: readonly string[]\n): ThreadConfigCustom {\n  const ids = uniqueIds(toolIds);\n  if (ids.length === 0) return { ...custom };\n  const next: ThreadConfigCustom = { ...custom };\n  const adding = new Set(ids);\n  next[ENABLED_TOOLS] = uniqueIds([...stringList(custom[ENABLED_TOOLS]), ...ids]);\n  for (const key of [EXCLUDED_TOOLS, DECLINED_TOOLKITS]) {\n    if (!(key in custom)) continue;\n    const kept = stringList(custom[key]).filter((id) => !adding.has(id));\n    if (kept.length > 0) next[key] = kept;\n    else delete next[key];\n  }\n  return next;\n}\n\n/**\n * Remove ids from an explicit `enabled_tools` list; an id that is not in the\n * list (or a thread without one — running its collab agent's compiled\n * toolkits) is recorded in `declined_toolkit_ids` so the opt-out sticks.\n */\nexport function applyToolsDisable(\n  custom: ThreadConfigCustom,\n  toolIds: readonly string[]\n): ThreadConfigCustom {\n  const ids = uniqueIds(toolIds);\n  if (ids.length === 0) return { ...custom };\n  const next: ThreadConfigCustom = { ...custom };\n  const removing = new Set(ids);\n  const explicit = Array.isArray(custom[ENABLED_TOOLS]);\n  const enabled = stringList(custom[ENABLED_TOOLS]);\n  const present = new Set(enabled);\n  if (explicit) next[ENABLED_TOOLS] = enabled.filter((id) => !removing.has(id));\n  const declined = ids.filter((id) => !present.has(id));\n  if (declined.length > 0) {\n    next[DECLINED_TOOLKITS] = uniqueIds([...stringList(custom[DECLINED_TOOLKITS]), ...declined]);\n  }\n  return next;\n}\n\n/** A thread's currently enabled tool ids — `null` when the thread has no explicit list (defers to its agent). */\nexport function readEnabledTools(custom: ThreadConfigCustom | null | undefined): string[] | null {\n  const value = custom?.[ENABLED_TOOLS];\n  return Array.isArray(value) ? stringList(value) : null;\n}\n\n/** The `declined_toolkit_ids` advisory list (empty when absent). */\nexport function readDeclinedToolkitIds(custom: ThreadConfigCustom | null | undefined): string[] {\n  return stringList(custom?.[DECLINED_TOOLKITS]);\n}\n\n/**\n * The subset of a `runConfig.custom` payload a client is allowed to carry per\n * send on a server-configured thread (`RUN_CONFIG_PER_SEND_CUSTOM_KEYS`).\n * Every other key is owned by the server config lane and would be dropped at\n * dispatch, so sending it only invites drift between what a client thinks it\n * asked for and what ran.\n */\nexport function pickPerSendCustom(custom: ThreadConfigCustom): ThreadConfigCustom {\n  const out: ThreadConfigCustom = {};\n  for (const [key, value] of Object.entries(custom)) {\n    if (value === undefined) continue;\n    if (RUN_CONFIG_PER_SEND_CUSTOM_KEY_SET.has(key)) out[key] = value;\n  }\n  return out;\n}\n\n/**\n * The subset of a `runConfig.custom` payload the thread's server config lane\n * owns (`THREAD_CONFIG_CUSTOM_KEYS`) — what a client seeds a fresh thread with\n * through `config/patch` before its first send.\n */\nexport function pickThreadConfigCustom(custom: ThreadConfigCustom): ThreadConfigCustom {\n  const out: ThreadConfigCustom = {};\n  for (const [key, value] of Object.entries(custom)) {\n    if (value === undefined) continue;\n    if (THREAD_CONFIG_CUSTOM_KEY_SET.has(key)) out[key] = value;\n  }\n  return out;\n}\n\n/**\n * The `config/patch` that turns `current` into `desired` over the thread-config\n * keys: changed keys carry their new value, keys absent from `desired` carry\n * `null` (unset). `null` when nothing differs.\n */\nexport function diffThreadConfig(\n  current: ThreadConfigCustom,\n  desired: ThreadConfigCustom\n): ThreadConfigPatch | null {\n  const patch: ThreadConfigPatch = {};\n  const next = pickThreadConfigCustom(desired);\n  const prev = pickThreadConfigCustom(current);\n  for (const [key, value] of Object.entries(next)) {\n    if (!(key in prev) || !deepEqual(prev[key], value)) patch[key] = value;\n  }\n  for (const key of Object.keys(prev)) {\n    if (!(key in next)) patch[key] = null;\n  }\n  return Object.keys(patch).length > 0 ? patch : null;\n}\n\nfunction deepEqual(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;\n  if (Array.isArray(a) !== Array.isArray(b)) return false;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((item, index) => deepEqual(item, b[index]));\n  }\n  const ra = a as Record<string, unknown>;\n  const rb = b as Record<string, unknown>;\n  const ka = Object.keys(ra);\n  const kb = Object.keys(rb);\n  return ka.length === kb.length && ka.every((key) => key in rb && deepEqual(ra[key], rb[key]));\n}\n"],"names":[],"mappings":";;AAsBA,MAAM,gBAAgB;AACtB,MAAM,iBAAiB;AACvB,MAAM,oBAAoB;AAC1B,MAAM,eAAe;AAErB,MAAM,aAAa,CAAC,UAClB,MAAM,QAAQ,KAAK,IAAI,MAAM,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ,IAAI,CAAA;AAE5F,MAAM,YAAY,CAAC,QAAoC;AACrD,QAAM,2BAAW,IAAA;AACjB,QAAM,MAAgB,CAAA;AACtB,aAAW,MAAM,KAAK;AACpB,QAAI,CAAC,MAAM,KAAK,IAAI,EAAE,EAAG;AACzB,SAAK,IAAI,EAAE;AACX,QAAI,KAAK,EAAE;AAAA,EACb;AACA,SAAO;AACT;AAGO,SAAS,iBACd,QACA,OACoB;AACpB,QAAM,OAA2B,EAAE,GAAG,OAAA;AACtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,KAAK,GAAG;AAChD,QAAI,QAAQ,aAAc;AAC1B,QAAI,UAAU,QAAQ,UAAU,OAAW,QAAO,KAAK,GAAG;AAAA,QACrD,MAAK,GAAG,IAAI;AAAA,EACnB;AACA,SAAO;AACT;AAMO,SAAS,iBACd,QACA,SACoB;AACpB,QAAM,MAAM,UAAU,OAAO;AAC7B,MAAI,IAAI,WAAW,EAAG,QAAO,EAAE,GAAG,OAAA;AAClC,QAAM,OAA2B,EAAE,GAAG,OAAA;AACtC,QAAM,SAAS,IAAI,IAAI,GAAG;AAC1B,OAAK,aAAa,IAAI,UAAU,CAAC,GAAG,WAAW,OAAO,aAAa,CAAC,GAAG,GAAG,GAAG,CAAC;AAC9E,aAAW,OAAO,CAAC,gBAAgB,iBAAiB,GAAG;AACrD,QAAI,EAAE,OAAO,QAAS;AACtB,UAAM,OAAO,WAAW,OAAO,GAAG,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;AACnE,QAAI,KAAK,SAAS,EAAG,MAAK,GAAG,IAAI;AAAA,QAC5B,QAAO,KAAK,GAAG;AAAA,EACtB;AACA,SAAO;AACT;AAOO,SAAS,kBACd,QACA,SACoB;AACpB,QAAM,MAAM,UAAU,OAAO;AAC7B,MAAI,IAAI,WAAW,EAAG,QAAO,EAAE,GAAG,OAAA;AAClC,QAAM,OAA2B,EAAE,GAAG,OAAA;AACtC,QAAM,WAAW,IAAI,IAAI,GAAG;AAC5B,QAAM,WAAW,MAAM,QAAQ,OAAO,aAAa,CAAC;AACpD,QAAM,UAAU,WAAW,OAAO,aAAa,CAAC;AAChD,QAAM,UAAU,IAAI,IAAI,OAAO;AAC/B,MAAI,SAAU,MAAK,aAAa,IAAI,QAAQ,OAAO,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;AAC5E,QAAM,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC;AACpD,MAAI,SAAS,SAAS,GAAG;AACvB,SAAK,iBAAiB,IAAI,UAAU,CAAC,GAAG,WAAW,OAAO,iBAAiB,CAAC,GAAG,GAAG,QAAQ,CAAC;AAAA,EAC7F;AACA,SAAO;AACT;;;;"}

package/dist/agent-runtime/src/config-mutations.js

@@ -0,0 +1,59 @@
+const ENABLED_TOOLS = "enabled_tools";
+const EXCLUDED_TOOLS = "excluded_tools";
+const DECLINED_TOOLKITS = "declined_toolkit_ids";
+const PANEL_CONFIG = "panel_config";
+const stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+const uniqueIds = (ids) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const id of ids) {
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+};
+function applyConfigPatch(custom, patch) {
+  const next = { ...custom };
+  for (const [key, value] of Object.entries(patch)) {
+    if (key === PANEL_CONFIG) continue;
+    if (value === null || value === void 0) delete next[key];
+    else next[key] = value;
+  }
+  return next;
+}
+function applyToolsEnable(custom, toolIds) {
+  const ids = uniqueIds(toolIds);
+  if (ids.length === 0) return { ...custom };
+  const next = { ...custom };
+  const adding = new Set(ids);
+  next[ENABLED_TOOLS] = uniqueIds([...stringList(custom[ENABLED_TOOLS]), ...ids]);
+  for (const key of [EXCLUDED_TOOLS, DECLINED_TOOLKITS]) {
+    if (!(key in custom)) continue;
+    const kept = stringList(custom[key]).filter((id) => !adding.has(id));
+    if (kept.length > 0) next[key] = kept;
+    else delete next[key];
+  }
+  return next;
+}
+function applyToolsDisable(custom, toolIds) {
+  const ids = uniqueIds(toolIds);
+  if (ids.length === 0) return { ...custom };
+  const next = { ...custom };
+  const removing = new Set(ids);
+  const explicit = Array.isArray(custom[ENABLED_TOOLS]);
+  const enabled = stringList(custom[ENABLED_TOOLS]);
+  const present = new Set(enabled);
+  if (explicit) next[ENABLED_TOOLS] = enabled.filter((id) => !removing.has(id));
+  const declined = ids.filter((id) => !present.has(id));
+  if (declined.length > 0) {
+    next[DECLINED_TOOLKITS] = uniqueIds([...stringList(custom[DECLINED_TOOLKITS]), ...declined]);
+  }
+  return next;
+}
+export {
+  applyConfigPatch,
+  applyToolsDisable,
+  applyToolsEnable
+};
+//# sourceMappingURL=config-mutations.js.map