@datalayer/agent-runtimes 1.0.3 → 1.0.5

package/lib/hooks/useSkills.js

@@ -2,45 +2,100 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { useContext } from 'react';
-import { useQuery, QueryClientContext } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { agentRuntimeStore, useAgentRuntimeCodemodeStatus } from '../stores';
+function parseSkillStatus(value) {
+    if (value === 'available' || value === 'enabled' || value === 'loaded') {
+        return value;
+    }
+    return 'available';
+}
+// ---------------------------------------------------------------------------
+// Skills from WS snapshot
+// ---------------------------------------------------------------------------
 /**
- * Hook to fetch available skills from backend.
+ * Derive the list of skills from the WS-pushed `codemodeStatus`.
+ *
+ * The server-side SkillsArea pushes per-skill status (`available`,
+ * `enabled`, `loaded`) via the monitoring WebSocket inside the
+ * `codemodeStatus.skills` array.  This hook reads from the Zustand
+ * store — no REST call is made.
  */
-export function useSkills(enabled, baseEndpoint, authToken) {
-    const queryClient = useContext(QueryClientContext);
-    if (!queryClient) {
-        return {
-            data: undefined,
-            isLoading: false,
-            isError: false,
-            error: null,
-            refetch: () => Promise.resolve({ data: undefined }),
-        };
-    }
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useQuery({
-        queryFn: async () => {
-            if (!baseEndpoint) {
-                return { skills: [], total: 0 };
-            }
-            // Derive skills endpoint from config endpoint.
-            const skillsEndpoint = baseEndpoint.replace('/configure', '/skills');
-            const headers = {
-                'Content-Type': 'application/json',
-            };
-            if (authToken) {
-                headers['Authorization'] = `Bearer ${authToken}`;
-            }
-            const response = await fetch(skillsEndpoint, { headers });
-            if (!response.ok) {
-                throw new Error(`Skills fetch failed: ${response.statusText}`);
-            }
-            return response.json();
-        },
-        queryKey: ['skills', baseEndpoint || 'jupyter'],
-        enabled,
-        staleTime: 5 * 60 * 1000,
-        retry: 1,
-    });
+export function useSkills(_enabled, _baseEndpoint, _authToken) {
+    const codemodeStatus = useAgentRuntimeCodemodeStatus();
+    const data = useMemo(() => {
+        if (!codemodeStatus) {
+            return undefined;
+        }
+        const skills = (codemodeStatus.skills ?? []).map(s => ({
+            id: s.id ?? s.name,
+            name: s.name,
+            description: s.description,
+            tags: s.tags,
+            has_scripts: s.has_scripts,
+            has_resources: s.has_resources,
+            status: parseSkillStatus(s.status),
+            approved: s.approved !== false,
+            skill_definition: s.skill_definition ?? null,
+            source_variant: s.source_variant,
+            module: s.module,
+            package: s.package,
+            method: s.method,
+            path: s.path,
+        }));
+        return { skills, total: skills.length };
+    }, [codemodeStatus]);
+    return {
+        data,
+        isLoading: false,
+        isError: false,
+        error: null,
+        refetch: () => Promise.resolve({ data }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Skill enable / disable via WebSocket
+// ---------------------------------------------------------------------------
+export function useSkillActions(agentId) {
+    const enableSkill = useCallback((skillId) => {
+        const ok = agentRuntimeStore
+            .getState()
+            .sendRawMessage({ type: 'skill_enable', skillId }, agentId);
+        if (!ok) {
+            console.warn('[useSkillActions] skill_enable dropped: websocket not ready');
+        }
+        return ok;
+    }, [agentId]);
+    const disableSkill = useCallback((skillId) => {
+        const ok = agentRuntimeStore
+            .getState()
+            .sendRawMessage({ type: 'skill_disable', skillId }, agentId);
+        if (!ok) {
+            console.warn('[useSkillActions] skill_disable dropped: websocket not ready');
+        }
+        return ok;
+    }, [agentId]);
+    const approveSkill = useCallback((skillId) => {
+        const ok = agentRuntimeStore
+            .getState()
+            .sendRawMessage({ type: 'skill_approve', skillId }, agentId);
+        if (!ok) {
+            console.warn('[useSkillActions] skill_approve dropped: websocket not ready');
+        }
+        return ok;
+    }, [agentId]);
+    const unapproveSkill = useCallback((skillId) => {
+        const ok = agentRuntimeStore
+            .getState()
+            .sendRawMessage({ type: 'skill_unapprove', skillId }, agentId);
+        if (!ok) {
+            console.warn('[useSkillActions] skill_unapprove dropped: websocket not ready');
+        }
+        return ok;
+    }, [agentId]);
+    return { enableSkill, disableSkill, approveSkill, unapproveSkill };
 }
+// ---------------------------------------------------------------------------
+// Loaded skills (kept for backward compat with AgentSkillsExample sidebar)
+// ---------------------------------------------------------------------------
+export { useAgentRuntimeLoadedSkills } from '../stores';

package/lib/hooks/useToolApprovals.d.ts

@@ -1,45 +1,69 @@
 import type { ToolApprovalFilters } from '../types/tool-approvals';
-export declare function useToolApprovalsQuery(filters?: ToolApprovalFilters): import("@tanstack/react-query").UseQueryResult<import("../types").ToolApproval[], Error>;
+/**
+ * Normalised approval record. Both snake_case (server-native) and
+ * camelCase (TypeScript-idiomatic) keys are present so existing UI
+ * consumers keep working regardless of which naming they read.
+ */
+export type ApprovalRecord = {
+    id: string;
+    agent_id: string;
+    agentId: string;
+    pod_name: string;
+    podName: string;
+    tool_name: string;
+    toolName: string;
+    tool_call_id?: string;
+    toolCallId?: string;
+    tool_args: Record<string, unknown>;
+    toolArgs: Record<string, unknown>;
+    status: string;
+    note?: string | null;
+    created_at: string;
+    createdAt: string;
+    updated_at?: string;
+    updatedAt?: string;
+    read?: boolean;
+};
+interface ApprovalsQueryData {
+    approvals: ApprovalRecord[];
+    total: number;
+}
+interface MutationResult {
+    isPending: boolean;
+    mutate: (vars: {
+        id: string;
+        note?: string;
+    }) => void;
+    mutateAsync: (vars: {
+        id: string;
+        note?: string;
+    }) => Promise<void>;
+}
+export declare function useToolApprovalsQuery(filters?: ToolApprovalFilters): import("@tanstack/react-query").UseQueryResult<ApprovalsQueryData, Error>;
 export declare function usePendingApprovalCount(): import("@tanstack/react-query").UseQueryResult<{
     count: number;
 }, Error>;
-export declare function useApproveToolRequest(): import("@tanstack/react-query").UseMutationResult<void, Error, {
-    id: string;
-    note?: string;
-}, unknown>;
-export declare function useRejectToolRequest(): import("@tanstack/react-query").UseMutationResult<void, Error, {
-    id: string;
-    note?: string;
-}, unknown>;
-export declare function useMarkToolApprovalRead(): import("@tanstack/react-query").UseMutationResult<void, Error, {
-    id: string;
-}, unknown>;
-export declare function useMarkToolApprovalUnread(): import("@tanstack/react-query").UseMutationResult<void, Error, {
-    id: string;
-}, unknown>;
-export declare function useDeleteToolApproval(): import("@tanstack/react-query").UseMutationResult<void, Error, {
-    id: string;
-}, unknown>;
+export declare function useApproveToolRequest(): MutationResult;
+export declare function useRejectToolRequest(): MutationResult;
+export declare function useMarkToolApprovalRead(): MutationResult;
+export declare function useMarkToolApprovalUnread(): MutationResult;
+/**
+ * Delete a tool approval.
+ *
+ * Sends a ``tool_approval_delete`` message over the shared websocket.
+ * The local cache is updated only after the server emits
+ * ``tool_approval_deleted``.
+ */
+export declare function useDeleteToolApproval(): MutationResult;
 export declare function useToolApprovals(filters?: ToolApprovalFilters): {
-    approvalsQuery: import("@tanstack/react-query").UseQueryResult<import("../types").ToolApproval[], Error>;
+    approvalsQuery: import("@tanstack/react-query").UseQueryResult<ApprovalsQueryData, Error>;
     pendingCountQuery: import("@tanstack/react-query").UseQueryResult<{
         count: number;
     }, Error>;
-    approve: import("@tanstack/react-query").UseMutationResult<void, Error, {
-        id: string;
-        note?: string;
-    }, unknown>;
-    reject: import("@tanstack/react-query").UseMutationResult<void, Error, {
-        id: string;
-        note?: string;
-    }, unknown>;
-    markRead: import("@tanstack/react-query").UseMutationResult<void, Error, {
-        id: string;
-    }, unknown>;
-    markUnread: import("@tanstack/react-query").UseMutationResult<void, Error, {
-        id: string;
-    }, unknown>;
-    remove: import("@tanstack/react-query").UseMutationResult<void, Error, {
-        id: string;
-    }, unknown>;
+    approve: MutationResult;
+    reject: MutationResult;
+    markRead: MutationResult;
+    markUnread: MutationResult;
+    remove: MutationResult;
 };
+export {};

package/lib/hooks/useToolApprovals.js

@@ -3,99 +3,348 @@
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * Agent tool approval hooks.
+ * Agent tool approval hooks (WebSocket-only).
+ *
+ * All tool-approval interactions flow over the AI Agents websocket stream.
+ * There are no REST endpoints — the server publishes approval snapshots and
+ * `tool_approval_*` events, and the client sends `tool_approval_decision`
+ * messages to approve/reject pending requests.
+ *
+ * Consumers use the familiar React Query-style API below. Internally the
+ * hooks:
+ *   - subscribe to the shared AI Agents WS once per component tree
+ *   - seed/update the `['tool-approvals', filters]` query cache from events
+ *   - send decision messages over the same socket for mutations
  *
  * @module hooks/useToolApprovals
  */
-import { useMemo } from 'react';
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { useCoreStore, useIAMStore } from '@datalayer/core/lib/state';
-import { DEFAULT_SERVICE_URLS } from '@datalayer/core/lib/api/constants';
-import { toolApprovals } from '../api';
-// ─── Auth helpers ────────────────────────────────────────────────────
-function useDashboardAuthToken() {
-    const token = useIAMStore((s) => s.token);
-    return token ?? '';
-}
-function useDashboardBaseUrl() {
-    const config = useCoreStore((s) => s.configuration);
-    return config?.aiagentsRunUrl ?? DEFAULT_SERVICE_URLS.AI_AGENTS;
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { useAIAgentsWebSocket } from './useAIAgentsWebSocket';
+// ─── Helpers ─────────────────────────────────────────────────────────
+const APPROVALS_ROOT_KEY = ['tool-approvals'];
+function str(value) {
+    return typeof value === 'string' ? value : value == null ? '' : String(value);
+}
+function normalizeApproval(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const rec = raw;
+    const id = typeof rec.id === 'string' ? rec.id : undefined;
+    if (!id)
+        return null;
+    const agent = str(rec.agent_id ?? rec.agentId);
+    const pod = str(rec.pod_name ?? rec.podName);
+    const tool = str(rec.tool_name ?? rec.toolName ?? 'unknown');
+    const toolCall = rec.tool_call_id ?? rec.toolCallId;
+    const args = rec.tool_args ??
+        rec.toolArgs ??
+        {};
+    const created = str(rec.created_at ?? rec.createdAt);
+    const updated = str(rec.updated_at ?? rec.updatedAt);
+    return {
+        id,
+        agent_id: agent,
+        agentId: agent,
+        pod_name: pod,
+        podName: pod,
+        tool_name: tool,
+        toolName: tool,
+        tool_call_id: typeof toolCall === 'string' ? toolCall : undefined,
+        toolCallId: typeof toolCall === 'string' ? toolCall : undefined,
+        tool_args: args,
+        toolArgs: args,
+        status: str(rec.status ?? 'pending'),
+        note: typeof rec.note === 'string'
+            ? rec.note
+            : rec.note === null
+                ? null
+                : undefined,
+        created_at: created,
+        createdAt: created,
+        updated_at: updated || undefined,
+        updatedAt: updated || undefined,
+        read: typeof rec.read === 'boolean' ? rec.read : undefined,
+    };
+}
+function matchesFilter(a, filters) {
+    if (!filters)
+        return true;
+    if (filters.agentId && a.agent_id !== filters.agentId)
+        return false;
+    if (filters.status && a.status !== filters.status)
+        return false;
+    if (filters.toolName && a.tool_name !== filters.toolName)
+        return false;
+    return true;
+}
+function upsertApproval(list, approval) {
+    const idx = list.findIndex(item => item.id === approval.id);
+    if (idx === -1)
+        return [approval, ...list];
+    const copy = list.slice();
+    copy[idx] = { ...copy[idx], ...approval };
+    return copy;
+}
+function removeApproval(list, id) {
+    return list.filter(item => item.id !== id);
+}
+function writeSnapshot(queryClient, approvals) {
+    const queries = queryClient
+        .getQueryCache()
+        .findAll({ queryKey: APPROVALS_ROOT_KEY });
+    for (const q of queries) {
+        const [, second] = q.queryKey;
+        if (second === 'pending-count') {
+            queryClient.setQueryData(q.queryKey, {
+                count: approvals.filter(a => a.status === 'pending').length,
+            });
+            continue;
+        }
+        const filters = (second ?? undefined);
+        const filtered = approvals.filter(a => matchesFilter(a, filters));
+        queryClient.setQueryData(q.queryKey, {
+            approvals: filtered,
+            total: filtered.length,
+        });
+    }
+    // Ensure there's always a root cache entry so downstream consumers can
+    // compute derived values (like pending-count refetches) even when no
+    // filter query has been mounted yet.
+    queryClient.setQueryData(APPROVALS_ROOT_KEY, {
+        approvals,
+        total: approvals.length,
+    });
+}
+function patchApproval(queryClient, approval, mode) {
+    const queries = queryClient
+        .getQueryCache()
+        .findAll({ queryKey: APPROVALS_ROOT_KEY });
+    for (const q of queries) {
+        const [, second] = q.queryKey;
+        if (second === 'pending-count') {
+            // Recompute from the root cache after we finish patching below.
+            continue;
+        }
+        const filters = (second ?? undefined);
+        const current = queryClient.getQueryData(q.queryKey)?.approvals ?? [];
+        let next;
+        if (mode === 'remove') {
+            next = removeApproval(current, approval.id);
+        }
+        else {
+            next = matchesFilter(approval, filters)
+                ? upsertApproval(current, approval)
+                : removeApproval(current, approval.id);
+        }
+        queryClient.setQueryData(q.queryKey, {
+            approvals: next,
+            total: next.length,
+        });
+    }
+    // Recompute pending-count from the unfiltered root cache.
+    const root = queryClient.getQueryData(APPROVALS_ROOT_KEY)?.approvals;
+    if (root) {
+        queryClient.setQueryData(['tool-approvals', 'pending-count'], { count: root.filter(a => a.status === 'pending').length });
+    }
+}
+// ─── Shared WS bridge ─────────────────────────────────────────────────
+/**
+ * Opens a WS connection and streams snapshots + events into the React
+ * Query cache. Returns a `send` function so sibling hooks can dispatch
+ * decisions over the same socket.
+ */
+function useApprovalsSocket() {
+    const queryClient = useQueryClient();
+    const { connectionState, send } = useAIAgentsWebSocket({
+        onMessage: msg => {
+            const type = (msg.type ?? msg.event);
+            if (!type)
+                return;
+            // Response to our { type: 'tool-approvals-history' } request.
+            // Shape: { type: "tool-approvals-history", data: { approvals: [...] } }
+            if (type === 'tool-approvals-history') {
+                const data = msg.data;
+                const rawList = Array.isArray(data?.approvals) ? data.approvals : [];
+                const list = rawList
+                    .map(normalizeApproval)
+                    .filter((a) => a !== null)
+                    .filter(a => a.status !== 'deleted');
+                writeSnapshot(queryClient, list);
+                return;
+            }
+            // Incremental broadcast events from datalayer-ai-agents.
+            // Shape: { channel: "user:<uid>", event: "tool_approval_*", data: record }
+            if (type.startsWith('tool_approval_')) {
+                const rawPayload = msg.payload ??
+                    msg.data ??
+                    undefined;
+                const approval = normalizeApproval(rawPayload);
+                if (!approval)
+                    return;
+                patchApproval(queryClient, approval, type === 'tool_approval_deleted' ? 'remove' : 'upsert');
+            }
+        },
+    });
+    // Request the full approval history once connected so the sidebar badge
+    // and any pending-count consumers always show the correct count.
+    const historyAskedRef = useRef(false);
+    useEffect(() => {
+        if (connectionState !== 'connected') {
+            historyAskedRef.current = false;
+            return;
+        }
+        if (historyAskedRef.current)
+            return;
+        historyAskedRef.current = send({ type: 'tool-approvals-history' });
+    }, [connectionState, send]);
+    return { send, connectionState };
 }
 // ─── Base hooks ──────────────────────────────────────────────────────
 export function useToolApprovalsQuery(filters) {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
+    useApprovalsSocket();
+    const queryClient = useQueryClient();
+    const queryKey = useMemo(() => ['tool-approvals', filters], [filters]);
     return useQuery({
-        queryKey: ['tool-approvals', filters],
-        queryFn: () => toolApprovals.getToolApprovals(token, filters, baseUrl),
-        enabled: !!token,
-        staleTime: 10_000,
+        queryKey,
+        // Data is populated via the WS bridge. On invalidation, return the
+        // cached value so the fresh WS snapshot is preserved.
+        queryFn: async () => queryClient.getQueryData(queryKey) ?? {
+            approvals: [],
+            total: 0,
+        },
+        staleTime: Number.POSITIVE_INFINITY,
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
     });
 }
 export function usePendingApprovalCount() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
+    useApprovalsSocket();
+    const queryClient = useQueryClient();
     return useQuery({
         queryKey: ['tool-approvals', 'pending-count'],
-        queryFn: () => toolApprovals.getPendingApprovalCount(token, baseUrl),
-        enabled: !!token,
-        staleTime: 5_000,
+        queryFn: async () => {
+            const cached = queryClient.getQueryData([
+                'tool-approvals',
+                'pending-count',
+            ]);
+            if (cached && typeof cached.count === 'number')
+                return cached;
+            const root = queryClient.getQueryData(APPROVALS_ROOT_KEY);
+            const pending = (root?.approvals ?? []).filter(a => a.status === 'pending').length;
+            return { count: pending };
+        },
+        staleTime: Number.POSITIVE_INFINITY,
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
     });
 }
+/** Build a mutation-style object that sends a WS decision. */
+function useDecisionMutation(approved) {
+    const { send } = useApprovalsSocket();
+    const [isPending, setIsPending] = useState(false);
+    const mutateAsync = useCallback(async ({ id, note }) => {
+        setIsPending(true);
+        try {
+            const ok = send({
+                type: 'tool_approval_decision',
+                approvalId: id,
+                approved,
+                ...(note ? { note } : {}),
+            });
+            if (!ok) {
+                throw new Error('Approvals WebSocket is not connected; decision was not sent');
+            }
+        }
+        finally {
+            setIsPending(false);
+        }
+    }, [approved, send]);
+    const mutate = useCallback((vars) => {
+        void mutateAsync(vars);
+    }, [mutateAsync]);
+    return { isPending, mutate, mutateAsync };
+}
 export function useApproveToolRequest() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id, note }) => toolApprovals.approveToolRequest(token, id, note, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    return useDecisionMutation(true);
 }
 export function useRejectToolRequest() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
+    return useDecisionMutation(false);
+}
+/**
+ * Mark a tool approval as read/unread in the local cache.
+ *
+ * Read-state isn't part of the websocket contract, so this hook patches
+ * only the React Query cache. The patch survives until the next snapshot.
+ */
+function useLocalReadMutation(target) {
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id, note }) => toolApprovals.rejectToolRequest(token, id, note, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    const [isPending, setIsPending] = useState(false);
+    const mutateAsync = useCallback(async ({ id }) => {
+        setIsPending(true);
+        try {
+            const queries = queryClient
+                .getQueryCache()
+                .findAll({ queryKey: APPROVALS_ROOT_KEY });
+            for (const q of queries) {
+                const [, second] = q.queryKey;
+                if (second === 'pending-count')
+                    continue;
+                const current = queryClient.getQueryData(q.queryKey);
+                if (!current?.approvals)
+                    continue;
+                queryClient.setQueryData(q.queryKey, {
+                    ...current,
+                    approvals: current.approvals.map(a => a.id === id ? { ...a, read: target } : a),
+                });
+            }
+        }
+        finally {
+            setIsPending(false);
+        }
+    }, [queryClient, target]);
+    const mutate = useCallback((vars) => {
+        void mutateAsync(vars);
+    }, [mutateAsync]);
+    return { isPending, mutate, mutateAsync };
 }
 export function useMarkToolApprovalRead() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id }) => toolApprovals.markToolApprovalRead(token, id, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    return useLocalReadMutation(true);
 }
 export function useMarkToolApprovalUnread() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id }) => toolApprovals.markToolApprovalUnread(token, id, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    return useLocalReadMutation(false);
 }
+/**
+ * Delete a tool approval.
+ *
+ * Sends a ``tool_approval_delete`` message over the shared websocket.
+ * The local cache is updated only after the server emits
+ * ``tool_approval_deleted``.
+ */
 export function useDeleteToolApproval() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id }) => toolApprovals.deleteToolApproval(token, id, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    const { send } = useApprovalsSocket();
+    const [isPending, setIsPending] = useState(false);
+    const mutateAsync = useCallback(async ({ id }) => {
+        setIsPending(true);
+        try {
+            const ok = send({
+                type: 'tool_approval_delete',
+                approvalId: id,
+            });
+            if (!ok) {
+                throw new Error('Approvals WebSocket is not connected; delete was not sent');
+            }
+        }
+        finally {
+            setIsPending(false);
+        }
+    }, [send]);
+    const mutate = useCallback((vars) => {
+        void mutateAsync(vars);
+    }, [mutateAsync]);
+    return { isPending, mutate, mutateAsync };
 }
 // ─── Composite hook ──────────────────────────────────────────────────
 export function useToolApprovals(filters) {

package/lib/hooks/useVercelAI.d.ts

@@ -6,7 +6,7 @@ export interface Message {
 }
 export interface UseVercelAIOptions {
     /**
-     * Base URL for the Vercel AI endpoint (e.g., 'http://localhost:8000')
+     * Base URL for the Vercel AI endpoint (e.g., `http://localhost:8000`).
      */
     baseUrl?: string;
     /**