@genispace/geniapp 0.3.0 → 0.5.0

package/dist/components/app/services/workbenchApi.d.ts

@@ -0,0 +1,495 @@
+import { Workbench, AppConfig } from '../../types';
+import { VisibleWhen } from '../../utils/visibleWhen';
+
+export interface BaseConfig {
+    id: string;
+    type: string;
+    version?: string;
+    description?: string;
+    created?: string;
+    updated?: string;
+    [key: string]: unknown;
+}
+export interface ApiAppConfig extends AppConfig, BaseConfig {
+    appId: string;
+}
+export interface PageConfig extends BaseConfig {
+    title: string;
+    layout: 'default' | 'fluid' | 'custom';
+    components: ComponentConfig[];
+    customStyles?: import('../../types/components').CustomStylesConfig;
+}
+export interface ComponentConfig {
+    id: string;
+    type: string;
+    props?: Record<string, unknown>;
+    /** Conditional visibility; absent/undefined = visible to all (see utils/visibleWhen) */
+    visibleWhen?: VisibleWhen;
+    dataSource?: {
+        type: string;
+        datasetId: string;
+        datasetName?: string;
+        params?: Record<string, unknown>;
+    };
+    mockData?: unknown;
+    /** When true, render using mockData (sibling field; do not store only under props) */
+    useMockData?: boolean;
+    customStyles?: import('../../types/components').CustomStylesConfig;
+    children?: ComponentConfig[];
+}
+export interface DataServiceConfig {
+    key: string;
+    type: 'rest' | 'graphql' | 'websocket';
+    endpoint: string;
+    method?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, unknown>;
+    transform?: {
+        request?: (data: unknown) => unknown;
+        response?: (data: unknown) => unknown;
+    };
+}
+export interface ApiConfig {
+    baseURL: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+    endpoints: {
+        [key: string]: {
+            url: string;
+            method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+            mockData?: unknown;
+            transformRequest?: (data: unknown) => unknown;
+            transformResponse?: (data: unknown) => unknown;
+        };
+    };
+    dataServices?: {
+        [key: string]: DataServiceConfig;
+    };
+}
+export interface RequestParams {
+    search?: string;
+    filters?: Record<string, unknown[]>;
+    sorter?: {
+        field: string;
+        order: 'ascend' | 'descend';
+    };
+    pagination?: {
+        current: number;
+        pageSize: number;
+    };
+    [key: string]: unknown;
+}
+export interface CacheConfig {
+    enabled: boolean;
+    ttl: number;
+    key?: string;
+}
+export interface ApiResponse<T> {
+    success: boolean;
+    data: T;
+    message?: string;
+}
+export interface DatasetQueryParams {
+    filter?: string;
+    limit?: number;
+    offset?: number;
+    outputFields?: string[];
+    [key: string]: unknown;
+}
+export interface DatasetResponse<T> {
+    success: boolean;
+    data: T;
+    message?: string;
+}
+export interface Dataset {
+    id: string;
+    name: string;
+    description?: string;
+    dbType: string;
+    dbConfig: Record<string, unknown>;
+    dbSchema?: Record<string, unknown>;
+    spaceId: string;
+    createdAt: string;
+    updatedAt: string;
+    isActive: boolean;
+}
+export interface DatasetListResponse {
+    total: number;
+    items: Dataset[];
+    page: number;
+    limit: number;
+}
+export interface ApiWorkbench extends Workbench {
+    version: string;
+}
+export interface WorkbenchResponse {
+    success: boolean;
+    data?: Workbench;
+    message?: string;
+    code?: string;
+}
+export interface WorkbenchListResponse {
+    success: boolean;
+    items: Workbench[];
+    message?: string;
+}
+export interface UpdateWorkbenchRequest {
+    name?: string;
+    description?: string;
+    config?: Record<string, unknown>;
+    status?: 'ACTIVE' | 'INACTIVE' | 'DRAFT';
+    isActive?: boolean;
+}
+export interface WorkbenchVersion {
+    id: string;
+    version: string;
+    createdAt: string;
+    createdBy: string;
+    description?: string;
+    changes?: string;
+    config?: Record<string, unknown>;
+}
+export interface WorkbenchVersionResponse {
+    success: boolean;
+    items: WorkbenchVersion[];
+    message?: string;
+}
+export interface WorkbenchVersionRestoreResponse {
+    success: boolean;
+    data: Workbench;
+    message?: string;
+}
+declare class WorkbenchApi {
+    private config;
+    private mockMode;
+    private cache;
+    private workbenchConfigCache;
+    private CACHE_TTL;
+    private pendingRequests;
+    constructor(config: ApiConfig, mockMode?: boolean);
+    setConfig(config: ApiConfig): void;
+    setMockMode(mockMode: boolean): void;
+    private generateCacheKey;
+    private checkCache;
+    private setCache;
+    clearCache(endpointKey?: string): void;
+    private processMockData;
+    request<T>(endpointKey: string, params?: RequestParams, cacheConfig?: CacheConfig): Promise<ApiResponse<T>>;
+    private getWorkbench;
+    clearWorkbenchCache(workbenchId?: string): void;
+    getAppConfig(workbenchId: string): Promise<ApiResponse<AppConfig>>;
+    getPageConfig(workbenchId: string, pageId: string): Promise<ApiResponse<PageConfig>>;
+    queryDataset<T>(datasetId: string, params?: DatasetQueryParams): Promise<DatasetResponse<T>>;
+    getComponentData<T>(dataSource: ComponentConfig['dataSource'], params?: DatasetQueryParams): Promise<DatasetResponse<T>>;
+}
+export declare const workbenchApi: WorkbenchApi;
+export declare function fetchAppConfig(workbenchId: string): Promise<ApiResponse<AppConfig>>;
+export declare function fetchPageConfig(workbenchId: string, pageId: string): Promise<ApiResponse<PageConfig>>;
+export declare function fetchComponentData<T>(dataSource: ComponentConfig['dataSource'], params?: DatasetQueryParams): Promise<DatasetResponse<T>>;
+export declare const getWorkbenches: (options?: {
+    page?: number;
+    limit?: number;
+    status?: string;
+    isActive?: boolean;
+}) => Promise<WorkbenchListResponse>;
+export type WorkbenchConfigView = 'draft' | 'published';
+export declare const getWorkbench: (workbenchId: string, options?: {
+    view?: WorkbenchConfigView;
+    previewToken?: string;
+}) => Promise<WorkbenchResponse>;
+export declare const updateWorkbench: (workbenchId: string, data: UpdateWorkbenchRequest) => Promise<Workbench>;
+/** Partial update: upsert a single page in workbench config */
+export declare const updatePage: (workbenchId: string, pageKey: string, pageData: Record<string, unknown>) => Promise<Workbench>;
+/** Partial update: replace workbench appConfig */
+export declare const updateAppConfig: (workbenchId: string, appConfig: Record<string, unknown>) => Promise<Workbench>;
+export declare const deleteWorkbench: (workbenchId: string) => Promise<void>;
+export declare const toggleWorkbenchActive: (workbenchId: string, isActive: boolean) => Promise<Workbench>;
+/** Publish the current draft — manage permission required (enforced server-side). */
+export declare const publishWorkbench: (workbenchId: string, description?: string) => Promise<import('../../lib/types/api').ApiResponse<{
+    id: string;
+    publishedVersion: string;
+    publishedAt: string;
+    publishedBy: string;
+}>>;
+export type GeniappExportStepStatus = 'pending' | 'running' | 'done' | 'failed';
+export interface WorkbenchGeniappExportJob {
+    id: string;
+    workbenchId: string;
+    publishedVersion: string;
+    configSha256: string;
+    targetIdentifier: string;
+    targetVersion: string;
+    packageName?: string | null;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    currentStep?: string | null;
+    steps: Array<{
+        key: string;
+        status: GeniappExportStepStatus;
+        startedAt?: string;
+        finishedAt?: string;
+        error?: string;
+    }>;
+    compatibilityReport?: {
+        compatible: boolean;
+        installable: boolean;
+        summary: {
+            pages: number;
+            components: number;
+            errors: number;
+            warnings: number;
+        };
+        errors: Array<{
+            code: string;
+            path: string;
+            message: string;
+        }>;
+        warnings: Array<{
+            code: string;
+            path: string;
+            message: string;
+        }>;
+    } | null;
+    artifactFileName?: string | null;
+    artifactSha256?: string | null;
+    artifactSize?: string | null;
+    error?: string | null;
+    errorCode?: string | null;
+    createdAt: string;
+    finishedAt?: string | null;
+    expiresAt?: string | null;
+}
+export declare const createWorkbenchGeniappExport: (workbenchId: string, target: {
+    identifier: string;
+    version: string;
+    packageName?: string;
+}) => Promise<import('../../lib/types/api').ApiResponse<WorkbenchGeniappExportJob>>;
+export declare const getWorkbenchGeniappExport: (workbenchId: string, jobId: string) => Promise<import('../../lib/types/api').ApiResponse<WorkbenchGeniappExportJob>>;
+export declare const listWorkbenchGeniappExports: (workbenchId: string, limit?: number) => Promise<import('../../lib/types/api').ApiResponse<WorkbenchGeniappExportJob[]>>;
+export declare const downloadWorkbenchGeniappExport: (workbenchId: string, jobId: string, filename?: string) => Promise<void>;
+export declare const createWorkbenchPreviewToken: (workbenchId: string, expiresInHours?: number) => Promise<import('../../lib/types/api').ApiResponse<import('../../types').WorkbenchPreviewToken>>;
+export declare const listWorkbenchPreviewTokens: (workbenchId: string) => Promise<import('../../lib/types/api').ApiResponse<import('../../types').WorkbenchPreviewToken[]>>;
+export declare const revokeWorkbenchPreviewToken: (workbenchId: string, tokenId: string) => Promise<import('../../lib/types/api').ApiResponse<{
+    success: boolean;
+}>>;
+export declare const restoreVersion: (workbenchId: string, version: string) => Promise<Workbench>;
+export declare const getDatasets: (options?: {
+    page?: number;
+    limit?: number;
+    search?: string;
+}) => Promise<DatasetListResponse | Dataset[]>;
+export declare const getDataset: (datasetId: string) => Promise<Dataset>;
+export declare const queryDatasetData: <T>(datasetId: string, params?: DatasetQueryParams) => Promise<import('../../lib/types/api').ApiResponse<T>>;
+export declare const insertDatasetData: <T>(datasetId: string, data: T[]) => Promise<import('../../lib/types/api').ApiResponse<{
+    ids?: Array<string | number>;
+    insertedCount?: number;
+    inserted_count?: number;
+}>>;
+export declare const updateDatasetData: <T>(datasetId: string, filter: string, updateData: Partial<T>) => Promise<import('../../lib/types/api').ApiResponse<{
+    updatedCount?: number;
+    updated_count?: number;
+    affectedRows?: number;
+    affected_rows?: number;
+}>>;
+export declare const deleteDatasetData: (datasetId: string, filter: string) => Promise<import('../../lib/types/api').ApiResponse<{
+    deletedCount?: number;
+    deleted_count?: number;
+    affectedRows?: number;
+    affected_rows?: number;
+}>>;
+/** Append `?version=N` when version is a positive integer; otherwise leave URL unchanged. */
+export declare function withDatasourceVersion(url: string, version?: number): string;
+export interface DataSourceVersionSummary {
+    id: string;
+    version: number;
+    isDefault: boolean;
+    operationType?: string;
+    databaseId?: string;
+    changeNote?: string | null;
+    createdBy?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare const listDatasourceVersions: (datasourceId: string) => Promise<import('../../lib/types/api').ApiResponse<{
+    datasourceId: string;
+    defaultVersion: number | null;
+    versions: DataSourceVersionSummary[];
+}>>;
+/** Batch endpoint item: versions only carry {version, isDefault}; missing/cross-space ids get `error`. */
+export interface DataSourceVersionBatchItem {
+    datasourceId: string;
+    /** Present for datasources found in the space (null when the column is empty). */
+    name?: string | null;
+    identifier?: string | null;
+    versions: Array<{
+        version: number;
+        isDefault: boolean;
+    }>;
+    error?: {
+        code: string;
+        messageKey: string;
+    };
+}
+/**
+ * POST /datasources/versions/batch — one call for up to 100 datasources.
+ * Note: no `defaultVersion` field — derive it from `versions.find(v => v.isDefault)`.
+ */
+export declare const batchListDatasourceVersions: (datasourceIds: string[]) => Promise<import('../../lib/types/api').ApiResponse<{
+    items: DataSourceVersionBatchItem[];
+}>>;
+export declare const updateDatabaseData: (datasourceId: string, updateData: Record<string, unknown>, whereConditions?: Record<string, unknown>, version?: number) => Promise<import('../../lib/types/api').ApiResponse<{
+    success: boolean;
+    data?: {
+        operationType?: string;
+        affectedRows?: number;
+        executionTime?: number;
+        insertId?: number;
+        changedRows?: number;
+    };
+    message?: string;
+}>>;
+export declare const insertDatabaseData: (datasourceId: string, insertData: Record<string, unknown>, version?: number) => Promise<import('../../lib/types/api').ApiResponse<{
+    success: boolean;
+    data?: {
+        operationType?: string;
+        affectedRows?: number;
+        executionTime?: number;
+        insertId?: number;
+        changedRows?: number;
+    };
+    message?: string;
+}>>;
+export declare const deleteDatabaseData: (datasourceId: string, whereConditions: Record<string, unknown>, version?: number) => Promise<{
+    success: boolean;
+    data?: {
+        operationType?: string;
+        affectedRows?: number;
+        deletedCount?: number;
+        executionTime?: number;
+    };
+    message?: string;
+}>;
+export declare const transactionDatabaseData: (datasourceId: string, body: Record<string, unknown>, version?: number) => Promise<import('../../lib/types/api').ApiResponse<{
+    success: boolean;
+    data?: {
+        operationType?: string;
+        affectedRows?: number;
+        deletedCount?: number;
+        executionTime?: number;
+        insertId?: number;
+        changedRows?: number;
+    };
+    message?: string;
+}>>;
+export declare const getDatasources: (params?: {
+    search?: string;
+    databaseId?: string;
+    status?: string;
+    page?: number;
+    limit?: number;
+}) => Promise<import('../../lib/types/api').ApiResponse<{
+    success: boolean;
+    data?: Array<{
+        id: string;
+        name: string;
+        identifier?: string;
+        description?: string;
+        type: string;
+        operationType?: "READ" | "CREATE" | "UPDATE" | "DELETE" | "BATCH_INSERT" | "TRANSACTION";
+        status?: string;
+        inputSchema?: Record<string, unknown>;
+        outputSchema?: Record<string, unknown>;
+        database?: {
+            id: string;
+            name: string;
+            type: string;
+            host?: string;
+            port?: number;
+        };
+        createdAt?: string;
+        updatedAt?: string;
+    }>;
+    message?: string;
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}>>;
+export declare const getDatasourceSchema: (datasourceId: string, version?: number) => Promise<{
+    success: boolean;
+    data?: {
+        id: string;
+        name: string;
+        description?: string;
+        type: string;
+        operationType?: "READ" | "CREATE" | "UPDATE" | "DELETE" | "BATCH_INSERT" | "TRANSACTION";
+        database?: {
+            host?: string;
+            port?: number;
+            database?: string;
+            username?: string;
+        };
+        outputSchema?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                title?: string;
+                description?: string;
+                format?: string;
+            }>;
+            required?: string[];
+        };
+        inputSchema?: {
+            type: "object";
+            properties: Record<string, {
+                type: string;
+                title?: string;
+                description?: string;
+                format?: string;
+                default?: unknown;
+            }>;
+            required?: string[];
+        };
+    };
+    message?: string;
+}>;
+export declare const getDatasourceFields: (datasourceId: string, version?: number) => Promise<Array<{
+    name: string;
+    type: string;
+    title?: string;
+    description?: string;
+    format?: string;
+    nullable?: boolean;
+}>>;
+export declare const vectorSearch: <T>(datasetId: string, params: {
+    filter?: string;
+    data: number[][];
+    limit?: number;
+    outputFields?: string[];
+}) => Promise<DatasetResponse<T[]>>;
+export declare const getWorkbenchAppConfig: (workbenchId: string) => Promise<{
+    pages: Record<string, unknown>;
+    appConfig: {
+        logo: string;
+        appId: string;
+        theme: string;
+        layout: {
+            type: string;
+            menuPosition: string;
+            headerActions: string[];
+        };
+        navigation: {
+            items: Array<{
+                key: string;
+                icon: string;
+                path: string;
+                title: string;
+            }>;
+        };
+    };
+}>;
+export declare const updateWorkbenchAppConfig: (workbenchId: string, config: unknown) => Promise<unknown>;
+export declare const getWorkbenchVersions: (workbenchId: string) => Promise<WorkbenchVersionResponse>;
+export declare const restoreWorkbenchVersion: (workbenchId: string, versionId: string) => Promise<WorkbenchVersionRestoreResponse>;
+export {};

package/dist/components/app/types/agent.d.ts

@@ -0,0 +1,100 @@
+interface UserAgentKnowledgeBase {
+    userAgentId: string;
+    knowledgeBaseId: string;
+    permissionLevel: 'read' | 'write';
+}
+export interface UserAgent {
+    name: string;
+    description: string;
+    model: string;
+    modelId: string;
+    modelConfig: Record<string, unknown>;
+    knowledgeBases: UserAgentKnowledgeBase[];
+    promptTemplate: string;
+    inputSchema: Record<string, unknown> | string;
+    outputSchema: Record<string, unknown> | string;
+    rateLimit: number;
+    retryAttempts: number;
+    contextWindow: number;
+    fallbackBehavior: string;
+    systemPrompt: string;
+    enableStreaming: boolean;
+    logLevel: string;
+    timeoutSeconds: number;
+    cacheEnabled: boolean;
+    cacheTTL: number;
+    tags: string[];
+    customHeaders: Record<string, string>;
+    webhooks: string[];
+    security: {
+        enableRateLimit: boolean;
+        requireAuthentication: boolean;
+        allowedOrigins: string[];
+        ipWhitelist: string[];
+    };
+    agentType: 'conversational' | 'response';
+    conversationConfig?: {
+        maxTurns: number;
+        contextWindow: number;
+        sessionTimeout: number;
+        welcomeMessage?: string;
+    };
+    responseConfig?: {
+        strictSchema: boolean;
+        validateInput: boolean;
+        validateOutput: boolean;
+        cacheable: boolean;
+    };
+    mcpConfig?: {
+        enabled: boolean;
+        builtinEnabled?: boolean;
+        operatorSelection?: {
+            strategy: 'all' | 'specific';
+            operatorIds: string[];
+        };
+        taskSelection?: {
+            strategy: 'all' | 'specific';
+            taskIds: string[];
+        };
+        servers: Array<{
+            name: string;
+            command: string;
+            args: string[];
+            env: Record<string, string>;
+            tools: string[];
+        }>;
+    };
+    memoryConfig?: {
+        enabled: boolean;
+        isolation: string;
+        retrieval?: {
+            layer_limits?: {
+                session: number;
+                user: number;
+                agent: number;
+            };
+            layer_weights?: {
+                session: number;
+                user: number;
+                agent: number;
+            };
+        };
+        storage?: {
+            importance_thresholds?: {
+                session: number;
+                user: number;
+                agent: number;
+            };
+        };
+    };
+    webSearchConfig?: {
+        enabled: boolean;
+        maxSearches: number;
+        maxResultsPerSearch: number;
+    };
+    thinkingChainConfig?: {
+        enabled: boolean;
+        maxIterations: number;
+    };
+}
+export {};

package/dist/components/app/types/api.d.ts

@@ -0,0 +1,9 @@
+export interface ApiResponse<T> {
+    success: boolean;
+    message?: string;
+    data?: T;
+    code?: number;
+    timestamp?: string;
+    error?: string;
+    errorDetails?: unknown;
+}

package/dist/components/app/types/knowledge.d.ts

@@ -0,0 +1,10 @@
+export interface KnowledgeBase {
+    id: string;
+    name: string;
+    description: string;
+    documentCount: number;
+    lastUpdated: string;
+    linkedAgents: number;
+    type: string;
+    icon: React.ReactNode;
+}

package/dist/components/app/types/model.d.ts

@@ -0,0 +1,23 @@
+export interface Model {
+    id: string;
+    identifier: string;
+    name: string;
+    description: string;
+    icon: React.ReactNode;
+    color: string;
+    features: string[];
+    pricing?: string;
+    latency?: string;
+    userConfigurableParams: Record<string, unknown>;
+    supportedFeatures: Record<string, unknown>;
+    supportsMultimodal?: boolean;
+    supportedContentTypes?: string[];
+    multimodalConfig?: {
+        maxImageSize?: number;
+        maxAudioDuration?: number;
+        supportedImageFormats?: string[];
+        supportedAudioFormats?: string[];
+        imageProcessingOptions?: Record<string, unknown>;
+        audioProcessingOptions?: Record<string, unknown>;
+    };
+}

package/dist/components/app/types/task.d.ts

@@ -0,0 +1,64 @@
+export interface Task {
+    id: string;
+    name: string;
+    description: string;
+    type: 'SCHEDULED' | 'EVENT' | 'MANUAL';
+    priority: 'HIGH' | 'MEDIUM' | 'LOW';
+    schedule?: string;
+    startDate?: string;
+    endDate?: string;
+    tags: string[];
+    webhookUrl?: string;
+    webhookSecret?: string;
+    webhookPayloadTemplate?: string;
+}
+export interface Port {
+    id: string;
+    type: string;
+    label?: string;
+    required?: boolean;
+}
+export interface Schema {
+    type: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+export interface TaskNode extends Node {
+    id: string;
+    type: 'agent' | 'operator' | 'control';
+    data: {
+        id: string;
+        identifier: string;
+        type: string;
+        name: string;
+        status?: string;
+        description?: string;
+        category?: string;
+        icon?: string;
+        iconColor?: string;
+        inputSchema?: Schema;
+        outputSchema?: Schema;
+        inputPorts?: Port[];
+        outputPorts?: Port[];
+        [key: string]: unknown;
+    };
+    position?: {
+        x: number;
+        y: number;
+    };
+    [key: string]: unknown;
+}
+export interface TaskNodeData {
+    identifier: string;
+    name: string;
+    description: string;
+    inputSchema?: Schema;
+    outputSchema?: Schema;
+    metadata?: {
+        locales?: Record<string, {
+            name: string;
+            description: string;
+        }>;
+    };
+}