@beeuni/sdk 0.2.0 → 0.3.0

package/dist/react/turn-end-handoff.js

@@ -0,0 +1,101 @@
+'use client';
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect, useRef } from 'react';
+import { getSessionTurn } from '../core/rest/projects-client/sessions.js';
+import { openSessionStream, sessionStreamConnected } from '../core/session/control-stream.js';
+import { createTurnEndWatch, } from '../core/session/turn-end-watch.js';
+import { unwrapError } from '../core/turns/errors.js';
+import { hasNotifySink, notifySessionError, notifyTaskComplete } from '../platform/ui.js';
+import { registerIdentityReset } from './identity-reset-registry.js';
+import { findCachedProjectSession } from './session-cache-write.js';
+import { realRuntimeTitle } from './use-opencode-events/helpers.js';
+import { runtimeKeys } from './use-opencode-sessions/index.js';
+let watch = null;
+let overrides = null;
+function announce(...[handoff, outcome, watchedSinceMs]) {
+    const title = handoff.title?.();
+    if (outcome.kind === 'completed') {
+        notifyTaskComplete(handoff.sessionId, title, { watchedSinceMs, projectId: handoff.projectId });
+    }
+    else if (outcome.kind === 'failed') {
+        notifySessionError(handoff.sessionId, unwrapError(outcome.error), title, {
+            projectId: handoff.projectId,
+        });
+    }
+}
+function subscribeTurnFrames(projectId, sessionId, onRead) {
+    const handle = openSessionStream({
+        projectId,
+        sessionId,
+        onControl: (frame) => {
+            if (frame.type !== 'beeuni.control.turn')
+                return;
+            const payload = frame.payload;
+            if (!payload?.known || !Array.isArray(payload.turns))
+                return;
+            onRead({
+                turns: payload.turns,
+                ...(payload.last_ended ? { last_ended: payload.last_ended } : {}),
+                ...(payload.recent_failures ? { recent_failures: payload.recent_failures } : {}),
+            });
+        },
+    });
+    return () => handle.close();
+}
+function turnEndWatch() {
+    watch ??= createTurnEndWatch({
+        readTurn: (projectId, sessionId) => getSessionTurn(projectId, sessionId, { showErrors: false }),
+        subscribe: subscribeTurnFrames,
+        pushLive: sessionStreamConnected,
+        onEnded: announce,
+        ...overrides,
+    });
+    return watch;
+}
+registerIdentityReset(() => watch?.releaseAll());
+export function resetTurnEndHandoffForTests(deps) {
+    overrides = deps ?? null;
+    watch = null;
+}
+export function turnEndHandoffWatching() {
+    return watch?.watching() ?? [];
+}
+function sessionTitle(queryClient, projectId, sessionId, runtimeSessionId) {
+    const row = findCachedProjectSession(queryClient, projectId, (session) => session.session_id === sessionId);
+    const named = row?.custom_name || row?.name;
+    if (named)
+        return named;
+    if (!runtimeSessionId)
+        return undefined;
+    const runtime = queryClient.getQueryData(runtimeKeys.runtimeSession(runtimeSessionId)) ??
+        queryClient.getQueryData(runtimeKeys.sessions())?.find((s) => s.id === runtimeSessionId);
+    return realRuntimeTitle(runtime?.title) ?? undefined;
+}
+export function useTurnEndHandoff(input) {
+    const queryClient = useQueryClient();
+    const latest = useRef(input);
+    useEffect(() => {
+        latest.current = input;
+    });
+    const { enabled, projectId, sessionId } = input;
+    useEffect(() => {
+        if (!enabled || !projectId || !sessionId)
+            return;
+        watch?.release(projectId, sessionId);
+        return () => {
+            const last = latest.current;
+            if (!last.working || last.projectId !== projectId || last.sessionId !== sessionId)
+                return;
+            if (!hasNotifySink())
+                return;
+            const runtimeSessionId = last.runtimeSessionId;
+            turnEndWatch().watch({
+                projectId,
+                sessionId,
+                openTurnToken: last.openTurnToken,
+                lastEndedToken: last.lastEndedToken,
+                title: () => sessionTitle(queryClient, projectId, sessionId, runtimeSessionId),
+            });
+        };
+    }, [enabled, projectId, sessionId, queryClient]);
+}

package/dist/react/use-admin-providers.d.ts

@@ -1,4 +1,3 @@
-import { type AdminBootModePolicy } from '../core/rest/projects-client/admin-providers.js';
 export declare function useAdminProviderDistribution(): import("@tanstack/react-query").UseQueryResult<import("../internal/platform-admin.js").AdminProviderDistribution, Error>;
 export declare function useAdminProviderSandboxes(): import("@tanstack/react-query").UseQueryResult<import("../internal/platform-admin.js").AdminProviderSandboxesResponse, Error>;
 export declare function useAdminProviderAnalytics(days: number, enabled: boolean): import("@tanstack/react-query").UseQueryResult<import("../internal/platform-admin.js").AdminProviderAnalytics, Error>;
@@ -16,5 +15,3 @@ export interface AdminProviderMigrationVariables {
 export declare function useSetAdminProviderDistribution(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, Record<string, number>, unknown>;
 export declare function useMigrateAdminSandboxProvider(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, AdminProviderMigrationVariables, unknown>;
 export declare function useSetAdminProviderFallback(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, boolean, unknown>;
-export declare function useAdminBootModes(): import("@tanstack/react-query").UseQueryResult<import("../internal/platform-admin.js").AdminBootModes, Error>;
-export declare function useSetAdminBootModes(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<import("../internal/platform-admin.js").AdminBootModes, Error, AdminBootModePolicy, unknown>;

package/dist/react/use-admin-providers.js

@@ -1,5 +1,5 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { getAdminProviderDistribution, listAdminSandboxes, getAdminProviderAnalytics, getAdminProviderFallback, setAdminProviderDistribution, migrateAdminSandboxProvider, setAdminProviderFallback, getAdminBootModes, setAdminBootModes } from '../core/rest/projects-client/admin-providers.js';
+import { getAdminProviderDistribution, listAdminSandboxes, getAdminProviderAnalytics, getAdminProviderFallback, setAdminProviderDistribution, migrateAdminSandboxProvider, setAdminProviderFallback } from '../core/rest/projects-client/admin-providers.js';
 export function useAdminProviderDistribution() {
     return useQuery({ queryKey: ['admin', 'provider-distribution'], queryFn: () => getAdminProviderDistribution() });
 }
@@ -33,13 +33,3 @@ export function useSetAdminProviderFallback(options = {}) {
             void qc.invalidateQueries({ queryKey: ['admin', 'provider-fallback'] });
         } });
 }
-export function useAdminBootModes() {
-    return useQuery({ queryKey: ['admin', 'boot-modes'], queryFn: () => getAdminBootModes(), refetchInterval: 30_000 });
-}
-export function useSetAdminBootModes(options = {}) {
-    const qc = useQueryClient();
-    return useMutation({ mutationFn: (policy) => setAdminBootModes(policy), onError: options.onError, onSuccess: (data) => {
-            options.onSuccess?.();
-            qc.setQueryData(['admin', 'boot-modes'], data);
-        } });
-}

package/dist/react/use-capture.d.ts

@@ -0,0 +1,47 @@
+import { type CaptureEnrollmentStatus, type CaptureEnrollmentTokenInput, type CaptureDaysQuery, type CapturePolicy, type CaptureSearchQuery, type CaptureWindowQuery } from '../core/rest/platform-client/capture.js';
+export declare function useCaptureDeviceGrant(userCode: string | null | undefined): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureDeviceGrantDetail, Error>;
+export declare function useApproveCaptureDevice(): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureDeviceGrant, Error, {
+    userCode: string;
+    accountId?: string;
+}, unknown>;
+export declare function useDenyCaptureDevice(): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureDeviceGrant, Error, string, unknown>;
+type AccountId = string | null | undefined;
+export declare function useCaptureDevices(accountId: AccountId, opts?: {
+    scope?: 'mine' | 'account';
+    userId?: string;
+}): import("@tanstack/react-query").UseQueryResult<{
+    devices: import("../index.js").CaptureDevice[];
+    health: import("../index.js").CaptureHealthSummary;
+}, Error>;
+export declare function useRevokeCaptureDevice(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureDevice, Error, string, unknown>;
+export declare function useCaptureDays(accountId: AccountId, query?: CaptureDaysQuery): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureDays, Error>;
+export declare function useCaptureTimeline(accountId: AccountId, query: CaptureWindowQuery | null): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureTimeline, Error>;
+export declare function useCaptureTimelineItems(accountId: AccountId, query: CaptureWindowQuery | null): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureTimelineItems, Error>;
+export declare function useCaptureSearch(accountId: AccountId, query: CaptureSearchQuery | null): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureSearchResult, Error>;
+export declare function useCaptureChunkMedia(accountId: AccountId, chunkId: string | null | undefined, opts?: {
+    userId?: string;
+}): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureChunkMedia, Error>;
+export declare function useCaptureEnrollmentTokens(accountId: AccountId): import("@tanstack/react-query").UseQueryResult<{
+    tokens: import("../index.js").CaptureEnrollmentToken[];
+}, Error>;
+export declare function useCreateCaptureEnrollmentToken(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureEnrollmentTokenSecret, Error, CaptureEnrollmentTokenInput, unknown>;
+export declare function useRevokeCaptureEnrollmentToken(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureEnrollmentToken, Error, string, unknown>;
+export declare function useCaptureEnrollments(accountId: AccountId, opts?: {
+    status?: CaptureEnrollmentStatus;
+}): import("@tanstack/react-query").UseQueryResult<{
+    enrollments: import("../index.js").CaptureEnrollment[];
+}, Error>;
+export declare function useApproveCaptureEnrollment(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureEnrollment, Error, {
+    enrollmentId: string;
+    userId?: string | null;
+}, unknown>;
+export declare function useDenyCaptureEnrollment(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureEnrollment, Error, string, unknown>;
+export declare function useLinkCaptureDevice(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureDevice, Error, {
+    deviceId: string;
+    userId: string | null;
+}, unknown>;
+export declare function useCapturePolicy(accountId: AccountId): import("@tanstack/react-query").UseQueryResult<import("../index.js").CapturePolicyRecord, Error>;
+export declare function useSetCapturePolicy(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CapturePolicyRecord, Error, CapturePolicy, unknown>;
+export declare function useCaptureWorkspace(accountId: AccountId): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureWorkspace, Error>;
+export declare function useSetCaptureEnabled(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureWorkspace, Error, boolean, unknown>;
+export {};

package/dist/react/use-capture.js

@@ -0,0 +1,173 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { approveCaptureDeviceGrant, approveCaptureEnrollment, createCaptureEnrollmentToken, denyCaptureEnrollment, listCaptureEnrollments, listCaptureEnrollmentTokens, linkCaptureDevice, revokeCaptureEnrollmentToken, denyCaptureDeviceGrant, getCaptureChunkMedia, getCaptureDays, getCaptureDeviceGrant, getCapturePolicy, getCaptureTimeline, getCaptureTimelineItems, getCaptureWorkspace, listCaptureDevices, revokeCaptureDevice, searchCapture, setCaptureEnabled, setCapturePolicy, } from '../core/rest/platform-client/capture.js';
+import { contract, FRESHNESS } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function useCaptureDeviceGrant(userCode) {
+    return useQuery({
+        queryKey: qk.capture.deviceGrant(userCode ?? ''),
+        queryFn: () => getCaptureDeviceGrant(userCode),
+        enabled: !!userCode,
+        ...contract('volatile'),
+    });
+}
+export function useApproveCaptureDevice() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (args) => approveCaptureDeviceGrant(args.userCode, args.accountId),
+        onSuccess: (grant, args) => queryClient.setQueryData(qk.capture.deviceGrant(args.userCode), grant),
+    });
+}
+export function useDenyCaptureDevice() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (userCode) => denyCaptureDeviceGrant(userCode),
+        onSuccess: (grant, userCode) => queryClient.setQueryData(qk.capture.deviceGrant(userCode), grant),
+    });
+}
+export function useCaptureDevices(accountId, opts = {}) {
+    return useQuery({
+        queryKey: qk.capture.devices(accountId ?? '', opts.scope ?? 'mine', opts.userId ?? null),
+        queryFn: () => listCaptureDevices(accountId, opts),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureDevices),
+    });
+}
+export function useRevokeCaptureDevice(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (deviceId) => revokeCaptureDevice(accountId, deviceId),
+        onSuccess: () => queryClient.invalidateQueries({ queryKey: qk.capture.account(accountId ?? '') }),
+    });
+}
+export function useCaptureDays(accountId, query = {}) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'days', query),
+        queryFn: () => getCaptureDays(accountId, query),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureTimeline),
+    });
+}
+export function useCaptureTimeline(accountId, query) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'runs', query),
+        queryFn: () => getCaptureTimeline(accountId, query ?? undefined),
+        enabled: !!accountId && !!query,
+        ...contract(FRESHNESS.captureTimeline),
+    });
+}
+export function useCaptureTimelineItems(accountId, query) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'items', query),
+        queryFn: () => getCaptureTimelineItems(accountId, query ?? undefined),
+        enabled: !!accountId && !!query,
+        ...contract(FRESHNESS.captureTimeline),
+    });
+}
+export function useCaptureSearch(accountId, query) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'search', query),
+        queryFn: () => searchCapture(accountId, query),
+        enabled: !!accountId && !!query?.q.trim(),
+        ...contract(FRESHNESS.captureTimeline),
+    });
+}
+export function useCaptureChunkMedia(accountId, chunkId, opts = {}) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'media', { chunkId, userId: opts.userId ?? null }),
+        queryFn: () => getCaptureChunkMedia(accountId, chunkId, opts),
+        enabled: !!accountId && !!chunkId,
+        ...contract(FRESHNESS.captureTimeline),
+        staleTime: 240_000,
+        refetchInterval: 240_000,
+    });
+}
+export function useCaptureEnrollmentTokens(accountId) {
+    return useQuery({
+        queryKey: qk.capture.enrollmentTokens(accountId ?? ''),
+        queryFn: () => listCaptureEnrollmentTokens(accountId),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureEnrollmentTokens),
+    });
+}
+export function useCreateCaptureEnrollmentToken(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => createCaptureEnrollmentToken(accountId, input),
+        onSuccess: () => void queryClient.invalidateQueries({ queryKey: qk.capture.enrollmentTokens(accountId ?? '') }),
+    });
+}
+export function useRevokeCaptureEnrollmentToken(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (tokenId) => revokeCaptureEnrollmentToken(accountId, tokenId),
+        onSuccess: () => void queryClient.invalidateQueries({ queryKey: qk.capture.enrollmentTokens(accountId ?? '') }),
+    });
+}
+export function useCaptureEnrollments(accountId, opts = {}) {
+    return useQuery({
+        queryKey: [...qk.capture.enrollments(accountId ?? ''), opts.status ?? 'all'],
+        queryFn: () => listCaptureEnrollments(accountId, opts),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureEnrollments),
+    });
+}
+function invalidateRollout(queryClient, accountId) {
+    for (const queryKey of [qk.capture.enrollments(accountId), qk.capture.enrollmentTokens(accountId), [...qk.capture.account(accountId), 'devices']]) {
+        void queryClient.invalidateQueries({ queryKey });
+    }
+}
+export function useApproveCaptureEnrollment(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (args) => approveCaptureEnrollment(accountId, args.enrollmentId, args.userId),
+        onSuccess: () => invalidateRollout(queryClient, accountId ?? ''),
+    });
+}
+export function useDenyCaptureEnrollment(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (enrollmentId) => denyCaptureEnrollment(accountId, enrollmentId),
+        onSuccess: () => invalidateRollout(queryClient, accountId ?? ''),
+    });
+}
+export function useLinkCaptureDevice(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (args) => linkCaptureDevice(accountId, args.deviceId, args.userId),
+        onSuccess: () => invalidateRollout(queryClient, accountId ?? ''),
+    });
+}
+export function useCapturePolicy(accountId) {
+    return useQuery({
+        queryKey: qk.capture.policy(accountId ?? ''),
+        queryFn: () => getCapturePolicy(accountId),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.capturePolicy),
+    });
+}
+export function useSetCapturePolicy(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (policy) => setCapturePolicy(accountId, policy),
+        onSuccess: (record) => queryClient.setQueryData(qk.capture.policy(accountId ?? ''), record),
+    });
+}
+export function useCaptureWorkspace(accountId) {
+    return useQuery({
+        queryKey: qk.capture.workspace(accountId ?? ''),
+        queryFn: () => getCaptureWorkspace(accountId),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureWorkspace),
+    });
+}
+export function useSetCaptureEnabled(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (enabled) => setCaptureEnabled(accountId, enabled),
+        onSuccess: (workspace) => {
+            queryClient.setQueryData(qk.capture.workspace(accountId ?? ''), workspace);
+            void queryClient.invalidateQueries({ queryKey: qk.capture.account(accountId ?? '') });
+        },
+    });
+}

package/dist/react/use-feature-flag.js

@@ -9,6 +9,7 @@ const GRADUATED_FEATURE_FLAG_KEYS = new Set([
     'session_transcript_history',
     'teams',
     'config_releases',
+    'apps',
 ]);
 export function useFeatureFlag(projectId, key) {
     const query = useQuery({

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-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() {