@peers-app/peers-ui 0.26.6 → 0.27.1

package/dist/hooks/use-rows.test.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("@testing-library/react");
+const use_rows_1 = require("./use-rows");
+/** A table whose reads are answered by the test, one at a time. */
+function fakeTable(answer) {
+    const listeners = new Set();
+    const reads = [];
+    const table = {
+        list: jest.fn(async (filter) => {
+            reads.push(filter);
+            return answer(filter);
+        }),
+        dataChanged: {
+            subscribe: (handler, options) => {
+                const listener = { handler: () => handler({}), options };
+                listeners.add(listener);
+                return { unsubscribe: () => listeners.delete(listener) };
+            },
+        },
+    };
+    return {
+        table,
+        reads,
+        listeners,
+        change: () => {
+            for (const listener of listeners)
+                listener.handler();
+        },
+        reconnect: () => {
+            for (const listener of listeners)
+                listener.options?.onReconnect?.();
+        },
+    };
+}
+function Rows({ table, filter }) {
+    const { rows, loading, error } = (0, use_rows_1.useRows)(table, filter);
+    return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("span", { "data-testid": "rows", children: rows.map((row) => row.id).join(",") }), (0, jsx_runtime_1.jsx)("span", { "data-testid": "loading", children: String(loading) }), (0, jsx_runtime_1.jsx)("span", { "data-testid": "error", children: error?.message ?? "" })] }));
+}
+const text = (id) => react_1.screen.getByTestId(id).textContent;
+describe("useRows", () => {
+    test("reads on mount and again when the table changes", async () => {
+        let rows = [{ id: "a" }];
+        const fake = fakeTable(() => rows);
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
+        expect(text("loading")).toBe("true");
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a"));
+        expect(text("loading")).toBe("false");
+        rows = [{ id: "a" }, { id: "b" }];
+        (0, react_1.act)(() => fake.change());
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a,b"));
+    });
+    test("changes during a read cause one more read, not one per change", async () => {
+        let release;
+        let n = 0;
+        const fake = fakeTable(() => new Promise((resolve) => {
+            const id = String(++n);
+            release = () => resolve([{ id }]);
+        }));
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
+        await (0, react_1.waitFor)(() => expect(fake.reads).toHaveLength(1));
+        (0, react_1.act)(() => {
+            fake.change();
+            fake.change();
+            fake.change();
+        });
+        await (0, react_1.act)(async () => release?.());
+        await (0, react_1.waitFor)(() => expect(fake.reads).toHaveLength(2));
+        await (0, react_1.act)(async () => release?.());
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("2"));
+        expect(fake.reads).toHaveLength(2);
+    });
+    test("reads again after a reconnect", async () => {
+        let rows = [{ id: "a" }];
+        const fake = fakeTable(() => rows);
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a"));
+        rows = [{ id: "missed" }];
+        (0, react_1.act)(() => fake.reconnect());
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("missed"));
+    });
+    test("reports a failed read and keeps the last rows", async () => {
+        let fail = false;
+        const fake = fakeTable(() => {
+            if (fail)
+                throw new Error("host is down");
+            return [{ id: "a" }];
+        });
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a"));
+        fail = true;
+        (0, react_1.act)(() => fake.change());
+        await (0, react_1.waitFor)(() => expect(text("error")).toBe("host is down"));
+        expect(text("rows")).toBe("a");
+        fail = false;
+        (0, react_1.act)(() => fake.change());
+        await (0, react_1.waitFor)(() => expect(text("error")).toBe(""));
+    });
+    test("reads again when the filter changes, and unsubscribes on unmount", async () => {
+        const fake = fakeTable((filter) => [{ id: JSON.stringify(filter) }]);
+        const { rerender, unmount } = (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table, filter: { id: "x" } }));
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe('{"id":"x"}'));
+        // An equal filter in a new object doesn't read again.
+        rerender((0, jsx_runtime_1.jsx)(Rows, { table: fake.table, filter: { id: "x" } }));
+        rerender((0, jsx_runtime_1.jsx)(Rows, { table: fake.table, filter: { id: "y" } }));
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe('{"id":"y"}'));
+        expect(fake.reads).toEqual([{ id: "x" }, { id: "y" }]);
+        expect(fake.listeners.size).toBe(1);
+        unmount();
+        expect(fake.listeners.size).toBe(0);
+    });
+    test("reads again once an asynchronous subscription is live", async () => {
+        let rows = [{ id: "before" }];
+        const fake = fakeTable(() => rows);
+        let release;
+        const ready = new Promise((resolve) => {
+            release = resolve;
+        });
+        const subscribe = fake.table.dataChanged.subscribe;
+        fake.table.dataChanged.subscribe = (handler, options) => ({
+            ...subscribe(handler, options),
+            ready,
+        });
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("before"));
+        // No notification can be delivered while the remote subscription is still attaching.
+        rows = [{ id: "during setup" }];
+        await (0, react_1.act)(async () => release(true));
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("during setup"));
+    });
+    test("a synchronous list failure can be retried", async () => {
+        const fake = fakeTable(() => [{ id: "recovered" }]);
+        const list = fake.table.list;
+        fake.table.list = jest.fn(() => {
+            throw new Error("offline");
+        });
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(Rows, { table: fake.table }));
+        await (0, react_1.waitFor)(() => expect(text("error")).toBe("offline"));
+        fake.table.list = list;
+        (0, react_1.act)(() => fake.change());
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("recovered"));
+    });
+    test("reload retries a failed subscription", async () => {
+        const fake = fakeTable(() => [{ id: "recovered" }]);
+        const subscribe = fake.table.dataChanged.subscribe;
+        fake.table.dataChanged.subscribe = () => {
+            throw new Error("subscription unavailable");
+        };
+        const { result } = (0, react_1.renderHook)(() => (0, use_rows_1.useRows)(fake.table));
+        await (0, react_1.waitFor)(() => expect(result.current.error?.message).toBe("subscription unavailable"));
+        fake.table.dataChanged.subscribe = subscribe;
+        await (0, react_1.act)(async () => result.current.reload());
+        expect(result.current.rows).toEqual([{ id: "recovered" }]);
+        expect(result.current.error).toBeUndefined();
+        expect(fake.listeners.size).toBe(1);
+    });
+    test("reload resolves once the rows are current", async () => {
+        let rows = [{ id: "a" }];
+        const fake = fakeTable(() => rows);
+        let reload;
+        function Reloading() {
+            const result = (0, use_rows_1.useRows)(fake.table);
+            reload = result.reload;
+            return (0, jsx_runtime_1.jsx)("span", { "data-testid": "rows", children: result.rows.map((row) => row.id).join(",") });
+        }
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(Reloading, {}));
+        await (0, react_1.waitFor)(() => expect(text("rows")).toBe("a"));
+        rows = [{ id: "b" }];
+        await (0, react_1.act)(async () => {
+            await reload?.();
+        });
+        expect(text("rows")).toBe("b");
+    });
+});

package/dist/hooks/use-subscription.d.ts

@@ -0,0 +1,10 @@
+import type { ReadonlyObservable } from "@peers-app/peers-sdk";
+/**
+ * Use this to register a handler for an observable in a functional component.
+ * The handler is called immediately (unless `doNotCallOnChangeDuringSetup`) and whenever the
+ * observable changes.
+ * @param subscribable The observable to subscribe to
+ * @param onChange The function to call with the new value when the observable changes
+ * @param doNotCallOnChangeDuringSetup Skip the immediate call.
+ */
+export declare function useSubscription<T>(subscribable: ReadonlyObservable<T>, onChange: (value: T) => void, doNotCallOnChangeDuringSetup?: boolean): void;

package/dist/hooks/use-subscription.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSubscription = useSubscription;
+const react_1 = require("react");
+/**
+ * Use this to register a handler for an observable in a functional component.
+ * The handler is called immediately (unless `doNotCallOnChangeDuringSetup`) and whenever the
+ * observable changes.
+ * @param subscribable The observable to subscribe to
+ * @param onChange The function to call with the new value when the observable changes
+ * @param doNotCallOnChangeDuringSetup Skip the immediate call.
+ */
+function useSubscription(subscribable, onChange, doNotCallOnChangeDuringSetup) {
+    (0, react_1.useEffect)(() => {
+        if (!doNotCallOnChangeDuringSetup) {
+            onChange(subscribable());
+        }
+        const subscription = subscribable.subscribe(() => onChange(subscribable()));
+        return () => subscription.dispose();
+    }, [subscribable, onChange, doNotCallOnChangeDuringSetup]);
+}

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

@@ -0,0 +1,43 @@
+/** A call {@link useTool} can run: a contract tool, a table write, or any async function. */
+export type UseToolCall = (...args: any[]) => Promise<unknown>;
+/**
+ * Callbacks for {@link useTool}. The latest ones passed are used. Callback failures are
+ * logged; they do not change the call's result or error. Async callbacks are not awaited.
+ */
+export interface IUseToolOptions<T extends UseToolCall> {
+    /** After a run succeeds, with its result and arguments. Not called after unmount. */
+    onSuccess?: (result: Awaited<ReturnType<T>>, ...args: Parameters<T>) => void;
+    /** After a run fails, with its error and arguments. Not called after unmount. */
+    onError?: (error: Error, ...args: Parameters<T>) => void;
+}
+/** What {@link useTool} returns. */
+export interface IUseToolResult<T extends UseToolCall> {
+    /** Run the call. Resolves to its result, or `undefined` when it fails; it never rejects. */
+    run: (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>> | undefined>;
+    /** True while the latest run is in flight. */
+    pending: boolean;
+    /** Why the latest run failed. Cleared when a run starts. */
+    error: Error | undefined;
+    /** The latest run's result. Cleared when a run starts. */
+    result: Awaited<ReturnType<T>> | undefined;
+    /** Clear state and ignore pending state updates, without cancelling calls or their callbacks. */
+    reset: () => void;
+}
+/**
+ * Run a tool from a component and track it: `pending` while it runs, then `result` or `error`.
+ *
+ * ```tsx
+ * const refresh = useTool(news.tools.refresh);
+ * <button disabled={refresh.pending} onClick={() => refresh.run()}>Refresh</button>
+ * {refresh.error && <div>Couldn't refresh.</div>}
+ * ```
+ *
+ * Typed from the call, so `run` takes the tool's input and `result` is its output. It also
+ * takes table writes (`useTool(news.tables.Feeds.save)`) or any async function. `run` keeps
+ * the same identity across renders and calls the latest function passed. When runs overlap,
+ * the state follows the latest one. Nothing updates after unmount.
+ *
+ * @param call - The tool or async function to run.
+ * @param options - `onSuccess` and `onError` callbacks.
+ */
+export declare function useTool<T extends UseToolCall>(call: T, options?: IUseToolOptions<T>): IUseToolResult<T>;

package/dist/hooks/use-tool.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTool = useTool;
+const react_1 = require("react");
+/**
+ * Run a tool from a component and track it: `pending` while it runs, then `result` or `error`.
+ *
+ * ```tsx
+ * const refresh = useTool(news.tools.refresh);
+ * <button disabled={refresh.pending} onClick={() => refresh.run()}>Refresh</button>
+ * {refresh.error && <div>Couldn't refresh.</div>}
+ * ```
+ *
+ * Typed from the call, so `run` takes the tool's input and `result` is its output. It also
+ * takes table writes (`useTool(news.tables.Feeds.save)`) or any async function. `run` keeps
+ * the same identity across renders and calls the latest function passed. When runs overlap,
+ * the state follows the latest one. Nothing updates after unmount.
+ *
+ * @param call - The tool or async function to run.
+ * @param options - `onSuccess` and `onError` callbacks.
+ */
+function useTool(call, options = {}) {
+    const latest = (0, react_1.useRef)({ call, options });
+    latest.current = { call, options };
+    const runs = (0, react_1.useRef)(0);
+    const mounted = (0, react_1.useRef)(true);
+    const [state, setState] = (0, react_1.useState)({ pending: false });
+    (0, react_1.useEffect)(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const run = (0, react_1.useCallback)(async (...args) => {
+        const id = ++runs.current;
+        if (mounted.current)
+            setState({ pending: true });
+        try {
+            const result = (await latest.current.call(...args));
+            if (mounted.current) {
+                if (id === runs.current)
+                    setState({ pending: false, result });
+                notify(() => latest.current.options.onSuccess?.(result, ...args));
+            }
+            return result;
+        }
+        catch (cause) {
+            const error = toolError(cause);
+            if (mounted.current) {
+                if (id === runs.current)
+                    setState({ pending: false, error });
+                notify(() => latest.current.options.onError?.(error, ...args));
+            }
+            return undefined;
+        }
+    }, []);
+    const reset = (0, react_1.useCallback)(() => {
+        runs.current++;
+        if (mounted.current)
+            setState({ pending: false });
+    }, []);
+    return { run, reset, pending: state.pending, error: state.error, result: state.result };
+}
+function notify(callback) {
+    const failed = (cause) => console.error("useTool callback failed", cause);
+    try {
+        void Promise.resolve(callback()).catch(failed);
+    }
+    catch (cause) {
+        failed(cause);
+    }
+}
+function toolError(cause) {
+    try {
+        if (cause instanceof Error)
+            return cause;
+        return new Error(String(cause));
+    }
+    catch {
+        return new Error("Tool call failed");
+    }
+}

package/dist/hooks/use-tool.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("@testing-library/react");
+const use_tool_1 = require("./use-tool");
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => {
+        resolve = yes;
+        reject = no;
+    });
+    return { promise, resolve, reject };
+}
+describe("useTool", () => {
+    test("tracks a run from pending to its result", async () => {
+        const answer = deferred();
+        const tool = jest.fn((_input) => answer.promise);
+        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(tool));
+        expect(result.current.pending).toBe(false);
+        let running;
+        (0, react_1.act)(() => {
+            running = result.current.run({ feed: "bbc" });
+        });
+        expect(result.current.pending).toBe(true);
+        expect(tool).toHaveBeenCalledWith({ feed: "bbc" });
+        await (0, react_1.act)(async () => answer.resolve({ count: 3 }));
+        await expect(running).resolves.toEqual({ count: 3 });
+        expect(result.current).toMatchObject({ pending: false, result: { count: 3 } });
+        expect(result.current.error).toBeUndefined();
+        const typeChecks = () => {
+            // @ts-expect-error the input is the tool's
+            void result.current.run({ feed: 1 });
+            const count = result.current.result?.count;
+            void count;
+        };
+        void typeChecks;
+    });
+    test("a failed run sets error and resolves undefined instead of throwing", async () => {
+        const onError = jest.fn();
+        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(async () => {
+            throw "offline";
+        }, { onError }));
+        let outcome = "unset";
+        await (0, react_1.act)(async () => {
+            outcome = await result.current.run();
+        });
+        expect(outcome).toBeUndefined();
+        expect(result.current.error?.message).toBe("offline");
+        expect(result.current.pending).toBe(false);
+        expect(onError).toHaveBeenCalledWith(expect.any(Error));
+    });
+    test("a new run clears the last error and result", async () => {
+        let fail = true;
+        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(async () => {
+            if (fail)
+                throw new Error("nope");
+            return "ok";
+        }));
+        await (0, react_1.act)(async () => {
+            await result.current.run();
+        });
+        expect(result.current.error).toBeDefined();
+        fail = false;
+        const next = deferred();
+        (0, react_1.act)(() => {
+            void result.current.run().then(() => next.resolve());
+        });
+        expect(result.current.error).toBeUndefined();
+        expect(result.current.pending).toBe(true);
+        await (0, react_1.act)(async () => next.promise);
+        expect(result.current.result).toBe("ok");
+    });
+    test("overlapping runs: the state follows the latest, each run resolves its own result", async () => {
+        const slow = deferred();
+        const fast = deferred();
+        const answers = [slow, fast];
+        const onSuccess = jest.fn();
+        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(() => answers.shift().promise, {
+            onSuccess,
+        }));
+        let first;
+        let second;
+        (0, react_1.act)(() => {
+            first = result.current.run();
+            second = result.current.run();
+        });
+        await (0, react_1.act)(async () => fast.resolve("fast"));
+        await expect(second).resolves.toBe("fast");
+        expect(result.current).toMatchObject({ pending: false, result: "fast" });
+        await (0, react_1.act)(async () => slow.resolve("slow"));
+        await expect(first).resolves.toBe("slow");
+        expect(result.current.result).toBe("fast");
+        expect(onSuccess.mock.calls.map(([value]) => value)).toEqual(["fast", "slow"]);
+    });
+    test("reset clears state but lets the pending call and callback finish", async () => {
+        const answer = deferred();
+        const onSuccess = jest.fn();
+        const { result } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(() => answer.promise, { onSuccess }));
+        (0, react_1.act)(() => {
+            void result.current.run();
+        });
+        (0, react_1.act)(() => result.current.reset());
+        expect(result.current.pending).toBe(false);
+        await (0, react_1.act)(async () => answer.resolve("late"));
+        expect(result.current.result).toBeUndefined();
+        expect(onSuccess).toHaveBeenCalledWith("late");
+    });
+    test("run is stable and calls the latest function and callbacks", async () => {
+        const onSuccess = jest.fn();
+        const { result, rerender } = (0, react_1.renderHook)(({ label }) => (0, use_tool_1.useTool)(async () => label, { onSuccess: (value) => onSuccess(label, value) }), { initialProps: { label: "first" } });
+        const run = result.current.run;
+        rerender({ label: "second" });
+        expect(result.current.run).toBe(run);
+        await (0, react_1.act)(async () => {
+            await run();
+        });
+        expect(result.current.result).toBe("second");
+        expect(onSuccess).toHaveBeenCalledWith("second", "second");
+    });
+    test("nothing updates after unmount", async () => {
+        const answer = deferred();
+        const onSuccess = jest.fn();
+        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
+        const { result, unmount } = (0, react_1.renderHook)(() => (0, use_tool_1.useTool)(() => answer.promise, { onSuccess }));
+        let running;
+        (0, react_1.act)(() => {
+            running = result.current.run();
+        });
+        unmount();
+        answer.resolve("done");
+        await expect(running).resolves.toBe("done");
+        expect(onSuccess).not.toHaveBeenCalled();
+        expect(errors).not.toHaveBeenCalled();
+        errors.mockRestore();
+    });
+    test("callback failures do not change the call's outcome or reject run", async () => {
+        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
+        const onError = jest.fn(() => {
+            throw new Error("error callback failed");
+        });
+        const { result, rerender } = (0, react_1.renderHook)(({ fail }) => (0, use_tool_1.useTool)(async () => {
+            if (fail)
+                throw new Error("tool failed");
+            return "saved";
+        }, {
+            onSuccess: () => {
+                throw new Error("success callback failed");
+            },
+            onError,
+        }), { initialProps: { fail: false } });
+        await (0, react_1.act)(async () => {
+            await expect(result.current.run()).resolves.toBe("saved");
+        });
+        expect(result.current.result).toBe("saved");
+        expect(result.current.error).toBeUndefined();
+        expect(onError).not.toHaveBeenCalled();
+        rerender({ fail: true });
+        await (0, react_1.act)(async () => {
+            await expect(result.current.run()).resolves.toBeUndefined();
+        });
+        expect(result.current.error?.message).toBe("tool failed");
+        expect(errors).toHaveBeenCalledTimes(2);
+        errors.mockRestore();
+    });
+    test("observes rejected async callbacks and unprintable rejection values", async () => {
+        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
+        const { result, rerender } = (0, react_1.renderHook)(({ fail }) => (0, use_tool_1.useTool)(async () => {
+            if (fail)
+                throw Object.create(null);
+            return "ok";
+        }, {
+            onSuccess: async () => {
+                throw new Error("async success callback");
+            },
+            onError: async () => {
+                throw new Error("async error callback");
+            },
+        }), { initialProps: { fail: false } });
+        await (0, react_1.act)(async () => {
+            await expect(result.current.run()).resolves.toBe("ok");
+        });
+        rerender({ fail: true });
+        await (0, react_1.act)(async () => {
+            await expect(result.current.run()).resolves.toBeUndefined();
+        });
+        expect(result.current.error).toBeInstanceOf(Error);
+        expect(errors).toHaveBeenCalledTimes(2);
+        errors.mockRestore();
+    });
+});

package/dist/screens/tools/tool-catalog-ipc.d.ts

@@ -9,27 +9,11 @@ export declare function getToolDetails(toolId: string): Promise<{
         usageDescription: string;
         inputSchema: {
             type: import("@peers-app/peers-sdk").IOSchemaType;
-            fields: {
-                name: string;
-                type: import("@peers-app/peers-sdk").FieldType;
-                optional?: boolean | undefined;
-                description?: string | undefined;
-                defaultValue?: any;
-                isArray?: boolean | undefined;
-                subType?: string | undefined;
-            }[];
+            fields: import("@peers-app/peers-sdk").IField[];
         };
         outputSchema: {
             type: import("@peers-app/peers-sdk").IOSchemaType;
-            fields: {
-                name: string;
-                type: import("@peers-app/peers-sdk").FieldType;
-                optional?: boolean | undefined;
-                description?: string | undefined;
-                defaultValue?: any;
-                isArray?: boolean | undefined;
-                subType?: string | undefined;
-            }[];
+            fields: import("@peers-app/peers-sdk").IField[];
         };
         toolId: string;
         contractId?: string | undefined;
@@ -40,15 +24,7 @@ export declare function getToolDetails(toolId: string): Promise<{
         catalogReason?: string | undefined;
         configSchema?: {
             type: import("@peers-app/peers-sdk").IOSchemaType;
-            fields: {
-                name: string;
-                type: import("@peers-app/peers-sdk").FieldType;
-                optional?: boolean | undefined;
-                description?: string | undefined;
-                defaultValue?: any;
-                isArray?: boolean | undefined;
-                subType?: string | undefined;
-            }[];
+            fields: import("@peers-app/peers-sdk").IField[];
         } | undefined;
         isAssistantRunner?: boolean | undefined;
         detailedDescription?: string | undefined;
@@ -67,27 +43,11 @@ export declare function listWorkflowMentionTools(query: string, limit: number):
     usageDescription: string;
     inputSchema: {
         type: import("@peers-app/peers-sdk").IOSchemaType;
-        fields: {
-            name: string;
-            type: import("@peers-app/peers-sdk").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }[];
+        fields: import("@peers-app/peers-sdk").IField[];
     };
     outputSchema: {
         type: import("@peers-app/peers-sdk").IOSchemaType;
-        fields: {
-            name: string;
-            type: import("@peers-app/peers-sdk").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }[];
+        fields: import("@peers-app/peers-sdk").IField[];
     };
     toolId: string;
     contractId?: string | undefined;
@@ -98,15 +58,7 @@ export declare function listWorkflowMentionTools(query: string, limit: number):
     catalogReason?: string | undefined;
     configSchema?: {
         type: import("@peers-app/peers-sdk").IOSchemaType;
-        fields: {
-            name: string;
-            type: import("@peers-app/peers-sdk").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }[];
+        fields: import("@peers-app/peers-sdk").IField[];
     } | undefined;
     isAssistantRunner?: boolean | undefined;
     detailedDescription?: string | undefined;

package/dist/utils.d.ts

@@ -1,9 +1,14 @@
+/** Plain text content of an HTML string (parsed with `DOMParser`, so browser-only). */
 export declare function htmlToText(html: string): string;
+/** Replaces `<@type:name:id>` / `<$type:name:id>` mentions with the readable name, underscores as spaces. */
 export declare function stripMentions(text: string): string;
+/** Sanitizes HTML with DOMPurify, collapses repeated blank paragraphs, and drops a trailing one. */
 export declare function trimAndSanitizeHtml(value: string): string;
-export declare function isObject(x: any): x is Record<string, any>;
-export declare function js(jsCode: string, externalReferences?: any): any;
+/** The `AsyncFunction` constructor, for compiling async code from a string. */
 export declare const AsyncFunction: any;
+/**
+ * Compiles and runs `jsCode` as the body of a strict async function. `utils`, `Promise`,
+ * `console` and each key of `externalReferences` are in scope; `process` and `global` are hidden.
+ * Runs arbitrary code: never pass it untrusted input.
+ */
 export declare function jsAsync(jsCode: string, externalReferences?: any): any;
-export declare function toJSON(obj: any): any;
-export declare function fromJSON(obj: any, externalReferences?: any): any;