@athenaintel/react 0.42.1 → 0.43.0

package/README.md

@@ -245,11 +245,14 @@ 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. 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.
+next user's token. That holds while the chat stays mounted too: when the
+signed-in user changes under it, the chat reconnects on the new user's lane as
+a new client, and what the previous user had not yet delivered waits under
+their name for their next sign-in. 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`:
 
@@ -737,12 +740,32 @@ registry entries (`SESSION_WORKBENCH_TASKS_PANE`, …), the data hooks
 (`deriveShellRows`, `filterShellRows`, `deriveTaskSteps`, `taskProgress`,
 `workspaceComputers`) are exported for hosts composing their own.
 
+## Chat voice in AthenaChat
+
+`AthenaChat` includes realtime voice alongside dictation where the deployment
+and workspace enable it. Start with the headphones button; during a call it
+mutes or unmutes the microphone, and the voice strip ends the call. Plain typed
+messages join the live conversation. Attachments and quotes keep their normal
+run queue, and a refused voice text send falls back to that queue.
+
+The composer owns one shared voice controller and lazy LiveKit adapter. A
+pending connection can be cancelled, and unmount, a changed account/environment,
+or revoked voice access releases the microphone. Dictation and realtime voice
+cannot capture together. Model, agent, mode and toolkit changes sync through the
+same model context for the next delegated task.
+
+Use `<AthenaChat voice={false} />` to omit realtime voice in a host that cannot
+support it, or `voice={{ model: 'gemini-3.8-live' }}` to request a host-offered
+voice model. A custom `livekit` adapter and `onDiagnostic` observer are accepted
+in the same options. `readOnly` chats expose no voice controls. This UI uses the
+server's voice access decision; it cannot override workspace or deployment policy.
+
 ## 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.
+The SDK includes `livekit-client` at the shared runtime version; its media code loads only when a session starts.
 
 ```tsx
 import { useMemo, useRef } from 'react';
@@ -784,7 +807,7 @@ agent audio, live/interim transcript turns, reconnects, StrictMode-safe
 teardown — so an app is a `start()` button and a transcript list.
 
 ```bash
-bun add @athenaintel/react livekit-client   # optional peer dep, only needed for voice
+bun add @athenaintel/react
 ```
 
 ```tsx
@@ -860,6 +883,22 @@ 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.43.0
+
+**Asset and citation chips look and read like Olympus's.** A chip is now Olympus's mention pill in your theme's colours (grey on the default theme, still legible on a dark one): the asset's icon, its name, then the cited place in brackets (`Q4 report [p.5]`). Like Olympus's chips, it looks the asset up and shows the asset's own title and its type's icon instead of the link's label and `type=`. The lookup is agora's `getAssetsByIds` with the chat's credentials, which returns only the assets the viewer may read. Chips that render together ask in one request. Each answer is cached for a minute per backend and per signed-in person or API key (TanStack Query, on the host's `QueryClient` when there is one); a credential that names neither shares nothing beyond its own chat. Until the answer arrives, and for an asset the viewer may not read, the chip keeps the link's label and `type=`. A chip asks only where the answer changes it: never for a repository file's catalog (the chip reads as the file either way) or for a session (agora would read its whole row, transcript ledgers included). A chip with no credential to send (no token, API key or session cookie) asks for nothing.
+
+**A repository file citation reads as the file and its lines, with GitHub's mark.** A citation of a GitHub repository's lines (`type=catalog&anchor=file_line_range`) now reads `route.ts:18-24` whatever label the model wrote: the repository's name, a long path, or a label in backticks. A long file name shortens before its lines do. The tooltip carries what the chip leaves out: the model's label when it says something else, the repository, the whole path and the cited passage.
+
+**A place is drawn once.** A label that already ends with its place (`Q4 report p.5`, `olympus/…/route.ts:18-24`) is no longer followed by the place again. Nothing to change in your app.
+
+Also first on npm in 0.43.0 (0.42.3 was tagged, not published): an asset link whose text markdown split shows its text, not `[object Object]` (#48739); a new chat's title poll waits for a session-list read already in flight (#48730); shared voice commands are scoped to their call (#48761).
+
+## What's new in 0.42.2
+
+**A message one signed-in user queued is never sent as the next user who signs in to the same chat.** The chat keeps each conversation's unconfirmed commands in this browser under the signed-in user, so a reload can resend them. When the signed-in user changed while the chat stayed mounted (a sign-in provider of your own that signs a signed-out person in, or `AthenaSSOProvider` with `revalidateOnWindowFocus` picking up another account), the conversation moved to the new user's key and took the previous user's client id, command numbers and unsent commands with it. A message the previous user sent while offline, or that had not yet reached Athena, could then go out on the new user's connection, as the new user. With the chat connected at the time, the reverse happened: the new user's messages went out on the connection the previous user had opened, and Athena ran them as the previous user.
+
+The chat now treats a change of signed-in user as a new conversation session. It reconnects on the new user's own key as a new client, and loads the conversation again as that user instead of showing the previous user's copy of it. Nothing the previous user queued goes with it. What they had not yet delivered stays under their key in this browser: it goes out, as them, when they sign in to the chat again, and the usual 7-day retention removes it otherwise. A token refresh for the same user changes nothing. 0.42.1 and earlier carry the previous user's pending commands over to the next user. Nothing to change in your app.
+
 ## 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.

package/dist/agent-runtime/src/conversation-list-groups.d.ts

@@ -0,0 +1,74 @@
+import { type ConversationAttention } from "./conversation-list";
+/**
+ * Pure rules behind the session-list rows' attention affordances: Olympus's
+ * Sessions pane and Recent Conversations dropdown and Midas's sessions sidebar
+ * render the same indicator, next-action line and group placement from these,
+ * so the render tests stay thin and the surfaces cannot disagree
+ * (`docs/SESSIONS_LIST_GUIDE.md`, "Session attention").
+ */
+/** The fields a row needs to answer every rule here; a subset of `ConversationItem`. */
+export interface ConversationAttentionInput {
+    attention?: ConversationAttention | null;
+    runStatus: string | null;
+    sessionStatus: string | null;
+    state?: string | null;
+    nextAction?: string | null;
+    isFavorited?: boolean;
+    isUnread: boolean;
+    updatedAt: string;
+}
+/**
+ * The server-derived attention when the transport reports one Olympus knows,
+ * else the shared client fallback from the status planes — so a row from an
+ * older backend still reads `needs_you` on a human gate and `error` on a
+ * failed run.
+ */
+export declare function resolveConversationAttention(conversation: Pick<ConversationAttentionInput, "attention" | "runStatus" | "sessionStatus" | "state">): ConversationAttention | null;
+/**
+ * The one indicator a row shows, in precedence order: a pending action for
+ * the viewer beats a live run, which beats the unread dot, which beats
+ * "waiting on someone else", which beats a terminal error. `running` is the
+ * caller's resolved running state (the live stream signal wins for the open
+ * thread), not the attention field, so the spinner keeps today's behaviour.
+ */
+export type ConversationAttentionIndicator = "needs_you" | "running" | "unread" | "watching" | "error" | null;
+export declare function conversationAttentionIndicator({ attention, isRunning, isUnread, }: {
+    attention: ConversationAttention | null;
+    isRunning: boolean;
+    isUnread: boolean;
+}): ConversationAttentionIndicator;
+/** Tone of the next-action line, named after the design tokens that paint it. */
+export type ConversationNextActionTone = "warning" | "success" | "muted" | "destructive";
+export interface ConversationNextAction {
+    text: string;
+    tone: ConversationNextActionTone;
+}
+/**
+ * The row's second line when the server derived a next step: the text as
+ * sent (already ≤ 80 characters), toned by what the session asks — orange
+ * for `needs_you`, green for `ready`, red for `error`, muted otherwise.
+ * `null` when there is nothing to do, so the row shows its timestamp.
+ */
+export declare function conversationNextAction({ attention, nextAction, }: {
+    attention: ConversationAttention | null;
+    nextAction?: string | null;
+}): ConversationNextAction | null;
+export type ConversationTimeGroup = "Today" | "Yesterday" | "This Week" | "This Month" | "Older";
+/**
+ * Where a row lands in the Sessions pane: sessions that need the viewer
+ * first, then the viewer's pinned sessions, then everything else by when it
+ * last changed. A row appears once, in the FIRST group that applies.
+ */
+export type ConversationListGroup = "Needs you" | "Pinned" | ConversationTimeGroup;
+export declare const CONVERSATION_LIST_GROUP_ORDER: readonly ConversationListGroup[];
+export declare function conversationTimeGroup(dateStr: string, now?: Date): ConversationTimeGroup;
+export declare function conversationListGroupOf(conversation: ConversationAttentionInput, now?: Date): ConversationListGroup;
+export interface ConversationListSection<T extends ConversationAttentionInput> {
+    group: ConversationListGroup;
+    items: T[];
+}
+/**
+ * Sections in display order; empty groups are omitted and the list's own
+ * newest-first order is kept within each group.
+ */
+export declare function groupConversationsForList<T extends ConversationAttentionInput>(conversations: readonly T[], now?: Date): ConversationListSection<T>[];

package/dist/agent-runtime/src/index.d.ts

@@ -4,6 +4,7 @@ export { CLIENT_TOOL_INTERRUPT_SOURCE, clientToolCallArgs, type ClientToolCached
 export { CLIENT_TOOL_WRITE_DECLINED_MESSAGE, type ClientToolBridgeTool, type ClientToolCallSettledEvent, clientToolClaimKey, type ClientToolWriteConsentDecision, defaultMissingClientToolMessage, executeClientToolBatch, type ExecuteClientToolBatchOptions, isPendingClientToolRequest, jsonSafeClientToolResult, useStatewireClientToolBridge, type UseStatewireClientToolBridgeOptions, } from "./client-tool-bridge";
 export { conversationIndexFingerprint, conversationIndexId, conversationIndexUrlFromStatewireUrl, type ConversationIndexEntry, type ConversationWatchActivity, useConversationIndex, type UseConversationIndexOptions, type UseConversationIndexResult, watchActivityFingerprint, } from "./conversation-index";
 export { cancelConversationListCaches, CONVERSATION_ATTENTIONS, CONVERSATION_LIST_DEFAULT_SCOPE_KEY, CONVERSATION_LIST_QUERY_KEY_ROOT, type ConversationAttention, type ConversationAttentionSource, type ConversationListFetcher, type ConversationListFetchParams, type ConversationListFilter, type ConversationListPage, conversationListFilterKey, conversationListQueryKeys, type ConversationPullRequest, type ConversationSummary, type ConversationWake, deriveConversationAttention, invalidateConversationListCaches, isConversationRunning, mergeConversationIndexIntoPage, mergeConversationPages, normalizeConversationListFilter, patchConversationListCaches, patchConversationsInPage, prependConversationToPage, removeConversationFromListCaches, removeConversationFromPage, summaryFromConversationIndexEntry, } from "./conversation-list";
+export { CONVERSATION_LIST_GROUP_ORDER, type ConversationAttentionIndicator, type ConversationAttentionInput, type ConversationListGroup, type ConversationListSection, type ConversationNextAction, type ConversationNextActionTone, type ConversationTimeGroup, conversationAttentionIndicator, conversationListGroupOf, conversationNextAction, conversationTimeGroup, groupConversationsForList, resolveConversationAttention, } from "./conversation-list-groups";
 export { CATEGORY_EMOJI, defaultToolDisplayMeta, describeDelegation, describeNamed, describePackage, describePath, describeQuery, describeRange, describeSql, describeTable, describeToolArgs, describeUrl, formatToolName, getCategoryEmoji, getToolDisplayMeta, hasToolDisplayMeta, isInlineTool, knownToolNames, TOOL_DISPLAY_META, type ToolArgsDescriber, type ToolCategory, toolActiveLabel, toolCompletedLabel, type ToolDisplayMeta, type ToolDisplayMetaEntry, type ToolIconKey, toolStatusLabel, type ToolStatusLabelState, truncateLine, } from "./tool-metadata";
 export { classifyToolResult, isRecord, isRejectedToolResult, isToolResultSuccess, parseJsonRecord, readRejectedToolResult, type RejectedToolResult, resultMessage, resultRecord, stringField, type ToolCallStatusLike, toolFailure, type ToolFailure, type ToolResultClassification, type ToolResultState, } from "./tool-result";
 export { type ConversationListController, useConversationList, type UseConversationListOptions, } from "./use-conversation-list";
@@ -14,7 +15,7 @@ export { type AbandonedInputRequest, type ApprovalResumeLock, asHitlApproval, ca
 export { buildQueueEditCommand, buildStatewireQueueRows, describeQueueSendFailure, isFailedSendEntryRace, isQueueEntryUnsettled, QUEUE_AUTO_CONTINUE_DELAY_MS, type QueueEditCommand, queueEntryText, queueLaneFlags, type QueueLaneFlags, readPrioritizedQueueIds, showQueueRowSendNow, showQueueRowSteer, type StatewireQueueRow, userStopBlocksQueueAutoContinue, } from "./queue";
 export { createDeepAgentSendRecovery, type DeepAgentSendRecovery, type DeepAgentSendRecoveryOptions, shouldAutoRetryFailedSend, } from "./send-recovery";
 export { hasStatewireThreadExtras, readStatewireFailedSendLane, requireStatewireFailedActions, type StatewireFailedActions, type StatewireFailedSendEntry, type StatewireFailedSendLane, } from "./thread-extras";
-export { applyRunErrorStatus, ATHENA_ERRORS_KEY, ATHENA_HANDOFF_KEY, ATHENA_QUEUED_LANE_KEY, ATHENA_RUN_MARKER_CANCELLED, ATHENA_RUN_MARKER_FAILED, ATHENA_RUN_MARKER_KEY, ATHENA_RUN_MARKER_SOURCE_KEY, ATHENA_STOP_SOURCE_INSTANCE_CLOSED, ATHENA_STOP_SOURCE_POD_DRAIN, ATHENA_STOP_SOURCE_SEND_NOW, ATHENA_STOP_SOURCE_VOICE_STEER, ATHENA_TERMINATION_REASON_KEY, convertDeepAgentLangChainMessage, convertDeepAgentState, type ConvertDeepAgentStateOptions, createDeepAgentMaterialize, createDeepAgentMessageConversionCache, type DeepAgentConversionMemory, deepAgentMaterialize, type DeepAgentMaterializeOptions, DeepAgentMessageConversionCache, deepAgentRowKey, isConvertibleChatMessage, isDrainRunMarker, isLangGraphState, isMessageHiddenFromFrontend, isQueuedLaneMessage, isServerUpdateStopSource, isSilentRunMarker, laneTailMessages, liftBranchIntoMetadata, liftCompactionBoundaryIntoMetadata, liftConversationStatsIntoMetadata, liftErrorsIntoMetadata, liftHandoffSummaryIntoMetadata, liftModelIntoMetadata, liftRunMarkerIntoMetadata, liftTerminationIntoMetadata, liftToolMessageMetadataIntoArtifact, liftTruncatedToolOutputIntoArtifact, markPreliminaryToolResults, messageConverter, nativeStepUsage, PENDING_ASSISTANT_MESSAGE_ID, readMessageErrorsFromSourceMessages, readRunMarkerFromSourceMessages, readSoleRunMarker, type RunMarkerInfo, sanitizeLangChainMessages, substituteToolOutput, withPendingAssistantMessage, } from "./messages";
+export { applyRunErrorStatus, ATHENA_ERRORS_KEY, ATHENA_HANDOFF_KEY, ATHENA_QUEUED_LANE_KEY, ATHENA_RUN_MARKER_CANCELLED, ATHENA_RUN_MARKER_FAILED, ATHENA_RUN_MARKER_KEY, ATHENA_RUN_MARKER_SOURCE_KEY, ATHENA_STOP_SOURCE_INSTANCE_CLOSED, ATHENA_STOP_SOURCE_POD_DRAIN, ATHENA_STOP_SOURCE_SEND_NOW, ATHENA_STOP_SOURCE_VOICE_STEER, ATHENA_TERMINATION_REASON_KEY, convertDeepAgentLangChainMessage, convertDeepAgentState, type ConvertDeepAgentStateOptions, type DeepAgentMessageConversionOptions, createDeepAgentMaterialize, createDeepAgentMessageConversionCache, type DeepAgentConversionMemory, deepAgentMaterialize, type DeepAgentMaterializeOptions, DeepAgentMessageConversionCache, deepAgentRowKey, isConvertibleChatMessage, isDrainRunMarker, isLangGraphState, isMessageHiddenFromFrontend, isQueuedLaneMessage, isServerUpdateStopSource, isSilentRunMarker, laneTailMessages, liftBranchIntoMetadata, liftCompactionBoundaryIntoMetadata, liftConversationStatsIntoMetadata, liftErrorsIntoMetadata, liftHandoffSummaryIntoMetadata, liftModelIntoMetadata, liftRunMarkerIntoMetadata, liftTerminationIntoMetadata, liftToolMessageMetadataIntoArtifact, liftTruncatedToolOutputIntoArtifact, convertDeepAgentMessage, markPreliminaryToolResults, messageConverter, nativeStepUsage, PENDING_ASSISTANT_MESSAGE_ID, readMessageErrorsFromSourceMessages, readRunMarkerFromSourceMessages, readSoleRunMarker, type RunMarkerInfo, sanitizeLangChainMessages, substituteToolOutput, withPendingAssistantMessage, } from "./messages";
 export { ATHENA_TRUNCATED_TOOL_OUTPUT_ARTIFACT_KEY, buildHistoryMessageCommand, buildToolOutputCommand, clampMessageWindowSize, type DeepAgentInterestChainEntry, type DeepAgentInterestRequest, type DeepAgentInterestResolution, type DeepAgentMessageWindow, type DeepAgentMessageWindowDeclaration, headInterestRequest, type HistoryMessageCommand, type HistoryMessageResult, interestsCovered, pageInterestRequest, pageInterestRequests, readDeepAgentInterestDocument, readDeepAgentInterestResolution, readDeepAgentMessageWindow, readHistoryMessageResult, readToolOutputResult, readTruncatedToolContent, readTruncatedToolOutputArtifact, type ToolOutputCommand, type ToolOutputResult, type TruncatedToolContent, type TruncatedToolOutputArtifact, withDeclaredMessageWindow, } from "./message-window";
 export { buildHistoryLaneCommand, type DeepAgentLaneHistoryState, type DeepAgentLaneTarget, deepAgentLaneHistoryQueryKey, type HistoryLaneCommand, type HistoryLanePage, isWholeCardRefusal, mergeLaneHistory, readHistoryLanePage, useDeepAgentLaneHistory, } from "./lane-history";
 export { buildHistoryLaneImageCommand, type DeepAgentLaneImagesState, deepAgentLaneImageQueryKey, type HistoryLaneImageChunk, type HistoryLaneImageCommand, type InlineImage, type InlineImageChunk, type LaneImageRef, laneImageKey, omittedLaneImages, readChunkedInlineImage, readHistoryLaneImageChunk, readInlineImageChunk, readLaneImage, readLaneImageTile, showLaneImages, useDeepAgentLaneImages, } from "./lane-images";
@@ -34,7 +35,7 @@ export { type CompletedPtcParent, extractCompletedPtcParents, type PtcSubcall, p
 export { isRunningToolPlaceholder, isRunningToolPlaceholderArtifact, } from "./running-tool-placeholder";
 export { convertSubagentTranscript, createSubagentLaneConversion, createSubagentTranscriptConversionCache, type SubagentLaneConversion, withLaneReport, withRepeatedResult, } from "./subagent-transcripts";
 export { countSubagentStatuses, deriveEvalSubagents, finalizeOrphanedSubagents, isTerminalSubagentStatus, nestedMessagesFromArtifact, nestedTodosFromArtifact, ORPHANED_SUBAGENT_OUTPUT, ptcSubagentsFromArtifact, readLaneUsage, readTruncatedLane, type SubagentDiscoverySnapshot, type SubagentLaneSource, type SubagentStatus, type SubagentStatusCounts, type SubagentTokenUsage, subagentAwaitingApproval, subagentToolCallAwaitingApproval, type TaskSiblingGroup, type TokenCounts, type TruncatedLane, taskSiblingGroup, taskSubagentsOfThread, taskSubagentsOfTurn, transcriptStepUsage, turnToolCallsAwaitingApproval, useTurnToolCallsAwaitingApproval, } from "./subagents";
-export { ASYNC_TASK_TOOL_NAMES, CANCEL_ASYNC_TASK_TOOL_NAME, CHECK_ASYNC_TASK_TOOL_NAME, EDIT_FILE_TOOL_NAME, EVAL_TOOL_NAME, EXECUTE_PRESENTATION_CODE_TOOL_NAME, EXECUTE_SPREADSHEET_CODE_TOOL_NAME, EXECUTE_TOOL_NAME, EXECUTE_WORD_DOCUMENT_CODE_TOOL_NAME, type FileToolArgs, LIST_ASYNC_TASKS_TOOL_NAME, PTC_PARENT_TOOL_NAMES, RUN_PYTHON_CODE_TOOL_NAME, salientToolCallDetail, START_ASYNC_TASK_TOOL_NAME, TASK_TOOL_NAME, UPDATE_ASYNC_TASK_TOOL_NAME, WRITE_FILE_TOOL_NAME, } from "./tool-names";
+export { ASYNC_TASK_TOOL_NAMES, CANCEL_ASYNC_TASK_TOOL_NAME, CHECK_ASYNC_TASK_TOOL_NAME, EDIT_FILE_TOOL_NAME, EVAL_TOOL_NAME, EXECUTE_PRESENTATION_CODE_TOOL_NAME, EXECUTE_SPREADSHEET_CODE_TOOL_NAME, EXECUTE_TOOL_NAME, EXECUTE_WORD_DOCUMENT_CODE_TOOL_NAME, type FileToolArgs, LIST_ASYNC_TASKS_TOOL_NAME, PTC_PARENT_TOOL_NAMES, QUIET_TOOL_NAMES, RUN_PYTHON_CODE_TOOL_NAME, salientToolCallDetail, START_ASYNC_TASK_TOOL_NAME, SUBMIT_FEEDBACK_TOOL_NAME, TASK_TOOL_NAME, UPDATE_ASYNC_TASK_TOOL_NAME, WRITE_FILE_TOOL_NAME, } from "./tool-names";
 export { buildOptimisticHumanContent, type OptimisticContentPart, } from "./optimistic-content";
 export { DEEP_AGENT_DEFAULT_CLIENT_PROTOCOL_VERSION, type DeepAgentProtocolDeclaration, type DeepAgentProtocolStatus, type DeepAgentWireProtocol, declaredDeepAgentProtocolVersion, isDeepAgentHostState, projectDeepAgentProtocol, readDeepAgentProtocol, withDeclaredProtocolVersion, } from "./protocol";
 export { AUTH_DENIAL_PARK_THRESHOLD, type AuthDenialTrackerState, initialAuthDenialTrackerState, observeAuthDenial, } from "./auth-denial";

package/dist/agent-runtime/src/messages.cjs

@@ -14,6 +14,7 @@ const messageWindow = require("./message-window.cjs");
 const optimisticContent = require("./optimistic-content.cjs");
 const runningToolPlaceholder = require("./running-tool-placeholder.cjs");
 const statewireState = require("./statewire-state.cjs");
+const toolNames = require("./tool-names.cjs");
 const voiceTurnGrouping = require("./voice-turn-grouping.cjs");
 const CACHE_EXCLUSIVE_ADAPTERS = /* @__PURE__ */ new Set([
   "amazon_bedrock",
@@ -79,7 +80,33 @@ const convertDeepAgentLangChainMessage = (message, metadata) => {
     }
   };
 };
-const messageConverter = react.createMessageConverter(convertDeepAgentLangChainMessage);
+function withoutQuietToolCalls(message) {
+  const calls = message.tool_calls ?? [];
+  const quietIds = new Set(
+    calls.filter((call) => toolNames.QUIET_TOOL_NAMES.has(call.name)).map((call) => call.id)
+  );
+  const chunks = message.tool_call_chunks ?? [];
+  const quietChunk = (chunk) => toolNames.QUIET_TOOL_NAMES.has(chunk.name) || quietIds.has(chunk.id);
+  if (quietIds.size === 0 && !chunks.some(quietChunk)) return message;
+  return {
+    ...message,
+    ...message.tool_calls && {
+      tool_calls: calls.filter((call) => !quietIds.has(call.id))
+    },
+    ...message.tool_call_chunks && {
+      tool_call_chunks: chunks.filter((chunk) => !quietChunk(chunk))
+    }
+  };
+}
+const convertDeepAgentMessage = (message, metadata) => {
+  if (message.type === "tool" && toolNames.QUIET_TOOL_NAMES.has(message.name)) return [];
+  if (message.type === "ai") {
+    return convertDeepAgentLangChainMessage(withoutQuietToolCalls(message), metadata);
+  }
+  return convertDeepAgentLangChainMessage(message, metadata);
+};
+const messageConverter = react.createMessageConverter(convertDeepAgentMessage);
+const messageConverterShowingQuietTools = react.createMessageConverter(convertDeepAgentLangChainMessage);
 const preliminaryMarkedTurns = /* @__PURE__ */ new WeakMap();
 function markPreliminaryToolResults(message) {
   if (message.role !== "assistant") return message;
@@ -97,7 +124,7 @@ function markPreliminaryToolResults(message) {
   return marked;
 }
 class DeepAgentMessageConversionCache {
-  constructor() {
+  constructor({ showQuietTools = false } = {}) {
     __publicField(this, "cache", react.createExternalMessageConversionCache());
     /**
      * Every cached entry is rebuilt when the metadata object changes identity,
@@ -110,6 +137,8 @@ class DeepAgentMessageConversionCache {
     __publicField(this, "previous", null);
     /** `convertExternalMessages`' own rows for the previous pass, before parts were kept. */
     __publicField(this, "previousConverted", null);
+    __publicField(this, "callback");
+    this.callback = showQuietTools ? convertDeepAgentLangChainMessage : convertDeepAgentMessage;
   }
   /**
    * Convert one pass's LangChain messages. Returns the previous pass's array
@@ -122,7 +151,7 @@ class DeepAgentMessageConversionCache {
   convert(messages, isRunning) {
     const converted = react.convertExternalMessages(
       messages,
-      convertDeepAgentLangChainMessage,
+      this.callback,
       isRunning,
       this.metadata,
       this.cache
@@ -241,8 +270,8 @@ function withUnchangedParts({
   });
   return kept === 0 ? message : { ...message, content };
 }
-function createDeepAgentMessageConversionCache() {
-  return new DeepAgentMessageConversionCache();
+function createDeepAgentMessageConversionCache(options = {}) {
+  return new DeepAgentMessageConversionCache(options);
 }
 function isSameMessageList(a, b) {
   return a.length === b.length && a.every((message, index) => message === b[index]);
@@ -694,7 +723,8 @@ function convertDeepAgentState(state, {
   selfAuthor = null,
   toolOutputs,
   withdrawnTurns,
-  conversionCache
+  conversionCache,
+  showQuietTools = false
 } = {}) {
   var _a, _b;
   const values = statewireState.readDeepAgentStreamValues(state);
@@ -714,7 +744,7 @@ function convertDeepAgentState(state, {
     ...laneTail
   ];
   return {
-    messages: conversionCache ? conversionCache.convert(sources, isRunning) : messageConverter.toThreadMessages(sources, isRunning).map(markPreliminaryToolResults),
+    messages: conversionCache ? conversionCache.convert(sources, isRunning) : (showQuietTools ? messageConverterShowingQuietTools : messageConverter).toThreadMessages(sources, isRunning).map(markPreliminaryToolResults),
     isRunning
   };
 }
@@ -732,6 +762,7 @@ exports.ATHENA_TERMINATION_REASON_KEY = ATHENA_TERMINATION_REASON_KEY;
 exports.DeepAgentMessageConversionCache = DeepAgentMessageConversionCache;
 exports.PENDING_ASSISTANT_MESSAGE_ID = PENDING_ASSISTANT_MESSAGE_ID;
 exports.convertDeepAgentLangChainMessage = convertDeepAgentLangChainMessage;
+exports.convertDeepAgentMessage = convertDeepAgentMessage;
 exports.convertDeepAgentState = convertDeepAgentState;
 exports.createDeepAgentMaterialize = createDeepAgentMaterialize;
 exports.createDeepAgentMessageConversionCache = createDeepAgentMessageConversionCache;