@beeuni/sdk 0.1.0

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

@@ -0,0 +1,149 @@
+'use client';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { getClient } from '../core/runtime/client.js';
+import { runtimeKeys, useOpenCodeMcpStatus } from './use-opencode-sessions/index.js';
+export { useOpenCodeMcpStatus };
+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 new Error(String(msg));
+    }
+    return result.data;
+}
+export function useAddMcpServer() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const client = getClient();
+            const config = params.type === 'local'
+                ? {
+                    type: 'local',
+                    command: params.command ?? [],
+                    ...(params.env && Object.keys(params.env).length > 0
+                        ? { environment: params.env }
+                        : {}),
+                }
+                : {
+                    type: 'remote',
+                    url: params.url ?? '',
+                    ...(params.headers && Object.keys(params.headers).length > 0
+                        ? { headers: params.headers }
+                        : {}),
+                };
+            const result = await client.mcp.add({
+                name: params.name,
+                config,
+            });
+            return unwrap(result);
+        },
+        onSuccess: (data) => {
+            queryClient.setQueryData(runtimeKeys.mcpStatus(), data);
+            queryClient.refetchQueries({ queryKey: runtimeKeys.toolIds(), type: 'active' });
+        },
+    });
+}
+export function useConnectMcpServer() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (name) => {
+            const client = getClient();
+            const result = await client.mcp.connect({ name });
+            return unwrap(result);
+        },
+        onMutate: async (name) => {
+            await queryClient.cancelQueries({ queryKey: runtimeKeys.mcpStatus() });
+            const prev = queryClient.getQueryData(runtimeKeys.mcpStatus());
+            if (prev) {
+                queryClient.setQueryData(runtimeKeys.mcpStatus(), {
+                    ...prev,
+                    [name]: { status: 'connected' },
+                });
+            }
+            return { prev };
+        },
+        onError: (_err, _name, context) => {
+            if (context?.prev) {
+                queryClient.setQueryData(runtimeKeys.mcpStatus(), context.prev);
+            }
+        },
+        onSettled: () => {
+            queryClient.refetchQueries({ queryKey: runtimeKeys.mcpStatus(), type: 'active' });
+            queryClient.refetchQueries({ queryKey: runtimeKeys.toolIds(), type: 'active' });
+        },
+    });
+}
+export function useDisconnectMcpServer() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (name) => {
+            const client = getClient();
+            const result = await client.mcp.disconnect({ name });
+            return unwrap(result);
+        },
+        onMutate: async (name) => {
+            await queryClient.cancelQueries({ queryKey: runtimeKeys.mcpStatus() });
+            const prev = queryClient.getQueryData(runtimeKeys.mcpStatus());
+            if (prev) {
+                queryClient.setQueryData(runtimeKeys.mcpStatus(), {
+                    ...prev,
+                    [name]: { status: 'disabled' },
+                });
+            }
+            return { prev };
+        },
+        onError: (_err, _name, context) => {
+            if (context?.prev) {
+                queryClient.setQueryData(runtimeKeys.mcpStatus(), context.prev);
+            }
+        },
+        onSettled: () => {
+            queryClient.refetchQueries({ queryKey: runtimeKeys.mcpStatus(), type: 'active' });
+            queryClient.refetchQueries({ queryKey: runtimeKeys.toolIds(), type: 'active' });
+        },
+    });
+}
+export function useMcpAuthStart() {
+    return useMutation({
+        mutationFn: async (name) => {
+            const client = getClient();
+            const result = await client.mcp.auth.start({ name });
+            return unwrap(result);
+        },
+    });
+}
+export function useMcpAuthCallback() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ name, code }) => {
+            const client = getClient();
+            const result = await client.mcp.auth.callback({ name, code });
+            return unwrap(result);
+        },
+        onSuccess: () => {
+            queryClient.refetchQueries({ queryKey: runtimeKeys.mcpStatus(), type: 'active' });
+            queryClient.refetchQueries({ queryKey: runtimeKeys.toolIds(), type: 'active' });
+        },
+    });
+}
+export function useMcpAuthRemove() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (name) => {
+            const client = getClient();
+            const result = await client.mcp.auth.remove({ name });
+            return unwrap(result);
+        },
+        onSuccess: () => {
+            queryClient.refetchQueries({ queryKey: runtimeKeys.mcpStatus(), type: 'active' });
+        },
+    });
+}

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

@@ -0,0 +1,39 @@
+import { type BeeuniPty } from '../core/runtime/pty.js';
+export type Pty = BeeuniPty;
+export declare const ptyKeys: {
+    all: readonly ["pty"];
+    list: (serverUrl: string) => readonly ["pty", string, "list"];
+    listPrefix: () => readonly ["pty"];
+    detail: (id: string) => readonly ["pty", string];
+};
+export interface PtyMutationOptions {
+    onError?: (error: unknown) => void;
+    serverUrl?: string;
+}
+export declare function ptyMutationOverrides(options?: PtyMutationOptions): {
+    onError?: (error: unknown) => void;
+};
+export declare function useRuntimePtyList(options?: {
+    enabled?: boolean;
+    serverUrl?: string;
+}): import("@tanstack/react-query").UseQueryResult<BeeuniPty[], Error>;
+export declare function useCreatePty(hookOptions?: PtyMutationOptions): import("@tanstack/react-query").UseMutationResult<BeeuniPty, unknown, {
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    title?: string;
+    env?: Record<string, string>;
+} | undefined, unknown>;
+export declare function useRemovePty(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export declare function useUpdatePty(options?: PtyMutationOptions): import("@tanstack/react-query").UseMutationResult<BeeuniPty, unknown, {
+    id: string;
+    title?: string;
+    size?: {
+        rows: number;
+        cols: number;
+    };
+}, unknown>;
+export declare function getPtyWebSocketUrl(ptyId: string, serverUrl?: string, opts?: {
+    wake?: boolean;
+}): Promise<string>;
+export declare const useOpenCodePtyList: typeof useRuntimePtyList;

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

@@ -0,0 +1,61 @@
+'use client';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { createBeeuniPty, getBeeuniPtyWebSocketUrl, listBeeuniPty, removeBeeuniPty, updateBeeuniPty, } from '../core/runtime/pty.js';
+import { getActiveRuntimeUrl } from '../browser/stores/server-store.js';
+import { isPtyQueryEnabled, resolvePtyServerUrl } from './pty-query-state.js';
+import { useCurrentRuntime } from './use-current-runtime.js';
+export const ptyKeys = {
+    all: ['pty'],
+    list: (serverUrl) => ['pty', serverUrl, 'list'],
+    listPrefix: () => ['pty'],
+    detail: (id) => ['pty', id],
+};
+export function ptyMutationOverrides(options) {
+    return options?.onError ? { onError: options.onError } : {};
+}
+export function useRuntimePtyList(options) {
+    const runtimeUrl = useCurrentRuntime((state) => state.url);
+    const activeUrl = runtimeUrl || getActiveRuntimeUrl();
+    const serverUrl = resolvePtyServerUrl(options?.serverUrl, activeUrl);
+    return useQuery({
+        queryKey: ptyKeys.list(serverUrl),
+        queryFn: () => listBeeuniPty(serverUrl),
+        staleTime: Infinity,
+        gcTime: 5 * 60 * 1000,
+        refetchOnWindowFocus: false,
+        enabled: isPtyQueryEnabled(serverUrl, options?.enabled ?? true),
+    });
+}
+export function useCreatePty(hookOptions) {
+    const queryClient = useQueryClient();
+    const runtimeUrl = useCurrentRuntime((state) => state.url);
+    const serverUrl = resolvePtyServerUrl(hookOptions?.serverUrl, runtimeUrl || getActiveRuntimeUrl());
+    return useMutation({
+        mutationFn: (options) => createBeeuniPty(serverUrl, options),
+        onSuccess: () => {
+            queryClient.refetchQueries({ queryKey: ptyKeys.listPrefix(), type: 'active' });
+        },
+        ...ptyMutationOverrides(hookOptions),
+    });
+}
+export function useRemovePty() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => removeBeeuniPty(getActiveRuntimeUrl(), id),
+        onSuccess: () => {
+            queryClient.refetchQueries({ queryKey: ptyKeys.listPrefix(), type: 'active' });
+        },
+    });
+}
+export function useUpdatePty(options) {
+    const runtimeUrl = useCurrentRuntime((state) => state.url);
+    const serverUrl = resolvePtyServerUrl(options?.serverUrl, runtimeUrl || getActiveRuntimeUrl());
+    return useMutation({
+        mutationFn: ({ id, title, size, }) => updateBeeuniPty(serverUrl, id, { title, size }),
+        ...ptyMutationOverrides(options),
+    });
+}
+export async function getPtyWebSocketUrl(ptyId, serverUrl, opts) {
+    return getBeeuniPtyWebSocketUrl(ptyId, serverUrl || getActiveRuntimeUrl(), opts);
+}
+export const useOpenCodePtyList = useRuntimePtyList;

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

@@ -0,0 +1,11 @@
+import type { Agent } from '../../core/runtime/runtime-types.js';
+import { projectConfigAgentsToOpenCodeAgents, projectConfigAgentsToRuntimeAgents } from '../../core/agents/composer-agents.js';
+export { useVisibleAgents } from '../use-visible-agents.js';
+export { projectConfigAgentsToOpenCodeAgents, projectConfigAgentsToRuntimeAgents };
+export declare function useRuntimeAgents(options?: {
+    directory?: string;
+    projectId?: string | null;
+}): import("@tanstack/react-query").UseQueryResult<Agent[], Error>;
+export declare function useRuntimeAgent(agentName: string): import("@tanstack/react-query").UseQueryResult<Agent | undefined, Error>;
+export declare const useOpenCodeAgents: typeof useRuntimeAgents;
+export declare const useOpenCodeAgent: typeof useRuntimeAgent;

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

@@ -0,0 +1,57 @@
+'use client';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { runtimeKeys, useRuntimeReady } from './keys.js';
+import { unwrap } from './shared.js';
+import { getProjectDetail } from '../../core/rest/projects-client/index.js';
+import { projectConfigAgentsToOpenCodeAgents, projectConfigAgentsToRuntimeAgents, } from '../../core/agents/composer-agents.js';
+import { contract } from '../query-contracts.js';
+import { qk } from '../query-keys.js';
+export { useVisibleAgents } from '../use-visible-agents.js';
+export { projectConfigAgentsToOpenCodeAgents, projectConfigAgentsToRuntimeAgents };
+export function useRuntimeAgents(options) {
+    const queryClient = useQueryClient();
+    const directory = options?.directory;
+    const projectId = options?.projectId ?? null;
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: projectId
+            ? [...qk.project.detail(projectId), 'agents']
+            : directory
+                ? [...runtimeKeys.agents(), 'dir', directory]
+                : runtimeKeys.agents(),
+        queryFn: async () => {
+            if (projectId) {
+                const detail = await queryClient.fetchQuery({
+                    queryKey: qk.project.detail(projectId),
+                    queryFn: () => getProjectDetail(projectId),
+                    ...contract('config'),
+                });
+                return projectConfigAgentsToRuntimeAgents(detail.config);
+            }
+            const client = getClient();
+            const result = await client.app.agents(directory ? { directory } : undefined);
+            const data = unwrap(result);
+            return Array.isArray(data) ? data : Object.values(data);
+        },
+        enabled: projectId ? true : runtimeReady,
+        staleTime: projectId ? 30_000 : Infinity,
+        gcTime: 10 * 60 * 1000,
+    });
+}
+export function useRuntimeAgent(agentName) {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: [...runtimeKeys.agents(), agentName],
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.app.agents();
+            const agents = unwrap(result);
+            return agents.find((a) => a.name === agentName);
+        },
+        enabled: runtimeReady && !!agentName,
+        staleTime: Infinity,
+    });
+}
+export const useOpenCodeAgents = useRuntimeAgents;
+export const useOpenCodeAgent = useRuntimeAgent;

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

@@ -0,0 +1,16 @@
+import type { Command } from '../../core/runtime/runtime-types.js';
+export declare function useRuntimeCommands(): import("@tanstack/react-query").UseQueryResult<Command[], Error>;
+export interface ExecuteRuntimeCommandInput {
+    sessionId: string;
+    command: string;
+    args?: string;
+    agent?: string;
+    model?: string;
+    variant?: string;
+}
+export declare function executeRuntimeCommand({ sessionId, command, args, agent, model, variant, }: ExecuteRuntimeCommandInput): Promise<void>;
+export declare function useExecuteRuntimeCommand(): import("@tanstack/react-query").UseMutationResult<void, Error, ExecuteRuntimeCommandInput, unknown>;
+export type ExecuteOpenCodeCommandInput = ExecuteRuntimeCommandInput;
+export declare const executeOpenCodeCommand: typeof executeRuntimeCommand;
+export declare const useOpenCodeCommands: typeof useRuntimeCommands;
+export declare const useExecuteOpenCodeCommand: typeof useExecuteRuntimeCommand;

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

@@ -0,0 +1,42 @@
+'use client';
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { useRuntimeSupports } from '../use-runtime-supports.js';
+import { runtimeKeys, useRuntimeReady } from './keys.js';
+import { unwrap, asRuntimeList } from './shared.js';
+export function useRuntimeCommands() {
+    const runtimeReady = useRuntimeReady();
+    const supported = useRuntimeSupports('session.commands');
+    return useQuery({
+        queryKey: runtimeKeys.commands(),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.command.list();
+            return asRuntimeList(unwrap(result));
+        },
+        enabled: runtimeReady && supported,
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+    });
+}
+export async function executeRuntimeCommand({ sessionId, command, args, agent, model, variant, }) {
+    const client = getClient();
+    const result = await client.session.command({
+        sessionID: sessionId,
+        command,
+        arguments: args || '',
+        ...(agent ? { agent } : {}),
+        ...(model ? { model } : {}),
+        ...(variant ? { variant } : {}),
+    });
+    unwrap(result);
+}
+export function useExecuteRuntimeCommand() {
+    return useMutation({
+        mutationFn: executeRuntimeCommand,
+        retry: false,
+    });
+}
+export const executeOpenCodeCommand = executeRuntimeCommand;
+export const useOpenCodeCommands = useRuntimeCommands;
+export const useExecuteOpenCodeCommand = useExecuteRuntimeCommand;

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

@@ -0,0 +1,2 @@
+export declare function findRuntimeFiles(query: string): Promise<string[]>;
+export declare const findOpenCodeFiles: typeof findRuntimeFiles;

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

@@ -0,0 +1,144 @@
+import { getClient } from '../../core/runtime/client.js';
+import { unwrap } from './shared.js';
+import { rankWorkspaceSearchEntry, workspaceEntryMatchesQuery } from '../../workspace-search/core.js';
+let mentionFileIndexCache;
+let mentionDirScanCache;
+export async function findRuntimeFiles(query) {
+    const client = getClient();
+    const normalizedQuery = query.trim();
+    const readEntries = async (request) => {
+        try {
+            const result = await request;
+            const entries = unwrap(result);
+            if (!Array.isArray(entries))
+                return [];
+            const normalized = [];
+            for (const entry of entries) {
+                if (typeof entry === 'string' && entry.length > 0) {
+                    normalized.push(entry);
+                    continue;
+                }
+                if (entry && typeof entry === 'object') {
+                    const maybePath = entry.path;
+                    const maybeType = entry.type;
+                    if (typeof maybePath === 'string' && maybePath.length > 0) {
+                        if (maybeType === 'directory' && !maybePath.endsWith('/')) {
+                            normalized.push(`${maybePath}/`);
+                        }
+                        else {
+                            normalized.push(maybePath);
+                        }
+                    }
+                }
+            }
+            return normalized;
+        }
+        catch {
+            return [];
+        }
+    };
+    const [strictFiles, broadResults] = await Promise.all([
+        readEntries(client.find.files({ query: normalizedQuery, type: 'file', limit: 80 })),
+        readEntries(client.find.files({ query: normalizedQuery, limit: 80 })),
+    ]);
+    const fileMatches = new Set();
+    const directoryMatches = [];
+    for (const entry of [...strictFiles, ...broadResults]) {
+        if (entry.endsWith('/')) {
+            directoryMatches.push(entry);
+            continue;
+        }
+        fileMatches.add(entry);
+    }
+    if (fileMatches.size < 20 && normalizedQuery.length > 0 && directoryMatches.length > 0) {
+        const expandedDirs = directoryMatches.slice(0, 6);
+        const dirChildren = await Promise.all(expandedDirs.map(async (dir) => {
+            const path = dir.endsWith('/') ? dir.slice(0, -1) : dir;
+            const children = await readEntries(client.file.list({ path }));
+            return children
+                .filter((child) => !child.endsWith('/'))
+                .filter((child) => workspaceEntryMatchesQuery({ path: child, name: '', isDir: false }, normalizedQuery, 'runtime-files'));
+        }));
+        for (const group of dirChildren) {
+            for (const child of group) {
+                fileMatches.add(child);
+            }
+        }
+    }
+    if (normalizedQuery.length > 0 && fileMatches.size < 20) {
+        const [rootWorkspace, rootEmpty] = await Promise.all([
+            readEntries(client.file.list({ path: '/workspace' })),
+            readEntries(client.file.list({ path: '' })),
+        ]);
+        for (const entry of [...rootWorkspace, ...rootEmpty]) {
+            if (entry.endsWith('/'))
+                continue;
+            if (workspaceEntryMatchesQuery({ path: entry, name: '', isDir: false }, normalizedQuery, 'runtime-files'))
+                fileMatches.add(entry);
+        }
+    }
+    if (normalizedQuery.length > 0 && fileMatches.size < 20) {
+        const now = Date.now();
+        const cacheFresh = mentionDirScanCache && now - mentionDirScanCache.fetchedAt < 60_000;
+        if (!cacheFresh) {
+            const roots = await Promise.all([
+                readEntries(client.file.list({ path: '/workspace' })),
+                readEntries(client.file.list({ path: '' })),
+            ]);
+            const rootEntries = Array.from(new Set([...roots[0], ...roots[1]]));
+            const fileSet = new Set();
+            const firstLevelDirs = rootEntries
+                .filter((entry) => entry.endsWith('/'))
+                .map((entry) => (entry.endsWith('/') ? entry.slice(0, -1) : entry))
+                .slice(0, 80);
+            for (const entry of rootEntries) {
+                if (!entry.endsWith('/'))
+                    fileSet.add(entry);
+            }
+            const childLists = await Promise.all(firstLevelDirs.map((dir) => readEntries(client.file.list({ path: dir }))));
+            for (const children of childLists) {
+                for (const child of children) {
+                    if (!child.endsWith('/'))
+                        fileSet.add(child);
+                }
+            }
+            mentionDirScanCache = {
+                files: Array.from(fileSet),
+                fetchedAt: now,
+            };
+        }
+        for (const path of mentionDirScanCache?.files ?? []) {
+            if (workspaceEntryMatchesQuery({ path, name: '', isDir: false }, normalizedQuery, 'runtime-files'))
+                fileMatches.add(path);
+        }
+    }
+    if (normalizedQuery.length > 0 && fileMatches.size < 10) {
+        const now = Date.now();
+        const cacheFresh = mentionFileIndexCache && now - mentionFileIndexCache.fetchedAt < 60_000;
+        if (!cacheFresh) {
+            const [indexStrict, indexBroad] = await Promise.all([
+                readEntries(client.find.files({ query: '', type: 'file', limit: 2000 })),
+                readEntries(client.find.files({ query: '', limit: 2000 })),
+            ]);
+            const indexSet = new Set();
+            for (const entry of [...indexStrict, ...indexBroad]) {
+                if (!entry.endsWith('/'))
+                    indexSet.add(entry);
+            }
+            mentionFileIndexCache = {
+                files: Array.from(indexSet),
+                fetchedAt: now,
+            };
+        }
+        for (const path of mentionFileIndexCache?.files ?? []) {
+            if (workspaceEntryMatchesQuery({ path, name: '', isDir: false }, normalizedQuery, 'runtime-files'))
+                fileMatches.add(path);
+        }
+    }
+    return Array.from(fileMatches)
+        .sort((a, b) => rankWorkspaceSearchEntry({ path: a, name: '', isDir: false }, normalizedQuery, 'runtime-files') -
+        rankWorkspaceSearchEntry({ path: b, name: '', isDir: false }, normalizedQuery, 'runtime-files') ||
+        a.localeCompare(b))
+        .slice(0, 20);
+}
+export const findOpenCodeFiles = findRuntimeFiles;

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

@@ -0,0 +1,15 @@
+export * from './keys.js';
+export * from './sessions.js';
+export * from './messages.js';
+export * from './agents.js';
+export * from './tools.js';
+export * from './projects.js';
+export * from './commands.js';
+export * from './providers.js';
+export * from './mcp.js';
+export * from './sharing.js';
+export * from './parts.js';
+export * from './files.js';
+export * from './permissions.js';
+export * from './vcs.js';
+export { canQueryOpenCodeSession, canQueryRuntimeSession, clearProjectProviderCache } from './shared.js';

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

@@ -0,0 +1,15 @@
+export * from './keys.js';
+export * from './sessions.js';
+export * from './messages.js';
+export * from './agents.js';
+export * from './tools.js';
+export * from './projects.js';
+export * from './commands.js';
+export * from './providers.js';
+export * from './mcp.js';
+export * from './sharing.js';
+export * from './parts.js';
+export * from './files.js';
+export * from './permissions.js';
+export * from './vcs.js';
+export { canQueryOpenCodeSession, canQueryRuntimeSession, clearProjectProviderCache } from './shared.js';

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

@@ -0,0 +1,102 @@
+import type { QueryClient } from '@tanstack/react-query';
+import type { Session, Message, Part, Agent, Command, Project, SessionStatus, PermissionRule, Model, McpStatus, Path as PathInfo, ProviderListResponse as SdkProviderListResponse, Worktree, WorktreeCreateInput, WorktreeRemoveInput, WorktreeResetInput } from '../../core/runtime/runtime-types.js';
+export type { Session, Message, Part, Agent, Command, Project, SessionStatus, PermissionRule, Model, McpStatus, PathInfo, Worktree, WorktreeCreateInput, WorktreeRemoveInput, WorktreeResetInput, };
+export interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}
+export type ProviderListResponse = SdkProviderListResponse;
+export type PromptPart = {
+    type: 'text';
+    text: string;
+    id?: string;
+} | {
+    type: 'file';
+    mime: string;
+    url: string;
+    filename?: string;
+    source?: {
+        text: {
+            value: string;
+            start: number;
+            end: number;
+        };
+        type: 'file';
+        path: string;
+    };
+} | {
+    type: 'agent';
+    name: string;
+    source?: {
+        value: string;
+        start: number;
+        end: number;
+    };
+};
+export interface SendMessageOptions {
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    agent?: string;
+    variant?: string;
+    directory?: string;
+}
+export interface Skill {
+    name: string;
+    description: string;
+    location: string;
+    content: string;
+}
+export interface ToolListItem {
+    id: string;
+    description: string;
+    parameters: unknown;
+}
+export declare const runtimeKeys: {
+    all: readonly ["opencode"];
+    sessions: (serverId?: string) => readonly ["opencode", "sessions", string];
+    session: (id: string) => readonly ["opencode", "session", string];
+    messages: (sessionId: string) => readonly ["opencode", "session", string, "messages"];
+    sessionTodo: (sessionId: string) => readonly ["opencode", "session-todo", string];
+    runtimeSession: (id: string, serverId?: string) => readonly ["opencode", "session", string, string];
+    runtimeMessages: (sessionId: string, serverId?: string) => readonly ["opencode", "session", string, "messages", string];
+    agents: () => readonly ["opencode", "agents", string];
+    toolIds: () => readonly ["opencode", "tool-ids", string];
+    tools: (providerID: string, modelID: string) => readonly ["opencode", "tools", string, string, string];
+    skills: () => readonly ["opencode", "skills", string];
+    projects: () => readonly ["opencode", "projects", string];
+    currentProject: () => readonly ["opencode", "project", "current", string];
+    commands: () => readonly ["opencode", "commands", string];
+    providers: () => readonly ["opencode", "providers", string];
+    pathInfo: () => readonly ["opencode", "path-info", string];
+    mcpStatus: () => readonly ["opencode", "mcp-status", string];
+    worktrees: () => readonly ["opencode", "worktrees", string];
+    vcsDiff: (mode: "git" | "branch", serverId?: string) => readonly ["opencode", "vcs-diff", "git" | "branch", string];
+    vcsDiffAll: () => readonly ["opencode", "vcs-diff"];
+};
+export declare function resetRuntimeQueries(queryClient: Pick<QueryClient, 'removeQueries'>): void;
+export declare function useRuntimeReady(): boolean;
+export declare const opencodeKeys: {
+    all: readonly ["opencode"];
+    sessions: (serverId?: string) => readonly ["opencode", "sessions", string];
+    session: (id: string) => readonly ["opencode", "session", string];
+    messages: (sessionId: string) => readonly ["opencode", "session", string, "messages"];
+    sessionTodo: (sessionId: string) => readonly ["opencode", "session-todo", string];
+    runtimeSession: (id: string, serverId?: string) => readonly ["opencode", "session", string, string];
+    runtimeMessages: (sessionId: string, serverId?: string) => readonly ["opencode", "session", string, "messages", string];
+    agents: () => readonly ["opencode", "agents", string];
+    toolIds: () => readonly ["opencode", "tool-ids", string];
+    tools: (providerID: string, modelID: string) => readonly ["opencode", "tools", string, string, string];
+    skills: () => readonly ["opencode", "skills", string];
+    projects: () => readonly ["opencode", "projects", string];
+    currentProject: () => readonly ["opencode", "project", "current", string];
+    commands: () => readonly ["opencode", "commands", string];
+    providers: () => readonly ["opencode", "providers", string];
+    pathInfo: () => readonly ["opencode", "path-info", string];
+    mcpStatus: () => readonly ["opencode", "mcp-status", string];
+    worktrees: () => readonly ["opencode", "worktrees", string];
+    vcsDiff: (mode: "git" | "branch", serverId?: string) => readonly ["opencode", "vcs-diff", "git" | "branch", string];
+    vcsDiffAll: () => readonly ["opencode", "vcs-diff"];
+};
+export declare const useOpenCodeRuntimeReady: typeof useRuntimeReady;