@beeuni/sdk 0.1.0

package/dist/react/use-notifications.js

@@ -0,0 +1,104 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { getNotificationPreferences, getSessionWatch, listNotifications, markNotificationsRead, setSessionWatch, updateNotificationPreferences, } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+const DEFAULT_INBOX_LIMIT = 20;
+export function notificationInboxQueryOptions(userId, limit = DEFAULT_INBOX_LIMIT, enabled = true) {
+    return {
+        queryKey: qk.notifications.inbox(userId, limit),
+        enabled: enabled && !!userId,
+        ...contract('inventory'),
+        refetchInterval: 60_000,
+        refetchIntervalInBackground: false,
+        refetchOnWindowFocus: true,
+    };
+}
+async function writeOptimistic(client, key, next) {
+    await client.cancelQueries({ queryKey: key });
+    const previous = client.getQueryData(key);
+    if (previous !== undefined)
+        client.setQueryData(key, next(previous));
+    return () => client.setQueryData(key, previous);
+}
+function markedRead(page, input) {
+    if ('all' in input) {
+        return { ...page, unread_count: 0, notifications: page.notifications.map((n) => ({ ...n, read: true })) };
+    }
+    const hit = (n) => ('ids' in input ? input.ids.includes(n.id) : n.session_id === input.sessionId);
+    let changed = 0;
+    const notifications = page.notifications.map((n) => {
+        if (n.read || !hit(n))
+            return n;
+        changed += 1;
+        return { ...n, read: true };
+    });
+    return { ...page, notifications, unread_count: Math.max(0, page.unread_count - changed) };
+}
+export function useNotificationInbox(options) {
+    const client = useQueryClient();
+    const limit = options.limit ?? DEFAULT_INBOX_LIMIT;
+    const key = qk.notifications.inbox(options.userId, limit);
+    const query = useQuery({
+        ...notificationInboxQueryOptions(options.userId, limit, options.enabled ?? true),
+        queryFn: ({ signal }) => listNotifications({ limit }, { signal }),
+    });
+    const mark = useMutation({
+        mutationFn: markNotificationsRead,
+        onMutate: (input) => writeOptimistic(client, key, (page) => markedRead(page, input)),
+        onError: (_error, _input, restore) => restore?.(),
+        onSettled: () => {
+            void client.invalidateQueries({ queryKey: qk.notifications.scope() });
+        },
+    });
+    return {
+        ...query,
+        unreadCount: query.data?.unread_count ?? 0,
+        markRead: (ids) => mark.mutateAsync({ ids }),
+        markAllRead: () => mark.mutateAsync({ all: true }),
+        markSessionRead: (sessionId) => mark.mutateAsync({ sessionId }),
+    };
+}
+export function useNotificationPreferences(options) {
+    const client = useQueryClient();
+    const key = qk.notifications.preferences(options.userId);
+    const query = useQuery({
+        queryKey: key,
+        queryFn: getNotificationPreferences,
+        enabled: (options.enabled ?? true) && !!options.userId,
+        ...contract('config'),
+    });
+    const save = useMutation({
+        mutationFn: updateNotificationPreferences,
+        onMutate: (patch) => writeOptimistic(client, key, (record) => {
+            const kinds = { ...record.kinds };
+            for (const [kind, channels] of Object.entries(patch.kinds)) {
+                if (channels)
+                    kinds[kind] = { ...kinds[kind], ...channels };
+            }
+            return { ...record, kinds };
+        }),
+        onError: (_error, _patch, restore) => restore?.(),
+        onSuccess: (record) => client.setQueryData(key, record),
+    });
+    return { ...query, update: (patch) => save.mutateAsync(patch) };
+}
+export function useSessionWatch(options) {
+    const client = useQueryClient();
+    const projectId = options.projectId ?? '';
+    const sessionId = options.sessionId ?? '';
+    const key = qk.notifications.sessionWatch(options.userId, projectId, sessionId);
+    const query = useQuery({
+        queryKey: key,
+        queryFn: () => getSessionWatch(projectId, sessionId),
+        enabled: (options.enabled ?? true) && !!options.userId && !!projectId && !!sessionId,
+        ...contract('config'),
+    });
+    const save = useMutation({
+        mutationFn: (watching) => setSessionWatch(projectId, sessionId, watching),
+        onMutate: (watching) => writeOptimistic(client, key, () => ({ watching })),
+        onError: (_error, _watching, restore) => restore?.(),
+        onSuccess: (state) => client.setQueryData(key, state),
+    });
+    return { ...query, setWatching: (watching) => save.mutateAsync(watching) };
+}

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

@@ -0,0 +1,12 @@
+import type { Config } from '../core/runtime/runtime-types.js';
+export type { Config };
+export declare const configKeys: {
+    all: readonly ["opencode", "config"];
+};
+export declare function useRuntimeConfig(): import("@tanstack/react-query").UseQueryResult<Config, Error>;
+export declare function useUpdateRuntimeConfig(): import("@tanstack/react-query").UseMutationResult<Config, Error, Partial<Config>, {
+    previous: Config | undefined;
+}>;
+export declare function clearConfigOverrides(): void;
+export declare const useOpenCodeConfig: typeof useRuntimeConfig;
+export declare const useUpdateOpenCodeConfig: typeof useUpdateRuntimeConfig;

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

@@ -0,0 +1,69 @@
+'use client';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { getClient } from '../core/runtime/client.js';
+import { useRuntimeReady } from './use-opencode-sessions/keys.js';
+import { useRuntimeSupports } from './use-runtime-supports.js';
+export const configKeys = {
+    all: ['opencode', 'config'],
+};
+function unwrap(result) {
+    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 : 'Request failed');
+    }
+    return result.data;
+}
+export function useRuntimeConfig() {
+    const runtimeReady = useRuntimeReady();
+    const supported = useRuntimeSupports('session.config');
+    return useQuery({
+        queryKey: configKeys.all,
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.global.config.get();
+            return unwrap(result);
+        },
+        enabled: runtimeReady && supported,
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+    });
+}
+export function useUpdateRuntimeConfig() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (config) => {
+            const client = getClient();
+            const result = await client.global.config.update({ config: config });
+            return unwrap(result);
+        },
+        onMutate: async (config) => {
+            await queryClient.cancelQueries({ queryKey: configKeys.all });
+            const previous = queryClient.getQueryData(configKeys.all);
+            if (previous) {
+                queryClient.setQueryData(configKeys.all, {
+                    ...previous,
+                    ...config,
+                    permission: typeof config.permission !== 'undefined'
+                        ? config.permission
+                        : previous.permission,
+                });
+            }
+            return { previous };
+        },
+        onError: (_err, _config, context) => {
+            if (context?.previous) {
+                queryClient.setQueryData(configKeys.all, context.previous);
+            }
+        },
+        onSettled: () => {
+            queryClient.refetchQueries({ queryKey: configKeys.all, type: 'active' });
+        },
+    });
+}
+export function clearConfigOverrides() {
+}
+export const useOpenCodeConfig = useRuntimeConfig;
+export const useUpdateOpenCodeConfig = useUpdateRuntimeConfig;

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

@@ -0,0 +1,4 @@
+import type { Part } from '../../core/runtime/runtime-types.js';
+import type { RefObject } from 'react';
+import type { NormalizeDiagnosticPaths } from './types.js';
+export declare function applyPartDiagnostics(part: Part, normalizeDiagnosticPaths: RefObject<NormalizeDiagnosticPaths>): void;

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

@@ -0,0 +1,42 @@
+import { parseDiagnosticsFromToolOutput, useDiagnosticsStore, } from '../../browser/stores/diagnostics-store.js';
+export function applyPartDiagnostics(part, normalizeDiagnosticPaths) {
+    const partState = part.type === 'tool' ? part.state : undefined;
+    if (partState?.status === 'completed' && partState.output) {
+        const output = partState.output;
+        if (output.includes('<file_diagnostics>') || output.includes('<project_diagnostics>')) {
+            const parsed = parseDiagnosticsFromToolOutput(output);
+            const fileCount = Object.keys(parsed).length;
+            if (fileCount > 0) {
+                const normalized = normalizeDiagnosticPaths.current(parsed);
+                const asRaw = {};
+                for (const [file, diags] of Object.entries(normalized)) {
+                    asRaw[file] = diags.map((d) => ({
+                        range: {
+                            start: { line: d.line, character: d.column },
+                        },
+                        severity: d.severity,
+                        message: d.message,
+                        source: d.source,
+                    }));
+                }
+                useDiagnosticsStore.getState().setFromLspEvent(asRaw);
+            }
+        }
+    }
+    const partMeta = partState && partState.status !== 'pending' ? partState.metadata : undefined;
+    if (partMeta?.diagnostics && typeof partMeta.diagnostics === 'object') {
+        const diagsByFile = partMeta.diagnostics;
+        const validEntries = {};
+        let hasValid = false;
+        for (const [file, diags] of Object.entries(diagsByFile)) {
+            if (Array.isArray(diags) && diags.length > 0) {
+                validEntries[file] = diags;
+                hasValid = true;
+            }
+        }
+        if (hasValid) {
+            const normalized = normalizeDiagnosticPaths.current(validEntries);
+            useDiagnosticsStore.getState().setFromLspEvent(normalized);
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+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, RuntimeEvent } from './types.js';
+export declare const USER_PARTS_GRACE_MS = 1500;
+export declare function createEventHandler(deps: {
+    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;
+}): (event: RuntimeEvent) => void;

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

@@ -0,0 +1,57 @@
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import { SESSION_SYNC_PAGE_SIZE } from '../../core/session-sync/session-sync-controller.js';
+import { binaryBlobKeys, fileContentKeys, fileListKeys, gitStatusKeys } from '../file-keys.js';
+import { runtimeKeys } from '../use-opencode-sessions/index.js';
+import { handleInteractionEvent } from './handle-interaction-event.js';
+import { handleMessageEvent } from './handle-message-event.js';
+import { handleSessionEvent } from './handle-session-event.js';
+import { handleWorkspaceEvent } from './handle-workspace-event.js';
+export const USER_PARTS_GRACE_MS = 1_500;
+export function createEventHandler(deps) {
+    const { queryClient, client } = deps;
+    const reconcileTail = deps.reconcileSessionTail ??
+        (async (sessionID) => {
+            const result = await client.session.messages({ sessionID, limit: SESSION_SYNC_PAGE_SIZE });
+            if (result.data)
+                useSyncStore.getState().hydrate(sessionID, result.data);
+        });
+    const ctx = {
+        ...deps,
+        projectId: deps.projectId ?? null,
+        userPartsGraceMs: deps.userPartsGraceMs ?? USER_PARTS_GRACE_MS,
+        reconcileTail,
+        getSessionTitle(sessionID) {
+            const sessions = queryClient.getQueryData(runtimeKeys.sessions());
+            return (sessions?.find((s) => s.id === sessionID)?.title ||
+                queryClient.getQueryData(runtimeKeys.runtimeSession(sessionID))?.title ||
+                undefined);
+        },
+        invalidateWorkspaceFilesAfterTurn() {
+            for (const queryKey of [
+                gitStatusKeys.all,
+                runtimeKeys.vcsDiffAll(),
+                fileListKeys.all,
+                fileContentKeys.all,
+                binaryBlobKeys.all,
+            ])
+                queryClient.invalidateQueries({ queryKey });
+        },
+    };
+    return (event) => {
+        const sessionID = event.type === 'session.status' || event.type === 'session.idle'
+            ? event.properties.sessionID
+            : undefined;
+        const statusBeforeEvent = sessionID
+            ? useSyncStore.getState().sessionStatus[sessionID]
+            : undefined;
+        deps.applySyncEvent(event);
+        if (event.type.startsWith('message.'))
+            handleMessageEvent(event, ctx);
+        else if (event.type.startsWith('session.') && event.type !== 'session.diff')
+            handleSessionEvent(event, ctx, statusBeforeEvent);
+        else if (event.type.startsWith('permission.') || event.type.startsWith('question.'))
+            handleInteractionEvent(event, ctx);
+        else
+            handleWorkspaceEvent(event, ctx);
+    };
+}

package/dist/react/use-opencode-events/handle-interaction-event.d.ts

@@ -0,0 +1,3 @@
+import type { HandlerContext } from './handler-context.js';
+import type { RuntimeEvent } from './types.js';
+export declare function handleInteractionEvent(event: RuntimeEvent, ctx: HandlerContext): void;

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

@@ -0,0 +1,41 @@
+import { notifyPermissionRequest, notifyQuestion } from '../../platform/ui.js';
+import { asStringOrUndefined } from './helpers.js';
+export function handleInteractionEvent(event, ctx) {
+    const { addPermission, removePermission, addQuestion, removeQuestion, getSessionTitle } = ctx;
+    switch (event.type) {
+        case 'permission.asked': {
+            const props = event.properties;
+            if (props.id && props.sessionID) {
+                addPermission(props);
+                const rawProps = props;
+                const toolName = asStringOrUndefined(rawProps.tool) ?? asStringOrUndefined(rawProps.type) ?? 'a tool';
+                notifyPermissionRequest(props.sessionID, toolName, getSessionTitle(props.sessionID));
+            }
+            break;
+        }
+        case 'permission.replied': {
+            const requestID = event.properties.requestID;
+            if (requestID)
+                removePermission(requestID);
+            break;
+        }
+        case 'question.asked': {
+            const props = event.properties;
+            if (props.id && props.sessionID) {
+                addQuestion(props);
+                const questionText = props.questions[0]?.question || props.questions[0]?.header || 'Beeuni needs your input';
+                notifyQuestion(props.sessionID, questionText, getSessionTitle(props.sessionID));
+            }
+            break;
+        }
+        case 'question.replied':
+        case 'question.rejected': {
+            const requestID = event.properties.requestID;
+            if (requestID)
+                removeQuestion(requestID);
+            break;
+        }
+        default:
+            break;
+    }
+}

package/dist/react/use-opencode-events/handle-message-event.d.ts

@@ -0,0 +1,3 @@
+import type { HandlerContext } from './handler-context.js';
+import type { RuntimeEvent } from './types.js';
+export declare function handleMessageEvent(event: RuntimeEvent, ctx: HandlerContext): void;

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

@@ -0,0 +1,32 @@
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import { applyPartDiagnostics } from './diagnostics.js';
+export function handleMessageEvent(event, ctx) {
+    const { reconcileTail, userPartsGraceMs, normalizeDiagnosticPaths } = ctx;
+    switch (event.type) {
+        case 'message.updated': {
+            const info = event.properties.info;
+            const sessionID = info?.sessionID ?? event.properties.sessionID;
+            if (info?.role === 'user' && info.id && sessionID) {
+                const messageID = info.id;
+                setTimeout(() => {
+                    const state = useSyncStore.getState();
+                    const stillListed = state.messages[sessionID]?.some((m) => m.id === messageID);
+                    if (stillListed && !(state.parts[messageID]?.length ?? 0)) {
+                        void reconcileTail(sessionID, 'sse-gap');
+                    }
+                }, userPartsGraceMs);
+            }
+            break;
+        }
+        case 'message.removed':
+            break;
+        case 'message.part.updated': {
+            applyPartDiagnostics(event.properties.part, normalizeDiagnosticPaths);
+            break;
+        }
+        case 'message.part.removed':
+            break;
+        default:
+            break;
+    }
+}

package/dist/react/use-opencode-events/handle-session-event.d.ts

@@ -0,0 +1,4 @@
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import type { HandlerContext } from './handler-context.js';
+import type { RuntimeEvent } from './types.js';
+export declare function handleSessionEvent(event: RuntimeEvent, ctx: HandlerContext, statusBeforeEvent: ReturnType<typeof useSyncStore.getState>['sessionStatus'][string] | undefined): void;

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

@@ -0,0 +1,240 @@
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import { isAbortError } from '../../core/http/abort-error.js';
+import { getClient } from '../../core/runtime/client.js';
+import { notifySessionError, notifyTaskComplete } from '../../platform/ui.js';
+import { runtimeKeys } from '../use-opencode-sessions/index.js';
+import { patchBeeuniSessionTitleMirrors, readSessionInfo, realRuntimeTitle, refetchBeeuniSessionMirrors, } from './helpers.js';
+export function handleSessionEvent(event, ctx, statusBeforeEvent) {
+    if (event.type === 'session.created' || event.type === 'session.updated')
+        handleSessionLifecycle(event, ctx);
+    else if (event.type === 'session.deleted')
+        handleSessionDeletion(event, ctx);
+    else if (event.type === 'session.error')
+        handleSessionFailure(event, ctx);
+    else if (event.type === 'session.compacted')
+        handleSessionCompaction(event, ctx);
+    else
+        handleSessionCompletion(event, ctx, statusBeforeEvent);
+}
+function handleSessionLifecycle(event, ctx) {
+    const { queryClient, projectId } = ctx;
+    switch (event.type) {
+        case 'session.created': {
+            const info = readSessionInfo(event);
+            if (info) {
+                useSyncStore.getState().syncSessionRevertFromInfo(info.id, info.revert ?? null);
+                queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                    if (!old)
+                        return [info];
+                    const exists = old.findIndex((s) => s.id === info.id);
+                    if (exists >= 0) {
+                        if (old[exists].time.updated === info.time.updated)
+                            return old;
+                        const next = [...old];
+                        next[exists] = info;
+                        return next.sort((a, b) => b.time.updated - a.time.updated);
+                    }
+                    return [info, ...old].sort((a, b) => b.time.updated - a.time.updated);
+                });
+                queryClient.setQueryData(runtimeKeys.runtimeSession(info.id), info);
+                patchBeeuniSessionTitleMirrors(queryClient, projectId, info.id, realRuntimeTitle(info.title));
+                refetchBeeuniSessionMirrors(queryClient, projectId);
+            }
+            break;
+        }
+        case 'session.updated': {
+            const info = readSessionInfo(event);
+            if (info) {
+                useSyncStore.getState().syncSessionRevertFromInfo(info.id, info.revert ?? null);
+                const prevTitle = queryClient.getQueryData(runtimeKeys.sessions())?.find((s) => s.id === info.id)
+                    ?.title ??
+                    queryClient.getQueryData(runtimeKeys.runtimeSession(info.id))?.title ??
+                    null;
+                const titleChanged = !!info.title && info.title !== prevTitle;
+                queryClient.setQueryData(runtimeKeys.runtimeSession(info.id), info);
+                queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                    if (!old)
+                        return old;
+                    const idx = old.findIndex((s) => s.id === info.id);
+                    if (idx < 0)
+                        return old;
+                    if (old[idx].time.updated === info.time.updated && old[idx].title === info.title)
+                        return old;
+                    const next = [...old];
+                    next[idx] = info;
+                    return next.sort((a, b) => b.time.updated - a.time.updated);
+                });
+                if (titleChanged) {
+                    patchBeeuniSessionTitleMirrors(queryClient, projectId, info.id, realRuntimeTitle(info.title));
+                    refetchBeeuniSessionMirrors(queryClient, projectId);
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+function handleSessionDeletion(event, ctx) {
+    const { queryClient } = ctx;
+    switch (event.type) {
+        case 'session.deleted': {
+            const info = readSessionInfo(event);
+            if (info) {
+                queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                    if (!old)
+                        return old;
+                    const found = old.some((s) => s.id === info.id);
+                    if (!found)
+                        return old;
+                    return old.filter((s) => s.id !== info.id);
+                });
+                queryClient.removeQueries({
+                    queryKey: runtimeKeys.runtimeSession(info.id),
+                });
+                queryClient.removeQueries({
+                    queryKey: runtimeKeys.runtimeMessages(info.id),
+                });
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+function handleSessionCompaction(event, ctx) {
+    const { queryClient, stopCompaction, reconcileTail } = ctx;
+    switch (event.type) {
+        case 'session.compacted': {
+            const sessionID = event.properties.sessionID;
+            if (sessionID) {
+                stopCompaction(sessionID);
+                const client = getClient();
+                void reconcileTail(sessionID, 'compaction');
+                client.session
+                    .get({ sessionID })
+                    .then((res) => {
+                    if (res.data) {
+                        const session = res.data;
+                        queryClient.setQueryData(runtimeKeys.runtimeSession(sessionID), session);
+                        queryClient.setQueryData(runtimeKeys.sessions(), (old) => {
+                            if (!old)
+                                return old;
+                            const idx = old.findIndex((s) => s.id === sessionID);
+                            if (idx < 0)
+                                return old;
+                            const next = [...old];
+                            next[idx] = session;
+                            return next;
+                        });
+                    }
+                    else {
+                        void queryClient.invalidateQueries({
+                            queryKey: runtimeKeys.runtimeSession(sessionID),
+                        });
+                    }
+                })
+                    .catch(() => {
+                    void queryClient.invalidateQueries({
+                        queryKey: runtimeKeys.runtimeSession(sessionID),
+                    });
+                });
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+function handleSessionCompletion(event, ctx, statusBeforeEvent) {
+    const { reconcileTail, getSessionTitle, invalidateWorkspaceFilesAfterTurn } = ctx;
+    switch (event.type) {
+        case 'session.next.revert.committed': {
+            const { sessionID } = event.properties;
+            if (sessionID && useSyncStore.getState().sessionRevertNeedsTailReconcile[sessionID]) {
+                useSyncStore.getState().clearSessionRevertNeedsTailReconcile(sessionID);
+                void reconcileTail(sessionID, 'manual');
+            }
+            break;
+        }
+        case 'session.status': {
+            const { sessionID, status } = event.properties;
+            if (sessionID && status) {
+                if (status.type === 'idle')
+                    void reconcileTail(sessionID, 'turn-end');
+                const prevStatus = statusBeforeEvent;
+                if (status.type === 'idle' && prevStatus && prevStatus.type !== 'idle') {
+                    notifyTaskComplete(sessionID, getSessionTitle(sessionID));
+                    invalidateWorkspaceFilesAfterTurn();
+                }
+            }
+            break;
+        }
+        case 'session.idle': {
+            const sessionID = event.properties.sessionID;
+            if (sessionID) {
+                void reconcileTail(sessionID, 'turn-end');
+                const prevStatus = statusBeforeEvent;
+                if (prevStatus && prevStatus.type !== 'idle') {
+                    notifyTaskComplete(sessionID, getSessionTitle(sessionID));
+                    invalidateWorkspaceFilesAfterTurn();
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+function handleSessionFailure(event, ctx) {
+    const { queryClient, stopCompaction, reconcileTail, getSessionTitle } = ctx;
+    switch (event.type) {
+        case 'session.error': {
+            const props = event.properties;
+            if (props.sessionID && props.error) {
+                const sessionID = props.sessionID;
+                const error = props.error;
+                stopCompaction(sessionID);
+                const rawMessage = error.data.message;
+                const errorTitle = error.name ||
+                    (typeof rawMessage === 'string' ? rawMessage : undefined) ||
+                    'An error occurred';
+                notifySessionError(sessionID, errorTitle, getSessionTitle(sessionID));
+                const key = runtimeKeys.runtimeMessages(sessionID);
+                queryClient.cancelQueries({ queryKey: key });
+                queryClient.setQueryData(key, (old) => {
+                    if (!old || old.length === 0)
+                        return old;
+                    for (let i = old.length - 1; i >= 0; i--) {
+                        const info = old[i].info;
+                        if (info.role === 'assistant') {
+                            if (info.error)
+                                return old;
+                            const updated = [...old];
+                            updated[i] = {
+                                ...old[i],
+                                info: { ...info, error },
+                            };
+                            return updated;
+                        }
+                    }
+                    return old;
+                });
+                const aborted = isAbortError(error);
+                if (!aborted) {
+                    reconcileTail(sessionID, 'session-error')
+                        .then(() => {
+                        useSyncStore.getState().clearOptimisticMessages(sessionID);
+                    })
+                        .catch(() => { });
+                }
+                else {
+                    useSyncStore.getState().clearOptimisticMessages(sessionID);
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { HandlerContext } from './handler-context.js';
+import type { RuntimeEvent } from './types.js';
+export declare function handleWorkspaceEvent(event: RuntimeEvent, ctx: HandlerContext): void;