@beeuni/sdk 0.1.0

package/dist/react/use-opencode-events/handle-workspace-event.js

@@ -0,0 +1,112 @@
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import { infoToast } from '../../platform/ui.js';
+import { binaryBlobKeys, fileContentKeys, fileListKeys, gitStatusKeys } from '../file-keys.js';
+import { ptyKeys } from '../use-opencode-pty.js';
+import { runtimeKeys } from '../use-opencode-sessions/index.js';
+import { scheduleProjectMetadataRefetch } from './helpers.js';
+export function handleWorkspaceEvent(event, ctx) {
+    const { queryClient, markSessionAbortedLocally, fetchLspDiagnosticsDebounced } = ctx;
+    switch (event.type) {
+        case 'session.diff': {
+            const props = event.properties;
+            if (props.sessionID) {
+                queryClient.setQueryData(['opencode', 'session-diff', props.sessionID], props.diff);
+            }
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.vcsDiffAll(), type: 'active' });
+            break;
+        }
+        case 'todo.updated': {
+            const props = event.properties;
+            if (props.sessionID) {
+                queryClient.setQueryData(['opencode', 'session-todo', props.sessionID], props.todos);
+            }
+            break;
+        }
+        case 'vcs.branch.updated': {
+            const props = event.properties;
+            queryClient.setQueryData(['opencode', 'vcs'], { branch: props.branch });
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.vcsDiffAll(), type: 'active' });
+            break;
+        }
+        case 'server.instance.disposed': {
+            for (const [sessionID, status] of Object.entries(useSyncStore.getState().sessionStatus)) {
+                if (status?.type !== 'idle') {
+                    markSessionAbortedLocally.current(sessionID, 'The operation was aborted because the server instance was disposed.');
+                }
+            }
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.sessions(), type: 'active' });
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.mcpStatus(), type: 'active' });
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.skills(), type: 'active' });
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.agents(), type: 'active' });
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.toolIds(), type: 'active' });
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.commands(), type: 'active' });
+            break;
+        }
+        case 'lsp.updated': {
+            queryClient.invalidateQueries({
+                queryKey: ['opencode', 'lsp'],
+                type: 'active',
+            });
+            fetchLspDiagnosticsDebounced.current();
+            break;
+        }
+        case 'lsp.client.diagnostics': {
+            fetchLspDiagnosticsDebounced.current();
+            break;
+        }
+        case 'mcp.tools.changed': {
+            queryClient.refetchQueries({ queryKey: runtimeKeys.mcpStatus(), type: 'active' });
+            queryClient.refetchQueries({ queryKey: runtimeKeys.toolIds(), type: 'active' });
+            break;
+        }
+        case 'pty.created':
+        case 'pty.updated':
+        case 'pty.exited':
+        case 'pty.deleted': {
+            queryClient.invalidateQueries({ queryKey: ptyKeys.listPrefix(), type: 'active' });
+            break;
+        }
+        case 'worktree.ready': {
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.worktrees(), type: 'active' });
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.projects(), type: 'active' });
+            break;
+        }
+        case 'worktree.failed': {
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.worktrees(), type: 'active' });
+            break;
+        }
+        case 'project.updated': {
+            scheduleProjectMetadataRefetch(queryClient);
+            break;
+        }
+        case 'file.edited': {
+            const fileProps = event.properties;
+            queryClient.invalidateQueries({ queryKey: fileListKeys.all, type: 'active' });
+            queryClient.invalidateQueries({ queryKey: gitStatusKeys.all, type: 'active' });
+            queryClient.invalidateQueries({ queryKey: runtimeKeys.vcsDiffAll(), type: 'active' });
+            if (fileProps.file) {
+                queryClient.invalidateQueries({ queryKey: fileContentKeys.all, type: 'active' });
+                queryClient.invalidateQueries({ queryKey: binaryBlobKeys.all, type: 'active' });
+            }
+            break;
+        }
+        case 'installation.updated': {
+            const installProps = event.properties;
+            const versionStr = installProps.version ? ` (v${installProps.version})` : '';
+            infoToast(`Installation updated${versionStr}. Restart to apply changes.`, {
+                duration: 10_000,
+            });
+            break;
+        }
+        case 'installation.update-available': {
+            const updateProps = event.properties;
+            const versionLabel = updateProps.version ? `v${updateProps.version}` : 'A new version';
+            infoToast(`${versionLabel} is available. Update when you're ready.`, {
+                duration: 15_000,
+            });
+            break;
+        }
+        default:
+            break;
+    }
+}

package/dist/react/use-opencode-events/handler-context.d.ts

@@ -0,0 +1,28 @@
+import type { Event as OpenCodeSdkEvent, PermissionRequest, QuestionRequest } from '../../core/runtime/runtime-types.js';
+import type { QueryClient } from '@tanstack/react-query';
+import type { RefObject } from 'react';
+import type { getClient } from '../../core/runtime/client.js';
+import type { SessionSyncReason } from '../../core/session-sync/session-sync-controller.js';
+import type { NormalizeDiagnosticPaths } from './types.js';
+export type HandlerContext = {
+    queryClient: QueryClient;
+    client: ReturnType<typeof getClient>;
+    applySyncEvent: (event: OpenCodeSdkEvent) => void;
+    stopCompaction: (sessionID: string) => void;
+    addPermission: (req: PermissionRequest) => void;
+    removePermission: (requestId: string) => void;
+    addQuestion: (req: QuestionRequest) => void;
+    removeQuestion: (requestId: string) => void;
+    normalizeDiagnosticPaths: RefObject<NormalizeDiagnosticPaths>;
+    markSessionAbortedLocally: RefObject<(sessionID: string, message?: string) => void>;
+    fetchLspDiagnosticsDebounced: RefObject<() => void>;
+    reconcileSessionTail?: (sessionID: string, reason: SessionSyncReason) => Promise<void>;
+    userPartsGraceMs?: number;
+    projectId?: string | null;
+} & {
+    reconcileTail: (sessionID: string, reason: import('../../core/session-sync/session-sync-controller.js').SessionSyncReason) => Promise<void>;
+    getSessionTitle: (sessionID: string) => string | undefined;
+    invalidateWorkspaceFilesAfterTurn: () => void;
+    projectId: string | null;
+    userPartsGraceMs: number;
+};

package/dist/react/use-opencode-events/handler-context.js

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

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

@@ -0,0 +1,27 @@
+import { type QueryClient } from '@tanstack/react-query';
+import { type Session } from '../use-opencode-sessions/index.js';
+import type { RuntimeEvent } from './types.js';
+export declare const WIRE_STATUS_FILL_FRESHNESS_MS = 45000;
+export declare function shouldSkipStatusFill(input: {
+    hasSlot: boolean;
+    origin: 'wire' | 'local' | undefined;
+    stampedAtMs: number | undefined;
+    nowMs: number;
+}): boolean;
+export interface ClientEvictionInput {
+    isFirstMount: boolean;
+    isServerSwitch: boolean;
+    didServerUrlChange: boolean;
+    previousServerUrl: string | null;
+    activeServerUrl: string | null;
+}
+export declare function resolveClientEvictionUrl(input: ClientEvictionInput): string | null;
+export declare function readSessionInfo(event: RuntimeEvent): Session | undefined;
+export declare function asStringOrUndefined(value: unknown): string | undefined;
+export declare function reserveMessageRehydrate(sessionID: string): boolean;
+export declare function messageRehydrateEntryCount(): number;
+export declare function releaseMessageRehydrate(sessionID: string): void;
+export declare function scheduleProjectMetadataRefetch(queryClient: QueryClient): void;
+export declare function refetchBeeuniSessionMirrors(queryClient: QueryClient, projectId: string | null): void;
+export declare function realRuntimeTitle(value: unknown): string | null;
+export declare function patchBeeuniSessionTitleMirrors(queryClient: QueryClient, projectId: string | null, nativeSessionId: string, title: string | null): void;

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

@@ -0,0 +1,126 @@
+import { STREAM_OBSERVATION_MAX_MS } from '../../core/session/working.js';
+import { runtimeKeys } from '../use-opencode-sessions/index.js';
+import { qk } from '../query-keys.js';
+import { updateCachedProjectSessions } from '../session-cache-write.js';
+export const WIRE_STATUS_FILL_FRESHNESS_MS = STREAM_OBSERVATION_MAX_MS;
+export function shouldSkipStatusFill(input) {
+    if (!input.hasSlot)
+        return false;
+    if (input.origin === 'local')
+        return false;
+    if (input.stampedAtMs === undefined)
+        return true;
+    return input.nowMs - input.stampedAtMs <= WIRE_STATUS_FILL_FRESHNESS_MS;
+}
+const MESSAGE_REHYDRATE_COOLDOWN_MS = 30_000;
+const PROJECT_METADATA_REFETCH_COOLDOWN_MS = 5_000;
+const messageRehydrateInFlight = new Set();
+const messageRehydrateLastAt = new Map();
+let projectMetadataRefetchLastAt = 0;
+let projectMetadataRefetchTimer = null;
+export function resolveClientEvictionUrl(input) {
+    if (input.isFirstMount) {
+        return input.activeServerUrl;
+    }
+    if (input.isServerSwitch || input.didServerUrlChange) {
+        return input.previousServerUrl;
+    }
+    return null;
+}
+export function readSessionInfo(event) {
+    const props = event.properties;
+    if (!props || typeof props !== 'object')
+        return undefined;
+    const rec = props;
+    if (rec.info)
+        return rec.info;
+    return typeof rec.id === 'string' ? props : undefined;
+}
+export function asStringOrUndefined(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+export function reserveMessageRehydrate(sessionID) {
+    if (!sessionID || messageRehydrateInFlight.has(sessionID))
+        return false;
+    const now = Date.now();
+    const last = messageRehydrateLastAt.get(sessionID) ?? 0;
+    if (now - last < MESSAGE_REHYDRATE_COOLDOWN_MS)
+        return false;
+    messageRehydrateInFlight.add(sessionID);
+    if (messageRehydrateLastAt.size >= 200) {
+        for (const [key, at] of messageRehydrateLastAt) {
+            if (now - at >= MESSAGE_REHYDRATE_COOLDOWN_MS)
+                messageRehydrateLastAt.delete(key);
+        }
+    }
+    messageRehydrateLastAt.set(sessionID, now);
+    return true;
+}
+export function messageRehydrateEntryCount() {
+    return messageRehydrateLastAt.size;
+}
+export function releaseMessageRehydrate(sessionID) {
+    messageRehydrateInFlight.delete(sessionID);
+}
+export function scheduleProjectMetadataRefetch(queryClient) {
+    const run = () => {
+        projectMetadataRefetchTimer = null;
+        projectMetadataRefetchLastAt = Date.now();
+        queryClient.refetchQueries({ queryKey: runtimeKeys.projects(), type: 'active' });
+        queryClient.refetchQueries({ queryKey: runtimeKeys.currentProject(), type: 'active' });
+    };
+    const now = Date.now();
+    const wait = PROJECT_METADATA_REFETCH_COOLDOWN_MS - (now - projectMetadataRefetchLastAt);
+    if (wait <= 0) {
+        if (projectMetadataRefetchTimer) {
+            clearTimeout(projectMetadataRefetchTimer);
+            projectMetadataRefetchTimer = null;
+        }
+        run();
+        return;
+    }
+    if (!projectMetadataRefetchTimer) {
+        projectMetadataRefetchTimer = setTimeout(run, wait);
+    }
+}
+export function refetchBeeuniSessionMirrors(queryClient, projectId) {
+    if (!projectId)
+        return;
+    void queryClient.refetchQueries({
+        queryKey: [...qk.project.sessionsScope(projectId), 'list'],
+        type: 'active',
+    });
+    void queryClient.refetchQueries({
+        queryKey: [...qk.project.sessionsScope(projectId), 'list-paged'],
+        type: 'active',
+    });
+    void queryClient.refetchQueries({
+        queryKey: [...qk.project.sessionsScope(projectId), 'list-children'],
+        type: 'active',
+    });
+}
+const PLACEHOLDER_RUNTIME_TITLE_RE = /^new (?:session|agent)\b/i;
+export function realRuntimeTitle(value) {
+    const title = typeof value === 'string' ? value.trim() : '';
+    if (!title || PLACEHOLDER_RUNTIME_TITLE_RE.test(title))
+        return null;
+    return title;
+}
+export function patchBeeuniSessionTitleMirrors(queryClient, projectId, nativeSessionId, title) {
+    if (!projectId || !title)
+        return;
+    updateCachedProjectSessions(queryClient, projectId, (rows) => {
+        let changed = false;
+        const next = rows.map((row) => {
+            if ((row.runtime_session_id ?? row.opencode_session_id) !== nativeSessionId)
+                return row;
+            if (typeof row.custom_name === 'string' && row.custom_name.trim())
+                return row;
+            if (row.name === title)
+                return row;
+            changed = true;
+            return { ...row, name: title };
+        });
+        return changed ? next : rows;
+    });
+}

package/dist/react/use-opencode-events/hydrate-core.d.ts

@@ -0,0 +1,22 @@
+import type { useQueryClient } from '@tanstack/react-query';
+import type { reconcileSessionTail as reconcileSessionTailFromRegistry } from '../../browser/session-sync/session-sync-registry.js';
+import type { useRuntimePendingStore } from '../../browser/stores/opencode-pending-store.js';
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import type { getClient } from '../../core/runtime/client.js';
+import type { useEventStreamRefs } from './use-event-stream-refs.js';
+type HydrationDeps = {
+    client: ReturnType<typeof getClient>;
+    queryClient: ReturnType<typeof useQueryClient>;
+    addPermission: ReturnType<typeof useRuntimePendingStore.getState>['addPermission'];
+    addQuestion: ReturnType<typeof useRuntimePendingStore.getState>['addQuestion'];
+    applySyncEvent: ReturnType<typeof useSyncStore.getState>['applyEvent'];
+    reconcileMissingBusySessions: ReturnType<typeof useEventStreamRefs>['reconcileMissingBusySessions'];
+    fetchLspDiagnosticsDebounced: ReturnType<typeof useEventStreamRefs>['fetchLspDiagnosticsDebounced'];
+    reconcileSessionTail: typeof reconcileSessionTailFromRegistry;
+    options?: {
+        refetchSessions?: boolean;
+        rehydrateMessages?: boolean;
+    };
+};
+export declare function hydrateCore(deps: HydrationDeps): void;
+export {};

package/dist/react/use-opencode-events/hydrate-core.js

@@ -0,0 +1,78 @@
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import { logger } from '../../core/http/logger.js';
+import { runtimeKeys } from '../use-opencode-sessions/index.js';
+import { releaseMessageRehydrate, reserveMessageRehydrate, shouldSkipStatusFill } from './helpers.js';
+import { sessionsNeedingRehydrate } from './rehydrate-targets.js';
+function hydrateStatuses({ client, applySyncEvent, reconcileMissingBusySessions, }) {
+    client.session
+        .status()
+        .then((res) => {
+        const statuses = res.data ?? {};
+        for (const [sessionID, status] of Object.entries(statuses)) {
+            const slotState = useSyncStore.getState();
+            if (shouldSkipStatusFill({
+                hasSlot: !!slotState.sessionStatus[sessionID],
+                origin: slotState.sessionStatusOrigin[sessionID],
+                stampedAtMs: slotState.sessionStatusAt[sessionID],
+                nowMs: Date.now(),
+            }))
+                continue;
+            applySyncEvent({
+                type: 'session.status',
+                synthetic: true,
+                properties: { sessionID, status },
+            });
+        }
+        reconcileMissingBusySessions.current(statuses);
+    })
+        .catch((err) => {
+        logger.error('Failed to hydrate session statuses', {
+            error: String(err),
+        });
+    });
+}
+function hydrateTails({ reconcileSessionTail }) {
+    const syncState = useSyncStore.getState();
+    for (const sid of sessionsNeedingRehydrate(Object.keys(syncState.messages))) {
+        if (!reserveMessageRehydrate(sid))
+            continue;
+        reconcileSessionTail(sid, 'sse-gap')
+            .catch(() => { })
+            .finally(() => releaseMessageRehydrate(sid));
+    }
+}
+export function hydrateCore(deps) {
+    const { client, queryClient, addPermission, addQuestion, fetchLspDiagnosticsDebounced, options } = deps;
+    client.permission
+        .list()
+        .then((res) => {
+        if (Array.isArray(res.data))
+            res.data.forEach(addPermission);
+    })
+        .catch((err) => {
+        logger.error('Failed to hydrate pending permissions', {
+            error: String(err),
+        });
+    });
+    client.question
+        .list()
+        .then((res) => {
+        if (Array.isArray(res.data))
+            res.data.forEach(addQuestion);
+    })
+        .catch((err) => {
+        logger.error('Failed to hydrate pending questions', {
+            error: String(err),
+        });
+    });
+    hydrateStatuses(deps);
+    fetchLspDiagnosticsDebounced.current();
+    if (options?.refetchSessions) {
+        queryClient.refetchQueries({
+            queryKey: runtimeKeys.sessions(),
+            type: 'active',
+        });
+    }
+    if (options?.rehydrateMessages)
+        hydrateTails(deps);
+}

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

@@ -0,0 +1,9 @@
+export { subscribeRuntimeStream, type RuntimeStreamSignal } from './runtime-stream-signals.js';
+export declare function useRuntimeEventStream(options?: {
+    enabled?: boolean;
+    projectId?: string;
+    sessionId?: string;
+}): void;
+export declare function RuntimeEventStreamProvider(): null;
+export declare const OpenCodeEventStreamProvider: typeof RuntimeEventStreamProvider;
+export declare const useOpenCodeEventStream: typeof useRuntimeEventStream;

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

@@ -0,0 +1,181 @@
+'use client';
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { noteSessionSyncEvent, reconcileSessionTail as reconcileSessionTailFromRegistry, } from '../../browser/session-sync/session-sync-registry.js';
+import { useDiagnosticsStore } from '../../browser/stores/diagnostics-store.js';
+import { useOpenCodeCompactionStore } from '../../browser/stores/opencode-compaction-store.js';
+import { useRuntimePendingStore } from '../../browser/stores/opencode-pending-store.js';
+import { noteRuntimeEvidence, useSandboxConnectionStore, } from '../../browser/stores/sandbox-connection-store.js';
+import { useServerStore } from '../../browser/stores/server-store.js';
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import { logger } from '../../core/http/logger.js';
+import { onHostSignal } from '../../core/session/host-signals.js';
+import { dropClientForUrl, getClient } from '../../core/runtime/client.js';
+import { openEventStream } from '../../core/stream/event-stream.js';
+import { openSessionStream, sessionStreamEventClient } from '../../core/session/control-stream.js';
+const SESSION_STREAM_WATCHDOG_OFF_MS = 24 * 60 * 60_000;
+import { useBeeuniRouteProjectId } from '../route-project.js';
+import { useCurrentRuntime } from '../use-current-runtime.js';
+import { clearConfigOverrides } from '../use-opencode-config.js';
+import { resetPrefetchState } from '../use-session-prefetch.js';
+import { createEventHandler } from './handle-event.js';
+import { resolveClientEvictionUrl } from './helpers.js';
+import { hydrateCore } from './hydrate-core.js';
+import { emitRuntimeStreamSignal, shouldReconnectOnHostSignal } from './runtime-stream-signals.js';
+import { createStreamRevival } from './stream-revival.js';
+import { useEventStreamRefs } from './use-event-stream-refs.js';
+export { subscribeRuntimeStream } from './runtime-stream-signals.js';
+export function useRuntimeEventStream(options = {}) {
+    const queryClient = useQueryClient();
+    const projectId = useBeeuniRouteProjectId();
+    const addPermission = useRuntimePendingStore((s) => s.addPermission);
+    const removePermission = useRuntimePendingStore((s) => s.removePermission);
+    const addQuestion = useRuntimePendingStore((s) => s.addQuestion);
+    const removeQuestion = useRuntimePendingStore((s) => s.removeQuestion);
+    const clearPending = useRuntimePendingStore((s) => s.clear);
+    const stopCompaction = useOpenCodeCompactionStore((s) => s.stopCompaction);
+    const applySyncEvent = useSyncStore((s) => s.applyEvent);
+    const runtimeVersion = useCurrentRuntime((s) => s.version);
+    const activeServerUrl = useServerStore((s) => s.getActiveServerUrl());
+    const sandboxStatus = useSandboxConnectionStore((s) => s.status);
+    const runtimeHealthy = useSandboxConnectionStore((s) => s.healthy);
+    const isMountRef = useRef(true);
+    const prevRuntimeVersionRef = useRef(runtimeVersion);
+    const prevServerUrlRef = useRef(activeServerUrl);
+    const [streamGeneration, setStreamGeneration] = useState(0);
+    const revival = useMemo(() => createStreamRevival(() => setStreamGeneration((generation) => generation + 1)), []);
+    useEffect(() => revival.stop, [revival]);
+    useEffect(() => onHostSignal((signal) => {
+        const lastEvidenceAt = useSandboxConnectionStore.getState().lastRuntimeEvidenceAt;
+        if (!shouldReconnectOnHostSignal(signal, lastEvidenceAt, Date.now()))
+            return;
+        setStreamGeneration((generation) => generation + 1);
+    }), []);
+    const { normalizeDiagnosticPaths, fetchLspDiagnosticsDebounced, markSessionAbortedLocally, reconcileMissingBusySessions, } = useEventStreamRefs({ queryClient, stopCompaction, applySyncEvent });
+    useEffect(() => {
+        const isFirstMount = isMountRef.current;
+        isMountRef.current = false;
+        const isServerSwitch = prevRuntimeVersionRef.current !== runtimeVersion;
+        prevRuntimeVersionRef.current = runtimeVersion;
+        const previousServerUrl = prevServerUrlRef.current;
+        const didServerUrlChange = previousServerUrl !== activeServerUrl;
+        prevServerUrlRef.current = activeServerUrl;
+        const evictUrl = resolveClientEvictionUrl({
+            isFirstMount,
+            isServerSwitch,
+            didServerUrlChange,
+            previousServerUrl,
+            activeServerUrl,
+        });
+        if (evictUrl)
+            dropClientForUrl(evictUrl);
+        if (isFirstMount || isServerSwitch) {
+            clearConfigOverrides();
+            clearPending();
+            useDiagnosticsStore.getState().clearAll();
+            resetPrefetchState();
+        }
+        if (options.enabled === false ||
+            !activeServerUrl ||
+            sandboxStatus !== 'connected' ||
+            runtimeHealthy !== true)
+            return;
+        let client;
+        try {
+            client = getClient();
+        }
+        catch {
+            return;
+        }
+        const handleEvent = createEventHandler({
+            queryClient,
+            client,
+            applySyncEvent,
+            stopCompaction,
+            addPermission,
+            removePermission,
+            addQuestion,
+            removeQuestion,
+            normalizeDiagnosticPaths,
+            markSessionAbortedLocally,
+            fetchLspDiagnosticsDebounced,
+            reconcileSessionTail: reconcileSessionTailFromRegistry,
+            projectId,
+        });
+        const hydrate = (options) => hydrateCore({
+            client,
+            queryClient,
+            addPermission,
+            addQuestion,
+            applySyncEvent,
+            reconcileMissingBusySessions,
+            fetchLspDiagnosticsDebounced,
+            reconcileSessionTail: reconcileSessionTailFromRegistry,
+            options,
+        });
+        hydrate({ rehydrateMessages: streamGeneration > 0 });
+        const sessionStream = options.projectId && options.sessionId
+            ? sessionStreamEventClient(options.projectId, options.sessionId)
+            : null;
+        const resyncs = options.projectId && options.sessionId
+            ? openSessionStream({
+                projectId: options.projectId,
+                sessionId: options.sessionId,
+                onRuntimeResync: () => hydrate({ rehydrateMessages: true }),
+            })
+            : null;
+        const handle = openEventStream({
+            client: sessionStream ?? client,
+            ...(sessionStream ? { heartbeatTimeoutMs: SESSION_STREAM_WATCHDOG_OFF_MS } : {}),
+            onParked: (info) => {
+                logger.warn('SSE stream parked — arming revival', {
+                    consecutiveFailures: info.consecutiveFailures,
+                });
+                revival.park();
+                emitRuntimeStreamSignal({ type: 'parked' });
+            },
+            onEvent: (event) => {
+                noteRuntimeEvidence();
+                noteSessionSyncEvent(event);
+                handleEvent(event);
+                emitRuntimeStreamSignal({ type: 'event', event });
+            },
+            onConnectionChange: (state) => emitRuntimeStreamSignal({ type: state }),
+            onGapRehydrate: () => {
+                if (!sessionStream)
+                    hydrate({ rehydrateMessages: true });
+            },
+        });
+        return () => {
+            revival.stop();
+            resyncs?.close();
+            handle.close();
+            emitRuntimeStreamSignal({ type: 'closed' });
+        };
+    }, [
+        queryClient,
+        addPermission,
+        removePermission,
+        addQuestion,
+        removeQuestion,
+        clearPending,
+        runtimeVersion,
+        activeServerUrl,
+        sandboxStatus,
+        runtimeHealthy,
+        options.enabled,
+        options.projectId,
+        options.sessionId,
+        applySyncEvent,
+        stopCompaction,
+        projectId,
+        revival,
+        streamGeneration,
+    ]);
+}
+export function RuntimeEventStreamProvider() {
+    useRuntimeEventStream();
+    return null;
+}
+export const OpenCodeEventStreamProvider = RuntimeEventStreamProvider;
+export const useOpenCodeEventStream = useRuntimeEventStream;

package/dist/react/use-opencode-events/rehydrate-targets.d.ts

@@ -0,0 +1 @@
+export declare function sessionsNeedingRehydrate(loadedSessionIds: string[]): string[];

package/dist/react/use-opencode-events/rehydrate-targets.js

@@ -0,0 +1,3 @@
+export function sessionsNeedingRehydrate(loadedSessionIds) {
+    return [...new Set(loadedSessionIds)];
+}

package/dist/react/use-opencode-events/runtime-stream-signals.d.ts

@@ -0,0 +1,19 @@
+import type { HostSignal } from '../../core/session/host-signals.js';
+import type { RuntimeEvent } from '../../core/stream/event-stream.js';
+export type RuntimeStreamSignal = {
+    type: 'event';
+    event: RuntimeEvent;
+} | {
+    type: 'connecting';
+} | {
+    type: 'open';
+} | {
+    type: 'lost';
+} | {
+    type: 'parked';
+} | {
+    type: 'closed';
+};
+export declare function subscribeRuntimeStream(listener: (signal: RuntimeStreamSignal) => void): () => void;
+export declare function emitRuntimeStreamSignal(signal: RuntimeStreamSignal): void;
+export declare function shouldReconnectOnHostSignal(signal: HostSignal, lastRuntimeEvidenceAt: number | null, now: number): boolean;

package/dist/react/use-opencode-events/runtime-stream-signals.js

@@ -0,0 +1,22 @@
+const listeners = new Set();
+export function subscribeRuntimeStream(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+export function emitRuntimeStreamSignal(signal) {
+    for (const listener of [...listeners]) {
+        try {
+            listener(signal);
+        }
+        catch {
+        }
+    }
+}
+const STALE_EVIDENCE_MS = 60_000;
+export function shouldReconnectOnHostSignal(signal, lastRuntimeEvidenceAt, now) {
+    if (signal === 'retry')
+        return true;
+    return lastRuntimeEvidenceAt === null || now - lastRuntimeEvidenceAt >= STALE_EVIDENCE_MS;
+}

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

@@ -0,0 +1,11 @@
+export interface StreamRevivalOptions {
+    reviveAfterMs?: number;
+    setTimeout?: (handler: () => void, ms: number) => unknown;
+    clearTimeout?: (handle: unknown) => void;
+    listen?: (event: string, handler: () => void) => () => void;
+}
+export interface StreamRevival {
+    park: () => void;
+    stop: () => void;
+}
+export declare function createStreamRevival(revive: () => void, options?: StreamRevivalOptions): StreamRevival;