@agents24/react 0.2.13 → 0.2.15

package/dist/lifecycle.d.ts

@@ -4,5 +4,9 @@ export type AbortControllerLike = {
     abort(reason?: unknown): void;
 };
 export type AbortControllerFactory = () => AbortControllerLike;
+export type VisibilitySource = {
+    isVisible(): boolean;
+    subscribe(listener: () => void): () => void;
+};
 export declare function createPortableId(): string;
 export declare function isAbortLike(error: unknown): boolean;

package/dist/model.d.ts

@@ -257,7 +257,7 @@ export declare function assistantProjectionFromEvent(event: RuntimeEvent): {
 export declare function modelTurnPartFromEvent(event: RuntimeEvent): ChatModelTurnPart | null;
 export declare function contextCompressionPartFromEvent(event: RuntimeEvent, existingParts?: readonly ChatPart[]): ChatContextCompressionPart | null;
 export declare function threadDetailToMessages(detail: ThreadDetail): ChatMessage[];
-export declare function threadTimelineToMessages(items: readonly import("@agents24/client").ThreadMessage[], detail?: ThreadDetail): ChatMessage[];
+export declare function threadTimelineToMessages(items: readonly import("@agents24/client").ThreadMessage[]): ChatMessage[];
 export declare function latestThreadContext(detail: ThreadDetail): {
     contextWindow: ContextWindow | null;
     contextCompression: ContextCompression | null;

package/dist/operation-ownership.d.ts

@@ -0,0 +1,12 @@
+/** A selection generation distinguishes A → B → A from uninterrupted ownership. */
+export type ChatOperationOwner = {
+    generation: number;
+    threadId: string | null;
+    runId?: string | null;
+    stream?: unknown;
+};
+export declare function captureChatOperation(read: () => ChatOperationOwner, options?: {
+    run?: boolean;
+    stream?: boolean;
+    adoptThread?: boolean;
+}): () => boolean;

package/dist/provider.d.ts

@@ -1,6 +1,6 @@
 import type { AgentClient } from "@agents24/client";
 import * as React from "react";
-import type { AbortControllerFactory } from "./lifecycle";
+import type { AbortControllerFactory, VisibilitySource } from "./lifecycle";
 import type { StoredChatThread } from "./model";
 export type AgentChatStorage = {
     loadThreads(): StoredChatThread[];
@@ -13,6 +13,7 @@ export type Agents24ReactRuntime = {
     createAbortController: AbortControllerFactory;
     createId: () => string;
     storage?: AgentChatStorage;
+    visibility?: VisibilitySource;
 };
 export type Agents24ProviderProps = {
     children: React.ReactNode;
@@ -20,7 +21,8 @@ export type Agents24ProviderProps = {
     createAbortController: AbortControllerFactory;
     createId?: () => string;
     storage?: AgentChatStorage;
+    visibility?: VisibilitySource;
 };
-export declare function Agents24Provider({ children, client, createAbortController, createId, storage, }: Agents24ProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function Agents24Provider({ children, client, createAbortController, createId, storage, visibility, }: Agents24ProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare function useAgents24Runtime(): Agents24ReactRuntime;
 export declare function useAgentClient(): AgentClient;

package/dist/state.d.ts

@@ -64,6 +64,8 @@ export declare function appendStableStreamingTurn<TMessage extends StableChatMes
 export declare function preserveMountedMessageIds(canonical: ChatMessage[], current: ChatMessage[]): ChatMessage[];
 /** Reconcile a durable timeline without replacing a newer live assistant segment. */
 export declare function reconcileThreadTimeline(current: ChatMessage[], canonical: ChatMessage[], activeRunId: string | null, streamingMessageId: string | null): ChatMessage[];
+/** Older pages add history without replacing already mounted or live messages. */
+export declare function prependThreadTimeline(current: ChatMessage[], older: ChatMessage[]): ChatMessage[];
 /** A promoted queue item enters the transcript under its durable message ID. */
 export declare function promoteThreadMessage(current: ChatMessage[], message: ChatMessage, runId: string): ChatMessage[];
 export declare function upsertStableAssistantMessage<TMessage extends StableChatMessageBase>(messages: TMessage[], input: StableAssistantUpsertInput<TMessage>): TMessage[];

package/dist/thread-message-queue.d.ts

@@ -1,6 +1,6 @@
 import type { ChatMessage } from "./model";
 import { type AgentChatState } from "./state";
-import type { ThreadMessage, ThreadMessageInput, ThreadMessageQueueState, ThreadMessageSubmission, ThreadMessagesPage } from "@agents24/client";
+import type { ThreadMessage, ThreadMessageInput, ThreadMessageQueueState, ThreadMessageSubmission, ThreadMessagesPage, AbortSignalLike } from "@agents24/client";
 /** Retry uncertain admission once; the caller retains the same receipt and payload. */
 export declare function retrySubmissionAdmission<T>(admit: () => Promise<T>): Promise<T>;
 export type ThreadMessageNotice = {
@@ -11,7 +11,7 @@ export type ThreadMessageNotice = {
     clientSubmissionId?: string | null;
 };
 export type ThreadMessageQueueTransport = {
-    list(threadId: string): Promise<ThreadMessagesPage>;
+    list(threadId: string, signal?: AbortSignalLike): Promise<ThreadMessagesPage>;
     submit(input: ThreadMessageInput): Promise<ThreadMessageSubmission>;
     edit(message: ThreadMessage, input: {
         text: string;
@@ -26,16 +26,18 @@ export type ThreadMessageQueueTransport = {
     }>;
 };
 export type RetractedMessageDraft = Pick<ThreadMessage, "text" | "attachment_ids" | "attachments">;
-export declare function useThreadMessageQueue({ threadId, transport, onPromoted, onOptimistic, onDiscard }: {
+export declare function useThreadMessageQueue({ threadId, transport, onPromoted, onUnknownPromotion, onOptimistic, onDiscard, ownOperation: ownSelection }: {
     threadId: string | null;
+    ownOperation?: () => () => boolean;
     transport: ThreadMessageQueueTransport;
     onPromoted: (message: ThreadMessage, runId: string) => void;
+    onUnknownPromotion?: (runId: string, threadId: string) => void;
     onOptimistic?: (message: ThreadMessage, uploading: boolean) => void;
     onDiscard?: (message: ThreadMessage) => void;
 }): {
     pendingMessages: readonly ThreadMessage[];
     messageQueue: ThreadMessageQueueState | null;
-    refresh: (selectedThreadId?: string | null) => Promise<ThreadMessagesPage | null>;
+    refresh: (selectedThreadId?: string | null, signal?: AbortSignalLike) => Promise<ThreadMessagesPage | null>;
     hydrate: (page: ThreadMessagesPage, selectedThreadId: string) => void;
     acceptNotice: (notice: ThreadMessageNotice) => boolean;
     beginSubmission: (input: {

package/dist/use-agent-chat-feedback.d.ts

@@ -1,13 +1,20 @@
 import type { AgentClient, FeedbackReason } from "@agents24/client";
 import type { ChatMessage } from "./model";
 import { type AgentChatOperation, type AgentChatState } from "./state";
-export declare function useAgentChatFeedback({ client, update, clearOperationError, failOperation }: {
-    client: AgentClient;
+export declare function useAgentChatFeedback({ client, update, clearOperationError, failOperation, ownOperation, refreshMessages }: {
+    client: {
+        runs: Pick<AgentClient["runs"], "setFeedback">;
+    };
+    ownOperation: () => () => boolean;
+    refreshMessages: () => Promise<void>;
     update: (updater: (current: AgentChatState) => AgentChatState) => void;
     clearOperationError: () => void;
     failOperation: (operation: AgentChatOperation, cause: unknown) => void;
-}): (message: ChatMessage, input: {
-    rating: "like" | "dislike" | null;
-    reason?: FeedbackReason | null;
-    comment?: string | null;
-}) => Promise<void>;
+}): {
+    setFeedback: (message: ChatMessage, input: {
+        rating: "like" | "dislike" | null;
+        reason?: FeedbackReason | null;
+        comment?: string | null;
+    }) => Promise<void>;
+    captureRead: () => (incoming: ChatMessage[], current: ChatMessage[]) => ChatMessage[];
+};

package/dist/use-agent-chat-queue-actions.d.ts

@@ -3,7 +3,8 @@ import * as React from "react";
 import type { AgentChatSubmitInput } from "./use-agent-chat";
 import { useThreadMessageQueue } from "./thread-message-queue";
 import type { AgentChatOperation, AgentChatState } from "./state";
-export declare function useAgentChatQueueActions({ queue, stateRef, createId, clearOperationError, failOperation, refreshMessages, attachRun }: {
+export declare function useAgentChatQueueActions({ queue, stateRef, createId, clearOperationError, failOperation, refreshMessages, attachRun, ownOperation }: {
+    ownOperation: () => () => boolean;
     queue: ReturnType<typeof useThreadMessageQueue>;
     stateRef: React.RefObject<AgentChatState>;
     createId: () => string;

package/dist/use-agent-chat.d.ts

@@ -15,6 +15,7 @@ export type UseAgentChatOptions = {
     client?: AgentClient;
     pageSize?: number;
     threadPageSize?: number;
+    observation?: "on-demand" | "realtime";
 };
 export type AgentChatController = AgentChatState & {
     pendingMessages: readonly ThreadMessage[];

package/dist/use-chat-observation.d.ts

@@ -0,0 +1,4 @@
+import { createChatObservation, type ChatObservationState } from "./chat-observation";
+export declare function useChatObservation(input: Parameters<typeof createChatObservation>[0] & {
+    state: ChatObservationState;
+}): () => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents24/react",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "DOM-free React state and hooks for Agents24 client applications.",
   "license": "MIT",
   "repository": {
@@ -40,7 +40,7 @@
     "prepack": "pnpm run build && pnpm run check:boundaries"
   },
   "dependencies": {
-    "@agents24/client": "0.2.12"
+    "@agents24/client": "0.2.13"
   },
   "peerDependencies": {
     "react": ">=19.0.0 <20.0.0"

package/dist/thread-summary-subscription.d.ts

@@ -1,12 +0,0 @@
-import type { AbortSignalLike, AgentClient, ThreadSummaryEvent } from "@agents24/client";
-type ThreadSummarySubscription = {
-    client: AgentClient;
-    signal: AbortSignalLike;
-    onEvent(event: ThreadSummaryEvent): Promise<void> | void;
-    onError(error: unknown): void;
-    onRecovered(): void;
-    refresh(): Promise<void>;
-};
-/** Keep the thread list connected across clean EOFs and transient stream failures. */
-export declare function subscribeToThreadSummaries(input: ThreadSummarySubscription): Promise<void>;
-export {};