@opengeni/react 0.15.0 → 0.20.0

package/dist/chunk-LAZ2A743.js

@@ -0,0 +1,2393 @@
+import {
+  cn
+} from "./chunk-TK7G6XLT.js";
+import {
+  shouldSteerOnKey,
+  shouldSubmitOnKey
+} from "./chunk-MRSECXRP.js";
+import {
+  formatBytes,
+  formatRelativeTime
+} from "./chunk-HHFA4AFX.js";
+
+// src/commands/registry.ts
+function parseCommandLine(value) {
+  if (value[0] !== "/") {
+    return null;
+  }
+  const body = value.slice(1);
+  const firstSpace = body.indexOf(" ");
+  if (firstSpace === -1) {
+    return { name: body, rest: "", hasTrailingSpace: false, args: [] };
+  }
+  const name = body.slice(0, firstSpace);
+  const rest = body.slice(firstSpace + 1);
+  return {
+    name,
+    rest,
+    hasTrailingSpace: true,
+    args: rest.split(/\s+/).filter((token) => token.length > 0)
+  };
+}
+var PERMISSION_SUPERUSER = "workspace:admin";
+function hasPermission(required, permissions) {
+  if (!required) {
+    return true;
+  }
+  return permissions.includes(required) || permissions.includes(PERMISSION_SUPERUSER);
+}
+function matchCommand(commands, value) {
+  const parsed = parseCommandLine(value);
+  if (!parsed) {
+    return null;
+  }
+  const token = parsed.name.toLowerCase();
+  return commands.find((command) => command.name === token || command.aliases?.includes(token)) ?? null;
+}
+function filterCommands(commands, token, ctx) {
+  const needle = token.toLowerCase();
+  return commands.filter((command) => {
+    if (!hasPermission(command.permission, ctx.permissions)) {
+      return false;
+    }
+    if (command.available && !command.available(ctx)) {
+      return false;
+    }
+    if (needle.length === 0) {
+      return true;
+    }
+    return command.name.startsWith(needle) || (command.aliases?.some((alias) => alias.startsWith(needle)) ?? false);
+  });
+}
+function argHint(args) {
+  if (!args || args.length === 0) {
+    return "";
+  }
+  return args.map((arg) => {
+    const label = arg.oneOf ? arg.oneOf.join("|") : arg.name;
+    return arg.required ? `<${label}>` : `[${label}]`;
+  }).join(" ");
+}
+function firstMissingRequiredArg(command, args) {
+  const required = (command.args ?? []).filter((arg) => arg.required);
+  for (let i = 0; i < required.length; i += 1) {
+    const value = args[i];
+    if (value === void 0 || value.length === 0) {
+      return required[i] ?? null;
+    }
+  }
+  return null;
+}
+function requireSession(ctx) {
+  if (!ctx.sessionId) {
+    throw new Error("No active session yet \u2014 start a session first.");
+  }
+  return ctx.sessionId;
+}
+var hasSession = (ctx) => ctx.sessionId !== null;
+var defaultCommands = [
+  {
+    name: "help",
+    aliases: ["?"],
+    description: "Show available commands.",
+    run: (_args, ctx) => {
+      ctx.openHelp();
+      return { status: "ok" };
+    }
+  },
+  {
+    name: "clear-view",
+    description: "Clear the local timeline view (this device only; no server change).",
+    run: (_args, ctx) => {
+      const cleared = ctx.clearView();
+      if (!cleared) {
+        return {
+          status: "error",
+          message: "This view can't be cleared here (no local timeline to reset)."
+        };
+      }
+      return { status: "ok", message: "Local view cleared." };
+    }
+  },
+  {
+    name: "goal",
+    description: "Pause or resume the session's goal loop.",
+    permission: "sessions:control",
+    available: hasSession,
+    args: [
+      { name: "action", required: true, oneOf: ["pause", "resume"], description: "pause | resume" }
+    ],
+    run: async (args, ctx) => {
+      const sessionId = requireSession(ctx);
+      const action = args[0];
+      if (action !== "pause" && action !== "resume") {
+        return { status: "error", message: "Usage: /goal pause | /goal resume" };
+      }
+      try {
+        await ctx.client.updateGoal(ctx.workspaceId, sessionId, {
+          status: action === "pause" ? "paused" : "active"
+        });
+        return { status: "ok", message: action === "pause" ? "Goal paused." : "Goal resumed." };
+      } catch (cause) {
+        return { status: "error", message: goalErrorMessage(cause, action) };
+      }
+    }
+  },
+  {
+    name: "compact",
+    description: "Compact the conversation context now.",
+    permission: "sessions:control",
+    available: hasSession,
+    run: async (_args, ctx) => {
+      const sessionId = requireSession(ctx);
+      try {
+        const result = await ctx.client.compactSessionContext(ctx.workspaceId, sessionId);
+        return { status: "ok", message: result.message };
+      } catch (cause) {
+        return { status: "error", message: errorMessage(cause) ?? "Could not compact context." };
+      }
+    }
+  },
+  {
+    name: "clear",
+    description: "Clear the conversation context (destructive; audit-preserved).",
+    permission: "sessions:control",
+    danger: true,
+    available: hasSession,
+    run: async (_args, ctx) => {
+      const sessionId = requireSession(ctx);
+      const confirmed = await ctx.confirm();
+      if (!confirmed) {
+        return { status: "ok", keepDraft: true };
+      }
+      try {
+        await ctx.client.clearSessionContext(ctx.workspaceId, sessionId);
+        return { status: "ok", message: "Context cleared." };
+      } catch (cause) {
+        return { status: "error", message: clearErrorMessage(cause) };
+      }
+    }
+  }
+];
+function errorMessage(cause) {
+  if (cause && typeof cause === "object" && "message" in cause && typeof cause.message === "string") {
+    return cause.message;
+  }
+  return void 0;
+}
+function statusCode(cause) {
+  if (cause && typeof cause === "object" && "status" in cause && typeof cause.status === "number") {
+    return cause.status;
+  }
+  return void 0;
+}
+function goalErrorMessage(cause, action) {
+  const code = statusCode(cause);
+  if (code === 404) {
+    return "This session has no goal to control.";
+  }
+  if (code === 409) {
+    return action === "resume" ? "Only a paused goal can be resumed." : "Goal is already in a terminal state.";
+  }
+  return errorMessage(cause) ?? `Could not ${action} the goal.`;
+}
+function clearErrorMessage(cause) {
+  if (statusCode(cause) === 409) {
+    return "Pause the session and wait for the current inference to settle, then clear context.";
+  }
+  return errorMessage(cause) ?? "Could not clear context.";
+}
+
+// src/hooks/use-slash-commands.ts
+import { useCallback, useMemo, useRef, useState } from "react";
+function useSlashCommands(options) {
+  const { commands, context, handlers, value, setValue } = options;
+  const [highlight, setHighlight] = useState(0);
+  const [dismissedValue, setDismissedValue] = useState(null);
+  const dismissed = dismissedValue !== null && dismissedValue === value;
+  const navigatedRef = useRef(false);
+  const navTokenRef = useRef(value);
+  if (navTokenRef.current !== value) {
+    navTokenRef.current = value;
+    navigatedRef.current = false;
+  }
+  const parsed = useMemo(() => parseCommandLine(value), [value]);
+  const filterCtx = useMemo(
+    () => ({
+      sessionId: context?.sessionId ?? null,
+      status: context?.status ?? null,
+      permissions: context?.permissions ?? []
+    }),
+    [context?.sessionId, context?.status, context?.permissions]
+  );
+  const activeCommand = useMemo(() => {
+    if (!parsed || !parsed.hasTrailingSpace) {
+      return null;
+    }
+    return matchCommand(commands, value);
+  }, [commands, value, parsed]);
+  const items = useMemo(() => {
+    if (!parsed) {
+      return [];
+    }
+    if (activeCommand) {
+      return [activeCommand];
+    }
+    return filterCommands(commands, parsed.name, filterCtx);
+  }, [commands, parsed, activeCommand, filterCtx]);
+  const open = parsed !== null && items.length > 0 && !dismissed;
+  const isCommandDraft = parsed !== null && items.length > 0;
+  const clampedHighlight = items.length === 0 ? 0 : Math.min(highlight, items.length - 1);
+  const activeArgHint = activeCommand ? argHint(activeCommand.args) : "";
+  const buildContext = useCallback(
+    (command) => {
+      if (!context) {
+        return null;
+      }
+      return { ...context, ...handlers, confirm: () => handlers.confirm(command) };
+    },
+    [context, handlers]
+  );
+  const execute = useCallback(
+    async (command, args) => {
+      const ctx = buildContext(command);
+      if (!ctx) {
+        return;
+      }
+      try {
+        const result = await command.run(args, ctx);
+        if (result.message) {
+          ctx.notice({ tone: result.status === "ok" ? "ok" : "error", message: result.message });
+        }
+        if (result.status === "ok" && !result.keepDraft) {
+          setValue("");
+        }
+      } catch (cause) {
+        ctx.notice({ tone: "error", message: errorMessage2(cause) });
+      }
+    },
+    [buildContext, setValue]
+  );
+  const autocomplete = useCallback(
+    (command) => {
+      setValue(`/${command.name} `);
+      setHighlight(0);
+    },
+    [setValue]
+  );
+  const autocompleteHighlighted = useCallback(() => {
+    const command = items[clampedHighlight];
+    if (command) {
+      autocomplete(command);
+    }
+  }, [items, clampedHighlight, autocomplete]);
+  const runningRef = useRef(false);
+  const runResolved = useCallback(
+    async (command, executionOptions) => {
+      if (!parsed || runningRef.current) {
+        return;
+      }
+      runningRef.current = true;
+      try {
+        const explicit = executionOptions?.explicit ?? false;
+        const nameMatchesToken = command.name === parsed.name.toLowerCase() || (command.aliases?.includes(parsed.name.toLowerCase()) ?? false);
+        if (!explicit && !activeCommand && !nameMatchesToken && !parsed.hasTrailingSpace) {
+          autocomplete(command);
+          return;
+        }
+        const args = nameMatchesToken || parsed.hasTrailingSpace ? parsed.args : [];
+        const missing = firstMissingRequiredArg(command, args);
+        if (missing) {
+          if (!parsed.hasTrailingSpace) {
+            autocomplete(command);
+          }
+          return;
+        }
+        await execute(command, args);
+      } finally {
+        runningRef.current = false;
+      }
+    },
+    [parsed, activeCommand, autocomplete, execute]
+  );
+  const runHighlighted = useCallback(async () => {
+    if (!parsed) {
+      return;
+    }
+    if (navigatedRef.current && !activeCommand) {
+      const highlighted = items[clampedHighlight];
+      if (highlighted) {
+        await runResolved(highlighted, { explicit: true });
+      }
+      return;
+    }
+    const token = parsed.name.toLowerCase();
+    const exact = items.find((item) => item.name === token || item.aliases?.includes(token));
+    const command = activeCommand ?? exact ?? items[clampedHighlight];
+    if (!command) {
+      return;
+    }
+    await runResolved(command);
+  }, [parsed, activeCommand, items, clampedHighlight, runResolved]);
+  const runAt = useCallback(
+    async (index) => {
+      const command = items[index];
+      if (!command) {
+        return;
+      }
+      await runResolved(command, { explicit: true });
+    },
+    [items, runResolved]
+  );
+  const onKeyDown = useCallback(
+    (event) => {
+      if (!open) {
+        return false;
+      }
+      switch (event.key) {
+        case "ArrowDown": {
+          event.preventDefault();
+          navigatedRef.current = true;
+          setHighlight(
+            (current) => items.length === 0 ? 0 : (Math.min(current, items.length - 1) + 1) % items.length
+          );
+          return true;
+        }
+        case "ArrowUp": {
+          event.preventDefault();
+          navigatedRef.current = true;
+          setHighlight((current) => {
+            const base = Math.min(current, items.length - 1);
+            return items.length === 0 ? 0 : (base - 1 + items.length) % items.length;
+          });
+          return true;
+        }
+        case "Tab": {
+          event.preventDefault();
+          autocompleteHighlighted();
+          return true;
+        }
+        case "Enter": {
+          if (event.shiftKey || event.nativeEvent?.isComposing) {
+            return false;
+          }
+          event.preventDefault();
+          void runHighlighted();
+          return true;
+        }
+        case "Escape": {
+          event.preventDefault();
+          setDismissedValue(value);
+          return true;
+        }
+        default:
+          return false;
+      }
+    },
+    [open, items, autocompleteHighlighted, runHighlighted, value]
+  );
+  return {
+    open,
+    isCommandDraft,
+    items,
+    highlight: clampedHighlight,
+    setHighlight,
+    activeCommand,
+    activeArgHint,
+    onKeyDown,
+    runHighlighted,
+    runAt,
+    autocompleteHighlighted
+  };
+}
+function errorMessage2(cause) {
+  if (cause instanceof Error) {
+    return cause.message;
+  }
+  return String(cause);
+}
+
+// src/components/command-palette.tsx
+import { AnimatePresence, motion } from "motion/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function CommandPalette({
+  open,
+  items,
+  highlight,
+  onHighlight,
+  onRun,
+  argHintText,
+  listboxId,
+  label = "Slash commands",
+  dangerLabel = "danger"
+}) {
+  return /* @__PURE__ */ jsx(AnimatePresence, { children: open ? /* @__PURE__ */ jsxs(
+    motion.div,
+    {
+      initial: { opacity: 0, y: 6, scale: 0.99 },
+      animate: { opacity: 1, y: 0, scale: 1 },
+      exit: { opacity: 0, y: 6, scale: 0.99 },
+      transition: { duration: 0.13, ease: "easeOut" },
+      className: cn(
+        "absolute bottom-full left-0 right-0 z-20 mb-2 overflow-hidden",
+        "rounded-og-lg border border-og-border bg-og-surface-2 shadow-og-sm"
+      ),
+      children: [
+        /* @__PURE__ */ jsx(
+          "ul",
+          {
+            id: listboxId,
+            role: "listbox",
+            "aria-label": label,
+            className: "max-h-72 overflow-y-auto py-1",
+            children: items.map((command, index) => {
+              const selected = index === highlight;
+              const hint = argHint(command.args);
+              return /* @__PURE__ */ jsxs(
+                "li",
+                {
+                  id: `${listboxId}-option-${index}`,
+                  role: "option",
+                  "aria-selected": selected,
+                  onMouseEnter: () => onHighlight(index),
+                  onMouseDown: (event) => {
+                    event.preventDefault();
+                    onRun(index);
+                  },
+                  className: cn(
+                    "mx-1 flex cursor-pointer items-center gap-2 rounded-og-md px-2.5 py-1.5",
+                    "transition-colors duration-100",
+                    selected ? "bg-og-accent/15 text-og-fg" : "text-og-fg-muted hover:bg-og-surface-3"
+                  ),
+                  children: [
+                    /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 items-baseline gap-1.5", children: [
+                      /* @__PURE__ */ jsxs(
+                        "span",
+                        {
+                          className: cn(
+                            "font-mono text-[13px]",
+                            selected ? "text-og-accent" : "text-og-fg"
+                          ),
+                          children: [
+                            "/",
+                            command.name
+                          ]
+                        }
+                      ),
+                      hint ? /* @__PURE__ */ jsx("span", { className: "truncate font-mono text-[11px] text-og-fg-subtle", children: hint }) : null
+                    ] }),
+                    /* @__PURE__ */ jsxs("span", { className: "ml-auto flex items-center gap-1.5", children: [
+                      command.danger ? /* @__PURE__ */ jsx("span", { className: "rounded-og-xs bg-og-status-failed/15 px-1 text-[10px] uppercase tracking-wide text-og-status-failed", children: dangerLabel }) : null,
+                      /* @__PURE__ */ jsx("span", { className: "truncate text-[12px] text-og-fg-subtle max-sm:hidden", children: command.description })
+                    ] })
+                  ]
+                },
+                command.name
+              );
+            })
+          }
+        ),
+        argHintText ? /* @__PURE__ */ jsx("div", { className: "border-t border-og-border px-3 py-1.5 font-mono text-[11px] text-og-fg-subtle", children: argHintText }) : null
+      ]
+    }
+  ) : null });
+}
+
+// src/components/model-picker.tsx
+import { ChevronDownIcon } from "lucide-react";
+import { useId, useMemo as useMemo2 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ModelPicker({
+  models,
+  value,
+  onChange,
+  disabled,
+  className,
+  label = "Model"
+}) {
+  const selectId = useId();
+  const groups = useMemo2(() => {
+    const byProvider = /* @__PURE__ */ new Map();
+    for (const model of models) {
+      let group = byProvider.get(model.provider);
+      if (!group) {
+        group = { label: model.providerLabel, models: [] };
+        byProvider.set(model.provider, group);
+      }
+      group.models.push(model);
+    }
+    return [...byProvider.values()];
+  }, [models]);
+  if (models.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs2("span", { className: cn("relative inline-flex items-center", className), children: [
+    /* @__PURE__ */ jsx2("label", { htmlFor: selectId, className: "sr-only", children: label }),
+    /* @__PURE__ */ jsx2(
+      "select",
+      {
+        id: selectId,
+        value: value ?? "",
+        onChange: (event) => onChange(event.target.value),
+        disabled: disabled === true,
+        "aria-label": label,
+        className: cn(
+          // Sized like the other footer controls; the chevron overlay needs the
+          // right padding so the value never collides with it.
+          "h-8 max-w-[180px] cursor-pointer appearance-none truncate rounded-og-md bg-transparent",
+          "py-0 pl-2 pr-6 text-[13px] text-og-fg-muted",
+          "transition-colors duration-150 hover:bg-og-surface-2 hover:text-og-fg",
+          "focus:outline-none focus-visible:outline-none",
+          "disabled:cursor-not-allowed disabled:opacity-50"
+        ),
+        children: groups.map((group) => /* @__PURE__ */ jsx2("optgroup", { label: group.label, children: group.models.map((model) => /* @__PURE__ */ jsx2("option", { value: model.id, children: model.label }, model.id)) }, group.label))
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      ChevronDownIcon,
+      {
+        "aria-hidden": true,
+        className: "pointer-events-none absolute right-1.5 size-3.5 text-og-fg-subtle"
+      }
+    )
+  ] });
+}
+
+// src/components/composer.tsx
+import {
+  ArrowUpIcon,
+  ChevronDownIcon as ChevronDownIcon2,
+  FileIcon,
+  ImageIcon,
+  LoaderCircleIcon,
+  PaperclipIcon,
+  PauseIcon,
+  PlayIcon,
+  RotateCwIcon,
+  XIcon
+} from "lucide-react";
+import { AnimatePresence as AnimatePresence2, motion as motion2 } from "motion/react";
+import {
+  createContext,
+  forwardRef,
+  useCallback as useCallback2,
+  useContext,
+  useEffect,
+  useId as useId2,
+  useMemo as useMemo3,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var OPEN_WORKSTREAM_CONTROL_EVENT = "opengeni:open-workstream-control";
+var defaultChatComposerMessages = {
+  messagePlaceholder: "Message the agent\u2026",
+  pausedPlaceholder: "Sending will resume this workstream\u2026",
+  inputLabel: "Message the agent",
+  keyboardHint: "Enter to queue \xB7 Cmd/Ctrl+Enter to steer \xB7 Shift+Enter for a new line",
+  slashCommandBlocked: "That's a slash command \u2014 press Enter in the command list to run it, or edit the line to send a message.",
+  controlChangedError: "This workstream was paused while you were sending. Nothing was sent, and your draft is still here.",
+  sendFailedError: "Sending failed \u2014 your draft is still here. Try again.",
+  dropFiles: "Drop files to attach",
+  attachFiles: "Attach files",
+  pauseAriaLabel: "Pause this workstream",
+  pauseTitle: "Pause this workstream; queued prompts and approvals are preserved",
+  sendMessageAriaLabel: "Send message",
+  sendAndResumeAriaLabel: "Send and resume",
+  sendTitle: "Queue message (Enter); steer with Cmd/Ctrl+Enter",
+  sendAndResumeTitle: "Send & resume (Enter); Steer & resume with Cmd/Ctrl+Enter",
+  workspacePaused: "Workspace paused",
+  pausedHere: "Paused here",
+  parentBlocker: "parent",
+  narrowerPause: "a narrower pause",
+  pausedBy: (displayName) => `Paused by ${displayName}`,
+  queuedAhead: (count) => `Send & resume queues behind ${count} waiting prompt${count === 1 ? "" : "s"}.`,
+  resumingAndSending: "Resuming and sending\u2026",
+  nextMessageResumes: "Your next message resumes this workstream automatically.",
+  resumeThisWorkstream: "Resume this workstream",
+  resumeShort: "Resume",
+  hidePauseDetails: "Hide pause details",
+  showPauseDetails: "Show pause details",
+  pauseReasonsLabel: "Reasons this workstream is paused",
+  pausedByLabel: "Paused by ",
+  alsoPausedByLabel: "Also paused by ",
+  resumeWorkspace: "Resume workspace",
+  resumeFromSession: "Resume from this session",
+  sessionCanRun: "This session will be able to run",
+  stillPausedBy: (displayName) => `Still paused by ${displayName}`,
+  restoredResourcesLabel: "Restored prompt resources",
+  restoredFile: (fileId) => `File ${fileId.slice(0, 8)}`,
+  removeRestoredResource: (index) => `Remove restored resource ${index + 1}`,
+  uploading: "Uploading",
+  uploadFailed: "Upload failed",
+  retryAttachment: (name) => `Retry ${name}`,
+  retryUpload: "Retry upload",
+  removeAttachment: (name) => `Remove ${name}`,
+  confirmCommand: (name) => `Confirm /${name}`,
+  confirmDescription: (command) => `Run /${command.name}? ${command.description}`,
+  cancel: "Cancel",
+  runCommand: (name) => `Run /${name}`,
+  commands: "Commands",
+  slashCommandsLabel: "Slash commands",
+  modelLabel: "Model",
+  close: "Close",
+  danger: "danger",
+  draftConflict: "This draft changed in another tab. Your local draft is still here.",
+  useOtherDraft: "Use other draft",
+  keepMine: "Keep mine",
+  savingDraft: "Saving draft\u2026",
+  formatBytes,
+  formatRelativeTime
+};
+function useChatComposerController({
+  delivery,
+  draft,
+  control,
+  effectiveControl,
+  queuedAheadCount = 0,
+  canControlWorkspace = false,
+  controlLinks,
+  disabled = false,
+  attachments,
+  commands = defaultCommands,
+  commandContext,
+  onClearView,
+  onPaste,
+  messages: messageOverrides
+}) {
+  const messages = useMemo3(
+    () => ({ ...defaultChatComposerMessages, ...messageOverrides }),
+    [messageOverrides]
+  );
+  const id = useId2();
+  const rootRef = useRef2(null);
+  const textareaRef = useRef2(null);
+  const pauseButtonRef = useRef2(null);
+  const fileInputRef = useRef2(null);
+  const listboxId = useId2();
+  const paused = effectiveControl?.state === "paused";
+  const [controlDetailsOpen, setControlDetailsOpen] = useState2(false);
+  const [paletteMounted, setPaletteMounted] = useState2(false);
+  const [submitting, setSubmitting] = useState2(false);
+  const submittingRef = useRef2(false);
+  const controlOperationRef = useRef2(false);
+  const mountedRef = useRef2(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  useEffect(() => {
+    const openControl = (event) => {
+      const requestedId = event instanceof CustomEvent && isRecord(event.detail) && typeof event.detail.composerId === "string" ? event.detail.composerId : null;
+      if (requestedId && requestedId !== id) return;
+      if (!requestedId) {
+        const roots = document.querySelectorAll("[data-og-composer-id]");
+        if (roots.length > 1 && !rootRef.current?.contains(document.activeElement)) return;
+      }
+      textareaRef.current?.scrollIntoView({ block: "end", behavior: "smooth" });
+      if (paused) {
+        setControlDetailsOpen(true);
+        return;
+      }
+      window.requestAnimationFrame(() => pauseButtonRef.current?.focus());
+    };
+    document.addEventListener(OPEN_WORKSTREAM_CONTROL_EVENT, openControl);
+    return () => document.removeEventListener(OPEN_WORKSTREAM_CONTROL_EVENT, openControl);
+  }, [id, paused]);
+  const blockedByUpload = attachments?.uploading === true;
+  const hasReadyAttachment = (attachments?.readyResources.length ?? 0) > 0;
+  const [dragging, setDragging] = useState2(false);
+  const dragCarriesFiles = (event) => event.dataTransfer !== null && [...event.dataTransfer.types].includes("Files");
+  const handleDragOver = useCallback2(
+    (event) => {
+      if (!attachments || !dragCarriesFiles(event)) return;
+      event.preventDefault();
+      setDragging(true);
+    },
+    [attachments]
+  );
+  const handleDragLeave = useCallback2(
+    (event) => {
+      if (!attachments) return;
+      if (event.currentTarget.contains(event.relatedTarget)) return;
+      setDragging(false);
+    },
+    [attachments]
+  );
+  const handleDrop = useCallback2(
+    (event) => {
+      if (!attachments || !dragCarriesFiles(event)) return;
+      event.preventDefault();
+      setDragging(false);
+      if (event.dataTransfer.files.length > 0) attachments.addFiles(event.dataTransfer.files);
+    },
+    [attachments]
+  );
+  const [notice, setNotice] = useState2(null);
+  const [helpOpen, setHelpOpen] = useState2(false);
+  const [confirmState, setConfirmState] = useState2(null);
+  const pendingConfirm = useRef2(null);
+  const settleConfirmation = useCallback2((confirmed) => {
+    const resolve = pendingConfirm.current;
+    pendingConfirm.current = null;
+    setConfirmState(null);
+    resolve?.(confirmed);
+  }, []);
+  useEffect(
+    () => () => {
+      pendingConfirm.current?.(false);
+      pendingConfirm.current = null;
+    },
+    []
+  );
+  const resizeInput = useCallback2(() => {
+    const textarea = textareaRef.current;
+    if (!textarea) return;
+    textarea.style.height = "0px";
+    textarea.style.height = `${Math.min(textarea.scrollHeight, 220)}px`;
+  }, []);
+  useEffect(() => resizeInput(), [delivery.value, resizeInput]);
+  const handlers = useMemo3(
+    () => ({
+      notice: (next) => {
+        setNotice(next);
+        delivery.clearError();
+      },
+      openHelp: () => setHelpOpen(true),
+      clearView: () => {
+        if (!onClearView) return false;
+        onClearView();
+        return true;
+      },
+      confirm: (command) => new Promise((resolve) => {
+        pendingConfirm.current?.(false);
+        pendingConfirm.current = resolve;
+        setConfirmState({ command, resolve: settleConfirmation });
+      })
+    }),
+    [delivery, onClearView, settleConfirmation]
+  );
+  const palette = useSlashCommands({
+    commands,
+    context: commandContext,
+    handlers,
+    value: delivery.value,
+    setValue: delivery.setValue
+  });
+  const paletteEnabled = commandContext !== void 0;
+  const commandDraftBlocked = paletteEnabled && palette.isCommandDraft;
+  const submitBlocker = disabled ? "disabled" : blockedByUpload ? "uploading" : delivery.sending || submitting ? "sending" : commandDraftBlocked ? "command" : delivery.canSend || hasReadyAttachment ? null : "empty";
+  const canSubmit = submitBlocker === null;
+  const submit = useCallback2(
+    async (mode) => {
+      if (commandDraftBlocked) {
+        setNotice({ tone: "error", message: messages.slashCommandBlocked });
+        delivery.clearError();
+        return false;
+      }
+      if (disabled || blockedByUpload || delivery.sending || submittingRef.current) return false;
+      if (!delivery.canSend && !hasReadyAttachment) return false;
+      submittingRef.current = true;
+      setSubmitting(true);
+      try {
+        return mode === "steer" ? await delivery.steer() : await delivery.send();
+      } finally {
+        submittingRef.current = false;
+        if (mountedRef.current) setSubmitting(false);
+      }
+    },
+    [
+      blockedByUpload,
+      commandDraftBlocked,
+      delivery,
+      disabled,
+      hasReadyAttachment,
+      messages.slashCommandBlocked
+    ]
+  );
+  const handleKeyDown = useCallback2(
+    (event) => {
+      if (paletteEnabled && paletteMounted && palette.onKeyDown(event)) return;
+      if (!shouldSubmitOnKey(event)) return;
+      event.preventDefault();
+      void submit(shouldSteerOnKey(event) ? "steer" : "queue");
+    },
+    [palette, paletteEnabled, paletteMounted, submit]
+  );
+  const handlePaste = useCallback2(
+    (event) => {
+      onPaste?.(event);
+      attachments?.addFromPaste(event);
+    },
+    [attachments, onPaste]
+  );
+  const handleFileChange = useCallback2(
+    (event) => {
+      if (event.target.files) attachments?.addFiles(event.target.files);
+      event.target.value = "";
+    },
+    [attachments]
+  );
+  const helpCommands = useMemo3(
+    () => commands.filter((command) => {
+      if (command.permission && commandContext) {
+        const permissions = commandContext.permissions;
+        return permissions.includes(command.permission) || permissions.includes("workspace:admin");
+      }
+      return true;
+    }),
+    [commandContext, commands]
+  );
+  const activeNotice = notice ?? (delivery.error ? {
+    tone: "error",
+    message: /control changed|paused while/i.test(delivery.error.message) ? messages.controlChangedError : delivery.error.message || messages.sendFailedError
+  } : null);
+  useEffect(() => {
+    if (notice?.tone !== "ok") return;
+    const timer = window.setTimeout(
+      () => setNotice((current) => current === notice ? null : current),
+      2400
+    );
+    return () => window.clearTimeout(timer);
+  }, [notice]);
+  const runControlOperation = useCallback2(async (operation) => {
+    if (controlOperationRef.current) return false;
+    controlOperationRef.current = true;
+    try {
+      await operation();
+      return true;
+    } finally {
+      controlOperationRef.current = false;
+    }
+  }, []);
+  const pause = useCallback2(
+    async (reason) => {
+      if (!control || control.pausing || control.resuming) return false;
+      return await runControlOperation(() => control.pause(reason));
+    },
+    [control, runControlOperation]
+  );
+  const resume = useCallback2(
+    async (reason) => {
+      if (!control || control.pausing || control.resuming) return false;
+      return await runControlOperation(() => control.resume(reason));
+    },
+    [control, runControlOperation]
+  );
+  const resumeScope = useCallback2(
+    async (option) => {
+      if (!control || control.pausing || control.resuming) return false;
+      return await runControlOperation(() => control.resumeScope(option));
+    },
+    [control, runControlOperation]
+  );
+  return {
+    id,
+    rootRef,
+    textareaRef,
+    pauseButtonRef,
+    fileInputRef,
+    listboxId,
+    effectiveControl,
+    queuedAheadCount,
+    canControlWorkspace,
+    controlLinks,
+    disabled,
+    attachments,
+    messages,
+    sending: delivery.sending || submitting,
+    error: delivery.error,
+    clearError: delivery.clearError,
+    hasDraftState: draft !== void 0,
+    draftConflict: draft?.draftConflict ?? null,
+    draftSaving: draft?.draftSaving ?? false,
+    restoredResources: draft?.restoredResources ?? [],
+    removeRestoredResource: draft?.removeRestoredResource,
+    resolveDraftConflict: draft?.resolveDraftConflict,
+    hasControl: control !== void 0,
+    pausing: control?.pausing ?? false,
+    resuming: control?.resuming ?? false,
+    pause,
+    resume,
+    resumeScope,
+    paused,
+    controlDetailsOpen,
+    setControlDetailsOpen,
+    paletteMounted,
+    setPaletteMounted,
+    dragging,
+    handleDragOver,
+    handleDragLeave,
+    handleDrop,
+    palette,
+    paletteEnabled,
+    commandDraftBlocked,
+    confirmState,
+    settleConfirmation,
+    helpOpen,
+    setHelpOpen,
+    helpCommands,
+    activeNotice,
+    canSubmit,
+    submitBlocker,
+    submit,
+    handleKeyDown,
+    handlePaste,
+    handleFileChange,
+    focusInput: () => textareaRef.current?.focus(),
+    setValue: delivery.setValue,
+    value: delivery.value
+  };
+}
+var ComposerContext = createContext(null);
+function useComposerController() {
+  const controller = useContext(ComposerContext);
+  if (!controller) throw new Error("useChatComposer must be used inside <Composer.Root>");
+  return controller;
+}
+function useChatComposer() {
+  return useComposerController();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+var Root = forwardRef(function ComposerRoot({ controller, children, className, style, ...props }, forwardedRef) {
+  return /* @__PURE__ */ jsx3(ComposerContext.Provider, { value: controller, children: /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      ...props,
+      ref: mergeRefs(controller.rootRef, forwardedRef),
+      "data-og-composer-id": controller.id,
+      className: cn("og-root", className),
+      style: { paddingBottom: "env(safe-area-inset-bottom)", ...style },
+      children: [
+        children,
+        /* @__PURE__ */ jsx3(ComposerAnnouncements, {})
+      ]
+    }
+  ) });
+});
+var Frame = forwardRef(function ComposerFrame({ className, ...props }, ref) {
+  return /* @__PURE__ */ jsx3("div", { ...props, ref, className: cn("relative", className) });
+});
+function CommandPalette2({ className }) {
+  const controller = useComposerController();
+  const setPaletteMounted = controller.setPaletteMounted;
+  useEffect(() => {
+    setPaletteMounted(true);
+    return () => setPaletteMounted(false);
+  }, [setPaletteMounted]);
+  if (!controller.paletteEnabled) return null;
+  return /* @__PURE__ */ jsx3("div", { className, children: /* @__PURE__ */ jsx3(
+    CommandPalette,
+    {
+      open: controller.palette.open && controller.confirmState === null,
+      items: controller.palette.items,
+      highlight: controller.palette.highlight,
+      onHighlight: controller.palette.setHighlight,
+      onRun: (index) => {
+        controller.palette.setHighlight(index);
+        void controller.palette.runAt(index);
+      },
+      argHintText: controller.palette.activeArgHint,
+      listboxId: controller.listboxId,
+      label: controller.messages.slashCommandsLabel,
+      dangerLabel: controller.messages.danger
+    }
+  ) });
+}
+var Surface = forwardRef(function ComposerSurface({ className, children, ...props }, ref) {
+  const controller = useComposerController();
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      ...props,
+      ref,
+      onDragOver: controller.attachments ? controller.handleDragOver : void 0,
+      onDragLeave: controller.attachments ? controller.handleDragLeave : void 0,
+      onDrop: controller.attachments ? controller.handleDrop : void 0,
+      className: cn(
+        "relative rounded-og-lg border border-og-border bg-og-surface-1 shadow-og-sm",
+        "transition-[border-color,box-shadow] duration-200",
+        "focus-within:border-og-accent/60 focus-within:shadow-og-glow",
+        controller.dragging && "border-dashed border-og-accent",
+        className
+      ),
+      children: [
+        controller.dragging ? /* @__PURE__ */ jsx3(
+          "div",
+          {
+            "aria-hidden": true,
+            className: cn(
+              "pointer-events-none absolute inset-0 z-10 flex items-center justify-center",
+              "rounded-og-lg bg-og-surface-1/85 text-sm font-medium text-og-accent backdrop-blur-[1px]"
+            ),
+            children: /* @__PURE__ */ jsxs3("span", { className: "inline-flex items-center gap-2", children: [
+              /* @__PURE__ */ jsx3(PaperclipIcon, { className: "size-4" }),
+              controller.messages.dropFiles
+            ] })
+          }
+        ) : null,
+        children
+      ]
+    }
+  );
+});
+function PausedState() {
+  const controller = useComposerController();
+  if (!controller.paused || !controller.effectiveControl || !controller.hasControl) return null;
+  return /* @__PURE__ */ jsx3(
+    WorkstreamPausedStrip,
+    {
+      control: controller.effectiveControl,
+      queuedAheadCount: controller.queuedAheadCount,
+      open: controller.controlDetailsOpen,
+      busy: controller.resuming,
+      sending: controller.sending,
+      canControlWorkspace: controller.canControlWorkspace,
+      controlLinks: controller.controlLinks,
+      messages: controller.messages,
+      onOpenChange: controller.setControlDetailsOpen,
+      onResume: () => void controller.resume(),
+      onResumeOption: (option) => void controller.resumeScope(option)
+    }
+  );
+}
+function RestoredResources() {
+  const controller = useComposerController();
+  if (controller.restoredResources.length === 0 || !controller.removeRestoredResource) return null;
+  return /* @__PURE__ */ jsx3(
+    RestoredResourceChips,
+    {
+      resources: controller.restoredResources,
+      messages: controller.messages,
+      onRemove: controller.removeRestoredResource
+    }
+  );
+}
+function Attachments() {
+  const controller = useComposerController();
+  if (!controller.attachments || controller.attachments.attachments.length === 0) return null;
+  return /* @__PURE__ */ jsx3(
+    AttachmentChips,
+    {
+      attachments: controller.attachments.attachments,
+      messages: controller.messages,
+      onRemove: controller.attachments.remove,
+      onRetry: controller.attachments.retry
+    }
+  );
+}
+var Input = forwardRef(function ComposerInput({ rows = 1, placeholder, className, "aria-label": ariaLabel, ...props }, forwardedRef) {
+  const controller = useComposerController();
+  const paletteOpen = controller.paletteEnabled && controller.paletteMounted && controller.palette.open;
+  return /* @__PURE__ */ jsx3(
+    "textarea",
+    {
+      ...props,
+      ref: mergeRefs(controller.textareaRef, forwardedRef),
+      rows,
+      value: controller.value,
+      onChange: (event) => controller.setValue(event.target.value),
+      onKeyDown: controller.handleKeyDown,
+      onPaste: controller.handlePaste,
+      placeholder: controller.paused && !controller.disabled ? controller.messages.pausedPlaceholder : placeholder ?? controller.messages.messagePlaceholder,
+      disabled: controller.disabled,
+      "aria-label": ariaLabel ?? controller.messages.inputLabel,
+      "aria-keyshortcuts": "Enter Meta+Enter Control+Enter Shift+Enter",
+      "aria-autocomplete": controller.paletteEnabled && controller.paletteMounted ? "list" : void 0,
+      "aria-controls": paletteOpen ? controller.listboxId : void 0,
+      "aria-activedescendant": paletteOpen ? `${controller.listboxId}-option-${controller.palette.highlight}` : void 0,
+      className: cn(
+        "block w-full resize-none bg-transparent px-4 pt-3.5 pb-1 text-base leading-6 md:text-og-md",
+        "text-og-fg placeholder:text-og-fg-subtle focus:outline-none focus-visible:outline-none",
+        "disabled:cursor-not-allowed disabled:opacity-60",
+        className
+      )
+    }
+  );
+});
+function Confirmation() {
+  const controller = useComposerController();
+  const command = controller.confirmState?.command;
+  if (!command || !controller.confirmState) return null;
+  return /* @__PURE__ */ jsx3(
+    ConfirmBar,
+    {
+      command,
+      messages: controller.messages,
+      onCancel: () => controller.settleConfirmation(false),
+      onConfirm: () => controller.settleConfirmation(true),
+      returnFocusRef: controller.textareaRef
+    }
+  );
+}
+var Footer = forwardRef(function ComposerFooter({ className, ...props }, ref) {
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ...props,
+      ref,
+      className: cn("flex items-end gap-2 px-2.5 pb-2.5 pt-1", className)
+    }
+  );
+});
+var Controls = forwardRef(
+  function ComposerControls({ className, ...props }, ref) {
+    return /* @__PURE__ */ jsx3(
+      "span",
+      {
+        ...props,
+        ref,
+        className: cn("flex min-w-0 flex-1 flex-wrap items-center gap-1.5", className)
+      }
+    );
+  }
+);
+var Hint = forwardRef(function ComposerHint({ className, children, ...props }, ref) {
+  const controller = useComposerController();
+  return /* @__PURE__ */ jsx3(
+    "span",
+    {
+      ...props,
+      ref,
+      className: cn("min-w-0 flex-1 px-1.5 text-og-xs text-og-fg-subtle max-sm:hidden", className),
+      children: children ?? controller.messages.keyboardHint
+    }
+  );
+});
+var Actions = forwardRef(function ComposerActions({ className, ...props }, ref) {
+  return /* @__PURE__ */ jsx3(
+    "span",
+    {
+      ...props,
+      ref,
+      className: cn("ml-auto flex shrink-0 items-center gap-1.5", className)
+    }
+  );
+});
+var AttachButton = forwardRef(
+  function ComposerAttachButton({ accept, multiple = true, className, "aria-label": ariaLabel, title, children, ...props }, ref) {
+    const controller = useComposerController();
+    if (!controller.attachments) return null;
+    return /* @__PURE__ */ jsxs3(Fragment, { children: [
+      /* @__PURE__ */ jsx3(
+        "input",
+        {
+          ref: controller.fileInputRef,
+          type: "file",
+          accept,
+          multiple,
+          className: "hidden",
+          onChange: controller.handleFileChange
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          ...props,
+          ref,
+          type: "button",
+          disabled: controller.disabled,
+          onClick: () => controller.fileInputRef.current?.click(),
+          "aria-label": ariaLabel ?? controller.messages.attachFiles,
+          title: title ?? controller.messages.attachFiles,
+          className: cn(
+            "inline-flex size-8 items-center justify-center rounded-og-md",
+            "text-og-fg-muted transition-colors duration-150 hover:bg-og-surface-2 hover:text-og-fg",
+            "disabled:cursor-not-allowed disabled:opacity-50 pointer-coarse:size-11",
+            className
+          ),
+          children: children ?? /* @__PURE__ */ jsx3(PaperclipIcon, { className: "size-4" })
+        }
+      )
+    ] });
+  }
+);
+function ModelPicker2({
+  models,
+  value,
+  onChange,
+  label,
+  className
+}) {
+  const controller = useComposerController();
+  return /* @__PURE__ */ jsx3(
+    ModelPicker,
+    {
+      models,
+      value,
+      onChange: (modelId) => onChange?.(modelId),
+      disabled: controller.disabled,
+      label: label ?? controller.messages.modelLabel,
+      className
+    }
+  );
+}
+var PauseButton = forwardRef(
+  function ComposerPauseButton({ className, "aria-label": ariaLabel, title, children, ...props }, ref) {
+    const controller = useComposerController();
+    if (!controller.effectiveControl || controller.paused || !controller.hasControl) return null;
+    const busy = controller.pausing || controller.resuming;
+    return /* @__PURE__ */ jsx3(
+      "button",
+      {
+        ...props,
+        ref: mergeRefs(controller.pauseButtonRef, ref),
+        type: "button",
+        onClick: () => void controller.pause(),
+        disabled: busy,
+        "aria-label": ariaLabel ?? controller.messages.pauseAriaLabel,
+        title: title ?? controller.messages.pauseTitle,
+        className: cn(
+          "inline-flex size-8 items-center justify-center rounded-og-md border border-og-border pointer-coarse:size-11",
+          "bg-og-surface-2 text-og-fg-muted transition-colors duration-150",
+          "hover:border-og-status-waiting/50 hover:text-og-status-waiting",
+          "disabled:opacity-50",
+          className
+        ),
+        children: children ?? (busy ? /* @__PURE__ */ jsx3(LoaderCircleIcon, { className: "size-3.5 animate-og-spin" }) : /* @__PURE__ */ jsx3(PauseIcon, { className: "size-3.5 fill-current" }))
+      }
+    );
+  }
+);
+var SendButton = forwardRef(
+  function ComposerSendButton({ className, "aria-label": ariaLabel, title, children, ...props }, ref) {
+    const controller = useComposerController();
+    return /* @__PURE__ */ jsx3(
+      "button",
+      {
+        ...props,
+        ref,
+        type: "button",
+        onClick: () => void controller.submit("queue"),
+        disabled: !controller.canSubmit,
+        "aria-label": ariaLabel ?? (controller.paused ? controller.messages.sendAndResumeAriaLabel : controller.messages.sendMessageAriaLabel),
+        title: title ?? (controller.paused ? controller.messages.sendAndResumeTitle : controller.messages.sendTitle),
+        className: cn(
+          "inline-flex size-8 items-center justify-center rounded-og-md pointer-coarse:size-11",
+          "bg-og-accent text-og-accent-fg shadow-og-sm",
+          "transition-[background-color,transform,opacity] duration-150 ease-og-spring",
+          "hover:bg-og-accent-strong active:scale-95",
+          "disabled:cursor-not-allowed disabled:bg-og-surface-3 disabled:text-og-fg-subtle disabled:shadow-none",
+          className
+        ),
+        children: children ?? (controller.sending ? /* @__PURE__ */ jsx3(LoaderCircleIcon, { className: "size-4 animate-og-spin" }) : /* @__PURE__ */ jsx3(ArrowUpIcon, { className: "size-4" }))
+      }
+    );
+  }
+);
+function Help() {
+  const controller = useComposerController();
+  return /* @__PURE__ */ jsx3(AnimatePresence2, { children: controller.helpOpen ? /* @__PURE__ */ jsx3(
+    HelpPanel,
+    {
+      commands: controller.helpCommands,
+      messages: controller.messages,
+      onClose: () => controller.setHelpOpen(false)
+    }
+  ) : null });
+}
+function Status() {
+  const controller = useComposerController();
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx3(AnimatePresence2, { children: controller.activeNotice ? /* @__PURE__ */ jsx3(
+      motion2.p,
+      {
+        initial: { opacity: 0, height: 0 },
+        animate: { opacity: 1, height: "auto" },
+        exit: { opacity: 0, height: 0 },
+        className: cn(
+          "overflow-hidden px-1 pt-1.5 text-xs",
+          controller.activeNotice.tone === "ok" ? "text-og-fg-muted" : "text-og-status-failed"
+        ),
+        children: controller.activeNotice.message
+      }
+    ) : null }),
+    controller.draftConflict ? /* @__PURE__ */ jsxs3("div", { className: "mt-1.5 flex flex-wrap items-center gap-2 px-1 text-og-xs text-og-status-failed", children: [
+      /* @__PURE__ */ jsx3("span", { className: "min-w-0 flex-1", children: controller.messages.draftConflict }),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          className: "underline underline-offset-2",
+          onClick: () => void controller.resolveDraftConflict?.("use_remote"),
+          children: controller.messages.useOtherDraft
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          className: "font-medium underline underline-offset-2",
+          onClick: () => void controller.resolveDraftConflict?.("keep_mine"),
+          children: controller.messages.keepMine
+        }
+      )
+    ] }) : controller.draftSaving ? /* @__PURE__ */ jsx3("p", { className: "px-1 pt-1 text-og-xs text-og-fg-subtle", children: controller.messages.savingDraft }) : null
+  ] });
+}
+function ComposerAnnouncements() {
+  const controller = useComposerController();
+  return /* @__PURE__ */ jsxs3("div", { className: "sr-only", children: [
+    controller.activeNotice ? /* @__PURE__ */ jsx3("p", { role: controller.activeNotice.tone === "error" ? "alert" : "status", children: controller.activeNotice.message }) : null,
+    controller.draftConflict ? /* @__PURE__ */ jsx3("p", { role: "alert", children: controller.messages.draftConflict }) : controller.draftSaving ? /* @__PURE__ */ jsx3("p", { role: "status", children: controller.messages.savingDraft }) : null
+  ] });
+}
+function mergeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    }
+  };
+}
+function WorkstreamPausedStrip({
+  control,
+  queuedAheadCount,
+  open,
+  busy,
+  sending,
+  canControlWorkspace,
+  controlLinks,
+  messages,
+  onOpenChange,
+  onResume,
+  onResumeOption
+}) {
+  const blocker = control.primaryBlocker;
+  const cause = blocker?.kind === "workspace" ? messages.workspacePaused : control.directState === "paused" ? messages.pausedHere : messages.pausedBy(blocker?.displayName ?? messages.parentBlocker);
+  const primary = control.resumeOptions.find((option) => option.scope === "selected");
+  const broaderOptions = control.resumeOptions.filter(
+    (option) => option !== primary && option.scope !== "selected" && (option.scope !== "workspace" || canControlWorkspace)
+  );
+  return /* @__PURE__ */ jsxs3("div", { className: "border-b border-og-status-waiting/25 bg-og-status-waiting/[0.07]", children: [
+    /* @__PURE__ */ jsxs3("div", { className: "flex min-w-0 items-center gap-2 px-3 py-2", children: [
+      /* @__PURE__ */ jsx3(PauseIcon, { className: "size-3.5 shrink-0 text-og-status-waiting" }),
+      /* @__PURE__ */ jsxs3(
+        "button",
+        {
+          type: "button",
+          className: "min-w-0 flex-1 text-left",
+          onClick: () => onOpenChange(!open),
+          "aria-expanded": open,
+          children: [
+            /* @__PURE__ */ jsx3("span", { className: "block truncate text-og-xs font-medium text-og-fg", children: cause }),
+            /* @__PURE__ */ jsx3("span", { className: "block truncate text-[11px] text-og-fg-muted", children: queuedAheadCount > 0 ? messages.queuedAhead(queuedAheadCount) : sending ? messages.resumingAndSending : messages.nextMessageResumes })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs3(
+        "button",
+        {
+          type: "button",
+          "aria-label": messages.resumeThisWorkstream,
+          className: "inline-flex min-h-8 shrink-0 items-center gap-1.5 rounded-og-md border border-og-status-waiting/35 bg-og-surface-1 px-2.5 text-og-xs font-medium text-og-fg hover:bg-og-surface-2 pointer-coarse:min-h-11",
+          disabled: busy,
+          onClick: onResume,
+          children: [
+            busy ? /* @__PURE__ */ jsx3(LoaderCircleIcon, { className: "size-3.5 animate-og-spin" }) : /* @__PURE__ */ jsx3(PlayIcon, { className: "size-3.5 fill-current" }),
+            /* @__PURE__ */ jsx3("span", { className: "hidden min-[400px]:inline", children: messages.resumeThisWorkstream }),
+            /* @__PURE__ */ jsx3("span", { className: "min-[400px]:hidden", children: messages.resumeShort })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          className: "inline-flex size-8 shrink-0 items-center justify-center rounded-og-md text-og-fg-muted hover:bg-og-surface-2 pointer-coarse:size-11",
+          onClick: () => onOpenChange(!open),
+          "aria-label": open ? messages.hidePauseDetails : messages.showPauseDetails,
+          children: /* @__PURE__ */ jsx3(ChevronDownIcon2, { className: cn("size-3.5 transition-transform", open && "rotate-180") })
+        }
+      )
+    ] }),
+    open ? /* @__PURE__ */ jsxs3("div", { className: "border-t border-og-status-waiting/20 px-3 pb-3 pt-2", children: [
+      /* @__PURE__ */ jsx3("ul", { className: "grid gap-2", "aria-label": messages.pauseReasonsLabel, children: control.blockers.map((entry, index) => /* @__PURE__ */ jsxs3(
+        "li",
+        {
+          className: "text-og-xs",
+          children: [
+            /* @__PURE__ */ jsx3("span", { className: "font-medium text-og-fg", children: index === 0 ? messages.pausedByLabel : messages.alsoPausedByLabel }),
+            blockerHref(entry, controlLinks) ? /* @__PURE__ */ jsx3(
+              "a",
+              {
+                href: blockerHref(entry, controlLinks),
+                className: "font-medium text-og-fg underline decoration-og-border-strong underline-offset-2 hover:text-og-accent focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-og-ring/40",
+                children: entry.displayName
+              }
+            ) : /* @__PURE__ */ jsx3("span", { className: "font-medium text-og-fg", children: entry.displayName }),
+            entry.reason ? /* @__PURE__ */ jsxs3("span", { className: "text-og-fg-muted", children: [
+              " \xB7 ",
+              entry.reason
+            ] }) : null,
+            entry.actor ? /* @__PURE__ */ jsxs3("span", { className: "text-og-fg-subtle", children: [
+              " \xB7 ",
+              entry.actor
+            ] }) : null,
+            entry.changedAt ? /* @__PURE__ */ jsxs3("span", { className: "text-og-fg-subtle", children: [
+              " ",
+              "\xB7 ",
+              messages.formatRelativeTime(entry.changedAt)
+            ] }) : null
+          ]
+        },
+        `${entry.kind}-${entry.sessionId ?? "workspace"}-${entry.revision}`
+      )) }),
+      broaderOptions.length > 0 ? /* @__PURE__ */ jsx3("div", { className: "mt-2 flex flex-wrap gap-1.5", children: broaderOptions.map((option) => /* @__PURE__ */ jsxs3(
+        "button",
+        {
+          type: "button",
+          disabled: busy,
+          title: option.impactCopy,
+          onClick: () => onResumeOption(option),
+          className: "rounded-og-md border border-og-border bg-og-surface-1 px-2 py-1 text-og-xs text-og-fg-muted hover:bg-og-surface-2 hover:text-og-fg pointer-coarse:min-h-10",
+          children: [
+            /* @__PURE__ */ jsx3("span", { className: "block font-medium", children: option.scope === "workspace" ? messages.resumeWorkspace : messages.resumeFromSession }),
+            /* @__PURE__ */ jsx3("span", { className: "block text-[10px] text-og-fg-subtle", children: option.selectedStateAfter === "active" ? messages.sessionCanRun : messages.stillPausedBy(
+              option.remainingPrimaryBlocker?.displayName ?? messages.narrowerPause
+            ) })
+          ]
+        },
+        `${option.scope}-${option.targetId ?? "selected"}`
+      )) }) : null
+    ] }) : null
+  ] });
+}
+function blockerHref(blocker, links) {
+  if (blocker.kind === "workspace") return links?.workspaceHref;
+  return blocker.sessionId ? links?.sessionHref?.(blocker.sessionId) : void 0;
+}
+function RestoredResourceChips({
+  resources,
+  messages,
+  onRemove
+}) {
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      className: "flex flex-wrap gap-1.5 border-b border-og-border px-3 py-2",
+      "aria-label": messages.restoredResourcesLabel,
+      children: resources.map((resource, index) => /* @__PURE__ */ jsxs3(
+        "span",
+        {
+          className: "inline-flex min-w-0 max-w-full items-center gap-1.5 rounded-og-md border border-og-border bg-og-surface-2 px-2 py-1 text-og-xs text-og-fg-muted",
+          children: [
+            /* @__PURE__ */ jsx3(FileIcon, { className: "size-3 shrink-0" }),
+            /* @__PURE__ */ jsx3("span", { className: "truncate", children: resource.kind === "file" ? messages.restoredFile(resource.fileId) : resource.uri }),
+            /* @__PURE__ */ jsx3(
+              "button",
+              {
+                type: "button",
+                className: "shrink-0 hover:text-og-fg",
+                onClick: () => onRemove(index),
+                "aria-label": messages.removeRestoredResource(index),
+                children: /* @__PURE__ */ jsx3(XIcon, { className: "size-3" })
+              }
+            )
+          ]
+        },
+        `${resource.kind}-${resource.kind === "file" ? resource.fileId : resource.uri}`
+      ))
+    }
+  );
+}
+function ConfirmBar({
+  command,
+  messages,
+  onCancel,
+  onConfirm,
+  returnFocusRef
+}) {
+  const confirmRef = useRef2(null);
+  const descriptionId = useId2();
+  useEffect(() => {
+    const returnTo = returnFocusRef?.current ?? null;
+    confirmRef.current?.focus();
+    return () => returnTo?.focus();
+  }, [returnFocusRef]);
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      role: "alertdialog",
+      "aria-label": messages.confirmCommand(command.name),
+      "aria-describedby": descriptionId,
+      "data-testid": "danger-confirm",
+      onKeyDown: (event) => {
+        if (event.key === "Escape") {
+          event.preventDefault();
+          event.stopPropagation();
+          onCancel();
+        }
+      },
+      className: "flex items-end justify-between gap-2 px-2.5 pb-2.5 pt-1",
+      children: [
+        /* @__PURE__ */ jsx3("span", { id: descriptionId, className: "min-w-0 flex-1 px-1.5 text-og-sm text-og-status-failed", children: messages.confirmDescription(command) }),
+        /* @__PURE__ */ jsxs3("span", { className: "flex shrink-0 items-center gap-1.5", children: [
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              onClick: onCancel,
+              className: "rounded-og-md border border-og-border bg-og-surface-2 px-2.5 py-1 text-og-sm text-og-fg-muted hover:bg-og-surface-3 pointer-coarse:min-h-11",
+              children: messages.cancel
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              ref: confirmRef,
+              type: "button",
+              onClick: onConfirm,
+              className: "rounded-og-md border border-og-status-failed/50 bg-og-status-failed/15 px-2.5 py-1 text-og-sm text-og-status-failed hover:bg-og-status-failed/25 pointer-coarse:min-h-11",
+              children: messages.runCommand(command.name)
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function AttachmentChips({
+  attachments,
+  messages,
+  onRemove,
+  onRetry
+}) {
+  return /* @__PURE__ */ jsx3("div", { className: "flex flex-wrap gap-2 border-b border-og-border px-3 py-2", children: attachments.map((attachment) => {
+    const failed = attachment.status === "failed";
+    const statusText = attachment.status === "uploading" ? messages.uploading : failed ? attachment.error || messages.uploadFailed : messages.formatBytes(attachment.sizeBytes);
+    return /* @__PURE__ */ jsxs3(
+      "div",
+      {
+        className: cn(
+          "flex min-w-0 max-w-[240px] items-center gap-2 rounded-og-md border px-2 py-1.5 text-og-sm",
+          failed ? "border-og-status-failed/40 bg-og-status-failed/10" : "border-og-border bg-og-surface-2"
+        ),
+        children: [
+          attachment.previewUrl ? /* @__PURE__ */ jsx3(
+            "img",
+            {
+              src: attachment.previewUrl,
+              alt: "",
+              className: "size-8 shrink-0 rounded object-cover"
+            }
+          ) : attachment.contentType.startsWith("image/") ? /* @__PURE__ */ jsx3(ImageIcon, { className: "size-4 shrink-0 text-og-fg-muted" }) : /* @__PURE__ */ jsx3(FileIcon, { className: "size-4 shrink-0 text-og-fg-muted" }),
+          /* @__PURE__ */ jsxs3("div", { className: "min-w-0 flex-1", children: [
+            /* @__PURE__ */ jsx3("div", { className: "truncate font-medium text-og-fg", children: attachment.name }),
+            /* @__PURE__ */ jsx3(
+              "div",
+              {
+                className: cn(
+                  "truncate text-og-xs",
+                  failed ? "text-og-status-failed" : "text-og-fg-subtle"
+                ),
+                title: failed ? statusText : void 0,
+                children: statusText
+              }
+            )
+          ] }),
+          attachment.status === "uploading" ? /* @__PURE__ */ jsx3(LoaderCircleIcon, { className: "size-3.5 shrink-0 animate-og-spin" }) : null,
+          failed && onRetry ? /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              onClick: () => onRetry(attachment.id),
+              className: "shrink-0 rounded-og-xs p-1 text-og-fg-muted hover:bg-og-surface-1 hover:text-og-fg pointer-coarse:size-10",
+              "aria-label": messages.retryAttachment(attachment.name),
+              title: messages.retryUpload,
+              children: /* @__PURE__ */ jsx3(RotateCwIcon, { className: "size-3.5" })
+            }
+          ) : null,
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              onClick: () => onRemove(attachment.id),
+              className: "shrink-0 rounded-og-xs p-1 text-og-fg-muted hover:bg-og-surface-1 hover:text-og-fg pointer-coarse:size-10",
+              "aria-label": messages.removeAttachment(attachment.name),
+              children: /* @__PURE__ */ jsx3(XIcon, { className: "size-3.5" })
+            }
+          )
+        ]
+      },
+      attachment.id
+    );
+  }) });
+}
+function HelpPanel({
+  commands,
+  messages,
+  onClose
+}) {
+  return /* @__PURE__ */ jsxs3(
+    motion2.div,
+    {
+      initial: { opacity: 0, height: 0 },
+      animate: { opacity: 1, height: "auto" },
+      exit: { opacity: 0, height: 0 },
+      className: "mt-2 overflow-hidden rounded-og-lg border border-og-border bg-og-surface-2",
+      children: [
+        /* @__PURE__ */ jsxs3("div", { className: "flex items-center justify-between border-b border-og-border px-3 py-1.5", children: [
+          /* @__PURE__ */ jsx3("span", { className: "text-og-sm font-medium text-og-fg", children: messages.commands }),
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              onClick: onClose,
+              className: "text-og-xs text-og-fg-subtle hover:text-og-fg",
+              children: messages.close
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx3("ul", { className: "py-1", children: commands.map((command) => {
+          const hint = argHint(command.args);
+          return /* @__PURE__ */ jsxs3("li", { className: "flex items-baseline gap-2 px-3 py-1", children: [
+            /* @__PURE__ */ jsxs3("span", { className: "font-mono text-og-sm text-og-accent", children: [
+              "/",
+              command.name,
+              hint ? /* @__PURE__ */ jsx3("span", { className: "ml-1 text-og-fg-subtle", children: hint }) : null
+            ] }),
+            /* @__PURE__ */ jsx3("span", { className: "text-og-sm text-og-fg-muted", children: command.description }),
+            command.danger ? /* @__PURE__ */ jsx3("span", { className: "ml-auto rounded-og-xs bg-og-status-failed/15 px-1 text-og-xs uppercase tracking-wide text-og-status-failed", children: messages.danger }) : null
+          ] }, command.name);
+        }) })
+      ]
+    }
+  );
+}
+
+// src/hooks/use-transcription.ts
+import {
+  authorizeTranscriptionAdapter,
+  createTranscriptionSessionRequest
+} from "@opengeni/sdk";
+import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo4, useRef as useRef3, useState as useState3 } from "react";
+var INITIAL_TRANSCRIPTION_CONTROL_STATE = {
+  status: "idle",
+  generation: 0,
+  localSessionId: null,
+  providerSessionId: null,
+  lastSequence: 0,
+  partial: "",
+  error: null,
+  acceptedFinalIds: [],
+  audioMilliseconds: 0,
+  costUsd: null
+};
+function transitionTranscriptionControl(state, action) {
+  if (action.type === "reset") {
+    return {
+      state: { ...INITIAL_TRANSCRIPTION_CONTROL_STATE, generation: state.generation },
+      commit: null
+    };
+  }
+  if (action.type === "start") {
+    if (action.generation <= state.generation) return { state, commit: null };
+    return {
+      state: {
+        ...INITIAL_TRANSCRIPTION_CONTROL_STATE,
+        status: "requesting-permission",
+        generation: action.generation,
+        localSessionId: action.localSessionId
+      },
+      commit: null
+    };
+  }
+  if (action.generation !== state.generation) return { state, commit: null };
+  if (action.type === "start.failed") {
+    if (state.status === "closed" || state.status === "error") return { state, commit: null };
+    return {
+      state: {
+        ...state,
+        status: "error",
+        partial: "",
+        error: { code: normalizeTranscriptionErrorCode(action.code), recoverable: false }
+      },
+      commit: null
+    };
+  }
+  if (action.type === "cancel") {
+    if (!isActiveTranscriptionStatus(state.status)) return { state, commit: null };
+    return {
+      state: { ...state, status: "cancelling", partial: "", error: null },
+      commit: null
+    };
+  }
+  if (action.type === "cancel.settled") {
+    if (state.status !== "cancelling") return { state, commit: null };
+    return { state: { ...state, status: "closed", partial: "" }, commit: null };
+  }
+  const event = action.event;
+  if (event.localSessionId !== state.localSessionId) return { state, commit: null };
+  if (!Number.isSafeInteger(event.sequence) || event.sequence <= state.lastSequence) {
+    return { state, commit: null };
+  }
+  if (state.status === "closed" || state.status === "error") return { state, commit: null };
+  if (state.status === "cancelling" && event.type !== "session.closed") {
+    return { state: { ...state, lastSequence: event.sequence }, commit: null };
+  }
+  const sequenced = { ...state, lastSequence: event.sequence };
+  switch (event.type) {
+    case "permission.requested":
+      return {
+        state: { ...sequenced, status: "requesting-permission", partial: "", error: null },
+        commit: null
+      };
+    case "session.opened":
+      return {
+        state: {
+          ...sequenced,
+          status: "listening",
+          providerSessionId: event.providerSessionId,
+          error: null
+        },
+        commit: null
+      };
+    case "transcript.partial":
+      return {
+        state: { ...sequenced, status: "listening", partial: event.text, error: null },
+        commit: null
+      };
+    case "transcript.final": {
+      const text = event.text.trim();
+      const duplicate = state.acceptedFinalIds.includes(event.providerAcceptanceId);
+      const acceptedFinalIds = duplicate || text.length === 0 ? state.acceptedFinalIds : [...state.acceptedFinalIds, event.providerAcceptanceId];
+      return {
+        state: {
+          ...sequenced,
+          status: "listening",
+          partial: "",
+          error: null,
+          acceptedFinalIds
+        },
+        commit: duplicate || text.length === 0 ? null : text
+      };
+    }
+    case "usage":
+      return {
+        state: {
+          ...sequenced,
+          audioMilliseconds: Math.max(state.audioMilliseconds, event.audioMilliseconds),
+          costUsd: event.costUsd
+        },
+        commit: null
+      };
+    case "session.reconnecting":
+      return {
+        state: { ...sequenced, status: "reconnecting", partial: "", error: null },
+        commit: null
+      };
+    case "session.error":
+      return {
+        state: {
+          ...sequenced,
+          status: event.recoverable ? "reconnecting" : "error",
+          partial: "",
+          error: {
+            code: normalizeTranscriptionErrorCode(event.code),
+            recoverable: event.recoverable
+          }
+        },
+        commit: null
+      };
+    case "session.closed":
+      return {
+        state: {
+          ...sequenced,
+          status: event.reason === "error" ? "error" : "closed",
+          partial: ""
+        },
+        commit: null
+      };
+  }
+}
+function appendFinalTranscript(draft, transcript) {
+  const final = transcript.trim();
+  if (!final) return draft;
+  if (!draft) return final;
+  return /\s$/u.test(draft) ? `${draft}${final}` : `${draft} ${final}`;
+}
+var DEFAULT_TRANSCRIPTION_LIFECYCLE_TIMEOUTS = {
+  startMs: 15e3,
+  cleanupMs: 2e3
+};
+function useTranscription({
+  adapter,
+  policy,
+  selection = { kind: "primary" },
+  value,
+  setValue,
+  focusInput,
+  disabled = false,
+  createLocalSessionId = defaultLocalSessionId,
+  lifecycleTimeouts,
+  onDiagnostic
+}) {
+  const [state, setState] = useState3(INITIAL_TRANSCRIPTION_CONTROL_STATE);
+  const stateRef = useRef3(state);
+  const valueRef = useRef3(value);
+  const sessionRef = useRef3(null);
+  const pendingStartRef = useRef3(null);
+  const activePolicyRef = useRef3(null);
+  valueRef.current = value;
+  const startTimeoutMs = normalizeTimeout(
+    lifecycleTimeouts?.startMs,
+    DEFAULT_TRANSCRIPTION_LIFECYCLE_TIMEOUTS.startMs
+  );
+  const cleanupTimeoutMs = normalizeTimeout(
+    lifecycleTimeouts?.cleanupMs,
+    DEFAULT_TRANSCRIPTION_LIFECYCLE_TIMEOUTS.cleanupMs
+  );
+  const reportDiagnostic = useCallback3(
+    (diagnostic) => {
+      if (!onDiagnostic) return;
+      try {
+        onDiagnostic(sanitizeTranscriptionDiagnostic(diagnostic));
+      } catch {
+      }
+    },
+    [onDiagnostic]
+  );
+  const cleanupRuntimeRef = useRef3({ cleanupTimeoutMs, reportDiagnostic });
+  useEffect2(() => {
+    cleanupRuntimeRef.current = { cleanupTimeoutMs, reportDiagnostic };
+  }, [cleanupTimeoutMs, reportDiagnostic]);
+  const policyRevision = useMemo4(
+    () => transcriptionPolicyRevision(policy, selection),
+    [policy, selection]
+  );
+  const authorization = useMemo4(
+    () => adapter ? authorizeTranscriptionAdapter(policy, adapter.descriptor, selection) : null,
+    [adapter, policy, selection]
+  );
+  const unavailableReason = disabled ? "composer_disabled" : !policy.enabled ? "disabled" : !policy.acceptanceId ? "unaccepted" : !policy.primary ? "target_missing" : !adapter ? "adapter_missing" : authorization?.authorized ? null : authorization?.reason ?? "unaccepted";
+  const apply = useCallback3(
+    (action) => {
+      const transition = transitionTranscriptionControl(stateRef.current, action);
+      if (transition.state !== stateRef.current) {
+        stateRef.current = transition.state;
+        setState(transition.state);
+      }
+      if (transition.commit !== null) {
+        const next = appendFinalTranscript(valueRef.current, transition.commit);
+        valueRef.current = next;
+        setValue(next);
+        focusInput();
+      }
+      return transition.state;
+    },
+    [focusInput, setValue]
+  );
+  const releaseTerminalSession = useCallback3(
+    (generation) => {
+      const active = sessionRef.current;
+      if (!active || active.generation !== generation) return;
+      sessionRef.current = null;
+      if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+      detachSessionCleanup(active.session, {
+        cleanupTimeoutMs,
+        reportDiagnostic
+      });
+    },
+    [cleanupTimeoutMs, reportDiagnostic]
+  );
+  const start = useCallback3(async () => {
+    if (!adapter || unavailableReason !== null || isActiveTranscriptionStatus(stateRef.current.status)) {
+      return false;
+    }
+    const generation = stateRef.current.generation + 1;
+    const localSessionId = createLocalSessionId();
+    apply({ type: "start", generation, localSessionId });
+    const request = createTranscriptionSessionRequest({
+      policy,
+      adapter,
+      localSessionId,
+      selection,
+      sequenceFloor: 0
+    });
+    if (!request) {
+      apply({
+        type: "start.failed",
+        generation,
+        code: "policy_blocked"
+      });
+      return false;
+    }
+    activePolicyRef.current = { generation, revision: policyRevision };
+    const controller = new AbortController();
+    pendingStartRef.current = { generation, controller };
+    let boundarySettled = false;
+    let accepted = false;
+    const observedStart = Promise.resolve().then(
+      () => adapter.start(
+        request,
+        (event) => {
+          apply({ type: "event", generation, event });
+          if (event.type === "session.error" && !event.recoverable) {
+            releaseTerminalSession(generation);
+          } else if (event.type === "session.closed") {
+            releaseTerminalSession(generation);
+          }
+        },
+        {
+          signal: controller.signal,
+          reportDiagnostic
+        }
+      )
+    ).then(
+      (session) => {
+        if (boundarySettled && !accepted) {
+          detachSessionCleanup(session, {
+            cancelReason: "stale-generation",
+            cleanupTimeoutMs,
+            reportDiagnostic
+          });
+        }
+        return { kind: "session", session };
+      },
+      (error) => {
+        if (boundarySettled) {
+          reportDiagnostic({
+            operation: "start",
+            code: classifyStartError(error),
+            detail: diagnosticDetail(error)
+          });
+        }
+        return { kind: "error", error };
+      }
+    );
+    let abortListener = null;
+    const aborted = new Promise((resolve) => {
+      if (controller.signal.aborted) {
+        resolve({ kind: "aborted" });
+        return;
+      }
+      abortListener = () => resolve({ kind: "aborted" });
+      controller.signal.addEventListener("abort", abortListener, { once: true });
+    });
+    let timeoutId = null;
+    const timedOut = new Promise((resolve) => {
+      timeoutId = setTimeout(() => resolve({ kind: "timeout" }), startTimeoutMs);
+    });
+    const outcome = await Promise.race([observedStart, aborted, timedOut]);
+    boundarySettled = true;
+    if (timeoutId !== null) clearTimeout(timeoutId);
+    if (abortListener) controller.signal.removeEventListener("abort", abortListener);
+    if (pendingStartRef.current?.generation === generation) pendingStartRef.current = null;
+    if (outcome.kind === "aborted") return false;
+    if (outcome.kind === "timeout") {
+      controller.abort("transcription-start-timeout");
+      if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+      reportDiagnostic({
+        operation: "start",
+        code: "timeout",
+        detail: `Transcription adapter start exceeded ${startTimeoutMs}ms.`
+      });
+      apply({ type: "start.failed", generation, code: "timeout" });
+      return false;
+    }
+    if (outcome.kind === "error") {
+      if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+      const code = classifyStartError(outcome.error);
+      reportDiagnostic({
+        operation: "start",
+        code,
+        detail: diagnosticDetail(outcome.error)
+      });
+      if (!controller.signal.aborted) {
+        apply({ type: "start.failed", generation, code });
+      }
+      return false;
+    }
+    const current = stateRef.current;
+    if (current.generation !== generation || current.localSessionId !== localSessionId || current.status === "cancelling" || !isActiveTranscriptionStatus(current.status)) {
+      if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+      detachSessionCleanup(outcome.session, {
+        ...current.status === "error" ? {} : { cancelReason: "stale-generation" },
+        cleanupTimeoutMs,
+        reportDiagnostic
+      });
+      return false;
+    }
+    accepted = true;
+    sessionRef.current = { generation, session: outcome.session };
+    return true;
+  }, [
+    adapter,
+    apply,
+    createLocalSessionId,
+    cleanupTimeoutMs,
+    policy,
+    policyRevision,
+    releaseTerminalSession,
+    reportDiagnostic,
+    selection,
+    startTimeoutMs,
+    unavailableReason
+  ]);
+  const cancel = useCallback3(async () => {
+    const current = stateRef.current;
+    if (!isActiveTranscriptionStatus(current.status)) return false;
+    const generation = current.generation;
+    apply({ type: "cancel", generation });
+    const pending = pendingStartRef.current;
+    if (pending?.generation === generation) {
+      pendingStartRef.current = null;
+      pending.controller.abort("transcription-locally-cancelled");
+    }
+    const active = sessionRef.current;
+    sessionRef.current = null;
+    if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+    apply({ type: "cancel.settled", generation });
+    focusInput();
+    if (active?.generation === generation) {
+      detachSessionCleanup(active.session, {
+        cancelReason: "user-cancelled",
+        cleanupTimeoutMs,
+        reportDiagnostic
+      });
+    }
+    return true;
+  }, [apply, cleanupTimeoutMs, focusInput, reportDiagnostic]);
+  const reset = useCallback3(() => apply({ type: "reset" }), [apply]);
+  useEffect2(() => {
+    if (!isActiveTranscriptionStatus(state.status)) return;
+    const onKeyDown = (event) => {
+      if (event.key !== "Escape") return;
+      event.preventDefault();
+      void cancel();
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [cancel, state.status]);
+  useEffect2(() => {
+    if (!isActiveTranscriptionStatus(state.status)) return;
+    const activePolicy = activePolicyRef.current;
+    if (unavailableReason === null && activePolicy?.generation === state.generation && activePolicy.revision === policyRevision) {
+      return;
+    }
+    void cancel();
+  }, [cancel, policyRevision, state.generation, state.status, unavailableReason]);
+  useEffect2(
+    () => () => {
+      const pending = pendingStartRef.current;
+      pendingStartRef.current = null;
+      pending?.controller.abort("transcription-component-unmounted");
+      const active = sessionRef.current;
+      sessionRef.current = null;
+      activePolicyRef.current = null;
+      stateRef.current = {
+        ...stateRef.current,
+        generation: stateRef.current.generation + 1,
+        status: "closed",
+        partial: ""
+      };
+      if (active) {
+        const runtime = cleanupRuntimeRef.current;
+        detachSessionCleanup(active.session, {
+          cancelReason: "component-unmounted",
+          cleanupTimeoutMs: runtime.cleanupTimeoutMs,
+          reportDiagnostic: runtime.reportDiagnostic
+        });
+      }
+    },
+    []
+  );
+  return {
+    state,
+    available: unavailableReason === null,
+    unavailableReason,
+    start,
+    cancel,
+    reset
+  };
+}
+function isActiveTranscriptionStatus(status) {
+  return status === "requesting-permission" || status === "listening" || status === "reconnecting" || status === "cancelling";
+}
+function defaultLocalSessionId() {
+  return globalThis.crypto.randomUUID();
+}
+function classifyStartError(error) {
+  if (isRecord2(error)) {
+    const normalized = normalizeTranscriptionErrorCode(error.code);
+    if (normalized !== "unknown") return normalized;
+  }
+  if (typeof DOMException !== "undefined" && error instanceof DOMException) {
+    if (error.name === "NotAllowedError") return "permission_denied";
+    if (error.name === "NotSupportedError") return "not_supported";
+    if (error.name === "TimeoutError") return "timeout";
+    if (error.name === "AbortError") return "cancelled";
+  }
+  return "unknown";
+}
+function normalizeTranscriptionErrorCode(code) {
+  switch (code) {
+    case "permission_denied":
+    case "not_supported":
+    case "network":
+    case "provider":
+    case "policy_blocked":
+    case "timeout":
+    case "cancelled":
+    case "unknown":
+      return code;
+    default:
+      return "unknown";
+  }
+}
+function sanitizeTranscriptionDiagnostic(diagnostic) {
+  const source = isRecord2(diagnostic) ? diagnostic : {};
+  const operation = source.operation === "start" || source.operation === "session" || source.operation === "cancel" || source.operation === "close" ? source.operation : "session";
+  const rawDetail = typeof source.detail === "string" ? source.detail : "No diagnostic detail.";
+  const detail = rawDetail.replace(/[\u0000-\u001f\u007f]+/gu, " ").replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/giu, "Bearer [REDACTED]").replace(/\bsk-[A-Za-z0-9_-]{4,}\b/gu, "[REDACTED]").replace(
+    /\b(api[-_ ]?key|authorization|access[-_ ]?token|refresh[-_ ]?token|token|secret)\b\s*[:=]\s*[^\s,;]+/giu,
+    "$1=[REDACTED]"
+  ).trim().slice(0, 512);
+  return {
+    operation,
+    code: normalizeTranscriptionErrorCode(source.code),
+    detail: detail || "No diagnostic detail."
+  };
+}
+function detachSessionCleanup(session, options) {
+  if (options.cancelReason) {
+    void runBoundedCleanup(
+      "cancel",
+      () => session.cancel(options.cancelReason),
+      options.cleanupTimeoutMs,
+      options.reportDiagnostic
+    );
+  }
+  void runBoundedCleanup(
+    "close",
+    () => session.close(),
+    options.cleanupTimeoutMs,
+    options.reportDiagnostic
+  );
+}
+async function runBoundedCleanup(operation, invoke, timeoutMs, reportDiagnostic) {
+  let timeoutId = null;
+  const result = Promise.resolve().then(invoke).then(
+    () => ({ kind: "settled" }),
+    (error) => ({ kind: "rejected", error })
+  );
+  const timeout = new Promise((resolve) => {
+    timeoutId = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+  });
+  const outcome = await Promise.race([result, timeout]);
+  if (timeoutId !== null) clearTimeout(timeoutId);
+  if (outcome.kind === "settled") return;
+  reportDiagnostic({
+    operation,
+    code: outcome.kind === "timeout" ? "timeout" : "provider",
+    detail: outcome.kind === "timeout" ? `Transcription ${operation} exceeded ${timeoutMs}ms.` : diagnosticDetail(outcome.error)
+  });
+}
+function diagnosticDetail(error) {
+  if (error instanceof Error) return error.message;
+  return typeof error === "string" ? error : "Unknown transcription adapter failure.";
+}
+function normalizeTimeout(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.min(Math.floor(value), 6e4) : fallback;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function transcriptionPolicyRevision(policy, selection) {
+  const targetKey = (target) => target ? [
+    target.provider,
+    target.model ?? "",
+    target.credentialMode,
+    target.credentialConnectionId ?? "",
+    target.region ?? ""
+  ].join("\0") : "";
+  return [
+    policy.enabled ? "1" : "0",
+    policy.acceptanceId ?? "",
+    targetKey(policy.primary),
+    policy.language ?? "",
+    policy.autoDetectLanguage ? "1" : "0",
+    policy.diarization.enabled ? "1" : "0",
+    policy.diarization.maxSpeakers?.toString() ?? "",
+    policy.retention.mode,
+    policy.retention.maxDays?.toString() ?? "",
+    policy.privacy.allowProviderLogging ? "1" : "0",
+    policy.privacy.allowProviderTraining ? "1" : "0",
+    policy.fallback.mode,
+    policy.fallback.targets.map(targetKey).join("
"),
+    policy.cost.currency,
+    policy.cost.maxPerHour?.toString() ?? "",
+    policy.cost.maxPerMonth?.toString() ?? "",
+    selection.kind,
+    selection.kind === "fallback" ? selection.index.toString() : ""
+  ].join("");
+}
+
+// src/components/composer-transcription-control.tsx
+import { LoaderCircleIcon as LoaderCircleIcon2, MicIcon, RotateCwIcon as RotateCwIcon2, SquareIcon } from "lucide-react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var defaultMessages = {
+  start: "Start voice input",
+  stop: "Stop voice input",
+  retry: "Retry voice input",
+  requestingPermission: "Requesting microphone permission\u2026",
+  listening: "Listening\u2026 Press Escape to cancel.",
+  reconnecting: "Reconnecting voice input\u2026",
+  cancelling: "Cancelling voice input\u2026",
+  unavailableDisabled: "Voice input is unavailable while the composer is disabled.",
+  unavailableAdapter: "Voice input needs an approved transcription adapter.",
+  unavailablePolicy: "Enable and accept transcription in Workspace settings.",
+  errorPermissionDenied: "Microphone permission was denied. Your draft was not changed.",
+  errorNotSupported: "Voice input is not supported on this device.",
+  errorNetwork: "Voice input lost its network connection.",
+  errorProvider: "The transcription service could not continue.",
+  errorPolicyBlocked: "Workspace policy does not authorize voice input.",
+  errorTimeout: "Voice input took too long to start. Try again.",
+  errorCancelled: "Voice input was cancelled.",
+  errorUnknown: "Voice input could not start. Try again."
+};
+function ComposerTranscriptionControl({
+  adapter,
+  policy,
+  selection,
+  messages: overrides,
+  className,
+  lifecycleTimeouts,
+  onDiagnostic
+}) {
+  const composer = useChatComposer();
+  const messages = { ...defaultMessages, ...overrides };
+  const transcription = useTranscription({
+    adapter,
+    policy,
+    ...selection ? { selection } : {},
+    value: composer.value,
+    setValue: composer.setValue,
+    focusInput: composer.focusInput,
+    disabled: composer.disabled,
+    lifecycleTimeouts,
+    onDiagnostic
+  });
+  const status = transcription.state.status;
+  const active = status === "requesting-permission" || status === "listening" || status === "reconnecting" || status === "cancelling";
+  const unavailableMessage = transcription.unavailableReason === "composer_disabled" ? messages.unavailableDisabled : transcription.unavailableReason === "adapter_missing" ? messages.unavailableAdapter : transcription.unavailableReason ? messages.unavailablePolicy : null;
+  const label = unavailableMessage ? unavailableMessage : status === "error" ? messages.retry : active ? messages.stop : messages.start;
+  const errorMessage3 = transcription.state.error ? transcriptionErrorMessage(transcription.state.error.code, messages) : null;
+  const announcement = transcription.state.partial || (status === "requesting-permission" ? messages.requestingPermission : status === "listening" ? messages.listening : status === "reconnecting" ? errorMessage3 ?? messages.reconnecting : status === "cancelling" ? messages.cancelling : status === "error" ? errorMessage3 ?? messages.errorUnknown : unavailableMessage);
+  function activate(event) {
+    if (unavailableMessage || status === "cancelling") {
+      event.preventDefault();
+      return;
+    }
+    if (active) void transcription.cancel();
+    else void transcription.start();
+  }
+  return /* @__PURE__ */ jsxs4(
+    "span",
+    {
+      className: cn("inline-flex min-w-0 items-center gap-1.5", className),
+      "data-transcription-status": status,
+      children: [
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            onClick: activate,
+            "aria-label": label,
+            "aria-pressed": active,
+            "aria-disabled": unavailableMessage !== null || status === "cancelling",
+            "aria-keyshortcuts": active ? "Escape" : void 0,
+            title: label,
+            className: cn(
+              "inline-flex size-8 shrink-0 items-center justify-center rounded-og-md pointer-coarse:size-11",
+              "text-og-fg-muted transition-colors duration-150 motion-reduce:transition-none",
+              unavailableMessage ? "cursor-not-allowed opacity-45" : status === "cancelling" ? "cursor-not-allowed" : "hover:bg-og-surface-2 hover:text-og-fg",
+              status === "listening" && "bg-og-status-failed/10 text-og-status-failed"
+            ),
+            children: status === "requesting-permission" || status === "cancelling" ? /* @__PURE__ */ jsx4(LoaderCircleIcon2, { className: "size-4 animate-og-spin motion-reduce:animate-none" }) : status === "reconnecting" ? /* @__PURE__ */ jsx4(RotateCwIcon2, { className: "size-4 animate-og-spin motion-reduce:animate-none" }) : active ? /* @__PURE__ */ jsx4(SquareIcon, { className: "size-3.5 fill-current" }) : /* @__PURE__ */ jsx4(MicIcon, { className: "size-4" })
+          }
+        ),
+        announcement && (active || status === "error") ? /* @__PURE__ */ jsx4(
+          "span",
+          {
+            "aria-hidden": "true",
+            title: announcement,
+            className: cn(
+              "max-w-48 truncate text-og-xs text-og-fg-muted max-sm:max-w-28",
+              status === "error" && "text-og-status-failed"
+            ),
+            children: announcement
+          }
+        ) : null,
+        /* @__PURE__ */ jsx4("span", { className: "sr-only", role: status === "error" ? "alert" : "status", "aria-live": "polite", children: announcement })
+      ]
+    }
+  );
+}
+function transcriptionErrorMessage(code, messages) {
+  switch (code) {
+    case "permission_denied":
+      return messages.errorPermissionDenied;
+    case "not_supported":
+      return messages.errorNotSupported;
+    case "network":
+      return messages.errorNetwork;
+    case "provider":
+      return messages.errorProvider;
+    case "policy_blocked":
+      return messages.errorPolicyBlocked;
+    case "timeout":
+      return messages.errorTimeout;
+    case "cancelled":
+      return messages.errorCancelled;
+    case "unknown":
+      return messages.errorUnknown;
+  }
+}
+
+export {
+  parseCommandLine,
+  hasPermission,
+  matchCommand,
+  filterCommands,
+  argHint,
+  firstMissingRequiredArg,
+  defaultCommands,
+  useSlashCommands,
+  CommandPalette,
+  ModelPicker,
+  OPEN_WORKSTREAM_CONTROL_EVENT,
+  defaultChatComposerMessages,
+  useChatComposerController,
+  useChatComposer,
+  Root,
+  Frame,
+  CommandPalette2,
+  Surface,
+  PausedState,
+  RestoredResources,
+  Attachments,
+  Input,
+  Confirmation,
+  Footer,
+  Controls,
+  Hint,
+  Actions,
+  AttachButton,
+  ModelPicker2,
+  PauseButton,
+  SendButton,
+  Help,
+  Status,
+  INITIAL_TRANSCRIPTION_CONTROL_STATE,
+  transitionTranscriptionControl,
+  appendFinalTranscript,
+  useTranscription,
+  ComposerTranscriptionControl
+};
+//# sourceMappingURL=chunk-LAZ2A743.js.map