@beeuni/sdk 0.1.0

package/dist/core/runtime/runtime-rest-client.js

@@ -0,0 +1,296 @@
+const SCOPE = ['directory', 'workspace'];
+const PROMPT_BODY = ['messageID', 'model', 'agent', 'noReply', 'tools', 'format', 'system', 'variant', 'parts'];
+const r = (method, path, query = SCOPE, body = [], bodyParam) => ({ method, path, query, body, bodyParam });
+export const RUNTIME_REST_ROUTES = {
+    'session.list': r('GET', '/session', [...SCOPE, 'scope', 'path', 'roots', 'start', 'search', 'limit']),
+    'session.get': r('GET', '/session/{sessionID}'),
+    'session.create': r('POST', '/session', SCOPE, ['parentID', 'title', 'agent', 'model', 'metadata', 'permission', 'workspaceID']),
+    'session.delete': r('DELETE', '/session/{sessionID}'),
+    'session.update': r('PATCH', '/session/{sessionID}', SCOPE, ['title', 'metadata', 'permission', 'time']),
+    'session.status': r('GET', '/session/status'),
+    'session.messages': r('GET', '/session/{sessionID}/message', [...SCOPE, 'limit', 'before']),
+    'session.prompt': r('POST', '/session/{sessionID}/message', SCOPE, PROMPT_BODY),
+    'session.promptAsync': r('POST', '/session/{sessionID}/prompt_async', SCOPE, PROMPT_BODY),
+    'session.abort': r('POST', '/session/{sessionID}/abort'),
+    'session.revert': r('POST', '/session/{sessionID}/revert', SCOPE, ['messageID', 'partID']),
+    'session.unrevert': r('POST', '/session/{sessionID}/unrevert'),
+    'session.summarize': r('POST', '/session/{sessionID}/summarize', SCOPE, ['providerID', 'modelID', 'auto']),
+    'session.command': r('POST', '/session/{sessionID}/command', SCOPE, ['messageID', 'agent', 'model', 'arguments', 'command', 'variant', 'parts']),
+    'session.share': r('POST', '/session/{sessionID}/share'),
+    'session.unshare': r('DELETE', '/session/{sessionID}/share'),
+    'session.fork': r('POST', '/session/{sessionID}/fork', SCOPE, ['messageID']),
+    'session.diff': r('GET', '/session/{sessionID}/diff', [...SCOPE, 'messageID']),
+    'session.todo': r('GET', '/session/{sessionID}/todo'),
+    'permission.list': r('GET', '/permission'),
+    'permission.reply': r('POST', '/permission/{requestID}/reply', SCOPE, ['reply', 'message']),
+    'question.list': r('GET', '/question'),
+    'question.reply': r('POST', '/question/{requestID}/reply', SCOPE, ['answers']),
+    'question.reject': r('POST', '/question/{requestID}/reject'),
+    'part.update': r('PATCH', '/session/{sessionID}/message/{messageID}/part/{partID}', SCOPE, [], 'part'),
+    'part.delete': r('DELETE', '/session/{sessionID}/message/{messageID}/part/{partID}'),
+    'file.list': r('GET', '/file', [...SCOPE, 'path']),
+    'file.read': r('GET', '/file/content', [...SCOPE, 'path']),
+    'find.files': r('GET', '/find/file', [...SCOPE, 'query', 'dirs', 'type', 'limit']),
+    'vcs.diff': r('GET', '/vcs/diff', [...SCOPE, 'mode', 'context']),
+    'global.health': r('GET', '/global/health', []),
+    'global.dispose': r('POST', '/global/dispose', []),
+    'global.config.get': r('GET', '/global/config', []),
+    'global.config.update': r('PATCH', '/global/config', [], [], 'config'),
+    'provider.list': r('GET', '/provider'),
+    'provider.auth': r('GET', '/provider/auth'),
+    'provider.oauth.authorize': r('POST', '/provider/{providerID}/oauth/authorize', SCOPE, ['method', 'inputs']),
+    'provider.oauth.callback': r('POST', '/provider/{providerID}/oauth/callback', SCOPE, ['method', 'code']),
+    'auth.set': r('PUT', '/auth/{providerID}', [], [], 'auth'),
+    'app.agents': r('GET', '/agent'),
+    'app.skills': r('GET', '/skill'),
+    'app.log': r('POST', '/log', SCOPE, ['service', 'level', 'message', 'extra']),
+    'command.list': r('GET', '/command'),
+    'tool.ids': r('GET', '/experimental/tool/ids'),
+    'tool.list': r('GET', '/experimental/tool', [...SCOPE, 'provider', 'model']),
+    'mcp.status': r('GET', '/mcp'),
+    'mcp.add': r('POST', '/mcp', SCOPE, ['name', 'config']),
+    'mcp.connect': r('POST', '/mcp/{name}/connect'),
+    'mcp.disconnect': r('POST', '/mcp/{name}/disconnect'),
+    'mcp.auth.start': r('POST', '/mcp/{name}/auth'),
+    'mcp.auth.callback': r('POST', '/mcp/{name}/auth/callback', SCOPE, ['code']),
+    'mcp.auth.remove': r('DELETE', '/mcp/{name}/auth'),
+    'project.list': r('GET', '/project'),
+    'project.current': r('GET', '/project/current'),
+    'path.get': r('GET', '/path'),
+};
+function queryString(route, params) {
+    const fields = [];
+    for (const key of route.query) {
+        const value = params[key];
+        if (value === undefined || value === null)
+            continue;
+        fields.push(`${key}=${encodeURIComponent(String(value))}`);
+    }
+    return fields.length ? `?${fields.join('&')}` : '';
+}
+export function buildRuntimeRequest(baseUrl, name, params = {}, options = {}) {
+    const route = RUNTIME_REST_ROUTES[name];
+    const path = route.path.replace(/\{(\w+)\}/g, (_, key) => encodeURIComponent(String(params[key])));
+    let body;
+    let hasBody = false;
+    if (route.bodyParam) {
+        body = params[route.bodyParam];
+        hasBody = body !== undefined;
+    }
+    else {
+        for (const key of route.body) {
+            if (!(key in params))
+                continue;
+            body = { ...body, [key]: params[key] };
+            hasBody = true;
+        }
+    }
+    const headers = new Headers(options.headers);
+    if (hasBody)
+        headers.set('Content-Type', 'application/json');
+    return new Request(`${baseUrl.replace(/\/$/, '')}${path}${queryString(route, params)}`, {
+        method: route.method,
+        headers,
+        redirect: 'follow',
+        ...(hasBody ? { body: JSON.stringify(body) } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
+    });
+}
+function parseAs(contentType) {
+    if (!contentType)
+        return 'stream';
+    const type = contentType.split(';')[0]?.trim() ?? '';
+    if (type.startsWith('application/json') || type.endsWith('+json'))
+        return 'json';
+    if (type === 'multipart/form-data')
+        return 'formData';
+    if (['application/', 'audio/', 'image/', 'video/'].some((prefix) => type.startsWith(prefix)))
+        return 'blob';
+    if (type.startsWith('text/'))
+        return 'text';
+    return 'json';
+}
+async function send(config, request) {
+    const fetchFn = config.fetch ?? globalThis.fetch;
+    let response;
+    try {
+        response = await fetchFn(request);
+    }
+    catch (error) {
+        return { error: error || {}, request, response: undefined };
+    }
+    if (response.headers.get('content-type') === 'text/html') {
+        throw new Error('The session runtime does not serve this request (it answered text/html)');
+    }
+    if (response.ok) {
+        const as = parseAs(response.headers.get('Content-Type'));
+        if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+            const empty = as === 'json' ? {} : as === 'formData' ? new FormData() : as === 'stream' ? response.body : await response[as]();
+            return { data: empty, request, response };
+        }
+        if (as === 'stream')
+            return { data: response.body, request, response };
+        if (as === 'json') {
+            const text = await response.text();
+            return { data: text ? JSON.parse(text) : {}, request, response };
+        }
+        return { data: await response[as](), request, response };
+    }
+    const text = await response.text();
+    let error = text;
+    try {
+        error = JSON.parse(text);
+    }
+    catch {
+    }
+    return { error: error || {}, request, response };
+}
+export function fetchEventTransport(fetchFn = globalThis.fetch) {
+    return async function* ({ url, headers, signal }) {
+        const response = await fetchFn(new Request(url, { method: 'GET', headers, signal, redirect: 'follow' }));
+        if (!response.ok) {
+            throw Object.assign(new Error(`SSE failed: ${response.status} ${response.statusText}`), {
+                status: response.status,
+            });
+        }
+        if (!response.body)
+            throw new Error('No body in SSE response');
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        const cancel = () => {
+            try {
+                void reader.cancel();
+            }
+            catch {
+            }
+        };
+        signal.addEventListener('abort', cancel);
+        try {
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer = (buffer + value).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+                const chunks = buffer.split('\n\n');
+                buffer = chunks.pop() ?? '';
+                for (const chunk of chunks) {
+                    const message = {};
+                    const data = [];
+                    for (const line of chunk.split('\n')) {
+                        if (line.startsWith('data:'))
+                            data.push(line.replace(/^data:\s*/, ''));
+                        else if (line.startsWith('id:'))
+                            message.id = line.replace(/^id:\s*/, '');
+                        else if (line.startsWith('retry:')) {
+                            const parsed = Number.parseInt(line.replace(/^retry:\s*/, ''), 10);
+                            if (!Number.isNaN(parsed))
+                                message.retry = parsed;
+                        }
+                    }
+                    if (data.length)
+                        message.data = data.join('\n');
+                    yield message;
+                }
+            }
+        }
+        finally {
+            signal.removeEventListener('abort', cancel);
+            reader.releaseLock();
+        }
+    };
+}
+async function* eventStream(config, url, options) {
+    const transport = config.eventTransport ?? fetchEventTransport(config.fetch ?? globalThis.fetch);
+    const signal = options.signal ?? new AbortController().signal;
+    let retryDelay = options.sseDefaultRetryDelay ?? 3000;
+    let lastEventId;
+    for (let attempt = 1; !signal.aborted; attempt++) {
+        try {
+            const headers = new Headers(options.headers);
+            if (lastEventId !== undefined)
+                headers.set('Last-Event-ID', lastEventId);
+            for await (const message of transport({ url: new URL(url).href, headers, signal })) {
+                if (message.id !== undefined)
+                    lastEventId = message.id;
+                if (message.retry !== undefined)
+                    retryDelay = message.retry;
+                if (message.data === undefined)
+                    continue;
+                try {
+                    yield JSON.parse(message.data);
+                }
+                catch {
+                    yield message.data;
+                }
+            }
+            return;
+        }
+        catch (error) {
+            options.onSseError?.(error);
+            if (options.sseMaxRetryAttempts !== undefined && attempt >= options.sseMaxRetryAttempts)
+                return;
+            const backoff = Math.min(retryDelay * 2 ** (attempt - 1), options.sseMaxRetryDelay ?? 30000);
+            await new Promise((resolve) => setTimeout(resolve, backoff));
+        }
+    }
+}
+export function createRuntimeRestClient(config) {
+    const call = (name) => (params, options) => send(config, buildRuntimeRequest(config.baseUrl, name, params, options));
+    const bare = (name) => (options) => call(name)(undefined, options);
+    const client = {
+        session: {
+            list: call('session.list'),
+            get: call('session.get'),
+            create: call('session.create'),
+            delete: call('session.delete'),
+            update: call('session.update'),
+            status: call('session.status'),
+            messages: call('session.messages'),
+            prompt: call('session.prompt'),
+            promptAsync: call('session.promptAsync'),
+            abort: call('session.abort'),
+            revert: call('session.revert'),
+            unrevert: call('session.unrevert'),
+            summarize: call('session.summarize'),
+            command: call('session.command'),
+            share: call('session.share'),
+            unshare: call('session.unshare'),
+            fork: call('session.fork'),
+            diff: call('session.diff'),
+            todo: call('session.todo'),
+        },
+        permission: { list: call('permission.list'), reply: call('permission.reply') },
+        question: { list: call('question.list'), reply: call('question.reply'), reject: call('question.reject') },
+        part: { update: call('part.update'), delete: call('part.delete') },
+        file: { list: call('file.list'), read: call('file.read') },
+        find: { files: call('find.files') },
+        vcs: { diff: call('vcs.diff') },
+        global: {
+            event: async (options = {}) => ({
+                stream: eventStream(config, `${config.baseUrl.replace(/\/$/, '')}/global/event`, options),
+            }),
+            health: bare('global.health'),
+            dispose: bare('global.dispose'),
+            config: { get: bare('global.config.get'), update: call('global.config.update') },
+        },
+        provider: {
+            list: call('provider.list'),
+            auth: call('provider.auth'),
+            oauth: { authorize: call('provider.oauth.authorize'), callback: call('provider.oauth.callback') },
+        },
+        auth: { set: call('auth.set') },
+        app: { agents: call('app.agents'), skills: call('app.skills'), log: call('app.log') },
+        command: { list: call('command.list') },
+        tool: { ids: call('tool.ids'), list: call('tool.list') },
+        mcp: {
+            status: call('mcp.status'),
+            add: call('mcp.add'),
+            connect: call('mcp.connect'),
+            disconnect: call('mcp.disconnect'),
+            auth: { start: call('mcp.auth.start'), callback: call('mcp.auth.callback'), remove: call('mcp.auth.remove') },
+        },
+        project: { list: call('project.list'), current: call('project.current') },
+        path: { get: call('path.get') },
+    };
+    return client;
+}