@beeuni/sdk 0.1.0

package/dist/core/runtime/runtime-rest-client.d.ts

@@ -0,0 +1,414 @@
+import type { Agent, AgentPartInput, Auth, Command, Config, Event, FileContent, FileNode, FilePartInput, McpLocalConfig, McpRemoteConfig, McpStatus, OutputFormat, Path, PermissionRuleset, Project, Provider, ProviderAuthAuthorization, ProviderAuthMethod, Session, SubtaskPartInput, TextPartInput, ToolIds, ToolList, VcsFileDiff } from './runtime-types.js';
+import type { BeeuniAssistantMessageInfo, BeeuniFileDiff, BeeuniFilePartSource, BeeuniMessageInfo, BeeuniPart, BeeuniSessionStatus, BeeuniTodo, RuntimePermissionRequest, RuntimeQuestionAnswer, RuntimeQuestionRequest } from './transcript-types.js';
+export type RuntimeResult<T> = Promise<({
+    data: T;
+    error: undefined;
+} | {
+    data: undefined;
+    error: unknown;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+export interface RuntimeRequestOptions {
+    signal?: AbortSignal;
+    headers?: HeadersInit;
+}
+export interface RuntimeClientConfig {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    eventTransport?: RuntimeEventTransport;
+}
+export interface RuntimeEventMessage {
+    data?: string;
+    id?: string;
+    retry?: number;
+}
+export type RuntimeEventTransport = (request: {
+    url: string;
+    headers: Headers;
+    signal: AbortSignal;
+}) => AsyncIterable<RuntimeEventMessage>;
+export interface RuntimeEventStreamOptions {
+    signal?: AbortSignal;
+    headers?: HeadersInit;
+    sseDefaultRetryDelay?: number;
+    sseMaxRetryDelay?: number;
+    sseMaxRetryAttempts?: number;
+    onSseError?: (error: unknown) => void;
+}
+type Scope = {
+    directory?: string;
+    workspace?: string;
+};
+type PromptParts = Array<TextPartInput | FilePartInput | AgentPartInput | SubtaskPartInput>;
+type TranscriptMessage = {
+    info: BeeuniMessageInfo;
+    parts: BeeuniPart[];
+};
+type Reply = {
+    info: BeeuniAssistantMessageInfo;
+    parts: BeeuniPart[];
+};
+type Method<P, T> = (parameters: P, options?: RuntimeRequestOptions) => RuntimeResult<T>;
+type OptionalMethod<P, T> = (parameters?: P, options?: RuntimeRequestOptions) => RuntimeResult<T>;
+export interface RuntimeClient {
+    session: {
+        list: OptionalMethod<Scope & {
+            scope?: 'project';
+            path?: string;
+            roots?: boolean | 'true' | 'false';
+            start?: number;
+            search?: string;
+            limit?: number;
+        }, Session[]>;
+        get: Method<Scope & {
+            sessionID: string;
+        }, Session>;
+        create: OptionalMethod<Scope & {
+            parentID?: string;
+            title?: string;
+            agent?: string;
+            model?: {
+                id: string;
+                providerID: string;
+                variant?: string;
+            };
+            metadata?: {
+                [key: string]: unknown;
+            };
+            permission?: PermissionRuleset;
+            workspaceID?: string;
+        }, Session>;
+        delete: Method<Scope & {
+            sessionID: string;
+        }, boolean>;
+        update: Method<Scope & {
+            sessionID: string;
+            title?: string;
+            metadata?: {
+                [key: string]: unknown;
+            };
+            permission?: PermissionRuleset;
+            time?: {
+                archived?: number;
+            };
+        }, Session>;
+        status: OptionalMethod<Scope, {
+            [sessionID: string]: BeeuniSessionStatus;
+        }>;
+        messages: Method<Scope & {
+            sessionID: string;
+            limit?: number;
+            before?: string;
+        }, TranscriptMessage[]>;
+        prompt: Method<Scope & PromptInput, Reply>;
+        promptAsync: Method<Scope & PromptInput, {}>;
+        abort: Method<Scope & {
+            sessionID: string;
+        }, boolean>;
+        revert: Method<Scope & {
+            sessionID: string;
+            messageID?: string;
+            partID?: string;
+        }, Session>;
+        unrevert: Method<Scope & {
+            sessionID: string;
+        }, Session>;
+        summarize: Method<Scope & {
+            sessionID: string;
+            providerID?: string;
+            modelID?: string;
+            auto?: boolean;
+        }, boolean>;
+        command: Method<Scope & {
+            sessionID: string;
+            messageID?: string;
+            agent?: string;
+            model?: string;
+            arguments?: string;
+            command?: string;
+            variant?: string;
+            parts?: Array<{
+                id?: string;
+                type: 'file';
+                mime: string;
+                filename?: string;
+                url: string;
+                source?: BeeuniFilePartSource;
+            }>;
+        }, Reply>;
+        share: Method<Scope & {
+            sessionID: string;
+        }, Session>;
+        unshare: Method<Scope & {
+            sessionID: string;
+        }, Session>;
+        fork: Method<Scope & {
+            sessionID: string;
+            messageID?: string;
+        }, Session>;
+        diff: Method<Scope & {
+            sessionID: string;
+            messageID?: string;
+        }, BeeuniFileDiff[]>;
+        todo: Method<Scope & {
+            sessionID: string;
+        }, BeeuniTodo[]>;
+    };
+    permission: {
+        list: OptionalMethod<Scope, RuntimePermissionRequest[]>;
+        reply: Method<Scope & {
+            requestID: string;
+            reply?: 'once' | 'always' | 'reject';
+            message?: string;
+        }, boolean>;
+    };
+    question: {
+        list: OptionalMethod<Scope, RuntimeQuestionRequest[]>;
+        reply: Method<Scope & {
+            requestID: string;
+            answers?: RuntimeQuestionAnswer[];
+        }, boolean>;
+        reject: Method<Scope & {
+            requestID: string;
+        }, boolean>;
+    };
+    part: {
+        update: Method<Scope & {
+            sessionID: string;
+            messageID: string;
+            partID: string;
+            part?: BeeuniPart;
+        }, BeeuniPart>;
+        delete: Method<Scope & {
+            sessionID: string;
+            messageID: string;
+            partID: string;
+        }, boolean>;
+    };
+    file: {
+        list: Method<Scope & {
+            path: string;
+        }, FileNode[]>;
+        read: Method<Scope & {
+            path: string;
+        }, FileContent>;
+    };
+    find: {
+        files: Method<Scope & {
+            query: string;
+            dirs?: 'true' | 'false';
+            type?: 'file' | 'directory';
+            limit?: number;
+        }, string[]>;
+    };
+    vcs: {
+        diff: Method<Scope & {
+            mode: 'git' | 'branch';
+            context?: number;
+        }, VcsFileDiff[]>;
+    };
+    global: {
+        event: (options?: RuntimeEventStreamOptions) => Promise<{
+            stream: AsyncGenerator<Event | string, void, unknown>;
+        }>;
+        health: (options?: RuntimeRequestOptions) => RuntimeResult<{
+            healthy: true;
+            version: string;
+        }>;
+        dispose: (options?: RuntimeRequestOptions) => RuntimeResult<boolean>;
+        config: {
+            get: (options?: RuntimeRequestOptions) => RuntimeResult<Config>;
+            update: OptionalMethod<{
+                config?: Config;
+            }, Config>;
+        };
+    };
+    provider: {
+        list: OptionalMethod<Scope, {
+            all: Provider[];
+            default: {
+                [key: string]: string;
+            };
+            connected: string[];
+        }>;
+        auth: OptionalMethod<Scope, {
+            [providerID: string]: ProviderAuthMethod[];
+        }>;
+        oauth: {
+            authorize: Method<Scope & {
+                providerID: string;
+                method?: number;
+                inputs?: {
+                    [key: string]: string;
+                };
+            }, ProviderAuthAuthorization>;
+            callback: Method<Scope & {
+                providerID: string;
+                method?: number;
+                code?: string;
+            }, boolean>;
+        };
+    };
+    auth: {
+        set: Method<{
+            providerID: string;
+            auth?: Auth;
+        }, boolean>;
+    };
+    app: {
+        agents: OptionalMethod<Scope, Agent[]>;
+        skills: OptionalMethod<Scope, Array<{
+            name: string;
+            description?: string;
+            location: string;
+            content: string;
+        }>>;
+        log: OptionalMethod<Scope & {
+            service?: string;
+            level?: 'debug' | 'info' | 'error' | 'warn';
+            message?: string;
+            extra?: {
+                [key: string]: unknown;
+            };
+        }, boolean>;
+    };
+    command: {
+        list: OptionalMethod<Scope, Command[]>;
+    };
+    tool: {
+        ids: OptionalMethod<Scope, ToolIds>;
+        list: Method<Scope & {
+            provider: string;
+            model: string;
+        }, ToolList>;
+    };
+    mcp: {
+        status: OptionalMethod<Scope, {
+            [name: string]: McpStatus;
+        }>;
+        add: OptionalMethod<Scope & {
+            name?: string;
+            config?: McpLocalConfig | McpRemoteConfig;
+        }, {
+            [name: string]: McpStatus;
+        }>;
+        connect: Method<Scope & {
+            name: string;
+        }, boolean>;
+        disconnect: Method<Scope & {
+            name: string;
+        }, boolean>;
+        auth: {
+            start: Method<Scope & {
+                name: string;
+            }, {
+                authorizationUrl: string;
+                oauthState: string;
+            }>;
+            callback: Method<Scope & {
+                name: string;
+                code?: string;
+            }, McpStatus>;
+            remove: Method<Scope & {
+                name: string;
+            }, {
+                success: true;
+            }>;
+        };
+    };
+    project: {
+        list: OptionalMethod<Scope, Project[]>;
+        current: OptionalMethod<Scope, Project>;
+    };
+    path: {
+        get: OptionalMethod<Scope, Path>;
+    };
+}
+interface PromptInput {
+    sessionID: string;
+    messageID?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    agent?: string;
+    noReply?: boolean;
+    tools?: {
+        [key: string]: boolean;
+    };
+    format?: OutputFormat;
+    system?: string;
+    variant?: string;
+    parts?: PromptParts;
+}
+interface Route {
+    method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+    path: string;
+    query: readonly string[];
+    body: readonly string[];
+    bodyParam?: string;
+}
+export declare const RUNTIME_REST_ROUTES: {
+    readonly 'session.list': Route;
+    readonly 'session.get': Route;
+    readonly 'session.create': Route;
+    readonly 'session.delete': Route;
+    readonly 'session.update': Route;
+    readonly 'session.status': Route;
+    readonly 'session.messages': Route;
+    readonly 'session.prompt': Route;
+    readonly 'session.promptAsync': Route;
+    readonly 'session.abort': Route;
+    readonly 'session.revert': Route;
+    readonly 'session.unrevert': Route;
+    readonly 'session.summarize': Route;
+    readonly 'session.command': Route;
+    readonly 'session.share': Route;
+    readonly 'session.unshare': Route;
+    readonly 'session.fork': Route;
+    readonly 'session.diff': Route;
+    readonly 'session.todo': Route;
+    readonly 'permission.list': Route;
+    readonly 'permission.reply': Route;
+    readonly 'question.list': Route;
+    readonly 'question.reply': Route;
+    readonly 'question.reject': Route;
+    readonly 'part.update': Route;
+    readonly 'part.delete': Route;
+    readonly 'file.list': Route;
+    readonly 'file.read': Route;
+    readonly 'find.files': Route;
+    readonly 'vcs.diff': Route;
+    readonly 'global.health': Route;
+    readonly 'global.dispose': Route;
+    readonly 'global.config.get': Route;
+    readonly 'global.config.update': Route;
+    readonly 'provider.list': Route;
+    readonly 'provider.auth': Route;
+    readonly 'provider.oauth.authorize': Route;
+    readonly 'provider.oauth.callback': Route;
+    readonly 'auth.set': Route;
+    readonly 'app.agents': Route;
+    readonly 'app.skills': Route;
+    readonly 'app.log': Route;
+    readonly 'command.list': Route;
+    readonly 'tool.ids': Route;
+    readonly 'tool.list': Route;
+    readonly 'mcp.status': Route;
+    readonly 'mcp.add': Route;
+    readonly 'mcp.connect': Route;
+    readonly 'mcp.disconnect': Route;
+    readonly 'mcp.auth.start': Route;
+    readonly 'mcp.auth.callback': Route;
+    readonly 'mcp.auth.remove': Route;
+    readonly 'project.list': Route;
+    readonly 'project.current': Route;
+    readonly 'path.get': Route;
+};
+type RouteName = keyof typeof RUNTIME_REST_ROUTES;
+export declare function buildRuntimeRequest(baseUrl: string, name: RouteName, params?: Record<string, unknown>, options?: RuntimeRequestOptions): Request;
+export declare function fetchEventTransport(fetchFn?: typeof fetch): RuntimeEventTransport;
+export declare function createRuntimeRestClient(config: RuntimeClientConfig): RuntimeClient;
+export {};