@dataverse-kit/agent-kit 0.2.0

package/dist/index.mjs

@@ -0,0 +1,3068 @@
+// src/conversation/MessageList.tsx
+import * as React10 from "react";
+import { Button as Button3, makeStyles as makeStyles10, tokens as tokens9 } from "@fluentui/react-components";
+import { ArrowDownRegular } from "@fluentui/react-icons";
+
+// 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}-`;
+}
+
+// src/a11y/LiveAnnouncer.tsx
+import * as React from "react";
+
+// src/a11y/visuallyHidden.ts
+import { makeStyles } from "@fluentui/react-components";
+var useVisuallyHiddenStyles = makeStyles({
+  root: {
+    position: "absolute",
+    width: "1px",
+    height: "1px",
+    margin: "-1px",
+    padding: "0",
+    overflow: "hidden",
+    clip: "rect(0 0 0 0)",
+    clipPath: "inset(50%)",
+    whiteSpace: "nowrap"
+  }
+});
+
+// src/a11y/LiveAnnouncer.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function useAnnounceWithRepeat(next, set) {
+  React.useEffect(() => {
+    if (!next) return;
+    let cancelled = false;
+    set("");
+    const id = setTimeout(() => {
+      if (!cancelled) set(next);
+    }, 0);
+    return () => {
+      cancelled = true;
+      clearTimeout(id);
+    };
+  }, [next, set]);
+}
+function LiveAnnouncer({
+  polite = "",
+  assertive = ""
+}) {
+  const styles = useVisuallyHiddenStyles();
+  const [politeText, setPoliteText] = React.useState("");
+  const [assertiveText, setAssertiveText] = React.useState("");
+  useAnnounceWithRepeat(polite, setPoliteText);
+  useAnnounceWithRepeat(assertive, setAssertiveText);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: styles.root,
+        "aria-live": "polite",
+        "aria-atomic": "true",
+        "data-testid": "agentkit-live-polite",
+        children: politeText
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: styles.root,
+        role: "alert",
+        "aria-live": "assertive",
+        "aria-atomic": "true",
+        "data-testid": "agentkit-live-assertive",
+        children: assertiveText
+      }
+    )
+  ] });
+}
+
+// src/a11y/useFocusRestore.ts
+import * as React2 from "react";
+function useFocusRestore(containerRef) {
+  return React2.useCallback(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const doc = container.ownerDocument;
+    if (doc.activeElement && doc.activeElement !== doc.body) return;
+    const focusable = container.querySelector(
+      'a[href],button:not([disabled]),input:not([disabled]),textarea:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex="-1"])'
+    );
+    (focusable ?? container).focus();
+  }, [containerRef]);
+}
+
+// src/a11y/useRovingTabindex.ts
+import * as React3 from "react";
+function useRovingTabindex(options) {
+  const { orientation = "horizontal", loop = true, itemCount, onActivate } = options;
+  const [activeIndex, setActiveIndex] = React3.useState(0);
+  const clamp = React3.useCallback(
+    (index) => {
+      if (itemCount === 0) return 0;
+      return loop ? (index + itemCount) % itemCount : Math.min(Math.max(index, 0), itemCount - 1);
+    },
+    [itemCount, loop]
+  );
+  const getItemProps = React3.useCallback(
+    (index) => ({
+      tabIndex: index === activeIndex ? 0 : -1,
+      "data-roving-item": true,
+      onFocus: () => setActiveIndex(index),
+      onKeyDown: (event) => {
+        const prevKey = orientation === "horizontal" ? "ArrowLeft" : "ArrowUp";
+        const nextKey = orientation === "horizontal" ? "ArrowRight" : "ArrowDown";
+        let target = null;
+        if (event.key === nextKey) target = clamp(index + 1);
+        else if (event.key === prevKey) target = clamp(index - 1);
+        else if (event.key === "Home") target = 0;
+        else if (event.key === "End") target = itemCount - 1;
+        else if (event.key === "Enter" || event.key === " ") {
+          onActivate?.(index);
+          return;
+        }
+        if (target === null) return;
+        event.preventDefault();
+        event.stopPropagation();
+        setActiveIndex(target);
+        const group = event.currentTarget.parentElement;
+        group?.querySelectorAll("[data-roving-item]")[target]?.focus();
+      }
+    }),
+    [activeIndex, clamp, itemCount, onActivate, orientation]
+  );
+  return { activeIndex, setActiveIndex, getItemProps };
+}
+
+// src/hooks/useStickyScroll.ts
+import * as React4 from "react";
+function useStickyScroll(ref, messageCount) {
+  const wasPinnedRef = React4.useRef(true);
+  const [isPinned, setIsPinned] = React4.useState(true);
+  const onScroll = React4.useCallback(() => {
+    const el = ref.current;
+    if (!el) return;
+    const pinned = shouldStickToBottom({
+      scrollTop: el.scrollTop,
+      scrollHeight: el.scrollHeight,
+      clientHeight: el.clientHeight
+    });
+    wasPinnedRef.current = pinned;
+    setIsPinned(pinned);
+  }, [ref]);
+  const scrollToBottom = React4.useCallback(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.scrollTo({ top: el.scrollHeight, behavior: "auto" });
+    wasPinnedRef.current = true;
+    setIsPinned(true);
+  }, [ref]);
+  React4.useEffect(() => {
+    if (!wasPinnedRef.current) return;
+    const el = ref.current;
+    if (!el) return;
+    el.scrollTo({ top: el.scrollHeight, behavior: "auto" });
+  }, [messageCount, ref]);
+  return { onScroll, scrollToBottom, isPinned };
+}
+
+// src/hooks/useConversation.ts
+import * as React5 from "react";
+var fallbackId = 0;
+function useConversation(options) {
+  const { service, seed, grounding, conversationId, createId } = options;
+  const [state, setState] = React5.useState(() => initialConversation(seed));
+  const [announcement, setAnnouncement] = React5.useState(NO_ANNOUNCEMENT);
+  const abortRef = React5.useRef(null);
+  const stateRef = React5.useRef(state);
+  stateRef.current = state;
+  const nextId = React5.useCallback(
+    () => createId?.() ?? `m${++fallbackId}-${Date.now().toString(36)}`,
+    [createId]
+  );
+  const commit = React5.useCallback((next) => {
+    const previous = stateRef.current;
+    stateRef.current = next;
+    setState(next);
+    const derived = deriveAnnouncement(next, previous);
+    if (derived.polite || derived.assertive) setAnnouncement(derived);
+  }, []);
+  const cancel = React5.useCallback(() => {
+    abortRef.current?.abort();
+  }, []);
+  const send = React5.useCallback(
+    async (text, attachments) => {
+      if (!text.trim()) return;
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      let next = appendUserMessage(stateRef.current, { id: nextId(), text, attachments });
+      commit(next);
+      try {
+        for await (const event of service.send({
+          text,
+          history: next.messages,
+          grounding,
+          attachments,
+          conversationId,
+          cancelSignal: controller.signal
+        })) {
+          next = applyAgentEvent(next, event);
+          commit(next);
+        }
+      } catch (error) {
+        commit({
+          ...next,
+          streamingMessageId: null,
+          status: "error",
+          failure: {
+            status: "error",
+            message: error instanceof Error ? error.message : String(error),
+            recoverable: true
+          }
+        });
+      } finally {
+        if (abortRef.current === controller) abortRef.current = null;
+      }
+    },
+    [service, grounding, conversationId, nextId, commit]
+  );
+  React5.useEffect(() => () => abortRef.current?.abort(), []);
+  const busy = state.status === "connecting" || state.status === "streaming";
+  return { state, announcement, busy, send, cancel };
+}
+
+// src/conversation/MessageBubble.tsx
+import * as React9 from "react";
+import { Avatar, makeStyles as makeStyles7, mergeClasses as mergeClasses4, tokens as tokens6 } from "@fluentui/react-components";
+
+// src/conversation/StreamingText.tsx
+import { makeStyles as makeStyles2, tokens } from "@fluentui/react-components";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var useStyles = makeStyles2({
+  root: { whiteSpace: "pre-wrap", wordBreak: "break-word" },
+  caret: {
+    display: "inline-block",
+    width: "2px",
+    height: "1em",
+    marginLeft: "2px",
+    verticalAlign: "text-bottom",
+    backgroundColor: tokens.colorBrandForeground1,
+    animationName: { "0%,49%": { opacity: 1 }, "50%,100%": { opacity: 0 } },
+    animationDuration: "1s",
+    animationIterationCount: "infinite",
+    // WCAG 2.2.2: a blinking caret is motion, and some readers cannot tolerate it.
+    "@media (prefers-reduced-motion: reduce)": { animationName: "none", opacity: 1 }
+  }
+});
+function StreamingText({ text, streaming }) {
+  const styles = useStyles();
+  return /* @__PURE__ */ jsxs2("span", { className: styles.root, "data-testid": "agentkit-streaming-text", children: [
+    text,
+    streaming ? /* @__PURE__ */ jsx2("span", { className: styles.caret, "aria-hidden": "true" }) : null
+  ] });
+}
+
+// src/conversation/MessageActions.tsx
+import { CopyRegular, ArrowClockwiseRegular, ThumbLikeRegular, ThumbDislikeRegular } from "@fluentui/react-icons";
+
+// src/internal/ActionToolbar.tsx
+import { Button, Tooltip, makeStyles as makeStyles3, tokens as tokens2, mergeClasses } from "@fluentui/react-components";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var useStyles2 = makeStyles3({
+  root: {
+    display: "inline-flex",
+    gap: tokens2.spacingHorizontalXXS,
+    alignItems: "center",
+    backgroundColor: tokens2.colorNeutralBackground1,
+    borderRadius: tokens2.borderRadiusMedium,
+    boxShadow: tokens2.shadow4,
+    padding: tokens2.spacingHorizontalXXS
+  },
+  button: {
+    // ★ A focus ring that survives Windows forced-colors. Once the kit owns its own focus
+    //   management it owns the indicator too, and `outline: none` + box-shadow — the usual
+    //   custom-focus recipe — disappears entirely under forced-colors.
+    ":focus-visible": {
+      outline: `2px solid ${tokens2.colorStrokeFocus2}`,
+      outlineOffset: "1px"
+    }
+  }
+});
+function ActionToolbar({ actions, label, className }) {
+  const styles = useStyles2();
+  const roving = useRovingTabindex({ itemCount: actions.length, orientation: "horizontal" });
+  return /* @__PURE__ */ jsx3("div", { role: "toolbar", "aria-label": label, "aria-orientation": "horizontal", className: mergeClasses(styles.root, className), children: actions.map((action, index) => {
+    const item = roving.getItemProps(index);
+    return /* @__PURE__ */ jsx3(Tooltip, { content: action.label, relationship: "label", withArrow: true, children: /* @__PURE__ */ jsx3(
+      Button,
+      {
+        appearance: "subtle",
+        size: "small",
+        icon: action.icon,
+        disabled: action.disabled,
+        onClick: action.onClick,
+        className: styles.button,
+        ...item
+      }
+    ) }, action.key);
+  }) });
+}
+
+// src/internal/CardSurface.tsx
+import * as React6 from "react";
+import { makeStyles as makeStyles4, mergeClasses as mergeClasses2, tokens as tokens3 } from "@fluentui/react-components";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var useStyles3 = makeStyles4({
+  root: {
+    display: "flex",
+    flexDirection: "column",
+    gap: tokens3.spacingVerticalXS,
+    padding: tokens3.spacingVerticalM,
+    borderRadius: tokens3.borderRadiusMedium,
+    backgroundColor: tokens3.colorNeutralBackground1,
+    border: `1px solid ${tokens3.colorNeutralStroke2}`,
+    boxShadow: tokens3.shadow2
+  },
+  attention: { borderLeft: `3px solid ${tokens3.colorBrandStroke1}` }
+});
+var CardSurface = React6.forwardRef(
+  function CardSurface2({ emphasis = "none", className, children, ...rest }, ref) {
+    const styles = useStyles3();
+    return /* @__PURE__ */ jsx4(
+      "div",
+      {
+        ref,
+        className: mergeClasses2(styles.root, emphasis === "attention" && styles.attention, className),
+        ...rest,
+        children
+      }
+    );
+  }
+);
+
+// src/internal/ConfirmInline.tsx
+import * as React7 from "react";
+import { Button as Button2, makeStyles as makeStyles5, tokens as tokens4, Text } from "@fluentui/react-components";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var useStyles4 = makeStyles5({
+  root: { maxWidth: "420px" },
+  actions: { display: "flex", gap: tokens4.spacingHorizontalS, justifyContent: "flex-end", marginTop: tokens4.spacingVerticalS }
+});
+var FOCUSABLE = 'a[href],button:not([disabled]),input:not([disabled]),textarea:not([disabled]),select:not([disabled]),[tabindex]:not([tabindex="-1"])';
+function ConfirmInline(props) {
+  const { open, title, body, confirmLabel = "Confirm", cancelLabel = "Cancel", destructive, onConfirm, onCancel } = props;
+  const styles = useStyles4();
+  const ref = React7.useRef(null);
+  const returnTo = React7.useRef(null);
+  const titleId = React7.useId();
+  const bodyId = React7.useId();
+  React7.useEffect(() => {
+    if (!open) return;
+    returnTo.current = document.activeElement ?? null;
+    const first = ref.current?.querySelector(FOCUSABLE);
+    first?.focus();
+    return () => {
+      const target = returnTo.current;
+      if (target && target.isConnected) target.focus();
+    };
+  }, [open]);
+  if (!open) return null;
+  const onKeyDown = (event) => {
+    if (event.key === "Escape") {
+      event.stopPropagation();
+      onCancel();
+      return;
+    }
+    if (event.key !== "Tab") return;
+    const items = [...ref.current?.querySelectorAll(FOCUSABLE) ?? []];
+    if (items.length === 0) return;
+    const first = items[0];
+    const last = items[items.length - 1];
+    const active = document.activeElement;
+    if (event.shiftKey && active === first) {
+      event.preventDefault();
+      last.focus();
+    } else if (!event.shiftKey && active === last) {
+      event.preventDefault();
+      first.focus();
+    }
+  };
+  return /* @__PURE__ */ jsxs3(
+    CardSurface,
+    {
+      ref,
+      role: "alertdialog",
+      "aria-modal": "true",
+      "aria-labelledby": titleId,
+      "aria-describedby": bodyId,
+      onKeyDown,
+      className: styles.root,
+      emphasis: "attention",
+      children: [
+        /* @__PURE__ */ jsx5(Text, { id: titleId, weight: "semibold", children: title }),
+        /* @__PURE__ */ jsx5(Text, { id: bodyId, size: 200, children: body }),
+        /* @__PURE__ */ jsxs3("div", { className: styles.actions, children: [
+          /* @__PURE__ */ jsx5(Button2, { size: "small", onClick: onCancel, children: cancelLabel }),
+          /* @__PURE__ */ jsx5(Button2, { size: "small", appearance: destructive ? "primary" : "primary", onClick: onConfirm, children: confirmLabel })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/internal/Disclosure.tsx
+import * as React8 from "react";
+import { makeStyles as makeStyles6, tokens as tokens5, mergeClasses as mergeClasses3 } from "@fluentui/react-components";
+import { ChevronRightRegular, ChevronDownRegular } from "@fluentui/react-icons";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var useStyles5 = makeStyles6({
+  trigger: {
+    display: "flex",
+    alignItems: "center",
+    gap: tokens5.spacingHorizontalXS,
+    background: "none",
+    border: "none",
+    cursor: "pointer",
+    padding: `${tokens5.spacingVerticalXXS} 0`,
+    color: tokens5.colorNeutralForeground2,
+    font: "inherit",
+    fontSize: tokens5.fontSizeBase200,
+    ":focus-visible": { outline: `2px solid ${tokens5.colorStrokeFocus2}`, outlineOffset: "1px" }
+  },
+  panel: { paddingTop: tokens5.spacingVerticalXS }
+});
+function Disclosure({
+  id,
+  summary,
+  children,
+  defaultOpen = false,
+  className
+}) {
+  const styles = useStyles5();
+  const [open, setOpen] = React8.useState(defaultOpen);
+  const panelId = `${id}-panel`;
+  return /* @__PURE__ */ jsxs4("div", { className, children: [
+    /* @__PURE__ */ jsxs4(
+      "button",
+      {
+        type: "button",
+        id,
+        className: styles.trigger,
+        "aria-expanded": open,
+        "aria-controls": panelId,
+        onClick: () => setOpen((v) => !v),
+        children: [
+          open ? /* @__PURE__ */ jsx6(ChevronDownRegular, {}) : /* @__PURE__ */ jsx6(ChevronRightRegular, {}),
+          summary
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      "div",
+      {
+        id: panelId,
+        role: "region",
+        "aria-labelledby": id,
+        hidden: !open,
+        className: mergeClasses3(styles.panel),
+        children: open ? children : null
+      }
+    )
+  ] });
+}
+
+// src/conversation/MessageActions.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function MessageActions({
+  message,
+  onCopy,
+  onRetry,
+  onFeedback
+}) {
+  const actions = [];
+  if (onCopy) {
+    actions.push({ key: "copy", label: "Copy message", icon: /* @__PURE__ */ jsx7(CopyRegular, {}), onClick: () => onCopy(message) });
+  }
+  if (onRetry && message.role === "assistant") {
+    actions.push({ key: "retry", label: "Regenerate", icon: /* @__PURE__ */ jsx7(ArrowClockwiseRegular, {}), onClick: () => onRetry(message) });
+  }
+  if (onFeedback && message.role === "assistant") {
+    actions.push(
+      { key: "up", label: "Good response", icon: /* @__PURE__ */ jsx7(ThumbLikeRegular, {}), onClick: () => onFeedback(message, "up") },
+      { key: "down", label: "Bad response", icon: /* @__PURE__ */ jsx7(ThumbDislikeRegular, {}), onClick: () => onFeedback(message, "down") }
+    );
+  }
+  if (actions.length === 0) return null;
+  return /* @__PURE__ */ jsx7(ActionToolbar, { actions, label: `Actions for this message` });
+}
+
+// src/conversation/MessageBubble.tsx
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+var useStyles6 = makeStyles7({
+  row: {
+    display: "flex",
+    gap: tokens6.spacingHorizontalS,
+    position: "relative",
+    paddingRight: tokens6.spacingHorizontalXXL
+  },
+  own: { flexDirection: "row-reverse", paddingRight: 0, paddingLeft: tokens6.spacingHorizontalXXL },
+  gutter: { width: "32px", flexShrink: 0 },
+  stack: { display: "flex", flexDirection: "column", gap: "2px", minWidth: 0, maxWidth: "80%" },
+  name: { fontSize: tokens6.fontSizeBase200, color: tokens6.colorNeutralForeground3 },
+  bubble: {
+    padding: `${tokens6.spacingVerticalS} ${tokens6.spacingHorizontalM}`,
+    borderRadius: tokens6.borderRadiusLarge,
+    backgroundColor: tokens6.colorNeutralBackground3,
+    color: tokens6.colorNeutralForeground1,
+    fontSize: tokens6.fontSizeBase300
+  },
+  ownBubble: {
+    backgroundColor: tokens6.colorBrandBackground,
+    color: tokens6.colorNeutralForegroundOnBrand
+  },
+  actions: {
+    position: "absolute",
+    top: "-12px",
+    right: tokens6.spacingHorizontalS,
+    opacity: 0,
+    pointerEvents: "none",
+    transitionProperty: "opacity",
+    transitionDuration: tokens6.durationFaster
+  },
+  // ★ hover OR focus-within. Without the second selector the row is unreachable by keyboard.
+  actionsVisible: { opacity: 1, pointerEvents: "auto" }
+});
+function MessageBubble(props) {
+  const { message, author, isRunStart = true, locale, ...actionHandlers } = props;
+  const styles = useStyles6();
+  const hidden = useVisuallyHiddenStyles();
+  const [revealed, setRevealed] = React9.useState(false);
+  const own = message.role === "user";
+  const name = author?.displayName ?? (own ? "You" : message.provider ?? "Assistant");
+  const time = new Intl.DateTimeFormat(locale, { timeStyle: "short" }).format(new Date(message.createdAt));
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: mergeClasses4(styles.row, own && styles.own),
+      onMouseEnter: () => setRevealed(true),
+      onMouseLeave: () => setRevealed(false),
+      onFocus: () => setRevealed(true),
+      onBlur: (e) => {
+        if (!e.currentTarget.contains(e.relatedTarget)) setRevealed(false);
+      },
+      "data-testid": "agentkit-message",
+      children: [
+        /* @__PURE__ */ jsx8("div", { className: styles.gutter, children: isRunStart ? /* @__PURE__ */ jsx8(Avatar, { name, size: 32, image: author?.imageUrl ? { src: author.imageUrl } : void 0 }) : null }),
+        /* @__PURE__ */ jsxs5("div", { className: styles.stack, children: [
+          /* @__PURE__ */ jsxs5("span", { className: hidden.root, children: [
+            name,
+            ", ",
+            /* @__PURE__ */ jsx8("time", { dateTime: new Date(message.createdAt).toISOString(), children: time })
+          ] }),
+          isRunStart ? /* @__PURE__ */ jsxs5("span", { className: styles.name, "aria-hidden": "true", children: [
+            name,
+            " \xB7 ",
+            time
+          ] }) : null,
+          /* @__PURE__ */ jsx8(
+            "div",
+            {
+              className: mergeClasses4(styles.bubble, own && styles.ownBubble),
+              "aria-busy": message.streaming || void 0,
+              children: /* @__PURE__ */ jsx8(StreamingText, { text: message.text, streaming: message.streaming })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx8("div", { className: mergeClasses4(styles.actions, revealed && styles.actionsVisible), children: /* @__PURE__ */ jsx8(MessageActions, { message, ...actionHandlers }) })
+      ]
+    }
+  );
+}
+
+// src/conversation/DayDivider.tsx
+import { makeStyles as makeStyles8, tokens as tokens7 } from "@fluentui/react-components";
+import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+var useStyles7 = makeStyles8({
+  root: {
+    display: "flex",
+    alignItems: "center",
+    gap: tokens7.spacingHorizontalM,
+    margin: `${tokens7.spacingVerticalM} 0`,
+    color: tokens7.colorNeutralForeground3,
+    fontSize: tokens7.fontSizeBase200
+  },
+  rule: { flex: 1, height: "1px", backgroundColor: tokens7.colorNeutralStroke2 }
+});
+function formatDayLabel(label, locale) {
+  switch (label.kind) {
+    case "today":
+      return "Today";
+    case "yesterday":
+      return "Yesterday";
+    case "weekday":
+      return new Intl.DateTimeFormat(locale, { weekday: "long", timeZone: "UTC" }).format(
+        /* @__PURE__ */ new Date(`${label.iso}T00:00:00Z`)
+      );
+    case "date":
+      return new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeZone: "UTC" }).format(
+        /* @__PURE__ */ new Date(`${label.iso}T00:00:00Z`)
+      );
+  }
+}
+function DayDivider({ label, locale }) {
+  const styles = useStyles7();
+  const text = formatDayLabel(label, locale);
+  return /* @__PURE__ */ jsxs6("div", { className: styles.root, role: "separator", "aria-label": text, children: [
+    /* @__PURE__ */ jsx9("span", { className: styles.rule, "aria-hidden": "true" }),
+    /* @__PURE__ */ jsx9("span", { children: text }),
+    /* @__PURE__ */ jsx9("span", { className: styles.rule, "aria-hidden": "true" })
+  ] });
+}
+
+// src/conversation/TypingIndicator.tsx
+import { makeStyles as makeStyles9, tokens as tokens8 } from "@fluentui/react-components";
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+var useStyles8 = makeStyles9({
+  root: { display: "inline-flex", gap: "4px", alignItems: "center", padding: tokens8.spacingVerticalXS },
+  dot: {
+    width: "6px",
+    height: "6px",
+    borderRadius: tokens8.borderRadiusCircular,
+    backgroundColor: tokens8.colorNeutralForeground3,
+    animationName: { "0%,80%,100%": { opacity: 0.3 }, "40%": { opacity: 1 } },
+    animationDuration: "1.4s",
+    animationIterationCount: "infinite",
+    "@media (prefers-reduced-motion: reduce)": { animationName: "none", opacity: 0.6 }
+  },
+  d2: { animationDelay: "0.2s" },
+  d3: { animationDelay: "0.4s" }
+});
+function TypingIndicator({ label = "Assistant is responding" }) {
+  const styles = useStyles8();
+  return /* @__PURE__ */ jsxs7("div", { className: styles.root, role: "status", "aria-label": label, "data-testid": "agentkit-typing", children: [
+    /* @__PURE__ */ jsx10("span", { className: styles.dot, "aria-hidden": "true" }),
+    /* @__PURE__ */ jsx10("span", { className: `${styles.dot} ${styles.d2}`, "aria-hidden": "true" }),
+    /* @__PURE__ */ jsx10("span", { className: `${styles.dot} ${styles.d3}`, "aria-hidden": "true" })
+  ] });
+}
+
+// src/conversation/MessageList.tsx
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+var useStyles9 = makeStyles10({
+  root: { position: "relative", height: "100%", minHeight: 0, display: "flex", flexDirection: "column" },
+  scroller: {
+    flex: 1,
+    overflowY: "auto",
+    padding: tokens9.spacingVerticalM,
+    display: "flex",
+    flexDirection: "column",
+    gap: tokens9.spacingVerticalS
+  },
+  jump: { position: "absolute", bottom: tokens9.spacingVerticalM, alignSelf: "center", zIndex: 1 }
+});
+function MessageList(props) {
+  const {
+    messages,
+    participants,
+    busy = false,
+    announcement,
+    groupWindowMs,
+    timeZone,
+    locale,
+    now,
+    emptyState,
+    ...actionHandlers
+  } = props;
+  const styles = useStyles9();
+  const scrollerRef = React10.useRef(null);
+  const { onScroll, scrollToBottom, isPinned } = useStickyScroll(scrollerRef, messages.length);
+  const byId = React10.useMemo(
+    () => new Map((participants ?? []).map((p) => [p.id, p])),
+    [participants]
+  );
+  const runStarts = React10.useMemo(() => {
+    const groups = groupMessages(messages, { windowMs: groupWindowMs, timeZone });
+    return new Set(groups.map((g) => g.messageIds[0]));
+  }, [messages, groupWindowMs, timeZone]);
+  const buckets = React10.useMemo(
+    () => bucketByDay(messages, { timeZone, now }),
+    [messages, timeZone, now]
+  );
+  const dividerBefore = React10.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const bucket of buckets) map.set(bucket.messageIds[0], bucket.label);
+    return map;
+  }, [buckets]);
+  return /* @__PURE__ */ jsxs8("div", { className: styles.root, children: [
+    /* @__PURE__ */ jsx11(LiveAnnouncer, { polite: announcement?.polite, assertive: announcement?.assertive }),
+    /* @__PURE__ */ jsxs8(
+      "div",
+      {
+        ref: scrollerRef,
+        className: styles.scroller,
+        onScroll,
+        role: "log",
+        "aria-label": "Conversation",
+        tabIndex: 0,
+        children: [
+          messages.length === 0 ? emptyState ?? null : messages.map((message) => /* @__PURE__ */ jsxs8(React10.Fragment, { children: [
+            dividerBefore.has(message.id) ? /* @__PURE__ */ jsx11(DayDivider, { label: dividerBefore.get(message.id), locale }) : null,
+            /* @__PURE__ */ jsx11(
+              MessageBubble,
+              {
+                message,
+                author: byId.get(message.authorId),
+                isRunStart: runStarts.has(message.id),
+                locale,
+                ...actionHandlers
+              }
+            )
+          ] }, message.id)),
+          busy ? /* @__PURE__ */ jsx11(TypingIndicator, {}) : null
+        ]
+      }
+    ),
+    !isPinned && messages.length > 0 ? /* @__PURE__ */ jsx11(
+      Button3,
+      {
+        className: styles.jump,
+        size: "small",
+        appearance: "primary",
+        icon: /* @__PURE__ */ jsx11(ArrowDownRegular, {}),
+        onClick: scrollToBottom,
+        children: "Jump to latest"
+      }
+    ) : null
+  ] });
+}
+
+// src/conversation/Composer.tsx
+import * as React11 from "react";
+import { Button as Button4, Textarea, makeStyles as makeStyles11, tokens as tokens10, Tooltip as Tooltip2 } from "@fluentui/react-components";
+import { SendRegular, StopRegular } from "@fluentui/react-icons";
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+var useStyles10 = makeStyles11({
+  root: {
+    display: "flex",
+    gap: tokens10.spacingHorizontalS,
+    alignItems: "flex-end",
+    padding: tokens10.spacingVerticalS,
+    borderTop: `1px solid ${tokens10.colorNeutralStroke2}`
+  },
+  input: { flex: 1 },
+  hint: { fontSize: tokens10.fontSizeBase100, color: tokens10.colorNeutralForeground3 }
+});
+function Composer(props) {
+  const {
+    value,
+    onChange,
+    onSend,
+    onStop,
+    busy = false,
+    disabled = false,
+    placeholder = "Type a message",
+    maxLength,
+    sendOn = "enter",
+    toolbar
+  } = props;
+  const styles = useStyles10();
+  const hintId = React11.useId();
+  const submit = () => {
+    const text = value.trim();
+    if (!text || busy || disabled) return;
+    onSend(text);
+  };
+  const onKeyDown = (event) => {
+    if (event.key !== "Enter") return;
+    const wants = sendOn === "enter" ? !event.shiftKey : event.metaKey || event.ctrlKey;
+    if (!wants) return;
+    event.preventDefault();
+    submit();
+  };
+  const hint = sendOn === "enter" ? "Press Enter to send, Shift plus Enter for a new line." : "Press Control or Command plus Enter to send.";
+  return /* @__PURE__ */ jsxs9("div", { className: styles.root, children: [
+    /* @__PURE__ */ jsxs9("div", { className: styles.input, children: [
+      /* @__PURE__ */ jsx12(
+        Textarea,
+        {
+          value,
+          onChange: (_, data) => onChange(data.value),
+          onKeyDown,
+          placeholder,
+          disabled,
+          maxLength,
+          resize: "vertical",
+          "aria-label": placeholder,
+          "aria-describedby": hintId,
+          textarea: { "aria-multiline": true }
+        }
+      ),
+      /* @__PURE__ */ jsx12("span", { id: hintId, className: styles.hint, children: hint })
+    ] }),
+    toolbar,
+    busy && onStop ? /* @__PURE__ */ jsx12(Tooltip2, { content: "Stop generating", relationship: "label", withArrow: true, children: /* @__PURE__ */ jsx12(Button4, { appearance: "secondary", icon: /* @__PURE__ */ jsx12(StopRegular, {}), onClick: onStop }) }) : /* @__PURE__ */ jsx12(Tooltip2, { content: "Send", relationship: "label", withArrow: true, children: /* @__PURE__ */ jsx12(
+      Button4,
+      {
+        appearance: "primary",
+        icon: /* @__PURE__ */ jsx12(SendRegular, {}),
+        onClick: submit,
+        disabled: !value.trim() || busy || disabled
+      }
+    ) })
+  ] });
+}
+
+// src/conversation/SuggestedPrompts.tsx
+import { Button as Button5, makeStyles as makeStyles12, tokens as tokens11 } from "@fluentui/react-components";
+import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+var useStyles11 = makeStyles12({
+  root: { display: "flex", flexWrap: "wrap", gap: tokens11.spacingHorizontalXS, padding: tokens11.spacingVerticalXS },
+  heading: { width: "100%", fontSize: tokens11.fontSizeBase200, color: tokens11.colorNeutralForeground3 }
+});
+function SuggestedPrompts({
+  prompts,
+  onPick,
+  heading = "Suggested follow-ups"
+}) {
+  const styles = useStyles11();
+  if (prompts.length === 0) return null;
+  return /* @__PURE__ */ jsxs10("div", { className: styles.root, role: "group", "aria-label": heading, children: [
+    /* @__PURE__ */ jsx13("span", { className: styles.heading, children: heading }),
+    prompts.map((prompt) => /* @__PURE__ */ jsx13(Button5, { size: "small", appearance: "outline", onClick: () => onPick(prompt), children: prompt }, prompt))
+  ] });
+}
+
+// src/conversation/EmptyConversation.tsx
+import { makeStyles as makeStyles13, tokens as tokens12, Text as Text2 } from "@fluentui/react-components";
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+var useStyles12 = makeStyles13({
+  root: {
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    justifyContent: "center",
+    gap: tokens12.spacingVerticalS,
+    height: "100%",
+    padding: tokens12.spacingVerticalXXL,
+    textAlign: "center",
+    color: tokens12.colorNeutralForeground3
+  }
+});
+function EmptyConversation({
+  title = "Ask the agent",
+  description = "It answers from the records you have open.",
+  prompts = [],
+  onPick
+}) {
+  const styles = useStyles12();
+  return /* @__PURE__ */ jsxs11("div", { className: styles.root, children: [
+    /* @__PURE__ */ jsx14(Text2, { as: "h2", size: 500, weight: "semibold", children: title }),
+    /* @__PURE__ */ jsx14(Text2, { children: description }),
+    onPick && prompts.length > 0 ? /* @__PURE__ */ jsx14(SuggestedPrompts, { prompts, onPick, heading: "Try one of these" }) : null
+  ] });
+}
+
+// src/conversation/SystemNotice.tsx
+import {
+  MessageBar,
+  MessageBarBody,
+  MessageBarTitle,
+  MessageBarActions,
+  Button as Button6
+} from "@fluentui/react-components";
+import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+var INTENT = { success: "success", warning: "warning", error: "error", info: "info" };
+function SystemNotice({ failure, guarded, onRetry }) {
+  if (!failure && !guarded) return null;
+  if (!failure && guarded) {
+    return /* @__PURE__ */ jsx15(MessageBar, { intent: "warning", children: /* @__PURE__ */ jsxs12(MessageBarBody, { children: [
+      /* @__PURE__ */ jsx15(MessageBarTitle, { children: "Response withheld" }),
+      "The provider substituted safe text for the generated answer."
+    ] }) });
+  }
+  if (!failure) return null;
+  const title = {
+    blocked: "Response withheld",
+    refused: "The agent declined",
+    error: "Something went wrong",
+    notProvisioned: "Not configured",
+    cancelled: "Stopped"
+  };
+  return /* @__PURE__ */ jsxs12(MessageBar, { intent: INTENT[runStatusSeverity(failure.status)], children: [
+    /* @__PURE__ */ jsxs12(MessageBarBody, { children: [
+      /* @__PURE__ */ jsx15(MessageBarTitle, { children: title[failure.status] ?? "Notice" }),
+      failure.message
+    ] }),
+    failure.recoverable && onRetry ? /* @__PURE__ */ jsx15(MessageBarActions, { children: /* @__PURE__ */ jsx15(Button6, { size: "small", onClick: onRetry, children: "Try again" }) }) : null
+  ] });
+}
+
+// src/ops/AgentStatusBadge.tsx
+import { Badge, Tooltip as Tooltip3 } from "@fluentui/react-components";
+import {
+  CheckmarkCircleRegular,
+  ShieldErrorRegular,
+  DismissCircleRegular,
+  ErrorCircleRegular,
+  PlugDisconnectedRegular,
+  StopRegular as StopRegular2
+} from "@fluentui/react-icons";
+import { jsx as jsx16 } from "react/jsx-runtime";
+var PRESENTATION = {
+  succeeded: { label: "Succeeded", color: "success", icon: /* @__PURE__ */ jsx16(CheckmarkCircleRegular, {}) },
+  blocked: { label: "Blocked by content filter", color: "warning", icon: /* @__PURE__ */ jsx16(ShieldErrorRegular, {}) },
+  refused: { label: "Declined", color: "warning", icon: /* @__PURE__ */ jsx16(DismissCircleRegular, {}) },
+  error: { label: "Error", color: "danger", icon: /* @__PURE__ */ jsx16(ErrorCircleRegular, {}) },
+  notProvisioned: { label: "Not configured", color: "informative", icon: /* @__PURE__ */ jsx16(PlugDisconnectedRegular, {}) },
+  cancelled: { label: "Stopped", color: "subtle", icon: /* @__PURE__ */ jsx16(StopRegular2, {}) }
+};
+function runStatusLabel(status) {
+  return PRESENTATION[status].label;
+}
+function AgentStatusBadge({ status, reason, size = "medium" }) {
+  const { label, color, icon } = PRESENTATION[status];
+  const badge = /* @__PURE__ */ jsx16(Badge, { appearance: "tint", color, icon, size, children: label });
+  return reason ? /* @__PURE__ */ jsx16(Tooltip3, { content: reason, relationship: "description", withArrow: true, children: badge }) : badge;
+}
+
+// src/ops/AvailabilityBanner.tsx
+import { MessageBar as MessageBar2, MessageBarBody as MessageBarBody2, MessageBarTitle as MessageBarTitle2, MessageBarActions as MessageBarActions2, Button as Button7 } from "@fluentui/react-components";
+import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+function AvailabilityBanner({
+  availability,
+  onRetry,
+  actions
+}) {
+  if (!availability || availability.available) return null;
+  const notProvisioned = availability.status === "notProvisioned";
+  return /* @__PURE__ */ jsxs13(MessageBar2, { intent: notProvisioned ? "info" : "warning", children: [
+    /* @__PURE__ */ jsxs13(MessageBarBody2, { children: [
+      /* @__PURE__ */ jsx17(MessageBarTitle2, { children: notProvisioned ? "No agent configured" : "The agent is unavailable" }),
+      availability.reason ?? "No reason was reported."
+    ] }),
+    onRetry || actions ? /* @__PURE__ */ jsxs13(MessageBarActions2, { children: [
+      actions,
+      onRetry ? /* @__PURE__ */ jsx17(Button7, { size: "small", onClick: onRetry, children: "Check again" }) : null
+    ] }) : null
+  ] });
+}
+
+// src/ops/UsageMeter.tsx
+import { makeStyles as makeStyles14, tokens as tokens13 } from "@fluentui/react-components";
+import { jsx as jsx18, jsxs as jsxs14 } from "react/jsx-runtime";
+var useStyles13 = makeStyles14({
+  root: {
+    display: "flex",
+    flexWrap: "wrap",
+    gap: tokens13.spacingHorizontalM,
+    fontSize: tokens13.fontSizeBase100,
+    color: tokens13.colorNeutralForeground3
+  },
+  item: { display: "flex", gap: tokens13.spacingHorizontalXXS },
+  value: { fontFamily: tokens13.fontFamilyMonospace },
+  unknown: { fontStyle: "italic" }
+});
+function UsageMeter({
+  usage,
+  show = ["tokens", "cost", "duration"]
+}) {
+  const styles = useStyles13();
+  if (!usage) return null;
+  const items = [];
+  if (show.includes("tokens")) {
+    const known = usage.inputTokens !== void 0 || usage.outputTokens !== void 0;
+    items.push({
+      key: "tokens",
+      label: "Tokens",
+      value: known ? `${usage.inputTokens ?? 0} in / ${usage.outputTokens ?? 0} out${usage.cachedTokens ? ` / ${usage.cachedTokens} cached` : ""}` : "not reported",
+      known
+    });
+  }
+  if (show.includes("cost")) {
+    const known = usage.costUsd !== void 0;
+    items.push({
+      key: "cost",
+      label: "Cost",
+      value: known ? `$${usage.costUsd.toFixed(6)}` : "not reported",
+      known
+    });
+  }
+  if (show.includes("duration")) {
+    const known = usage.durationMs !== void 0;
+    items.push({
+      key: "duration",
+      label: "Duration",
+      value: known ? `${usage.durationMs} ms` : "not reported",
+      known
+    });
+  }
+  if (show.includes("model") && usage.model) {
+    items.push({ key: "model", label: "Model", value: usage.model, known: true });
+  }
+  return /* @__PURE__ */ jsx18("div", { className: styles.root, children: items.map((item) => /* @__PURE__ */ jsxs14("span", { className: styles.item, children: [
+    item.label,
+    ":",
+    " ",
+    /* @__PURE__ */ jsx18("span", { className: item.known ? styles.value : styles.unknown, children: item.value })
+  ] }, item.key)) });
+}
+
+// src/ops/ThrottleNotice.tsx
+import * as React12 from "react";
+import { MessageBar as MessageBar3, MessageBarBody as MessageBarBody3, MessageBarTitle as MessageBarTitle3, MessageBarActions as MessageBarActions3, Button as Button8 } from "@fluentui/react-components";
+import { jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
+function ThrottleNotice({ failure, onRetry, now = Date.now }) {
+  const retryAfterMs = failure?.retryAfterMs;
+  const eligible = Boolean(failure?.recoverable && retryAfterMs && retryAfterMs > 0);
+  const [remaining, setRemaining] = React12.useState(retryAfterMs ?? 0);
+  React12.useEffect(() => {
+    if (!eligible) return;
+    const deadline = now() + (retryAfterMs ?? 0);
+    setRemaining(retryAfterMs ?? 0);
+    const id = setInterval(() => {
+      const left = deadline - now();
+      setRemaining(left > 0 ? left : 0);
+      if (left <= 0) clearInterval(id);
+    }, 250);
+    return () => clearInterval(id);
+  }, [eligible, retryAfterMs, now]);
+  if (!eligible || !failure) return null;
+  const seconds = Math.ceil(remaining / 1e3);
+  const ready = remaining <= 0;
+  return /* @__PURE__ */ jsxs15(MessageBar3, { intent: "warning", children: [
+    /* @__PURE__ */ jsxs15(MessageBarBody3, { children: [
+      /* @__PURE__ */ jsx19(MessageBarTitle3, { children: "Rate limited" }),
+      ready ? "You can try again now." : `${failure.message} Try again in ${seconds}s.`
+    ] }),
+    onRetry ? /* @__PURE__ */ jsx19(MessageBarActions3, { children: /* @__PURE__ */ jsx19(Button8, { size: "small", onClick: onRetry, disabled: !ready, children: "Try again" }) }) : null
+  ] });
+}
+
+// src/ops/ModelBadge.tsx
+import { Badge as Badge2 } from "@fluentui/react-components";
+import { jsx as jsx20 } from "react/jsx-runtime";
+function ModelBadge({ provider, model, version }) {
+  const parts = [provider, model, version ? `v${version}` : void 0].filter(Boolean);
+  if (parts.length === 0) return null;
+  return /* @__PURE__ */ jsx20(Badge2, { appearance: "outline", color: "informative", children: parts.join(" \xB7 ") });
+}
+
+// src/ops/AgentPicker.tsx
+import { Dropdown, Option, Field } from "@fluentui/react-components";
+import { jsx as jsx21 } from "react/jsx-runtime";
+function AgentPicker({
+  agents,
+  selectedId,
+  onSelect,
+  label = "Agent",
+  disabled
+}) {
+  const selected = agents.find((a) => a.id === selectedId);
+  return /* @__PURE__ */ jsx21(Field, { label, children: /* @__PURE__ */ jsx21(
+    Dropdown,
+    {
+      disabled,
+      value: selected ? selected.name : "",
+      selectedOptions: selectedId ? [selectedId] : [],
+      onOptionSelect: (_, data) => {
+        if (data.optionValue) onSelect(data.optionValue);
+      },
+      placeholder: "Select an agent",
+      children: agents.map((agent) => /* @__PURE__ */ jsx21(Option, { value: agent.id, text: agent.name, children: agent.model ? `${agent.name} \u2014 ${agent.model}` : agent.name }, agent.id))
+    }
+  ) });
+}
+
+// src/ops/RunTimeline.tsx
+import * as React13 from "react";
+import { makeStyles as makeStyles15, tokens as tokens14, Text as Text3 } from "@fluentui/react-components";
+import { jsx as jsx22, jsxs as jsxs16 } from "react/jsx-runtime";
+var useStyles14 = makeStyles15({
+  list: { listStyle: "none", margin: 0, padding: 0, display: "flex", flexDirection: "column", gap: tokens14.spacingVerticalXS },
+  step: { display: "flex", gap: tokens14.spacingHorizontalS, alignItems: "baseline" },
+  index: { fontFamily: tokens14.fontFamilyMonospace, fontSize: tokens14.fontSizeBase100, color: tokens14.colorNeutralForeground3, minWidth: "18px" },
+  name: { fontFamily: tokens14.fontFamilyMonospace, fontSize: tokens14.fontSizeBase200 },
+  status: { fontSize: tokens14.fontSizeBase100, color: tokens14.colorNeutralForeground3 },
+  section: { marginTop: tokens14.spacingVerticalS }
+});
+var TOOL_STATUS = {
+  proposed: "proposed",
+  running: "running",
+  succeeded: "succeeded",
+  failed: "failed",
+  denied: "denied"
+};
+function RunTimeline({ message, defaultOpen = false }) {
+  const styles = useStyles14();
+  const id = React13.useId();
+  const calls = message.toolCalls ?? [];
+  const sources = message.sources ?? [];
+  const hasAnything = calls.length > 0 || sources.length > 0 || message.usage || message.failure;
+  if (!hasAnything) return null;
+  const status = message.failure?.status ?? (message.guarded ? "blocked" : "succeeded");
+  return /* @__PURE__ */ jsxs16(
+    Disclosure,
+    {
+      id,
+      defaultOpen,
+      summary: `Trace \u2014 ${calls.length} tool call${calls.length === 1 ? "" : "s"}`,
+      children: [
+        /* @__PURE__ */ jsx22("div", { className: styles.step, children: /* @__PURE__ */ jsx22(AgentStatusBadge, { status, reason: message.failure?.message, size: "small" }) }),
+        calls.length > 0 ? /* @__PURE__ */ jsx22("ol", { className: styles.list, "aria-label": "Tool calls", children: calls.map((call, index) => /* @__PURE__ */ jsxs16("li", { className: styles.step, children: [
+          /* @__PURE__ */ jsxs16("span", { className: styles.index, children: [
+            index + 1,
+            "."
+          ] }),
+          /* @__PURE__ */ jsx22("span", { className: styles.name, children: call.name }),
+          /* @__PURE__ */ jsx22("span", { className: styles.status, children: TOOL_STATUS[call.status] })
+        ] }, call.id)) }) : null,
+        sources.length > 0 ? /* @__PURE__ */ jsxs16(Text3, { as: "p", size: 200, className: styles.section, children: [
+          sources.length,
+          " source",
+          sources.length === 1 ? "" : "s",
+          " retrieved"
+        ] }) : null,
+        /* @__PURE__ */ jsx22("div", { className: styles.section, children: /* @__PURE__ */ jsx22(UsageMeter, { usage: message.usage, show: ["tokens", "cost", "duration", "model"] }) })
+      ]
+    }
+  );
+}
+
+// src/ops/RunHistoryPanel.tsx
+import { makeStyles as makeStyles16, tokens as tokens15, Text as Text4 } from "@fluentui/react-components";
+import { Fragment as Fragment3, jsx as jsx23, jsxs as jsxs17 } from "react/jsx-runtime";
+var useStyles15 = makeStyles16({
+  list: { listStyle: "none", margin: 0, padding: 0, display: "flex", flexDirection: "column", gap: tokens15.spacingVerticalXS },
+  row: {
+    display: "flex",
+    flexDirection: "column",
+    gap: "2px",
+    padding: tokens15.spacingVerticalXS,
+    borderBottom: `1px solid ${tokens15.colorNeutralStroke2}`
+  },
+  head: { display: "flex", alignItems: "center", gap: tokens15.spacingHorizontalS, flexWrap: "wrap" },
+  time: { fontSize: tokens15.fontSizeBase100, color: tokens15.colorNeutralForeground3 },
+  prompt: { fontSize: tokens15.fontSizeBase200, color: tokens15.colorNeutralForeground2, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+  id: { fontFamily: tokens15.fontFamilyMonospace, fontSize: tokens15.fontSizeBase100, color: tokens15.colorNeutralForeground3 },
+  empty: { padding: tokens15.spacingVerticalM, color: tokens15.colorNeutralForeground3 }
+});
+function RunHistoryPanel({
+  runs,
+  grid,
+  locale,
+  emptyLabel = "No runs yet."
+}) {
+  const styles = useStyles15();
+  if (grid) return /* @__PURE__ */ jsx23(Fragment3, { children: grid });
+  if (runs.length === 0) {
+    return /* @__PURE__ */ jsx23(Text4, { className: styles.empty, size: 200, children: emptyLabel });
+  }
+  return /* @__PURE__ */ jsx23("ul", { className: styles.list, "aria-label": "Run history", children: runs.map((run) => /* @__PURE__ */ jsxs17("li", { className: styles.row, children: [
+    /* @__PURE__ */ jsxs17("div", { className: styles.head, children: [
+      /* @__PURE__ */ jsx23(AgentStatusBadge, { status: run.status, size: "small" }),
+      /* @__PURE__ */ jsx23("span", { className: styles.time, children: new Intl.DateTimeFormat(locale, { dateStyle: "short", timeStyle: "short" }).format(
+        new Date(run.startedAt)
+      ) }),
+      run.correlationId ? /* @__PURE__ */ jsx23("span", { className: styles.id, children: run.correlationId }) : null
+    ] }),
+    run.prompt ? /* @__PURE__ */ jsx23("span", { className: styles.prompt, children: run.prompt }) : null,
+    /* @__PURE__ */ jsx23(UsageMeter, { usage: run.usage })
+  ] }, run.id)) });
+}
+
+// src/ops/AgentOpsPanel.tsx
+import { makeStyles as makeStyles17, tokens as tokens16, Text as Text5 } from "@fluentui/react-components";
+import { jsx as jsx24, jsxs as jsxs18 } from "react/jsx-runtime";
+var useStyles16 = makeStyles17({
+  root: { display: "flex", flexDirection: "column", gap: tokens16.spacingVerticalM, minWidth: 0 },
+  head: { display: "flex", alignItems: "center", gap: tokens16.spacingHorizontalS, flexWrap: "wrap" },
+  section: { display: "flex", flexDirection: "column", gap: tokens16.spacingVerticalXS },
+  caps: { fontSize: tokens16.fontSizeBase100, color: tokens16.colorNeutralForeground3 }
+});
+function AgentOpsPanel(props) {
+  const { availability, agents, selectedAgentId, onSelectAgent, runs = [], runsGrid, onRefresh, locale } = props;
+  const styles = useStyles16();
+  const selected = agents?.find((a) => a.id === selectedAgentId);
+  const caps = availability?.capabilities;
+  return /* @__PURE__ */ jsxs18("div", { className: styles.root, children: [
+    /* @__PURE__ */ jsx24(AvailabilityBanner, { availability, onRetry: onRefresh }),
+    agents && agents.length > 0 && onSelectAgent ? /* @__PURE__ */ jsxs18("div", { className: styles.section, children: [
+      /* @__PURE__ */ jsx24(AgentPicker, { agents, selectedId: selectedAgentId, onSelect: onSelectAgent }),
+      /* @__PURE__ */ jsx24("div", { className: styles.head, children: /* @__PURE__ */ jsx24(ModelBadge, { provider: selected?.name, model: selected?.model, version: selected?.version }) })
+    ] }) : null,
+    caps ? /* @__PURE__ */ jsxs18("span", { className: styles.caps, children: [
+      "Supports:",
+      " ",
+      Object.entries(caps).filter(([, on]) => on).map(([name]) => name).join(", ") || "nothing reported"
+    ] }) : null,
+    /* @__PURE__ */ jsxs18("div", { className: styles.section, children: [
+      /* @__PURE__ */ jsx24(Text5, { weight: "semibold", size: 300, children: "Recent runs" }),
+      /* @__PURE__ */ jsx24(RunHistoryPanel, { runs, grid: runsGrid, locale })
+    ] })
+  ] });
+}
+
+// src/shell/AgentAppShell.tsx
+import * as React14 from "react";
+import { makeStyles as makeStyles18, tokens as tokens17, Button as Button9 } from "@fluentui/react-components";
+import { NavigationRegular } from "@fluentui/react-icons";
+import { BREAKPOINTS, resolveBreakpoint, useContainerWidth } from "@dataverse-kit/surface-kit/v9";
+import { Fragment as Fragment4, jsx as jsx25, jsxs as jsxs19 } from "react/jsx-runtime";
+var useStyles17 = makeStyles18({
+  root: {
+    display: "flex",
+    height: "100%",
+    minHeight: 0,
+    backgroundColor: tokens17.colorNeutralBackground2,
+    position: "relative",
+    overflow: "hidden"
+  },
+  sidebar: {
+    display: "flex",
+    flexDirection: "column",
+    minHeight: 0,
+    backgroundColor: tokens17.colorNeutralBackground1,
+    borderRight: `1px solid ${tokens17.colorNeutralStroke2}`
+  },
+  // Below `md` the list overlays the conversation instead of shrinking it to nothing.
+  sidebarOverlay: {
+    position: "absolute",
+    top: 0,
+    bottom: 0,
+    left: 0,
+    zIndex: 2,
+    boxShadow: tokens17.shadow16
+  },
+  scrim: { position: "absolute", inset: "0", zIndex: 1, backgroundColor: tokens17.colorBackgroundOverlay },
+  main: { flex: 1, display: "flex", flexDirection: "column", minWidth: 0, minHeight: 0 },
+  body: { flex: 1, minHeight: 0, display: "flex", flexDirection: "column" },
+  toggle: { position: "absolute", top: tokens17.spacingVerticalS, left: tokens17.spacingHorizontalS, zIndex: 3 }
+});
+function AgentAppShell(props) {
+  const {
+    rail,
+    sidebar,
+    header,
+    children,
+    rightPane,
+    sidebarWidth = 280,
+    sidebarOpen,
+    onSidebarOpenChange,
+    label = "Agent workspace"
+  } = props;
+  const styles = useStyles17();
+  const [containerRef, measuredWidth] = useContainerWidth();
+  const width = props.containerWidth ?? (measuredWidth > 0 ? measuredWidth : void 0);
+  const effective = width ?? BREAKPOINTS.xl;
+  const breakpoint = resolveBreakpoint(effective);
+  const railVisible = effective >= BREAKPOINTS.sm;
+  const sidebarInline = effective >= BREAKPOINTS.md;
+  const rightPaneVisible = effective >= BREAKPOINTS.lg;
+  const [uncontrolledOpen, setUncontrolledOpen] = React14.useState(false);
+  const overlayOpen = sidebarOpen ?? uncontrolledOpen;
+  const setOverlayOpen = (open) => {
+    onSidebarOpenChange?.(open);
+    if (sidebarOpen === void 0) setUncontrolledOpen(open);
+  };
+  return /* @__PURE__ */ jsxs19("div", { ref: containerRef, className: styles.root, "data-breakpoint": breakpoint, "aria-label": label, children: [
+    rail && railVisible ? rail : null,
+    sidebar && sidebarInline ? /* @__PURE__ */ jsx25("div", { className: styles.sidebar, style: { width: sidebarWidth }, children: sidebar }) : null,
+    sidebar && !sidebarInline && overlayOpen ? /* @__PURE__ */ jsxs19(Fragment4, { children: [
+      /* @__PURE__ */ jsx25(
+        "div",
+        {
+          className: styles.scrim,
+          onClick: () => setOverlayOpen(false),
+          "aria-hidden": "true"
+        }
+      ),
+      /* @__PURE__ */ jsx25("div", { className: `${styles.sidebar} ${styles.sidebarOverlay}`, style: { width: sidebarWidth }, children: sidebar })
+    ] }) : null,
+    /* @__PURE__ */ jsxs19("div", { className: styles.main, children: [
+      sidebar && !sidebarInline ? /* @__PURE__ */ jsx25(
+        Button9,
+        {
+          className: styles.toggle,
+          size: "small",
+          appearance: "subtle",
+          icon: /* @__PURE__ */ jsx25(NavigationRegular, {}),
+          "aria-label": overlayOpen ? "Hide conversations" : "Show conversations",
+          "aria-expanded": overlayOpen,
+          onClick: () => setOverlayOpen(!overlayOpen)
+        }
+      ) : null,
+      header,
+      /* @__PURE__ */ jsx25("div", { className: styles.body, children })
+    ] }),
+    rightPaneVisible ? rightPane : null
+  ] });
+}
+
+// src/shell/AppRail.tsx
+import {
+  Button as Button10,
+  Menu,
+  MenuTrigger,
+  MenuPopover,
+  MenuList,
+  MenuItem,
+  Tooltip as Tooltip4,
+  makeStyles as makeStyles19,
+  mergeClasses as mergeClasses5,
+  tokens as tokens18
+} from "@fluentui/react-components";
+import { MoreHorizontalRegular } from "@fluentui/react-icons";
+import { jsx as jsx26, jsxs as jsxs20 } from "react/jsx-runtime";
+var useStyles18 = makeStyles19({
+  root: {
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    gap: tokens18.spacingVerticalXS,
+    padding: tokens18.spacingVerticalS,
+    backgroundColor: tokens18.colorNeutralBackground3,
+    borderRight: `1px solid ${tokens18.colorNeutralStroke2}`,
+    minHeight: 0
+  },
+  spacer: { flex: 1 },
+  button: {
+    position: "relative",
+    ":focus-visible": { outline: `2px solid ${tokens18.colorStrokeFocus2}`, outlineOffset: "1px" }
+  },
+  selected: { backgroundColor: tokens18.colorNeutralBackground1Selected },
+  badge: {
+    position: "absolute",
+    top: "2px",
+    right: "2px",
+    minWidth: "16px",
+    height: "16px",
+    padding: "0 3px",
+    borderRadius: tokens18.borderRadiusCircular,
+    backgroundColor: tokens18.colorPaletteRedBackground3,
+    color: tokens18.colorNeutralForegroundOnBrand,
+    fontSize: "10px",
+    lineHeight: "16px"
+  }
+});
+function AppRail(props) {
+  const { items, selectedId, onSelect, maxVisible = 6, label = "Apps", footer } = props;
+  const styles = useStyles18();
+  const visible = items.slice(0, maxVisible);
+  const overflow = items.slice(maxVisible);
+  return /* @__PURE__ */ jsxs20("nav", { className: styles.root, "aria-label": label, children: [
+    visible.map((item) => /* @__PURE__ */ jsx26(Tooltip4, { content: item.label, relationship: "label", positioning: "after", withArrow: true, children: /* @__PURE__ */ jsx26(
+      Button10,
+      {
+        appearance: "subtle",
+        icon: item.icon,
+        className: mergeClasses5(styles.button, item.id === selectedId && styles.selected),
+        "aria-pressed": item.id === selectedId,
+        "aria-label": item.badgeCount ? `${item.label}, ${item.badgeCount} unread` : item.label,
+        onClick: () => onSelect(item.id),
+        children: item.badgeCount ? /* @__PURE__ */ jsx26("span", { className: styles.badge, "aria-hidden": "true", children: item.badgeCount }) : null
+      }
+    ) }, item.id)),
+    overflow.length > 0 ? /* @__PURE__ */ jsxs20(Menu, { children: [
+      /* @__PURE__ */ jsx26(MenuTrigger, { disableButtonEnhancement: true, children: /* @__PURE__ */ jsx26(
+        Button10,
+        {
+          appearance: "subtle",
+          icon: /* @__PURE__ */ jsx26(MoreHorizontalRegular, {}),
+          className: styles.button,
+          "aria-label": `More apps, ${overflow.length} hidden`
+        }
+      ) }),
+      /* @__PURE__ */ jsx26(MenuPopover, { children: /* @__PURE__ */ jsx26(MenuList, { children: overflow.map((item) => /* @__PURE__ */ jsx26(MenuItem, { icon: item.icon, onClick: () => onSelect(item.id), children: item.label }, item.id)) }) })
+    ] }) : null,
+    /* @__PURE__ */ jsx26("div", { className: styles.spacer }),
+    footer
+  ] });
+}
+
+// src/shell/ConversationList.tsx
+import * as React15 from "react";
+import { makeStyles as makeStyles21, tokens as tokens20, Text as Text6 } from "@fluentui/react-components";
+
+// src/shell/ConversationListItem.tsx
+import { makeStyles as makeStyles20, mergeClasses as mergeClasses6, tokens as tokens19 } from "@fluentui/react-components";
+
+// src/shell/AgentAvatar.tsx
+import { Avatar as Avatar2 } from "@fluentui/react-components";
+import { jsx as jsx27 } from "react/jsx-runtime";
+var STATUS = {
+  available: "available",
+  busy: "busy",
+  away: "away",
+  offline: "offline",
+  dnd: "do-not-disturb",
+  unknown: "unknown"
+};
+function AgentAvatar({ participant, presence, size = 32, name }) {
+  const displayName = name ?? participant?.displayName ?? "Unknown";
+  return /* @__PURE__ */ jsx27(
+    Avatar2,
+    {
+      name: displayName,
+      initials: participant?.initials,
+      image: participant?.imageUrl ? { src: participant.imageUrl } : void 0,
+      size,
+      badge: presence ? { status: STATUS[presence] ?? "unknown" } : void 0,
+      "aria-hidden": void 0
+    }
+  );
+}
+
+// src/shell/ConversationListItem.tsx
+import { jsx as jsx28, jsxs as jsxs21 } from "react/jsx-runtime";
+var useStyles19 = makeStyles20({
+  row: {
+    display: "flex",
+    gap: tokens19.spacingHorizontalS,
+    alignItems: "center",
+    padding: `${tokens19.spacingVerticalS} ${tokens19.spacingHorizontalS}`,
+    borderRadius: tokens19.borderRadiusMedium,
+    cursor: "pointer",
+    ":hover": { backgroundColor: tokens19.colorNeutralBackground1Hover }
+  },
+  // ★ The ACTIVE row (aria-activedescendant target) gets a visible focus indicator, because
+  //   real DOM focus stays on the listbox — without this the keyboard user sees nothing move.
+  active: { outline: `2px solid ${tokens19.colorStrokeFocus2}`, outlineOffset: "-2px" },
+  selected: { backgroundColor: tokens19.colorNeutralBackground1Selected },
+  body: { flex: 1, minWidth: 0 },
+  title: {
+    display: "block",
+    fontSize: tokens19.fontSizeBase300,
+    fontWeight: tokens19.fontWeightSemibold,
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap"
+  },
+  muted: { fontWeight: tokens19.fontWeightRegular, color: tokens19.colorNeutralForeground3 },
+  preview: {
+    display: "block",
+    fontSize: tokens19.fontSizeBase200,
+    color: tokens19.colorNeutralForeground3,
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap"
+  },
+  meta: { display: "flex", flexDirection: "column", alignItems: "flex-end", gap: "2px" },
+  time: { fontSize: tokens19.fontSizeBase100, color: tokens19.colorNeutralForeground3 },
+  unread: {
+    minWidth: "18px",
+    height: "18px",
+    padding: `0 ${tokens19.spacingHorizontalXXS}`,
+    borderRadius: tokens19.borderRadiusCircular,
+    backgroundColor: tokens19.colorBrandBackground,
+    color: tokens19.colorNeutralForegroundOnBrand,
+    fontSize: tokens19.fontSizeBase100,
+    lineHeight: "18px",
+    textAlign: "center"
+  }
+});
+function conversationAccessibleName(summary, locale) {
+  const parts = [summary.title];
+  if (summary.presence && summary.presence !== "unknown") parts.push(summary.presence);
+  if (!summary.muted && summary.unreadCount) {
+    parts.push(`${summary.unreadCount} unread`);
+  }
+  if (summary.muted) parts.push("muted");
+  if (summary.timestamp) {
+    parts.push(new Intl.DateTimeFormat(locale, { timeStyle: "short" }).format(new Date(summary.timestamp)));
+  }
+  return parts.join(", ");
+}
+function ConversationListItem(props) {
+  const { summary, selected, active, id, locale, onSelect } = props;
+  const styles = useStyles19();
+  const time = summary.timestamp ? new Intl.DateTimeFormat(locale, { timeStyle: "short" }).format(new Date(summary.timestamp)) : void 0;
+  return /* @__PURE__ */ jsxs21(
+    "div",
+    {
+      id,
+      role: "option",
+      "aria-selected": selected,
+      "aria-label": conversationAccessibleName(summary, locale),
+      className: mergeClasses6(styles.row, selected && styles.selected, active && styles.active),
+      onClick: () => onSelect(summary.id),
+      "data-conversation-option": true,
+      children: [
+        /* @__PURE__ */ jsx28(AgentAvatar, { participant: summary.participant, presence: summary.presence, size: 32 }),
+        /* @__PURE__ */ jsxs21("div", { className: styles.body, "aria-hidden": "true", children: [
+          /* @__PURE__ */ jsx28("span", { className: mergeClasses6(styles.title, summary.muted && styles.muted), children: summary.title }),
+          summary.preview ? /* @__PURE__ */ jsx28("span", { className: styles.preview, children: summary.preview }) : null
+        ] }),
+        /* @__PURE__ */ jsxs21("div", { className: styles.meta, "aria-hidden": "true", children: [
+          time ? /* @__PURE__ */ jsx28("span", { className: styles.time, children: time }) : null,
+          !summary.muted && summary.unreadCount ? /* @__PURE__ */ jsx28("span", { className: styles.unread, children: summary.unreadCount }) : null
+        ] })
+      ]
+    }
+  );
+}
+
+// src/shell/ConversationList.tsx
+import { jsx as jsx29 } from "react/jsx-runtime";
+var useStyles20 = makeStyles21({
+  root: {
+    display: "flex",
+    flexDirection: "column",
+    gap: "2px",
+    padding: tokens20.spacingHorizontalXS,
+    overflowY: "auto",
+    minHeight: 0,
+    ":focus-visible": { outline: `2px solid ${tokens20.colorStrokeFocus2}`, outlineOffset: "-2px" }
+  },
+  empty: { padding: tokens20.spacingVerticalM, color: tokens20.colorNeutralForeground3 }
+});
+function ConversationList(props) {
+  const { items, selectedId, onSelect, label = "Conversations", locale, empty } = props;
+  const styles = useStyles20();
+  const listRef = React15.useRef(null);
+  const idBase = React15.useId();
+  const selectedIndex = Math.max(0, items.findIndex((i) => i.id === selectedId));
+  const [active, setActive] = React15.useState(selectedIndex);
+  React15.useEffect(() => {
+    setActive((current) => {
+      if (items.length === 0) return 0;
+      if (selectedIndex >= 0 && items[selectedIndex]) return selectedIndex;
+      return Math.min(current, items.length - 1);
+    });
+  }, [selectedIndex, items]);
+  const optionId = (index) => `${idBase}-opt-${index}`;
+  React15.useEffect(() => {
+    const el = listRef.current?.ownerDocument.getElementById(optionId(active));
+    el?.scrollIntoView?.({ block: "nearest" });
+  }, [active, idBase]);
+  const onKeyDown = (event) => {
+    const last = items.length - 1;
+    if (last < 0) return;
+    let next = null;
+    if (event.key === "ArrowDown") next = Math.min(last, active + 1);
+    else if (event.key === "ArrowUp") next = Math.max(0, active - 1);
+    else if (event.key === "Home") next = 0;
+    else if (event.key === "End") next = last;
+    else if (event.key === "Enter" || event.key === " ") {
+      event.preventDefault();
+      const picked = items[active];
+      if (picked) onSelect(picked.id);
+      return;
+    }
+    if (next === null) return;
+    event.preventDefault();
+    setActive(next);
+  };
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsx29("div", { className: styles.root, children: empty ?? /* @__PURE__ */ jsx29(Text6, { className: styles.empty, size: 200, children: "No conversations yet." }) });
+  }
+  return /* @__PURE__ */ jsx29(
+    "div",
+    {
+      ref: listRef,
+      className: styles.root,
+      role: "listbox",
+      "aria-label": label,
+      tabIndex: 0,
+      "aria-activedescendant": optionId(active),
+      onKeyDown,
+      children: items.map((summary, index) => /* @__PURE__ */ jsx29(
+        ConversationListItem,
+        {
+          id: optionId(index),
+          summary,
+          selected: summary.id === selectedId,
+          active: index === active,
+          locale,
+          onSelect
+        },
+        summary.id
+      ))
+    }
+  );
+}
+
+// src/shell/ConversationHeader.tsx
+import {
+  Button as Button11,
+  Menu as Menu2,
+  MenuTrigger as MenuTrigger2,
+  MenuPopover as MenuPopover2,
+  MenuList as MenuList2,
+  MenuItem as MenuItem2,
+  Tab,
+  TabList,
+  Text as Text7,
+  makeStyles as makeStyles22,
+  tokens as tokens21
+} from "@fluentui/react-components";
+import { MoreHorizontalRegular as MoreHorizontalRegular2 } from "@fluentui/react-icons";
+import { jsx as jsx30, jsxs as jsxs22 } from "react/jsx-runtime";
+var useStyles21 = makeStyles22({
+  root: {
+    display: "flex",
+    flexDirection: "column",
+    gap: tokens21.spacingVerticalXS,
+    padding: `${tokens21.spacingVerticalS} ${tokens21.spacingHorizontalM} 0`,
+    borderBottom: `1px solid ${tokens21.colorNeutralStroke2}`,
+    backgroundColor: tokens21.colorNeutralBackground1
+  },
+  top: { display: "flex", alignItems: "center", gap: tokens21.spacingHorizontalS },
+  identity: { display: "flex", alignItems: "center", gap: tokens21.spacingHorizontalS, minWidth: 0 },
+  titles: { display: "flex", flexDirection: "column", minWidth: 0 },
+  subtitle: { color: tokens21.colorNeutralForeground3, fontSize: tokens21.fontSizeBase200 },
+  spacer: { flex: 1 },
+  tabRow: { display: "flex", alignItems: "flex-end", gap: tokens21.spacingHorizontalS }
+});
+function ConversationHeader(props) {
+  const {
+    title,
+    subtitle,
+    participant,
+    presence,
+    tabs,
+    selectedTabId,
+    onTabSelect,
+    actions,
+    trailing
+  } = props;
+  const styles = useStyles21();
+  const inline = (actions ?? []).slice(0, 2);
+  const overflow = (actions ?? []).slice(2);
+  return /* @__PURE__ */ jsxs22("header", { className: styles.root, children: [
+    /* @__PURE__ */ jsxs22("div", { className: styles.top, children: [
+      /* @__PURE__ */ jsxs22("div", { className: styles.identity, children: [
+        /* @__PURE__ */ jsx30(AgentAvatar, { participant, presence, size: 32, name: title }),
+        /* @__PURE__ */ jsxs22("div", { className: styles.titles, children: [
+          /* @__PURE__ */ jsx30(Text7, { weight: "semibold", truncate: true, wrap: false, children: title }),
+          subtitle ? /* @__PURE__ */ jsx30("span", { className: styles.subtitle, children: subtitle }) : null
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx30("div", { className: styles.spacer }),
+      trailing,
+      inline.map((action) => /* @__PURE__ */ jsx30(
+        Button11,
+        {
+          appearance: "subtle",
+          size: "small",
+          icon: action.icon,
+          "aria-label": action.label,
+          onClick: action.onClick
+        },
+        action.key
+      )),
+      overflow.length > 0 ? /* @__PURE__ */ jsxs22(Menu2, { children: [
+        /* @__PURE__ */ jsx30(MenuTrigger2, { disableButtonEnhancement: true, children: /* @__PURE__ */ jsx30(
+          Button11,
+          {
+            appearance: "subtle",
+            size: "small",
+            icon: /* @__PURE__ */ jsx30(MoreHorizontalRegular2, {}),
+            "aria-label": `More actions, ${overflow.length} available`
+          }
+        ) }),
+        /* @__PURE__ */ jsx30(MenuPopover2, { children: /* @__PURE__ */ jsx30(MenuList2, { children: overflow.map((action) => /* @__PURE__ */ jsx30(MenuItem2, { icon: action.icon, onClick: action.onClick, children: action.label }, action.key)) }) })
+      ] }) : null
+    ] }),
+    tabs && tabs.length > 0 ? /* @__PURE__ */ jsx30("div", { className: styles.tabRow, children: /* @__PURE__ */ jsx30(
+      TabList,
+      {
+        selectedValue: selectedTabId,
+        onTabSelect: (_, data) => onTabSelect?.(data.value),
+        size: "small",
+        children: tabs.map((tab) => /* @__PURE__ */ jsx30(Tab, { value: tab.id, children: tab.label }, tab.id))
+      }
+    ) }) : null
+  ] });
+}
+
+// src/shell/RightPane.tsx
+import * as React16 from "react";
+import { Button as Button12, makeStyles as makeStyles23, tokens as tokens22, Text as Text8 } from "@fluentui/react-components";
+import { DismissRegular } from "@fluentui/react-icons";
+import { jsx as jsx31, jsxs as jsxs23 } from "react/jsx-runtime";
+var useStyles22 = makeStyles23({
+  root: {
+    display: "flex",
+    flexDirection: "column",
+    borderLeft: `1px solid ${tokens22.colorNeutralStroke2}`,
+    backgroundColor: tokens22.colorNeutralBackground1,
+    minHeight: 0
+  },
+  head: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    gap: tokens22.spacingHorizontalS,
+    padding: tokens22.spacingVerticalS,
+    borderBottom: `1px solid ${tokens22.colorNeutralStroke2}`
+  },
+  body: { flex: 1, overflowY: "auto", padding: tokens22.spacingVerticalM }
+});
+function RightPane({ open, title, onClose, children, width = 320 }) {
+  const styles = useStyles22();
+  const labelId = React16.useId();
+  if (!open) return null;
+  return /* @__PURE__ */ jsxs23("aside", { className: styles.root, style: { width }, "aria-labelledby": labelId, children: [
+    /* @__PURE__ */ jsxs23("div", { className: styles.head, children: [
+      /* @__PURE__ */ jsx31(Text8, { id: labelId, weight: "semibold", children: title }),
+      /* @__PURE__ */ jsx31(
+        Button12,
+        {
+          appearance: "subtle",
+          size: "small",
+          icon: /* @__PURE__ */ jsx31(DismissRegular, {}),
+          onClick: onClose,
+          "aria-label": `Close ${title}`
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx31("div", { className: styles.body, children })
+  ] });
+}
+
+// src/shell/GlobalSearchBar.tsx
+import { SearchBox, makeStyles as makeStyles24 } from "@fluentui/react-components";
+import { jsx as jsx32 } from "react/jsx-runtime";
+var useStyles23 = makeStyles24({
+  root: { width: "100%", maxWidth: "640px" }
+});
+function GlobalSearchBar({
+  value,
+  onChange,
+  onSubmit,
+  placeholder = "Search conversations"
+}) {
+  const styles = useStyles23();
+  return /* @__PURE__ */ jsx32(
+    SearchBox,
+    {
+      className: styles.root,
+      value,
+      placeholder,
+      "aria-label": placeholder,
+      onChange: (_, data) => onChange(data.value),
+      onKeyDown: (e) => {
+        if (e.key === "Enter" && onSubmit) onSubmit(value);
+      }
+    }
+  );
+}
+
+// src/grounding/CitationChip.tsx
+import { Tooltip as Tooltip5, makeStyles as makeStyles25, tokens as tokens23 } from "@fluentui/react-components";
+import { jsx as jsx33 } from "react/jsx-runtime";
+var useStyles24 = makeStyles25({
+  chip: {
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    minWidth: "18px",
+    height: "18px",
+    padding: `0 ${tokens23.spacingHorizontalXXS}`,
+    marginLeft: "2px",
+    verticalAlign: "super",
+    fontSize: tokens23.fontSizeBase100,
+    lineHeight: "18px",
+    borderRadius: tokens23.borderRadiusSmall,
+    border: `1px solid ${tokens23.colorNeutralStroke2}`,
+    backgroundColor: tokens23.colorNeutralBackground3,
+    color: tokens23.colorNeutralForeground2,
+    cursor: "pointer",
+    ":hover": { backgroundColor: tokens23.colorNeutralBackground3Hover },
+    ":focus-visible": { outline: `2px solid ${tokens23.colorStrokeFocus2}`, outlineOffset: "1px" }
+  },
+  inert: { cursor: "default" }
+});
+function CitationChip({ marker, source, onOpen }) {
+  const styles = useStyles24();
+  const label = source ? `Source ${marker}: ${source.title}` : `Source ${marker}`;
+  if (!source || !onOpen) {
+    return /* @__PURE__ */ jsx33("span", { className: `${styles.chip} ${styles.inert}`, "aria-label": label, children: marker });
+  }
+  return /* @__PURE__ */ jsx33(Tooltip5, { content: source.title, relationship: "description", withArrow: true, children: /* @__PURE__ */ jsx33("button", { type: "button", className: styles.chip, "aria-label": label, onClick: () => onOpen(source), children: marker }) });
+}
+
+// src/grounding/CitationList.tsx
+import * as React17 from "react";
+import { makeStyles as makeStyles27, tokens as tokens25 } from "@fluentui/react-components";
+
+// src/grounding/SourceCard.tsx
+import { Button as Button13, Text as Text9, makeStyles as makeStyles26, tokens as tokens24 } from "@fluentui/react-components";
+import {
+  DocumentRegular,
+  DatabaseRegular,
+  GlobeRegular,
+  BookRegular,
+  DocumentBulletListRegular
+} from "@fluentui/react-icons";
+import { jsx as jsx34, jsxs as jsxs24 } from "react/jsx-runtime";
+var ICONS = {
+  dataverse: DatabaseRegular,
+  document: DocumentRegular,
+  web: GlobeRegular,
+  knowledge: BookRegular,
+  other: DocumentBulletListRegular
+};
+var useStyles25 = makeStyles26({
+  root: { gap: tokens24.spacingVerticalXXS },
+  head: { display: "flex", alignItems: "center", gap: tokens24.spacingHorizontalXS },
+  marker: { color: tokens24.colorNeutralForeground3, fontSize: tokens24.fontSizeBase200 },
+  snippet: { color: tokens24.colorNeutralForeground2, fontSize: tokens24.fontSizeBase200 },
+  meta: { display: "flex", alignItems: "center", gap: tokens24.spacingHorizontalS, marginTop: tokens24.spacingVerticalXXS }
+});
+function SourceCard({ source, marker, onOpen, showSnippet = true }) {
+  const styles = useStyles25();
+  const Icon = ICONS[source.kind] ?? ICONS.other;
+  return /* @__PURE__ */ jsxs24(CardSurface, { className: styles.root, children: [
+    /* @__PURE__ */ jsxs24("div", { className: styles.head, children: [
+      /* @__PURE__ */ jsx34(Icon, { "aria-hidden": "true" }),
+      marker ? /* @__PURE__ */ jsxs24("span", { className: styles.marker, children: [
+        "[",
+        marker,
+        "]"
+      ] }) : null,
+      /* @__PURE__ */ jsx34(Text9, { weight: "semibold", children: source.title })
+    ] }),
+    showSnippet && source.snippet ? /* @__PURE__ */ jsx34("span", { className: styles.snippet, children: source.snippet }) : null,
+    /* @__PURE__ */ jsxs24("div", { className: styles.meta, children: [
+      onOpen && (source.recordId || source.url) ? /* @__PURE__ */ jsx34(Button13, { size: "small", appearance: "subtle", onClick: () => onOpen(source), children: source.recordId ? "Open record" : "Open" }) : null,
+      /* @__PURE__ */ jsx34("span", { className: styles.snippet, children: source.score === void 0 ? "Relevance not reported" : `Relevance ${Math.round(source.score * 100)}%` })
+    ] })
+  ] });
+}
+
+// src/grounding/CitationList.tsx
+import { jsx as jsx35 } from "react/jsx-runtime";
+var useStyles26 = makeStyles27({
+  list: { display: "flex", flexDirection: "column", gap: tokens25.spacingVerticalXS, listStyle: "none", margin: 0, padding: 0 }
+});
+function CitationList({
+  text,
+  sources,
+  onOpenSource,
+  defaultOpen = false
+}) {
+  const styles = useStyles26();
+  const id = React17.useId();
+  const { used, citations } = React17.useMemo(() => renumberCitations(text, sources), [text, sources]);
+  if (used.length === 0) return null;
+  const markerFor = (sourceId) => citations.find((c) => c.sourceId === sourceId)?.marker;
+  return /* @__PURE__ */ jsx35(
+    Disclosure,
+    {
+      id,
+      defaultOpen,
+      summary: `${used.length} source${used.length === 1 ? "" : "s"}`,
+      children: /* @__PURE__ */ jsx35("ul", { className: styles.list, children: used.map((source) => /* @__PURE__ */ jsx35("li", { children: /* @__PURE__ */ jsx35(SourceCard, { source, marker: markerFor(source.id), onOpen: onOpenSource }) }, source.id)) })
+    }
+  );
+}
+
+// src/grounding/AnswerWithCitations.tsx
+import * as React18 from "react";
+import { makeStyles as makeStyles28 } from "@fluentui/react-components";
+import { jsx as jsx36 } from "react/jsx-runtime";
+var useStyles27 = makeStyles28({ root: { whiteSpace: "pre-wrap", wordBreak: "break-word" } });
+function AnswerWithCitations({
+  text,
+  citations = [],
+  sources = [],
+  onOpenSource
+}) {
+  const styles = useStyles27();
+  const segments = React18.useMemo(() => splitTextByCitations(text, citations), [text, citations]);
+  const byId = React18.useMemo(() => new Map(sources.map((s) => [s.id, s])), [sources]);
+  return /* @__PURE__ */ jsx36("span", { className: styles.root, children: segments.map(
+    (segment, i) => segment.kind === "text" ? /* @__PURE__ */ jsx36(React18.Fragment, { children: segment.text }, i) : /* @__PURE__ */ jsx36(
+      CitationChip,
+      {
+        marker: segment.marker ?? "",
+        source: segment.sourceId ? byId.get(segment.sourceId) : void 0,
+        onOpen: onOpenSource
+      },
+      i
+    )
+  ) });
+}
+
+// src/grounding/GroundingPanel.tsx
+import * as React19 from "react";
+import { Text as Text10, makeStyles as makeStyles29, tokens as tokens26 } from "@fluentui/react-components";
+import { jsx as jsx37, jsxs as jsxs25 } from "react/jsx-runtime";
+var useStyles28 = makeStyles29({
+  grid: {
+    display: "grid",
+    gridTemplateColumns: "minmax(96px, max-content) 1fr",
+    gap: `${tokens26.spacingVerticalXXS} ${tokens26.spacingHorizontalM}`,
+    margin: 0,
+    fontSize: tokens26.fontSizeBase200
+  },
+  key: { color: tokens26.colorNeutralForeground3, margin: 0 },
+  value: { margin: 0, wordBreak: "break-word", fontFamily: tokens26.fontFamilyMonospace },
+  empty: { fontSize: tokens26.fontSizeBase200, color: tokens26.colorNeutralForeground3 }
+});
+function render(value) {
+  if (value === null || value === void 0) return "\u2014";
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function GroundingPanel({
+  grounding,
+  title = "What this answer used",
+  defaultOpen = false
+}) {
+  const styles = useStyles28();
+  const id = React19.useId();
+  const entries = Object.entries(grounding ?? {});
+  if (entries.length === 0) return null;
+  return /* @__PURE__ */ jsxs25(Disclosure, { id, defaultOpen, summary: title, children: [
+    /* @__PURE__ */ jsx37("dl", { className: styles.grid, children: entries.map(([key, value]) => /* @__PURE__ */ jsxs25(React19.Fragment, { children: [
+      /* @__PURE__ */ jsx37("dt", { className: styles.key, children: key }),
+      /* @__PURE__ */ jsx37("dd", { className: styles.value, children: render(value) })
+    ] }, key)) }),
+    /* @__PURE__ */ jsx37(Text10, { as: "p", className: styles.empty, children: "These facts were supplied by the app, not produced by the model." })
+  ] });
+}
+
+// src/grounding/ProviderAttribution.tsx
+import { makeStyles as makeStyles30, tokens as tokens27 } from "@fluentui/react-components";
+import { ShieldErrorRegular as ShieldErrorRegular2 } from "@fluentui/react-icons";
+import { jsx as jsx38, jsxs as jsxs26 } from "react/jsx-runtime";
+var useStyles29 = makeStyles30({
+  root: {
+    display: "flex",
+    alignItems: "center",
+    gap: tokens27.spacingHorizontalXXS,
+    fontSize: tokens27.fontSizeBase100,
+    color: tokens27.colorNeutralForeground3
+  },
+  guarded: { color: tokens27.colorPaletteDarkOrangeForeground1 }
+});
+function ProviderAttribution({ provider, model, guarded }) {
+  const styles = useStyles29();
+  if (!provider && !model && !guarded) return null;
+  const who = [provider, model].filter(Boolean).join(" \xB7 ");
+  if (guarded) {
+    return /* @__PURE__ */ jsxs26("span", { className: `${styles.root} ${styles.guarded}`, children: [
+      /* @__PURE__ */ jsx38(ShieldErrorRegular2, { "aria-hidden": "true" }),
+      "Withheld and replaced with safe text",
+      who ? ` \u2014 not ${who}'s words` : ""
+    ] });
+  }
+  return /* @__PURE__ */ jsxs26("span", { className: styles.root, children: [
+    "Answered by ",
+    who || "the agent"
+  ] });
+}
+function messageAttribution(message) {
+  return { provider: message.provider, model: message.usage?.model, guarded: message.guarded };
+}
+
+// src/actions/ActionCard.tsx
+import * as React20 from "react";
+import { Text as Text11, makeStyles as makeStyles31, tokens as tokens28 } from "@fluentui/react-components";
+import { jsx as jsx39, jsxs as jsxs27 } from "react/jsx-runtime";
+var useStyles30 = makeStyles31({
+  head: { display: "flex", alignItems: "center", gap: tokens28.spacingHorizontalXS },
+  description: { color: tokens28.colorNeutralForeground2, fontSize: tokens28.fontSizeBase200 },
+  footer: { display: "flex", gap: tokens28.spacingHorizontalS, justifyContent: "flex-end", marginTop: tokens28.spacingVerticalXS }
+});
+function ActionCard({ title, description, icon, pending, children, footer }) {
+  const styles = useStyles30();
+  return /* @__PURE__ */ jsxs27(CardSurface, { emphasis: pending ? "attention" : "none", children: [
+    /* @__PURE__ */ jsxs27("div", { className: styles.head, children: [
+      icon ? React20.cloneElement(icon, { "aria-hidden": "true" }) : null,
+      /* @__PURE__ */ jsx39(Text11, { weight: "semibold", children: title })
+    ] }),
+    description ? /* @__PURE__ */ jsx39("span", { className: styles.description, children: description }) : null,
+    children,
+    footer ? /* @__PURE__ */ jsx39("div", { className: styles.footer, children: footer }) : null
+  ] });
+}
+
+// src/actions/ApprovalCard.tsx
+import * as React22 from "react";
+import { Button as Button15, Spinner, makeStyles as makeStyles34, tokens as tokens31 } from "@fluentui/react-components";
+import { CheckmarkRegular, DismissRegular as DismissRegular2, EditRegular } from "@fluentui/react-icons";
+
+// src/actions/ParameterReview.tsx
+import * as React21 from "react";
+import { Input, makeStyles as makeStyles32, tokens as tokens29, Text as Text12 } from "@fluentui/react-components";
+import { jsx as jsx40, jsxs as jsxs28 } from "react/jsx-runtime";
+var useStyles31 = makeStyles32({
+  grid: {
+    display: "grid",
+    gridTemplateColumns: "minmax(110px, max-content) 1fr",
+    gap: `${tokens29.spacingVerticalXS} ${tokens29.spacingHorizontalM}`,
+    alignItems: "center",
+    margin: 0
+  },
+  key: { margin: 0, color: tokens29.colorNeutralForeground2, fontSize: tokens29.fontSizeBase200 },
+  value: { margin: 0 },
+  raw: {
+    whiteSpace: "pre-wrap",
+    wordBreak: "break-all",
+    fontFamily: tokens29.fontFamilyMonospace,
+    fontSize: tokens29.fontSizeBase200,
+    color: tokens29.colorNeutralForeground2
+  }
+});
+function ParameterReview({ argumentsJson, readOnly = true, onChange }) {
+  const styles = useStyles31();
+  const parsed = React21.useMemo(() => {
+    try {
+      const value = JSON.parse(argumentsJson);
+      return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    } catch {
+      return null;
+    }
+  }, [argumentsJson]);
+  if (!parsed) {
+    return /* @__PURE__ */ jsxs28("div", { children: [
+      /* @__PURE__ */ jsx40(Text12, { size: 200, children: "Arguments (unparsed)" }),
+      /* @__PURE__ */ jsx40("pre", { className: styles.raw, children: argumentsJson || "(empty)" })
+    ] });
+  }
+  const set = (key, next) => {
+    if (!onChange) return;
+    onChange(JSON.stringify({ ...parsed, [key]: next }));
+  };
+  return /* @__PURE__ */ jsx40("dl", { className: styles.grid, children: Object.entries(parsed).map(([key, value]) => /* @__PURE__ */ jsxs28(React21.Fragment, { children: [
+    /* @__PURE__ */ jsx40("dt", { className: styles.key, children: key }),
+    /* @__PURE__ */ jsx40("dd", { className: styles.value, children: readOnly ? /* @__PURE__ */ jsx40("span", { className: styles.raw, children: typeof value === "string" ? value : JSON.stringify(value) }) : /* @__PURE__ */ jsx40(
+      Input,
+      {
+        size: "small",
+        "aria-label": key,
+        value: typeof value === "string" ? value : JSON.stringify(value),
+        onChange: (_, data) => set(key, data.value)
+      }
+    ) })
+  ] }, key)) });
+}
+
+// src/actions/ActionResult.tsx
+import { MessageBar as MessageBar4, MessageBarBody as MessageBarBody4, MessageBarTitle as MessageBarTitle4, MessageBarActions as MessageBarActions4, Button as Button14, makeStyles as makeStyles33, tokens as tokens30 } from "@fluentui/react-components";
+import { jsx as jsx41, jsxs as jsxs29 } from "react/jsx-runtime";
+var INTENT2 = { succeeded: "success", failed: "error", denied: "warning" };
+var TITLE = { succeeded: "Done", failed: "Failed", denied: "Not approved" };
+var useStyles32 = makeStyles33({
+  id: { display: "block", marginTop: tokens30.spacingVerticalXXS, fontSize: tokens30.fontSizeBase100, color: tokens30.colorNeutralForeground3, fontFamily: tokens30.fontFamilyMonospace }
+});
+function ActionResult({ status, message, correlationId, onRetry }) {
+  const styles = useStyles32();
+  return /* @__PURE__ */ jsxs29(MessageBar4, { intent: INTENT2[status], children: [
+    /* @__PURE__ */ jsxs29(MessageBarBody4, { children: [
+      /* @__PURE__ */ jsx41(MessageBarTitle4, { children: TITLE[status] }),
+      message,
+      correlationId ? /* @__PURE__ */ jsxs29("span", { className: styles.id, children: [
+        "Correlation id: ",
+        correlationId
+      ] }) : null
+    ] }),
+    status === "failed" && onRetry ? /* @__PURE__ */ jsx41(MessageBarActions4, { children: /* @__PURE__ */ jsx41(Button14, { size: "small", onClick: onRetry, children: "Try again" }) }) : null
+  ] });
+}
+
+// src/actions/ApprovalCard.tsx
+import { Fragment as Fragment8, jsx as jsx42, jsxs as jsxs30 } from "react/jsx-runtime";
+var useStyles33 = makeStyles34({
+  busy: { display: "flex", alignItems: "center", gap: tokens31.spacingHorizontalXS, fontSize: tokens31.fontSizeBase200 }
+});
+function ApprovalCard({
+  toolCall,
+  onApprove,
+  onDeny,
+  allowEdit = false,
+  busy = false
+}) {
+  const styles = useStyles33();
+  const [args, setArgs] = React22.useState(toolCall.argumentsJson);
+  const [editing, setEditing] = React22.useState(false);
+  const [decided, setDecided] = React22.useState(false);
+  const settled = toolCall.status === "succeeded" || toolCall.status === "failed" || toolCall.status === "denied";
+  if (settled) {
+    return /* @__PURE__ */ jsxs30(ActionCard, { title: toolCall.name, description: "Tool call", children: [
+      /* @__PURE__ */ jsx42(ParameterReview, { argumentsJson: toolCall.argumentsJson }),
+      /* @__PURE__ */ jsx42(
+        ActionResult,
+        {
+          status: toolCall.status === "succeeded" ? "succeeded" : toolCall.status === "denied" ? "denied" : "failed",
+          message: toolCall.resultText ?? toolCall.failure?.message ?? "Completed.",
+          correlationId: toolCall.failure?.correlationId
+        }
+      )
+    ] });
+  }
+  const locked = decided || busy || toolCall.status === "running";
+  const approve = () => {
+    if (locked) return;
+    setDecided(true);
+    onApprove(toolCall, args);
+  };
+  const deny = () => {
+    if (locked) return;
+    setDecided(true);
+    onDeny(toolCall);
+  };
+  return /* @__PURE__ */ jsx42(
+    ActionCard,
+    {
+      title: toolCall.name,
+      description: "The agent is asking to run this. Check the details before approving.",
+      pending: !locked,
+      footer: locked ? /* @__PURE__ */ jsxs30("span", { className: styles.busy, children: [
+        /* @__PURE__ */ jsx42(Spinner, { size: "tiny" }),
+        " Submitting\u2026"
+      ] }) : /* @__PURE__ */ jsxs30(Fragment8, { children: [
+        allowEdit ? /* @__PURE__ */ jsx42(Button15, { size: "small", icon: /* @__PURE__ */ jsx42(EditRegular, {}), onClick: () => setEditing((v) => !v), children: editing ? "Done editing" : "Edit" }) : null,
+        /* @__PURE__ */ jsx42(Button15, { size: "small", icon: /* @__PURE__ */ jsx42(DismissRegular2, {}), onClick: deny, disabled: locked, children: "Deny" }),
+        /* @__PURE__ */ jsx42(Button15, { size: "small", appearance: "primary", icon: /* @__PURE__ */ jsx42(CheckmarkRegular, {}), onClick: approve, disabled: locked, children: "Approve" })
+      ] }),
+      children: /* @__PURE__ */ jsx42(ParameterReview, { argumentsJson: args, readOnly: !editing, onChange: setArgs })
+    }
+  );
+}
+
+// src/actions/ToolCallCard.tsx
+import * as React23 from "react";
+import { Badge as Badge3, Spinner as Spinner2, makeStyles as makeStyles35, tokens as tokens32 } from "@fluentui/react-components";
+import { jsx as jsx43, jsxs as jsxs31 } from "react/jsx-runtime";
+var LABEL = {
+  proposed: "Proposed",
+  running: "Running",
+  succeeded: "Succeeded",
+  failed: "Failed",
+  denied: "Denied"
+};
+var COLOUR = {
+  proposed: "informative",
+  running: "informative",
+  succeeded: "success",
+  failed: "danger",
+  denied: "warning"
+};
+var useStyles34 = makeStyles35({
+  head: { display: "flex", alignItems: "center", gap: tokens32.spacingHorizontalXS },
+  name: { fontFamily: tokens32.fontFamilyMonospace, fontSize: tokens32.fontSizeBase200 },
+  result: {
+    whiteSpace: "pre-wrap",
+    wordBreak: "break-all",
+    fontFamily: tokens32.fontFamilyMonospace,
+    fontSize: tokens32.fontSizeBase200,
+    marginTop: tokens32.spacingVerticalXS
+  }
+});
+function ToolCallCard({ toolCall, defaultExpanded = false }) {
+  const styles = useStyles34();
+  const id = React23.useId();
+  return /* @__PURE__ */ jsx43(CardSurface, { children: /* @__PURE__ */ jsxs31(
+    Disclosure,
+    {
+      id,
+      defaultOpen: defaultExpanded,
+      summary: /* @__PURE__ */ jsxs31("span", { className: styles.head, children: [
+        /* @__PURE__ */ jsx43("span", { className: styles.name, children: toolCall.name }),
+        /* @__PURE__ */ jsx43(Badge3, { appearance: "tint", color: COLOUR[toolCall.status], children: LABEL[toolCall.status] }),
+        toolCall.status === "running" ? /* @__PURE__ */ jsx43(Spinner2, { size: "extra-tiny" }) : null
+      ] }),
+      children: [
+        /* @__PURE__ */ jsx43(ParameterReview, { argumentsJson: toolCall.argumentsJson }),
+        toolCall.resultText ? /* @__PURE__ */ jsx43("div", { className: styles.result, children: toolCall.resultText }) : null,
+        toolCall.failure ? /* @__PURE__ */ jsx43("div", { className: styles.result, children: toolCall.failure.message }) : null
+      ]
+    }
+  ) });
+}
+
+// src/host/AgentKitHostProvider.tsx
+import * as React24 from "react";
+import { FluentProvider, IdPrefixProvider } from "@fluentui/react-components";
+
+// src/theme/index.ts
+import {
+  createDynamicsV9Theme,
+  createDynamicsV9DarkTheme,
+  dynamicsBrandRamp
+} from "@dataverse-kit/fluent-theme";
+import { typography, radius } from "@dataverse-kit/design-tokens";
+function applyAgentOverrides(base) {
+  return {
+    ...base,
+    // Fluent's web theme is close to CE but does not pin the Web variant of Segoe.
+    fontFamilyBase: typography.fontFamily,
+    // CE is squarer than Fluent web's default. Bubbles opt back up to borderRadiusLarge.
+    borderRadiusMedium: radius.card
+  };
+}
+function createAgentTheme(brand = dynamicsBrandRamp) {
+  return applyAgentOverrides(createDynamicsV9Theme(brand));
+}
+function createAgentDarkTheme(brand = dynamicsBrandRamp) {
+  return applyAgentOverrides(createDynamicsV9DarkTheme(brand));
+}
+var agentTheme = createAgentTheme();
+var agentDarkTheme = createAgentDarkTheme();
+function resolveHostTheme(input = {}) {
+  if (input.theme) return input.theme;
+  if (input.hostTheme) return input.hostTheme;
+  return input.isDarkTheme ? agentDarkTheme : agentTheme;
+}
+
+// src/host/idPrefix.ts
+var nextAgentIdPrefix = createIdPrefixCounter("dvkak");
+
+// src/host/AgentKitHostProvider.tsx
+import { jsx as jsx44 } from "react/jsx-runtime";
+function AgentKitHostProvider(props) {
+  const { children, theme, hostTheme, isDarkTheme, targetDocument, className, style } = props;
+  const [generated] = React24.useState(nextAgentIdPrefix);
+  const idPrefix = props.idPrefix ?? generated;
+  const resolved = React24.useMemo(
+    () => resolveHostTheme({ theme, hostTheme, isDarkTheme }),
+    [theme, hostTheme, isDarkTheme]
+  );
+  return /* @__PURE__ */ jsx44(IdPrefixProvider, { value: idPrefix, children: /* @__PURE__ */ jsx44(
+    FluentProvider,
+    {
+      theme: resolved,
+      targetDocument,
+      className,
+      style,
+      children
+    }
+  ) });
+}
+
+// src/services/scenarios.ts
+var SOURCES = [
+  { id: "src-acct", title: "Contoso Ltd", kind: "dataverse", entityLogicalName: "account", recordId: "11111111-1111-1111-1111-111111111111", snippet: "Annual revenue \xA34.2m, 38 employees." },
+  { id: "src-case", title: "Case 4417 \u2014 invoice mismatch", kind: "dataverse", entityLogicalName: "incident", recordId: "22222222-2222-2222-2222-222222222222", snippet: "Raised 12 Mar, priority High." },
+  { id: "src-kb", title: "KB-208: credit note policy", kind: "knowledge", url: "https://example.invalid/kb/208", snippet: "Credit notes above \xA35,000 require finance approval.", score: 0.82 },
+  { id: "src-doc", title: "Statement-Mar.pdf", kind: "document", snippet: "Page 3 lists the disputed line." },
+  { id: "src-web", title: "Companies House filing", kind: "web", url: "https://example.invalid/ch" }
+];
+var mockScenarios = {
+  happy: {
+    text: "Contoso has three open cases. The oldest, case 4417, has been waiting eleven days for a credit note.",
+    status: "succeeded",
+    suggestions: ["Draft a credit note", "Show all three cases", "Who owns case 4417?"]
+  },
+  // ★ FIVE sources, but the text cites only [3] and [1] — and out of order. The panel must
+  //   show TWO, renumbered 1 and 2 in first-appearance order. A fixture where every source
+  //   is cited cannot tell a correct implementation from one that lists everything it was given.
+  grounded: {
+    text: "Credit notes over \xA35,000 need finance approval [3], and case 4417 is for \xA36,200 [1]. So this one needs sign-off.",
+    status: "succeeded",
+    sources: SOURCES
+  },
+  toolApproval: {
+    text: "I can raise the credit note for you \u2014 approve the details below and I will submit it.",
+    status: "succeeded",
+    toolCall: {
+      id: "call-1",
+      name: "create_credit_note",
+      argumentsJson: '{"accountId":"11111111-1111-1111-1111-111111111111","amount":6200,"currency":"GBP","reason":"Invoice mismatch, case 4417"}',
+      status: "proposed",
+      requiresApproval: true
+    }
+  },
+  toolAuto: {
+    text: "I checked the balance for you.",
+    status: "succeeded",
+    toolCall: { id: "call-2", name: "get_account_balance", argumentsJson: '{"accountId":"1111"}', status: "running" },
+    autoToolResult: '{"balance":6200,"currency":"GBP"}'
+  },
+  // ★ blocked and refused MUST look different on screen: a content filter fired, versus the
+  //   model declining. They need different fixes, so they are different states.
+  blocked: {
+    text: "I can\u2019t help with that request.",
+    status: "blocked",
+    guarded: true,
+    failureMessage: "The response was withheld by the content filter.",
+    failureCode: "content_filter",
+    recoverable: false
+  },
+  refused: {
+    text: "I don\u2019t have enough information to answer that safely. Could you say which account you mean?",
+    status: "refused",
+    failureMessage: "The agent declined to answer.",
+    recoverable: true
+  },
+  error: {
+    text: "",
+    status: "error",
+    failureMessage: "The agent is rate limited. Try again shortly.",
+    failureCode: "rate_limited",
+    recoverable: true,
+    retryAfterMs: 4e3
+  },
+  notProvisioned: {
+    text: "",
+    status: "notProvisioned",
+    failureMessage: "No Foundry project is configured for this environment.",
+    failureCode: "not_provisioned",
+    recoverable: false,
+    unavailable: true
+  },
+  cancelled: {
+    text: "Let me pull the last six months of activity for Contoso and work through it case by case, starting with the oldest\u2026",
+    status: "cancelled",
+    failureMessage: "Stopped."
+  },
+  // The fixture the autoscroll and live-region gates run against: enough deltas that
+  // "once, not per token" is a meaningful distinction.
+  longAnswer: {
+    text: Array.from({ length: 200 }, (_, i) => `word${i + 1}`).join(" "),
+    status: "succeeded"
+  },
+  throws: {
+    text: "partial\u2026",
+    status: "error",
+    throwsMidStream: true,
+    failureMessage: "never reached \u2014 the iterator throws instead"
+  }
+};
+
+// src/services/MockAgentService.ts
+var realScheduler = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var immediateScheduler = () => Promise.resolve();
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var MockAgentService = class {
+  constructor(options = {}) {
+    this.name = "mock";
+    this.scenarioName = options.scenario ?? "happy";
+    this.scenario = mockScenarios[this.scenarioName];
+    this.scheduler = options.scheduler ?? realScheduler;
+    this.firstTokenMs = options.firstTokenMs ?? 400;
+    this.chunkMs = options.chunkMs ?? 28;
+    this.rand = mulberry32(options.seed ?? 1);
+    this.availabilityOverride = options.availability;
+  }
+  async isAvailable() {
+    if (this.availabilityOverride) return this.availabilityOverride;
+    if (this.scenario.unavailable) {
+      return {
+        available: false,
+        status: "notProvisioned",
+        reason: this.scenario.failureMessage ?? "Not provisioned."
+      };
+    }
+    return {
+      available: true,
+      capabilities: { streaming: true, tools: true, citations: true, attachments: true, cancel: true }
+    };
+  }
+  /**
+   * A prompt can select a scenario (`/blocked`, `/tool`, `/error`), so one story can walk
+   * every state without remounting.
+   */
+  resolveScenario(promptText) {
+    const slash = promptText.trim().match(/^\/(\w+)/)?.[1];
+    if (slash && slash in mockScenarios) {
+      return { name: slash, scenario: mockScenarios[slash] };
+    }
+    return { name: this.scenarioName, scenario: this.scenario };
+  }
+  async *send(turn) {
+    const { scenario } = this.resolveScenario(turn.text);
+    const messageId = `mock-${Math.floor(this.rand() * 1e9).toString(36)}`;
+    const turnId = `turn-${messageId}`;
+    const provider = this.name;
+    const finish = (result) => ({
+      type: "turn_end",
+      turnId,
+      messageId,
+      result: { ...result, provider }
+    });
+    yield { type: "turn_start", turnId, messageId, provider, model: "mock-1" };
+    if (turn.cancelSignal?.aborted) {
+      yield finish({ status: "cancelled", text: "", failure: { status: "cancelled", message: "Stopped." } });
+      return;
+    }
+    if (scenario.status === "notProvisioned" || scenario.status === "error" && !scenario.text) {
+      await this.scheduler(this.firstTokenMs);
+      yield finish({
+        status: scenario.status,
+        text: "",
+        failure: {
+          status: scenario.status,
+          message: scenario.failureMessage ?? "Failed.",
+          code: scenario.failureCode,
+          recoverable: scenario.recoverable,
+          retryAfterMs: scenario.retryAfterMs
+        }
+      });
+      return;
+    }
+    if (scenario.sources) {
+      yield { type: "status", messageId, label: "Searching Dataverse\u2026" };
+      await this.scheduler(this.firstTokenMs);
+      yield { type: "sources", messageId, sources: scenario.sources };
+    }
+    if (scenario.thinking) {
+      yield { type: "thinking_delta", messageId, text: scenario.thinking };
+    }
+    if (scenario.toolCall) {
+      yield { type: "tool_call", messageId, call: scenario.toolCall };
+      if (scenario.autoToolResult !== void 0) {
+        await this.scheduler(this.chunkMs);
+        yield {
+          type: "tool_result",
+          messageId,
+          callId: scenario.toolCall.id,
+          status: "succeeded",
+          resultText: scenario.autoToolResult
+        };
+      }
+    }
+    const chunks = scenario.chunks ?? scenario.text.split(/(?<=\s)/);
+    await this.scheduler(this.firstTokenMs);
+    let emitted = "";
+    for (const [i, chunk] of chunks.entries()) {
+      if (turn.cancelSignal?.aborted) {
+        yield finish({
+          status: "cancelled",
+          text: emitted,
+          failure: { status: "cancelled", message: "Stopped." }
+        });
+        return;
+      }
+      if (scenario.throwsMidStream && i === Math.floor(chunks.length / 2)) {
+        throw new Error("mock transport exploded mid-stream");
+      }
+      emitted += chunk;
+      yield { type: "text_delta", messageId, text: chunk };
+      await this.scheduler(this.chunkMs);
+    }
+    if (scenario.suggestions) {
+      yield { type: "suggestions", messageId, prompts: scenario.suggestions };
+    }
+    const failed = scenario.status !== "succeeded";
+    yield finish({
+      status: scenario.status,
+      text: emitted,
+      guarded: scenario.guarded,
+      usage: {
+        inputTokens: 128,
+        outputTokens: chunks.length,
+        costUsd: Number((chunks.length * 2e-6).toFixed(6)),
+        durationMs: this.firstTokenMs + chunks.length * this.chunkMs,
+        model: "mock-1"
+      },
+      failure: failed ? {
+        status: scenario.status,
+        message: scenario.failureMessage ?? "Failed.",
+        code: scenario.failureCode,
+        recoverable: scenario.recoverable,
+        retryAfterMs: scenario.retryAfterMs
+      } : void 0
+    });
+  }
+};
+
+// src/services/NullAgentService.ts
+var NullAgentService = class {
+  constructor() {
+    this.name = "none";
+  }
+  async isAvailable() {
+    return {
+      available: false,
+      status: "notProvisioned",
+      reason: "No agent provider is configured for this host."
+    };
+  }
+  async *send(turn) {
+    const messageId = `null-${Date.now()}`;
+    const turnId = `turn-${messageId}`;
+    void turn;
+    yield { type: "turn_start", turnId, messageId, provider: this.name };
+    yield {
+      type: "turn_end",
+      turnId,
+      messageId,
+      result: {
+        status: "notProvisioned",
+        text: "",
+        provider: this.name,
+        failure: {
+          status: "notProvisioned",
+          message: "No agent provider is configured for this host.",
+          code: "not_provisioned",
+          recoverable: false
+        }
+      }
+    };
+  }
+};
+
+// src/services/createAgentService.ts
+function decide(config) {
+  switch (config.provider) {
+    case "custom":
+      return config.factory ? { provider: config.factory(), reason: "explicit factory (provider: custom)" } : { provider: new NullAgentService(), reason: "provider: custom but no factory supplied" };
+    case "mock":
+      return { provider: new MockAgentService(), reason: "provider: mock" };
+    case "none":
+      return { provider: new NullAgentService(), reason: "provider: none (the default)" };
+    default:
+      return {
+        provider: new NullAgentService(),
+        reason: `unrecognised provider ${String(config.provider)} \u2014 falling back to none`
+      };
+  }
+}
+function createAgentService(config = { provider: "none" }) {
+  return decide(config).provider;
+}
+export {
+  ANNOUNCE_FULL_TEXT_MAX_CHARS,
+  ActionCard,
+  ActionResult,
+  AgentAppShell,
+  AgentAvatar,
+  AgentKitHostProvider,
+  AgentOpsPanel,
+  AgentPicker,
+  AgentStatusBadge,
+  AnswerWithCitations,
+  AppRail,
+  ApprovalCard,
+  AvailabilityBanner,
+  CitationChip,
+  CitationList,
+  Composer,
+  ConfirmInline,
+  ConversationHeader,
+  ConversationList,
+  ConversationListItem,
+  DEFAULT_GROUP_WINDOW_MS,
+  DayDivider,
+  EmptyConversation,
+  GlobalSearchBar,
+  GroundingPanel,
+  LiveAnnouncer,
+  MessageActions,
+  MessageBubble,
+  MessageList,
+  MockAgentService,
+  ModelBadge,
+  NO_ANNOUNCEMENT,
+  NullAgentService,
+  ParameterReview,
+  ProviderAttribution,
+  RightPane,
+  RunHistoryPanel,
+  RunTimeline,
+  STICK_TO_BOTTOM_THRESHOLD_PX,
+  SourceCard,
+  StreamingText,
+  SuggestedPrompts,
+  SystemNotice,
+  ThrottleNotice,
+  ToolCallCard,
+  TypingIndicator,
+  UsageMeter,
+  agentDarkTheme,
+  agentTheme,
+  appendUserMessage,
+  applyAgentEvent,
+  bucketByDay,
+  classifyTransportFailure,
+  conversationAccessibleName,
+  createAgentDarkTheme,
+  createAgentService,
+  createAgentTheme,
+  createIdPrefixCounter,
+  dayKeyOf,
+  decide,
+  deriveAnnouncement,
+  extractCitationMarkers,
+  formatDayLabel,
+  fromClaudeStreamEvent,
+  fromFoundryChatResult,
+  fromOpenAiChatChunk,
+  fromSseLine,
+  groupMessages,
+  immediateScheduler,
+  initialConversation,
+  isSameAuthorRun,
+  isTerminalStatus,
+  messageAttribution,
+  mockScenarios,
+  nextAgentIdPrefix,
+  realScheduler,
+  renumberCitations,
+  resolveHostTheme,
+  runStatusLabel,
+  runStatusSeverity,
+  shouldStickToBottom,
+  splitTextByCitations,
+  useConversation,
+  useFocusRestore,
+  useRovingTabindex,
+  useStickyScroll,
+  useVisuallyHiddenStyles
+};
+//# sourceMappingURL=index.mjs.map