@beeuni/sdk 0.1.0

package/dist/core/client/project-platform-resources.js

@@ -0,0 +1,27 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindProjectPlatformResources(projectId) {
+    return {
+        gateway: {
+            logs: (opts) => P.listGatewayLogs(projectId, opts),
+            log: (logId) => P.getGatewayLog(projectId, logId),
+            overview: (days) => P.getGatewayOverview(projectId, days),
+            series: (days) => P.getGatewaySeries(projectId, days),
+            breakdown: (days) => P.getGatewayBreakdown(projectId, days),
+            sessions: (days) => P.getGatewaySessions(projectId, days),
+            errors: (days) => P.getGatewayErrors(projectId, days),
+            budgets: () => P.getGatewayBudgets(projectId),
+            setBudget: (input) => P.setGatewayBudget(projectId, input),
+            deleteBudget: (budgetId) => P.deleteGatewayBudget(projectId, budgetId),
+            keys: () => P.getGatewayKeys(projectId),
+            createKey: (name) => P.createGatewayKey(projectId, name),
+            revokeKey: (keyId) => P.revokeGatewayKey(projectId, keyId),
+            routing: {
+                get: () => P.getGatewayRoutingPolicy(projectId),
+                set: (policy) => P.setGatewayRoutingPolicy(projectId, policy),
+                reset: () => P.resetGatewayRoutingPolicy(projectId),
+                preview: (input) => P.previewGatewayRoute(projectId, input),
+            },
+            playground: (prompt, models, system) => P.runGatewayPlayground(projectId, prompt, models, system),
+        },
+    };
+}

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

@@ -0,0 +1,76 @@
+import * as P from '../rest/projects-client/index.js';
+export declare function bindProjectPlatformSecurity(projectId: string): {
+    modelDefaults: {
+        get: () => Promise<P.ModelDefaultsResponse>;
+        set: (input: Parameters<typeof P.setModelDefault>[1]) => Promise<{
+            ok: boolean;
+            scope: string;
+            agentName?: string;
+            model: string;
+        }>;
+        clear: (params: Parameters<typeof P.clearModelDefault>[1]) => Promise<{
+            ok: boolean;
+        }>;
+    };
+    setDefaultAgent: (agentName: string) => Promise<P.UpdateProjectDefaultAgentResponse>;
+    sandbox: {
+        list: () => Promise<P.SandboxTemplatesResponse>;
+        snapshots: () => Promise<P.ProjectSnapshotsResponse>;
+        rebuildSnapshot: (slug?: string) => Promise<P.RebuildSnapshotResponse>;
+        fixWithAgent: () => Promise<{
+            session_id: string;
+        }>;
+        createTemplate: (input: Parameters<typeof P.createSandboxTemplate>[1]) => Promise<{
+            template_id: string;
+            slug: string;
+        }>;
+        updateTemplate: (templateId: string, input: P.UpdateSandboxTemplateInput) => Promise<{
+            template_id: string;
+            slug: string;
+        }>;
+        removeTemplate: (templateId: string) => Promise<null>;
+        buildTemplate: (templateId: string) => Promise<{
+            status: "started";
+            template_id: string;
+            slug: string;
+            providers?: Array<"daytona" | "platinum" | "e2b">;
+        }>;
+        setProvider: (provider: Parameters<typeof P.updateProjectSandboxProvider>[1]) => Promise<P.UpdateProjectSandboxProviderResult>;
+    };
+    setAgentScope: (agentName: string, scope: {
+        env?: P.AgentGrantSet;
+        connectors?: P.AgentGrantSet;
+        connectors_required?: string[];
+        connectors_personal?: string[];
+    }) => Promise<{
+        ok: boolean;
+        agent: string;
+        env: P.AgentGrantSet;
+        connectors: P.AgentGrantSet;
+        connectors_required: string[];
+    }>;
+    channels: {
+        slack: {
+            installation: () => Promise<P.SlackInstallation | null>;
+            connect: (input: Parameters<typeof P.connectSlack>[1]) => Promise<P.SlackInstallation>;
+            mode: () => Promise<P.SlackMode>;
+            completeInstall: (input: Parameters<typeof P.completeSlackInstall>[1]) => Promise<P.ChannelInstallCompletion>;
+            manifest: () => Promise<Record<string, unknown>>;
+            disconnect: () => Promise<void>;
+            getFile: (url: string) => Promise<Blob>;
+            uploadFile: (input: Parameters<typeof P.uploadSlackChannelFile>[1]) => Promise<P.UploadSlackChannelFileResult>;
+        };
+        teams: {
+            completeInstall: (input: Parameters<typeof P.completeTeamsInstall>[1]) => Promise<P.ChannelInstallCompletion>;
+        };
+        email: {
+            installation: (connectorSlug?: string | null) => Promise<P.EmailInstallation | null>;
+            mode: () => Promise<P.EmailMode>;
+            connect: (input: Parameters<typeof P.connectEmail>[1]) => Promise<P.EmailInstallation>;
+            disconnect: (connectorSlug?: string | null) => Promise<void>;
+            updatePolicy: (connectorSlug: string | null | undefined, senderPolicy: P.EmailSenderPolicy) => Promise<P.EmailInstallation>;
+        };
+    };
+    updateFeatureFlag: (feature: P.FeatureFlagKey, enabled: boolean | null) => Promise<P.BeeuniProject>;
+    updateExperimentalFeature: (feature: P.FeatureFlagKey, enabled: boolean | null) => Promise<P.BeeuniProject>;
+};

package/dist/core/client/project-platform-security.js

@@ -0,0 +1,31 @@
+import * as P from '../rest/projects-client/index.js';
+import { bindProjectPlatformSettings } from './project-platform-settings.js';
+export function bindProjectPlatformSecurity(projectId) {
+    return {
+        channels: {
+            slack: {
+                installation: () => P.getSlackInstallation(projectId),
+                connect: (input) => P.connectSlack(projectId, input),
+                mode: () => P.getSlackMode(projectId),
+                completeInstall: (input) => P.completeSlackInstall(projectId, input),
+                manifest: () => P.getSlackManifest(projectId),
+                disconnect: () => P.disconnectSlack(projectId),
+                getFile: (url) => P.getSlackChannelFile(projectId, url),
+                uploadFile: (input) => P.uploadSlackChannelFile(projectId, input),
+            },
+            teams: {
+                completeInstall: (input) => P.completeTeamsInstall(projectId, input),
+            },
+            email: {
+                installation: (connectorSlug) => P.getEmailInstallation(projectId, connectorSlug),
+                mode: () => P.getEmailMode(projectId),
+                connect: (input) => P.connectEmail(projectId, input),
+                disconnect: (connectorSlug) => P.disconnectEmail(projectId, connectorSlug),
+                updatePolicy: (...a) => P.updateEmailPolicy(projectId, ...a),
+            },
+        },
+        updateFeatureFlag: (...a) => P.updateFeatureFlag(projectId, ...a),
+        updateExperimentalFeature: (...a) => P.updateExperimentalFeature(projectId, ...a),
+        ...bindProjectPlatformSettings(projectId),
+    };
+}

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

@@ -0,0 +1,53 @@
+import * as P from '../rest/projects-client/index.js';
+import type { DropFirst } from './binding-types.js';
+export declare function bindProjectPlatformSettings(projectId: string): {
+    modelDefaults: {
+        get: () => Promise<P.ModelDefaultsResponse>;
+        set: (input: Parameters<typeof P.setModelDefault>[1]) => Promise<{
+            ok: boolean;
+            scope: string;
+            agentName?: string;
+            model: string;
+        }>;
+        clear: (params: Parameters<typeof P.clearModelDefault>[1]) => Promise<{
+            ok: boolean;
+        }>;
+    };
+    setDefaultAgent: (agentName: string) => Promise<P.UpdateProjectDefaultAgentResponse>;
+    sandbox: {
+        list: () => Promise<P.SandboxTemplatesResponse>;
+        snapshots: () => Promise<P.ProjectSnapshotsResponse>;
+        rebuildSnapshot: (slug?: string) => Promise<P.RebuildSnapshotResponse>;
+        fixWithAgent: () => Promise<{
+            session_id: string;
+        }>;
+        createTemplate: (input: Parameters<typeof P.createSandboxTemplate>[1]) => Promise<{
+            template_id: string;
+            slug: string;
+        }>;
+        updateTemplate: (templateId: string, input: P.UpdateSandboxTemplateInput) => Promise<{
+            template_id: string;
+            slug: string;
+        }>;
+        removeTemplate: (templateId: string) => Promise<null>;
+        buildTemplate: (templateId: string) => Promise<{
+            status: "started";
+            template_id: string;
+            slug: string;
+            providers?: Array<"daytona" | "platinum" | "e2b">;
+        }>;
+        setProvider: (provider: Parameters<typeof P.updateProjectSandboxProvider>[1]) => Promise<P.UpdateProjectSandboxProviderResult>;
+    };
+    setAgentScope: (agentName: string, scope: {
+        env?: P.AgentGrantSet;
+        connectors?: P.AgentGrantSet;
+        connectors_required?: string[];
+        connectors_personal?: string[];
+    }) => Promise<{
+        ok: boolean;
+        agent: string;
+        env: P.AgentGrantSet;
+        connectors: P.AgentGrantSet;
+        connectors_required: string[];
+    }>;
+};

package/dist/core/client/project-platform-settings.js

@@ -0,0 +1,23 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindProjectPlatformSettings(projectId) {
+    return {
+        modelDefaults: {
+            get: () => P.getModelDefaults(projectId),
+            set: (input) => P.setModelDefault(projectId, input),
+            clear: (params) => P.clearModelDefault(projectId, params),
+        },
+        setDefaultAgent: (agentName) => P.updateProjectDefaultAgent(projectId, agentName),
+        sandbox: {
+            list: () => P.listProjectSandboxes(projectId),
+            snapshots: () => P.listProjectSnapshots(projectId),
+            rebuildSnapshot: (slug) => P.rebuildProjectSnapshot(projectId, slug),
+            fixWithAgent: () => P.fixSandboxWithAgent(projectId),
+            createTemplate: (input) => P.createSandboxTemplate(projectId, input),
+            updateTemplate: (...a) => P.updateSandboxTemplate(projectId, ...a),
+            removeTemplate: (templateId) => P.deleteSandboxTemplate(projectId, templateId),
+            buildTemplate: (templateId) => P.buildSandboxTemplate(projectId, templateId),
+            setProvider: (provider) => P.updateProjectSandboxProvider(projectId, provider),
+        },
+        setAgentScope: (...a) => P.setAgentScope(projectId, ...a),
+    };
+}

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

@@ -0,0 +1,7 @@
+import * as P from '../rest/projects-client/index.js';
+import type { SessionBindingContext } from './session-context.js';
+import type { SessionModel } from './session-shared.js';
+export declare function bindSessionActionsResources(ctx: SessionBindingContext): {
+    setModel: (model: SessionModel | undefined) => void;
+    changeModel: (model: string) => Promise<P.SessionModelChangeResult>;
+};

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

@@ -0,0 +1,13 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindSessionActionsResources(ctx) {
+    return {
+        setModel: (model) => {
+            ctx.model = model;
+        },
+        changeModel: async (model) => {
+            const result = await P.setProjectSessionModel(ctx.projectId, ctx.sessionId, model);
+            ctx.clearPersistedDefaults();
+            return result;
+        },
+    };
+}

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

@@ -0,0 +1,22 @@
+import * as P from '../rest/projects-client/index.js';
+import type { SessionBindingContext } from './session-context.js';
+import type { SessionModel } from './session-shared.js';
+export declare function bindSessionActionsSecurity(ctx: SessionBindingContext): {
+    scope: () => Promise<P.SessionScope>;
+    providerSecretPool: {
+        list: () => Promise<{
+            pools: P.SessionProviderSecretPool[];
+            can_edit: boolean;
+            personal_user_id?: string | null;
+            personal_keys_reason?: "shared" | "prompted_by_another_member" | "no_person" | null;
+        }>;
+        get: (providerId: string) => Promise<P.SessionProviderSecretPool>;
+        set: (providerId: string, secretIds: string[] | null) => Promise<P.SessionProviderSecretPool>;
+    };
+    rescope: (scope: P.SessionScopeInput) => Promise<P.SessionScope>;
+    setAgent: (agent: string | undefined) => void;
+    send: (text: string, opts?: {
+        model?: SessionModel;
+        agent?: string;
+    }) => Promise<P.CreateSessionPromptResult>;
+};

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

@@ -0,0 +1,38 @@
+import { ApiError } from '../http/api/errors.js';
+import { mintWireMessageId } from '../session/wire-message-id.js';
+import * as P from '../rest/projects-client/index.js';
+export function bindSessionActionsSecurity(ctx) {
+    return {
+        scope: () => P.getProjectSessionScope(ctx.projectId, ctx.sessionId),
+        providerSecretPool: {
+            list: () => P.listSessionProviderSecretPools(ctx.projectId, ctx.sessionId),
+            get: (providerId) => P.getSessionProviderSecretPool(ctx.projectId, ctx.sessionId, providerId),
+            set: (providerId, secretIds) => P.setSessionProviderSecretPool(ctx.projectId, ctx.sessionId, providerId, secretIds),
+        },
+        rescope: (scope) => P.setProjectSessionScope(ctx.projectId, ctx.sessionId, scope),
+        setAgent: (agent) => {
+            ctx.agent = agent;
+        },
+        send: async (text, opts) => {
+            await ctx.ensureReady();
+            const selectedModel = opts?.model ?? ctx.model;
+            const selectedAgent = opts?.agent ?? ctx.agent;
+            const persisted = selectedModel && selectedAgent ? {} : await ctx.persistedPromptDefaults();
+            const model = selectedModel ?? persisted.model;
+            const agent = selectedAgent ?? persisted.agent;
+            const messageId = mintWireMessageId();
+            const result = await P.createSessionPrompt(ctx.projectId, ctx.sessionId, {
+                clientMessageId: messageId,
+                messageId,
+                remintOnDelivery: true,
+                parts: [{ type: 'text', text }],
+                clientSentAtMs: Date.now(),
+                ...(model || agent ? { overrides: { ...(model ? { model } : {}), ...(agent ? { agent } : {}) } } : {}),
+            });
+            if (result.state === 'failed') {
+                throw new ApiError('This prompt was refused: its earlier delivery already failed.', { code: 'PROMPT_FAILED' });
+            }
+            return result;
+        },
+    };
+}

package/dist/core/client/session-actions-services.d.ts

@@ -0,0 +1,39 @@
+import { type EventStreamHandle, type RuntimeEvent } from '../stream/event-stream.js';
+import type { SessionBindingContext } from './session-context.js';
+export declare function bindSessionActionsServices(ctx: SessionBindingContext): {
+    abort: () => Promise<({
+        data: undefined;
+        error: unknown;
+    } | {
+        data: boolean;
+        error: undefined;
+    }) & {
+        request: Request;
+        response: Response;
+    }>;
+    rewind: (messageId: string) => Promise<({
+        data: undefined;
+        error: unknown;
+    } | {
+        data: import("../../index.js").Session;
+        error: undefined;
+    }) & {
+        request: Request;
+        response: Response;
+    }>;
+    restoreRewind: () => Promise<({
+        data: undefined;
+        error: unknown;
+    } | {
+        data: import("../../index.js").Session;
+        error: undefined;
+    }) & {
+        request: Request;
+        response: Response;
+    }>;
+    stream: (opts: {
+        onEvent: (event: RuntimeEvent) => void;
+        onGapRehydrate?: (gapMs: number) => void;
+        signal?: AbortSignal;
+    }) => Promise<EventStreamHandle>;
+};

package/dist/core/client/session-actions-services.js

@@ -0,0 +1,34 @@
+import { getClientForUrl } from '../runtime/client.js';
+import { openEventStream } from '../stream/event-stream.js';
+export function bindSessionActionsServices(ctx) {
+    return {
+        abort: async () => {
+            const { runtimeSessionId, runtimeUrl } = await ctx.ensureReady();
+            return getClientForUrl(runtimeUrl).session.abort({
+                sessionID: runtimeSessionId,
+            });
+        },
+        rewind: async (messageId) => {
+            const { runtimeSessionId, runtimeUrl } = await ctx.ensureReady();
+            return getClientForUrl(runtimeUrl).session.revert({
+                sessionID: runtimeSessionId,
+                messageID: messageId,
+            });
+        },
+        restoreRewind: async () => {
+            const { runtimeSessionId, runtimeUrl } = await ctx.ensureReady();
+            return getClientForUrl(runtimeUrl).session.unrevert({
+                sessionID: runtimeSessionId,
+            });
+        },
+        stream: async (opts) => {
+            const { runtimeUrl } = await ctx.ensureReady();
+            return openEventStream({
+                url: runtimeUrl,
+                onEvent: opts.onEvent,
+                onGapRehydrate: opts.onGapRehydrate,
+                signal: opts.signal,
+            });
+        },
+    };
+}

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

@@ -0,0 +1,21 @@
+import type { ResolvedPreviewOptions } from '../session/preview-options.js';
+import type { SessionRuntimeEntry } from '../session/session-runtime-registry.js';
+import type { SessionModel } from './session-shared.js';
+export type SessionBindingContext = {
+    projectId: string;
+    sessionId: string;
+    ensureReady: (opts?: {
+        readyTimeoutMs?: number;
+    }) => Promise<SessionRuntimeEntry>;
+    tryResolveReady: () => SessionRuntimeEntry | null;
+    requireReady: (action: string) => SessionRuntimeEntry;
+    forgetReady: () => void;
+    resolvePreviewOptsForSandbox: (sandboxId: string) => ResolvedPreviewOptions;
+    model: SessionModel | undefined;
+    agent: string | undefined;
+    clearPersistedDefaults: () => void;
+    persistedPromptDefaults: () => Promise<{
+        model?: SessionModel;
+        agent?: string;
+    }>;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import type { SessionModel } from './session-shared.js';
+export declare function bindSessionDefaults(projectId: string, sessionId: string): {
+    persistedPromptDefaults: () => Promise<{
+        model?: SessionModel;
+        agent?: string;
+    }>;
+    clearPersistedDefaults: () => void;
+};

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

@@ -0,0 +1,35 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindSessionDefaults(projectId, sessionId) {
+    let _persistedPromptDefaults = null;
+    async function persistedPromptDefaults() {
+        if (!_persistedPromptDefaults) {
+            _persistedPromptDefaults = P.getProjectSession(projectId, sessionId, {
+                showErrors: false,
+            }).then((projectSession) => {
+                const modelReference = P.sessionModelPin(projectSession) ?? '';
+                const separator = modelReference.indexOf('/');
+                const model = separator > 0 && separator < modelReference.length - 1
+                    ? {
+                        providerID: modelReference.slice(0, separator),
+                        modelID: modelReference.slice(separator + 1),
+                    }
+                    : undefined;
+                const agent = projectSession.agent_name?.trim() || undefined;
+                return { model, agent };
+            });
+        }
+        try {
+            return await _persistedPromptDefaults;
+        }
+        catch (error) {
+            _persistedPromptDefaults = null;
+            throw error;
+        }
+    }
+    return {
+        persistedPromptDefaults,
+        clearPersistedDefaults: () => {
+            _persistedPromptDefaults = null;
+        },
+    };
+}

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

@@ -0,0 +1,20 @@
+import * as F from '../files/client.js';
+import type { SessionRuntimeEntry } from '../session/session-runtime-registry.js';
+export declare function bindSessionFiles(ensureReady: () => Promise<SessionRuntimeEntry>): {
+    list: (dirPath: string) => Promise<F.FileNode[]>;
+    read: (filePath: string) => Promise<F.FileContent>;
+    readBlob: (filePath: string) => Promise<Blob>;
+    status: () => Promise<F.GitFileStatus[]>;
+    findFiles: (query: string, options?: {
+        type?: "file" | "directory";
+        limit?: number;
+    }) => Promise<string[]>;
+    findText: (pattern: string) => Promise<F.FindMatch[]>;
+    upload: (file: File | Blob, targetPath?: string, filename?: string, options?: F.UploadFileOptions) => Promise<F.UploadResult[]>;
+    write: (filePath: string, content: Blob | File) => Promise<F.WriteFileResult>;
+    create: (filePath: string) => Promise<F.UploadResult[]>;
+    copy: (sourcePath: string, destPath: string) => Promise<F.UploadResult[]>;
+    remove: (filePath: string) => Promise<boolean>;
+    mkdir: (dirPath: string) => Promise<boolean>;
+    rename: (from: string, to: string) => Promise<boolean>;
+};

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

@@ -0,0 +1,18 @@
+import * as F from '../files/client.js';
+export function bindSessionFiles(ensureReady) {
+    return {
+        list: async (dirPath) => F.listFiles(dirPath, (await ensureReady()).runtimeUrl),
+        read: async (filePath) => F.readFile(filePath, (await ensureReady()).runtimeUrl),
+        readBlob: async (filePath) => F.readBlob(filePath, (await ensureReady()).runtimeUrl),
+        status: async () => F.getFileStatus((await ensureReady()).runtimeUrl),
+        findFiles: async (query, options) => F.findFiles(query, options, (await ensureReady()).runtimeUrl),
+        findText: async (pattern) => F.findText(pattern, (await ensureReady()).runtimeUrl),
+        upload: async (file, targetPath, filename, options) => F.uploadFile(file, targetPath, filename, (await ensureReady()).runtimeUrl, options),
+        write: async (filePath, content) => F.writeFile(filePath, content, (await ensureReady()).runtimeUrl),
+        create: async (filePath) => F.createFile(filePath, (await ensureReady()).runtimeUrl),
+        copy: async (sourcePath, destPath) => F.copyFile(sourcePath, destPath, (await ensureReady()).runtimeUrl),
+        remove: async (filePath) => F.deleteFile(filePath, (await ensureReady()).runtimeUrl),
+        mkdir: async (dirPath) => F.mkdir(dirPath, (await ensureReady()).runtimeUrl),
+        rename: async (from, to) => F.renameFile(from, to, (await ensureReady()).runtimeUrl),
+    };
+}