@dataverse-kit/agent-kit 0.2.0

package/README.md

@@ -0,0 +1,166 @@
+# @dataverse-kit/agent-kit
+
+Fluent UI **v9** conversational and agent surfaces for Dynamics 365 — styled as Dynamics CE,
+hostable in a custom page, a static web app, or a PCF control.
+
+> The kit is feature-complete for the four surface families — **grounding**, **action/approval
+> cards**, the **Teams-like shell** and **agent ops** (availability, agent picker, run history,
+> traces, usage) — over the base **conversation surface**. What remains is host proof and
+> retiring one of the existing chat implementations.
+
+```bash
+npm install @dataverse-kit/agent-kit @fluentui/react-components @fluentui/react-icons
+```
+
+```tsx
+import {
+  AgentKitHostProvider, MessageList, Composer, SystemNotice,
+  useConversation, MockAgentService,
+} from '@dataverse-kit/agent-kit';
+
+function Chat() {
+  const service = React.useMemo(() => new MockAgentService({ scenario: 'grounded' }), []);
+  const { state, announcement, busy, send, cancel } = useConversation({ service });
+  const [draft, setDraft] = React.useState('');
+
+  return (
+    <AgentKitHostProvider>
+      <MessageList
+        messages={state.messages}
+        announcement={announcement}
+        busy={busy}
+        onCopy={() => {}}
+      />
+      <SystemNotice failure={state.failure} />
+      <Composer
+        value={draft}
+        onChange={setDraft}
+        onSend={(text) => { setDraft(''); void send(text); }}
+        onStop={cancel}
+        busy={busy}
+      />
+    </AgentKitHostProvider>
+  );
+}
+```
+
+Swap `MockAgentService` for your own `IAgentService` and nothing else changes.
+
+## Entry points
+
+| Subpath | Contents | React? |
+|---|---|---|
+| `.` | everything | yes |
+| `./core` | grouping, day dividers, the stream reducer, transport normalizers, citation renumbering, scroll rules, the run-status ladder | **no** |
+| `./services` | `IAgentService`, `MockAgentService`, `NullAgentService`, the provider factory | **no** |
+| `./host` | `AgentKitHostProvider` — `IdPrefixProvider` ▸ `FluentProvider` ▸ `targetDocument` | yes |
+
+`./core` and `./services` are framework-agnostic *by gate*, not by convention, so a transport
+adapter can share them with an Azure Function, a web worker or a Node broker.
+
+## The seam
+
+The kit ships **no real transport**. It defines one interface and one fake:
+
+```ts
+interface IAgentService {
+  readonly name: string;
+  isAvailable(): Promise<AgentAvailability>;         // probed, never assumed; never throws
+  send(turn: AgentTurn): AsyncIterable<AgentEvent>;  // ordered; exactly one turn_end
+}
+```
+
+Four properties are deliberate and gated:
+
+- **No write method.** `send()` yields events and nothing else — the kit renders a tool *request*
+  and raises a callback; the host runs the tool.
+- **No `apiKey` field anywhere.** A browser control cannot keep a secret, so providers take an
+  endpoint and a server holds the credential.
+- **Failures are data.** Neither method throws; a transport failure arrives as a `turn_end`.
+- **Six terminal states, not two.** `succeeded | blocked | refused | error | notProvisioned |
+  cancelled`. `503 → notProvisioned`, because with on-demand Azure an absent service is a normal
+  state and reporting it as a failure makes the app look broken.
+
+`MockAgentService` can reach every one of them (plus mid-stream tool calls, citations, abort and a
+throwing transport), so Storybook can show each state and tests can assert it.
+
+## Hosting
+
+The kit renders no provider, so a host that already has one is not given a second. For hosts that
+do not, `AgentKitHostProvider` supplies the chain — and in a **PCF control** it is also where the
+tabster fix goes:
+
+```tsx
+<AgentKitHostProvider
+  hostTheme={context.fluentDesignLanguage?.tokenTheme}
+  targetDocument={createIsolatedTargetDocument(document)}
+/>
+```
+
+Fluent v9's tabster is a per-window singleton; a Dynamics form's copy predates the `attrHandlers`
+API, so a bundled control that reaches it throws and unmounts. Passing an isolated
+`targetDocument` gives the control its own tabster core, and every child inherits it. See
+`CLAUDE.md` for the measured hook-level detail.
+
+## Agent ops
+
+`AgentOpsPanel` composes availability, the agent picker and run history. The run ladder has six
+states, each with its own words — a content filter, the model declining, an unconfigured
+environment and a user-cancelled run need different reactions, and `AgentStatusBadge` never
+collapses them into one label or into a colour. `UsageMeter` distinguishes "not reported" from
+zero. `RunHistoryPanel` takes a `grid` slot so a host that already has `grid-kit/v9` passes it in
+rather than getting a second, worse grid.
+
+## The shell
+
+`AgentAppShell` is the Teams-like frame — rail │ conversation list │ thread │ detail pane —
+composed from `AppRail`, `ConversationList`, `ConversationHeader` and `RightPane`. It measures its
+**container**, not the viewport, because a PCF control or custom page occupies a pane; pass
+`containerWidth` (a PCF's `context.allocatedWidth`) to skip measurement entirely. Breakpoints come
+from `@dataverse-kit/surface-kit/v9` rather than being redeclared.
+
+The conversation list is a **listbox**: one tab stop, Up/Down/Home/End, `aria-selected`, and unread
+count and presence carried in each row's accessible name rather than only in a badge and a colour.
+
+## Grounding, and why the citation list is short
+
+`CitationList` shows only the sources the answer actually cites — a retriever commonly returns a
+dozen chunks for a two-citation answer, and listing all twelve implies provenance the answer does
+not have. `SourceCard` distinguishes "relevance not reported" from a score of zero.
+`ProviderAttribution` changes its visible wording when a provider **withheld** its answer, so a
+substituted safe response is never attributed to the model as if it were the model's words.
+`GroundingPanel` renders the same object the turn carried, so what the model was told and what the
+screen shows cannot drift.
+
+## Action cards — the kit never runs the tool
+
+`ApprovalCard` renders a tool *request* and raises `onApprove` / `onDeny`; the host executes and
+feeds the outcome back as a `tool_result` event. The card cannot double-submit, and `ConfirmInline`
+— the in-tree replacement for Fluent's `Dialog` — traps focus, returns it to the trigger on close
+and declares `aria-modal`, three things the gallery precedent it is modelled on does not do.
+
+## Accessibility
+
+The conversation surface is built to a stated contract, each rule with a test behind it:
+
+- The transcript is **not** a live region. One polite region announces the settled answer, on a
+  state transition — never per token, which would make a screen reader re-read the growing
+  string and never finish. Failures go to an assertive region.
+- Every message names its author in the accessible tree, **including grouped continuations**
+  where the name is visually suppressed.
+- Hover actions are revealed on hover **or focus**, as a `role="toolbar"` with a roving
+  tabindex — one tab stop per message, not one per action.
+- Focus is restored when a focused node is removed, and a streaming answer keeps a stable
+  element identity so focus survives it.
+
+`axe` runs over every component, but it is a floor: measured, it has no rule for an unlabelled
+toolbar and does not report a dangling `aria-controls`. The hand-rolled ARIA is pinned by explicit
+structural and keyboard tests instead. See `CLAUDE.md`.
+
+## Theming
+
+`createAgentTheme()` builds on the shared `@dataverse-kit/fluent-theme` ramp (the same Dynamics
+blue grid-kit/v9 and surface-kit/v9 use) and adds the CE font stack and corner radius.
+`resolveHostTheme()` is the precedence ladder: explicit theme → host theme → Dynamics light/dark.
+The fallback is the **Dynamics** theme, not stock Fluent — a standalone SWA has no host theme, and
+stock Fluent does not read as CE.

package/dist/core.cjs

@@ -0,0 +1,532 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  ANNOUNCE_FULL_TEXT_MAX_CHARS: () => ANNOUNCE_FULL_TEXT_MAX_CHARS,
+  DEFAULT_GROUP_WINDOW_MS: () => DEFAULT_GROUP_WINDOW_MS,
+  NO_ANNOUNCEMENT: () => NO_ANNOUNCEMENT,
+  STICK_TO_BOTTOM_THRESHOLD_PX: () => STICK_TO_BOTTOM_THRESHOLD_PX,
+  appendUserMessage: () => appendUserMessage,
+  applyAgentEvent: () => applyAgentEvent,
+  bucketByDay: () => bucketByDay,
+  classifyTransportFailure: () => classifyTransportFailure,
+  createIdPrefixCounter: () => createIdPrefixCounter,
+  dayKeyOf: () => dayKeyOf,
+  deriveAnnouncement: () => deriveAnnouncement,
+  extractCitationMarkers: () => extractCitationMarkers,
+  fromClaudeStreamEvent: () => fromClaudeStreamEvent,
+  fromFoundryChatResult: () => fromFoundryChatResult,
+  fromOpenAiChatChunk: () => fromOpenAiChatChunk,
+  fromSseLine: () => fromSseLine,
+  groupMessages: () => groupMessages,
+  initialConversation: () => initialConversation,
+  isSameAuthorRun: () => isSameAuthorRun,
+  isTerminalStatus: () => isTerminalStatus,
+  renumberCitations: () => renumberCitations,
+  runStatusSeverity: () => runStatusSeverity,
+  shouldStickToBottom: () => shouldStickToBottom,
+  splitTextByCitations: () => splitTextByCitations
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/core/runStatus.ts
+var TERMINAL = /* @__PURE__ */ new Set([
+  "succeeded",
+  "blocked",
+  "refused",
+  "error",
+  "notProvisioned",
+  "cancelled"
+]);
+function isTerminalStatus(status) {
+  return TERMINAL.has(status);
+}
+function runStatusSeverity(status) {
+  switch (status) {
+    case "succeeded":
+      return "success";
+    case "blocked":
+    case "refused":
+      return "warning";
+    case "error":
+      return "error";
+    case "notProvisioned":
+    case "cancelled":
+      return "info";
+  }
+}
+function classifyTransportFailure(input) {
+  const { httpStatus, code, retryAfterMs } = input;
+  const message = input.message ?? "The agent could not be reached.";
+  if (httpStatus === 503) {
+    return {
+      status: "notProvisioned",
+      message,
+      code: code ?? "not_provisioned",
+      recoverable: false,
+      correlationId: void 0
+    };
+  }
+  if (httpStatus === 429) {
+    return { status: "error", message, code: code ?? "rate_limited", recoverable: true, retryAfterMs };
+  }
+  if (code === "content_filter") {
+    return { status: "blocked", message, code, recoverable: false };
+  }
+  return { status: "error", message, code, recoverable: httpStatus !== void 0 && httpStatus >= 500 };
+}
+
+// src/core/grouping.ts
+var DEFAULT_GROUP_WINDOW_MS = 5 * 60 * 1e3;
+function dayKey(epochMs, timeZone) {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(new Date(epochMs));
+}
+function isSameAuthorRun(a, b, windowMs = DEFAULT_GROUP_WINDOW_MS, timeZone) {
+  if (a.authorId !== b.authorId) return false;
+  if (a.role !== b.role) return false;
+  if (a.role === "system" || b.role === "system") return false;
+  if (b.createdAt < a.createdAt) return false;
+  if (b.createdAt - a.createdAt > windowMs) return false;
+  return dayKey(a.createdAt, timeZone) === dayKey(b.createdAt, timeZone);
+}
+function groupMessages(messages, options = {}) {
+  const windowMs = options.windowMs ?? DEFAULT_GROUP_WINDOW_MS;
+  const groups = [];
+  for (const message of messages) {
+    const current = groups[groups.length - 1];
+    const previousId = current?.messageIds[current.messageIds.length - 1];
+    const previous = previousId ? messages.find((m) => m.id === previousId) : void 0;
+    if (current && previous && isSameAuthorRun(previous, message, windowMs, options.timeZone)) {
+      current.messageIds.push(message.id);
+      continue;
+    }
+    groups.push({
+      key: `${message.authorId}:${message.id}`,
+      authorId: message.authorId,
+      role: message.role,
+      startedAt: message.createdAt,
+      messageIds: [message.id]
+    });
+  }
+  return groups;
+}
+
+// src/core/dayDividers.ts
+function dayKeyOf(epochMs, timeZone) {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(new Date(epochMs));
+}
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function labelFor(dayKey2, nowMs, timeZone) {
+  const todayKey = dayKeyOf(nowMs, timeZone);
+  if (dayKey2 === todayKey) return { kind: "today" };
+  if (dayKey2 === dayKeyOf(nowMs - DAY_MS, timeZone)) return { kind: "yesterday" };
+  const asDate = /* @__PURE__ */ new Date(`${dayKey2}T00:00:00Z`);
+  for (let back = 2; back <= 6; back++) {
+    if (dayKey2 === dayKeyOf(nowMs - back * DAY_MS, timeZone)) {
+      return { kind: "weekday", weekday: asDate.getUTCDay(), iso: dayKey2 };
+    }
+  }
+  return { kind: "date", iso: dayKey2 };
+}
+function bucketByDay(messages, options = {}) {
+  const nowMs = options.now ?? Date.now();
+  const buckets = [];
+  for (const message of messages) {
+    const key = dayKeyOf(message.createdAt, options.timeZone);
+    const current = buckets[buckets.length - 1];
+    if (current && current.dayKey === key) {
+      current.messageIds.push(message.id);
+      continue;
+    }
+    buckets.push({
+      dayKey: key,
+      label: labelFor(key, nowMs, options.timeZone),
+      messageIds: [message.id]
+    });
+  }
+  return buckets;
+}
+
+// src/core/citations.ts
+var BRACKET_MARKER = /\[(\d{1,3})\]/g;
+var AOAI_MARKER = /【(\d{1,3}):\d+†[^】]*】/g;
+function extractCitationMarkers(text) {
+  const found = [];
+  for (const re of [BRACKET_MARKER, AOAI_MARKER]) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      found.push({ marker: m[1], index: m.index, length: m[0].length });
+    }
+  }
+  return found.sort((a, b) => a.index - b.index);
+}
+function renumberCitations(text, sources) {
+  const markers = extractCitationMarkers(text);
+  const order = [];
+  for (const { marker } of markers) if (!order.includes(marker)) order.push(marker);
+  const byOriginal = /* @__PURE__ */ new Map();
+  order.forEach((marker, i) => byOriginal.set(marker, i + 1));
+  const used = [];
+  const citations = [];
+  for (const marker of order) {
+    const source = sources[Number(marker) - 1];
+    if (!source) continue;
+    used.push(source);
+    citations.push({ marker: String(byOriginal.get(marker)), sourceId: source.id });
+  }
+  let out = "";
+  let cursor = 0;
+  for (const { marker, index, length } of markers) {
+    out += text.slice(cursor, index);
+    const renumbered = byOriginal.get(marker);
+    out += renumbered === void 0 ? "" : `[${renumbered}]`;
+    cursor = index + length;
+  }
+  out += text.slice(cursor);
+  return { text: out, used, citations };
+}
+function splitTextByCitations(text, citations) {
+  const markers = extractCitationMarkers(text);
+  if (markers.length === 0) return text ? [{ kind: "text", text }] : [];
+  const segments = [];
+  let cursor = 0;
+  for (const { marker, index, length } of markers) {
+    if (index > cursor) segments.push({ kind: "text", text: text.slice(cursor, index) });
+    const citation = citations.find((c) => c.marker === marker);
+    segments.push({
+      kind: "citation",
+      text: `[${marker}]`,
+      marker,
+      sourceId: citation?.sourceId
+    });
+    cursor = index + length;
+  }
+  if (cursor < text.length) segments.push({ kind: "text", text: text.slice(cursor) });
+  return segments;
+}
+
+// src/core/conversationReducer.ts
+function initialConversation(seed = []) {
+  return { messages: [...seed], streamingMessageId: null, status: "idle" };
+}
+function patch(state, messageId, update) {
+  const i = state.messages.findIndex((m) => m.id === messageId);
+  if (i === -1) return state.messages;
+  const next = state.messages.slice();
+  next[i] = update(next[i]);
+  return next;
+}
+function appendUserMessage(state, input) {
+  const message = {
+    id: input.id,
+    role: "user",
+    authorId: input.authorId ?? "user",
+    text: input.text,
+    createdAt: input.now ?? Date.now(),
+    attachments: input.attachments
+  };
+  return { ...state, messages: [...state.messages, message], status: "connecting", failure: void 0 };
+}
+function applyAgentEvent(state, event) {
+  switch (event.type) {
+    case "turn_start": {
+      const message = {
+        id: event.messageId,
+        role: "assistant",
+        authorId: event.provider ?? "agent",
+        text: "",
+        createdAt: Date.now(),
+        streaming: true,
+        provider: event.provider
+      };
+      return {
+        ...state,
+        messages: [...state.messages, message],
+        streamingMessageId: event.messageId,
+        status: "streaming",
+        statusLabel: void 0,
+        failure: void 0,
+        suggestions: void 0
+      };
+    }
+    case "text_delta":
+      return {
+        ...state,
+        messages: patch(state, event.messageId, (m) => ({ ...m, text: m.text + event.text }))
+      };
+    case "thinking_delta":
+      return {
+        ...state,
+        messages: patch(state, event.messageId, (m) => ({
+          ...m,
+          thinking: (m.thinking ?? "") + event.text
+        }))
+      };
+    case "tool_call":
+      return {
+        ...state,
+        messages: patch(state, event.messageId, (m) => ({
+          ...m,
+          toolCalls: [...m.toolCalls ?? [], event.call]
+        }))
+      };
+    case "tool_result":
+      return {
+        ...state,
+        messages: patch(state, event.messageId, (m) => ({
+          ...m,
+          toolCalls: (m.toolCalls ?? []).map(
+            (c) => c.id === event.callId ? { ...c, status: event.status, resultText: event.resultText, failure: event.failure } : c
+          )
+        }))
+      };
+    case "sources":
+      return {
+        ...state,
+        messages: patch(state, event.messageId, (m) => ({ ...m, sources: event.sources }))
+      };
+    case "citation":
+      return {
+        ...state,
+        messages: patch(state, event.messageId, (m) => ({
+          ...m,
+          citations: [...m.citations ?? [], event.citation]
+        }))
+      };
+    case "suggestions":
+      return { ...state, suggestions: event.prompts };
+    case "status":
+      return { ...state, statusLabel: event.label };
+    case "turn_end": {
+      const { result } = event;
+      return {
+        ...state,
+        messages: patch(state, event.messageId, (m) => ({
+          ...m,
+          // A non-streaming provider sends no deltas, so the assembled text arrives here.
+          text: m.text.length > 0 ? m.text : result.text,
+          streaming: false,
+          guarded: result.guarded,
+          provider: result.provider,
+          usage: result.usage,
+          failure: result.failure
+        })),
+        streamingMessageId: null,
+        status: result.status,
+        statusLabel: void 0,
+        failure: result.failure,
+        usage: result.usage
+      };
+    }
+  }
+}
+
+// src/core/normalize.ts
+function fromSseLine(line) {
+  const trimmed = line.trim();
+  if (trimmed === "" || trimmed.startsWith(":")) return void 0;
+  if (!trimmed.startsWith("data:")) return void 0;
+  const payload = trimmed.slice("data:".length).trim();
+  if (payload === "") return void 0;
+  if (payload === "[DONE]") return "[DONE]";
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return void 0;
+  }
+}
+function fromOpenAiChatChunk(chunk, ctx) {
+  const events = [];
+  const delta = chunk?.choices?.[0]?.delta;
+  if (!delta) return events;
+  if (typeof delta.content === "string" && delta.content.length > 0) {
+    events.push({ type: "text_delta", messageId: ctx.messageId, text: delta.content });
+  }
+  for (const call of delta.tool_calls ?? []) {
+    if (!call.id) continue;
+    const toolCall = {
+      id: call.id,
+      name: call.function?.name ?? "",
+      argumentsJson: call.function?.arguments ?? "",
+      status: "proposed"
+    };
+    events.push({ type: "tool_call", messageId: ctx.messageId, call: toolCall });
+  }
+  return events;
+}
+function fromClaudeStreamEvent(event, ctx) {
+  switch (event.type) {
+    case "init":
+      return [
+        {
+          type: "turn_start",
+          turnId: ctx.turnId,
+          messageId: ctx.messageId,
+          model: event.model,
+          provider: "claude-bridge",
+          sessionId: event.sessionId
+        }
+      ];
+    case "text_delta":
+      return event.text ? [{ type: "text_delta", messageId: ctx.messageId, text: event.text }] : [];
+    case "thinking_delta":
+      return event.text ? [{ type: "thinking_delta", messageId: ctx.messageId, text: event.text }] : [];
+    case "done":
+      return [
+        {
+          type: "turn_end",
+          turnId: ctx.turnId,
+          messageId: ctx.messageId,
+          result: {
+            status: "succeeded",
+            text: event.fullText ?? "",
+            provider: "claude-bridge",
+            model: event.model,
+            usage: {
+              inputTokens: event.inputTokens,
+              outputTokens: event.outputTokens,
+              cachedTokens: event.cacheReadTokens,
+              costUsd: event.costUsd,
+              durationMs: event.durationMs,
+              model: event.model
+            }
+          }
+        }
+      ];
+    case "error":
+      return [
+        {
+          type: "turn_end",
+          turnId: ctx.turnId,
+          messageId: ctx.messageId,
+          result: {
+            status: "error",
+            text: "",
+            provider: "claude-bridge",
+            failure: {
+              status: "error",
+              message: event.message ?? "The agent failed.",
+              recoverable: event.recoverable ?? false
+            }
+          }
+        }
+      ];
+  }
+}
+function fromFoundryChatResult(result, ctx, provider = "foundry") {
+  return [
+    { type: "turn_start", turnId: ctx.turnId, messageId: ctx.messageId, model: result.model, provider },
+    {
+      type: "turn_end",
+      turnId: ctx.turnId,
+      messageId: ctx.messageId,
+      result: {
+        status: "succeeded",
+        text: result.text,
+        provider,
+        model: result.model,
+        usage: {
+          inputTokens: result.promptTokens,
+          outputTokens: result.completionTokens,
+          model: result.model
+        }
+      }
+    }
+  ];
+}
+
+// src/core/announce.ts
+var ANNOUNCE_FULL_TEXT_MAX_CHARS = 240;
+var NO_ANNOUNCEMENT = { polite: "", assertive: "" };
+var TERMINAL2 = /* @__PURE__ */ new Set(["succeeded", "blocked", "refused", "error", "notProvisioned", "cancelled"]);
+function deriveAnnouncement(state, previous) {
+  const wasTerminal = previous ? TERMINAL2.has(previous.status) : false;
+  const isTerminal = TERMINAL2.has(state.status);
+  if (!isTerminal || wasTerminal) return NO_ANNOUNCEMENT;
+  if (state.failure) {
+    return { polite: "", assertive: state.failure.message };
+  }
+  const last = state.messages[state.messages.length - 1];
+  const text = last?.text ?? "";
+  if (!text) return NO_ANNOUNCEMENT;
+  const guarded = last?.guarded ? "The response was withheld. " : "";
+  if (text.length <= ANNOUNCE_FULL_TEXT_MAX_CHARS) {
+    return { polite: `${guarded}${text}`, assertive: "" };
+  }
+  const words = text.trim().split(/\s+/).length;
+  return {
+    polite: `${guarded}Response complete, ${words} words.`,
+    assertive: ""
+  };
+}
+
+// src/core/scroll.ts
+var STICK_TO_BOTTOM_THRESHOLD_PX = 32;
+function shouldStickToBottom(geometry, thresholdPx = STICK_TO_BOTTOM_THRESHOLD_PX) {
+  const { scrollTop, scrollHeight, clientHeight } = geometry;
+  const distanceFromBottom = scrollHeight - scrollTop - clientHeight;
+  return distanceFromBottom <= thresholdPx;
+}
+
+// src/core/ids.ts
+function createIdPrefixCounter(tag) {
+  let n = 0;
+  return () => `${tag}${++n}-`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANNOUNCE_FULL_TEXT_MAX_CHARS,
+  DEFAULT_GROUP_WINDOW_MS,
+  NO_ANNOUNCEMENT,
+  STICK_TO_BOTTOM_THRESHOLD_PX,
+  appendUserMessage,
+  applyAgentEvent,
+  bucketByDay,
+  classifyTransportFailure,
+  createIdPrefixCounter,
+  dayKeyOf,
+  deriveAnnouncement,
+  extractCitationMarkers,
+  fromClaudeStreamEvent,
+  fromFoundryChatResult,
+  fromOpenAiChatChunk,
+  fromSseLine,
+  groupMessages,
+  initialConversation,
+  isSameAuthorRun,
+  isTerminalStatus,
+  renumberCitations,
+  runStatusSeverity,
+  shouldStickToBottom,
+  splitTextByCitations
+});
+//# sourceMappingURL=core.cjs.map