@beeuni/sdk 0.1.0

package/dist/react/use-project-triggers.d.ts

@@ -0,0 +1,221 @@
+import { updateProjectTrigger, type ProjectTriggerEventApps, type ProjectTriggerEventTypes, type ProjectTriggerListing } from '../core/rest/projects-client/index.js';
+export declare const projectTriggersKey: (projectId: string | null | undefined) => readonly ["kx", "project", string, "triggers"];
+export declare function useProjectTriggers(projectId: string | null | undefined): {
+    create: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, import("../index.js").CreateProjectTriggerInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, {
+        slug: string;
+        input: Parameters<typeof updateProjectTrigger>[2];
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    fire: import("@tanstack/react-query").UseMutationResult<import("../index.js").FireProjectTriggerResponse, Error, string, unknown>;
+    data: ProjectTriggerListing;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<ProjectTriggerListing, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    create: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, import("../index.js").CreateProjectTriggerInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, {
+        slug: string;
+        input: Parameters<typeof updateProjectTrigger>[2];
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    fire: import("@tanstack/react-query").UseMutationResult<import("../index.js").FireProjectTriggerResponse, Error, string, unknown>;
+    data: ProjectTriggerListing;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<ProjectTriggerListing, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    create: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, import("../index.js").CreateProjectTriggerInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, {
+        slug: string;
+        input: Parameters<typeof updateProjectTrigger>[2];
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    fire: import("@tanstack/react-query").UseMutationResult<import("../index.js").FireProjectTriggerResponse, Error, string, unknown>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<ProjectTriggerListing, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    create: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, import("../index.js").CreateProjectTriggerInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, {
+        slug: string;
+        input: Parameters<typeof updateProjectTrigger>[2];
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    fire: import("@tanstack/react-query").UseMutationResult<import("../index.js").FireProjectTriggerResponse, Error, string, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<ProjectTriggerListing, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    create: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, import("../index.js").CreateProjectTriggerInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, {
+        slug: string;
+        input: Parameters<typeof updateProjectTrigger>[2];
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    fire: import("@tanstack/react-query").UseMutationResult<import("../index.js").FireProjectTriggerResponse, Error, string, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<ProjectTriggerListing, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    create: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, import("../index.js").CreateProjectTriggerInput, unknown>;
+    update: import("@tanstack/react-query").UseMutationResult<ProjectTriggerListing, Error, {
+        slug: string;
+        input: Parameters<typeof updateProjectTrigger>[2];
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    fire: import("@tanstack/react-query").UseMutationResult<import("../index.js").FireProjectTriggerResponse, Error, string, unknown>;
+    data: ProjectTriggerListing;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<ProjectTriggerListing, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};
+export type ProjectTriggerEventTarget = string | {
+    app: string;
+    source?: string;
+};
+export declare const projectTriggerEventTypesKey: (projectId: string | null | undefined, target: ProjectTriggerEventTarget | null | undefined) => readonly ["kx", "project", string, "triggers", "event-types", string];
+export declare function useProjectTriggerEventTypes(projectId: string | null | undefined, target: ProjectTriggerEventTarget | null | undefined): import("@tanstack/react-query").UseQueryResult<ProjectTriggerEventTypes, Error>;
+export declare const projectTriggerEventAppsKey: (projectId: string | null | undefined) => readonly ["kx", "project", string, "triggers", "event-apps"];
+export declare function useProjectTriggerEventApps(projectId: string | null | undefined): import("@tanstack/react-query").UseQueryResult<ProjectTriggerEventApps, Error>;

package/dist/react/use-project-triggers.js

@@ -0,0 +1,53 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { createProjectTrigger, deleteProjectTrigger, fireProjectTrigger, listProjectTriggerEventApps, listProjectTriggerEventTypes, listProjectTriggers, updateProjectTrigger, } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export const projectTriggersKey = (projectId) => qk.project.triggers(projectId ?? '');
+export function useProjectTriggers(projectId) {
+    const queryClient = useQueryClient();
+    const queryKey = projectTriggersKey(projectId);
+    const query = useQuery({
+        queryKey,
+        queryFn: () => listProjectTriggers(projectId),
+        enabled: !!projectId,
+        ...contract('config'),
+    });
+    const invalidate = () => queryClient.invalidateQueries({ queryKey });
+    const create = useMutation({
+        mutationFn: (input) => createProjectTrigger(projectId, input),
+        onSuccess: invalidate,
+    });
+    const update = useMutation({
+        mutationFn: (args) => updateProjectTrigger(projectId, args.slug, args.input),
+        onSuccess: invalidate,
+    });
+    const remove = useMutation({
+        mutationFn: (slug) => deleteProjectTrigger(projectId, slug),
+        onSuccess: invalidate,
+    });
+    const fire = useMutation({
+        mutationFn: (slug) => fireProjectTrigger(projectId, slug),
+    });
+    return { ...query, create, update, remove, fire };
+}
+const targetKey = (target) => typeof target === 'object' && target ? `app:${target.source ?? 'composio'}:${target.app}` : (target ?? '');
+export const projectTriggerEventTypesKey = (projectId, target) => qk.project.triggerEventTypes(projectId ?? '', targetKey(target));
+export function useProjectTriggerEventTypes(projectId, target) {
+    const chosen = typeof target === 'object' && target ? target.app : target;
+    return useQuery({
+        queryKey: projectTriggerEventTypesKey(projectId, target),
+        queryFn: () => listProjectTriggerEventTypes(projectId, typeof target === 'object' ? target : { connector: target }),
+        enabled: !!projectId && !!chosen,
+        ...contract('config'),
+    });
+}
+export const projectTriggerEventAppsKey = (projectId) => qk.project.triggerEventApps(projectId ?? '');
+export function useProjectTriggerEventApps(projectId) {
+    return useQuery({
+        queryKey: projectTriggerEventAppsKey(projectId),
+        queryFn: () => listProjectTriggerEventApps(projectId),
+        enabled: !!projectId,
+        ...contract('config'),
+    });
+}

package/dist/react/use-prompt-attachments.d.ts

@@ -0,0 +1,3 @@
+import { type PromptAttachmentController, type PromptAttachmentControllerOptions, type PromptAttachmentSnapshot } from '../core/attachments/prompt-attachments.js';
+export type UsePromptAttachmentsResult = Omit<PromptAttachmentController, 'dispose' | 'subscribe' | 'getSnapshot'> & PromptAttachmentSnapshot;
+export declare function usePromptAttachments(projectId: string | null | undefined, options?: PromptAttachmentControllerOptions): UsePromptAttachmentsResult;

package/dist/react/use-prompt-attachments.js

@@ -0,0 +1,34 @@
+'use client';
+import { useEffect, useMemo, useSyncExternalStore } from 'react';
+import { createPromptAttachmentController, } from '../core/attachments/prompt-attachments.js';
+export function usePromptAttachments(projectId, options = {}) {
+    const concurrency = options.concurrency;
+    const owner = useMemo(() => ({
+        controller: createPromptAttachmentController(projectId, { concurrency }),
+        mounts: 0,
+    }), [projectId, concurrency]);
+    const { controller } = owner;
+    const snapshot = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+    useEffect(() => {
+        owner.mounts++;
+        return () => {
+            owner.mounts--;
+            queueMicrotask(() => {
+                if (owner.mounts === 0)
+                    controller.dispose();
+            });
+        };
+    }, [owner, controller]);
+    return useMemo(() => ({
+        add: controller.add,
+        addMany: controller.addMany,
+        retry: controller.retry,
+        remove: controller.remove,
+        abort: controller.abort,
+        submit: controller.submit,
+        reclaim: controller.reclaim,
+        whenReady: controller.whenReady,
+        forget: controller.forget,
+        ...snapshot,
+    }), [controller, snapshot]);
+}

package/dist/react/use-provider-secrets.d.ts

@@ -0,0 +1,229 @@
+export declare function useAccountSecretResources(accountId: string | null | undefined, projectId?: string): import("@tanstack/react-query").UseQueryResult<{
+    secrets: import("../index.js").AccountSecretResource[];
+}, Error>;
+export declare function useSessionProviderSecretPools(projectId: string | null | undefined, sessionId: string | null | undefined): {
+    setPool: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionProviderSecretPool, Error, {
+        providerId: string;
+        secretIds: string[] | null;
+    }, unknown>;
+    data: {
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    setPool: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionProviderSecretPool, Error, {
+        providerId: string;
+        secretIds: string[] | null;
+    }, unknown>;
+    data: {
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    setPool: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionProviderSecretPool, Error, {
+        providerId: string;
+        secretIds: string[] | null;
+    }, unknown>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    setPool: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionProviderSecretPool, Error, {
+        providerId: string;
+        secretIds: string[] | null;
+    }, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    setPool: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionProviderSecretPool, Error, {
+        providerId: string;
+        secretIds: string[] | null;
+    }, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    setPool: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionProviderSecretPool, Error, {
+        providerId: string;
+        secretIds: string[] | null;
+    }, unknown>;
+    data: {
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    };
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        pools: import("../index.js").SessionProviderSecretPool[];
+        can_edit: boolean;
+        personal_user_id?: string | null;
+        personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};

package/dist/react/use-provider-secrets.js

@@ -0,0 +1,38 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { listAccountSecretResources, listSessionProviderSecretPools, setSessionProviderSecretPool, } from '../core/rest/projects-client/account-secret-resources.js';
+export function useAccountSecretResources(accountId, projectId) {
+    return useQuery({
+        queryKey: ['account-secret-resources', accountId, projectId],
+        queryFn: () => listAccountSecretResources(accountId, projectId),
+        enabled: Boolean(accountId),
+        refetchInterval: (query) => {
+            const now = Date.now();
+            const deadlines = (query.state.data?.secrets ?? []).map((secret) => Date.parse(secret.cooldown_until ?? '')).filter((deadline) => deadline > now);
+            return deadlines.length ? Math.max(1000, Math.min(...deadlines) - now) : false;
+        },
+    });
+}
+export function useSessionProviderSecretPools(projectId, sessionId) {
+    const queryClient = useQueryClient();
+    const queryKey = ['session-provider-secret-pools', projectId, sessionId];
+    const query = useQuery({
+        queryKey,
+        queryFn: () => listSessionProviderSecretPools(projectId, sessionId),
+        enabled: Boolean(projectId && sessionId),
+    });
+    const setPool = useMutation({
+        mutationFn: ({ providerId, secretIds }) => {
+            if (!projectId || !sessionId)
+                throw new Error('A project and session are required to select provider secrets');
+            return setSessionProviderSecretPool(projectId, sessionId, providerId, secretIds);
+        },
+        onSuccess: async () => {
+            await Promise.all([
+                queryClient.invalidateQueries({ queryKey }),
+                queryClient.invalidateQueries({ queryKey: ['session-provider-secret-pool', projectId, sessionId] }),
+            ]);
+        },
+    });
+    return { ...query, setPool };
+}

package/dist/react/use-question-self-heal.d.ts

@@ -0,0 +1,7 @@
+import type { MessageWithPartsLike } from '../core/turns/types.js';
+export declare function hasRunningQuestionTool(messages: MessageWithPartsLike[] | undefined): boolean;
+export interface UseQuestionSelfHealOptions {
+    enabled?: boolean;
+    isSuppressed?: (requestId: string) => boolean;
+}
+export declare function useQuestionSelfHeal(sessionId: string, messages: MessageWithPartsLike[] | undefined, options?: UseQuestionSelfHealOptions): void;

package/dist/react/use-question-self-heal.js

@@ -0,0 +1,81 @@
+'use client';
+import { useEffect, useMemo, useRef } from 'react';
+import { useRuntimePendingStore } from '../browser/stores/opencode-pending-store.js';
+import { useSandboxConnectionStore } from '../browser/stores/sandbox-connection-store.js';
+import { getClient } from '../core/runtime/client.js';
+import { shouldRunSelfHealPoll } from './self-heal-poll-gate.js';
+export function hasRunningQuestionTool(messages) {
+    if (!messages)
+        return false;
+    return messages.some((m) => {
+        if (m.info.role !== 'assistant')
+            return false;
+        return m.parts.some((p) => {
+            if (p.type !== 'tool')
+                return false;
+            const tool = p;
+            if (tool.tool !== 'question')
+                return false;
+            return tool.state.status === 'running' || tool.state.status === 'pending';
+        });
+    });
+}
+export function useQuestionSelfHeal(sessionId, messages, options = {}) {
+    const { enabled = true, isSuppressed } = options;
+    const addQuestion = useRuntimePendingStore((s) => s.addQuestion);
+    const pendingCount = useRuntimePendingStore((s) => Object.values(s.questions).filter((q) => q.sessionID === sessionId && !isSuppressed?.(q.id))
+        .length);
+    const running = useMemo(() => hasRunningQuestionTool(messages), [messages]);
+    const sandboxStatus = useSandboxConnectionStore((s) => s.status);
+    const parked = useSandboxConnectionStore((s) => s.parked);
+    const pollAllowed = shouldRunSelfHealPoll({
+        enabled,
+        hasCandidate: running,
+        pendingCount,
+        sandboxStatus,
+        parked,
+    });
+    const inFlightRef = useRef(false);
+    const lastAtRef = useRef(0);
+    useEffect(() => {
+        if (!pollAllowed)
+            return;
+        let cancelled = false;
+        const hydrate = () => {
+            if (inFlightRef.current || cancelled)
+                return;
+            const now = Date.now();
+            if (now - lastAtRef.current < 1500)
+                return;
+            let client;
+            try {
+                client = getClient();
+            }
+            catch {
+                return;
+            }
+            inFlightRef.current = true;
+            lastAtRef.current = now;
+            void client.question
+                .list()
+                .then((res) => {
+                if (!res.data || cancelled)
+                    return;
+                res.data.forEach((q) => {
+                    if (!q?.id || isSuppressed?.(q.id))
+                        return;
+                    addQuestion(q);
+                });
+            })
+                .finally(() => {
+                inFlightRef.current = false;
+            });
+        };
+        hydrate();
+        const timer = setInterval(hydrate, 2000);
+        return () => {
+            cancelled = true;
+            clearInterval(timer);
+        };
+    }, [pollAllowed, addQuestion, isSuppressed]);
+}