@athenaintel/react 0.41.2 → 0.42.1

package/README.md

@@ -23,8 +23,11 @@ requires a compatible backend. Publication is temporarily withheld until product
 and authorization tests pass and a compatible backend rollback release is
 retained. The publish workflow requires a manual
 `PRODUCTION_NATIVE_CONTEXT_AND_ROLLBACK_QUALIFIED` acknowledgement; dry runs
-remain available. Computer templates keep SDK0.28.0 until the qualified
-release is published. The qualification steps and gate removal condition are
+remain available. Once a release is on npm, the computer starters
+(`docker/athena-app`, `docker/default-vite`, `docker/kpmg-audit`) move to it
+with `scripts/computer-starter-lockfiles.ts --react <version>`; their
+`bunfig.toml` exempts only `@athenaintel/react` from the image's four-day
+release-age gate. The qualification steps and gate removal condition are
 in the [coordinated release runbook](../../docs/runbooks/coordinated-client-releases.md#public-native-context-publication-gate).
 
 The SDK pins its assistant-ui runtime (`@assistant-ui/tap`, `store`, `core`,
@@ -60,7 +63,14 @@ export default defineConfig({
 });
 ```
 
-Then bump to the release you want and re-resolve from scratch.
+Then bump to the release you want. One exception comes first: if your app
+depends on an assistant-ui package itself (say `@assistant-ui/react`, for
+components of its own) and the new SDK pins the same assistant-ui stack as the
+old one (compare the two versions' `dependencies`), keep `bun.lock`. Run only
+the `bun add` line below and skip deleting anything. A from-scratch resolve
+there can take newer `core` / `store` / `tap` patches through that package's
+caret ranges, beside the SDK's exact pins; `resolve.dedupe` above still mounts
+one instance at runtime. Otherwise, re-resolve from scratch.
 Lockfile-preserving commands do not do it — `bun update` and
 `bun install --force` keep the nested lockfile entries, and `bun remove` +
 `bun add` (or deleting only `bun.lock`) rewrites the lockfile but bun leaves
@@ -235,7 +245,11 @@ A `getToken` resolver is called with `{ force: true }` right after the sync
 host refuses a credential, so a caching getter must mint a fresh token then;
 the persisted command lane is scoped to the signed-in user as well as the
 host, so a shared browser never resends one user's pending sends under the
-next user's token.
+next user's token. While a sign-in provider above the chat is still loading
+who is signed in (`AthenaAuthContext` with `isLoading: true` and no `user`
+yet), the chat does not connect and stores nothing: it connects once, under
+the signed-in user, when they are known, and sends made meanwhile wait for
+that.
 
 What the statewire transport wires up in `AthenaChat`:
 
@@ -276,8 +290,9 @@ What the statewire transport wires up in `AthenaChat`:
   `SuperGroupingCard`, `SuperGroupingFinalText`, `CollapsibleGroup`, the
   activity-timeline derivation, and the tool-based grouping function — with
   slots for the host's text/tool renderers and controls (`renderHeaderActions`,
-  `renderRunningMeta`, `summaryDetails`, `waitingTools`, `expansionKey`), so
-  Olympus and the Chrome extension mount one card instead of copies.
+  `renderRunningMeta`, `summaryDetails`, `waitingTools`, `waitingToolCallIds`,
+  `expansionKey`), so Olympus and the Chrome extension mount one card instead
+  of copies.
 - **In-repo hosts consume the package, not the source.** `@athenaintel/react`
   is a workspace dependency of Olympus, the Chrome extension, and the Office
   add-in, resolved through this package's `exports` to the built `dist/` (the
@@ -722,6 +737,44 @@ registry entries (`SESSION_WORKBENCH_TASKS_PANE`, …), the data hooks
 (`deriveShellRows`, `filterShellRows`, `deriveTaskSteps`, `taskProgress`,
 `workspaceComputers`) are exported for hosts composing their own.
 
+## Chat voice media (`@athenaintel/react/voice/livekit`)
+
+Hosts using the shared agent runtime can use the SDK's browser LiveKit adapter
+for chat voice. The runtime owns the voice commands and transcript; the adapter
+joins the authorized room, publishes the microphone and plays the agent audio.
+Install the optional `livekit-client` peer before starting a session.
+
+```tsx
+import { useMemo, useRef } from 'react';
+import { useAthenaChatVoice } from '@athenaintel/react/voice/chat';
+import { createDeepAgentVoiceLiveKitAdapter } from '@athenaintel/react/voice/livekit';
+
+function ChatVoice() {
+  const audioRef = useRef<HTMLAudioElement>(null);
+  const livekit = useMemo(
+    () => createDeepAgentVoiceLiveKitAdapter({ audioElement: () => audioRef.current }),
+    [],
+  );
+  const voice = useAthenaChatVoice({ transport: 'livekit', livekit });
+  const active = voice.phase === 'connecting' || voice.phase === 'live';
+  return <>
+    <audio ref={audioRef} autoPlay />
+    <button disabled={active} onClick={() => void voice.start()}>Start voice</button>
+    <button disabled={!active} onClick={voice.end}>End voice</button>
+  </>;
+}
+```
+
+Use this inside the thread's runtime provider and start voice from a user
+action. Importing the adapter leaves LiveKit unloaded until a room joins. The
+default room releases the microphone device on mute and enables browser echo
+cancellation, noise suppression and gain control. A host can supply its own
+`roomFactory` when it needs a platform-specific room policy.
+The SDK's shared runtime supplies cancellation: Stop or unmount releases a pending
+join, ignores late audio and cleans up a microphone request that finishes
+after the attempt ended. The host still applies its voice permission and
+deployment gates before issuing room credentials.
+
 ## Voice Sessions (`@athenaintel/react/voice`)
 
 `useAthenaVoiceSession` runs a real-time voice conversation with an Athena
@@ -807,6 +860,49 @@ Both use the same bearer / API key as session creation. The full recipe
 template skill `voice-session-guide.md`. `createAthenaVoiceSession` is also
 exported if you hold the bridge state yourself.
 
+## What's new in 0.42.1
+
+**A chat that mounts before your sign-in provider knows who is signed in no longer resends old commands, and no longer loses what was sent meanwhile.** The chat keeps each conversation's unconfirmed commands in this browser under the signed-in user, so a reload can resend them. A sign-in provider of your own that renders the chat while it is still loading (`AthenaAuthContext` with `isLoading: true`) put the conversation under an anonymous key first. When the user loaded, the conversation moved to their key and took the anonymous record's client id and command numbers with it, and the anonymous record stayed behind with the same id. Every later page load read that record first and resent its commands below the numbers Athena had already taken, so Athena refused them as expired. A message sent before the user loaded went into a conversation that could not keep it.
+
+While the sign-in provider is loading and names no user yet, the chat now waits: it does not connect and stores nothing, and it connects once, under the signed-in user, as soon as they are known. A provider that refreshes while still naming its user keeps that user's conversation as it is. A message sent meanwhile (Enter in the composer, a dictated send, a suggestion, `useSendMessage`) waits and goes out then, and `useComposerReady()` reads `false` until then. `AthenaAuthProvider` and `AthenaSSOProvider` render the chat only once someone is signed in, so apps that use them are unaffected. Nothing to change in your app.
+
+## What's new in 0.42.0
+
+**Subagent cards.** When the agent delegates work to a subagent (a `task` call), `AthenaChat` shows the delegation as a card in the conversation, outside the turn's collapsed steps: what the subagent was asked to do, where it is (Queued, Running, Done, Failed, Stopped), how many tool calls it has made, how long it has run, and while it runs, the step it took last ("Read `routes.ts`"). A finished subagent shows the start of its report, and a failed one the start of why it failed; the card opens to the whole text, steps or none. Open the card to follow its steps live: they render read-only with the chat's own tool cards, and a delegation inside a subagent's steps shows as one row. The card is `SubagentTaskToolUI`, registered as `task` in `TOOL_UI_REGISTRY`, so an app that spreads the registry into `toolUIs` gets it too.
+
+**Load earlier steps.** Athena sends a running subagent's card with only its newest steps. An open card says how many it shows ("Showing the latest 8 of 42 steps.") and "Load earlier steps" reads the rest, a page at a time, over the conversation's own connection (the read-only `history/lane` command, sent only when asked). Pass `subagentLaneHistory` to `AthenaProvider` when every `task` call your chat shows renders in this card (`AthenaChat` with the registry's `task`): the provider then tells Athena that its chat pages subagent steps (deep-agent protocol 2), so a finished subagent's card also arrives with only its newest steps and a long fan-out loads lighter. It is off by default, so finished subagents arrive whole until you opt in. Against an Athena that cannot page a running subagent, the card says instead that the earlier steps arrive when the subagent finishes.
+
+**A subagent waiting for approval says so.** When a gated tool a subagent calls (or the delegation itself) waits on a person's approval, its card reads "Waiting for approval" and names what it waits on ("Needs approval to run `delete` …", or "Needs approval to start") instead of live activity, with no clock running. The turn's step for it reads "Waiting for your input", not running, so the turn header says "Waiting for you" and never "Nothing new". `AthenaChat` reads the run's approval once, the one the approval card shows, and passes the waiting steps to the collapsed view (`waitingToolCallIds`, 0.41.7). It only reads: the approval card is still what answers. For a chat of your own, `useStatewireApprovalWait()` returns the gated calls still waiting (`toolCallIds`) and whether the run is parked (`runParked`), and `useTurnToolCallsAwaitingApproval(toolCallIds)` the steps of the turn in scope they make wait, for `SuperGroupingCard` / `SuperGroupingTranscript`.
+
+**If you render `task` yourself.** A `task` tool UI you pass in `toolUIs` keeps its place in the turn, and the SDK adds no subagent steps under it. Leave `subagentLaneHistory` off (the default) and finished subagents keep arriving whole, so a UI that reads every step off the card (`artifact.subgraph_state.messages`) still sees them all; a running subagent's card carries only its newest steps, as before. A chat of your own on `useAthenaStatewireRuntime` likewise declares the default contract unless you pass `subagentLaneHistory: true`. Each `task` tool-call part now carries its subagent's steps as `messages`, assistant-ui's nested-thread channel (`MessagePartPrimitive.Messages`, `thread.tasks`); `NestedPtcMessages` leaves them to the subagent card.
+
+## What's new in 0.41.7
+
+**A step that is still running no longer reads as done when its turn stops streaming.** A long-running tool's step (a `task` subagent, Studio or Python execution, deep research) holds the backend's running placeholder until its real result arrives. When a run parks on an approval raised inside a subagent, nothing streams, so the turn's status reads complete, and the collapsed view checked the subagent's step off as done. A step whose only result is the running placeholder now reads as running whatever the turn's status says (`buildActivityTimeline`, `getActivityToolState`), and so does the card that holds it (`resolveActivityPhase`), which keeps its live tool details mounted.
+
+**Hosts can name the steps a run is parked on.** `SuperGroupingCard` and `SuperGroupingTranscript` take `waitingToolCallIds` (and `buildActivityTimeline` the same option): the ids of the tool calls the run waits on a person for. Each one still without its real result reads "Waiting for your input", and the card reads "Waiting for you". Olympus passes the `task` call whose subagent is parked on an approval. Keep the set's identity stable while its ids do not change. Nothing to change in your app.
+
+## What's new in 0.41.6
+
+**A new session reaches the sidebar even when the first refresh is refused.** When the conversation index tells the list about a session it does not show yet, the list refreshes. That refresh used to run once per session: if it was refused (a rate limit, a network error, a deploy restart), the session stayed out of the sidebar until a reload. A refused refresh is now tried again, after 10 s and then 20 s, at most three times, so a session the list legitimately never shows (another app, a search) cannot loop. The same applies to `useAthenaSessions` lists (`SessionsPage`, `Inbox`).
+
+**Fewer session-list reads per session change.** A session starting or changing used to make every open tab re-read each of its lists at once. Now:
+
+- the refreshes one burst of index pushes calls for are gathered into one (about 0.75 s, at most 3 s), and none is sent while that list is already being read;
+- tabs of the same user and workspace share what they read over a `BroadcastChannel`. One tab claims a list and reads it, and the others take its page instead of reading it themselves. A background tab waits a little longer, so the visible tab is usually the one that reads. If the shared page never arrives, each tab reads for itself after 5 s.
+
+Without `BroadcastChannel`, or before the signed-in user and workspace are known, each tab reads for itself, as before. Nothing to change in your app.
+
+## What's new in 0.41.4
+
+**Text typed after a link stays plain.** Tiptap's Link is inclusive whenever autolink is on, so in the composer a space and the words typed after a pasted (or autolinked) URL joined the link and were sent as part of it. The chat link mark is no longer inclusive: the URL keeps its link and whatever is typed at its end is ordinary text.
+
+## What's new in 0.41.3
+
+**A pinned session stays in the sidebar.** The session list reads the newest 50 sessions, and its Pinned group was built from that page alone, so a session pinned long ago left the sidebar once 50 newer sessions existed (on staging, four pinned sessions became three when two new sessions started). The provider now also reads the viewer's pinned sessions on their own (`favorites_only`, under the same app scope and search, every page of them up to 500) and adds the ones the page does not list to the Pinned group. Unpinning such a session takes it out of the sidebar, since it is not one of the newest. Nothing to change in your app.
+
+**"Completed with issues" means the turn ended on a problem.** A finished turn's collapsed card said "Completed with issues" when any tool call in it had failed, so a long run that opened its pull request after a few failed reads or commands read as a failure. It now says so only when the turn ended on a failed call (no later call completed) or held a call the person refused; otherwise it reads `Used N tools`. `getActivitySummary` follows the same rule.
+
 ## What's new in 0.41.2
 
 **A session opened while its run is streaming shows, and keeps, its own model.** `useAthenaThreadModel()` could report `ready` with no model before the session's snapshot had arrived. On a session whose run was streaming, the connection reported `connected` before the attach snapshot applied, and the SDK took the placeholder the thread shows meanwhile, which holds no server config, as what the server sent. A picker seeded from it showed the agent's default model, and the provider then wrote that pick to the session (`config/patch {model: null}`), so the session lost its model for its next turns. `ready`, and every config write the provider decides, now wait for a state the server sent: the placeholder and a remembered snapshot never count, whenever the connection reports `connected`. The `statewire.attach` diagnostics span (time to the session's snapshot) now ends when that snapshot arrives, not when the thread first renders.
@@ -2045,6 +2141,8 @@ The transcript is `SuperGroupingTranscript` from `@athenaintel/react/super-group
 
 Every step row and every thread tool card reads one summary registry, `summarizeToolCall({ toolName, args, result, status })` → `{ label, detail?, meta?, code? }` (also on `@athenaintel/react/tools`). It has rules for the deep agent's core tools (`execute`, the workspace file tools, `search_assets`, the computer and GitHub tools, web search and browse, `read_asset`, `write_todos`, `task`, and the UI Testing toolkit's `test_recording_start` / `_mark` / `_stop`); other tools read the shared display registry, and a tool neither knows falls back to a host catalog name (`resolveToolDisplayName`), else its sentence-cased name. A call that targets a machine or document by id (`sandbox_asset_id`, `computer_asset_id`) is named by its title when an earlier result in the turn carried one (`collectAssetTitles`); nothing is fetched.
 
+A delegation to a subagent (`task`) stays in the conversation, as an email draft or a UI test report does: the subagent card, with its state, tool calls, clock and newest step, and its steps behind its disclosure (see [What's new in 0.42.0](#whats-new-in-0420)).
+
 Every tool call it renders — the generic `ToolFallback`, the built-in tool UIs, nested sub-calls — shares one row anatomy: a status glyph (spinner / check / x / alert), the verb and its target on one line, a running call's elapsed seconds after three, a failed call tinted red, and a disclosure for the arguments and result.
 
 That row is the `thread` appearance of `ToolFallback`. Hosts that render their own thread keep the boxed host card they render today (the default, `card`); to adopt the row, wrap the thread in the provider or set it per card:
@@ -2110,9 +2208,10 @@ function MeetingCard({ block }: { block: string }) {
 
 Both hooks are safe to call at any time. A write made before the chat is
 ready — with `enableThreadList`, while the list is still resolving the active
-thread, or while the thread's history is still loading — waits in the provider
-and lands once the composer is ready, instead of being lost with the mount it
-was written into (the provider keys its statewire subtree by thread). Readiness
+thread, while the thread's history is still loading, or while a sign-in
+provider above the chat is still loading who is signed in — waits in the
+provider and lands once the composer is ready, instead of being lost with the
+mount it was written into (the provider keys its statewire subtree by thread). Readiness
 is not the socket: a never-started chat sits in `standby` until its first send
 and still takes a prefill. Early writes keep their order (two early sends both
 go out, first then second; adjacent plain appends fold into one draft), and

package/dist/agent-runtime/src/asset-attachment.d.ts

@@ -0,0 +1,98 @@
+import type { Attachment, AttachmentAdapter, CompleteAttachment, PendingAttachment } from '@assistant-ui/core';
+/**
+ * Shared Athena asset-attachment choreography (issue #29088): upload the file
+ * as a normal Athena asset, insert its final mention into the host composer,
+ * and yield no assistant-ui attachment tile — the deep-agent backend resolves
+ * the mention (documents via read_asset, images inlined server-side), so no
+ * duplicate base64 part ever enters statewire. No preparation state rides the
+ * wire: readiness is local to the composer doing the attaching.
+ */
+export interface UploadedChatAsset {
+    id: string;
+    title: string;
+    assetType: string;
+}
+/** Composer mention-insertion hook. The source file stays local to the client
+ * and lets rich composers show a preview without putting image bytes on the
+ * statewire. The return value is awaited when it is a promise and otherwise
+ * ignored, so ordinary event-handler arrows fit. */
+export type ChatAssetMentionHandler = (asset: UploadedChatAsset, sourceFile?: File) => unknown;
+/**
+ * Register the composer's mention-insertion hook for one thread. The hook is
+ * the per-client seam — TipTap on web, the native editor bridge on mobile —
+ * and the identity-checked unregister keeps a stale composer from clobbering
+ * a newer registration.
+ */
+export declare function registerChatAssetMentionHandler(threadId: string, handler: ChatAssetMentionHandler): () => void;
+export declare function getChatAssetMentionHandler(threadId: string): ChatAssetMentionHandler | undefined;
+export interface ChatAssetUploadResponse {
+    success?: Array<{
+        id?: unknown;
+        title?: unknown;
+        file_name?: unknown;
+        athena_original_type?: unknown;
+    }>;
+}
+/**
+ * Map agora's `/api/upload/` response to the mention payload. Title falls
+ * back `title → file_name → local file name`; the asset type falls back to
+ * the caller's sniffed default when the row carries none.
+ */
+export declare function uploadedChatAsset(args: {
+    body: ChatAssetUploadResponse;
+    fallbackTitle: string;
+    fallbackAssetType: string;
+}): UploadedChatAsset;
+/** The local default when the upload response carries no asset type. */
+export declare function sniffAssetTypeForFile(file: {
+    type: string;
+}): string;
+export interface UploadChatAssetOptions {
+    /** Agora base URL (trailing slashes tolerated). */
+    baseUrl: string;
+    file: File;
+    /** Auth headers for the upload request. */
+    headers: () => Promise<Record<string, string>> | Record<string, string>;
+    /**
+     * Fresh headers for exactly one retry after a 401 (e.g. a force-renewed
+     * token). Omitted, a 401 fails like any other error status.
+     */
+    retryHeadersOn401?: () => Promise<Record<string, string>> | Record<string, string>;
+    /** Upload timeout; the request aborts (and the add() rejects) past it. */
+    timeoutMs?: number;
+}
+/**
+ * Upload one file as an Athena asset through agora's `/api/upload/`.
+ * Cancellation and the timeout live inside the adapter path by construction:
+ * the abort signal rejects the `add()` generator, so the composer's send
+ * (which awaits adapter completion) can never race a hung upload.
+ */
+export declare function uploadChatAsset(options: UploadChatAssetOptions): Promise<UploadedChatAsset>;
+export interface AthenaAssetAttachmentAdapterOptions {
+    threadId: string;
+    /** File-picker filter; defaults to images (the deep-agent mention path). */
+    accept?: string;
+    /** Platform upload transport; most hosts wrap {@link uploadChatAsset}. */
+    upload: (file: File) => Promise<UploadedChatAsset>;
+}
+/**
+ * The shared mention-backed attachment adapter: `add()` requires the thread's
+ * registered composer hook up front (no upload cost when the composer is
+ * gone), uploads, then inserts the mention into the thread's CURRENT hook —
+ * a same-thread composer remount mid-upload still receives the mention, and
+ * the thread-keyed registry makes cross-thread insertion impossible by
+ * construction. A thread whose hook is gone after the upload rejects with a
+ * visible error (the conversation closed; the user must re-attach).
+ * `send()` throws by contract: mention-backed attachments are never message
+ * parts.
+ */
+export declare class AthenaAssetAttachmentAdapter implements AttachmentAdapter {
+    private readonly options;
+    readonly accept: string;
+    constructor(options: AthenaAssetAttachmentAdapterOptions);
+    add(args: {
+        file: File;
+    }): AsyncGenerator<PendingAttachment, void>;
+    remove(_attachment: Attachment): Promise<void>;
+    send(_attachment: PendingAttachment): Promise<CompleteAttachment>;
+}

package/dist/agent-runtime/src/athena-asset-drag.d.ts

@@ -0,0 +1,32 @@
+import type { UploadedChatAsset } from "./asset-attachment";
+/**
+ * Cross-surface drag payload for an Athena asset. Olympus sets it when a
+ * Spaces tab or sidebar row starts a native drag so a composer in another
+ * document (the Chrome extension side panel, an embedded SDK chat) can insert
+ * an asset mention instead of the drag's incidental text.
+ */
+export declare const ATHENA_ASSET_DRAG_MIME = "application/x-athena-asset+json";
+/** Olympus's FlexLayout tab drags carry the tab's asset id under this type. */
+export declare const FLEXLAYOUT_TAB_DRAG_MIME = "application/x-flexlayout-tab";
+/** The `text/plain` value FlexLayout writes on every tab drag. */
+export declare const FLEXLAYOUT_DRAG_TEXT_SENTINEL = "--flexlayout--";
+/** The `DataTransfer` surface read here (agent-runtime has no DOM lib). */
+interface DragData {
+    getData(format: string): string;
+}
+export declare function serializeAthenaAssetDrag(asset: UploadedChatAsset): string;
+/** Whether a drag carries an Athena asset — readable during `dragover`. */
+export declare function isAthenaAssetDrag(types: Iterable<string>): boolean;
+export type AthenaAssetDrop = {
+    kind: "asset";
+    asset: UploadedChatAsset;
+}
+/** An Athena asset drag whose metadata did not travel — swallow it rather
+ * than let the editor paste the sentinel text. */
+ | {
+    kind: "unresolved";
+    assetId: string | null;
+} | null;
+/** Reads an Athena asset from a drop, or `null` when the drop is not one. */
+export declare function readAthenaAssetDrop(dataTransfer: DragData): AthenaAssetDrop;
+export {};

package/dist/agent-runtime/src/auth-denial.d.ts

@@ -0,0 +1,29 @@
+import type { DeepAgentConnectionState } from './types';
+/**
+ * How many consecutive `unauthorized` attach denials park the transport.
+ *
+ * The client's reconnect backoff reaches its 30s ceiling around the eighth
+ * attempt, so eight denials ≈ one minute of the server actively refusing the
+ * credential. Transient auth blips (a tab waking with a stale token that
+ * refreshes on the next attempt) recover in one or two attempts and never
+ * park; a credential the server keeps refusing (revoked access, no workspace)
+ * would otherwise retry every 30s indefinitely — the prod "attach denied"
+ * loops ran for hours per tab.
+ */
+export declare const AUTH_DENIAL_PARK_THRESHOLD = 8;
+export interface AuthDenialTrackerState {
+    /** Reconnect attempt number of the last counted denial (dedupes converter re-runs). */
+    lastAttempt: number | null;
+    /** Consecutive `unauthorized` denials observed on this attach. */
+    consecutive: number;
+    /** The denial's host-supplied message, kept for the parked connection state. */
+    message: string | undefined;
+}
+export declare const initialAuthDenialTrackerState: () => AuthDenialTrackerState;
+/** Count distinct unauthorized retries, preserving the streak during each dial. */
+export declare function observeAuthDenial(state: AuthDenialTrackerState, connection: DeepAgentConnectionState, { threshold }?: {
+    threshold?: number;
+}): {
+    state: AuthDenialTrackerState;
+    park: boolean;
+};

package/dist/agent-runtime/src/chat-outbox-attachments.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function chatOutboxAttachmentPath(assetId) {
+  return `/api/v0/assets/${encodeURIComponent(assetId)}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function verdictOf(response) {
+  if (response.status === 403 || response.status === 404) return "refused";
+  if (response.status < 200 || response.status >= 300) return "unknown";
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return "unknown";
+  }
+  if (!isRecord(body)) return "unknown";
+  return body.is_archived === true ? "refused" : "ok";
+}
+function createChatOutboxAttachmentCheck({
+  readAsset
+}) {
+  return async (attachments) => {
+    let unknown = false;
+    for (const assetId of new Set(attachments.map((attachment) => attachment.assetId))) {
+      let verdict;
+      try {
+        verdict = await verdictOf(await readAsset(assetId));
+      } catch {
+        verdict = "unknown";
+      }
+      if (verdict === "refused") return "refused";
+      if (verdict === "unknown") unknown = true;
+    }
+    return unknown ? "unknown" : "ok";
+  };
+}
+exports.chatOutboxAttachmentPath = chatOutboxAttachmentPath;
+exports.createChatOutboxAttachmentCheck = createChatOutboxAttachmentCheck;
+//# sourceMappingURL=chat-outbox-attachments.cjs.map

package/dist/agent-runtime/src/chat-outbox-attachments.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-outbox-attachments.cjs","sources":["../../../../agent-runtime/src/chat-outbox-attachments.ts"],"sourcesContent":["import type { ChatOutboxAttachment } from \"./chat-outbox-store\";\n\n/**\n * Whether a waiting message's attachments can still be opened, asked of Athena right before the\n * message goes (`chat-outbox.ts`). A held message carries only files that had finished uploading\n * before Athena went out of reach, but one may be deleted, or stop being shared with the person,\n * while it waits: the message must not go with a reference Athena no longer lets them open.\n *\n * Each file is read through agora's permission-checked `GET /api/v0/assets/{id}`\n * (`get_asset_access_context_or_http`: `get_asset_with_permission_check` in the asset's workspace)\n * as the signed-in person. Nothing here grants anything: the run reads every attachment through\n * the same gates again when it uses it.\n */\n\n/** What Athena answered about a waiting message's attachments. */\nexport type ChatOutboxAttachmentVerdict =\n  /** Every one is still there and still the person's to open. */\n  | \"ok\"\n  /** At least one is gone (deleted, or in the trash) or no longer the person's to open. */\n  | \"refused\"\n  /** Athena could not say: a read failed, timed out, or its credential was refused. */\n  | \"unknown\";\n\n/** Asks Athena about a waiting message's attachments. */\nexport type ChatOutboxAttachmentCheck = (\n  attachments: readonly ChatOutboxAttachment[],\n) => Promise<ChatOutboxAttachmentVerdict>;\n\n/** agora's permission-checked read of one asset, relative to its API base. */\nexport function chatOutboxAttachmentPath(assetId: string): string {\n  return `/api/v0/assets/${encodeURIComponent(assetId)}`;\n}\n\n/** As much of a `fetch` response as the check reads. */\nexport interface ChatOutboxAssetReadResponse {\n  status: number;\n  json(): Promise<unknown>;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n\nasync function verdictOf(response: ChatOutboxAssetReadResponse): Promise<ChatOutboxAttachmentVerdict> {\n  // 404: the asset is gone (or never was); 403: it is no longer the person's to open.\n  if (response.status === 403 || response.status === 404) return \"refused\";\n  if (response.status < 200 || response.status >= 300) return \"unknown\";\n  // A body that does not read (cut off, or not agora's JSON) never says whether the file is in\n  // the trash: that is no answer.\n  let body: unknown;\n  try {\n    body = await response.json();\n  } catch {\n    return \"unknown\";\n  }\n  if (!isRecord(body)) return \"unknown\";\n  // An archived asset is in the trash: deleted, as far as a message is concerned.\n  return body.is_archived === true ? \"refused\" : \"ok\";\n}\n\n/**\n * The check a host hands its chat outbox: each attachment read once, in turn, through `readAsset`\n * (`GET {agora}{chatOutboxAttachmentPath(id)}` with the person's credential, renewed once on a\n * refused token where the host can, under the host's own request timeout). `refused` as soon as\n * one is refused; `unknown` when none was refused but one could not be read; else `ok`.\n */\nexport function createChatOutboxAttachmentCheck({\n  readAsset,\n}: {\n  readAsset: (assetId: string) => Promise<ChatOutboxAssetReadResponse>;\n}): ChatOutboxAttachmentCheck {\n  return async (attachments) => {\n    let unknown = false;\n    for (const assetId of new Set(attachments.map((attachment) => attachment.assetId))) {\n      let verdict: ChatOutboxAttachmentVerdict;\n      try {\n        verdict = await verdictOf(await readAsset(assetId));\n      } catch {\n        verdict = \"unknown\";\n      }\n      if (verdict === \"refused\") return \"refused\";\n      if (verdict === \"unknown\") unknown = true;\n    }\n    return unknown ? \"unknown\" : \"ok\";\n  };\n}\n"],"names":[],"mappings":";;AA6BO,SAAS,yBAAyB,SAAyB;AAChE,SAAO,kBAAkB,mBAAmB,OAAO,CAAC;AACtD;AAQA,SAAS,SAAS,OAAkD;AAClE,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;AAEA,eAAe,UAAU,UAA6E;AAEpG,MAAI,SAAS,WAAW,OAAO,SAAS,WAAW,IAAK,QAAO;AAC/D,MAAI,SAAS,SAAS,OAAO,SAAS,UAAU,IAAK,QAAO;AAG5D,MAAI;AACJ,MAAI;AACF,WAAO,MAAM,SAAS,KAAA;AAAA,EACxB,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI,CAAC,SAAS,IAAI,EAAG,QAAO;AAE5B,SAAO,KAAK,gBAAgB,OAAO,YAAY;AACjD;AAQO,SAAS,gCAAgC;AAAA,EAC9C;AACF,GAE8B;AAC5B,SAAO,OAAO,gBAAgB;AAC5B,QAAI,UAAU;AACd,eAAW,WAAW,IAAI,IAAI,YAAY,IAAI,CAAC,eAAe,WAAW,OAAO,CAAC,GAAG;AAClF,UAAI;AACJ,UAAI;AACF,kBAAU,MAAM,UAAU,MAAM,UAAU,OAAO,CAAC;AAAA,MACpD,QAAQ;AACN,kBAAU;AAAA,MACZ;AACA,UAAI,YAAY,UAAW,QAAO;AAClC,UAAI,YAAY,UAAW,WAAU;AAAA,IACvC;AACA,WAAO,UAAU,YAAY;AAAA,EAC/B;AACF;;;"}

package/dist/agent-runtime/src/chat-outbox-attachments.d.ts

@@ -0,0 +1,38 @@
+import type { ChatOutboxAttachment } from "./chat-outbox-store";
+/**
+ * Whether a waiting message's attachments can still be opened, asked of Athena right before the
+ * message goes (`chat-outbox.ts`). A held message carries only files that had finished uploading
+ * before Athena went out of reach, but one may be deleted, or stop being shared with the person,
+ * while it waits: the message must not go with a reference Athena no longer lets them open.
+ *
+ * Each file is read through agora's permission-checked `GET /api/v0/assets/{id}`
+ * (`get_asset_access_context_or_http`: `get_asset_with_permission_check` in the asset's workspace)
+ * as the signed-in person. Nothing here grants anything: the run reads every attachment through
+ * the same gates again when it uses it.
+ */
+/** What Athena answered about a waiting message's attachments. */
+export type ChatOutboxAttachmentVerdict = 
+/** Every one is still there and still the person's to open. */
+"ok"
+/** At least one is gone (deleted, or in the trash) or no longer the person's to open. */
+ | "refused"
+/** Athena could not say: a read failed, timed out, or its credential was refused. */
+ | "unknown";
+/** Asks Athena about a waiting message's attachments. */
+export type ChatOutboxAttachmentCheck = (attachments: readonly ChatOutboxAttachment[]) => Promise<ChatOutboxAttachmentVerdict>;
+/** agora's permission-checked read of one asset, relative to its API base. */
+export declare function chatOutboxAttachmentPath(assetId: string): string;
+/** As much of a `fetch` response as the check reads. */
+export interface ChatOutboxAssetReadResponse {
+    status: number;
+    json(): Promise<unknown>;
+}
+/**
+ * The check a host hands its chat outbox: each attachment read once, in turn, through `readAsset`
+ * (`GET {agora}{chatOutboxAttachmentPath(id)}` with the person's credential, renewed once on a
+ * refused token where the host can, under the host's own request timeout). `refused` as soon as
+ * one is refused; `unknown` when none was refused but one could not be read; else `ok`.
+ */
+export declare function createChatOutboxAttachmentCheck({ readAsset, }: {
+    readAsset: (assetId: string) => Promise<ChatOutboxAssetReadResponse>;
+}): ChatOutboxAttachmentCheck;

package/dist/agent-runtime/src/chat-outbox-attachments.js

@@ -0,0 +1,41 @@
+function chatOutboxAttachmentPath(assetId) {
+  return `/api/v0/assets/${encodeURIComponent(assetId)}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function verdictOf(response) {
+  if (response.status === 403 || response.status === 404) return "refused";
+  if (response.status < 200 || response.status >= 300) return "unknown";
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return "unknown";
+  }
+  if (!isRecord(body)) return "unknown";
+  return body.is_archived === true ? "refused" : "ok";
+}
+function createChatOutboxAttachmentCheck({
+  readAsset
+}) {
+  return async (attachments) => {
+    let unknown = false;
+    for (const assetId of new Set(attachments.map((attachment) => attachment.assetId))) {
+      let verdict;
+      try {
+        verdict = await verdictOf(await readAsset(assetId));
+      } catch {
+        verdict = "unknown";
+      }
+      if (verdict === "refused") return "refused";
+      if (verdict === "unknown") unknown = true;
+    }
+    return unknown ? "unknown" : "ok";
+  };
+}
+export {
+  chatOutboxAttachmentPath,
+  createChatOutboxAttachmentCheck
+};
+//# sourceMappingURL=chat-outbox-attachments.js.map

package/dist/agent-runtime/src/chat-outbox-attachments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-outbox-attachments.js","sources":["../../../../agent-runtime/src/chat-outbox-attachments.ts"],"sourcesContent":["import type { ChatOutboxAttachment } from \"./chat-outbox-store\";\n\n/**\n * Whether a waiting message's attachments can still be opened, asked of Athena right before the\n * message goes (`chat-outbox.ts`). A held message carries only files that had finished uploading\n * before Athena went out of reach, but one may be deleted, or stop being shared with the person,\n * while it waits: the message must not go with a reference Athena no longer lets them open.\n *\n * Each file is read through agora's permission-checked `GET /api/v0/assets/{id}`\n * (`get_asset_access_context_or_http`: `get_asset_with_permission_check` in the asset's workspace)\n * as the signed-in person. Nothing here grants anything: the run reads every attachment through\n * the same gates again when it uses it.\n */\n\n/** What Athena answered about a waiting message's attachments. */\nexport type ChatOutboxAttachmentVerdict =\n  /** Every one is still there and still the person's to open. */\n  | \"ok\"\n  /** At least one is gone (deleted, or in the trash) or no longer the person's to open. */\n  | \"refused\"\n  /** Athena could not say: a read failed, timed out, or its credential was refused. */\n  | \"unknown\";\n\n/** Asks Athena about a waiting message's attachments. */\nexport type ChatOutboxAttachmentCheck = (\n  attachments: readonly ChatOutboxAttachment[],\n) => Promise<ChatOutboxAttachmentVerdict>;\n\n/** agora's permission-checked read of one asset, relative to its API base. */\nexport function chatOutboxAttachmentPath(assetId: string): string {\n  return `/api/v0/assets/${encodeURIComponent(assetId)}`;\n}\n\n/** As much of a `fetch` response as the check reads. */\nexport interface ChatOutboxAssetReadResponse {\n  status: number;\n  json(): Promise<unknown>;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n\nasync function verdictOf(response: ChatOutboxAssetReadResponse): Promise<ChatOutboxAttachmentVerdict> {\n  // 404: the asset is gone (or never was); 403: it is no longer the person's to open.\n  if (response.status === 403 || response.status === 404) return \"refused\";\n  if (response.status < 200 || response.status >= 300) return \"unknown\";\n  // A body that does not read (cut off, or not agora's JSON) never says whether the file is in\n  // the trash: that is no answer.\n  let body: unknown;\n  try {\n    body = await response.json();\n  } catch {\n    return \"unknown\";\n  }\n  if (!isRecord(body)) return \"unknown\";\n  // An archived asset is in the trash: deleted, as far as a message is concerned.\n  return body.is_archived === true ? \"refused\" : \"ok\";\n}\n\n/**\n * The check a host hands its chat outbox: each attachment read once, in turn, through `readAsset`\n * (`GET {agora}{chatOutboxAttachmentPath(id)}` with the person's credential, renewed once on a\n * refused token where the host can, under the host's own request timeout). `refused` as soon as\n * one is refused; `unknown` when none was refused but one could not be read; else `ok`.\n */\nexport function createChatOutboxAttachmentCheck({\n  readAsset,\n}: {\n  readAsset: (assetId: string) => Promise<ChatOutboxAssetReadResponse>;\n}): ChatOutboxAttachmentCheck {\n  return async (attachments) => {\n    let unknown = false;\n    for (const assetId of new Set(attachments.map((attachment) => attachment.assetId))) {\n      let verdict: ChatOutboxAttachmentVerdict;\n      try {\n        verdict = await verdictOf(await readAsset(assetId));\n      } catch {\n        verdict = \"unknown\";\n      }\n      if (verdict === \"refused\") return \"refused\";\n      if (verdict === \"unknown\") unknown = true;\n    }\n    return unknown ? \"unknown\" : \"ok\";\n  };\n}\n"],"names":[],"mappings":"AA6BO,SAAS,yBAAyB,SAAyB;AAChE,SAAO,kBAAkB,mBAAmB,OAAO,CAAC;AACtD;AAQA,SAAS,SAAS,OAAkD;AAClE,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;AAEA,eAAe,UAAU,UAA6E;AAEpG,MAAI,SAAS,WAAW,OAAO,SAAS,WAAW,IAAK,QAAO;AAC/D,MAAI,SAAS,SAAS,OAAO,SAAS,UAAU,IAAK,QAAO;AAG5D,MAAI;AACJ,MAAI;AACF,WAAO,MAAM,SAAS,KAAA;AAAA,EACxB,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI,CAAC,SAAS,IAAI,EAAG,QAAO;AAE5B,SAAO,KAAK,gBAAgB,OAAO,YAAY;AACjD;AAQO,SAAS,gCAAgC;AAAA,EAC9C;AACF,GAE8B;AAC5B,SAAO,OAAO,gBAAgB;AAC5B,QAAI,UAAU;AACd,eAAW,WAAW,IAAI,IAAI,YAAY,IAAI,CAAC,eAAe,WAAW,OAAO,CAAC,GAAG;AAClF,UAAI;AACJ,UAAI;AACF,kBAAU,MAAM,UAAU,MAAM,UAAU,OAAO,CAAC;AAAA,MACpD,QAAQ;AACN,kBAAU;AAAA,MACZ;AACA,UAAI,YAAY,UAAW,QAAO;AAClC,UAAI,YAAY,UAAW,WAAU;AAAA,IACvC;AACA,WAAO,UAAU,YAAY;AAAA,EAC/B;AACF;"}

package/dist/agent-runtime/src/chat-outbox-signals.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const host = globalThis;
+function subscribeTo(targets, events, listener) {
+  const bound = targets.filter((target) => target !== void 0);
+  for (const target of bound) for (const event of events) target.addEventListener(event, listener);
+  return () => {
+    for (const target of bound) for (const event of events) target.removeEventListener(event, listener);
+  };
+}
+function browserOnlineSignal() {
+  return {
+    get: () => {
+      var _a;
+      return ((_a = host.navigator) == null ? void 0 : _a.onLine) !== false;
+    },
+    subscribe: (listener) => subscribeTo([typeof host.addEventListener === "function" ? host : void 0], ["online", "offline"], listener)
+  };
+}
+function documentVisibleSignal() {
+  return {
+    get: () => {
+      var _a;
+      return ((_a = host.document) == null ? void 0 : _a.visibilityState) !== "hidden";
+    },
+    subscribe: (listener) => subscribeTo([host.document], ["visibilitychange"], listener)
+  };
+}
+function windowInFrontSignal() {
+  const windowTarget = typeof host.addEventListener === "function" ? host : void 0;
+  return {
+    get: () => {
+      const document = host.document;
+      if (!document) return true;
+      if (document.visibilityState === "hidden") return false;
+      return typeof document.hasFocus === "function" ? document.hasFocus() : true;
+    },
+    subscribe: (listener) => {
+      const stopDocument = subscribeTo([host.document], ["visibilitychange"], listener);
+      const stopWindow = subscribeTo([windowTarget], ["focus", "blur"], listener);
+      return () => {
+        stopDocument();
+        stopWindow();
+      };
+    }
+  };
+}
+function allChatOutboxSignals(...signals) {
+  return {
+    get: () => signals.every((signal) => signal.get()),
+    subscribe: (listener) => {
+      const stops = signals.map((signal) => signal.subscribe(listener));
+      return () => {
+        for (const stop of stops) stop();
+      };
+    }
+  };
+}
+exports.allChatOutboxSignals = allChatOutboxSignals;
+exports.browserOnlineSignal = browserOnlineSignal;
+exports.documentVisibleSignal = documentVisibleSignal;
+exports.windowInFrontSignal = windowInFrontSignal;
+//# sourceMappingURL=chat-outbox-signals.cjs.map

package/dist/agent-runtime/src/chat-outbox-signals.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-outbox-signals.cjs","sources":["../../../../agent-runtime/src/chat-outbox-signals.ts"],"sourcesContent":["import type { ChatOutboxSignal } from \"./chat-outbox\";\n\n/**\n * Default signals for the chat outbox on browser hosts. A host with its own reachability model\n * (Olympus's `athena-reachability`, the mobile app's `connectivity`) passes that instead: \"online\"\n * means the device is online AND agora answers, which the browser alone cannot tell.\n *\n * This package compiles without the DOM lib, so the browser globals are described structurally.\n */\n\ntype EventTargetLike = {\n  addEventListener(type: string, listener: () => void): void;\n  removeEventListener(type: string, listener: () => void): void;\n};\n\ntype BrowserHost = EventTargetLike & {\n  navigator?: { onLine?: boolean };\n  document?: EventTargetLike & { visibilityState?: string; hasFocus?: () => boolean };\n};\n\nconst host = globalThis as unknown as Partial<BrowserHost>;\n\nfunction subscribeTo(\n  targets: readonly (EventTargetLike | undefined)[],\n  events: readonly string[],\n  listener: () => void,\n): () => void {\n  const bound = targets.filter((target): target is EventTargetLike => target !== undefined);\n  for (const target of bound) for (const event of events) target.addEventListener(event, listener);\n  return () => {\n    for (const target of bound) for (const event of events) target.removeEventListener(event, listener);\n  };\n}\n\n/** The browser's own word on the network (`navigator.onLine`); true where there is no browser. */\nexport function browserOnlineSignal(): ChatOutboxSignal {\n  return {\n    get: () => host.navigator?.onLine !== false,\n    subscribe: (listener) =>\n      subscribeTo([typeof host.addEventListener === \"function\" ? (host as EventTargetLike) : undefined], [\"online\", \"offline\"], listener),\n  };\n}\n\n/** A tab in front: the document is visible (a hidden tab never sends). */\nexport function documentVisibleSignal(): ChatOutboxSignal {\n  return {\n    get: () => host.document?.visibilityState !== \"hidden\",\n    subscribe: (listener) => subscribeTo([host.document], [\"visibilitychange\"], listener),\n  };\n}\n\n/**\n * A desktop window in front: visible and focused. An unfocused or minimized window waits until the\n * person comes back to it.\n */\nexport function windowInFrontSignal(): ChatOutboxSignal {\n  const windowTarget = typeof host.addEventListener === \"function\" ? (host as EventTargetLike) : undefined;\n  return {\n    get: () => {\n      const document = host.document;\n      if (!document) return true;\n      if (document.visibilityState === \"hidden\") return false;\n      return typeof document.hasFocus === \"function\" ? document.hasFocus() : true;\n    },\n    subscribe: (listener) => {\n      const stopDocument = subscribeTo([host.document], [\"visibilitychange\"], listener);\n      const stopWindow = subscribeTo([windowTarget], [\"focus\", \"blur\"], listener);\n      return () => {\n        stopDocument();\n        stopWindow();\n      };\n    },\n  };\n}\n\n/** Both signals at once (e.g. a host's reachability AND the browser being online). */\nexport function allChatOutboxSignals(...signals: readonly ChatOutboxSignal[]): ChatOutboxSignal {\n  return {\n    get: () => signals.every((signal) => signal.get()),\n    subscribe: (listener) => {\n      const stops = signals.map((signal) => signal.subscribe(listener));\n      return () => {\n        for (const stop of stops) stop();\n      };\n    },\n  };\n}\n"],"names":[],"mappings":";;AAoBA,MAAM,OAAO;AAEb,SAAS,YACP,SACA,QACA,UACY;AACZ,QAAM,QAAQ,QAAQ,OAAO,CAAC,WAAsC,WAAW,MAAS;AACxF,aAAW,UAAU,MAAO,YAAW,SAAS,OAAQ,QAAO,iBAAiB,OAAO,QAAQ;AAC/F,SAAO,MAAM;AACX,eAAW,UAAU,MAAO,YAAW,SAAS,OAAQ,QAAO,oBAAoB,OAAO,QAAQ;AAAA,EACpG;AACF;AAGO,SAAS,sBAAwC;AACtD,SAAO;AAAA,IACL,KAAK,MAAA;;AAAM,yBAAK,cAAL,mBAAgB,YAAW;AAAA;AAAA,IACtC,WAAW,CAAC,aACV,YAAY,CAAC,OAAO,KAAK,qBAAqB,aAAc,OAA2B,MAAS,GAAG,CAAC,UAAU,SAAS,GAAG,QAAQ;AAAA,EAAA;AAExI;AAGO,SAAS,wBAA0C;AACxD,SAAO;AAAA,IACL,KAAK,MAAA;;AAAM,yBAAK,aAAL,mBAAe,qBAAoB;AAAA;AAAA,IAC9C,WAAW,CAAC,aAAa,YAAY,CAAC,KAAK,QAAQ,GAAG,CAAC,kBAAkB,GAAG,QAAQ;AAAA,EAAA;AAExF;AAMO,SAAS,sBAAwC;AACtD,QAAM,eAAe,OAAO,KAAK,qBAAqB,aAAc,OAA2B;AAC/F,SAAO;AAAA,IACL,KAAK,MAAM;AACT,YAAM,WAAW,KAAK;AACtB,UAAI,CAAC,SAAU,QAAO;AACtB,UAAI,SAAS,oBAAoB,SAAU,QAAO;AAClD,aAAO,OAAO,SAAS,aAAa,aAAa,SAAS,aAAa;AAAA,IACzE;AAAA,IACA,WAAW,CAAC,aAAa;AACvB,YAAM,eAAe,YAAY,CAAC,KAAK,QAAQ,GAAG,CAAC,kBAAkB,GAAG,QAAQ;AAChF,YAAM,aAAa,YAAY,CAAC,YAAY,GAAG,CAAC,SAAS,MAAM,GAAG,QAAQ;AAC1E,aAAO,MAAM;AACX,qBAAA;AACA,mBAAA;AAAA,MACF;AAAA,IACF;AAAA,EAAA;AAEJ;AAGO,SAAS,wBAAwB,SAAwD;AAC9F,SAAO;AAAA,IACL,KAAK,MAAM,QAAQ,MAAM,CAAC,WAAW,OAAO,KAAK;AAAA,IACjD,WAAW,CAAC,aAAa;AACvB,YAAM,QAAQ,QAAQ,IAAI,CAAC,WAAW,OAAO,UAAU,QAAQ,CAAC;AAChE,aAAO,MAAM;AACX,mBAAW,QAAQ,MAAO,MAAA;AAAA,MAC5B;AAAA,IACF;AAAA,EAAA;AAEJ;;;;;"}

package/dist/agent-runtime/src/chat-outbox-signals.d.ts

@@ -0,0 +1,12 @@
+import type { ChatOutboxSignal } from "./chat-outbox";
+/** The browser's own word on the network (`navigator.onLine`); true where there is no browser. */
+export declare function browserOnlineSignal(): ChatOutboxSignal;
+/** A tab in front: the document is visible (a hidden tab never sends). */
+export declare function documentVisibleSignal(): ChatOutboxSignal;
+/**
+ * A desktop window in front: visible and focused. An unfocused or minimized window waits until the
+ * person comes back to it.
+ */
+export declare function windowInFrontSignal(): ChatOutboxSignal;
+/** Both signals at once (e.g. a host's reachability AND the browser being online). */
+export declare function allChatOutboxSignals(...signals: readonly ChatOutboxSignal[]): ChatOutboxSignal;