@agents24/react 0.2.7 → 0.2.8

package/dist/model.d.ts

@@ -64,6 +64,13 @@ export type ChatTextPart = ChatPartMetadata & {
     kind: "text";
     text: string;
 };
+export type ChatComputerResourceTarget = {
+    type: "computer";
+    thread_id: string;
+    computer_id: string;
+    path: string;
+    kind: "file" | "directory";
+};
 export type ChatToolPart = ChatPartMetadata & {
     type: `tool-${string}`;
     kind: "tool";
@@ -77,6 +84,7 @@ export type ChatToolPart = ChatPartMetadata & {
     state: ChatToolState;
     input?: unknown;
     output?: unknown;
+    resourceTargets?: readonly ChatComputerResourceTarget[];
     errorText?: string | null;
     failure?: FailureView | null;
     presentation: ChatToolPresentation;
@@ -194,6 +202,9 @@ export type ChatAttachmentPart = ChatPartMetadata & {
 export type ChatPart = ChatTextPart | ChatToolPart | ChatReasoningPart | ChatModelTurnPart | ChatContextCompressionPart | ChatNodeActivityPart | ChatUiBlocksPart | ChatHitlPart | ChatErrorPart | ChatDataPart | ChatSourcePart | ChatCitationPart | ChatAttachmentPart;
 export type ChatMessage = {
     id: string;
+    /** Durable timeline identity when a mounted optimistic turn keeps its display key. */
+    durableId?: string;
+    segmentIndex?: number | null;
     role: AgentChatMessageRole;
     runId?: string | null;
     content: string;
@@ -235,6 +246,7 @@ export type ThreadActivity = {
     isCancelled: boolean;
 };
 export declare function getThreadActivity(thread: Pick<ThreadSummary, "active_run" | "last_run_id" | "last_run_status">): ThreadActivity;
+export declare function computerResourceTargets(value: unknown): ChatComputerResourceTarget[];
 export declare function partsFromResponseBlocks(blocks: unknown, fallbackText?: string, fallbackPartId?: string): ChatPart[];
 export declare function assistantProjectionFromEvent(event: RuntimeEvent): {
     content: string;
@@ -243,6 +255,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 latestThreadContext(detail: ThreadDetail): {
     contextWindow: ContextWindow | null;
     contextCompression: ContextCompression | null;

package/dist/state.d.ts

@@ -43,6 +43,7 @@ export declare function clearAgentChatBackgroundError(state: AgentChatState): Ag
  * active thread before it becomes visible in the server's list projection.
  */
 export declare function reconcileRefreshedThreads(current: StoredChatThread[], incoming: StoredChatThread[], activeThreadId: string | null, concurrentEvents?: readonly ThreadSummaryEvent[]): StoredChatThread[];
+export declare function preferNewestThreadSummary(current: StoredChatThread | undefined, incoming: StoredChatThread): StoredChatThread;
 /** Adopt the server-created thread without reloading the in-memory transcript. */
 export declare function adoptStreamingThread(state: AgentChatState, threadId: string): AgentChatState;
 export type StableChatMessageBase = {
@@ -55,9 +56,12 @@ export type StableAssistantUpsertInput<TMessage extends StableChatMessageBase> =
     create: () => TMessage;
     messageId?: string | null;
     runId?: string | null;
+    strictMessageId?: boolean;
     update: (message: TMessage) => TMessage;
 };
 export declare function appendStableStreamingTurn<TMessage extends StableChatMessageBase>(messages: TMessage[], userMessage: TMessage, assistantMessage: TMessage): TMessage[];
+/** Keep mounted display keys while matching only durable IDs and run linkage. */
+export declare function preserveMountedMessageIds(canonical: ChatMessage[], current: ChatMessage[]): ChatMessage[];
 export declare function upsertStableAssistantMessage<TMessage extends StableChatMessageBase>(messages: TMessage[], input: StableAssistantUpsertInput<TMessage>): TMessage[];
 export declare function applyRuntimeEvent(state: AgentChatState, event: RuntimeEvent): AgentChatState;
 export declare function applyRuntimeEvents(state: AgentChatState, events: readonly RuntimeEvent[]): AgentChatState;

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

@@ -0,0 +1,47 @@
+import type { ThreadMessage, ThreadMessageInput, ThreadMessageQueueState, ThreadMessageSubmission, ThreadMessagesPage } from "@agents24/client";
+export type ThreadMessageNotice = {
+    messageId: string;
+    status: string;
+    runId: string | null;
+    cursor?: number;
+};
+export type ThreadMessageQueueTransport = {
+    list(threadId: string): Promise<ThreadMessagesPage>;
+    submit(input: ThreadMessageInput): Promise<ThreadMessageSubmission>;
+    edit(message: ThreadMessage, input: {
+        text: string;
+        attachmentIds?: readonly string[];
+        requestedAgentId?: string;
+        requestedModelId?: string;
+        mode?: "steer";
+    }): Promise<ThreadMessage>;
+    remove(message: ThreadMessage): Promise<void>;
+    resume(threadId: string): Promise<{
+        run_id: string | null;
+    }>;
+};
+export type RetractedMessageDraft = Pick<ThreadMessage, "text" | "attachment_ids" | "attachments">;
+export declare function useThreadMessageQueue({ threadId, transport, onPromoted }: {
+    threadId: string | null;
+    transport: ThreadMessageQueueTransport;
+    onPromoted: (message: ThreadMessage, runId: string) => void;
+}): {
+    pendingMessages: readonly ThreadMessage[];
+    messageQueue: ThreadMessageQueueState | null;
+    refresh: (selectedThreadId?: string | null) => Promise<ThreadMessagesPage | null>;
+    hydrate: (page: ThreadMessagesPage, selectedThreadId: string) => void;
+    acceptNotice: (notice: ThreadMessageNotice) => boolean;
+    submit: (input: Omit<ThreadMessageInput, "threadId">) => Promise<ThreadMessageSubmission>;
+    edit: (message: ThreadMessage, input: {
+        text: string;
+        attachmentIds?: readonly string[];
+        requestedAgentId?: string;
+        requestedModelId?: string;
+        mode?: "steer";
+    }) => Promise<ThreadMessage>;
+    remove: (message: ThreadMessage) => Promise<void>;
+    retractForEdit: (message: ThreadMessage) => Promise<RetractedMessageDraft>;
+    resume: () => Promise<{
+        run_id: string | null;
+    } | null>;
+};

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

@@ -0,0 +1,13 @@
+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;
+    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>;

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

@@ -0,0 +1,20 @@
+import type { ThreadMessage } from "@agents24/client";
+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 }: {
+    queue: ReturnType<typeof useThreadMessageQueue>;
+    stateRef: React.RefObject<AgentChatState>;
+    createId: () => string;
+    clearOperationError: () => void;
+    failOperation: (operation: AgentChatOperation, cause: unknown) => void;
+    refreshMessages: (threadId: string) => Promise<void>;
+    attachRun: (runId: string) => Promise<void>;
+}): {
+    steer: (text: string) => Promise<void>;
+    editPendingMessage: (message: ThreadMessage, input: Pick<AgentChatSubmitInput, "text" | "attachmentIds" | "requestedAgentId" | "requestedModelId">) => Promise<void>;
+    steerPendingMessage: (message: ThreadMessage) => Promise<void>;
+    removePendingMessage: (message: ThreadMessage) => Promise<void>;
+    resumeQueue: () => Promise<void>;
+};

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

@@ -0,0 +1,20 @@
+import type { AgentClient, ThreadSummaryEvent } from "@agents24/client";
+import * as React from "react";
+import type { StoredChatThread } from "./model";
+import { type AgentChatOperation, type AgentChatState } from "./state";
+export declare function summaryToStored(thread: Record<string, unknown>): StoredChatThread;
+export declare function useAgentChatThreadList({ client, threadPageSize, stateRef, update, clearOperationError, failOperation }: {
+    client: AgentClient;
+    threadPageSize: number;
+    stateRef: React.RefObject<AgentChatState>;
+    update: (updater: (current: AgentChatState) => AgentChatState) => void;
+    clearOperationError: () => void;
+    failOperation: (operation: AgentChatOperation, cause: unknown) => void;
+}): {
+    isLoadingThreads: boolean;
+    isLoadingMoreThreads: boolean;
+    threadTotal: number | undefined;
+    eventsDuringRefreshRef: React.RefObject<ThreadSummaryEvent[] | null>;
+    refreshThreads: () => Promise<void>;
+    loadMoreThreads: () => Promise<void>;
+};

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

@@ -1,5 +1,6 @@
-import type { AgentClient, FeedbackReason, HitlResponse, PortableUpload } from "@agents24/client";
+import type { AgentClient, FeedbackReason, HitlResponse, PortableUpload, ThreadMessage, ThreadMessageQueueState } from "@agents24/client";
 import type { ChatAttachment, ChatHitlPart, ChatMessage, StoredChatThread } from "./model";
+import { type RetractedMessageDraft } from "./thread-message-queue";
 import { type AgentChatOperation, type AgentChatState } from "./state";
 export type AgentChatSubmitInput = {
     text: string;
@@ -16,6 +17,8 @@ export type UseAgentChatOptions = {
     threadPageSize?: number;
 };
 export type AgentChatController = AgentChatState & {
+    pendingMessages: readonly ThreadMessage[];
+    messageQueue: ThreadMessageQueueState | null;
     activeThread: StoredChatThread | null;
     hasOlderTurns: boolean;
     hasMoreThreads: boolean;
@@ -35,6 +38,13 @@ export type AgentChatController = AgentChatState & {
     openThread(threadId: string): Promise<void>;
     refreshThreads(): Promise<void>;
     regenerate(message: ChatMessage): Promise<void>;
+    refreshMessages(threadId?: string): Promise<void>;
+    editPendingMessage(message: ThreadMessage, input: Pick<AgentChatSubmitInput, "text" | "attachmentIds" | "requestedAgentId" | "requestedModelId">): Promise<void>;
+    steerPendingMessage(message: ThreadMessage): Promise<void>;
+    removePendingMessage(message: ThreadMessage): Promise<void>;
+    retractPendingMessage(message: ThreadMessage): Promise<RetractedMessageDraft>;
+    resumeQueue(): Promise<void>;
+    steer(text: string): Promise<void>;
     resumeHitl(part: ChatHitlPart, response: HitlResponse): Promise<void>;
     setFeedback(message: ChatMessage, input: {
         rating: "like" | "dislike" | null;

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

@@ -1,4 +1,4 @@
-import type { AbortSignalLike, AttachmentResult, BinaryUploadData, HitlAction, HitlResumeResult, McpAuthorizationResult, McpCallbackResult, RuntimeEvent, ThreadDetail, ThreadSummary } from "@agents24/client";
+import type { AbortSignalLike, AttachmentResult, BinaryUploadData, HitlAction, HitlResumeResult, McpAuthorizationResult, McpCallbackResult, RuntimeEvent, ThreadDetail, ThreadComputerStatus, ThreadSummary } from "@agents24/client";
 export declare function useAgentThreads(options?: {
     limit?: number;
     skip?: number;
@@ -18,6 +18,19 @@ export declare function useAgentThread(threadId: string | null, options?: {
     refresh: () => Promise<ThreadDetail | null>;
     thread: ThreadDetail | null;
 };
+export declare function useThreadComputer(threadId: string | null): {
+    computer: ThreadComputerStatus | null;
+    error: unknown;
+    isLoading: boolean;
+    list: (input: {
+        path?: string;
+        cursor?: number;
+        limit?: number;
+    }) => Promise<import("@agents24/client").ThreadComputerFiles>;
+    read: (path: string) => Promise<import("@agents24/client").ThreadComputerFileText>;
+    createContentAccess: (path: string, download?: boolean) => Promise<import("@agents24/client").ThreadComputerContentAccess>;
+    refresh: () => Promise<ThreadComputerStatus | null>;
+};
 export declare function useAgentRun(): {
     attach: (runId: string, onEvent: (event: RuntimeEvent) => void | Promise<void>, cursor?: number) => Promise<import("@agents24/client").StreamResult>;
     cancel: (runId: string) => Promise<Record<string, unknown>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents24/react",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "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.7"
+    "@agents24/client": "0.2.8"
   },
   "peerDependencies": {
     "react": ">=19.0.0 <20.0.0"