@agent-native/core 0.219.0 → 0.220.0-nightly-20261023212848

package/dist/client/chat/runtime.js

@@ -8,6 +8,7 @@ import { agentChatStreamingUrl, agentNativePath } from "../api-path.js";
 import { CHAT_REQUEST_TOO_LARGE_MESSAGE } from "../error-format.js";
 import { appendMissingFinalResponseWarning, findApprovalToolCallIndex, } from "../sse-event-processor.js";
 import { runOutcomeForCode } from "./run-outcome.js";
+import { DEFAULT_TURN_SURFACE, } from "./turn-submitted.js";
 export const AGENT_NATIVE_RUN_RESUME_STATE_METADATA_KEY = "agentNativeRunResumeState";
 const AGENTKIT_TOOL_HISTORY_OMISSION_MESSAGE_ID_PREFIX = "agentkit-tool-history-omission";
 const DEFAULT_RUNTIME_CAPABILITIES = {
@@ -395,12 +396,13 @@ async function readHttpRuntimeError(response) {
     return error;
 }
 /**
- * A turn that failed to start keeps its id: the server records a turn it
- * refused under that id, and the client reports the failure with it.
+ * A turn that failed to start keeps its ids: the server records a turn it
+ * refused under the request's turn id, and the client reports the failure
+ * with both.
  */
-function withTurnId(error, turnId) {
+function withTurnId(error, turnId, requestTurnId) {
     if (error !== null && typeof error === "object" && !("turnId" in error)) {
-        Object.assign(error, { turnId });
+        Object.assign(error, { turnId, requestTurnId });
     }
     return error;
 }
@@ -439,6 +441,7 @@ export function createHttpAgentChatRuntime(options) {
         };
         const startTurn = async (turn) => {
             const turnId = turn.queuePromotion?.turnId ?? createRuntimeId("turn");
+            const requestTurnId = options.requestTurnId?.({ turn, turnId }) ?? turnId;
             const { controller, cleanup } = createAbortController(turn.abortSignal);
             latestTurn = turn;
             previousTurns.set(turnId, turn);
@@ -459,8 +462,17 @@ export function createHttpAgentChatRuntime(options) {
                     headers,
                     credentials: options.credentials,
                     body: JSON.stringify(options.mapRequest
-                        ? options.mapRequest({ session: summary, turn, turnId })
-                        : defaultHttpRuntimeRequest({ session: summary, turn, turnId })),
+                        ? options.mapRequest({
+                            session: summary,
+                            turn,
+                            turnId,
+                            requestTurnId,
+                        })
+                        : defaultHttpRuntimeRequest({
+                            session: summary,
+                            turn,
+                            turnId: requestTurnId,
+                        })),
                     signal: controller.signal,
                 });
             }
@@ -469,7 +481,7 @@ export function createHttpAgentChatRuntime(options) {
                 if (!isRetryableRuntimeFailure(error)) {
                     forgetTurnContext(turnId, turn);
                 }
-                throw withTurnId(error, turnId);
+                throw withTurnId(error, turnId, requestTurnId);
             }
             if (!response.ok) {
                 cleanup();
@@ -477,7 +489,7 @@ export function createHttpAgentChatRuntime(options) {
                 if (!isRetryableRuntimeFailure(error)) {
                     forgetTurnContext(turnId, turn);
                 }
-                throw withTurnId(error, turnId);
+                throw withTurnId(error, turnId, requestTurnId);
             }
             if (response.status === 202) {
                 let queuedSubmission;
@@ -505,7 +517,7 @@ export function createHttpAgentChatRuntime(options) {
                         code: "invalid_queued_submission_response",
                         status: response.status,
                         retryable: true,
-                    }), turnId);
+                    }), turnId, requestTurnId);
                 }
                 cleanup();
                 forgetTurnContext(turnId, turn);
@@ -517,6 +529,29 @@ export function createHttpAgentChatRuntime(options) {
                 };
             }
             const runId = response.headers.get("X-Run-Id") ?? undefined;
+            const replay = response.headers.get("X-Dispatch-Mode") === "replay";
+            // The server can store the run under another turn than the one asked
+            // for: an approval resume runs under its pending approval's turn. A
+            // replay streams a run an earlier request started, so without the
+            // server's turn its turn is unknown, not this request's.
+            const storedTurnId = response.headers.get("X-Turn-Id") || undefined;
+            const runTurnId = storedTurnId ?? (replay ? undefined : requestTurnId);
+            try {
+                // A replay streams a turn the server already finished, and a stream
+                // with no run id is a refusal (no model connected), not new work.
+                if (runId && !replay) {
+                    options.onTurnAccepted?.({
+                        session: summary,
+                        turn,
+                        turnId,
+                        requestTurnId: storedTurnId ?? requestTurnId,
+                        runId,
+                    });
+                }
+            }
+            catch {
+                // coercion-ok: an observer of a started turn must not stop it.
+            }
             const events = (async function* () {
                 let retryableFailure = false;
                 try {
@@ -550,6 +585,7 @@ export function createHttpAgentChatRuntime(options) {
             };
             return {
                 id: turnId,
+                requestTurnId: runTurnId,
                 sessionId,
                 runId,
                 events,
@@ -3066,6 +3102,33 @@ function metadataStringList(metadata, key) {
     const strings = value.filter((item) => typeof item === "string" && item.length > 0);
     return strings.length > 0 ? strings : undefined;
 }
+/** The turn a continuation continues; a queued turn keeps its queue id. */
+function agentNativeRequestTurnId(input) {
+    return (metadataString(input.turn.metadata, AGENT_NATIVE_CONTINUATION_TURN_ID_METADATA_KEY) ??
+        input.turn.queuePromotion?.turnId ??
+        input.turnId);
+}
+function agentNativeTurnInitiator(metadata) {
+    const custom = asRecord(metadata?.custom);
+    const startedByChat = metadata?.[AGENT_NATIVE_INTERNAL_CONTINUATION_METADATA_KEY] === true ||
+        metadata?.trackInRunsTray === true ||
+        metadata?.hideUserMessage === true ||
+        [
+            AGENT_NATIVE_CONTINUATION_TURN_ID_METADATA_KEY,
+            AGENT_NATIVE_APPROVED_TOOL_CALLS_METADATA_KEY,
+            "approvedToolCalls",
+            AUTO_CONTINUE_OF_RUN_METADATA_KEY,
+            CONTINUE_OF_RUN_METADATA_KEY,
+        ].some((key) => metadata?.[key] !== undefined) ||
+        custom?.agentNativeRecoveryAction !== undefined ||
+        custom?.agentNativeResumeAfterSetup === true;
+    if (startedByChat)
+        return "system";
+    // A send deferred while the thread restored is still the sender's own.
+    const fromApp = metadataString(metadata, "submitMessageId") !== undefined ||
+        custom?.agentNativeDeferredFromApp === true;
+    return fromApp ? "app" : "user";
+}
 function terminalRuntimeTurn(input) {
     return {
         id: input.turnId ?? createRuntimeId("turn"),
@@ -3075,7 +3138,7 @@ function terminalRuntimeTurn(input) {
         })(),
     };
 }
-export function createAgentNativeChatRuntime(options = {}) {
+export function createAgentNativeChatRuntime(options = {}, telemetry = {}) {
     const apiUrl = options.apiUrl ?? agentNativePath("/_agent-native/agent-chat");
     const runtimeId = options.id ?? "agent-native";
     const fetchImpl = options.fetch ?? fetch;
@@ -3157,6 +3220,27 @@ export function createAgentNativeChatRuntime(options = {}) {
         description: options.description ?? "Agent-Native's built-in chat transport.",
         endpoint: apiUrl,
         fetch: runtimeFetch,
+        requestTurnId: agentNativeRequestTurnId,
+        onTurnAccepted: ({ session, turn, requestTurnId, runId }) => {
+            const metadata = turn.metadata;
+            const custom = asRecord(metadata?.custom) ?? undefined;
+            const requestMode = metadataString(metadata, "requestMode") ??
+                metadataString(metadata, "mode") ??
+                options.mode;
+            telemetry.onTurnSubmitted?.({
+                turnId: requestTurnId,
+                threadId: session.threadId ?? options.threadId,
+                runId,
+                surface: metadataString(metadata, "agentNativeSurface") ??
+                    DEFAULT_TURN_SURFACE,
+                initiator: agentNativeTurnInitiator(metadata),
+                submitMessageId: metadataString(metadata, "submitMessageId"),
+                recoveryOfRunId: metadataString(custom, "agentNativeRecoveryOfRunId") ??
+                    metadataString(metadata, CONTINUE_OF_RUN_METADATA_KEY) ??
+                    metadataString(metadata, AUTO_CONTINUE_OF_RUN_METADATA_KEY),
+                requestMode,
+            });
+        },
         beforeStartTurn: async ({ session, turn, turnId }) => {
             const metadata = turn.metadata;
             const isAdmittedContinuation = turn.queuePromotion !== undefined ||
@@ -3213,7 +3297,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                 connectionRequests: true,
             },
         },
-        mapRequest: ({ session, turn, turnId }) => {
+        mapRequest: ({ session, turn, turnId, requestTurnId }) => {
             const latestUserMessage = [...(turn.messages ?? [])]
                 .reverse()
                 .find((message) => message.role === "user");
@@ -3265,7 +3349,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                 history,
                 ...(structuredHistory?.length ? { structuredHistory } : {}),
                 ...(loadedSkillSlugs.length ? { loadedSkillSlugs } : {}),
-                turnId: continuationTurnId ?? turn.queuePromotion?.turnId ?? turnId,
+                turnId: requestTurnId,
                 threadId: session.threadId ?? options.threadId,
                 ...(turn.submissionPayload !== undefined
                     ? { submissionPayload: turn.submissionPayload }

package/dist/client/chat/turn-submitted-telemetry.d.ts

@@ -0,0 +1,4 @@
+import { trackEvent } from "../analytics.js";
+import { type RoutedTurnSubmittedReport, type TurnSubmittedReport } from "./turn-submitted.js";
+export declare function trackTurnSubmitted(report: TurnSubmittedReport, send?: typeof trackEvent): void;
+export declare function trackRoutedTurnSubmitted(report: RoutedTurnSubmittedReport, send?: typeof trackEvent): void;

package/dist/client/chat/turn-submitted-telemetry.js

@@ -0,0 +1,39 @@
+import { trackEvent } from "../analytics.js";
+import { TURN_SUBMITTED_EVENT, } from "./turn-submitted.js";
+export function trackTurnSubmitted(report, send = trackEvent) {
+    try {
+        send(TURN_SUBMITTED_EVENT, {
+            turn_id: report.turnId,
+            ...(report.threadId ? { thread_id: report.threadId } : {}),
+            ...(report.runId ? { run_id: report.runId } : {}),
+            surface: report.surface,
+            initiator: report.initiator,
+            ...(report.submitMessageId
+                ? { submit_message_id: report.submitMessageId }
+                : {}),
+            ...(report.recoveryOfRunId
+                ? { recovery_of_run_id: report.recoveryOfRunId }
+                : {}),
+            ...(report.requestMode ? { request_mode: report.requestMode } : {}),
+        });
+    }
+    catch {
+        // coercion-ok: telemetry must never change whether a turn runs.
+    }
+}
+export function trackRoutedTurnSubmitted(report, send = trackEvent) {
+    try {
+        send(TURN_SUBMITTED_EVENT, {
+            routed_to: report.routedTo,
+            surface: report.surface,
+            initiator: "app",
+            ...(report.submitMessageId
+                ? { submit_message_id: report.submitMessageId }
+                : {}),
+            ...(report.requestMode ? { request_mode: report.requestMode } : {}),
+        });
+    }
+    catch {
+        // coercion-ok: telemetry must never change where a message is sent.
+    }
+}

package/dist/client/chat/turn-submitted.d.ts

@@ -0,0 +1,39 @@
+/**
+ * One event per agent request the server accepts, carrying the turn id the
+ * server stores on that request's run so the two join. A turn's continuations
+ * are further requests: they repeat its `turn_id` as `initiator: "system"`, so
+ * count turns by distinct `turn_id`, and the turns people started by
+ * `initiator` `user` or `app`. A request refused for a busy run slot and then
+ * queued is counted once when the browser promotes it, and not yet when the
+ * server's inbox drain admits it. A replay is not counted, including a retry
+ * the server answers with the run it already started. A send routed to
+ * Builder or an MCP host never starts a local turn; it is reported with
+ * `routed_to` and no `turn_id`, also when the host has not confirmed it.
+ * Never the message text.
+ */
+export declare const TURN_SUBMITTED_EVENT = "agent_turn_submitted";
+/**
+ * `system` is a turn the chat started on its own: a recovery, continuation,
+ * approval, setup replay, or background send. `app` came from app code through
+ * `sendToAgentChat`, including one deferred while the thread restored. `user`
+ * is everything else the person typed or picked.
+ */
+export type TurnInitiator = "user" | "app" | "system";
+/** The surface a turn reports when nothing names one (the legacy `chat_submit` default). */
+export declare const DEFAULT_TURN_SURFACE = "chat";
+export interface TurnSubmittedReport {
+    readonly turnId: string;
+    readonly threadId?: string;
+    readonly runId?: string;
+    readonly surface: string;
+    readonly initiator: TurnInitiator;
+    readonly submitMessageId?: string;
+    readonly recoveryOfRunId?: string;
+    readonly requestMode?: string;
+}
+export interface RoutedTurnSubmittedReport {
+    readonly routedTo: "builder" | "mcp_host";
+    readonly surface: string;
+    readonly submitMessageId?: string;
+    readonly requestMode?: string;
+}

package/dist/client/chat/turn-submitted.js

@@ -0,0 +1,16 @@
+/**
+ * One event per agent request the server accepts, carrying the turn id the
+ * server stores on that request's run so the two join. A turn's continuations
+ * are further requests: they repeat its `turn_id` as `initiator: "system"`, so
+ * count turns by distinct `turn_id`, and the turns people started by
+ * `initiator` `user` or `app`. A request refused for a busy run slot and then
+ * queued is counted once when the browser promotes it, and not yet when the
+ * server's inbox drain admits it. A replay is not counted, including a retry
+ * the server answers with the run it already started. A send routed to
+ * Builder or an MCP host never starts a local turn; it is reported with
+ * `routed_to` and no `turn_id`, also when the host has not confirmed it.
+ * Never the message text.
+ */
+export const TURN_SUBMITTED_EVENT = "agent_turn_submitted";
+/** The surface a turn reports when nothing names one (the legacy `chat_submit` default). */
+export const DEFAULT_TURN_SURFACE = "chat";

package/dist/client/route-chunk-recovery.d.ts

@@ -1,11 +1,6 @@
-/**
- * Fired on `window` the first time a stale chunk could not be recovered by a
- * reload. The shared noise rules drop the raw dynamic-import failure because
- * recovery handles it; this is the one signal that it did not, so a deploy whose
- * chunks are gone for everyone stays visible.
- */
-export declare const STALE_CHUNK_RECOVERY_EXHAUSTED_EVENT = "agent-native:stale-chunk-recovery-exhausted";
-export type StaleChunkRecoveryExhaustedReason = "cooldown" | "desktop";
+import { STALE_CHUNK_RECOVERY_EXHAUSTED_EVENT } from "../shared/route-chunk-recovery-bootstrap.js";
+export { STALE_CHUNK_RECOVERY_EXHAUSTED_EVENT };
+export type StaleChunkRecoveryExhaustedReason = "cooldown" | "desktop" | "external-embed";
 export interface StaleChunkRecoveryExhausted {
     reason: StaleChunkRecoveryExhaustedReason;
 }

package/dist/client/route-chunk-recovery.js

@@ -1,16 +1,9 @@
-import { CHUNK_RECOVERY_CACHE_BUSTER_PARAM, CHUNK_RECOVERY_ORIGINAL_HASH_PARAM, CHUNK_RECOVERY_PATH_SUFFIX, CHUNK_RECOVERY_QUERY_PARAM, CHUNK_RECOVERY_QUERY_VALUE, ROUTE_WARMUP_PRELOAD_ATTRIBUTE, STALE_CHUNK_RELOAD_AT_KEY, STALE_CHUNK_RELOAD_COOLDOWN_MS, } from "../shared/route-chunk-recovery-bootstrap.js";
+import { CHUNK_RECOVERY_CACHE_BUSTER_PARAM, CHUNK_RECOVERY_ORIGINAL_HASH_PARAM, CHUNK_RECOVERY_PATH_SUFFIX, CHUNK_RECOVERY_QUERY_PARAM, CHUNK_RECOVERY_QUERY_VALUE, EXTERNAL_EMBED_WINDOW_KEY, ROUTE_WARMUP_PRELOAD_ATTRIBUTE, STALE_CHUNK_EXHAUSTED_KEY, STALE_CHUNK_RECOVERY_EXHAUSTED_EVENT, STALE_CHUNK_RELOAD_AT_KEY, STALE_CHUNK_RELOAD_COOLDOWN_MS, } from "../shared/route-chunk-recovery-bootstrap.js";
 import { recordNav } from "./recorder.js";
 const INSTALL_KEY = "__agentNativeRouteChunkRecoveryInstalled";
 const INTENDED_NAV_MAX_AGE_MS = 15_000;
-const STALE_CHUNK_EXHAUSTED_KEY = "__agentNativeStaleChunkRecoveryExhausted";
 const recoveryStates = new WeakMap();
-/**
- * Fired on `window` the first time a stale chunk could not be recovered by a
- * reload. The shared noise rules drop the raw dynamic-import failure because
- * recovery handles it; this is the one signal that it did not, so a deploy whose
- * chunks are gone for everyone stays visible.
- */
-export const STALE_CHUNK_RECOVERY_EXHAUSTED_EVENT = "agent-native:stale-chunk-recovery-exhausted";
+export { STALE_CHUNK_RECOVERY_EXHAUSTED_EVENT };
 export function createRouteChunkRecoveryState() {
     return {
         intendedHref: null,
@@ -187,6 +180,9 @@ function isModuleAssetLoadFailure(event) {
 function isAgentNativeDesktop(win) {
     return /AgentNativeDesktop/i.test(win.navigator?.userAgent || "");
 }
+function isExternalEmbed(win) {
+    return Boolean(win[EXTERNAL_EMBED_WINDOW_KEY]);
+}
 function hasViteDevRecovery(win) {
     if (win["__agentNativeViteDevRecoveryInstalled"] === true) {
         return true;
@@ -269,6 +265,10 @@ export function reloadForStaleChunk(win = typeof window === "undefined" ? undefi
         reportStaleChunkRecoveryExhausted(win, "desktop");
         return false;
     }
+    if (isExternalEmbed(win)) {
+        reportStaleChunkRecoveryExhausted(win, "external-embed");
+        return false;
+    }
     const lastReloadAt = readStaleChunkReloadAt(win);
     if (lastReloadAt > 0 &&
         now - lastReloadAt <= STALE_CHUNK_RELOAD_COOLDOWN_MS) {
@@ -288,6 +288,8 @@ export function recoverFromStaleChunkError(error, win = typeof window === "undef
     return reloadForStaleChunk(win);
 }
 function recoverToIntendedNavigation(win, state) {
+    if (isExternalEmbed(win))
+        return false;
     const target = getFreshIntendedNavigation(state, win.location.href);
     const sameCurrentTarget = isAgentNativeDesktop(win) &&
         !target &&

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

@@ -8,6 +8,7 @@ export interface UseChatThreadListOptions {
     includeExternal?: boolean;
     /** Include archived threads. Defaults to false. */
     includeArchived?: boolean;
+    includeHidden?: boolean;
     /** Search text. Empty lists the whole set. */
     query?: string;
     /** When false nothing is fetched and the list is empty. Defaults to true. */
@@ -30,6 +31,7 @@ export interface UseChatThreadListResult {
     refresh: () => Promise<void>;
     /** Reports whether this invocation applied the complete refreshed window. */
     refreshWithResult: () => Promise<ChatThreadListRefreshOutcome>;
+    hideThread: (id: string, hidden: boolean) => Promise<boolean>;
 }
 /** `pageSize` is not an integer between 1 and the server's page cap. */
 export declare class ChatThreadListConfigError extends Error {

package/dist/client/use-chat-thread-list.js

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useLayoutEffect, useState } from "react";
 import { agentNativePath } from "./api-path.js";
-import { CHAT_THREADS_MAX_PAGE_SIZE, CHAT_THREADS_UPDATED_EVENT, ChatThreadListError, fetchChatThreadListPage, } from "./use-chat-threads.js";
+import { CHAT_THREADS_MAX_PAGE_SIZE, CHAT_THREADS_UPDATED_EVENT, ChatThreadListError, fetchChatThreadListPage, hideChatThread, } from "./use-chat-threads.js";
 const DEFAULT_PAGE_SIZE = 50;
 /** `pageSize` is not an integer between 1 and the server's page cap. */
 export class ChatThreadListConfigError extends Error {
@@ -48,7 +48,7 @@ function createListState(identity, enabled) {
  * rather than collapsing to the first page.
  */
 export function useChatThreadList(options) {
-    const { ownership, includeExternal = false, includeArchived = false, enabled = true, refreshOnThreadUpdates = true, } = options;
+    const { ownership, includeExternal = false, includeArchived = false, includeHidden = false, enabled = true, refreshOnThreadUpdates = true, } = options;
     const apiUrl = options.apiUrl ?? agentNativePath("/_agent-native/agent-chat");
     const pageSize = resolvePageSize(options.pageSize);
     const query = options.query?.trim() ?? "";
@@ -63,6 +63,7 @@ export function useChatThreadList(options) {
         pageSize,
         includeExternal,
         includeArchived,
+        includeHidden,
         enabled,
     ]);
     const [stored, setState] = useState(() => createListState(identity, enabled));
@@ -91,6 +92,7 @@ export function useChatThreadList(options) {
         ownership,
         includeExternal,
         includeArchived,
+        includeHidden,
         scope: scopeType && scopeId ? { type: scopeType, id: scopeId } : null,
     }).then((result) => {
         if (result.hasMore === undefined) {
@@ -106,6 +108,7 @@ export function useChatThreadList(options) {
         apiUrl,
         includeArchived,
         includeExternal,
+        includeHidden,
         ownership,
         query,
         scopeId,
@@ -223,6 +226,48 @@ export function useChatThreadList(options) {
         return () => window.removeEventListener(CHAT_THREADS_UPDATED_EVENT, onUpdated);
     }, [enabled, refresh, refreshOnThreadUpdates]);
     const { threads, loading, loadingMore, error, hasMore } = state;
+    const hideThread = useCallback(async (id, hidden) => {
+        const previous = state.threads.find((thread) => thread.id === id);
+        update({
+            threads: state.threads.flatMap((thread) => {
+                if (thread.id !== id)
+                    return [thread];
+                if (hidden && !includeHidden)
+                    return [];
+                return [{ ...thread, hiddenAt: hidden ? Date.now() : null }];
+            }),
+        });
+        try {
+            return await hideChatThread(id, hidden, {
+                apiUrl,
+                scope: options.scope,
+            });
+        }
+        catch (error) {
+            // A newer refresh may have dropped a removed row because access was
+            // revoked, so the server decides whether it comes back.
+            if (hidden && !includeHidden)
+                void refreshWithResult();
+            else if (previous)
+                setState((current) => current.session === session
+                    ? {
+                        ...current,
+                        threads: current.threads.map((thread) => thread.id === id
+                            ? { ...thread, hiddenAt: previous.hiddenAt }
+                            : thread),
+                    }
+                    : current);
+            throw error;
+        }
+    }, [
+        apiUrl,
+        includeHidden,
+        options.scope,
+        refreshWithResult,
+        session,
+        state.threads,
+        update,
+    ]);
     return {
         threads,
         loading,
@@ -232,5 +277,6 @@ export function useChatThreadList(options) {
         loadMore,
         refresh,
         refreshWithResult,
+        hideThread,
     };
 }

package/dist/client/use-chat-threads.d.ts

@@ -24,6 +24,7 @@ export interface ChatThreadSummary {
     scope: ChatThreadScope | null;
     source?: ChatThreadSource | null;
     pinnedAt?: number | null;
+    hiddenAt?: number | null;
     archivedAt?: number | null;
     /**
      * Server-supplied on listed threads. Absent on optimistic local drafts,
@@ -51,6 +52,7 @@ export interface ChatThreadData {
     scope: ChatThreadScope | null;
     source?: ChatThreadSource | null;
     pinnedAt?: number | null;
+    hiddenAt?: number | null;
     archivedAt?: number | null;
 }
 export interface ChatThreadSnapshot {
@@ -76,6 +78,7 @@ export interface UseChatThreadsOptions {
     browserTabId?: string;
     routeThreadId?: string | null;
     includeExternal?: boolean;
+    includeHidden?: boolean;
     isolateHistoryByScope?: boolean;
     /** Narrows the history list and search. Defaults to `all`. */
     ownership?: ChatThreadOwnership;
@@ -99,6 +102,7 @@ export interface ChatThreadListPageRequest {
     ownership?: ChatThreadOwnership;
     includeExternal?: boolean;
     includeArchived?: boolean;
+    includeHidden?: boolean;
     scope?: ChatThreadScope | null;
 }
 /** A listed thread as the server returns it: ownership metadata always present. */
@@ -124,6 +128,14 @@ export interface ChatThreadListPage {
  * of returned rows and use `hasMore`, rather than the requested limit.
  */
 export declare function fetchChatThreadListPage(request?: ChatThreadListPageRequest): Promise<ChatThreadListPage>;
+export declare class ChatThreadMutationError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+export declare function hideChatThread(threadId: string, hidden: boolean, options?: {
+    apiUrl?: string;
+    scope?: ChatThreadScope | null;
+}): Promise<boolean>;
 export declare function appendChatThreadScopeParams(params: URLSearchParams, scope?: ChatThreadScope | null): void;
 /**
  * Tell every mounted chat history list the thread set or its sharing changed,
@@ -141,6 +153,7 @@ export declare function useChatThreads(apiUrl?: string, storageKey?: string, sco
     deleteThread: (id: string) => Promise<void>;
     detachThread: (threadId: string) => Promise<void>;
     pinThread: (threadId: string, pinned: boolean) => Promise<boolean>;
+    hideThread: (threadId: string, hidden: boolean) => Promise<boolean>;
     archiveThread: (threadId: string) => Promise<boolean>;
     renameThread: (threadId: string, title: string) => Promise<boolean>;
     forkThread: (sourceId: string, sourceSnapshot?: ChatThreadSnapshot | null) => Promise<string | null>;