@beeuni/sdk 0.1.0

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

@@ -0,0 +1,670 @@
+import { type ApiClientOptions } from '../../http/api-client.js';
+import type { AuditEvent } from './audit.js';
+import { type ConnectorSharing } from './shared.js';
+export type ProjectSessionStatus = 'queued' | 'branching' | 'provisioning' | 'running' | 'stopped' | 'failed' | 'completed';
+export interface ProjectSessionMetadata {
+    spawned_by_session?: string;
+    [key: string]: unknown;
+}
+export type ProjectSessionInitiatorType = 'member' | 'trigger' | 'channel' | 'api' | 'system';
+export interface ProjectSessionInitiator {
+    type: ProjectSessionInitiatorType;
+    id: string | null;
+    label: string | null;
+}
+export interface ProjectSession {
+    session_id: string;
+    account_id: string;
+    project_id: string;
+    branch_name: string;
+    base_ref: string;
+    sandbox_provider: 'daytona' | 'platinum' | 'e2b' | null;
+    sandbox_id: string | null;
+    sandbox_url: string | null;
+    runtime_session_id?: string | null;
+    opencode_session_id: string | null;
+    name: string | null;
+    custom_name: string | null;
+    labels?: string[];
+    agent_name: string | null;
+    status: ProjectSessionStatus;
+    error: string | null;
+    metadata: ProjectSessionMetadata;
+    runtime_sessions?: ProjectRuntimeSession[];
+    opencode_sessions: ProjectRuntimeSession[];
+    created_by?: string | null;
+    parent_session_id?: string | null;
+    initiator?: ProjectSessionInitiator | null;
+    child_count?: number;
+    search_match?: 'self' | 'child';
+    owner_email?: string | null;
+    owner_name?: string | null;
+    owner_avatar_url?: string | null;
+    owner_type?: 'user' | 'service_account' | 'unknown' | null;
+    visibility?: 'private' | 'project' | 'restricted';
+    origin?: 'user' | 'trigger' | 'schedule' | 'backend' | 'system';
+    secrets_allowlist?: string[] | null;
+    sharing?: ConnectorSharing | null;
+    is_owner?: boolean;
+    can_manage_sharing?: boolean;
+    can_manage_lifecycle?: boolean;
+    can_access?: boolean;
+    runtime_status?: 'provisioning' | 'active' | 'stopped' | 'error' | 'archived' | null;
+    deleted_at?: string | null;
+    deleted_by?: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export declare function sessionParentId(session: Pick<ProjectSession, 'session_id'> & {
+    parent_session_id?: string | null;
+    metadata?: ProjectSessionMetadata;
+}): string | null;
+export type SessionRuntimeContextScalar = string | number | boolean | null;
+export type SessionRuntimeContext = Record<string, SessionRuntimeContextScalar>;
+export interface SessionConnectorBinding {
+    connection_id: string;
+}
+export type SessionConnectorBindings = Record<string, SessionConnectorBinding>;
+export type SessionConnectorBindingInput = SessionConnectorBinding;
+export type SessionConnectorBindingsInput = Record<string, SessionConnectorBindingInput>;
+export interface PendingSessionPrompt {
+    text: string;
+    agent?: string | null;
+    model?: {
+        providerID: string;
+        modelID: string;
+    } | null;
+    variant?: string | null;
+    attachment_names?: string[];
+    parts?: SessionPromptPart[];
+}
+export interface CreateProjectSessionInput {
+    base_ref?: string;
+    agent_name?: string;
+    sandbox_slug?: string;
+    initial_prompt?: string;
+    pending_prompt?: PendingSessionPrompt;
+    model?: string;
+    opencode_model?: string;
+    name?: string;
+    labels?: string[];
+    session_id?: string;
+    provider?: 'daytona' | 'platinum' | 'e2b';
+    persistent_machine?: boolean;
+    branch_already_created?: boolean;
+    metadata?: Record<string, unknown>;
+    runtime_context?: SessionRuntimeContext;
+    connector_bindings?: SessionConnectorBindingsInput;
+    inherit_unbound?: boolean;
+    require_connectors?: string[];
+    secrets?: string[];
+}
+export interface WarmProjectSessionWorkspaceRefresh {
+    status: 'skipped' | 'unchanged' | 'updated' | 'failed';
+    before_sha?: string | null;
+    after_sha?: string | null;
+    error?: string;
+}
+export interface WarmProjectSessionResult {
+    session: ProjectSession;
+    reused: boolean;
+    workspace_refresh: WarmProjectSessionWorkspaceRefresh;
+}
+export interface ClaimWarmProjectSessionInput {
+    session_id: string;
+    agent_name?: string;
+    sandbox_slug?: string;
+    pending_prompt?: PendingSessionPrompt;
+}
+export interface ProjectRuntimeSession {
+    id: string;
+    title: string | null;
+    parent_id: string | null;
+    project_id: string | null;
+    created_at: number | null;
+    updated_at: number | null;
+    archived_at: number | null;
+}
+export type ProjectOpenCodeSession = ProjectRuntimeSession;
+export declare const PROJECT_SESSION_PAGE_DEFAULT_LIMIT = 50;
+export declare const PROJECT_SESSION_PAGE_MAX_LIMIT = 200;
+export declare const PROJECT_SESSION_NAME_LOOKUP_LIMIT = 200;
+export interface ListProjectSessionsOptions {
+    scope?: 'visible' | 'project';
+    limit?: number;
+    cursor?: string | null;
+    parent?: 'root' | string;
+    startedBy?: 'me' | 'others' | 'automated';
+    q?: string;
+    labels?: string[];
+}
+export interface ProjectSessionPage {
+    items: ProjectSession[];
+    next_cursor: string | null;
+}
+export declare function listProjectSessionsPage(projectId: string, options?: ListProjectSessionsOptions): Promise<ProjectSessionPage>;
+export declare function listProjectSessions(projectId: string, options?: ListProjectSessionsOptions): Promise<ProjectSession[]>;
+export declare function setProjectSessionSharing(projectId: string, sessionId: string, intent: ConnectorSharing): Promise<ProjectSession>;
+export interface SessionParticipant {
+    user_id: string;
+    name: string | null;
+    email: string | null;
+    avatar_url: string | null;
+    is_viewer: boolean;
+}
+export interface SessionParticipants {
+    participants: SessionParticipant[];
+    total: number;
+    multi_user: boolean;
+}
+export declare function getSessionParticipants(projectId: string, sessionId: string): Promise<SessionParticipants>;
+export declare function getSessionWatch(projectId: string, sessionId: string): Promise<{
+    watching: boolean;
+}>;
+export declare function setSessionWatch(projectId: string, sessionId: string, watching: boolean): Promise<{
+    watching: boolean;
+}>;
+export interface SessionPreviewCandidate {
+    id: string;
+    label: string;
+    port: number;
+    path: string;
+    status: 'online' | 'offline' | 'unknown';
+    source: string;
+}
+export interface SessionPublicShare {
+    share_id: string;
+    session_id: string;
+    project_id: string;
+    resource_type: 'preview' | 'file' | 'transcript' | string;
+    label: string;
+    port: number | null;
+    path: string;
+    file_path: string | null;
+    mode: 'view' | 'interactive' | string;
+    allow_websocket: boolean;
+    expires_at: string | null;
+    revoked_at: string | null;
+    created_at: string;
+    updated_at: string;
+    public_token?: string;
+    public_path?: string;
+    proxy_path?: string;
+    public_url?: string | null;
+}
+export interface CreateSessionPublicShareInput {
+    transcript?: boolean;
+    preview_id?: string;
+    preview?: {
+        label?: string;
+        url?: string;
+        port?: number;
+        path?: string;
+    };
+    file?: {
+        label?: string;
+        path: string;
+    };
+    mode?: 'view' | 'interactive';
+    label?: string;
+    expires_at?: string | null;
+}
+export declare function resolvePublicShareUrl(share: Pick<SessionPublicShare, 'public_url' | 'public_path' | 'proxy_path' | 'public_token'>, origin?: string): string;
+export declare function findActiveTranscriptShare(shares: readonly SessionPublicShare[], now?: Date): SessionPublicShare | null;
+export declare function getSessionPreviewCandidates(projectId: string, sessionId: string): Promise<{
+    candidates: SessionPreviewCandidate[];
+}>;
+export declare function listSessionPublicShares(projectId: string, sessionId: string): Promise<{
+    shares: SessionPublicShare[];
+}>;
+export declare function createSessionPublicShare(projectId: string, sessionId: string, input: CreateSessionPublicShareInput): Promise<{
+    share: SessionPublicShare;
+}>;
+export declare function revokeSessionPublicShare(projectId: string, sessionId: string, shareId: string): Promise<{
+    share: SessionPublicShare;
+}>;
+export declare function createProjectSession(projectId: string, input?: CreateProjectSessionInput): Promise<ProjectSession>;
+export interface EnsureWarmProjectSessionOptions {
+    excludeSessionId?: string;
+}
+export declare function ensureWarmProjectSession(projectId: string, options?: EnsureWarmProjectSessionOptions): Promise<WarmProjectSessionResult>;
+export declare function claimWarmProjectSession(projectId: string, input: ClaimWarmProjectSessionInput): Promise<ProjectSession>;
+export declare function getProjectSession(projectId: string, sessionId: string, options?: {
+    showErrors?: boolean;
+}): Promise<ProjectSession>;
+export interface SessionAuditAction {
+    execution_id: string;
+    action: string;
+    connector_id: string | null;
+    connector?: string | null;
+    status: string;
+    risk: string | null;
+    acted_by: string | null;
+    acted_by_email: string | null;
+    resolved_by: string | null;
+    resolved_by_email: string | null;
+    result_summary: Record<string, unknown> | null;
+    at: string;
+    resolved_at: string | null;
+    approval_url?: string | null;
+}
+export interface SessionAudit {
+    session_id: string;
+    agent: string | null;
+    audit_access?: boolean;
+    count: number;
+    events?: AuditEvent[];
+    next_cursor?: string | null;
+    actions: SessionAuditAction[];
+}
+export declare function getSessionAudit(projectId: string, sessionId: string, limit?: number, options?: {
+    showErrors?: boolean;
+    cursor?: string;
+    includeEvents?: boolean;
+}): Promise<SessionAudit>;
+export interface SessionTranscriptToolCall {
+    tool: string;
+    status: string | null;
+}
+export interface SessionTranscriptMessage {
+    role: string;
+    created: string | null;
+    completed: string | null;
+    text: string;
+    tools: SessionTranscriptToolCall[];
+    files: Array<{
+        filename: string | null;
+        mime: string | null;
+    }>;
+    reasoning_omitted: boolean;
+    error: {
+        name?: string;
+        message?: string;
+    } | null;
+}
+export type SessionTranscriptSource = 'live' | 'mirror' | 'none';
+export interface SessionTranscript {
+    available: boolean;
+    reason: string | null;
+    source: SessionTranscriptSource;
+    complete: boolean;
+    captured_at: string | null;
+    runtime_session_id?: string | null;
+    opencode_session_id: string | null;
+    message_count: number;
+    messages: SessionTranscriptMessage[];
+}
+export interface SessionTranscriptSyncMessage {
+    info: Record<string, unknown>;
+    parts: Array<Record<string, unknown>>;
+}
+export interface SessionTranscriptSyncEnvelope {
+    available: boolean;
+    reason: string | null;
+    source: SessionTranscriptSource;
+    complete: boolean;
+    captured_at: string | null;
+    runtime_session_id?: string | null;
+    opencode_session_id: string | null;
+    message_count: number;
+    total?: number;
+    next_cursor?: string | null;
+    messages: SessionTranscriptSyncMessage[];
+}
+export declare function getSessionTranscript(projectId: string, sessionId: string, options?: {
+    limit?: number;
+    chars?: number;
+}): Promise<SessionTranscript>;
+export declare function getSessionTranscriptSync(projectId: string, sessionId: string, options?: {
+    limit?: number;
+    signal?: AbortSignal;
+    history?: boolean;
+    before?: string | null;
+    child?: string | null;
+}): Promise<SessionTranscriptSyncEnvelope>;
+export type SessionTurnState = 'delivering' | 'active';
+export interface SessionTurn {
+    turn_token: string;
+    state: SessionTurnState;
+    message_id: string | null;
+    runtime_session_id?: string | null;
+    opencode_session_id: string | null;
+    started_at: string | null;
+    accepted_at: string | null;
+}
+export interface SessionTurnEndError {
+    name: string | null;
+    message: string | null;
+}
+export interface SessionTurnFailure {
+    message_id: string;
+    ended_at: string | null;
+    error: SessionTurnEndError | null;
+}
+export interface SessionTurnEnded {
+    turn_token: string;
+    message_id?: string;
+    end_reason: string | null;
+    ended_at: string | null;
+    error?: SessionTurnEndError;
+}
+export interface SessionTurnStatus {
+    turns: SessionTurn[];
+    last_ended?: SessionTurnEnded;
+    recent_failures?: SessionTurnFailure[];
+}
+export declare function getSessionTurn(projectId: string, sessionId: string): Promise<SessionTurnStatus>;
+export interface SessionOpenBundleUnknown {
+    known: false;
+    reason: string;
+}
+export type SessionOpenBundleTurn = ({
+    known: true;
+} & SessionTurnStatus) | SessionOpenBundleUnknown;
+export type SessionOpenBundleQueue = {
+    known: true;
+    prompts: SessionPrompt[];
+    held: boolean;
+} | SessionOpenBundleUnknown;
+export type SessionOpenBundleTranscript = {
+    known: true;
+    requested: false;
+} | ({
+    known: true;
+    requested: true;
+} & SessionTranscriptSyncEnvelope) | SessionOpenBundleUnknown;
+export interface SessionOpenBundleConfig {
+    known: true;
+    base_ref: string | null;
+    agent_name: string | null;
+    llm_gateway_enabled: boolean;
+}
+export type SessionOpenBundleModels = {
+    known: true;
+    platformDefault: string | null;
+    accountDefault: string | null;
+    agentDefaults: Record<string, string>;
+    projectDefault: string | null;
+    resolvedForCaller: string | null;
+    resolvedSource: string;
+    freeTier: boolean;
+} | SessionOpenBundleUnknown;
+export type SessionOpenBundleAudit = {
+    known: true;
+    session_id: string;
+    agent: string | null;
+    audit_access: boolean;
+    count: number;
+    actions: SessionAuditAction[];
+} | SessionOpenBundleUnknown;
+export type SessionOpenBundleRuntime = {
+    known: true;
+    fresh: boolean;
+    source: 'daemon_push' | 'api_pull';
+    captured_at: string;
+    age_ms: number;
+    runtime_running: boolean;
+    epoch: string | null;
+    seq: number | null;
+    identity: {
+        schema: string | null;
+        harness: string | null;
+        runtime_session_id: string | null;
+        harness_version: string | null;
+        opencode_session_id: string | null;
+        opencode_version: string | null;
+        daemon_build: number | null;
+        agent_config_etag: string | null;
+        head_seq: Record<string, number> | null;
+    };
+    state: Record<string, unknown>;
+} | SessionOpenBundleUnknown;
+export interface SessionOpenBundle {
+    observed_at: string;
+    session: ProjectSession;
+    turn: SessionOpenBundleTurn;
+    queue: SessionOpenBundleQueue;
+    transcript: SessionOpenBundleTranscript;
+    config: SessionOpenBundleConfig;
+    models: SessionOpenBundleModels;
+    runtime?: SessionOpenBundleRuntime;
+    audit: SessionOpenBundleAudit;
+}
+export declare function getSessionOpenBundle(projectId: string, sessionId: string, options?: {
+    transcript?: number;
+    signal?: AbortSignal;
+}): Promise<SessionOpenBundle>;
+export interface SessionPromptPart {
+    type: 'text' | 'file' | 'agent';
+    text?: string;
+    mime?: string;
+    url?: string;
+    attachment_id?: string;
+    filename?: string;
+    name?: string;
+    source?: unknown;
+}
+export interface SessionPromptOverrides {
+    agent?: string | null;
+    model?: {
+        providerID: string;
+        modelID: string;
+    } | null;
+    variant?: string | null;
+    directory?: string | null;
+}
+export type SessionPromptState = 'queued' | 'delivering' | 'waiting' | 'failed';
+export type SessionPromptDelivery = 'steer' | 'queue' | 'interrupt';
+export type SessionPromptSteerFallback = 'unsupported' | 'not_prompter' | 'turn_ended';
+export interface SessionPrompt {
+    placement?: 'transcript' | 'composer';
+    delivery?: SessionPromptDelivery;
+    steer_fallback?: SessionPromptSteerFallback | null;
+    full_text?: string;
+    prompt_id: string;
+    client_message_id: string;
+    message_id: string;
+    wire_message_id?: string;
+    state: SessionPromptState;
+    reason: string | null;
+    text: string;
+    client_sent_at_ms?: number | null;
+    attempts: number;
+    runtime_retries?: number;
+    last_error: string | null;
+    attachments?: Array<{
+        filename: string;
+        mime: string;
+    }>;
+    no_reply?: boolean;
+    author_user_id?: string | null;
+    created_at: string;
+    available_at: string;
+}
+export interface CreateSessionPromptResult {
+    prompt_id: string;
+    state: SessionPromptState;
+    message_id: string;
+    deduped: boolean;
+    observed_at?: string;
+}
+export interface CreateSessionPromptInput {
+    placement?: 'transcript' | 'composer';
+    delivery?: SessionPromptDelivery;
+    clientMessageId: string;
+    messageId: string;
+    parts: SessionPromptPart[];
+    overrides?: SessionPromptOverrides;
+    remintOnDelivery?: boolean;
+    clientSentAtMs?: number;
+}
+export declare function createSessionPrompt(projectId: string, sessionId: string, input: CreateSessionPromptInput): Promise<CreateSessionPromptResult>;
+export declare function listSessionPrompts(projectId: string, sessionId: string): Promise<{
+    prompts: SessionPrompt[];
+    observed_at?: string;
+}>;
+export interface RemovedSessionPrompt {
+    placement?: 'transcript' | 'composer';
+    prompt_id: string;
+    client_message_id: string;
+    message_id: string;
+    removed_message_ids?: string[];
+    parts: SessionPromptPart[];
+    overrides: SessionPromptOverrides | null;
+}
+export declare function deleteSessionPrompt(projectId: string, sessionId: string, promptId: string): Promise<RemovedSessionPrompt>;
+export declare function editSessionPrompt(projectId: string, sessionId: string, promptId: string, text: string): Promise<SessionPrompt>;
+export declare function interruptSessionPrompt(projectId: string, sessionId: string, promptId: string): Promise<SessionPrompt>;
+export declare function retrySessionPrompt(projectId: string, sessionId: string, promptId: string): Promise<SessionPrompt>;
+export declare function holdSessionPrompts(projectId: string, sessionId: string, held: boolean): Promise<{
+    prompts: SessionPrompt[];
+    observed_at?: string;
+}>;
+export interface UpdateProjectSessionInput {
+    name?: string | null;
+    labels?: string[];
+    metadata?: Record<string, unknown>;
+}
+export declare function updateProjectSession(projectId: string, sessionId: string, input: UpdateProjectSessionInput): Promise<ProjectSession>;
+export declare function deleteProjectSession(projectId: string, sessionId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function restartProjectSession(projectId: string, sessionId: string, opts?: {
+    reset_machine?: boolean;
+    discard_state?: boolean;
+}): Promise<{
+    ok: boolean;
+    session_id: string;
+    status: string;
+    state_carried?: boolean | null;
+    warning?: string;
+}>;
+export declare function stopProjectSession(projectId: string, sessionId: string): Promise<{
+    ok: boolean;
+    session_id: string;
+    status: string;
+}>;
+export interface SessionConfigRelease {
+    mode: 'follow-base';
+    source: 'release' | 'image-default';
+    running_release_id: string | null;
+    desired_release_id: string | null;
+    proven: boolean;
+    fallback_reason: string | null;
+    failed_release_id: string | null;
+}
+export interface SessionManagedCatalogState {
+    ids: string[] | null;
+    fallback_reason: string | null;
+}
+export interface SessionConfigState {
+    base_ref: string;
+    running_etag: string | null;
+    latest_etag: string | null;
+    commit_sha: string | null;
+    stale: boolean | null;
+    sandbox_reachable: boolean;
+    release?: SessionConfigRelease;
+    managed_catalog?: SessionManagedCatalogState;
+}
+export declare function getProjectSessionConfigState(projectId: string, sessionId: string): Promise<SessionConfigState>;
+export interface SessionReloadResult {
+    applied: boolean;
+    previous_etag: string | null;
+    etag: string | null;
+    repo_refreshed: boolean;
+    commit_sha: string | null;
+    agent_files?: 'updated' | 'already-current' | 'kept-yours' | 'not-applicable' | 'not-requested' | 'unknown';
+    opencode_reload?: 'disposed' | 'restarted' | 'kept-old' | null;
+    turn_ended?: boolean | null;
+    reason?: string;
+    detail: string;
+    release?: SessionConfigRelease;
+    workspace_checkout?: 'updated' | 'already-current' | 'not-requested' | 'refused';
+}
+export type SessionReloadPhase = 'checking-session' | 'refreshing-workspace' | 'compiling-config' | 'applying-config' | 'confirming-config';
+export type SessionReloadStreamEvent = {
+    type: 'phase';
+    phase: SessionReloadPhase;
+} | {
+    type: 'done';
+    result: SessionReloadResult;
+} | {
+    type: 'error';
+    error: string;
+    code?: string;
+    status?: number;
+    reason?: string;
+};
+export declare function reloadProjectSessionConfig(projectId: string, sessionId: string, input?: {
+    refresh_repo?: boolean;
+    force?: boolean;
+}): Promise<SessionReloadResult>;
+export declare function reloadProjectSessionConfigStream(projectId: string, sessionId: string, input: {
+    refresh_repo?: boolean;
+    force?: boolean;
+}, onEvent: (event: SessionReloadStreamEvent) => void, options?: ApiClientOptions): Promise<SessionReloadResult>;
+export interface SessionScopeInput {
+    secrets?: string[] | null;
+    connector_bindings?: SessionConnectorBindingsInput | null;
+    require_connectors?: string[] | null;
+}
+export interface SessionScope {
+    secrets_allowlist: string[] | null;
+    required_connectors: null;
+    connector_bindings: SessionConnectorBindings;
+    connector_bindings_configured: boolean;
+    connector_bindings_inherit_unbound: boolean;
+    dropped_secrets: string[];
+    added_secrets: string[];
+    dropped_bindings: string[];
+    retroactive: boolean;
+    detail: string;
+}
+export type SessionScopeResult = SessionScope;
+export declare function getProjectSessionScope(projectId: string, sessionId: string): Promise<SessionScope>;
+export declare function setProjectSessionScope(projectId: string, sessionId: string, scope: SessionScopeInput): Promise<SessionScope>;
+export interface SessionModelChangeResult {
+    model?: string;
+    opencode_model: string;
+    applied_live: boolean;
+    push_failed?: true;
+    detail?: string;
+}
+export declare function setProjectSessionModel(projectId: string, sessionId: string, model: string): Promise<SessionModelChangeResult>;
+export declare function sessionModelPin(session: {
+    metadata?: Record<string, unknown> | null;
+}): string | null;
+export type SessionMessageAuthor = {
+    kind: 'member';
+    user_id: string;
+    name: string;
+    email: string | null;
+    avatar_url?: string | null;
+} | {
+    kind: 'session';
+    session_id: string;
+    name: string;
+    agent?: string;
+};
+export interface SessionMessageAuthors {
+    authors: Record<string, SessionMessageAuthor>;
+    initial_author: SessionMessageAuthor | null;
+}
+export declare function getSessionMessageAuthors(projectId: string, sessionId: string): Promise<SessionMessageAuthors>;
+export interface SessionServedModel {
+    served_model: string;
+    fallback_from: string | null;
+    at: string;
+}
+export interface SessionTurnModelUsage {
+    served_models: string[];
+    fallback_from: string | null;
+    billed_cost: number;
+}
+export interface SessionModelUsage {
+    latest: SessionServedModel | null;
+    billed_cost: number;
+    turns: Record<string, SessionTurnModelUsage>;
+}
+export declare function getSessionModelUsage(projectId: string, sessionId: string): Promise<SessionModelUsage>;