@beeuni/sdk 0.1.0 → 0.3.0

package/dist/core/client/project-operations-review.d.ts

@@ -9,9 +9,8 @@ export declare function bindProjectOperationsReview(projectId: string): {
         claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
     };
     review: {
-        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
-            review_items: P.ApiReviewItem[];
-        }>;
+        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<P.ReviewItemsPage>;
+        summary: () => Promise<P.ReviewSummary>;
         get: (reviewItemId: string) => Promise<{
             review_item: P.ApiReviewItem;
         }>;

package/dist/core/client/project-operations-review.js

@@ -10,6 +10,7 @@ export function bindProjectOperationsReview(projectId) {
         },
         review: {
             list: (params) => P.listReviewItems(projectId, params),
+            summary: () => P.getReviewSummary(projectId),
             get: (reviewItemId) => P.getReviewItem(projectId, reviewItemId),
             submit: (input) => P.submitReviewItem(projectId, input),
             act: (...a) => P.actReviewItem(projectId, ...a),

package/dist/core/client/project-operations-workspace.d.ts

@@ -8,9 +8,8 @@ export declare function bindProjectOperationsWorkspace(projectId: string): {
         claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
     };
     review: {
-        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
-            review_items: P.ApiReviewItem[];
-        }>;
+        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<P.ReviewItemsPage>;
+        summary: () => Promise<P.ReviewSummary>;
         get: (reviewItemId: string) => Promise<{
             review_item: P.ApiReviewItem;
         }>;
@@ -64,8 +63,9 @@ export declare function bindProjectOperationsWorkspace(projectId: string): {
         inviteCollaborator: (githubUsername: string, permission?: "read" | "write" | undefined) => Promise<P.RepoCollaboratorInvite>;
     };
     changeRequests: {
-        list: () => Promise<{
+        list: (status?: "all" | P.ChangeRequestStatus | undefined, options?: P.ListChangeRequestsOptions | undefined) => Promise<{
             change_requests: P.ChangeRequest[];
+            next_cursor?: string | null;
         }>;
         get: (crId: string) => Promise<P.ChangeRequestDetailResponse>;
         update: (crId: string, input: {

package/dist/core/client/project-operations-workspace.js

@@ -20,7 +20,7 @@ export function bindProjectOperationsWorkspace(projectId) {
             inviteCollaborator: (...a) => P.inviteRepoCollaborator(projectId, ...a),
         },
         changeRequests: {
-            list: () => P.listChangeRequests(projectId),
+            list: (...a) => P.listChangeRequests(projectId, ...a),
             get: (crId) => P.getChangeRequest(projectId, crId),
             update: (...a) => P.updateChangeRequest(projectId, ...a),
             diff: (crId) => P.getChangeRequestDiff(projectId, crId),

package/dist/core/client/project-operations.d.ts

@@ -9,9 +9,8 @@ export declare function bindProjectOperations(projectId: string, connections: Re
         claimWarm: (input: Parameters<typeof P.claimWarmProjectSession>[1]) => Promise<P.ProjectSession>;
     };
     review: {
-        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<{
-            review_items: P.ApiReviewItem[];
-        }>;
+        list: (params?: Parameters<typeof P.listReviewItems>[1]) => Promise<P.ReviewItemsPage>;
+        summary: () => Promise<P.ReviewSummary>;
         get: (reviewItemId: string) => Promise<{
             review_item: P.ApiReviewItem;
         }>;
@@ -65,8 +64,9 @@ export declare function bindProjectOperations(projectId: string, connections: Re
         inviteCollaborator: (githubUsername: string, permission?: "read" | "write" | undefined) => Promise<P.RepoCollaboratorInvite>;
     };
     changeRequests: {
-        list: () => Promise<{
+        list: (status?: "all" | P.ChangeRequestStatus | undefined, options?: P.ListChangeRequestsOptions | undefined) => Promise<{
             change_requests: P.ChangeRequest[];
+            next_cursor?: string | null;
         }>;
         get: (crId: string) => Promise<P.ChangeRequestDetailResponse>;
         update: (crId: string, input: {
@@ -152,6 +152,7 @@ export declare function bindProjectOperations(projectId: string, connections: Re
         }>;
         setCredential: (slug: string, credential: string | P.ConnectionCredentialInput) => Promise<{
             ok: boolean;
+            sync?: P.ConnectorSyncResult;
         }>;
         deleteCredential: (slug: string) => Promise<{
             ok: boolean;
@@ -187,8 +188,8 @@ export declare function bindProjectOperations(projectId: string, connections: Re
                 tunnelId: string;
                 share?: P.ConnectorConnectOwner;
             }) => Promise<P.Connection>;
-            pipedreamConnect: (connectionId: string, input?: P.ConnectionConnectInput | undefined) => Promise<P.ConnectorConnectResult>;
-            pipedreamFinalize: (connectionId: string) => Promise<P.ConnectorFinalizeResult>;
+            connect: (connectionId: string, input?: P.ConnectionConnectInput | undefined) => Promise<P.ConnectorConnectResult>;
+            finalize: (connectionId: string) => Promise<P.ConnectorFinalizeResult>;
         };
         policies: {
             get: (slug: string) => Promise<{
@@ -202,19 +203,8 @@ export declare function bindProjectOperations(projectId: string, connections: Re
                 sync?: P.ConnectorSyncResult;
             }>;
         };
-        pipedream: {
-            listApps: (qOrQuery?: string | P.PipedreamCatalogQuery | undefined, cursor?: string | undefined) => Promise<P.PipedreamCatalogPage>;
-            listSections: (opts?: {
-                perCategory?: number;
-                maxCategories?: number;
-            } | undefined) => Promise<{
-                sections: P.PipedreamSection[];
-                categories: P.PipedreamCategory[];
-                indexReady?: boolean;
-            }>;
-            connect: (slug: string, options?: P.ConnectorConnectOptions | undefined) => Promise<P.ConnectorConnectResult>;
-            finalize: (slug: string, options?: P.ConnectorFinalizeOptions | undefined) => Promise<P.ConnectorFinalizeResult>;
-        };
+        connect: (slug: string, options?: P.ConnectorConnectOptions | undefined) => Promise<P.ConnectorConnectResult>;
+        finalize: (slug: string, options?: P.ConnectorFinalizeOptions | undefined) => Promise<P.ConnectorFinalizeResult>;
         discover: {
             list: (qOrQuery?: string | P.DiscoverConnectorsQuery | undefined, cursor?: string | undefined) => Promise<P.DiscoverConnectorsPage>;
             sections: (opts?: {

package/dist/core/client/project-operations.js

@@ -24,12 +24,8 @@ export function bindProjectOperations(projectId, connections) {
                 get: (...a) => P.getConnectorPolicies(projectId, ...a),
                 set: (...a) => P.setConnectorPolicies(projectId, ...a),
             },
-            pipedream: {
-                listApps: (...a) => P.listPipedreamApps(projectId, ...a),
-                listSections: (...a) => P.listPipedreamSections(projectId, ...a),
-                connect: (...a) => P.pipedreamConnect(projectId, ...a),
-                finalize: (...a) => P.pipedreamFinalize(projectId, ...a),
-            },
+            connect: (...a) => P.connectorConnect(projectId, ...a),
+            finalize: (...a) => P.connectorFinalize(projectId, ...a),
             discover: {
                 list: (...a) => P.listDiscoverConnectors(projectId, ...a),
                 sections: (...a) => P.listDiscoverSections(projectId, ...a),

package/dist/core/client/project-platform-security.d.ts

@@ -33,7 +33,7 @@ export declare function bindProjectPlatformSecurity(projectId: string): {
             status: "started";
             template_id: string;
             slug: string;
-            providers?: Array<"daytona" | "platinum" | "e2b">;
+            providers?: Array<string>;
         }>;
         setProvider: (provider: Parameters<typeof P.updateProjectSandboxProvider>[1]) => Promise<P.UpdateProjectSandboxProviderResult>;
     };

package/dist/core/client/project-platform-settings.d.ts

@@ -34,7 +34,7 @@ export declare function bindProjectPlatformSettings(projectId: string): {
             status: "started";
             template_id: string;
             slug: string;
-            providers?: Array<"daytona" | "platinum" | "e2b">;
+            providers?: Array<string>;
         }>;
         setProvider: (provider: Parameters<typeof P.updateProjectSandboxProvider>[1]) => Promise<P.UpdateProjectSandboxProviderResult>;
     };

package/dist/core/client/session-context.d.ts

@@ -1,3 +1,4 @@
+import type { ProjectSession } from '../rest/projects-client/sessions.js';
 import type { ResolvedPreviewOptions } from '../session/preview-options.js';
 import type { SessionRuntimeEntry } from '../session/session-runtime-registry.js';
 import type { SessionModel } from './session-shared.js';
@@ -6,6 +7,7 @@ export type SessionBindingContext = {
     sessionId: string;
     ensureReady: (opts?: {
         readyTimeoutMs?: number;
+        session?: ProjectSession;
     }) => Promise<SessionRuntimeEntry>;
     tryResolveReady: () => SessionRuntimeEntry | null;
     requireReady: (action: string) => SessionRuntimeEntry;

package/dist/core/client/session-handle.d.ts

@@ -115,6 +115,7 @@ export declare function session(projectId: string, sessionId: string, config: Be
     messageAuthors: () => Promise<import("../../index.js").SessionMessageAuthors>;
     modelUsage: () => Promise<import("../../index.js").SessionModelUsage>;
     transcriptSync: (options?: Parameters<typeof import("../../index.js").getSessionTranscriptSync>[2]) => Promise<import("../../index.js").SessionTranscriptSyncEnvelope>;
+    log: (query?: Parameters<typeof import("../../index.js").getSessionLogPage>[2]) => Promise<import("../session-log/index.js").SessionLogPage | null>;
     turn: () => Promise<import("../../index.js").SessionTurnStatus>;
     prompts: {
         create: (input: import("../../index.js").CreateSessionPromptInput) => Promise<import("../../index.js").CreateSessionPromptResult>;
@@ -133,6 +134,7 @@ export declare function session(projectId: string, sessionId: string, config: Be
     };
     ensureReady: (opts?: {
         readyTimeoutMs?: number;
+        session?: import("../../index.js").ProjectSession;
     }) => Promise<import("../../index.js").SessionRuntimeEntry>;
     get: (opts?: {
         showErrors?: boolean;
@@ -145,11 +147,20 @@ export declare function session(projectId: string, sessionId: string, config: Be
         keepalive?: boolean;
     }) => Promise<import("../../index.js").ApiResponse<{
         ok: boolean;
+        awake_until?: string | null;
+        awake_cap_at?: string | null;
     }>>;
     cost: () => Promise<import("../../index.js").SessionCostDetail>;
     update: (input: Parameters<typeof import("../../index.js").updateProjectSession>[2]) => Promise<import("../../index.js").ProjectSession>;
     delete: () => Promise<{
         ok: boolean;
+        restore_until?: string;
+    }>;
+    restore: () => Promise<{
+        ok: boolean;
+    }>;
+    recover: () => Promise<{
+        ok: true;
     }>;
     start: (options?: (number | {
         waitMs?: number;
@@ -192,6 +203,8 @@ export declare function session(projectId: string, sessionId: string, config: Be
     setWatch: (watching: boolean) => Promise<{
         watching: boolean;
     }>;
+    setPinned: (pinned: boolean) => Promise<import("../../index.js").SessionListState>;
+    setArchived: (archived: boolean) => Promise<import("../../index.js").SessionListState>;
     commit: (input?: Parameters<typeof import("../../index.js").commitSessionChanges>[2]) => Promise<import("../../index.js").CommitSessionResult>;
     publicShares: {
         list: () => Promise<{

package/dist/core/client/session-lifecycle-resources.d.ts

@@ -13,11 +13,20 @@ export declare function bindSessionLifecycleResources(ctx: SessionBindingContext
         keepalive?: boolean;
     }) => Promise<import("../../index.js").ApiResponse<{
         ok: boolean;
+        awake_until?: string | null;
+        awake_cap_at?: string | null;
     }>>;
     cost: () => Promise<P.SessionCostDetail>;
     update: (input: Parameters<typeof P.updateProjectSession>[2]) => Promise<P.ProjectSession>;
     delete: () => Promise<{
         ok: boolean;
+        restore_until?: string;
+    }>;
+    restore: () => Promise<{
+        ok: boolean;
+    }>;
+    recover: () => Promise<{
+        ok: true;
     }>;
     start: (options?: (number | {
         waitMs?: number;
@@ -60,6 +69,8 @@ export declare function bindSessionLifecycleResources(ctx: SessionBindingContext
     setWatch: (watching: boolean) => Promise<{
         watching: boolean;
     }>;
+    setPinned: (pinned: boolean) => Promise<P.SessionListState>;
+    setArchived: (archived: boolean) => Promise<P.SessionListState>;
     commit: (input?: Parameters<typeof P.commitSessionChanges>[2]) => Promise<P.CommitSessionResult>;
     publicShares: {
         list: () => Promise<{

package/dist/core/client/session-lifecycle-resources.js

@@ -10,6 +10,8 @@ export function bindSessionLifecycleResources(ctx) {
             ctx.forgetReady();
             return P.deleteProjectSession(ctx.projectId, ctx.sessionId);
         },
+        restore: () => P.restoreProjectSession(ctx.projectId, ctx.sessionId),
+        recover: () => P.recoverProjectSession(ctx.projectId, ctx.sessionId),
         start: (...a) => P.startProjectSession(ctx.projectId, ctx.sessionId, ...a),
         startOrThrow: (...a) => P.startProjectSessionOrThrow(ctx.projectId, ctx.sessionId, ...a),
         restart: () => {
@@ -34,6 +36,8 @@ export function bindSessionLifecycleResources(ctx) {
         participants: () => P.getSessionParticipants(ctx.projectId, ctx.sessionId),
         watch: () => P.getSessionWatch(ctx.projectId, ctx.sessionId),
         setWatch: (watching) => P.setSessionWatch(ctx.projectId, ctx.sessionId, watching),
+        setPinned: (pinned) => P.setSessionPinned(ctx.projectId, ctx.sessionId, pinned),
+        setArchived: (archived) => P.setSessionArchived(ctx.projectId, ctx.sessionId, archived),
         commit: (input) => P.commitSessionChanges(ctx.projectId, ctx.sessionId, input),
         publicShares: {
             list: () => P.listSessionPublicShares(ctx.projectId, ctx.sessionId),

package/dist/core/client/session-lifecycle-security.d.ts

@@ -20,6 +20,7 @@ export declare function bindSessionLifecycleSecurity(ctx: SessionBindingContext)
     messageAuthors: () => Promise<P.SessionMessageAuthors>;
     modelUsage: () => Promise<P.SessionModelUsage>;
     transcriptSync: (options?: Parameters<typeof P.getSessionTranscriptSync>[2]) => Promise<P.SessionTranscriptSyncEnvelope>;
+    log: (query?: Parameters<typeof P.getSessionLogPage>[2]) => Promise<import("../session-log/index.js").SessionLogPage | null>;
     turn: () => Promise<P.SessionTurnStatus>;
     prompts: {
         create: (input: P.CreateSessionPromptInput) => Promise<P.CreateSessionPromptResult>;
@@ -38,5 +39,6 @@ export declare function bindSessionLifecycleSecurity(ctx: SessionBindingContext)
     };
     ensureReady: (opts?: {
         readyTimeoutMs?: number;
+        session?: P.ProjectSession;
     }) => Promise<import("../../index.js").SessionRuntimeEntry>;
 };

package/dist/core/client/session-lifecycle-security.js

@@ -16,6 +16,7 @@ export function bindSessionLifecycleSecurity(ctx) {
         messageAuthors: () => P.getSessionMessageAuthors(ctx.projectId, ctx.sessionId),
         modelUsage: () => P.getSessionModelUsage(ctx.projectId, ctx.sessionId),
         transcriptSync: (options) => P.getSessionTranscriptSync(ctx.projectId, ctx.sessionId, options),
+        log: (query) => P.getSessionLogPage(ctx.projectId, ctx.sessionId, query),
         turn: () => P.getSessionTurn(ctx.projectId, ctx.sessionId),
         prompts: {
             create: (input) => P.createSessionPrompt(ctx.projectId, ctx.sessionId, input),

package/dist/core/client/session-readiness.d.ts

@@ -1,8 +1,10 @@
 import { type BeeuniPlatformConfig } from '../http/config.js';
+import type { ProjectSession } from '../rest/projects-client/sessions.js';
 import { type SessionRuntimeEntry } from '../session/session-runtime-registry.js';
 export declare function bindSessionReadiness(projectId: string, sessionId: string, config: BeeuniPlatformConfig): {
     ensureReady: (opts?: {
         readyTimeoutMs?: number;
+        session?: ProjectSession;
     }) => Promise<SessionRuntimeEntry>;
     tryResolveReady: () => SessionRuntimeEntry | null;
     requireReady: (action: string) => SessionRuntimeEntry;

package/dist/core/client/session-readiness.js

@@ -1,6 +1,9 @@
 import { platformConfig } from '../http/config.js';
+import { projectSessionStartSeed } from '../rest/projects-client/session-sandbox.js';
+import { setCurrentRuntime } from '../session/current-runtime.js';
 import { loadPreviewUrlTemplate } from '../session/preview-config.js';
-import { clearSessionRuntime, getSessionRuntime, } from '../session/session-runtime-registry.js';
+import { getSandboxUrlForExternalId } from '../session/server-store/url-helpers.js';
+import { clearSessionRuntime, getSessionRuntime, setSessionRuntime, } from '../session/session-runtime-registry.js';
 import { SessionNotReadyError, inFlightSessionStarts } from './session-shared.js';
 import { bindSessionStart } from './session-start.js';
 export function bindSessionReadiness(projectId, sessionId, config) {
@@ -20,6 +23,22 @@ export function bindSessionReadiness(projectId, sessionId, config) {
             return cached;
         const readyTimeoutMs = opts?.readyTimeoutMs ?? 180_000;
         const previewConfig = loadPreviewUrlTemplate(platformConfig().backendUrl ?? config.backendUrl).catch(() => null);
+        const seed = opts?.session?.session_id === sessionId ? projectSessionStartSeed(opts.session) : null;
+        const seededSandbox = seed?.sandbox?.external_id;
+        const seededRuntimeSession = seed?.runtime_session_id;
+        if (seededSandbox && seededRuntimeSession) {
+            const runtimeUrl = getSandboxUrlForExternalId(seededSandbox);
+            setCurrentRuntime(runtimeUrl, seededSandbox);
+            _ready = {
+                runtimeSessionId: seededRuntimeSession,
+                opencodeSessionId: seededRuntimeSession,
+                runtimeUrl,
+                sandboxId: seededSandbox,
+            };
+            setSessionRuntime(projectId, sessionId, _ready);
+            await previewConfig;
+            return _ready;
+        }
         const key = `${projectId}\n${sessionId}`;
         const inFlight = inFlightSessionStarts.get(key);
         if (inFlight) {

package/dist/core/http/api-client.d.ts

@@ -1,5 +1,4 @@
 import { ApiError } from './api/errors.js';
-export { isAdminBypassEnabled, setAdminBypass } from './transport.js';
 export { ApiError, AuthError, BillingError, RequestTooLargeError, parseBillingError, isAuthFailure, isBillingError, formatBillingErrorForUI, FEATURE_DISABLED_CODE, isFeatureDisabledError, featureDisabledKey, type ApiErrorFields, type BillingErrorUI, type FeatureDisabledError, } from './api/errors.js';
 export interface ErrorContext {
     operation?: string;
@@ -22,14 +21,9 @@ export interface ApiResponse<T = any> {
 export declare const FEATURE_NOT_SUPPORTED_CODE = "feature_not_supported";
 export declare const MODEL_NOT_SERVABLE_CODE = "model_not_servable";
 export declare const PROVISION_IN_FLIGHT_CODE = "provision_in_flight";
+export declare const SANDBOX_STATE_CHANGE_IN_PROGRESS_CODE = "sandbox_state_change_in_progress";
 export declare const ANALYTICS_UNAVAILABLE_CODE = "analytics_unavailable";
 export declare const ACCOUNTS_LIST_UNAVAILABLE_CODE = "accounts_list_unavailable";
-export declare const supabaseClient: {
-    execute<T = any>(queryFn: () => Promise<{
-        data: T | null;
-        error: any;
-    }>, errorContext?: ErrorContext): Promise<ApiResponse<T>>;
-};
 declare function postStream(endpoint: string, data: unknown, options?: ApiClientOptions): Promise<Response>;
 export declare const backendApi: {
     putRaw: <T = any>(endpoint: string, body: BodyInit, options?: Omit<RequestInit & ApiClientOptions, "method" | "body">) => Promise<ApiResponse<T>>;

package/dist/core/http/api-client.js

@@ -1,51 +1,16 @@
 import { syntheticUnauthenticatedResponse } from '../../platform/auth-core.js';
-import { ApiError, AuthError } from './api/errors.js';
+import { AuthError } from './api/errors.js';
 import { platformConfig } from './config.js';
 import { makeRequest } from './request.js';
 import { send } from './transport.js';
-export { isAdminBypassEnabled, setAdminBypass } from './transport.js';
 const getApiUrl = () => platformConfig().backendUrl || '';
 export { ApiError, AuthError, BillingError, RequestTooLargeError, parseBillingError, isAuthFailure, isBillingError, formatBillingErrorForUI, FEATURE_DISABLED_CODE, isFeatureDisabledError, featureDisabledKey, } from './api/errors.js';
 export const FEATURE_NOT_SUPPORTED_CODE = 'feature_not_supported';
 export const MODEL_NOT_SERVABLE_CODE = 'model_not_servable';
 export const PROVISION_IN_FLIGHT_CODE = 'provision_in_flight';
+export const SANDBOX_STATE_CHANGE_IN_PROGRESS_CODE = 'sandbox_state_change_in_progress';
 export const ANALYTICS_UNAVAILABLE_CODE = 'analytics_unavailable';
 export const ACCOUNTS_LIST_UNAVAILABLE_CODE = 'accounts_list_unavailable';
-export const supabaseClient = {
-    async execute(queryFn, errorContext) {
-        try {
-            const { data, error } = await queryFn();
-            if (error) {
-                const apiError = new ApiError(error.message || 'Database error', {
-                    code: error.code,
-                    details: error,
-                });
-                platformConfig().onError?.(apiError, errorContext);
-                return {
-                    error: apiError,
-                    success: false,
-                };
-            }
-            return {
-                data: data,
-                success: true,
-            };
-        }
-        catch (error) {
-            const apiError = error instanceof Error
-                ? new ApiError(error.message, {
-                    name: error.name || 'ApiError',
-                    stack: error.stack,
-                })
-                : new ApiError(String(error));
-            platformConfig().onError?.(apiError, errorContext);
-            return {
-                error: apiError,
-                success: false,
-            };
-        }
-    },
-};
 async function postStream(endpoint, data, options = {}) {
     const { timeout = 30000, fetch: fetchImpl } = options;
     const controller = new AbortController();

package/dist/core/http/auth.d.ts

@@ -1,11 +1,9 @@
 import { type TokenRetryOptions } from '../../platform/auth-core.js';
-export declare function getSupabaseAccessToken(): Promise<string | null>;
-export declare function getSupabaseAccessTokenWithRetry(options?: TokenRetryOptions): Promise<string | null>;
+export declare function getAuthToken(): Promise<string | null>;
+export declare function getAuthTokenWithRetry(options?: TokenRetryOptions): Promise<string | null>;
 export declare function invalidateTokenCache(): void;
 export declare function setCachedAuthToken(token: string | null): void;
 export declare function setBootstrapAuthToken(_token: string | null): void;
-export declare function getAuthToken(): Promise<string | null>;
-export declare function getAuthTokenWithRetry(options?: TokenRetryOptions): Promise<string | null>;
 export declare function authenticatedFetch(input: RequestInfo | URL, init?: RequestInit, options?: {
     retryOnAuthError?: boolean;
     timeoutMs?: number | null;

package/dist/core/http/auth.js

@@ -2,10 +2,10 @@ import { syntheticUnauthenticatedResponse, withTokenRetry, } from '../../platfor
 import { AuthError } from './api/errors.js';
 import { platformConfig } from './config.js';
 import { hostToken, invalidateHostToken, send } from './transport.js';
-export async function getSupabaseAccessToken() {
+export async function getAuthToken() {
     return hostToken();
 }
-export async function getSupabaseAccessTokenWithRetry(options) {
+export async function getAuthTokenWithRetry(options) {
     return withTokenRetry(() => platformConfig().getToken(), options, invalidateTokenCache);
 }
 export function invalidateTokenCache() {
@@ -16,12 +16,6 @@ export function setCachedAuthToken(token) {
         invalidateHostToken();
 }
 export function setBootstrapAuthToken(_token) { }
-export async function getAuthToken() {
-    return getSupabaseAccessToken();
-}
-export async function getAuthTokenWithRetry(options) {
-    return getSupabaseAccessTokenWithRetry(options);
-}
 export async function authenticatedFetch(input, init, options) {
     try {
         return await send(input, init, {

package/dist/core/http/config.d.ts

@@ -10,11 +10,13 @@ export interface BeeuniPlatformConfig {
     getToken: (() => Promise<string | null>) & {
         invalidate?: (rejectedToken: string) => void;
     };
+    credentialHeader?: string;
     fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
     eventStreamTransport?: RuntimeEventTransport;
     clientSource?: 'api' | 'cli' | 'mobile' | 'tui' | 'web';
     clientVersion?: string;
     onError?: (error: unknown, context?: unknown) => void;
+    onAccessRemedy?: (code: 'sso_required' | 'account_mfa_required') => void;
     sandboxId?: string | null;
     billingEnabled?: boolean;
     getUserId?: () => Promise<string | null>;

package/dist/core/http/response-error.js

@@ -1,5 +1,5 @@
 import { abortable, createAbortError } from './abort.js';
-import { ACCOUNTS_LIST_UNAVAILABLE_CODE, ANALYTICS_UNAVAILABLE_CODE, FEATURE_NOT_SUPPORTED_CODE, MODEL_NOT_SERVABLE_CODE, PROVISION_IN_FLIGHT_CODE, } from './api-client.js';
+import { ACCOUNTS_LIST_UNAVAILABLE_CODE, ANALYTICS_UNAVAILABLE_CODE, FEATURE_NOT_SUPPORTED_CODE, MODEL_NOT_SERVABLE_CODE, PROVISION_IN_FLIGHT_CODE, SANDBOX_STATE_CHANGE_IN_PROGRESS_CODE, } from './api-client.js';
 import { ApiError, RequestTooLargeError, parseBillingError } from './api/errors.js';
 import { platformConfig } from './config.js';
 const REQUEST_DEADLINE_CODE = 'request_deadline';
@@ -22,6 +22,15 @@ const isGitMirrorUnavailableResponse = (status, errorData, message) => {
         : undefined;
     return (code === GIT_MIRROR_UNAVAILABLE_CODE || LEGACY_GIT_MIRROR_UNAVAILABLE_MESSAGE.test(message));
 };
+const CONNECTORS_PROVIDER_UNAVAILABLE_CODE = 'connectors_provider_unavailable';
+const isConnectorsProviderUnavailableResponse = (status, errorData) => {
+    if (status !== 503)
+        return false;
+    const code = typeof errorData === 'object' && errorData !== null && 'code' in errorData
+        ? errorData.code
+        : undefined;
+    return code === CONNECTORS_PROVIDER_UNAVAILABLE_CODE;
+};
 async function readErrorBody(response, signal) {
     let message = `HTTP ${response.status}: ${response.statusText}`;
     let data = null;
@@ -46,9 +55,12 @@ async function readErrorBody(response, signal) {
 function isExpectedResponse(status, data, message) {
     return (isRequestDeadlineResponse(status, data, message) ||
         isGitMirrorUnavailableResponse(status, data, message) ||
+        isConnectorsProviderUnavailableResponse(status, data) ||
         (status === 501 && data?.code === FEATURE_NOT_SUPPORTED_CODE) ||
         (status === 409 &&
-            (data?.code === MODEL_NOT_SERVABLE_CODE || data?.code === PROVISION_IN_FLIGHT_CODE)) ||
+            (data?.code === MODEL_NOT_SERVABLE_CODE ||
+                data?.code === PROVISION_IN_FLIGHT_CODE ||
+                data?.code === SANDBOX_STATE_CHANGE_IN_PROGRESS_CODE)) ||
         (status === 503 &&
             (data?.code === ANALYTICS_UNAVAILABLE_CODE || data?.code === ACCOUNTS_LIST_UNAVAILABLE_CODE)));
 }
@@ -66,18 +78,21 @@ export async function handleErrorResponse(response, signal, showErrors, errorCon
     });
     if (response.status === 402)
         error = parseBillingError(error);
-    const remedyEvent = response.status !== 403
-        ? null
-        : data?.code === 'account_mfa_required'
-            ? 'beeuni:mfa-required'
-            : data?.code === 'sso_required'
-                ? 'beeuni:sso-required'
-                : null;
-    if (remedyEvent && typeof window !== 'undefined' && typeof window.dispatchEvent === 'function') {
+    const remedyCode = response.status === 403 &&
+        (data?.code === 'account_mfa_required' || data?.code === 'sso_required')
+        ? data.code
+        : null;
+    if (remedyCode) {
         try {
-            window.dispatchEvent(new CustomEvent(remedyEvent));
+            platformConfig().onAccessRemedy?.(remedyCode);
         }
         catch { }
+        if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function') {
+            try {
+                window.dispatchEvent(new CustomEvent(remedyCode === 'account_mfa_required' ? 'beeuni:mfa-required' : 'beeuni:sso-required'));
+            }
+            catch { }
+        }
     }
     if (response.status === 431) {
         error = new RequestTooLargeError(431, {

package/dist/core/http/transport.js

@@ -45,7 +45,12 @@ function withPlatformHeaders(url, base, token) {
         setHeader(headers, 'x-beeuni-admin-bypass', '1');
     for (const [name, value] of Object.entries(impersonationHeaders(url)))
         setHeader(headers, name, value);
-    if (!hasHeader(headers, 'authorization'))
+    const credentialHeader = platformConfig().credentialHeader?.trim();
+    if (credentialHeader) {
+        if (!hasHeader(headers, credentialHeader))
+            setHeader(headers, credentialHeader, token);
+    }
+    else if (!hasHeader(headers, 'authorization'))
         setHeader(headers, 'Authorization', `Bearer ${token}`);
     return headers;
 }

package/dist/core/models/composer-model.d.ts

@@ -3,6 +3,20 @@ import type { ModelDefaultsResponse } from '../rest/projects-client/model-defaul
 import { type FlatModel } from './model-flatten.js';
 import { type ModelKey } from './model-key.js';
 export declare function resolveModelDefault(data: ModelDefaultsResponse | undefined, agentName: string | undefined): ModelKey | undefined;
+export declare function latestPromptModel(messages: ReadonlyArray<{
+    role: string;
+    model?: {
+        provider?: string;
+        model?: string;
+    } | null;
+}> | null | undefined): ModelKey | undefined;
+export declare function sessionModelCandidates(input: {
+    session?: {
+        metadata?: Record<string, unknown> | null;
+    } | null;
+    lastPromptModel?: ModelKey;
+    gatewayEnabled: boolean;
+}): ModelKey[];
 export interface ComposerModelResolution {
     model: ModelKey | undefined;
     explicit: ModelKey | undefined;

package/dist/core/models/composer-model.js

@@ -1,7 +1,8 @@
 import { autoSeedableModels } from '@beeuni/llm-catalog/lite';
+import { sessionModelPin } from '../rest/projects-client/sessions.js';
 import { healBedrockModelKey } from './bedrock-invokable.js';
 import { isOfferedModel } from './model-flatten.js';
-import { wireToModelKey } from './model-key.js';
+import { modelRefToKey, wireToModelKey } from './model-key.js';
 export function resolveModelDefault(data, agentName) {
     const wire = (agentName ? data?.agentDefaults?.[agentName] : undefined) ??
         data?.projectDefault ??
@@ -9,6 +10,25 @@ export function resolveModelDefault(data, agentName) {
         data?.platformDefault;
     return wire ? wireToModelKey(wire) : undefined;
 }
+export function latestPromptModel(messages) {
+    for (let i = (messages?.length ?? 0) - 1; i >= 0; i--) {
+        const message = messages[i];
+        const { provider, model } = message.model ?? {};
+        if (message.role === 'user' && provider && model)
+            return { providerID: provider, modelID: model };
+    }
+    return undefined;
+}
+const CHOSEN_PIN_SOURCES = new Set(['explicit', 'repointed']);
+export function sessionModelCandidates(input) {
+    const pin = input.session ? sessionModelPin(input.session) : null;
+    const pinKey = pin ? modelRefToKey(pin, input.gatewayEnabled) : undefined;
+    const chosen = CHOSEN_PIN_SOURCES.has(String(input.session?.metadata?.opencode_model_source));
+    const ordered = chosen
+        ? [pinKey, input.lastPromptModel]
+        : [input.lastPromptModel, pinKey];
+    return ordered.filter((model) => !!model);
+}
 export function resolveComposerModel(input) {
     const { models, providers } = input;
     const isValid = (model) => isOfferedModel(models, model);