@beeuni/sdk 0.1.0

package/dist/react/use-opencode-events/stream-revival.js

@@ -0,0 +1,60 @@
+import { onHostSignal } from '../../core/session/host-signals.js';
+const DEFAULT_REVIVE_AFTER_MS = 30_000;
+function defaultListen(event, handler) {
+    const hostSignal = event === 'visibilitychange' ? 'visible' : event;
+    const stopHost = onHostSignal((signal) => {
+        if (signal === hostSignal)
+            handler();
+    });
+    if (typeof globalThis.addEventListener !== 'function')
+        return stopHost;
+    const target = event === 'visibilitychange' && typeof document !== 'undefined' ? document : globalThis;
+    const wrapped = () => {
+        if (event === 'visibilitychange' && typeof document !== 'undefined') {
+            if (document.visibilityState !== 'visible')
+                return;
+        }
+        handler();
+    };
+    target.addEventListener(event, wrapped);
+    return () => {
+        stopHost();
+        target.removeEventListener(event, wrapped);
+    };
+}
+export function createStreamRevival(revive, options = {}) {
+    const reviveAfterMs = options.reviveAfterMs ?? DEFAULT_REVIVE_AFTER_MS;
+    const setTimer = options.setTimeout ?? ((handler, ms) => setTimeout(handler, ms));
+    const clearTimer = options.clearTimeout ?? ((handle) => clearTimeout(handle));
+    const listen = options.listen ?? defaultListen;
+    let armed = false;
+    let timer;
+    let unsubscribers = [];
+    const disarm = () => {
+        if (!armed)
+            return;
+        armed = false;
+        if (timer !== undefined)
+            clearTimer(timer);
+        timer = undefined;
+        for (const unsubscribe of unsubscribers)
+            unsubscribe();
+        unsubscribers = [];
+    };
+    const fire = () => {
+        if (!armed)
+            return;
+        disarm();
+        revive();
+    };
+    return {
+        park: () => {
+            if (armed)
+                return;
+            armed = true;
+            timer = setTimer(fire, reviveAfterMs);
+            unsubscribers = [listen('visibilitychange', fire), listen('online', fire)];
+        },
+        stop: disarm,
+    };
+}

package/dist/react/use-opencode-events/types.d.ts

@@ -0,0 +1,2 @@
+export type { OpenCodeEvent, RuntimeEvent } from '../../core/stream/event-stream.js';
+export type NormalizeDiagnosticPaths = <T>(diagsByFile: Record<string, T[]>) => Record<string, T[]>;

package/dist/react/use-opencode-events/types.js

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

package/dist/react/use-opencode-events/use-event-stream-refs.d.ts

@@ -0,0 +1,16 @@
+import { type QueryClient } from '@tanstack/react-query';
+import type { Event as OpenCodeSdkEvent } from '../../core/runtime/runtime-types.js';
+import { type SessionStatus } from '../use-opencode-sessions/index.js';
+import type { NormalizeDiagnosticPaths } from './types.js';
+export declare function useEventStreamRefs(deps: {
+    queryClient: QueryClient;
+    stopCompaction: (sessionID: string) => void;
+    applySyncEvent: (event: OpenCodeSdkEvent) => void;
+}): {
+    normalizeLspPath: import("react").RefObject<(absPath: string) => string>;
+    normalizeDiagnosticPaths: import("react").RefObject<NormalizeDiagnosticPaths>;
+    fetchLspDiagnosticsDebounced: import("react").RefObject<() => void>;
+    markSessionAbortedLocally: import("react").RefObject<(sessionID: string, message?: string) => void>;
+    markSessionIdleLocally: import("react").RefObject<(sessionID: string) => void>;
+    reconcileMissingBusySessions: import("react").RefObject<(nextStatuses: Record<string, SessionStatus>) => void>;
+};

package/dist/react/use-opencode-events/use-event-stream-refs.js

@@ -0,0 +1,129 @@
+'use client';
+import { useRef } from 'react';
+import { authenticatedFetch } from '../../core/http/auth.js';
+import { useDiagnosticsStore } from '../../browser/stores/diagnostics-store.js';
+import { getActiveRuntimeUrl } from '../../browser/stores/server-store.js';
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import { runtimeKeys } from '../use-opencode-sessions/index.js';
+import { qk } from '../query-keys.js';
+const [KEY_ROOT, PROJECT_SEGMENT] = qk.project.scope('');
+const TURN_SEGMENT = qk.project.sessionTurn('', '').at(-1);
+const PROMPTS_SEGMENT = qk.project.sessionPrompts('', '').at(-1);
+function isSessionTruthQuery(query) {
+    const key = query.queryKey;
+    const tail = key[key.length - 1];
+    return (key[0] === KEY_ROOT &&
+        key[1] === PROJECT_SEGMENT &&
+        (tail === TURN_SEGMENT || tail === PROMPTS_SEGMENT));
+}
+export function useEventStreamRefs(deps) {
+    const { queryClient, stopCompaction, applySyncEvent } = deps;
+    const normalizeLspPath = useRef((absPath) => {
+        if (!absPath || !absPath.startsWith('/'))
+            return absPath;
+        const prefixes = [];
+        try {
+            const project = queryClient.getQueryData(runtimeKeys.currentProject());
+            if (project?.worktree)
+                prefixes.push(project.worktree);
+            const pathInfo = queryClient.getQueryData(runtimeKeys.pathInfo());
+            if (pathInfo?.directory)
+                prefixes.push(pathInfo.directory);
+            if (pathInfo?.worktree)
+                prefixes.push(pathInfo.worktree);
+        }
+        catch {
+        }
+        const unique = [...new Set(prefixes.filter(Boolean))].sort((a, b) => b.length - a.length);
+        for (const wt of unique) {
+            if (!wt || wt === '/')
+                continue;
+            const prefix = wt.endsWith('/') ? wt : wt + '/';
+            if (absPath.startsWith(prefix)) {
+                return absPath.slice(prefix.length);
+            }
+        }
+        return absPath;
+    });
+    const normalizeDiagnosticPaths = useRef(function normalizeDiagnosticPaths(diagsByFile) {
+        const normalized = {};
+        for (const [file, diags] of Object.entries(diagsByFile)) {
+            const relPath = normalizeLspPath.current(file);
+            normalized[relPath] = diags;
+        }
+        return normalized;
+    });
+    const fetchLspDiagnosticsDebounced = useRef((() => {
+        let timer = null;
+        return () => {
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(async () => {
+                timer = null;
+                try {
+                    const baseUrl = getActiveRuntimeUrl();
+                    const resp = await authenticatedFetch(`${baseUrl}/lsp/diagnostics`);
+                    if (!resp.ok)
+                        return;
+                    const data = (await resp.json());
+                    if (data && typeof data === 'object') {
+                        const normalized = normalizeDiagnosticPaths.current(data);
+                        const store = useDiagnosticsStore.getState();
+                        store.clearAll();
+                        store.setFromLspEvent(normalized);
+                    }
+                }
+                catch {
+                }
+            }, 250);
+        };
+    })());
+    const markSessionAbortedLocally = useRef((sessionID, message = 'The operation was aborted because the runtime shut down.') => {
+        if (!sessionID)
+            return;
+        const error = {
+            name: 'AbortError',
+            data: { message, reason: 'runtime-disposed' },
+        };
+        stopCompaction(sessionID);
+        applySyncEvent({
+            type: 'session.error',
+            synthetic: true,
+            properties: { sessionID, error },
+        });
+        if (!useSyncStore.getState().hasOptimisticMessages(sessionID)) {
+            useSyncStore.getState().clearOptimisticMessages(sessionID);
+        }
+        void queryClient.invalidateQueries({ predicate: isSessionTruthQuery });
+    });
+    const markSessionIdleLocally = useRef((sessionID) => {
+        if (!sessionID)
+            return;
+        stopCompaction(sessionID);
+        applySyncEvent({
+            type: 'session.idle',
+            synthetic: true,
+            properties: { sessionID },
+        });
+        useSyncStore.getState().setStatus(sessionID, { type: 'idle' }, 'local');
+        useSyncStore.getState().clearOptimisticMessages(sessionID);
+    });
+    const reconcileMissingBusySessions = useRef((nextStatuses) => {
+        const previousStatuses = useSyncStore.getState().sessionStatus;
+        for (const [sessionID, status] of Object.entries(previousStatuses)) {
+            if (status?.type !== 'idle' && !nextStatuses[sessionID]) {
+                if (useSyncStore.getState().hasOptimisticMessages(sessionID))
+                    continue;
+                markSessionIdleLocally.current(sessionID);
+            }
+        }
+    });
+    return {
+        normalizeLspPath,
+        normalizeDiagnosticPaths,
+        fetchLspDiagnosticsDebounced,
+        markSessionAbortedLocally,
+        markSessionIdleLocally,
+        reconcileMissingBusySessions,
+    };
+}

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

@@ -0,0 +1,72 @@
+import { type FlatModel } from './model-flatten.js';
+import type { Agent, Config, ProviderListResponse } from '../core/runtime/runtime-types.js';
+import { type ModelKey } from './use-model-store.js';
+export type { ModelKey };
+export interface UseRuntimeLocalOptions {
+    agents?: Agent[];
+    providers?: ProviderListResponse;
+    config?: Config;
+    sessionId?: string;
+    boundAgentName?: string | null;
+    defaultAgentName?: string | null;
+    freeTier?: boolean;
+    resolveServerDefault?: (agentName: string | undefined) => ModelKey | undefined;
+}
+export interface RuntimeLocalAgent {
+    current: Agent | undefined;
+    list: Agent[];
+    set: (name: string | undefined) => void;
+    move: (direction: 1 | -1) => void;
+}
+export interface RuntimeLocalModel {
+    current: FlatModel | undefined;
+    currentKey: ModelKey | undefined;
+    sendKey: ModelKey | undefined;
+    onDefault: boolean;
+    recent: FlatModel[];
+    list: FlatModel[];
+    set: (model: ModelKey | undefined, options?: {
+        recent?: boolean;
+        autoSeed?: boolean;
+    }) => void;
+    visible: (model: ModelKey) => boolean;
+    setVisibility: (model: ModelKey, visible: boolean) => void;
+    cycle: (direction: 1 | -1) => void;
+    hasSessionModel: boolean;
+    variant: {
+        current: string | undefined;
+        list: string[];
+        set: (value: string | undefined) => void;
+        cycle: () => void;
+    };
+}
+export interface RuntimeLocal {
+    agent: RuntimeLocalAgent;
+    model: RuntimeLocalModel;
+}
+export declare function parseModelKey(model: unknown): ModelKey | undefined;
+export declare function formatModelString(model: ModelKey): string;
+export declare function formatPromptModel(model: ModelKey): ModelKey;
+export declare function resolvePromptModel(explicit: ModelKey | undefined, current: ModelKey | undefined): ModelKey | undefined;
+export declare function resolveHiddenAutoModel(resolved: ModelKey | undefined, _options: {
+    enableAutoModel: boolean;
+    isModelValid: (model: ModelKey) => boolean;
+}): ModelKey | undefined;
+export type ModelProviderMode = 'native' | 'gateway';
+export declare function modelProviderMode(providers: ProviderListResponse | undefined): ModelProviderMode;
+export declare function scopedModelSelectionKey(key: string | undefined, mode: ModelProviderMode): string | undefined;
+export declare function agentScopedModelSelectionKey(mode: ModelProviderMode, agentName: string | undefined): string;
+export declare function resolveCurrentAgentName(input: {
+    sessionId?: string;
+    sessionAgentName?: string;
+    boundAgentName?: string | null;
+    defaultAgentName?: string | null;
+    explicitAgentName?: string;
+    lastAgentName?: string;
+}): string | undefined;
+export declare function useRuntimeLocal({ agents: rawAgents, providers, config, sessionId, boundAgentName, defaultAgentName, resolveServerDefault, }: UseRuntimeLocalOptions): RuntimeLocal;
+export type UseOpenCodeLocalOptions = UseRuntimeLocalOptions;
+export type OpenCodeLocalAgent = RuntimeLocalAgent;
+export type OpenCodeLocalModel = RuntimeLocalModel;
+export type OpenCodeLocal = RuntimeLocal;
+export declare const useOpenCodeLocal: typeof useRuntimeLocal;

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

@@ -0,0 +1,306 @@
+'use client';
+import { flattenModels, isOfferedModel } from './model-flatten.js';
+import { composerSelectableAgents } from '../core/agents/composer-agents.js';
+import { resolveComposerModel } from '../core/models/composer-model.js';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { createAgentSelectionScope } from './agent-selection-scope.js';
+import { useBeeuniRouteProjectId } from './route-project.js';
+import { healBedrockModelKey } from './bedrock-invokable.js';
+import { normalizeProviderList } from './provider-selection.js';
+import { useModelStore } from './use-model-store.js';
+export function parseModelKey(model) {
+    if (!model)
+        return undefined;
+    if (typeof model === 'object' && model !== null) {
+        const obj = model;
+        if (typeof obj.providerID === 'string' && typeof obj.modelID === 'string') {
+            return { providerID: obj.providerID, modelID: obj.modelID };
+        }
+    }
+    if (typeof model === 'string') {
+        const idx = model.indexOf('/');
+        if (idx > 0 && idx < model.length - 1) {
+            return { providerID: model.slice(0, idx), modelID: model.slice(idx + 1) };
+        }
+    }
+    return undefined;
+}
+export function formatModelString(model) {
+    if (model.providerID === 'opencode')
+        return model.modelID;
+    return `${model.providerID}/${model.modelID}`;
+}
+export function formatPromptModel(model) {
+    return model;
+}
+function isRemovedAutoModel(model) {
+    return model?.modelID === 'auto' || model?.modelID === 'beeuni/auto';
+}
+export function resolvePromptModel(explicit, current) {
+    if (explicit && !isRemovedAutoModel(explicit))
+        return explicit;
+    return current && !isRemovedAutoModel(current) ? current : undefined;
+}
+export function resolveHiddenAutoModel(resolved, _options) {
+    return resolvePromptModel(resolved, undefined);
+}
+export function modelProviderMode(providers) {
+    if (!providers)
+        return 'native';
+    const normalized = normalizeProviderList(providers);
+    return normalized.connected?.includes('beeuni') ? 'gateway' : 'native';
+}
+export function scopedModelSelectionKey(key, mode) {
+    return key ? `${mode}:${key}` : undefined;
+}
+export function agentScopedModelSelectionKey(mode, agentName) {
+    return `${mode}:${agentName ?? ''}`;
+}
+export function resolveCurrentAgentName(input) {
+    const boundAgentName = input.boundAgentName?.trim() || undefined;
+    const defaultAgentName = input.defaultAgentName?.trim() || undefined;
+    return (input.explicitAgentName ??
+        input.sessionAgentName ??
+        boundAgentName ??
+        defaultAgentName ??
+        (input.sessionId ? undefined : input.lastAgentName));
+}
+export function useRuntimeLocal({ agents: rawAgents, providers, config, sessionId, boundAgentName, defaultAgentName, resolveServerDefault, }) {
+    const providerMode = useMemo(() => modelProviderMode(providers), [providers]);
+    const flatModels = useMemo(() => flattenModels(providers, { providerMode }), [providers, providerMode]);
+    const projectId = useBeeuniRouteProjectId();
+    const modelStore = useModelStore(flatModels);
+    const isModelValid = useCallback((model) => isOfferedModel(flatModels, model), [flatModels]);
+    const findModel = useCallback((key) => flatModels.find((m) => m.modelID === key.modelID && m.providerID === key.providerID), [flatModels]);
+    const visibleAgents = useMemo(() => composerSelectableAgents(rawAgents, { includeSubagents: true }), [rawAgents]);
+    const sessionAgentName = sessionId ? modelStore.getSessionAgentName(sessionId) : undefined;
+    const agentSelectionScope = createAgentSelectionScope({
+        sessionId,
+        boundAgentName,
+        projectId,
+    });
+    const [explicitAgentSelection, setExplicitAgentSelection] = useState({ scope: '', name: undefined });
+    const explicitAgentName = explicitAgentSelection.scope === agentSelectionScope
+        ? explicitAgentSelection.name
+        : undefined;
+    const currentAgentName = resolveCurrentAgentName({
+        sessionId,
+        sessionAgentName,
+        boundAgentName,
+        defaultAgentName,
+        explicitAgentName,
+        lastAgentName: modelStore.lastAgentName,
+    });
+    const scopedSessionModelKey = useMemo(() => scopedModelSelectionKey(sessionId, providerMode), [sessionId, providerMode]);
+    const setCurrentAgentName = useCallback((name) => {
+        if (sessionId) {
+            modelStore.setSessionAgentName(sessionId, name);
+        }
+        else {
+            setExplicitAgentSelection({ scope: agentSelectionScope, name });
+        }
+        if (name !== undefined || !sessionId) {
+            modelStore.setLastAgentName(name);
+        }
+    }, [
+        sessionId,
+        agentSelectionScope,
+        modelStore.setSessionAgentName,
+        modelStore.setLastAgentName,
+    ]);
+    const currentAgent = useMemo(() => {
+        if (visibleAgents.length === 0)
+            return undefined;
+        if (currentAgentName) {
+            const found = visibleAgents.find((a) => a.name === currentAgentName);
+            if (found)
+                return found;
+        }
+        return visibleAgents[0];
+    }, [visibleAgents, currentAgentName]);
+    const agentModelSlotKey = useMemo(() => agentScopedModelSelectionKey(providerMode, currentAgent?.name), [providerMode, currentAgent?.name]);
+    const modelResolution = useMemo(() => resolveComposerModel({
+        models: flatModels,
+        picks: [
+            scopedSessionModelKey ? modelStore.getSessionModel(scopedSessionModelKey) : undefined,
+            sessionId ? modelStore.getSessionModel(sessionId) : undefined,
+            modelStore.getSelectedModel(agentModelSlotKey),
+            currentAgent ? modelStore.getSelectedModel(currentAgent.name) : undefined,
+        ],
+        serverDefault: resolveServerDefault?.(currentAgent?.name),
+        globalDefault: modelStore.globalDefault,
+        agentModel: currentAgent?.model,
+        configModel: config?.model,
+        recent: modelStore.recent,
+        providers,
+    }), [
+        flatModels,
+        scopedSessionModelKey,
+        sessionId,
+        agentModelSlotKey,
+        currentAgent,
+        resolveServerDefault,
+        config?.model,
+        providers,
+        modelStore,
+    ]);
+    const fallbackModel = modelResolution.fallback;
+    const explicitModelKey = modelResolution.explicit;
+    const currentModelKey = modelResolution.model;
+    const onDefaultModel = !explicitModelKey;
+    const sendModelKey = useMemo(() => healBedrockModelKey(resolvePromptModel(explicitModelKey, currentModelKey), flatModels), [explicitModelKey, currentModelKey, flatModels]);
+    const currentModel = useMemo(() => (currentModelKey ? findModel(currentModelKey) : undefined), [currentModelKey, findModel]);
+    const recentModels = useMemo(() => modelStore.recent.map(findModel).filter(Boolean), [modelStore.recent, findModel]);
+    const setModel = useCallback((model, options) => {
+        if (options?.autoSeed && modelStore.globalDefault && isModelValid(modelStore.globalDefault)) {
+            return;
+        }
+        const next = model ?? fallbackModel;
+        if (next) {
+            modelStore.setSelectedModel(agentModelSlotKey, next);
+        }
+        if (scopedSessionModelKey && next) {
+            modelStore.setSessionModel(scopedSessionModelKey, next);
+        }
+        if (options?.recent && model) {
+            modelStore.pushRecent(model);
+        }
+    }, [agentModelSlotKey, scopedSessionModelKey, fallbackModel, modelStore, isModelValid]);
+    const setAgent = useCallback((name) => {
+        if (visibleAgents.length === 0) {
+            setCurrentAgentName(undefined);
+            return;
+        }
+        if (name && visibleAgents.some((a) => a.name === name)) {
+            setCurrentAgentName(name);
+            return;
+        }
+        setCurrentAgentName(visibleAgents[0]?.name);
+    }, [visibleAgents, setCurrentAgentName]);
+    const setModelRef = useRef(setModel);
+    setModelRef.current = setModel;
+    const moveAgent = useCallback((direction) => {
+        if (visibleAgents.length === 0) {
+            setCurrentAgentName(undefined);
+            return;
+        }
+        const currentIdx = visibleAgents.findIndex((a) => a.name === currentAgentName);
+        let next = (currentIdx === -1 ? 0 : currentIdx) + direction;
+        if (next < 0)
+            next = visibleAgents.length - 1;
+        if (next >= visibleAgents.length)
+            next = 0;
+        const value = visibleAgents[next];
+        if (!value)
+            return;
+        setCurrentAgentName(value.name);
+        if (value.model) {
+            setModelRef.current({
+                providerID: value.model.providerID,
+                modelID: value.model.modelID,
+            });
+        }
+    }, [visibleAgents, currentAgentName, setCurrentAgentName]);
+    const prevAgentRef = useRef(undefined);
+    useEffect(() => {
+        if (!currentAgent)
+            return;
+        if (prevAgentRef.current === currentAgent.name)
+            return;
+        prevAgentRef.current = currentAgent.name;
+        const persisted = modelStore.getSelectedModel(currentAgent.name);
+        if (persisted && isModelValid(persisted))
+            return;
+        if (modelStore.globalDefault && isModelValid(modelStore.globalDefault))
+            return;
+        if (currentAgent.model) {
+            if (isModelValid(currentAgent.model)) {
+                setModel({
+                    providerID: currentAgent.model.providerID,
+                    modelID: currentAgent.model.modelID,
+                }, { autoSeed: true });
+            }
+        }
+    }, [currentAgent?.name, isModelValid]);
+    const cycleModel = useCallback((direction) => {
+        if (!currentModel || recentModels.length === 0)
+            return;
+        const index = recentModels.findIndex((x) => x.providerID === currentModel.providerID && x.modelID === currentModel.modelID);
+        if (index === -1)
+            return;
+        let next = index + direction;
+        if (next < 0)
+            next = recentModels.length - 1;
+        if (next >= recentModels.length)
+            next = 0;
+        const val = recentModels[next];
+        if (!val)
+            return;
+        setModel({ providerID: val.providerID, modelID: val.modelID });
+    }, [currentModel, recentModels, setModel]);
+    const variantCurrent = useMemo(() => {
+        if (!currentModel)
+            return undefined;
+        return modelStore.getVariant({
+            providerID: currentModel.providerID,
+            modelID: currentModel.modelID,
+        });
+    }, [currentModel, modelStore]);
+    const variantList = useMemo(() => {
+        if (!currentModel?.variants)
+            return [];
+        return Object.keys(currentModel.variants);
+    }, [currentModel]);
+    const setVariant = useCallback((value) => {
+        if (!currentModel)
+            return;
+        modelStore.setVariant({ providerID: currentModel.providerID, modelID: currentModel.modelID }, value);
+    }, [currentModel, modelStore]);
+    const cycleVariant = useCallback(() => {
+        if (variantList.length === 0)
+            return;
+        if (!variantCurrent) {
+            setVariant(variantList[0]);
+            return;
+        }
+        const index = variantList.indexOf(variantCurrent);
+        if (index === -1 || index === variantList.length - 1) {
+            setVariant(undefined);
+            return;
+        }
+        setVariant(variantList[index + 1]);
+    }, [variantList, variantCurrent, setVariant]);
+    const hasSessionModel = useMemo(() => {
+        if (!scopedSessionModelKey)
+            return false;
+        return !!modelStore.getSessionModel(scopedSessionModelKey);
+    }, [scopedSessionModelKey, modelStore]);
+    return {
+        agent: {
+            current: currentAgent,
+            list: visibleAgents,
+            set: setAgent,
+            move: moveAgent,
+        },
+        model: {
+            current: currentModel,
+            currentKey: currentModelKey,
+            sendKey: sendModelKey,
+            onDefault: onDefaultModel,
+            recent: recentModels,
+            list: flatModels,
+            set: setModel,
+            visible: isModelValid,
+            setVisibility: modelStore.setVisibility,
+            cycle: cycleModel,
+            hasSessionModel,
+            variant: {
+                current: variantCurrent,
+                list: variantList,
+                set: setVariant,
+                cycle: cycleVariant,
+            },
+        },
+    };
+}
+export const useOpenCodeLocal = useRuntimeLocal;

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

@@ -0,0 +1,29 @@
+import { useOpenCodeMcpStatus } from './use-opencode-sessions/index.js';
+import type { McpStatus } from './use-opencode-sessions/index.js';
+export { useOpenCodeMcpStatus };
+export type { McpStatus };
+export interface AddMcpServerParams {
+    name: string;
+    type: 'local' | 'remote';
+    command?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+}
+export declare function useAddMcpServer(): import("@tanstack/react-query").UseMutationResult<Record<string, McpStatus>, Error, AddMcpServerParams, unknown>;
+export declare function useConnectMcpServer(): import("@tanstack/react-query").UseMutationResult<boolean, Error, string, {
+    prev: Record<string, McpStatus> | undefined;
+}>;
+export declare function useDisconnectMcpServer(): import("@tanstack/react-query").UseMutationResult<boolean, Error, string, {
+    prev: Record<string, McpStatus> | undefined;
+}>;
+export declare function useMcpAuthStart(): import("@tanstack/react-query").UseMutationResult<{
+    authorizationUrl: string;
+}, Error, string, unknown>;
+export declare function useMcpAuthCallback(): import("@tanstack/react-query").UseMutationResult<McpStatus, Error, {
+    name: string;
+    code: string;
+}, unknown>;
+export declare function useMcpAuthRemove(): import("@tanstack/react-query").UseMutationResult<{
+    success: true;
+}, Error, string, unknown>;