@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/billing.js

@@ -0,0 +1,257 @@
+import { backendApi } from '../../http/api-client.js';
+import { serverTokenGet, unwrap } from './shared.js';
+import { retiredEndpointError } from '../../http/api/errors.js';
+const CHECKOUT_INSTEAD = 'Use createPerSeatCheckout().';
+export function getDefaultAccountState() {
+    return {
+        credits: {
+            total: 0,
+            daily: 0,
+            monthly: 0,
+            extra: 0,
+            can_run: false,
+            daily_refresh: null,
+        },
+        subscription: {
+            tier_key: 'none',
+            tier_display_name: 'No Plan',
+            status: 'no_subscription',
+            billing_period: null,
+            provider: 'stripe',
+            subscription_id: null,
+            current_period_end: null,
+            cancel_at_period_end: false,
+            is_cancelled: false,
+            cancellation_effective_date: null,
+            has_scheduled_change: false,
+            scheduled_change: null,
+            commitment: {
+                has_commitment: false,
+                can_cancel: true,
+                commitment_type: null,
+                months_remaining: null,
+                commitment_end_date: null,
+            },
+            can_purchase_credits: false,
+        },
+        models: [],
+        limits: {
+            concurrent_runs: {
+                running_count: 0,
+                limit: 0,
+                can_start: false,
+                tier_name: 'none',
+            },
+            ai_worker_count: {
+                current_count: 0,
+                limit: 0,
+                can_create: false,
+                tier_name: 'none',
+            },
+            custom_mcp_count: {
+                current_count: 0,
+                limit: 0,
+                can_create: false,
+                tier_name: 'none',
+            },
+        },
+        tier: {
+            name: 'none',
+            display_name: 'No Plan',
+            monthly_credits: 0,
+            can_purchase_credits: false,
+        },
+    };
+}
+function planFamilyForTierKey(tierKey) {
+    const key = tierKey.trim().toLowerCase();
+    if (key === '' || key === 'free' || key === 'none')
+        return 'free';
+    if (key === 'enterprise')
+        return 'enterprise';
+    return 'team';
+}
+export function resolvedPlan(state) {
+    const plan = state?.plan;
+    if (plan) {
+        return {
+            family: plan.family,
+            label: plan.label,
+            sublabel: plan.sublabel ?? null,
+            isGrandfathered: plan.is_grandfathered === true,
+        };
+    }
+    const s = state ?? getDefaultAccountState();
+    const tierKey = (s.subscription?.tier_key || s.tier?.name || 'none').toString();
+    const label = (s.tier?.display_name || '').trim() || tierKey;
+    return {
+        family: planFamilyForTierKey(tierKey),
+        label,
+        sublabel: null,
+        isGrandfathered: false,
+    };
+}
+async function fetchAccountState(path) {
+    const response = await backendApi.get(path, { showErrors: false });
+    const isGracefulDisabledResponse = response.error?.status === 404 && /billing is not enabled/i.test(response.error.message || '');
+    if (response.error && response.error.status !== 401 && !isGracefulDisabledResponse) {
+        throw response.error;
+    }
+    if (response.error) {
+        return getDefaultAccountState();
+    }
+    return response.data;
+}
+function accountStateQuery(options) {
+    const search = new URLSearchParams();
+    if (options?.skipCache)
+        search.set('skip_cache', 'true');
+    if (options?.accountId)
+        search.set('account_id', options.accountId);
+    const query = search.toString();
+    return query ? `?${query}` : '';
+}
+export async function getAccountState(options) {
+    return fetchAccountState(`/billing/account-state${accountStateQuery(options)}`);
+}
+export async function getAccountStateMinimal(options) {
+    return fetchAccountState(`/billing/account-state/minimal${accountStateQuery(options)}`);
+}
+export async function listBillingTransactions(options) {
+    const search = new URLSearchParams();
+    if (options?.accountId)
+        search.set('account_id', options.accountId);
+    if (options?.limit != null)
+        search.set('limit', String(options.limit));
+    if (options?.offset != null)
+        search.set('offset', String(options.offset));
+    if (options?.typeFilter) {
+        search.set('type_filter', Array.isArray(options.typeFilter) ? options.typeFilter.join(',') : options.typeFilter);
+    }
+    const query = search.toString();
+    return unwrap(await backendApi.get(`/billing/transactions${query ? `?${query}` : ''}`));
+}
+export async function getBillingTransactionsSummary(options) {
+    const search = new URLSearchParams();
+    if (options?.accountId)
+        search.set('account_id', options.accountId);
+    if (options?.days != null)
+        search.set('days', String(options.days));
+    const query = search.toString();
+    return unwrap(await backendApi.get(`/billing/transactions/summary${query ? `?${query}` : ''}`));
+}
+export async function getBillingCreditBreakdown() {
+    return unwrap(await backendApi.get('/billing/credit-breakdown'));
+}
+export async function getBillingUsageHistory(days) {
+    const qs = days != null ? `?days=${days}` : '';
+    return unwrap(await backendApi.get(`/billing/usage-history${qs}`));
+}
+export async function getBillingTierConfigurations() {
+    return unwrap(await backendApi.get('/billing/tier-configurations'));
+}
+export async function fetchAccountStateWithToken(opts) {
+    const query = opts.accountId ? `?account_id=${encodeURIComponent(opts.accountId)}` : '';
+    return serverTokenGet(opts, `/v1/billing/account-state${query}`);
+}
+export async function createCheckoutSession(_input) {
+    throw retiredEndpointError('createCheckoutSession', CHECKOUT_INSTEAD);
+}
+export async function confirmCheckoutSession(_sessionId, _accountId) {
+    throw retiredEndpointError('confirmCheckoutSession', CHECKOUT_INSTEAD);
+}
+export async function createPortalSession(returnUrl, accountId) {
+    return unwrap(await backendApi.post('/billing/create-portal-session', {
+        account_id: accountId,
+        return_url: returnUrl,
+    }), 'Failed to create portal session');
+}
+export async function cancelSubscription(feedback, accountId) {
+    return unwrap(await backendApi.post('/billing/cancel-subscription', {
+        account_id: accountId,
+        feedback,
+    }), 'Failed to cancel subscription');
+}
+export async function reactivateSubscription(accountId) {
+    return unwrap(await backendApi.post('/billing/reactivate-subscription', {
+        account_id: accountId,
+    }), 'Failed to reactivate subscription');
+}
+export async function scheduleDowngrade(_targetTierKey, _commitmentType, _accountId) {
+    throw retiredEndpointError('scheduleDowngrade', 'Change the plan in the Stripe customer portal (createPortalSession()).');
+}
+export async function cancelScheduledChange(accountId) {
+    return unwrap(await backendApi.post('/billing/cancel-scheduled-change', {
+        account_id: accountId,
+    }), 'Failed to cancel scheduled change');
+}
+export async function getProrationPreview(newPriceId, accountId) {
+    const search = new URLSearchParams({ new_price_id: newPriceId });
+    if (accountId)
+        search.set('account_id', accountId);
+    return unwrap(await backendApi.get(`/billing/proration-preview?${search.toString()}`), 'Failed to load proration preview');
+}
+export async function purchaseCredits(input) {
+    return unwrap(await backendApi.post('/billing/purchase-credits', {
+        amount: input.amount,
+        account_id: input.accountId,
+        success_url: input.successUrl,
+        cancel_url: input.cancelUrl,
+    }), 'Failed to purchase credits');
+}
+export async function getAutoTopupSettings(accountId) {
+    const query = accountId ? `?account_id=${encodeURIComponent(accountId)}` : '';
+    return unwrap(await backendApi.get(`/billing/auto-topup/settings${query}`), 'Failed to load auto-topup settings');
+}
+export async function requestTopUp(accountId) {
+    return unwrap(await backendApi.post(`/accounts/${encodeURIComponent(accountId)}/top-up-requests`, {}), 'Failed to ask the owners for credits');
+}
+export async function configureAutoTopup(input) {
+    return unwrap(await backendApi.post('/billing/auto-topup/configure', {
+        account_id: input.accountId,
+        enabled: input.enabled,
+        threshold: input.threshold,
+        amount: input.amount,
+    }, { showErrors: false }), 'Failed to configure auto-topup');
+}
+export async function getAutoTopupSetupStatus(accountId) {
+    const query = accountId ? `?account_id=${encodeURIComponent(accountId)}` : '';
+    return unwrap(await backendApi.get(`/billing/auto-topup/setup-status${query}`, {
+        timeout: 8000,
+        showErrors: false,
+    }), 'Failed to load auto-topup setup status');
+}
+export async function createPerSeatCheckout(input) {
+    return unwrap(await backendApi.post('/billing/create-per-seat-checkout', {
+        account_id: input.accountId,
+        success_url: input.successUrl,
+        cancel_url: input.cancelUrl,
+        locale: input.locale,
+    }), 'Failed to create per-seat checkout');
+}
+export async function claimPerSeatBilling(accountId) {
+    return unwrap(await backendApi.post('/billing/claim-per-seat', {
+        account_id: accountId,
+    }), 'Failed to switch to per-seat billing');
+}
+export async function syncSubscription(accountId) {
+    return unwrap(await backendApi.post('/billing/sync-subscription', {
+        account_id: accountId,
+    }), 'Failed to sync subscription');
+}
+export async function getUsageRollup(options = {}) {
+    const qs = new URLSearchParams();
+    if (options.start)
+        qs.set('start', options.start);
+    if (options.end)
+        qs.set('end', options.end);
+    if (options.groupBy === 'model' ||
+        options.groupBy === 'provider' ||
+        options.groupBy === 'day') {
+        qs.set('group_by', options.groupBy);
+    }
+    if (options.accountId)
+        qs.set('account_id', options.accountId);
+    const query = qs.toString();
+    return unwrap(await backendApi.get(`/usage${query ? `?${query}` : ''}`));
+}

package/dist/core/rest/projects-client/change-requests.d.ts

@@ -0,0 +1,116 @@
+import type { ProjectCommitFile } from './git-history.js';
+export type ChangeRequestStatus = 'open' | 'merged' | 'closed';
+export interface ChangeRequest {
+    cr_id: string;
+    account_id: string;
+    project_id: string;
+    number: number;
+    title: string;
+    description: string;
+    base_ref: string;
+    head_ref: string;
+    status: ChangeRequestStatus;
+    head_commit_sha: string | null;
+    base_commit_sha: string | null;
+    origin_session_id: string | null;
+    created_by: string;
+    merged_at: string | null;
+    merged_by: string | null;
+    merge_commit_sha: string | null;
+    closed_at: string | null;
+    closed_by: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export interface ChangeRequestDetailResponse {
+    change_request: ChangeRequest;
+}
+export interface ChangeRequestDiffResponse {
+    cr_id: string;
+    base_ref: string;
+    head_ref: string;
+    base_sha: string;
+    head_sha: string;
+    merge_base: string | null;
+    files: ProjectCommitFile[];
+    files_changed: number;
+    additions: number;
+    deletions: number;
+    patch: string;
+    patch_truncated?: boolean;
+}
+export interface ChangeRequestMergePreview {
+    base_sha: string;
+    head_sha: string;
+    merge_base: string | null;
+    can_fast_forward: boolean;
+    can_merge: boolean;
+    conflicts: string[];
+    is_up_to_date: boolean;
+}
+export interface VersionDiffPreview {
+    from: string;
+    into: string;
+    from_sha: string | null;
+    into_sha: string | null;
+    merge_base: string | null;
+    files_changed: number;
+    additions: number;
+    deletions: number;
+    is_up_to_date: boolean;
+    is_same_ref: boolean;
+}
+export declare function getVersionDiff(projectId: string, input: {
+    from: string;
+    into: string;
+}): Promise<VersionDiffPreview>;
+export interface ChangeRequestMergeResponse {
+    change_request: ChangeRequest;
+    merge: {
+        merge_commit_sha: string;
+        fast_forward: boolean;
+        base_sha_before: string;
+        base_sha_after: string;
+    };
+}
+export interface ListChangeRequestsOptions {
+    originSessionId?: string;
+    limit?: number;
+}
+export declare function listChangeRequests(projectId: string, status?: ChangeRequestStatus | 'all', options?: ListChangeRequestsOptions): Promise<{
+    change_requests: ChangeRequest[];
+}>;
+export declare function getChangeRequest(projectId: string, crId: string): Promise<ChangeRequestDetailResponse>;
+export declare function getChangeRequestDiff(projectId: string, crId: string): Promise<ChangeRequestDiffResponse>;
+export declare function getChangeRequestMergePreview(projectId: string, crId: string): Promise<ChangeRequestMergePreview>;
+export declare function openChangeRequest(projectId: string, input: {
+    title: string;
+    description?: string;
+    head_ref: string;
+    base_ref?: string;
+    session_id?: string;
+}): Promise<ChangeRequest>;
+export declare function mergeChangeRequest(projectId: string, crId: string, input?: {
+    message?: string;
+}): Promise<ChangeRequestMergeResponse>;
+export declare function closeChangeRequest(projectId: string, crId: string): Promise<ChangeRequest>;
+export declare function reopenChangeRequest(projectId: string, crId: string): Promise<ChangeRequest>;
+export declare function requestChangesOnChangeRequest(projectId: string, crId: string, feedback: string): Promise<{
+    change_request: ChangeRequest;
+    delivering: boolean;
+}>;
+export interface CommitSessionResult {
+    committed: boolean;
+    pushed: boolean;
+    nothing_to_do: boolean;
+    branch: string | null;
+    head_sha: string | null;
+}
+export declare function commitSessionChanges(projectId: string, sessionId: string, input?: {
+    message?: string;
+}): Promise<CommitSessionResult>;
+export declare function updateChangeRequest(projectId: string, crId: string, input: {
+    title?: string;
+    description?: string;
+}): Promise<ChangeRequest>;

package/dist/core/rest/projects-client/change-requests.js

@@ -0,0 +1,50 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function getVersionDiff(projectId, input) {
+    const params = new URLSearchParams({ from: input.from, into: input.into });
+    return unwrap(await backendApi.get(`/projects/${projectId}/version-diff?${params.toString()}`));
+}
+export async function listChangeRequests(projectId, status, options) {
+    const params = new URLSearchParams();
+    if (status)
+        params.set('status', status);
+    if (options?.originSessionId)
+        params.set('origin_session_id', options.originSessionId);
+    if (options?.limit != null)
+        params.set('limit', String(options.limit));
+    const query = params.toString() ? `?${params.toString()}` : '';
+    return unwrap(await backendApi.get(`/projects/${projectId}/change-requests${query}`, {
+        showErrors: false,
+        timeout: 15_000,
+    }));
+}
+export async function getChangeRequest(projectId, crId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/change-requests/${crId}`));
+}
+export async function getChangeRequestDiff(projectId, crId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/change-requests/${crId}/diff`));
+}
+export async function getChangeRequestMergePreview(projectId, crId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/change-requests/${crId}/merge-preview`));
+}
+export async function openChangeRequest(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/change-requests`, input));
+}
+export async function mergeChangeRequest(projectId, crId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/change-requests/${crId}/merge`, input ?? {}, { showErrors: false }));
+}
+export async function closeChangeRequest(projectId, crId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/change-requests/${crId}/close`, {}));
+}
+export async function reopenChangeRequest(projectId, crId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/change-requests/${crId}/reopen`, {}));
+}
+export async function requestChangesOnChangeRequest(projectId, crId, feedback) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/change-requests/${crId}/request-changes`, { feedback }));
+}
+export async function commitSessionChanges(projectId, sessionId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/sessions/${sessionId}/commit-push`, input ?? {}));
+}
+export async function updateChangeRequest(projectId, crId, input) {
+    return unwrap(await backendApi.patch(`/projects/${projectId}/change-requests/${crId}`, input));
+}

package/dist/core/rest/projects-client/channels.d.ts

@@ -0,0 +1,131 @@
+export interface ChatIdentityBindResult {
+    ok: boolean;
+    workspaceName: string | null;
+    hasAccess: boolean;
+    resumed: boolean;
+}
+export declare function bindSlackIdentity(token: string): Promise<ChatIdentityBindResult>;
+export declare function bindTeamsIdentity(token: string): Promise<ChatIdentityBindResult>;
+export interface ChatIdentityPreview {
+    service: 'slack' | 'teams';
+    workspaceName: string | null;
+    chatUserId: string;
+    chatUserName: string | null;
+}
+export declare function previewSlackIdentity(token: string): Promise<ChatIdentityPreview>;
+export declare function previewTeamsIdentity(token: string): Promise<ChatIdentityPreview>;
+export interface SlackInstallation {
+    workspaceId: string;
+    workspaceName: string | null;
+    botUserId: string | null;
+    installedAt: string;
+}
+export declare function getSlackInstallation(projectId: string): Promise<SlackInstallation | null>;
+export interface ConnectSlackInput {
+    bot_token: string;
+    signing_secret: string;
+}
+export declare function connectSlack(projectId: string, input: ConnectSlackInput): Promise<SlackInstallation>;
+export interface SlackMode {
+    oauth_available: boolean;
+    install_url: string | null;
+}
+export declare function getSlackMode(projectId: string): Promise<SlackMode>;
+export interface ChannelInstallCompletionInput {
+    code: string;
+    state: string;
+}
+export interface ChannelInstallCompletion {
+    redirect_url: string;
+}
+export declare function completeSlackInstall(projectId: string, input: ChannelInstallCompletionInput): Promise<ChannelInstallCompletion>;
+export declare function completeTeamsInstall(projectId: string, input: ChannelInstallCompletionInput): Promise<ChannelInstallCompletion>;
+export declare function getSlackManifest(projectId: string): Promise<Record<string, unknown>>;
+export declare function disconnectSlack(projectId: string): Promise<void>;
+export declare function getSlackChannelFile(projectId: string, url: string): Promise<Blob>;
+export interface UploadSlackChannelFileInput {
+    channel: string;
+    filename: string;
+    contentBase64: string;
+    comment?: string;
+    threadTs?: string;
+}
+export interface UploadSlackChannelFileResult {
+    ok: boolean;
+    files: unknown;
+}
+export declare function uploadSlackChannelFile(projectId: string, input: UploadSlackChannelFileInput): Promise<UploadSlackChannelFileResult>;
+export interface EmailSenderPolicy {
+    mode: 'allow_all' | 'restricted';
+    allowedEmails: string[];
+    allowedDomains: string[];
+    allowedRegex: string | null;
+}
+export interface EmailInstallation {
+    connectionId: string | null;
+    connectorSlug: string;
+    inboxId: string;
+    email: string;
+    displayName: string | null;
+    webhookId: string | null;
+    senderPolicy: EmailSenderPolicy;
+    installedAt: string;
+}
+export type EmailConnectionInstallation = EmailInstallation;
+export interface EmailMode {
+    provider: 'agentmail';
+    enabled?: boolean;
+    managed_available: boolean;
+}
+export declare function getEmailInstallation(projectId: string, connectorSlug?: string | null): Promise<EmailConnectionInstallation | null>;
+export declare function getEmailMode(projectId: string): Promise<EmailMode>;
+export interface ConnectEmailInput {
+    connector_slug?: string;
+    api_key?: string;
+    display_name?: string;
+    username?: string;
+    domain?: string;
+    inbox_id?: string;
+    email?: string;
+    sender_policy?: EmailSenderPolicy;
+}
+export declare function connectEmail(projectId: string, input: ConnectEmailInput): Promise<EmailConnectionInstallation>;
+export declare function disconnectEmail(projectId: string, connectorSlug?: string | null): Promise<void>;
+export declare function updateEmailPolicy(projectId: string, connectorSlug: string | null | undefined, senderPolicy: EmailSenderPolicy): Promise<EmailConnectionInstallation>;
+export type ChannelConversationPolicy = 'owner_approval' | 'owner_only' | 'project_open';
+export interface ChannelBindingEffectiveAgent {
+    agent: string;
+    source: 'explicit' | 'project' | 'fallback';
+}
+export type ChannelBindingModelSource = 'explicit' | 'agent' | 'project' | 'account' | 'platform';
+export interface ChannelBindingEffectiveModel {
+    model: string | null;
+    source: ChannelBindingModelSource;
+}
+export interface ChannelBinding {
+    bindingId: string;
+    platform: string;
+    workspaceId: string;
+    channelId: string;
+    channelName: string | null;
+    channelType: string | null;
+    channelUnavailable?: boolean;
+    threadTitle?: string | null;
+    agentName: string | null;
+    opencodeModel: string | null;
+    conversationPolicy: ChannelConversationPolicy;
+    installedAt: string;
+    effectiveAgent: ChannelBindingEffectiveAgent;
+    effectiveModel: ChannelBindingEffectiveModel;
+}
+export interface ChannelBindingsResponse {
+    projectDefaultAgent: string | null;
+    bindings: ChannelBinding[];
+}
+export declare function listChannelBindings(projectId: string): Promise<ChannelBindingsResponse>;
+export interface UpdateChannelBindingInput {
+    agentName?: string | null;
+    opencodeModel?: string | null;
+    conversationPolicy?: ChannelConversationPolicy;
+}
+export declare function updateChannelBinding(projectId: string, bindingId: string, input: UpdateChannelBindingInput): Promise<ChannelBinding>;

package/dist/core/rest/projects-client/channels.js

@@ -0,0 +1,112 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+async function bindChatIdentity(service, token) {
+    return unwrap(await backendApi.post(`/channels/${service}/identity/bind`, { token }), 'Failed to connect your account');
+}
+export function bindSlackIdentity(token) {
+    return bindChatIdentity('slack', token);
+}
+export function bindTeamsIdentity(token) {
+    return bindChatIdentity('teams', token);
+}
+async function previewChatIdentity(service, token) {
+    return unwrap(await backendApi.post(`/channels/${service}/identity/preview`, { token }, { showErrors: false }), 'This link is invalid or has expired');
+}
+export function previewSlackIdentity(token) {
+    return previewChatIdentity('slack', token);
+}
+export function previewTeamsIdentity(token) {
+    return previewChatIdentity('teams', token);
+}
+export async function getSlackInstallation(projectId) {
+    const res = await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/slack/installation`, { showErrors: false });
+    if (!res.success)
+        return null;
+    return res.data ?? null;
+}
+export async function connectSlack(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${encodeURIComponent(projectId)}/channels/slack/connect`, input, { showErrors: false }), 'Failed to connect');
+}
+const DEFAULT_SLACK_MODE = { oauth_available: false, install_url: null };
+export async function getSlackMode(projectId) {
+    const res = await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/slack/mode`, { showErrors: false });
+    if (!res.success || !res.data)
+        return DEFAULT_SLACK_MODE;
+    return res.data;
+}
+async function completeChannelInstall(service, projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${encodeURIComponent(projectId)}/channels/${service}/oauth/complete`, { code: input.code, state: input.state }, { showErrors: false }), 'Failed to finish the install');
+}
+export function completeSlackInstall(projectId, input) {
+    return completeChannelInstall('slack', projectId, input);
+}
+export function completeTeamsInstall(projectId, input) {
+    return completeChannelInstall('teams', projectId, input);
+}
+export async function getSlackManifest(projectId) {
+    return unwrap(await backendApi.get(`/webhooks/slack/${encodeURIComponent(projectId)}/manifest`, { showErrors: false }), 'Failed to load Slack manifest');
+}
+export async function disconnectSlack(projectId) {
+    const res = await backendApi.delete(`/projects/${encodeURIComponent(projectId)}/channels/slack/installation`, { showErrors: false });
+    if (!res.success)
+        throw new Error(res.error?.message ?? 'Failed to disconnect');
+}
+export async function getSlackChannelFile(projectId, url) {
+    return unwrap(await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/slack/file?url=${encodeURIComponent(url)}`, { showErrors: false }), 'Failed to download Slack file');
+}
+export async function uploadSlackChannelFile(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${encodeURIComponent(projectId)}/channels/slack/file/upload`, {
+        channel: input.channel,
+        filename: input.filename,
+        content_base64: input.contentBase64,
+        comment: input.comment,
+        thread_ts: input.threadTs,
+    }, { showErrors: false }), 'Failed to upload Slack file');
+}
+function normalizeEmailInstallation(value) {
+    const connectionId = value.connectionId ?? value.connection_id ?? null;
+    const connectorSlug = value.connectorSlug ??
+        value.connector_slug ??
+        value.connectionSlug ??
+        value.connection_slug ??
+        'beeuni_email';
+    return {
+        ...value,
+        connectionId,
+        connectorSlug,
+    };
+}
+const DEFAULT_EMAIL_MODE = { provider: 'agentmail', managed_available: false };
+export async function getEmailInstallation(projectId, connectorSlug) {
+    const query = connectorSlug ? `?connector_slug=${encodeURIComponent(connectorSlug)}` : '';
+    const res = await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/email/installation${query}`, { showErrors: false });
+    if (!res.success)
+        return null;
+    return res.data ? normalizeEmailInstallation(res.data) : null;
+}
+export async function getEmailMode(projectId) {
+    const res = await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/email/mode`, { showErrors: false });
+    if (!res.success || !res.data)
+        return DEFAULT_EMAIL_MODE;
+    return res.data;
+}
+export async function connectEmail(projectId, input) {
+    const installation = unwrap(await backendApi.post(`/projects/${encodeURIComponent(projectId)}/channels/email/connect`, input, { showErrors: false }), 'Failed to connect email');
+    return normalizeEmailInstallation(installation);
+}
+export async function disconnectEmail(projectId, connectorSlug) {
+    const query = connectorSlug ? `?connector_slug=${encodeURIComponent(connectorSlug)}` : '';
+    const res = await backendApi.delete(`/projects/${encodeURIComponent(projectId)}/channels/email/installation${query}`, { showErrors: false });
+    if (!res.success)
+        throw new Error(res.error?.message ?? 'Failed to disconnect email');
+}
+export async function updateEmailPolicy(projectId, connectorSlug, senderPolicy) {
+    const installation = unwrap(await backendApi.patch(`/projects/${encodeURIComponent(projectId)}/channels/email/installation`, { connector_slug: connectorSlug ?? 'beeuni_email', sender_policy: senderPolicy }, { showErrors: false }), 'Failed to update email policy');
+    return normalizeEmailInstallation(installation);
+}
+export async function listChannelBindings(projectId) {
+    return unwrap(await backendApi.get(`/projects/${encodeURIComponent(projectId)}/channels/bindings`, { showErrors: false }), 'Failed to load channel bindings');
+}
+export async function updateChannelBinding(projectId, bindingId, input) {
+    return unwrap(await backendApi.patch(`/projects/${encodeURIComponent(projectId)}/channels/bindings/${encodeURIComponent(bindingId)}`, input, { showErrors: false }), 'Failed to update channel binding');
+}