@beeuni/sdk 0.1.0

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

@@ -0,0 +1,45 @@
+import { type AuthenticatedRequest } from '../../http/authenticated-request.js';
+import { type ProjectFileEntry } from './shared.js';
+export declare function listProjectFiles(projectId: string, options?: {
+    ref?: string;
+    path?: string;
+}): Promise<ProjectFileEntry[]>;
+export interface ProjectDirectoryEntry {
+    path: string;
+    type: 'file' | 'directory';
+    size?: number;
+}
+export interface ProjectDirectoryListing {
+    entries: ProjectDirectoryEntry[];
+    truncated: boolean;
+}
+export declare function listProjectDirectory(projectId: string, options?: {
+    ref?: string;
+    path?: string;
+}): Promise<ProjectDirectoryListing>;
+export interface ProjectFileSearchMatch {
+    path: string;
+    line_number?: number;
+    line_text?: string;
+}
+export interface ProjectFileSearchResponse {
+    query: string;
+    ref: string;
+    content_search: boolean;
+    results: ProjectFileSearchMatch[];
+}
+export declare function searchProjectFiles(projectId: string, query: string, options?: {
+    content?: boolean;
+    ref?: string;
+    limit?: number;
+}): Promise<ProjectFileSearchResponse>;
+export declare function readProjectFile(projectId: string, path: string, ref?: string): Promise<{
+    path: string;
+    ref: string;
+    content: string;
+}>;
+export declare function fetchProjectArchive(projectId: string, ref: string, path?: string): Promise<Blob>;
+export declare function projectArchiveRequest(projectId: string, ref: string, path?: string): Promise<AuthenticatedRequest>;
+export declare function fetchProjectFileRaw(projectId: string, path: string, ref?: string, options?: {
+    signal?: AbortSignal;
+}): Promise<Blob>;

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

@@ -0,0 +1,69 @@
+import { backendApi } from '../../http/api-client.js';
+import { sendChecked } from '../../http/transport.js';
+import { platformConfig } from '../../http/config.js';
+import { authenticatedRequest } from '../../http/authenticated-request.js';
+import { unwrap } from './shared.js';
+export async function listProjectFiles(projectId, options) {
+    const params = new URLSearchParams();
+    if (options?.ref)
+        params.set('ref', options.ref);
+    if (options?.path)
+        params.set('path', options.path);
+    const query = params.toString() ? `?${params.toString()}` : '';
+    return unwrap(await backendApi.get(`/projects/${projectId}/files${query}`, { showErrors: false }));
+}
+export async function listProjectDirectory(projectId, options) {
+    const params = new URLSearchParams();
+    if (options?.ref)
+        params.set('ref', options.ref);
+    if (options?.path)
+        params.set('path', options.path);
+    params.set('depth', '1');
+    return unwrap(await backendApi.get(`/projects/${projectId}/files?${params.toString()}`, { showErrors: false }));
+}
+export async function searchProjectFiles(projectId, query, options) {
+    const params = new URLSearchParams({ q: query });
+    if (options?.content)
+        params.set('content', '1');
+    if (options?.ref)
+        params.set('ref', options.ref);
+    if (options?.limit)
+        params.set('limit', String(options.limit));
+    return unwrap(await backendApi.get(`/projects/${projectId}/files/search?${params.toString()}`));
+}
+export async function readProjectFile(projectId, path, ref) {
+    const params = new URLSearchParams({ path });
+    if (ref)
+        params.set('ref', ref);
+    return unwrap(await backendApi.get(`/projects/${projectId}/files/content?${params.toString()}`, { showErrors: false }));
+}
+const ARCHIVE_TIMEOUT_MS = 10 * 60_000;
+export async function fetchProjectArchive(projectId, ref, path) {
+    const params = new URLSearchParams();
+    if (ref)
+        params.set('ref', ref);
+    if (path)
+        params.set('path', path);
+    const query = params.toString() ? `?${params.toString()}` : '';
+    const url = `${platformConfig().backendUrl || ''}/projects/${projectId}/files/archive${query}`;
+    const res = await sendChecked(url, { method: 'GET' }, { timeoutMs: ARCHIVE_TIMEOUT_MS }, 'Failed to download');
+    return await res.blob();
+}
+export async function projectArchiveRequest(projectId, ref, path) {
+    const params = new URLSearchParams();
+    if (ref)
+        params.set('ref', ref);
+    if (path)
+        params.set('path', path);
+    const query = params.toString() ? `?${params.toString()}` : '';
+    return authenticatedRequest(`${platformConfig().backendUrl}/projects/${encodeURIComponent(projectId)}/files/archive${query}`);
+}
+export async function fetchProjectFileRaw(projectId, path, ref, options) {
+    const params = new URLSearchParams({ path });
+    if (ref)
+        params.set('ref', ref);
+    const query = params.toString() ? `?${params.toString()}` : '';
+    const url = `${platformConfig().backendUrl || ''}/projects/${projectId}/files/raw${query}`;
+    const res = await sendChecked(url, { method: 'GET', ...(options?.signal ? { signal: options.signal } : {}) }, {}, 'Failed to read file');
+    return await res.blob();
+}

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

@@ -0,0 +1,257 @@
+export interface GatewayLogRow {
+    log_id: string;
+    request_id: string;
+    created_at: string;
+    requested_model: string;
+    resolved_model: string;
+    provider: string;
+    status: number;
+    ok: boolean;
+    error_code: string | null;
+    error_message: string | null;
+    latency_ms: number;
+    attempts: number;
+    input_tokens: number;
+    output_tokens: number;
+    cached_tokens: number;
+    cache_write_tokens: number;
+    beeuni_cost: number;
+    provider_cost: number;
+    total_cost: number;
+    upstream_cost: number;
+    final_cost: number;
+    streaming: boolean;
+    billing_mode: string | null;
+    actor_user_id: string | null;
+    key_id: string | null;
+}
+export interface GatewayLogDetail extends GatewayLogRow {
+    candidates_tried: string[];
+    request: unknown;
+    response: unknown;
+    metadata: Record<string, unknown>;
+}
+export interface GatewayLogsResponse {
+    logs: GatewayLogRow[];
+    next_offset: number | null;
+}
+export interface GatewayOverview {
+    window_days: number;
+    requests: number;
+    errors: number;
+    total_cost: number;
+    beeuni_cost: number;
+    provider_cost: number;
+    input_tokens: number;
+    output_tokens: number;
+}
+export interface GatewaySeriesPoint {
+    day: string;
+    requests: number;
+    errors: number;
+    cost: number;
+    beeuni_cost: number;
+    provider_cost: number;
+    input_tokens: number;
+    output_tokens: number;
+    p50: number;
+    p95: number;
+    p99: number;
+}
+export interface GatewayErrorStat {
+    code: string;
+    count: number;
+}
+export interface GatewayErrorsResponse {
+    window_days: number;
+    errors: GatewayErrorStat[];
+}
+export interface GatewaySeries {
+    window_days: number;
+    series: GatewaySeriesPoint[];
+}
+export interface GatewayModelStat {
+    model: string;
+    provider: string;
+    requests: number;
+    errors: number;
+    cost: number;
+    beeuni_cost: number;
+    provider_cost: number;
+    tokens: number;
+}
+export interface GatewayBreakdown {
+    window_days: number;
+    models: GatewayModelStat[];
+}
+export interface GatewaySessionStat {
+    session_id: string;
+    llm_cost: number;
+    compute_cost: number;
+    total_cost: number;
+    requests: number;
+    errors: number;
+    tokens: number;
+    models: number;
+    compute_seconds: number;
+    last_at: string | null;
+}
+export interface GatewaySessions {
+    window_days: number;
+    sessions: GatewaySessionStat[];
+}
+export interface GatewayBudgetRow {
+    budget_id: string;
+    scope: 'project' | 'member';
+    subject_user_id: string | null;
+    limit_usd: number;
+    period: 'day' | 'week' | 'month';
+    action: 'block' | 'warn';
+}
+export interface GatewayMemberSpend {
+    user_id: string | null;
+    email: string | null;
+    requests: number;
+    cost: number;
+    tokens: number;
+}
+export interface GatewayBudgetsResponse {
+    project_spend: {
+        requests: number;
+        cost: number;
+    };
+    budgets: GatewayBudgetRow[];
+    members: GatewayMemberSpend[];
+}
+export interface SetGatewayBudgetInput {
+    scope: 'project' | 'member';
+    subject_user_id?: string | null;
+    limit_usd: number;
+    period?: 'day' | 'week' | 'month';
+    action?: 'block' | 'warn';
+}
+export interface GatewayKeyRow {
+    key_id: string;
+    name: string;
+    key_prefix: string;
+    status: 'active' | 'revoked' | 'expired';
+    last_used_at: string | null;
+    created_at: string;
+}
+export interface CreatedGatewayKey {
+    key_id: string;
+    name: string;
+    key_prefix: string;
+    secret_key: string;
+}
+export type GatewayFallbackCondition = 'transient' | 'any-error';
+export interface GatewayFallbackChain {
+    models: string[];
+    fallbackOn: GatewayFallbackCondition;
+}
+export interface GatewayRoutingRule {
+    model: string;
+    fallbackModels: string[];
+    fallbackOn: GatewayFallbackCondition;
+}
+export interface GatewayModelGenerationConfig {
+    reasoningEffort?: string;
+    temperature?: number;
+    topP?: number;
+    maxOutputTokens?: number;
+}
+export interface GatewayProjectRoutingPolicy {
+    defaultModel: string | null;
+    visionModel: string | null;
+    defaultFallback: GatewayFallbackChain | null;
+    rules: GatewayRoutingRule[];
+    modelGenerationConfig?: Record<string, GatewayModelGenerationConfig>;
+}
+export interface GatewayRoutingPolicyDocument {
+    version: 1;
+    project: GatewayProjectRoutingPolicy;
+    effective: {
+        defaultModel: string;
+        defaultModelSource: 'project' | 'account' | 'platform';
+        visionModel: string;
+        defaultFallback: GatewayFallbackChain;
+    };
+    platform: {
+        defaultModel: string;
+        visionModel: string;
+        defaultFallback: GatewayFallbackChain;
+    };
+    capabilities?: {
+        write: boolean;
+    };
+}
+export interface GatewayRoutePreviewInput {
+    requestedModel: string;
+    imageInput: boolean;
+}
+export interface GatewayRoutePreview {
+    version: 1;
+    route: {
+        policyId: string;
+        primaryModel: string;
+        fallbackModels: string[];
+        fallbackOn: GatewayFallbackCondition;
+    };
+    models: Array<{
+        model: string;
+        available: boolean;
+    }>;
+}
+export declare function getGatewayRoutingPolicy(projectId: string): Promise<GatewayRoutingPolicyDocument>;
+export declare function setGatewayRoutingPolicy(projectId: string, policy: GatewayProjectRoutingPolicy): Promise<GatewayRoutingPolicyDocument>;
+export declare function resetGatewayRoutingPolicy(projectId: string): Promise<GatewayRoutingPolicyDocument>;
+export declare function previewGatewayRoute(projectId: string, input: GatewayRoutePreviewInput): Promise<GatewayRoutePreview>;
+export declare function listGatewayLogs(projectId: string, opts?: {
+    limit?: number;
+    offset?: number;
+    ok?: boolean;
+}): Promise<GatewayLogsResponse>;
+export declare function getGatewayLog(projectId: string, logId: string): Promise<GatewayLogDetail>;
+export declare function getGatewayOverview(projectId: string, days?: number): Promise<GatewayOverview>;
+export declare function getGatewaySeries(projectId: string, days?: number): Promise<GatewaySeries>;
+export declare function getGatewayBreakdown(projectId: string, days?: number): Promise<GatewayBreakdown>;
+export declare function getGatewaySessions(projectId: string, days?: number): Promise<GatewaySessions>;
+export declare function getGatewayErrors(projectId: string, days?: number): Promise<GatewayErrorsResponse>;
+export declare function getGatewayBudgets(projectId: string): Promise<GatewayBudgetsResponse>;
+export declare function setGatewayBudget(projectId: string, input: SetGatewayBudgetInput): Promise<{
+    ok: boolean;
+}>;
+export declare function deleteGatewayBudget(projectId: string, budgetId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function getGatewayKeys(projectId: string): Promise<{
+    keys: GatewayKeyRow[];
+    gateway_url?: string | null;
+}>;
+export declare function createGatewayKey(projectId: string, name: string): Promise<CreatedGatewayKey>;
+export declare function revokeGatewayKey(projectId: string, keyId: string): Promise<{
+    ok: boolean;
+}>;
+export interface GatewayPlaygroundResult {
+    model: string;
+    ok: boolean;
+    latency_ms?: number;
+    output?: string;
+    input_tokens?: number;
+    output_tokens?: number;
+    cost?: number;
+    resolved_model?: string;
+    provider?: string;
+    error?: string;
+}
+export interface GatewayPlaygroundResponse {
+    results: GatewayPlaygroundResult[];
+}
+export declare function runGatewayPlayground(projectId: string, prompt: string, models: string[], system?: string, generationConfig?: Record<string, GatewayModelGenerationConfig>): Promise<GatewayPlaygroundResponse>;
+export type GatewayProviderVerifyStatus = 'verified' | 'invalid' | 'unknown' | 'not_connected';
+export interface GatewayProviderVerifyResult {
+    status: GatewayProviderVerifyStatus;
+    message: string;
+    checked_at: string;
+}
+export declare function verifyGatewayProvider(projectId: string, providerId: string): Promise<GatewayProviderVerifyResult>;

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

@@ -0,0 +1,72 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function getGatewayRoutingPolicy(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/routing-policy`), 'Gateway routing policy request failed');
+}
+export async function setGatewayRoutingPolicy(projectId, policy) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/gateway/routing-policy`, policy), 'Gateway routing policy request failed');
+}
+export async function resetGatewayRoutingPolicy(projectId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/gateway/routing-policy`), 'Gateway routing policy request failed');
+}
+export async function previewGatewayRoute(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/gateway/routing-policy/preview`, input), 'Gateway route preview failed');
+}
+export async function listGatewayLogs(projectId, opts) {
+    const q = new URLSearchParams();
+    if (opts?.limit)
+        q.set('limit', String(opts.limit));
+    if (opts?.offset)
+        q.set('offset', String(opts.offset));
+    if (opts?.ok !== undefined)
+        q.set('ok', String(opts.ok));
+    const qs = q.toString();
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/logs${qs ? `?${qs}` : ''}`), 'Gateway request failed');
+}
+export async function getGatewayLog(projectId, logId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/logs/${logId}`), 'Gateway request failed');
+}
+export async function getGatewayOverview(projectId, days) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/overview${days ? `?days=${days}` : ''}`), 'Gateway request failed');
+}
+export async function getGatewaySeries(projectId, days) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/series${days ? `?days=${days}` : ''}`), 'Gateway request failed');
+}
+export async function getGatewayBreakdown(projectId, days) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/breakdown${days ? `?days=${days}` : ''}`), 'Gateway request failed');
+}
+export async function getGatewaySessions(projectId, days) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/sessions${days ? `?days=${days}` : ''}`), 'Gateway request failed');
+}
+export async function getGatewayErrors(projectId, days) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/errors${days ? `?days=${days}` : ''}`), 'Gateway request failed');
+}
+export async function getGatewayBudgets(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/budgets`), 'Gateway request failed');
+}
+export async function setGatewayBudget(projectId, input) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/gateway/budgets`, input), 'Gateway request failed');
+}
+export async function deleteGatewayBudget(projectId, budgetId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/gateway/budgets/${budgetId}`), 'Gateway request failed');
+}
+export async function getGatewayKeys(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/gateway/keys`), 'Gateway request failed');
+}
+export async function createGatewayKey(projectId, name) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/gateway/keys`, { name }), 'Gateway request failed');
+}
+export async function revokeGatewayKey(projectId, keyId) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/gateway/keys/${keyId}`), 'Gateway request failed');
+}
+export async function runGatewayPlayground(projectId, prompt, models, system, generationConfig) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/gateway/playground`, {
+        prompt,
+        models,
+        ...(system ? { system } : {}),
+        ...(generationConfig && Object.keys(generationConfig).length ? { generationConfig } : {}),
+    }), 'Gateway request failed');
+}
+export async function verifyGatewayProvider(projectId, providerId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/gateway/providers/${encodeURIComponent(providerId)}/verify`, {}), 'Gateway provider verification failed');
+}

package/dist/core/rest/projects-client/git-backend.d.ts

@@ -0,0 +1,15 @@
+import type { GitHubRepository } from './github.js';
+export interface ManagedGitBackend {
+    configured: boolean;
+    kind: 'app' | 'pat' | null;
+    owner: string | null;
+}
+export interface ManagedGitRepositoriesResponse {
+    owner: string;
+    repositories: GitHubRepository[];
+}
+export declare function getManagedGitBackend(): Promise<ManagedGitBackend>;
+export declare function listManagedGitRepositories(options?: {
+    search?: string;
+    limit?: number;
+}): Promise<ManagedGitRepositoriesResponse>;

package/dist/core/rest/projects-client/git-backend.js

@@ -0,0 +1,15 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function getManagedGitBackend() {
+    return unwrap(await backendApi.get('/projects/git/backend', { showErrors: false }));
+}
+export async function listManagedGitRepositories(options) {
+    const params = new URLSearchParams();
+    const search = options?.search?.trim();
+    if (search)
+        params.set('search', search);
+    if (options?.limit !== undefined)
+        params.set('limit', String(options.limit));
+    const query = params.toString();
+    return unwrap(await backendApi.get(`/projects/git/backend/repositories${query ? `?${query}` : ''}`, { showErrors: false }));
+}

package/dist/core/rest/projects-client/git-history.d.ts

@@ -0,0 +1,78 @@
+export interface ProjectBranch {
+    name: string;
+    is_default: boolean;
+    tip: string;
+    tip_short: string;
+    subject: string;
+    committer_name: string;
+    committer_email: string;
+    committed_at: string;
+    ahead: number | null;
+    behind: number | null;
+}
+export interface ProjectBranchesResponse {
+    default_branch: string;
+    branches: ProjectBranch[];
+}
+export interface ProjectCommit {
+    hash: string;
+    short_hash: string;
+    parents: string[];
+    author_name: string;
+    author_email: string;
+    authored_at: string;
+    committer_name: string;
+    committer_email: string;
+    committed_at: string;
+    subject: string;
+    body: string;
+}
+export interface ProjectCommitsResponse {
+    ref: string;
+    path: string | null;
+    commits: ProjectCommit[];
+    hasMore: boolean;
+}
+export interface ProjectCommitFile {
+    path: string;
+    old_path: string | null;
+    status: 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' | 'typechange';
+    additions: number;
+    deletions: number;
+}
+export interface ProjectCommitDetail extends ProjectCommit {
+    files: ProjectCommitFile[];
+}
+export interface ProjectCommitDiffResponse {
+    hash: string;
+    parent: string | null;
+    path: string | null;
+    patch: string;
+}
+export interface ProjectFileHistoryResponse {
+    path: string;
+    ref: string;
+    commits: ProjectCommit[];
+    hasMore: boolean;
+}
+export interface ListProjectBranchesOptions {
+    q?: string;
+    limit?: number;
+    includeSessionBranches?: boolean;
+}
+export declare function listProjectBranches(projectId: string, options?: ListProjectBranchesOptions): Promise<ProjectBranchesResponse>;
+export declare function listProjectCommits(projectId: string, options?: {
+    ref?: string;
+    path?: string;
+    limit?: number;
+    skip?: number;
+}): Promise<ProjectCommitsResponse>;
+export declare function getProjectCommit(projectId: string, sha: string): Promise<ProjectCommitDetail>;
+export declare function getProjectCommitDiff(projectId: string, sha: string, options?: {
+    path?: string;
+}): Promise<ProjectCommitDiffResponse>;
+export declare function getProjectFileHistory(projectId: string, path: string, options?: {
+    ref?: string;
+    limit?: number;
+    skip?: number;
+}): Promise<ProjectFileHistoryResponse>;

package/dist/core/rest/projects-client/git-history.js

@@ -0,0 +1,47 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function listProjectBranches(projectId, options) {
+    const params = new URLSearchParams();
+    if (options?.q)
+        params.set('q', options.q);
+    if (options?.limit != null)
+        params.set('limit', String(options.limit));
+    if (options?.includeSessionBranches !== undefined) {
+        params.set('include_session_branches', String(options.includeSessionBranches));
+    }
+    const query = params.toString() ? `?${params.toString()}` : '';
+    return unwrap(await backendApi.get(`/projects/${projectId}/branches${query}`));
+}
+export async function listProjectCommits(projectId, options) {
+    const params = new URLSearchParams();
+    if (options?.ref)
+        params.set('ref', options.ref);
+    if (options?.path)
+        params.set('path', options.path);
+    if (options?.limit != null)
+        params.set('limit', String(options.limit));
+    if (options?.skip != null)
+        params.set('skip', String(options.skip));
+    const query = params.toString() ? `?${params.toString()}` : '';
+    return unwrap(await backendApi.get(`/projects/${projectId}/commits${query}`));
+}
+export async function getProjectCommit(projectId, sha) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/commits/${encodeURIComponent(sha)}`));
+}
+export async function getProjectCommitDiff(projectId, sha, options) {
+    const params = new URLSearchParams();
+    if (options?.path)
+        params.set('path', options.path);
+    const query = params.toString() ? `?${params.toString()}` : '';
+    return unwrap(await backendApi.get(`/projects/${projectId}/commits/${encodeURIComponent(sha)}/diff${query}`));
+}
+export async function getProjectFileHistory(projectId, path, options) {
+    const params = new URLSearchParams({ path });
+    if (options?.ref)
+        params.set('ref', options.ref);
+    if (options?.limit != null)
+        params.set('limit', String(options.limit));
+    if (options?.skip != null)
+        params.set('skip', String(options.skip));
+    return unwrap(await backendApi.get(`/projects/${projectId}/files/history?${params.toString()}`));
+}