@beeuni/sdk 0.1.0 → 0.3.0

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

@@ -20,4 +20,5 @@ export declare function createEventHandler(deps: {
     reconcileSessionTail?: (sessionID: string, reason: SessionSyncReason) => Promise<void>;
     userPartsGraceMs?: number;
     projectId?: string | null;
+    sessionId?: string | null;
 }): (event: RuntimeEvent) => void;

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

@@ -44,6 +44,11 @@ export function createEventHandler(deps) {
         const statusBeforeEvent = sessionID
             ? useSyncStore.getState().sessionStatus[sessionID]
             : undefined;
+        if (event.type.startsWith('log.')) {
+            if (deps.sessionId)
+                useSyncStore.getState().applySessionLogEvent(deps.sessionId, event);
+            return;
+        }
         deps.applySyncEvent(event);
         if (event.type.startsWith('message.'))
             handleMessageEvent(event, ctx);

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

@@ -1,7 +1,12 @@
 import { notifyPermissionRequest, notifyQuestion } from '../../platform/ui.js';
-import { asStringOrUndefined } from './helpers.js';
+import { qk } from '../query-keys.js';
+import { asStringOrUndefined, notificationSessionId } from './helpers.js';
 export function handleInteractionEvent(event, ctx) {
     const { addPermission, removePermission, addQuestion, removeQuestion, getSessionTitle } = ctx;
+    const notifiedId = (runtimeId) => notificationSessionId(ctx.queryClient, ctx.projectId, ctx.sessionId, runtimeId, true) ?? runtimeId;
+    if (event.type.startsWith('question.') && ctx.projectId) {
+        ctx.queryClient.invalidateQueries({ queryKey: qk.project.needsInput(ctx.projectId) });
+    }
     switch (event.type) {
         case 'permission.asked': {
             const props = event.properties;
@@ -9,7 +14,7 @@ export function handleInteractionEvent(event, ctx) {
                 addPermission(props);
                 const rawProps = props;
                 const toolName = asStringOrUndefined(rawProps.tool) ?? asStringOrUndefined(rawProps.type) ?? 'a tool';
-                notifyPermissionRequest(props.sessionID, toolName, getSessionTitle(props.sessionID));
+                notifyPermissionRequest(notifiedId(props.sessionID), toolName, getSessionTitle(props.sessionID));
             }
             break;
         }
@@ -24,7 +29,7 @@ export function handleInteractionEvent(event, ctx) {
             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));
+                notifyQuestion(notifiedId(props.sessionID), questionText, getSessionTitle(props.sessionID));
             }
             break;
         }

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

@@ -1,9 +1,10 @@
 import { useSyncStore } from '../../browser/stores/sync-store.js';
 import { isAbortError } from '../../core/http/abort-error.js';
 import { getClient } from '../../core/runtime/client.js';
+import { extractGatewayErrorDetails, unwrapError } from '../../core/turns/errors.js';
 import { notifySessionError, notifyTaskComplete } from '../../platform/ui.js';
 import { runtimeKeys } from '../use-opencode-sessions/index.js';
-import { patchBeeuniSessionTitleMirrors, readSessionInfo, realRuntimeTitle, refetchBeeuniSessionMirrors, } from './helpers.js';
+import { notificationSessionId, 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);
@@ -146,6 +147,11 @@ function handleSessionCompaction(event, ctx) {
             break;
     }
 }
+function notifyTurnEnd(ctx, runtimeId, notify) {
+    const id = notificationSessionId(ctx.queryClient, ctx.projectId, ctx.sessionId, runtimeId);
+    if (id)
+        notify(id);
+}
 function handleSessionCompletion(event, ctx, statusBeforeEvent) {
     const { reconcileTail, getSessionTitle, invalidateWorkspaceFilesAfterTurn } = ctx;
     switch (event.type) {
@@ -164,7 +170,7 @@ function handleSessionCompletion(event, ctx, statusBeforeEvent) {
                     void reconcileTail(sessionID, 'turn-end');
                 const prevStatus = statusBeforeEvent;
                 if (status.type === 'idle' && prevStatus && prevStatus.type !== 'idle') {
-                    notifyTaskComplete(sessionID, getSessionTitle(sessionID));
+                    notifyTurnEnd(ctx, sessionID, (id) => notifyTaskComplete(id, getSessionTitle(sessionID)));
                     invalidateWorkspaceFilesAfterTurn();
                 }
             }
@@ -176,7 +182,7 @@ function handleSessionCompletion(event, ctx, statusBeforeEvent) {
                 void reconcileTail(sessionID, 'turn-end');
                 const prevStatus = statusBeforeEvent;
                 if (prevStatus && prevStatus.type !== 'idle') {
-                    notifyTaskComplete(sessionID, getSessionTitle(sessionID));
+                    notifyTurnEnd(ctx, sessionID, (id) => notifyTaskComplete(id, getSessionTitle(sessionID)));
                     invalidateWorkspaceFilesAfterTurn();
                 }
             }
@@ -195,11 +201,10 @@ function handleSessionFailure(event, ctx) {
                 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 errorTitle = extractGatewayErrorDetails(error)?.message || unwrapError(error);
+                if (!isAbortError(error)) {
+                    notifyTurnEnd(ctx, sessionID, (id) => notifySessionError(id, errorTitle, getSessionTitle(sessionID)));
+                }
                 const key = runtimeKeys.runtimeMessages(sessionID);
                 queryClient.cancelQueries({ queryKey: key });
                 queryClient.setQueryData(key, (old) => {

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

@@ -19,6 +19,7 @@ export type HandlerContext = {
     reconcileSessionTail?: (sessionID: string, reason: SessionSyncReason) => Promise<void>;
     userPartsGraceMs?: number;
     projectId?: string | null;
+    sessionId?: string | null;
 } & {
     reconcileTail: (sessionID: string, reason: import('../../core/session-sync/session-sync-controller.js').SessionSyncReason) => Promise<void>;
     getSessionTitle: (sessionID: string) => string | undefined;

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

@@ -25,3 +25,4 @@ export declare function scheduleProjectMetadataRefetch(queryClient: QueryClient)
 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;
+export declare function notificationSessionId(queryClient: QueryClient, projectId: string | null | undefined, streamSessionId: string | null | undefined, runtimeId: string, subAgentAsStream?: boolean): string | null;

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

@@ -1,7 +1,7 @@
 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';
+import { findCachedProjectSession, updateCachedProjectSessions } from '../session-cache-write.js';
 export const WIRE_STATUS_FILL_FRESHNESS_MS = STREAM_OBSERVATION_MAX_MS;
 export function shouldSkipStatusFill(input) {
     if (!input.hasSlot)
@@ -124,3 +124,13 @@ export function patchBeeuniSessionTitleMirrors(queryClient, projectId, nativeSes
         return changed ? next : rows;
     });
 }
+export function notificationSessionId(queryClient, projectId, streamSessionId, runtimeId, subAgentAsStream = false) {
+    if (!streamSessionId)
+        return runtimeId;
+    const row = projectId
+        ? findCachedProjectSession(queryClient, projectId, (session) => (session.runtime_session_id ?? session.opencode_session_id) === runtimeId)
+        : undefined;
+    if (row)
+        return row.session_id;
+    return subAgentAsStream ? streamSessionId : null;
+}

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

@@ -101,6 +101,7 @@ export function useRuntimeEventStream(options = {}) {
             fetchLspDiagnosticsDebounced,
             reconcileSessionTail: reconcileSessionTailFromRegistry,
             projectId,
+            sessionId: options.projectId && options.sessionId ? options.sessionId : null,
         });
         const hydrate = (options) => hydrateCore({
             client,

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

@@ -11,6 +11,10 @@ export interface UseRuntimeLocalOptions {
     defaultAgentName?: string | null;
     freeTier?: boolean;
     resolveServerDefault?: (agentName: string | undefined) => ModelKey | undefined;
+    projectSession?: {
+        metadata?: Record<string, unknown> | null;
+    } | null;
+    lastPromptModel?: ModelKey;
 }
 export interface RuntimeLocalAgent {
     current: Agent | undefined;
@@ -64,7 +68,7 @@ export declare function resolveCurrentAgentName(input: {
     explicitAgentName?: string;
     lastAgentName?: string;
 }): string | undefined;
-export declare function useRuntimeLocal({ agents: rawAgents, providers, config, sessionId, boundAgentName, defaultAgentName, resolveServerDefault, }: UseRuntimeLocalOptions): RuntimeLocal;
+export declare function useRuntimeLocal({ agents: rawAgents, providers, config, sessionId, boundAgentName, defaultAgentName, resolveServerDefault, projectSession, lastPromptModel, }: UseRuntimeLocalOptions): RuntimeLocal;
 export type UseOpenCodeLocalOptions = UseRuntimeLocalOptions;
 export type OpenCodeLocalAgent = RuntimeLocalAgent;
 export type OpenCodeLocalModel = RuntimeLocalModel;

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

@@ -1,7 +1,7 @@
 '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 { resolveComposerModel, sessionModelCandidates } 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';
@@ -65,7 +65,7 @@ export function resolveCurrentAgentName(input) {
         defaultAgentName ??
         (input.sessionId ? undefined : input.lastAgentName));
 }
-export function useRuntimeLocal({ agents: rawAgents, providers, config, sessionId, boundAgentName, defaultAgentName, resolveServerDefault, }) {
+export function useRuntimeLocal({ agents: rawAgents, providers, config, sessionId, boundAgentName, defaultAgentName, resolveServerDefault, projectSession, lastPromptModel, }) {
     const providerMode = useMemo(() => modelProviderMode(providers), [providers]);
     const flatModels = useMemo(() => flattenModels(providers, { providerMode }), [providers, providerMode]);
     const projectId = useBeeuniRouteProjectId();
@@ -119,11 +119,23 @@ export function useRuntimeLocal({ agents: rawAgents, providers, config, sessionI
         return visibleAgents[0];
     }, [visibleAgents, currentAgentName]);
     const agentModelSlotKey = useMemo(() => agentScopedModelSelectionKey(providerMode, currentAgent?.name), [providerMode, currentAgent?.name]);
+    const sessionModels = useMemo(() => sessionModelCandidates({
+        session: projectSession,
+        lastPromptModel,
+        gatewayEnabled: providerMode === 'gateway',
+    }), [
+        projectSession?.metadata?.opencode_model,
+        projectSession?.metadata?.opencode_model_source,
+        lastPromptModel?.providerID,
+        lastPromptModel?.modelID,
+        providerMode,
+    ]);
     const modelResolution = useMemo(() => resolveComposerModel({
         models: flatModels,
         picks: [
             scopedSessionModelKey ? modelStore.getSessionModel(scopedSessionModelKey) : undefined,
             sessionId ? modelStore.getSessionModel(sessionId) : undefined,
+            ...sessionModels,
             modelStore.getSelectedModel(agentModelSlotKey),
             currentAgent ? modelStore.getSelectedModel(currentAgent.name) : undefined,
         ],
@@ -140,6 +152,7 @@ export function useRuntimeLocal({ agents: rawAgents, providers, config, sessionI
         agentModelSlotKey,
         currentAgent,
         resolveServerDefault,
+        sessionModels,
         config?.model,
         providers,
         modelStore,

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

@@ -1,5 +1,15 @@
 import type { Command } from '../../core/runtime/runtime-types.js';
-export declare function useRuntimeCommands(): import("@tanstack/react-query").UseQueryResult<Command[], Error>;
+export declare function useRuntimeCommands(options?: UseRuntimeCommandsOptions): import("@tanstack/react-query").UseQueryResult<Command[], Error>;
+export interface UseRuntimeCommandsOptions {
+    agent?: string;
+}
+export declare class CommandNotEnabledError extends Error {
+    readonly command: string;
+    readonly agent: string;
+    readonly status = 403;
+    readonly code = "command_not_enabled";
+    constructor(command: string, agent: string);
+}
 export interface ExecuteRuntimeCommandInput {
     sessionId: string;
     command: string;

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

@@ -4,7 +4,8 @@ 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() {
+export function useRuntimeCommands(options = {}) {
+    const { agent } = options;
     const runtimeReady = useRuntimeReady();
     const supported = useRuntimeSupports('session.commands');
     return useQuery({
@@ -14,11 +15,26 @@ export function useRuntimeCommands() {
             const result = await client.command.list();
             return asRuntimeList(unwrap(result));
         },
+        select: agent
+            ? (commands) => commands.filter((command) => !command.agents || command.agents.includes(agent))
+            : undefined,
         enabled: runtimeReady && supported,
         staleTime: Infinity,
         gcTime: 10 * 60 * 1000,
     });
 }
+export class CommandNotEnabledError extends Error {
+    command;
+    agent;
+    status = 403;
+    code = 'command_not_enabled';
+    constructor(command, agent) {
+        super(`The agent "${agent}" cannot run /${command}.`);
+        this.command = command;
+        this.agent = agent;
+        this.name = 'CommandNotEnabledError';
+    }
+}
 export async function executeRuntimeCommand({ sessionId, command, args, agent, model, variant, }) {
     const client = getClient();
     const result = await client.session.command({
@@ -29,6 +45,10 @@ export async function executeRuntimeCommand({ sessionId, command, args, agent, m
         ...(model ? { model } : {}),
         ...(variant ? { variant } : {}),
     });
+    const body = result.error;
+    if (result.response?.status === 403 && body?.error === 'command_not_enabled') {
+        throw new CommandNotEnabledError(String(body.command ?? command), String(body.agent ?? agent ?? ''));
+    }
     unwrap(result);
 }
 export function useExecuteRuntimeCommand() {

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

@@ -1,10 +1,37 @@
 import { getClient } from '../../core/runtime/client.js';
 import { unwrap } from './shared.js';
-export async function replyToPermission(requestId, reply, message) {
+const repliesInFlight = new Map();
+function permissionAlreadyAnswered(result) {
+    if (result.response?.status !== 404)
+        return false;
+    const err = result.error;
+    if (typeof err === 'string') {
+        return err.toLowerCase().includes('permission request not found');
+    }
+    if (!err || typeof err !== 'object')
+        return false;
+    const rec = err;
+    const data = rec.data && typeof rec.data === 'object' ? rec.data : undefined;
+    const message = data?.message ?? rec.message ?? rec.error ?? '';
+    return String(message).toLowerCase().includes('permission request not found');
+}
+async function sendPermissionReply(requestId, reply, message) {
     const client = getClient();
     const result = await client.permission.reply({ requestID: requestId, reply, message });
+    if (permissionAlreadyAnswered(result))
+        return;
     unwrap(result);
 }
+export async function replyToPermission(requestId, reply, message) {
+    const inFlight = repliesInFlight.get(requestId);
+    if (inFlight)
+        return inFlight;
+    const send = sendPermissionReply(requestId, reply, message).finally(() => {
+        repliesInFlight.delete(requestId);
+    });
+    repliesInFlight.set(requestId, send);
+    return send;
+}
 const KNOWN_PERMISSION_TYPES = [
     'bash',
     'edit',

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

@@ -9,7 +9,7 @@ export declare function shouldScanPastEmptySessionPages(data: {
     pages: ProjectSessionPage[];
     pageParams: unknown[];
 } | undefined, hasNextPage: boolean): boolean;
-export interface UseProjectSessionsOptions extends Pick<ListProjectSessionsOptions, 'scope' | 'limit' | 'parent' | 'startedBy' | 'q' | 'labels'> {
+export interface UseProjectSessionsOptions extends Pick<ListProjectSessionsOptions, 'scope' | 'limit' | 'parent' | 'startedBy' | 'q' | 'labels' | 'view'> {
     enabled?: boolean;
     refetchInterval?: number | false | ((sessions: ProjectSession[]) => number | false);
     refetchOnWindowFocus?: boolean;

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

@@ -31,9 +31,9 @@ export function shouldScanPastEmptySessionPages(data, hasNextPage) {
 }
 export function useProjectSessions(projectId, options) {
     const scope = options?.scope ?? 'visible';
-    const { parent, startedBy, q, labels } = options ?? {};
+    const { parent, startedBy, q, labels, view } = options ?? {};
     const query = useInfiniteQuery({
-        queryKey: qk.project.sessionsPaged(projectId, scope, { parent, startedBy, q, labels }),
+        queryKey: qk.project.sessionsPaged(projectId, scope, { parent, startedBy, q, labels, view }),
         initialPageParam: null,
         queryFn: ({ pageParam }) => listProjectSessionsPage(projectId, {
             scope,
@@ -43,6 +43,7 @@ export function useProjectSessions(projectId, options) {
             startedBy,
             q,
             labels,
+            view,
         }),
         getNextPageParam: projectSessionsPageParam,
         enabled: options?.enabled ?? true,
@@ -55,12 +56,12 @@ export function useProjectSessions(projectId, options) {
             return interval(flattenProjectSessionPages(query.state.data));
         },
     });
-    const isScanning = shouldScanPastEmptySessionPages(query.data, query.hasNextPage);
-    const { isFetching, fetchNextPage } = query;
+    const isScanning = shouldScanPastEmptySessionPages(query.data, query.hasNextPage) && !query.isError;
+    const { isFetching, data, dataUpdatedAt, fetchNextPage } = query;
     useEffect(() => {
         if (isScanning && !isFetching)
             void fetchNextPage();
-    }, [isScanning, isFetching, fetchNextPage]);
+    }, [isScanning, isFetching, data, dataUpdatedAt, fetchNextPage]);
     return {
         ...query,
         isScanning,

package/dist/react/use-prompt-attachments.js

@@ -22,6 +22,7 @@ export function usePromptAttachments(projectId, options = {}) {
     return useMemo(() => ({
         add: controller.add,
         addMany: controller.addMany,
+        restore: controller.restore,
         retry: controller.retry,
         remove: controller.remove,
         abort: controller.abort,

package/dist/react/use-review-summary.d.ts

@@ -0,0 +1,13 @@
+import { type ApiReviewItem, type ReviewItemsPage, type ReviewItemsQuery } from '../core/rest/projects-client/index.js';
+export declare function useReviewSummary(projectId: string, options?: {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}): import("@tanstack/react-query").UseQueryResult<import("../index.js").ReviewSummary, Error>;
+export declare function nextReviewItemsCursor(page: ReviewItemsPage): string | undefined;
+export declare function reviewItemsOf(data: {
+    pages: ReadonlyArray<Pick<ReviewItemsPage, 'review_items'>>;
+} | undefined): ApiReviewItem[];
+export declare function useReviewItemPages(projectId: string, query?: ReviewItemsQuery, options?: {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/react-query").InfiniteData<ReviewItemsPage, unknown>, Error>;

package/dist/react/use-review-summary.js

@@ -0,0 +1,32 @@
+'use client';
+import { useInfiniteQuery, useQuery } from '@tanstack/react-query';
+import { getReviewSummary, listReviewItems, } from '../core/rest/projects-client/index.js';
+import { qk } from './query-keys.js';
+export function useReviewSummary(projectId, options) {
+    const enabled = Boolean(projectId) && options?.enabled !== false;
+    return useQuery({
+        queryKey: qk.project.reviewSummary(projectId),
+        queryFn: () => getReviewSummary(projectId),
+        enabled,
+        staleTime: 5_000,
+        refetchInterval: enabled ? (options?.refetchInterval ?? 60_000) : false,
+        refetchOnWindowFocus: false,
+    });
+}
+export function nextReviewItemsCursor(page) {
+    return page.next_cursor ?? undefined;
+}
+export function reviewItemsOf(data) {
+    return data?.pages.flatMap((page) => page.review_items) ?? [];
+}
+export function useReviewItemPages(projectId, query = {}, options) {
+    return useInfiniteQuery({
+        queryKey: qk.project.reviewItemPages(projectId, query),
+        queryFn: ({ pageParam }) => listReviewItems(projectId, { ...query, cursor: pageParam }),
+        initialPageParam: undefined,
+        getNextPageParam: nextReviewItemsCursor,
+        enabled: Boolean(projectId) && options?.enabled !== false,
+        staleTime: 5_000,
+        refetchInterval: options?.refetchInterval ?? false,
+    });
+}

package/dist/react/use-runtime-reconnect.js

@@ -1,6 +1,6 @@
 'use client';
 import { useEffect, useRef } from 'react';
-import { getSupabaseAccessToken } from '../core/http/auth.js';
+import { getAuthToken as getSupabaseAccessToken } from '../core/http/auth.js';
 import { CONNECTION_FAULT_GRACE_MS, getSessionHealth, isRuntimeReady, } from '../core/session/index.js';
 import { incrementSandboxFail, markInitialCheckDone, resetForServerSwitch, resetSandboxFail, setRuntimeHealth, setRuntimeCapabilities, setSandboxStatus, useSandboxConnectionStore, } from '../browser/stores/sandbox-connection-store.js';
 import { useServerStore } from '../browser/stores/server-store.js';

package/dist/react/use-session-list-state.d.ts

@@ -0,0 +1,6 @@
+import { type SessionListState } from '../core/rest/projects-client/sessions.js';
+export declare function useSessionListState(projectId: string): {
+    isPending: boolean;
+    setPinned: (sessionId: string, pinned: boolean) => Promise<SessionListState>;
+    setArchived: (sessionId: string, archived: boolean) => Promise<SessionListState>;
+};

package/dist/react/use-session-list-state.js

@@ -0,0 +1,33 @@
+'use client';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { setSessionArchived, setSessionPinned, } from '../core/rest/projects-client/sessions.js';
+import { qk } from './query-keys.js';
+import { updateCachedProjectSessions } from './session-cache-write.js';
+function changedState(session, change, now) {
+    if ('pinned' in change) {
+        return { pinned_at: change.pinned ? (session.pinned_at ?? now) : null, archived_at: change.pinned ? null : (session.archived_at ?? null) };
+    }
+    return { archived_at: change.archived ? (session.archived_at ?? now) : null, pinned_at: change.archived ? null : (session.pinned_at ?? null) };
+}
+export function useSessionListState(projectId) {
+    const client = useQueryClient();
+    const write = (sessionId, state) => updateCachedProjectSessions(client, projectId, (sessions) => sessions.map((session) => (session.session_id === sessionId ? { ...session, ...state(session) } : session)));
+    const mutation = useMutation({
+        mutationFn: ({ sessionId, change }) => 'pinned' in change
+            ? setSessionPinned(projectId, sessionId, change.pinned)
+            : setSessionArchived(projectId, sessionId, change.archived),
+        onMutate: ({ sessionId, change }) => {
+            const now = new Date().toISOString();
+            write(sessionId, (session) => changedState(session, change, now));
+        },
+        onSuccess: (state, { sessionId }) => write(sessionId, () => state),
+        onSettled: () => client.invalidateQueries({ queryKey: [...qk.project.sessionsScope(projectId), 'list-paged'] }),
+    });
+    const { mutateAsync, isPending } = mutation;
+    const actions = useMemo(() => ({
+        setPinned: (sessionId, pinned) => mutateAsync({ sessionId, change: { pinned } }),
+        setArchived: (sessionId, archived) => mutateAsync({ sessionId, change: { archived } }),
+    }), [mutateAsync]);
+    return { ...actions, isPending };
+}

package/dist/react/use-session-log.d.ts

@@ -0,0 +1,16 @@
+import { type SessionControlStreamOptions } from '../core/session/control-stream.js';
+import { type LoadSessionLogPage, type SessionLogDialect } from '../core/session-log/source.js';
+import type { SessionLog, SessionLogThread } from '../core/session-log/types.js';
+import { type SessionMessagesOptions, type SessionMessagesSource } from './use-session-messages.js';
+export declare function useSessionLog(session: SessionMessagesSource): (SessionLog & {
+    source: 'v1' | 'v2';
+}) | null;
+export declare function useSessionLogRecord(session: Pick<SessionMessagesSource, 'sessionId'>): Partial<Omit<SessionLog, 'threads'>> | null;
+export declare function useSessionLogThread(session: SessionMessagesSource, threadId?: string | null, options?: SessionMessagesOptions): SessionLogThread | null;
+export declare function useSessionLogSync(projectId: string, sessionId: string, options: {
+    enabled: boolean;
+    loader?: LoadSessionLogPage | null;
+    joinStream?: (options: SessionControlStreamOptions) => {
+        close: () => void;
+    };
+}): SessionLogDialect;