@miragon/mcp-toolkit-ui 2.6.0 → 2.8.0

package/dist/hooks/use-tool-query.js

@@ -1,47 +1,124 @@
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { useCallTool } from "../providers/query-provider.js";
+import { useCallback, useEffect, useRef } from "react";
+import { hashKey, useMutation, useQuery, useQueryClient, } from "@tanstack/react-query";
+import { useCallTool, useToolNameInQueryKey } from "../providers/query-provider.js";
 import { parseToolResult } from "../lib/parse-tool-result.js";
+import { claimToolQueryKey, invalidateToolQueries, NoToolTransportError, settleEachCall, toolKeyCollisionMessage, toolQueryKey, toolQueryOptions, } from "../lib/tool-query.js";
+/**
+ * The exact cache key `useToolQuery`, `useViewToolQuery` and `useViewData`
+ * use for this tool and args under the nearest `AppQueryProvider`:
+ * `toolQueryKey` with the provider's `toolNameInQueryKey` setting. For
+ * `getQueryData`, `setQueryData` or `cancelQueries({ exact: true })`; prefix
+ * invalidation needs only the caller's `queryKey`. A new array per render.
+ */
+export function useToolQueryKey(queryKey, toolName, args) {
+    return toolQueryKey(queryKey, toolName, args, useToolNameInQueryKey());
+}
+/**
+ * Warns when two tools use one cache key (toolkit#176 K18): their answers
+ * would overwrite each other. Only the 2.x key can collide: with the tool
+ * name in the key (`toolNameInQueryKey`), two tools never share one.
+ */
+export function useToolKeyGuard(queryKey, toolName, args) {
+    const client = useQueryClient();
+    const keyId = hashKey(useToolQueryKey(queryKey, toolName, args));
+    useEffect(() => {
+        const previous = claimToolQueryKey(client, keyId, toolName);
+        if (previous !== null)
+            console.warn(toolKeyCollisionMessage(keyId, toolName, previous));
+    }, [client, keyId, toolName]);
+}
+/**
+ * Fetches a query again once a tool transport arrives, when it failed for
+ * want of one ({@link NoToolTransportError}): a `callTool` that resolves
+ * after the first render. TanStack refetches on a new key or `enabled`,
+ * never on a new fetcher, so the query would keep the error until a remount.
+ */
+export function useRefetchOnTransport(callTool, query) {
+    const { error, refetch } = query;
+    useEffect(() => {
+        if (callTool && error instanceof NoToolTransportError)
+            void refetch();
+    }, [callTool, error, refetch]);
+}
 /**
  * Loads data from a widget tool via TanStack Query.
  *
- * `args` is appended to the effective query key so two callers that share
- * the supplied `queryKey` but pass different `args` get separate cache
- * entries (otherwise the second caller silently reads stale data from the
- * first — the classic queryKey-vs-args trap). `select` transforms data on
- * each read without mutating the cache.
+ * The effective cache key is `[...queryKey, args]` (`toolQueryKey`): two
+ * callers that share `queryKey` but pass different `args` get separate
+ * entries. Two tools must not share a key and args; the hook warns when they
+ * do. Under an `AppQueryProvider` with `toolNameInQueryKey` (opt-in in 2.x,
+ * the default from the next major) the key is `[...queryKey, toolName,
+ * args]` and two tools never collide; `useToolQueryKey` returns the key in
+ * force. `opts` passes TanStack's query options through (`retry`,
+ * `retryDelay`, `staleTime`, `placeholderData` / `keepPreviousData`,
+ * `initialData` + `initialDataUpdatedAt`, `enabled`, `select`, …), and the
+ * result exposes `refetch`, `failureCount` and `failureReason`. `retry`
+ * defaults to the client's; `retry: shouldRetryToolCall` stops retrying a
+ * tool's own `isError` answer.
+ *
+ * The tool goes through `AppQueryProvider`'s `callTool`, else the nearest
+ * `HostBridgeProvider`'s bridge; with neither, the query fails with a
+ * "no tool transport" error instead of idling, and fetches once one arrives.
  */
 export function useToolQuery(queryKey, toolName, args, opts) {
     const callTool = useCallTool();
-    return useQuery({
-        queryKey: [...queryKey, args],
-        queryFn: async () => {
-            if (!callTool)
-                throw new Error("callTool not available");
-            const result = await callTool(toolName, args);
-            return parseToolResult(result);
-        },
-        select: opts?.select,
-        enabled: !!callTool && (opts?.enabled ?? true),
-    });
+    const toolNameInKey = useToolNameInQueryKey();
+    useToolKeyGuard(queryKey, toolName, args);
+    const query = useQuery(toolQueryOptions(queryKey, toolName, args, callTool, opts, {
+        toolNameInKey,
+    }));
+    useRefetchOnTransport(callTool, query);
+    return query;
 }
 /**
- * Executes a mutation via a widget tool and invalidates configured query keys.
+ * Executes a mutation via a widget tool and invalidates `invalidateKeys`
+ * after each successful call (`invalidateQueries`: active queries refetch,
+ * inactive ones are marked stale and refetch when they are next used).
+ *
+ * `mutate(args, { onSuccess, onError, onSettled })` fires its per-call
+ * callbacks for EVERY call while the component is mounted, not only for the
+ * latest one (TanStack's own rule), so two quick calls each get their
+ * confirmation. The hook-level callbacks in `opts` run first; the
+ * invalidation runs before the hook-level `onSuccess`.
  */
 export function useToolMutation(toolName, opts) {
     const callTool = useCallTool();
     const queryClient = useQueryClient();
-    return useMutation({
+    const { invalidateKeys, onSuccess, ...options } = opts ?? {};
+    const mutation = useMutation({
+        ...options,
         mutationFn: async (args) => {
             if (!callTool)
-                throw new Error("callTool not available");
+                throw new NoToolTransportError(toolName);
             const result = await callTool(toolName, args);
             return parseToolResult(result);
         },
-        onSuccess: async () => {
-            if (opts?.invalidateKeys) {
-                await Promise.all(opts.invalidateKeys.map((key) => queryClient.refetchQueries({ queryKey: key })));
-            }
+        onSuccess: async (data, variables, onMutateResult, context) => {
+            await invalidateToolQueries(queryClient, invalidateKeys);
+            await onSuccess?.(data, variables, onMutateResult, context);
         },
     });
+    // Per-call callbacks fire only while mounted (TanStack's rule, kept), with
+    // the latest meta/mutationKey. Both refs are written in effects and read
+    // only when a call settles, so `mutate` stays stable across renders.
+    const mounted = useRef(false);
+    const scope = useRef({
+        meta: undefined,
+        mutationKey: undefined,
+    });
+    useEffect(() => {
+        scope.current = { meta: options.meta, mutationKey: options.mutationKey };
+    });
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const { mutateAsync } = mutation;
+    const mutate = useCallback((variables, callbacks) => {
+        settleEachCall(mutateAsync(variables), variables, callbacks, () => mounted.current ? { client: queryClient, ...scope.current } : null);
+    }, [mutateAsync, queryClient]);
+    return { ...mutation, mutate };
 }
 //# sourceMappingURL=use-tool-query.js.map

package/dist/hooks/use-tool-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-tool-query.js","sourceRoot":"","sources":["../../src/hooks/use-tool-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAO7D;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAC1B,QAAmB,EACnB,QAAgB,EAChB,IAAY,EACZ,IAA4C;IAE5C,MAAM,QAAQ,GAAG,WAAW,EAAE,CAAA;IAE9B,OAAO,QAAQ,CAA0B;QACvC,QAAQ,EAAE,CAAC,GAAG,QAAQ,EAAE,IAAI,CAAC;QAC7B,OAAO,EAAE,KAAK,IAAI,EAAE;YAClB,IAAI,CAAC,QAAQ;gBAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAA;YACxD,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;YAC7C,OAAO,eAAe,CAAQ,MAAM,CAAC,CAAA;QACvC,CAAC;QACD,MAAM,EAAE,IAAI,EAAE,MAAM;QACpB,OAAO,EAAE,CAAC,CAAC,QAAQ,IAAI,CAAC,IAAI,EAAE,OAAO,IAAI,IAAI,CAAC;KAC/C,CAAC,CAAA;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,QAAgB,EAChB,IAAuC;IAEvC,MAAM,QAAQ,GAAG,WAAW,EAAE,CAAA;IAC9B,MAAM,WAAW,GAAG,cAAc,EAAE,CAAA;IAEpC,OAAO,WAAW,CAAwC;QACxD,UAAU,EAAE,KAAK,EAAE,IAA6B,EAAE,EAAE;YAClD,IAAI,CAAC,QAAQ;gBAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAA;YACxD,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;YAC7C,OAAO,eAAe,CAAQ,MAAM,CAAC,CAAA;QACvC,CAAC;QACD,SAAS,EAAE,KAAK,IAAI,EAAE;YACpB,IAAI,IAAI,EAAE,cAAc,EAAE,CAAC;gBACzB,MAAM,OAAO,CAAC,GAAG,CACf,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,CAChF,CAAA;YACH,CAAC;QACH,CAAC;KACF,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"use-tool-query.js","sourceRoot":"","sources":["../../src/hooks/use-tool-query.ts"],"names":[],"mappings":"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"}

package/dist/hooks/use-tool-result-recovery.d.ts

@@ -1,45 +1,49 @@
+import { type ToolResultObserver } from "../lib/tool-result-observer.js";
+import { type RecoveryPolicy, type ToolResultRecoveryState } from "./tool-result-recovery-model.js";
+export { decodeRecoveredResult } from "./tool-result-recovery-model.js";
+export type { RecoveryBlockReason, RecoveryPolicy, ToolResultRecoveryState, ToolSafety, } from "./tool-result-recovery-model.js";
 /**
  * Recovery for hosts that deliver the `ui/notifications/tool-result`
  * notification without `structuredContent` (observed on claude.ai and Claude
- * Desktop, which forward only the model-facing `content` blocks). Since
- * mcp-use 2.x such a result is not even observable: the `useToolContext`
- * latch ignores content-only successes, so the tool status stays `"pending"`
- * forever and the shell would idle on its loading skeleton.
+ * Desktop, which forward only the model-facing `content` blocks). mcp-use
+ * 2.x's `useToolContext` latch ignores such a content-only result, so its
+ * status stays `"pending"` forever and the shell would idle on its skeleton.
  *
- * Because the stripped notification is invisible, readiness is inferred two
- * ways: the hard `resultReady` signal (the latch fired but the payload is
- * invalid), or a grace timer — once the originating tool is known and no
- * result has latched within
- * {@link ToolResultRecoveryOptions.assumeStrippedAfterMs}, the result is
- * assumed delivered-but-stripped. Either way the hook re-executes the
- * originating tool once via the host bridge's official `callTool` — tool-call
- * RESPONSES carry `structuredContent` intact on those hosts — and exposes the
- * decoded payload. Spec-conforming hosts (e.g. the mcp-use inspector) deliver
- * a valid payload up front, so the recovery never fires there.
+ * The hook re-executes the originating tool once via the host bridge's
+ * `callTool` — tool-call RESPONSES carry `structuredContent` intact on those
+ * hosts — and exposes the decoded payload. When it does so (toolkit#176):
  *
- * A call the host cancelled is never recovered: since mcp-use 2.7.1 the
- * cancellation latches as `status: "error"` (a `ToolCancelledError`), which
- * would otherwise count as a ready-but-invalid result — re-executing it would
- * override the user's decision to stop the call.
+ * - **Only when the host stripped the result.** A passive observer of the
+ *   host's lifecycle notifications (`installToolResultObserver`) sees the
+ *   content-only result itself, so the recovery fires as it arrives, and a
+ *   slow tool on a compliant host is never re-run (K13): no result has
+ *   arrived because none was sent. Where the observer cannot vouch for that
+ *   (no browser frame, or installed after the handshake), the 2.x grace timer
+ *   ({@link ToolResultRecoveryOptions.assumeStrippedAfterMs}) still infers a
+ *   stripped result, once the call's arguments arrived.
+ * - **With the call's complete arguments** (N21): the observer's complete
+ *   `tool-input`, never a partial stream; an equal re-delivery is the same run.
+ * - **Never for a cancelled or failed call:** re-running repeats the failure
+ *   or overrides the user's stop; the shell renders that state and offers an
+ *   explicit retry.
+ * - **Only for a tool the policy allows** ({@link ToolResultRecoveryOptions.policy}):
+ *   by default never one the host reports as writing (`readOnlyHint: false`
+ *   or `destructiveHint: true` in `hostContext.toolInfo.tool.annotations`).
+ *   A blocked recovery is reported (`blocked`) so the view can show its error.
  *
- * Assumes the originating tool is a read-only render pipeline (true for all
- * toolkit `render-view`/`show_*` tools) — the re-execution must be safe to
- * repeat, and may rarely run concurrently with the original invocation when
- * the grace timer beats a slow but conforming host.
+ * The decision and its timer live in `createRecoveryController`; this hook
+ * only binds it to React.
  */
 /**
- * Default grace period before a silent latch counts as a stripped result.
- * Long enough for a conforming host to latch a typical render tool first,
- * short enough that users on stripping hosts are not left staring at the
- * skeleton noticeably.
+ * Default grace period before a silent latch counts as a stripped result —
+ * used only where the transport observer cannot vouch that nothing arrived.
  */
 export declare const DEFAULT_ASSUME_STRIPPED_AFTER_MS = 2500;
 export interface ToolResultRecoveryOptions {
     /**
      * The latch fired (`useToolContext().status !== "pending"`) — a structured
      * result, a tool error, or a host cancellation arrived. On hosts that strip
-     * `structuredContent` this never turns true; the grace timer below covers
-     * that case.
+     * `structuredContent` this never turns true.
      */
     resultReady: boolean;
     /**
@@ -48,12 +52,17 @@ export interface ToolResultRecoveryOptions {
      * attempt already in flight is dropped. Defaults to `false`.
      */
     cancelled?: boolean;
-    /** The payload the host delivered (`useToolContext().toolOutput`). */
-    props: unknown;
     /**
-     * Validates a candidate payload. MUST be referentially stable (module-level
-     * function or memoised) — it is an effect dependency.
+     * The originating call latched a tool error (`useToolContext().status ===
+     * "error"` without a cancellation): an `isError` result or a failed call.
+     * Suppresses the recovery exactly like {@link cancelled} — the shell shows
+     * the error instead of silently re-running a call that just failed
+     * (toolkit#176). Defaults to `false`.
      */
+    errored?: boolean;
+    /** The payload the host delivered (`useToolContext().toolOutput`). */
+    props: unknown;
+    /** Validates a candidate payload. */
     isValid: (value: unknown) => boolean;
     /** The tool arguments from `ui/notifications/tool-input` (`useToolContext().toolInput`). */
     toolInput: Record<string, unknown> | null | undefined;
@@ -63,18 +72,19 @@ export interface ToolResultRecoveryOptions {
     callTool: (name: string, args: Record<string, unknown>) => Promise<unknown>;
     /**
      * Grace period in ms after which a silent latch counts as a stripped
-     * result. Armed once the originating tool is known while `resultReady` is
-     * still false; re-armed on every `toolInput` update, because streaming
-     * arguments mean the invocation may not have finished yet. Defaults to
+     * result. Applies only where the transport observer cannot vouch that no
+     * result arrived (see above); restarts for new arguments. Defaults to
      * {@link DEFAULT_ASSUME_STRIPPED_AFTER_MS}.
      */
     assumeStrippedAfterMs?: number;
-}
-export interface ToolResultRecoveryState<T> {
-    /** The recovered payload, `null` until the re-execution resolved (or when it failed). */
-    data: T | null;
-    /** `true` when the single recovery attempt failed — the shell keeps its skeleton, no retry loop. */
-    failed: boolean;
+    /** Which tools may be re-executed on their own. Default `"auto"`. */
+    policy?: RecoveryPolicy;
+    /**
+     * The transport observer. Defaults to the document's
+     * (`installToolResultObserver()`); `null` disables it, leaving the grace
+     * timer to decide alone (the 2.x behaviour).
+     */
+    observer?: ToolResultObserver | null;
 }
 /**
  * Resolves the originating tool name from the host context's `toolInfo`.
@@ -83,9 +93,16 @@ export interface ToolResultRecoveryState<T> {
  */
 export declare function resolveRecoveryToolName(hostContext: unknown): string | undefined;
 /**
- * Decodes a re-executed tool result and validates it. Exposed for tests;
- * the hook uses it on the `callTool` response.
+ * Whether a latched or assumed-stripped result may be recovered at all: the
+ * call was neither cancelled nor failed. Kept for existing imports; the full
+ * rule (observer, policy, arguments) is `decideRecovery`.
+ * @deprecated Use `decideRecovery` from the recovery model.
  */
-export declare function decodeRecoveredResult<T>(result: unknown, isValid: (value: unknown) => boolean): T | null;
+export declare function isRecoveryReady(state: {
+    resultReady: boolean;
+    assumedReady: boolean;
+    cancelled: boolean;
+    errored: boolean;
+}): boolean;
 export declare function useToolResultRecovery<T>(options: ToolResultRecoveryOptions): ToolResultRecoveryState<T>;
 //# sourceMappingURL=use-tool-result-recovery.d.ts.map

package/dist/hooks/use-tool-result-recovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-tool-result-recovery.d.ts","sourceRoot":"","sources":["../../src/hooks/use-tool-result-recovery.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,OAAO,CAAA;AAEpD,MAAM,WAAW,yBAAyB;IACxC;;;;;OAKG;IACH,WAAW,EAAE,OAAO,CAAA;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,sEAAsE;IACtE,KAAK,EAAE,OAAO,CAAA;IACd;;;OAGG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;IACpC,4FAA4F;IAC5F,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;IACrD,gGAAgG;IAChG,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;IACvD,oCAAoC;IACpC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3E;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAA;CAC/B;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,yFAAyF;IACzF,IAAI,EAAE,CAAC,GAAG,IAAI,CAAA;IACd,oGAAoG;IACpG,MAAM,EAAE,OAAO,CAAA;CAChB;AAID;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAehF;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,GACnC,CAAC,GAAG,IAAI,CAQV;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,OAAO,EAAE,yBAAyB,GACjC,uBAAuB,CAAC,CAAC,CAAC,CAsF5B"}
+{"version":3,"file":"use-tool-result-recovery.d.ts","sourceRoot":"","sources":["../../src/hooks/use-tool-result-recovery.ts"],"names":[],"mappings":"AACA,OAAO,EAA6B,KAAK,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACnG,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC7B,MAAM,iCAAiC,CAAA;AAExC,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AACvE,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,uBAAuB,EACvB,UAAU,GACX,MAAM,iCAAiC,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;GAGG;AACH,eAAO,MAAM,gCAAgC,OAAO,CAAA;AAEpD,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAAA;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sEAAsE;IACtE,KAAK,EAAE,OAAO,CAAA;IACd,qCAAqC;IACrC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;IACpC,4FAA4F;IAC5F,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;IACrD,gGAAgG;IAChG,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;IACvD,oCAAoC;IACpC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC3E;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,qEAAqE;IACrE,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAA;CACrC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAehF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,WAAW,EAAE,OAAO,CAAA;IACpB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;CACjB,GAAG,OAAO,CAGV;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,OAAO,EAAE,yBAAyB,GACjC,uBAAuB,CAAC,CAAC,CAAC,CAyC5B"}

package/dist/hooks/use-tool-result-recovery.js

@@ -1,42 +1,44 @@
-import { useEffect, useRef, useState } from "react";
-import { parseToolResult } from "../lib/parse-tool-result.js";
+import { useEffect, useState, useSyncExternalStore } from "react";
+import { installToolResultObserver } from "../lib/tool-result-observer.js";
+import { createRecoveryController, } from "./tool-result-recovery-model.js";
+export { decodeRecoveredResult } from "./tool-result-recovery-model.js";
 /**
  * Recovery for hosts that deliver the `ui/notifications/tool-result`
  * notification without `structuredContent` (observed on claude.ai and Claude
- * Desktop, which forward only the model-facing `content` blocks). Since
- * mcp-use 2.x such a result is not even observable: the `useToolContext`
- * latch ignores content-only successes, so the tool status stays `"pending"`
- * forever and the shell would idle on its loading skeleton.
+ * Desktop, which forward only the model-facing `content` blocks). mcp-use
+ * 2.x's `useToolContext` latch ignores such a content-only result, so its
+ * status stays `"pending"` forever and the shell would idle on its skeleton.
  *
- * Because the stripped notification is invisible, readiness is inferred two
- * ways: the hard `resultReady` signal (the latch fired but the payload is
- * invalid), or a grace timer — once the originating tool is known and no
- * result has latched within
- * {@link ToolResultRecoveryOptions.assumeStrippedAfterMs}, the result is
- * assumed delivered-but-stripped. Either way the hook re-executes the
- * originating tool once via the host bridge's official `callTool` — tool-call
- * RESPONSES carry `structuredContent` intact on those hosts — and exposes the
- * decoded payload. Spec-conforming hosts (e.g. the mcp-use inspector) deliver
- * a valid payload up front, so the recovery never fires there.
+ * The hook re-executes the originating tool once via the host bridge's
+ * `callTool` — tool-call RESPONSES carry `structuredContent` intact on those
+ * hosts — and exposes the decoded payload. When it does so (toolkit#176):
  *
- * A call the host cancelled is never recovered: since mcp-use 2.7.1 the
- * cancellation latches as `status: "error"` (a `ToolCancelledError`), which
- * would otherwise count as a ready-but-invalid result — re-executing it would
- * override the user's decision to stop the call.
+ * - **Only when the host stripped the result.** A passive observer of the
+ *   host's lifecycle notifications (`installToolResultObserver`) sees the
+ *   content-only result itself, so the recovery fires as it arrives, and a
+ *   slow tool on a compliant host is never re-run (K13): no result has
+ *   arrived because none was sent. Where the observer cannot vouch for that
+ *   (no browser frame, or installed after the handshake), the 2.x grace timer
+ *   ({@link ToolResultRecoveryOptions.assumeStrippedAfterMs}) still infers a
+ *   stripped result, once the call's arguments arrived.
+ * - **With the call's complete arguments** (N21): the observer's complete
+ *   `tool-input`, never a partial stream; an equal re-delivery is the same run.
+ * - **Never for a cancelled or failed call:** re-running repeats the failure
+ *   or overrides the user's stop; the shell renders that state and offers an
+ *   explicit retry.
+ * - **Only for a tool the policy allows** ({@link ToolResultRecoveryOptions.policy}):
+ *   by default never one the host reports as writing (`readOnlyHint: false`
+ *   or `destructiveHint: true` in `hostContext.toolInfo.tool.annotations`).
+ *   A blocked recovery is reported (`blocked`) so the view can show its error.
  *
- * Assumes the originating tool is a read-only render pipeline (true for all
- * toolkit `render-view`/`show_*` tools) — the re-execution must be safe to
- * repeat, and may rarely run concurrently with the original invocation when
- * the grace timer beats a slow but conforming host.
+ * The decision and its timer live in `createRecoveryController`; this hook
+ * only binds it to React.
  */
 /**
- * Default grace period before a silent latch counts as a stripped result.
- * Long enough for a conforming host to latch a typical render tool first,
- * short enough that users on stripping hosts are not left staring at the
- * skeleton noticeably.
+ * Default grace period before a silent latch counts as a stripped result —
+ * used only where the transport observer cannot vouch that nothing arrived.
  */
 export const DEFAULT_ASSUME_STRIPPED_AFTER_MS = 2500;
-const IDLE = { data: null, failed: false };
 /**
  * Resolves the originating tool name from the host context's `toolInfo`.
  * Reads the SEP-1865 shape first (`toolInfo.tool.name`), then the flattened
@@ -62,92 +64,42 @@ export function resolveRecoveryToolName(hostContext) {
     return undefined;
 }
 /**
- * Decodes a re-executed tool result and validates it. Exposed for tests;
- * the hook uses it on the `callTool` response.
+ * Whether a latched or assumed-stripped result may be recovered at all: the
+ * call was neither cancelled nor failed. Kept for existing imports; the full
+ * rule (observer, policy, arguments) is `decideRecovery`.
+ * @deprecated Use `decideRecovery` from the recovery model.
  */
-export function decodeRecoveredResult(result, isValid) {
-    let decoded;
-    try {
-        decoded = parseToolResult(result);
-    }
-    catch {
-        return null;
-    }
-    return decoded !== null && isValid(decoded) ? decoded : null;
+export function isRecoveryReady(state) {
+    if (state.cancelled || state.errored)
+        return false;
+    return state.resultReady || state.assumedReady;
 }
 export function useToolResultRecovery(options) {
-    const { resultReady, cancelled = false, props, isValid, toolInput, hostContext, callTool, assumeStrippedAfterMs = DEFAULT_ASSUME_STRIPPED_AFTER_MS, } = options;
-    const [state, setState] = useState(IDLE);
-    // Single-flight: the promise ref survives StrictMode's dev-mode
-    // effect re-run (cleanup + setup on the same instance), so the re-run
-    // re-subscribes to the SAME in-flight call instead of firing a second one.
-    const flightRef = useRef(null);
-    const flightInputRef = useRef(null);
-    const toolName = resolveRecoveryToolName(hostContext);
-    // A stripped result is unobservable (the 2.x latch ignores content-only
-    // results), so infer it: once a recovery could fire but the latch has been
-    // silent for the grace period, treat the result as delivered-but-stripped.
-    // Re-armed on every toolInput identity change — streaming arguments mean
-    // the invocation may still be running, so the grace period starts over.
-    // The re-arm is a render-phase reset (not an effect) so the cascading-
-    // render lint stays satisfied; the timer effect below restarts anyway
-    // because toolInput is one of its dependencies.
-    const [assumedReady, setAssumedReady] = useState(false);
-    const [prevTimerInput, setPrevTimerInput] = useState(toolInput);
-    if (prevTimerInput !== toolInput) {
-        setPrevTimerInput(toolInput);
-        if (assumedReady)
-            setAssumedReady(false);
-    }
+    const { resultReady, cancelled = false, errored = false, props, isValid, toolInput, hostContext, callTool, assumeStrippedAfterMs = DEFAULT_ASSUME_STRIPPED_AFTER_MS, policy = "auto", observer, } = options;
+    // One controller per mount; it survives StrictMode's effect re-run, so an
+    // in-flight call is never fired twice.
+    const [controller] = useState(() => createRecoveryController({
+        observer: observer === undefined ? installToolResultObserver() : observer,
+    }));
     useEffect(() => {
-        if (resultReady || cancelled || toolName === undefined)
-            return;
-        const timer = setTimeout(() => setAssumedReady(true), assumeStrippedAfterMs);
-        return () => clearTimeout(timer);
-    }, [resultReady, cancelled, toolName, toolInput, assumeStrippedAfterMs]);
-    // A cancelled call never counts as ready, so the effect below invalidates
-    // any in-flight attempt the same way it does for a superseded run.
-    const ready = !cancelled && (resultReady || assumedReady);
+        controller.start();
+        return () => controller.stop();
+    }, [controller]);
     useEffect(() => {
-        // A new tool run (result no longer ready, or fresh tool-input identity)
-        // invalidates any previous recovery attempt and re-arms the single-flight.
-        if (flightRef.current && (!ready || flightInputRef.current !== toolInput)) {
-            flightRef.current = null;
-            setState((prev) => (prev.data === null && !prev.failed ? prev : IDLE));
-        }
-        // Never fire on conforming hosts (valid payload) or before the
-        // originating tool is known.
-        if (!ready || isValid(props) || toolName === undefined)
-            return;
-        if (!flightRef.current) {
-            flightInputRef.current = toolInput;
-            flightRef.current = (async () => {
-                try {
-                    const result = await callTool(toolName, toolInput ?? {});
-                    const data = decodeRecoveredResult(result, isValid);
-                    if (data !== null)
-                        return { data, failed: false };
-                    console.warn(`[mcp-toolkit] tool-result recovery: re-executing "${toolName}" returned no usable payload`);
-                    return { data: null, failed: true };
-                }
-                catch (err) {
-                    console.warn(`[mcp-toolkit] tool-result recovery for "${toolName}" failed:`, err);
-                    return { data: null, failed: true };
-                }
-            })();
-        }
-        const flight = flightRef.current;
-        let stale = false;
-        void flight.then((outcome) => {
-            // Drop the outcome when this subscription was superseded or the flight
-            // was invalidated by a newer tool run.
-            if (!stale && flightRef.current === flight)
-                setState(outcome);
+        controller.update({
+            resultReady,
+            cancelled,
+            errored,
+            props,
+            isValid,
+            toolInput,
+            hostContext,
+            callTool,
+            policy,
+            graceMs: assumeStrippedAfterMs,
+            resolveToolName: resolveRecoveryToolName,
         });
-        return () => {
-            stale = true;
-        };
-    }, [ready, props, isValid, toolName, toolInput, callTool]);
-    return state;
+    });
+    return useSyncExternalStore(controller.subscribe, controller.getState, controller.getState);
 }
 //# sourceMappingURL=use-tool-result-recovery.js.map

package/dist/hooks/use-tool-result-recovery.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-tool-result-recovery.js","sourceRoot":"","sources":["../../src/hooks/use-tool-result-recovery.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-tool-result-recovery.js","sourceRoot":"","sources":["../../src/hooks/use-tool-result-recovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,OAAO,CAAA;AACjE,OAAO,EAAE,yBAAyB,EAA2B,MAAM,gCAAgC,CAAA;AACnG,OAAO,EACL,wBAAwB,GAGzB,MAAM,iCAAiC,CAAA;AAExC,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAQvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,IAAI,CAAA;AAkDpD;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,WAAoB;IAC1D,IAAI,CAAC,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IACrE,MAAM,IAAI,GAAI,WAAuC,CAAC,QAAQ,CAAA;IAC9D,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IACvD,MAAM,GAAG,GAAG,IAA+B,CAAA;IAC3C,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAA;IACrB,MAAM,UAAU,GAAG;QACjB,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAE,IAAgC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;QACrF,GAAG,CAAC,IAAI;QACR,GAAG,CAAC,QAAQ;KACb,CAAA;IACD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,SAAS,CAAA;IAC7E,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,KAK/B;IACC,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,OAAO;QAAE,OAAO,KAAK,CAAA;IAClD,OAAO,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,YAAY,CAAA;AAChD,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,OAAkC;IAElC,MAAM,EACJ,WAAW,EACX,SAAS,GAAG,KAAK,EACjB,OAAO,GAAG,KAAK,EACf,KAAK,EACL,OAAO,EACP,SAAS,EACT,WAAW,EACX,QAAQ,EACR,qBAAqB,GAAG,gCAAgC,EACxD,MAAM,GAAG,MAAM,EACf,QAAQ,GACT,GAAG,OAAO,CAAA;IACX,0EAA0E;IAC1E,uCAAuC;IACvC,MAAM,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,CACjC,wBAAwB,CAAI;QAC1B,QAAQ,EAAE,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,yBAAyB,EAAE,CAAC,CAAC,CAAC,QAAQ;KAC1E,CAAC,CACH,CAAA;IACD,SAAS,CAAC,GAAG,EAAE;QACb,UAAU,CAAC,KAAK,EAAE,CAAA;QAClB,OAAO,GAAG,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,CAAA;IAChC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAA;IAChB,SAAS,CAAC,GAAG,EAAE;QACb,UAAU,CAAC,MAAM,CAAC;YAChB,WAAW;YACX,SAAS;YACT,OAAO;YACP,KAAK;YACL,OAAO;YACP,SAAS;YACT,WAAW;YACX,QAAQ;YACR,MAAM;YACN,OAAO,EAAE,qBAAqB;YAC9B,eAAe,EAAE,uBAAuB;SACzC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IACF,OAAO,oBAAoB,CAAC,UAAU,CAAC,SAAS,EAAE,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAA;AAC7F,CAAC"}