@beeuni/sdk 0.1.0

package/dist/react/use-opencode-sessions/providers.js

@@ -0,0 +1,98 @@
+'use client';
+import { useMemo } from 'react';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { useBeeuniRouteProjectId } from '../route-project.js';
+import { contract } from '../query-contracts.js';
+import { qk } from '../query-keys.js';
+import { runtimeKeys, useRuntimeReady } from './keys.js';
+import { unwrap } from './shared.js';
+import { getProjectDetail, getProjectLlmCatalogProviders, getProjectModelPicker, listProjectSecrets, } from '../../core/rest/projects-client/index.js';
+import { GATEWAY_PROVIDER_IDS, mergeNativeProviderLists, nativeProviderListFromCatalog, nativeRuntimeProviderList, normalizeProviderList, projectLlmCatalogToProviderList, providerListHasModels, } from '../../core/models/provider-selection.js';
+import { shouldLoadProjectModelPicker } from './provider-load-plan.js';
+export { GATEWAY_PROVIDER_IDS };
+function isClientError(error) {
+    const status = error?.status;
+    return typeof status === 'number' && status >= 400 && status < 500;
+}
+export function useRuntimeProviders() {
+    const queryClient = useQueryClient();
+    const runtimeReady = useRuntimeReady();
+    const projectId = useBeeuniRouteProjectId();
+    const projectDetailQuery = useQuery({
+        queryKey: qk.project.detail(projectId ?? ''),
+        queryFn: () => getProjectDetail(projectId),
+        enabled: !!projectId,
+        ...contract('config'),
+    });
+    const projectGatewayEnabled = projectId ? projectDetailQuery.data?.project.experimental?.llm_gateway === true : false;
+    const projectModeKnown = !projectId || projectDetailQuery.isSuccess;
+    const gatewayProvidersQuery = useQuery({
+        queryKey: ['project-providers', projectId, 'gateway'],
+        queryFn: async () => {
+            const catalog = await queryClient.fetchQuery({
+                queryKey: qk.project.modelPicker(projectId),
+                queryFn: () => getProjectModelPicker(projectId),
+                ...contract('config'),
+            });
+            return projectLlmCatalogToProviderList(catalog);
+        },
+        enabled: shouldLoadProjectModelPicker({
+            projectId,
+            projectModeKnown,
+            projectGatewayEnabled,
+        }),
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+        retry: (failureCount, error) => (!projectModeKnown || projectGatewayEnabled) && !isClientError(error) && failureCount < 10,
+        retryDelay: (attempt) => Math.min(1000 * Math.pow(2, attempt), 8000),
+    });
+    const nativeProvidersQuery = useQuery({
+        queryKey: projectId ? ['project-providers', projectId, 'native'] : runtimeKeys.providers(),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.provider.list();
+            let providers = normalizeProviderList(unwrap(result));
+            if (projectId) {
+                const secrets = await listProjectSecrets(projectId);
+                const items = Array.isArray(secrets) ? secrets : (secrets.items ?? []);
+                const secretNames = new Set(items.map((secret) => secret.name));
+                providers = nativeRuntimeProviderList(providers, secretNames);
+            }
+            if (!providerListHasModels(providers)) {
+                throw new Error('opencode provider list has no connected models yet — sandbox still warming up');
+            }
+            return providers;
+        },
+        enabled: projectId
+            ? projectModeKnown && !projectGatewayEnabled && runtimeReady
+            : runtimeReady,
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+        retry: (failureCount, error) => !isClientError(error) && failureCount < 10,
+        retryDelay: (attempt) => Math.min(1000 * Math.pow(2, attempt), 8000),
+    });
+    const nativeCatalogQuery = useQuery({
+        queryKey: ['project-providers', projectId, 'native-catalog'],
+        queryFn: async () => {
+            const [catalog, secrets] = await Promise.all([
+                getProjectLlmCatalogProviders(projectId),
+                listProjectSecrets(projectId).catch(() => ({ items: [] })),
+            ]);
+            const items = Array.isArray(secrets) ? secrets : (secrets.items ?? []);
+            return nativeProviderListFromCatalog(catalog, new Set(items.map((secret) => secret.name)));
+        },
+        enabled: !!projectId && projectModeKnown && !projectGatewayEnabled,
+        ...contract('config'),
+        retry: false,
+    });
+    const mergedNative = useMemo(() => mergeNativeProviderLists(nativeCatalogQuery.data, nativeProvidersQuery.data), [nativeCatalogQuery.data, nativeProvidersQuery.data]);
+    if (projectId && projectGatewayEnabled)
+        return gatewayProvidersQuery;
+    if (projectId && projectModeKnown && !projectGatewayEnabled) {
+        const base = runtimeReady || nativeProvidersQuery.data ? nativeProvidersQuery : nativeCatalogQuery;
+        return Object.assign({}, base, { data: mergedNative });
+    }
+    return nativeProvidersQuery;
+}
+export const useOpenCodeProviders = useRuntimeProviders;

package/dist/react/use-opencode-sessions/sessions.d.ts

@@ -0,0 +1,34 @@
+import type { Session } from '../../core/runtime/runtime-types.js';
+export declare function useRuntimeSessions(enabled?: boolean): import("@tanstack/react-query").UseQueryResult<Session[], Error>;
+export declare function useRuntimeSession(sessionId: string): import("@tanstack/react-query").UseQueryResult<Session, Error>;
+export declare function useCreateRuntimeSession(): import("@tanstack/react-query").UseMutationResult<Session, Error, void | {
+    directory?: string;
+    title?: string;
+}, unknown>;
+export declare function useDeleteOpenCodeSession(): import("@tanstack/react-query").UseMutationResult<string, Error, string, unknown>;
+export declare function useUpdateRuntimeSession(): import("@tanstack/react-query").UseMutationResult<Session, Error, {
+    sessionId: string;
+    title?: string;
+    archived?: boolean;
+}, unknown>;
+export declare function useForkSession(): import("@tanstack/react-query").UseMutationResult<Session, Error, {
+    sessionId: string;
+    messageID?: string;
+}, unknown>;
+export declare function useRuntimeSessionDiff(sessionId: string): import("@tanstack/react-query").UseQueryResult<import("../../index.js").BeeuniFileDiff[], Error>;
+export declare function useRuntimeSessionTodo(sessionId: string): import("@tanstack/react-query").UseQueryResult<import("../../index.js").BeeuniTodo[], Error>;
+export declare function useSummarizeRuntimeSession(): import("@tanstack/react-query").UseMutationResult<string, Error, {
+    sessionId: string;
+    providerID?: string;
+    modelID?: string;
+}, void>;
+export declare function useInitSession(): import("@tanstack/react-query").UseMutationResult<string, Error, {
+    sessionId: string;
+}, unknown>;
+export declare const useOpenCodeSessions: typeof useRuntimeSessions;
+export declare const useOpenCodeSession: typeof useRuntimeSession;
+export declare const useCreateOpenCodeSession: typeof useCreateRuntimeSession;
+export declare const useUpdateOpenCodeSession: typeof useUpdateRuntimeSession;
+export declare const useOpenCodeSessionDiff: typeof useRuntimeSessionDiff;
+export declare const useOpenCodeSessionTodo: typeof useRuntimeSessionTodo;
+export declare const useSummarizeOpenCodeSession: typeof useSummarizeRuntimeSession;

package/dist/react/use-opencode-sessions/sessions.js

@@ -0,0 +1,330 @@
+'use client';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { isRuntimeConfigInvalidError } from '../../core/http/runtime-errors.js';
+import { markSessionFresh } from '../../core/http/fresh-sessions.js';
+import { useOpenCodeCompactionStore } from '../../browser/stores/opencode-compaction-store.js';
+import { useCurrentRuntime } from '../use-current-runtime.js';
+import { useRuntimeSupports } from '../use-runtime-supports.js';
+import { runtimeKeys, useRuntimeReady } from './keys.js';
+import { unwrap, canQueryRuntimeSession } from './shared.js';
+import { NoCompactionModelError } from './no-compaction-model-error.js';
+import { SESSION_SYNC_PAGE_SIZE } from '../../core/session-sync/session-sync-controller.js';
+export function useRuntimeSessions(enabled = true) {
+    const runtimeReady = useRuntimeReady();
+    const serverId = useCurrentRuntime((s) => s.sandboxId) ?? undefined;
+    return useQuery({
+        queryKey: runtimeKeys.sessions(serverId),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.session.list({ limit: 10000 });
+            const sessions = unwrap(result);
+            return sessions.sort((a, b) => b.time.updated - a.time.updated);
+        },
+        enabled: runtimeReady && enabled,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 5 * 60 * 1000,
+        refetchOnWindowFocus: false,
+        retry: (failureCount, error) => !isRuntimeConfigInvalidError(error) && failureCount < 16,
+        retryDelay: (attempt) => attempt < 16 ? 150 : Math.min(150 * Math.pow(2, attempt - 16), 10000),
+    });
+}
+export function useRuntimeSession(sessionId) {
+    const queryClient = useQueryClient();
+    const runtimeReady = useRuntimeReady();
+    const canQuerySession = canQueryRuntimeSession(sessionId);
+    return useQuery({
+        queryKey: runtimeKeys.runtimeSession(sessionId),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.session.get({ sessionID: sessionId });
+            return unwrap(result);
+        },
+        enabled: runtimeReady && canQuerySession,
+        staleTime: Infinity,
+        retry: (failureCount, error) => !isRuntimeConfigInvalidError(error) && failureCount < 3,
+        retryDelay: (attempt) => Math.min(1000 * Math.pow(2, attempt), 10000),
+        placeholderData: () => {
+            const sessions = queryClient.getQueryData(runtimeKeys.sessions());
+            return sessions?.find((s) => s.id === sessionId);
+        },
+    });
+}
+export function useCreateRuntimeSession() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (options) => {
+            const opts = options || {};
+            for (let attempt = 0;; attempt++) {
+                try {
+                    const client = getClient();
+                    const result = await client.session.create({
+                        directory: opts.directory,
+                        title: opts.title,
+                    });
+                    return unwrap(result);
+                }
+                catch (e) {
+                    const msg = e?.message ?? '';
+                    if (attempt < 6 && /opencode not ready/i.test(msg)) {
+                        await new Promise((r) => setTimeout(r, Math.min(500 * 2 ** attempt, 4_000)));
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+        },
+        onSuccess: (newSession) => {
+            const session = newSession;
+            markSessionFresh(session.id);
+            queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                if (!old)
+                    return [session];
+                const idx = old.findIndex((s) => s.id === session.id);
+                if (idx >= 0) {
+                    const next = [...old];
+                    next[idx] = session;
+                    return next.sort((a, b) => b.time.updated - a.time.updated);
+                }
+                return [session, ...old].sort((a, b) => b.time.updated - a.time.updated);
+            });
+            queryClient.setQueryData(runtimeKeys.runtimeSession(session.id), session);
+        },
+    });
+}
+export function useDeleteOpenCodeSession() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (sessionId) => {
+            const client = getClient();
+            const result = await client.session.delete({ sessionID: sessionId });
+            unwrap(result);
+            return sessionId;
+        },
+        onSuccess: (sessionId) => {
+            queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                if (!old)
+                    return old;
+                return old.filter((s) => s.id !== sessionId);
+            });
+            queryClient.removeQueries({
+                queryKey: runtimeKeys.runtimeSession(sessionId),
+            });
+            queryClient.removeQueries({
+                queryKey: runtimeKeys.runtimeMessages(sessionId),
+            });
+        },
+    });
+}
+export function useUpdateRuntimeSession() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ sessionId, title, archived, }) => {
+            const client = getClient();
+            const body = {};
+            if (title !== undefined)
+                body.title = title;
+            if (archived !== undefined)
+                body.time = { archived: archived ? Date.now() : 0 };
+            const result = await client.session.update({
+                sessionID: sessionId,
+                ...body,
+            });
+            return unwrap(result);
+        },
+        onSuccess: (updatedSession) => {
+            const session = updatedSession;
+            queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                if (!old)
+                    return old;
+                const idx = old.findIndex((s) => s.id === session.id);
+                if (idx < 0)
+                    return old;
+                const next = [...old];
+                next[idx] = session;
+                return next.sort((a, b) => b.time.updated - a.time.updated);
+            });
+            queryClient.setQueryData(runtimeKeys.runtimeSession(session.id), session);
+        },
+    });
+}
+export function useForkSession() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ sessionId, messageID }) => {
+            const client = getClient();
+            const result = await client.session.fork({
+                sessionID: sessionId,
+                ...(messageID !== undefined && { messageID }),
+            });
+            return unwrap(result);
+        },
+        onSuccess: (forkedSession) => {
+            const session = forkedSession;
+            queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                if (!old)
+                    return [session];
+                const idx = old.findIndex((s) => s.id === session.id);
+                if (idx >= 0) {
+                    const next = [...old];
+                    next[idx] = session;
+                    return next.sort((a, b) => b.time.updated - a.time.updated);
+                }
+                return [session, ...old].sort((a, b) => b.time.updated - a.time.updated);
+            });
+            queryClient.setQueryData(runtimeKeys.runtimeSession(session.id), session);
+        },
+    });
+}
+export function useRuntimeSessionDiff(sessionId) {
+    const runtimeReady = useRuntimeReady();
+    const canQuerySession = canQueryRuntimeSession(sessionId);
+    return useQuery({
+        queryKey: ['opencode', 'session-diff', sessionId],
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.session.diff({ sessionID: sessionId });
+            return unwrap(result);
+        },
+        enabled: runtimeReady && canQuerySession,
+        staleTime: Infinity,
+    });
+}
+export function useRuntimeSessionTodo(sessionId) {
+    const runtimeReady = useRuntimeReady();
+    const canQuerySession = canQueryRuntimeSession(sessionId);
+    const supported = useRuntimeSupports('session.todo');
+    return useQuery({
+        queryKey: runtimeKeys.sessionTodo(sessionId),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.session.todo({ sessionID: sessionId });
+            const data = unwrap(result);
+            return Array.isArray(data) ? data : [];
+        },
+        enabled: runtimeReady && canQuerySession && supported,
+        staleTime: Infinity,
+    });
+}
+export function useSummarizeRuntimeSession() {
+    const startCompaction = useOpenCodeCompactionStore((s) => s.startCompaction);
+    const stopCompaction = useOpenCodeCompactionStore((s) => s.stopCompaction);
+    return useMutation({
+        mutationFn: async (params) => {
+            const client = getClient();
+            let { providerID, modelID } = params;
+            if (!providerID || !modelID) {
+                try {
+                    const configResult = await client.global.config.get();
+                    const config = configResult.data;
+                    if (config?.model) {
+                        const parts = config.model.split('/');
+                        if (parts.length >= 2) {
+                            providerID = providerID || parts[0];
+                            modelID = modelID || parts.slice(1).join('/');
+                        }
+                    }
+                }
+                catch {
+                }
+            }
+            if (!providerID || !modelID) {
+                try {
+                    const msgs = await client.session.messages({
+                        sessionID: params.sessionId,
+                        limit: SESSION_SYNC_PAGE_SIZE,
+                    });
+                    const allMsgs = (msgs.data ?? []);
+                    for (let i = allMsgs.length - 1; i >= 0; i--) {
+                        const m = allMsgs[i].info;
+                        if (m.role === 'assistant' && m.providerID && m.modelID) {
+                            providerID = providerID || m.providerID;
+                            modelID = modelID || m.modelID;
+                            break;
+                        }
+                    }
+                }
+                catch {
+                }
+            }
+            if (!providerID || !modelID) {
+                try {
+                    const providerResult = await client.provider.list();
+                    const providers = providerResult.data;
+                    if (providers && typeof providers === 'object') {
+                        for (const [pid, providerInfo] of Object.entries(providers)) {
+                            const models = providerInfo && typeof providerInfo === 'object'
+                                ? providerInfo.models
+                                : undefined;
+                            if (models && typeof models === 'object') {
+                                const firstModelId = Object.keys(models)[0];
+                                if (firstModelId) {
+                                    providerID = pid;
+                                    modelID = firstModelId;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                }
+            }
+            if (!providerID || !modelID) {
+                throw new NoCompactionModelError();
+            }
+            const result = await client.session.summarize({
+                sessionID: params.sessionId,
+                providerID,
+                modelID,
+            });
+            unwrap(result);
+            return params.sessionId;
+        },
+        onMutate: ({ sessionId }) => {
+            startCompaction(sessionId);
+        },
+        onError: (_err, { sessionId }) => {
+            stopCompaction(sessionId);
+        },
+        onSuccess: (_sessionId) => {
+        },
+    });
+}
+export function useInitSession() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ sessionId }) => {
+            const client = getClient();
+            const result = await client.session.command({
+                sessionID: sessionId,
+                command: 'init',
+                arguments: '',
+            });
+            if (result.error) {
+                const err = result.error;
+                const errRec = err && typeof err === 'object' ? err : undefined;
+                const dataRec = errRec?.data && typeof errRec.data === 'object'
+                    ? errRec.data
+                    : undefined;
+                const message = dataRec?.message ?? errRec?.message;
+                throw new Error(typeof message === 'string' ? message : 'Failed to initialize project');
+            }
+            return sessionId;
+        },
+        onSuccess: (sessionId) => {
+            queryClient.refetchQueries({
+                queryKey: runtimeKeys.runtimeMessages(sessionId),
+            });
+        },
+        onError: () => { },
+        retry: false,
+    });
+}
+export const useOpenCodeSessions = useRuntimeSessions;
+export const useOpenCodeSession = useRuntimeSession;
+export const useCreateOpenCodeSession = useCreateRuntimeSession;
+export const useUpdateOpenCodeSession = useUpdateRuntimeSession;
+export const useOpenCodeSessionDiff = useRuntimeSessionDiff;
+export const useOpenCodeSessionTodo = useRuntimeSessionTodo;
+export const useSummarizeOpenCodeSession = useSummarizeRuntimeSession;

package/dist/react/use-opencode-sessions/shared.d.ts

@@ -0,0 +1,10 @@
+export declare function activeServerKey(): string;
+export declare function unwrap<T>(result: {
+    data?: T;
+    error?: unknown;
+    response?: Response;
+}): T;
+export declare function asRuntimeList<T>(value: unknown): T[];
+export declare function canQueryRuntimeSession(sessionId: string | null | undefined): sessionId is string;
+export declare function clearProjectProviderCache(_projectId: string): void;
+export declare const canQueryOpenCodeSession: typeof canQueryRuntimeSession;

package/dist/react/use-opencode-sessions/shared.js

@@ -0,0 +1,36 @@
+import { getCurrentRuntimeSandboxId } from '../../core/session/current-runtime.js';
+export function activeServerKey() {
+    try {
+        return getCurrentRuntimeSandboxId() ?? 'none';
+    }
+    catch {
+        return 'none';
+    }
+}
+export function unwrap(result) {
+    if (result.error) {
+        const err = result.error;
+        const status = result.response?.status;
+        const errRec = err && typeof err === 'object' ? err : undefined;
+        const dataRec = errRec?.data && typeof errRec.data === 'object'
+            ? errRec.data
+            : undefined;
+        const msg = dataRec?.message ||
+            errRec?.message ||
+            errRec?.error ||
+            (typeof err === 'string' ? err : null) ||
+            (typeof err === 'object' ? JSON.stringify(err) : null) ||
+            (status ? `Server returned ${status}` : 'SDK request failed');
+        throw status ? Object.assign(new Error(String(msg)), { status }) : new Error(String(msg));
+    }
+    return result.data;
+}
+export function asRuntimeList(value) {
+    return Array.isArray(value) ? value : [];
+}
+const PROJECT_SESSION_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function canQueryRuntimeSession(sessionId) {
+    return !!sessionId && !PROJECT_SESSION_UUID_RE.test(sessionId);
+}
+export function clearProjectProviderCache(_projectId) { }
+export const canQueryOpenCodeSession = canQueryRuntimeSession;

package/dist/react/use-opencode-sessions/sharing.d.ts

@@ -0,0 +1,3 @@
+import type { Session } from '../../core/runtime/runtime-types.js';
+export declare function useShareSession(): import("@tanstack/react-query").UseMutationResult<Session, Error, string, unknown>;
+export declare function useUnshareSession(): import("@tanstack/react-query").UseMutationResult<Session, Error, string, unknown>;

package/dist/react/use-opencode-sessions/sharing.js

@@ -0,0 +1,51 @@
+'use client';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { runtimeKeys } from './keys.js';
+import { unwrap } from './shared.js';
+export function useShareSession() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (sessionId) => {
+            const client = getClient();
+            const result = await client.session.share({ sessionID: sessionId });
+            return unwrap(result);
+        },
+        onSuccess: (updatedSession) => {
+            queryClient.setQueryData(runtimeKeys.runtimeSession(updatedSession.id), updatedSession);
+            queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                if (!old)
+                    return old;
+                const idx = old.findIndex((s) => s.id === updatedSession.id);
+                if (idx < 0)
+                    return old;
+                const next = [...old];
+                next[idx] = updatedSession;
+                return next;
+            });
+        },
+    });
+}
+export function useUnshareSession() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (sessionId) => {
+            const client = getClient();
+            const result = await client.session.unshare({ sessionID: sessionId });
+            return unwrap(result);
+        },
+        onSuccess: (updatedSession) => {
+            queryClient.setQueryData(runtimeKeys.runtimeSession(updatedSession.id), updatedSession);
+            queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                if (!old)
+                    return old;
+                const idx = old.findIndex((s) => s.id === updatedSession.id);
+                if (idx < 0)
+                    return old;
+                const next = [...old];
+                next[idx] = updatedSession;
+                return next;
+            });
+        },
+    });
+}

package/dist/react/use-opencode-sessions/tools.d.ts

@@ -0,0 +1,5 @@
+import type { Skill, ToolListItem } from './keys.js';
+export declare function useOpenCodeToolIds(): import("@tanstack/react-query").UseQueryResult<string[], Error>;
+export declare function useRuntimeTools(providerID: string, modelID: string): import("@tanstack/react-query").UseQueryResult<ToolListItem[], Error>;
+export declare function useOpenCodeSkills(): import("@tanstack/react-query").UseQueryResult<Skill[], Error>;
+export declare const useOpenCodeTools: typeof useRuntimeTools;

package/dist/react/use-opencode-sessions/tools.js

@@ -0,0 +1,48 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { runtimeKeys, useRuntimeReady } from './keys.js';
+import { unwrap } from './shared.js';
+export function useOpenCodeToolIds() {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: runtimeKeys.toolIds(),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.tool.ids();
+            return unwrap(result);
+        },
+        enabled: runtimeReady,
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+    });
+}
+export function useRuntimeTools(providerID, modelID) {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: runtimeKeys.tools(providerID, modelID),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.tool.list({ provider: providerID, model: modelID });
+            return unwrap(result);
+        },
+        enabled: runtimeReady && !!providerID && !!modelID,
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+    });
+}
+export function useOpenCodeSkills() {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: runtimeKeys.skills(),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.app.skills();
+            return unwrap(result);
+        },
+        enabled: runtimeReady,
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+    });
+}
+export const useOpenCodeTools = useRuntimeTools;

package/dist/react/use-opencode-sessions/vcs.d.ts

@@ -0,0 +1,7 @@
+import type { VcsFileDiff } from '../../core/runtime/runtime-types.js';
+export type { VcsFileDiff };
+export type VcsDiffMode = 'git' | 'branch';
+export declare function useRuntimeVcsDiff(mode?: VcsDiffMode, options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<VcsFileDiff[], Error>;
+export declare const useOpenCodeVcsDiff: typeof useRuntimeVcsDiff;

package/dist/react/use-opencode-sessions/vcs.js

@@ -0,0 +1,24 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { useCurrentRuntime } from '../use-current-runtime.js';
+import { runtimeKeys, useRuntimeReady } from './keys.js';
+import { unwrap } from './shared.js';
+export function useRuntimeVcsDiff(mode = 'branch', options) {
+    const runtimeReady = useRuntimeReady();
+    const serverId = useCurrentRuntime((s) => s.sandboxId) ?? undefined;
+    return useQuery({
+        queryKey: runtimeKeys.vcsDiff(mode, serverId),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.vcs.diff({ mode });
+            const data = unwrap(result);
+            return Array.isArray(data) ? data : [];
+        },
+        enabled: runtimeReady && options?.enabled !== false,
+        staleTime: 30_000,
+        gcTime: 5 * 60_000,
+        refetchOnWindowFocus: false,
+    });
+}
+export const useOpenCodeVcsDiff = useRuntimeVcsDiff;