@base44/sdk 0.7.0 → 0.7.3

package/dist/client.d.ts

@@ -1,3 +1,7 @@
+export type CreateClientOptions = {
+    onError?: (error: Error) => void;
+};
+export type Base44Client = ReturnType<typeof createClient>;
 /**
  * Create a Base44 client instance
  * @param {Object} config - Client configuration
@@ -14,6 +18,9 @@ export declare function createClient(config: {
     token?: string;
     serviceToken?: string;
     requiresAuth?: boolean;
+    functionsVersion?: string;
+    options?: CreateClientOptions;
+    onRedirectToLogin?: () => void;
 }): {
     /**
      * Set authentication token for all requests
@@ -38,6 +45,18 @@ export declare function createClient(config: {
         functions: {
             invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
         };
+        agents: {
+            getConversations: () => Promise<import("./types.js").AgentConversation[]>;
+            getConversation: (conversationId: string) => Promise<import("./types.js").AgentConversation | undefined>;
+            listConversations: (filterParams: import("./types.js").ModelFilterParams) => Promise<import("./types.js").AgentConversation[]>;
+            createConversation: (conversation: {
+                agent_name: string;
+                metadata?: Record<string, any>;
+            }) => Promise<import("./types.js").AgentConversation>;
+            addMessage: (conversation: import("./types.js").AgentConversation, message: import("./types.js").AgentMessage) => Promise<import("./types.js").AgentMessage>;
+            subscribeToConversation: (conversationId: string, onUpdate?: (conversation: import("./types.js").AgentConversation) => void) => () => void;
+        };
+        cleanup: () => void;
     };
     entities: {};
     integrations: {};
@@ -56,6 +75,18 @@ export declare function createClient(config: {
     functions: {
         invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
     };
+    agents: {
+        getConversations: () => Promise<import("./types.js").AgentConversation[]>;
+        getConversation: (conversationId: string) => Promise<import("./types.js").AgentConversation | undefined>;
+        listConversations: (filterParams: import("./types.js").ModelFilterParams) => Promise<import("./types.js").AgentConversation[]>;
+        createConversation: (conversation: {
+            agent_name: string;
+            metadata?: Record<string, any>;
+        }) => Promise<import("./types.js").AgentConversation>;
+        addMessage: (conversation: import("./types.js").AgentConversation, message: import("./types.js").AgentMessage) => Promise<import("./types.js").AgentMessage>;
+        subscribeToConversation: (conversationId: string, onUpdate?: (conversation: import("./types.js").AgentConversation) => void) => () => void;
+    };
+    cleanup: () => void;
 };
 export declare function createClientFromRequest(request: Request): {
     /**
@@ -81,6 +112,18 @@ export declare function createClientFromRequest(request: Request): {
         functions: {
             invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
         };
+        agents: {
+            getConversations: () => Promise<import("./types.js").AgentConversation[]>;
+            getConversation: (conversationId: string) => Promise<import("./types.js").AgentConversation | undefined>;
+            listConversations: (filterParams: import("./types.js").ModelFilterParams) => Promise<import("./types.js").AgentConversation[]>;
+            createConversation: (conversation: {
+                agent_name: string;
+                metadata?: Record<string, any>;
+            }) => Promise<import("./types.js").AgentConversation>;
+            addMessage: (conversation: import("./types.js").AgentConversation, message: import("./types.js").AgentMessage) => Promise<import("./types.js").AgentMessage>;
+            subscribeToConversation: (conversationId: string, onUpdate?: (conversation: import("./types.js").AgentConversation) => void) => () => void;
+        };
+        cleanup: () => void;
     };
     entities: {};
     integrations: {};
@@ -99,4 +142,16 @@ export declare function createClientFromRequest(request: Request): {
     functions: {
         invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
     };
+    agents: {
+        getConversations: () => Promise<import("./types.js").AgentConversation[]>;
+        getConversation: (conversationId: string) => Promise<import("./types.js").AgentConversation | undefined>;
+        listConversations: (filterParams: import("./types.js").ModelFilterParams) => Promise<import("./types.js").AgentConversation[]>;
+        createConversation: (conversation: {
+            agent_name: string;
+            metadata?: Record<string, any>;
+        }) => Promise<import("./types.js").AgentConversation>;
+        addMessage: (conversation: import("./types.js").AgentConversation, message: import("./types.js").AgentMessage) => Promise<import("./types.js").AgentMessage>;
+        subscribeToConversation: (conversationId: string, onUpdate?: (conversation: import("./types.js").AgentConversation) => void) => () => void;
+    };
+    cleanup: () => void;
 };

package/dist/client.js

@@ -5,6 +5,8 @@ import { createAuthModule } from "./modules/auth.js";
 import { createSsoModule } from "./modules/sso.js";
 import { getAccessToken } from "./utils/auth-utils.js";
 import { createFunctionsModule } from "./modules/functions.js";
+import { createAgentsModule } from "./modules/agents.js";
+import { RoomsSocket } from "./utils/socket-utils.js";
 /**
  * Create a Base44 client instance
  * @param {Object} config - Client configuration
@@ -16,58 +18,95 @@ import { createFunctionsModule } from "./modules/functions.js";
  * @returns {Object} Base44 client instance
  */
 export function createClient(config) {
-    const { serverUrl = "https://base44.app", appId, token, serviceToken, requiresAuth = false, } = config;
+    const { serverUrl = "https://base44.app", appId, token, serviceToken, requiresAuth = false, options, functionsVersion, onRedirectToLogin, } = config;
+    const socketConfig = {
+        serverUrl,
+        mountPath: "/ws-user-apps/socket.io/",
+        transports: ["websocket"],
+        appId,
+        token,
+    };
+    const socket = RoomsSocket({
+        config: socketConfig,
+    });
+    const headers = {
+        "X-App-Id": String(appId),
+    };
+    const functionHeaders = functionsVersion
+        ? {
+            ...headers,
+            "Base44-Functions-Version": functionsVersion,
+        }
+        : headers;
     const axiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
-        headers: {
-            "X-App-Id": String(appId),
-        },
+        headers,
         token,
         requiresAuth,
         appId,
         serverUrl,
+        onError: options === null || options === void 0 ? void 0 : options.onError,
+        onRedirectToLogin,
     });
     const functionsAxiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
-        headers: {
-            "X-App-Id": String(appId),
-        },
+        headers: functionHeaders,
         token,
         requiresAuth,
         appId,
         serverUrl,
         interceptResponses: false,
+        onError: options === null || options === void 0 ? void 0 : options.onError,
+        onRedirectToLogin,
     });
     const serviceRoleAxiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
-        headers: {
-            "X-App-Id": String(appId),
-        },
+        headers,
         token: serviceToken,
         serverUrl,
         appId,
+        onError: options === null || options === void 0 ? void 0 : options.onError,
+        onRedirectToLogin,
     });
     const serviceRoleFunctionsAxiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
-        headers: {
-            "X-App-Id": String(appId),
-        },
+        headers: functionHeaders,
         token: serviceToken,
         serverUrl,
         appId,
         interceptResponses: false,
+        onRedirectToLogin,
     });
     const userModules = {
         entities: createEntitiesModule(axiosClient, appId),
         integrations: createIntegrationsModule(axiosClient, appId),
-        auth: createAuthModule(axiosClient, functionsAxiosClient, appId),
+        auth: createAuthModule(axiosClient, functionsAxiosClient, appId, {
+            onRedirectToLogin,
+            serverUrl,
+        }),
         functions: createFunctionsModule(functionsAxiosClient, appId),
+        agents: createAgentsModule({
+            axios: axiosClient,
+            socket,
+            appId,
+        }),
+        cleanup: () => {
+            socket.disconnect();
+        },
     };
     const serviceRoleModules = {
         entities: createEntitiesModule(serviceRoleAxiosClient, appId),
         integrations: createIntegrationsModule(serviceRoleAxiosClient, appId),
         sso: createSsoModule(serviceRoleAxiosClient, appId, token),
         functions: createFunctionsModule(serviceRoleFunctionsAxiosClient, appId),
+        agents: createAgentsModule({
+            axios: serviceRoleAxiosClient,
+            socket,
+            appId,
+        }),
+        cleanup: () => {
+            socket.disconnect();
+        },
     };
     // Always try to get token from localStorage or URL parameters
     if (typeof window !== "undefined") {
@@ -102,6 +141,9 @@ export function createClient(config) {
          */
         setToken(newToken) {
             userModules.auth.setToken(newToken);
+            socket.updateConfig({
+                token: newToken,
+            });
         },
         /**
          * Get current configuration
@@ -120,10 +162,10 @@ export function createClient(config) {
          */
         get asServiceRole() {
             if (!serviceToken) {
-                throw new Error('Service token is required to use asServiceRole. Please provide a serviceToken when creating the client.');
+                throw new Error("Service token is required to use asServiceRole. Please provide a serviceToken when creating the client.");
             }
             return serviceRoleModules;
-        }
+        },
     };
     return client;
 }
@@ -132,6 +174,7 @@ export function createClientFromRequest(request) {
     const serviceRoleAuthHeader = request.headers.get("Base44-Service-Authorization");
     const appId = request.headers.get("Base44-App-Id");
     const serverUrlHeader = request.headers.get("Base44-Api-Url");
+    const functionsVersion = request.headers.get("Base44-Functions-Version");
     if (!appId) {
         throw new Error("Base44-App-Id header is required, but is was not found on the request");
     }
@@ -139,21 +182,26 @@ export function createClientFromRequest(request) {
     let serviceRoleToken;
     let userToken;
     if (serviceRoleAuthHeader !== null) {
-        if (serviceRoleAuthHeader === '' || !serviceRoleAuthHeader.startsWith('Bearer ') || serviceRoleAuthHeader.split(' ').length !== 2) {
+        if (serviceRoleAuthHeader === "" ||
+            !serviceRoleAuthHeader.startsWith("Bearer ") ||
+            serviceRoleAuthHeader.split(" ").length !== 2) {
             throw new Error('Invalid authorization header format. Expected "Bearer <token>"');
         }
-        serviceRoleToken = serviceRoleAuthHeader.split(' ')[1];
+        serviceRoleToken = serviceRoleAuthHeader.split(" ")[1];
     }
     if (authHeader !== null) {
-        if (authHeader === '' || !authHeader.startsWith('Bearer ') || authHeader.split(' ').length !== 2) {
+        if (authHeader === "" ||
+            !authHeader.startsWith("Bearer ") ||
+            authHeader.split(" ").length !== 2) {
             throw new Error('Invalid authorization header format. Expected "Bearer <token>"');
         }
-        userToken = authHeader.split(' ')[1];
+        userToken = authHeader.split(" ")[1];
     }
     return createClient({
         serverUrl: serverUrlHeader || "https://base44.app",
         appId,
         token: userToken,
         serviceToken: serviceRoleToken,
+        functionsVersion: functionsVersion !== null && functionsVersion !== void 0 ? functionsVersion : undefined,
     });
 }

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import { createClient, createClientFromRequest } from "./client.js";
+import { createClient, createClientFromRequest, type Base44Client } from "./client.js";
 import { Base44Error } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from "./utils/auth-utils.js";
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
+export type { Base44Client };
+export * from "./types.js";

package/dist/index.js

@@ -2,3 +2,4 @@ import { createClient, createClientFromRequest } from "./client.js";
 import { Base44Error } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, } from "./utils/auth-utils.js";
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
+export * from "./types.js";

package/dist/modules/agents.d.ts

@@ -0,0 +1,20 @@
+import { RoomsSocket } from "../utils/socket-utils.js";
+import { AgentConversation, AgentMessage } from "./agents.types.js";
+import { AxiosInstance } from "axios";
+import { ModelFilterParams } from "../types.js";
+export type AgentsModuleConfig = {
+    axios: AxiosInstance;
+    socket: ReturnType<typeof RoomsSocket>;
+    appId: string;
+};
+export declare function createAgentsModule({ axios, socket, appId, }: AgentsModuleConfig): {
+    getConversations: () => Promise<AgentConversation[]>;
+    getConversation: (conversationId: string) => Promise<AgentConversation | undefined>;
+    listConversations: (filterParams: ModelFilterParams) => Promise<AgentConversation[]>;
+    createConversation: (conversation: {
+        agent_name: string;
+        metadata?: Record<string, any>;
+    }) => Promise<AgentConversation>;
+    addMessage: (conversation: AgentConversation, message: AgentMessage) => Promise<AgentMessage>;
+    subscribeToConversation: (conversationId: string, onUpdate?: (conversation: AgentConversation) => void) => () => void;
+};

package/dist/modules/agents.js

@@ -0,0 +1,43 @@
+export function createAgentsModule({ axios, socket, appId, }) {
+    const baseURL = `/apps/${appId}/agents`;
+    const getConversations = () => {
+        return axios.get(`${baseURL}/conversations`);
+    };
+    const getConversation = (conversationId) => {
+        return axios.get(`${baseURL}/conversations/${conversationId}`);
+    };
+    const listConversations = (filterParams) => {
+        return axios.get(`${baseURL}/conversations`, {
+            params: filterParams,
+        });
+    };
+    const createConversation = (conversation) => {
+        return axios.post(`${baseURL}/conversations`, conversation);
+    };
+    const addMessage = async (conversation, message) => {
+        const room = `/agent-conversations/${conversation.id}`;
+        await socket.updateModel(room, {
+            ...conversation,
+            messages: [...(conversation.messages || []), message],
+        });
+        return axios.post(`${baseURL}/conversations/${conversation.id}/messages`, message);
+    };
+    const subscribeToConversation = (conversationId, onUpdate) => {
+        const room = `/agent-conversations/${conversationId}`;
+        return socket.subscribeToRoom(room, {
+            connect: () => { },
+            update_model: ({ data: jsonStr }) => {
+                const conv = JSON.parse(jsonStr);
+                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(conv);
+            },
+        });
+    };
+    return {
+        getConversations,
+        getConversation,
+        listConversations,
+        createConversation,
+        addMessage,
+        subscribeToConversation,
+    };
+}

package/dist/modules/agents.types.d.ts

@@ -0,0 +1,44 @@
+export type AgentConversation = {
+    id: string;
+    app_id: string;
+    agent_name: string;
+    created_by_id: string;
+    messages: AgentMessage[];
+    metadata?: Record<string, any>;
+};
+export type AgentMessage = {
+    id: string;
+    role: "user" | "assistant" | "system";
+    reasoning?: {
+        start_date: string;
+        end_date?: string;
+        content: string;
+    };
+    content?: string | Record<string, any> | null;
+    file_urls?: string[] | null;
+    tool_calls?: {
+        id: string;
+        name: string;
+        arguments_string: string;
+        status: "running" | "success" | "error" | "stopped";
+        results?: string | null;
+    }[] | null;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+    } | null;
+    hidden?: boolean;
+    custom_context?: {
+        message: string;
+        data: Record<string, any>;
+        type: string;
+    }[] | null;
+    model?: string | null;
+    checkpoint_id?: string | null;
+    metadata?: {
+        created_date: string;
+        created_by_email: string;
+        created_by_full_name: string | null;
+    };
+    additional_message_params?: Record<string, any>;
+};

package/dist/modules/agents.types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/app.types.d.ts

@@ -0,0 +1,115 @@
+export interface AppMessageContent {
+    content?: string;
+    file_urls?: string[];
+    custom_context?: unknown;
+    additional_message_params?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface AppConversationMessage extends AppMessageContent {
+    id?: string | null;
+    role?: "user" | "assistant" | string;
+}
+export interface AppConversationLike {
+    id?: string | null;
+    messages?: AppMessageContent[] | null;
+    model?: string;
+    functions_fail_silently?: boolean;
+}
+export interface DenoProjectLike {
+    project_id: string;
+    project_name: string;
+    app_id: string;
+    deployment_name_to_info: Record<string, {
+        id: string;
+        code: string;
+    }>;
+}
+export interface AppLike {
+    id?: string;
+    conversation?: AppConversationLike | null;
+    app_stage?: "pending" | "product_flows" | "ready" | string;
+    created_date?: string;
+    updated_date?: string;
+    created_by?: string;
+    organization_id?: string;
+    name?: string;
+    user_description?: string;
+    entities?: Record<string, any>;
+    additional_user_data_schema?: any;
+    pages?: {
+        [key: string]: string;
+    };
+    components: {
+        [key: string]: any;
+    };
+    layout?: string;
+    globals_css?: string;
+    agents?: Record<string, any>;
+    logo_url?: string;
+    slug?: string;
+    public_settings?: "private_with_login" | "public_with_login" | "public_without_login" | "workspace_with_login" | string;
+    is_blocked?: boolean;
+    github_repo_url?: string;
+    main_page?: string;
+    installable_integrations?: any;
+    backend_project?: DenoProjectLike;
+    last_deployed_at?: string;
+    is_remixable?: boolean;
+    remixed_from_app_id?: string;
+    hide_entity_created_by?: boolean;
+    platform_version?: number;
+    enable_username_password?: boolean;
+    auth_config?: AuthConfigLike;
+    status?: {
+        state?: string;
+        details?: any;
+        last_updated_date?: string;
+    };
+    custom_instructions?: any;
+    frozen_files?: string[];
+    deep_coding_mode?: boolean;
+    needs_to_add_diff?: boolean;
+    installed_integration_context_items?: any[];
+    model?: string;
+    is_starred?: boolean;
+    agents_enabled?: boolean;
+    categories?: string[];
+    functions?: any;
+    function_names?: string[];
+    user_entity?: UserEntityLike;
+    app_code_hash?: string;
+    has_backend_functions_enabled?: boolean;
+}
+export interface UserLike {
+    id?: string | null;
+}
+export interface UserEntityLike {
+    type: string;
+    name: string;
+    title?: string;
+    properties?: {
+        role?: {
+            type?: string;
+            description?: string;
+            enum?: ("admin" | "user" | string)[];
+        };
+        email?: {
+            type?: string;
+            description?: string;
+        };
+        full_name?: {
+            type?: string;
+            description?: string;
+        };
+    };
+    required: string[];
+}
+export interface AuthConfigLike {
+    enable_username_password?: boolean;
+    enable_google_login?: boolean;
+    enable_microsoft_login?: boolean;
+    enable_facebook_login?: boolean;
+    sso_provider_name?: string;
+    enable_sso_login?: boolean;
+}
+export type LoginInfoResponse = Pick<AppLike, "id" | "name" | "slug" | "logo_url" | "user_description" | "updated_date" | "created_date" | "auth_config" | "platform_version">;

package/dist/modules/app.types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/auth.d.ts

@@ -6,7 +6,10 @@ import { AxiosInstance } from "axios";
  * @param {string} serverUrl - Server URL
  * @returns {Object} Auth module with authentication methods
  */
-export declare function createAuthModule(axios: AxiosInstance, functionsAxiosClient: AxiosInstance, appId: string): {
+export declare function createAuthModule(axios: AxiosInstance, functionsAxiosClient: AxiosInstance, appId: string, options: {
+    serverUrl: string;
+    onRedirectToLogin?: () => void;
+}): {
     /**
      * Get current user information
      * @returns {Promise<Object>} Current user data

package/dist/modules/auth.js

@@ -5,7 +5,7 @@
  * @param {string} serverUrl - Server URL
  * @returns {Object} Auth module with authentication methods
  */
-export function createAuthModule(axios, functionsAxiosClient, appId) {
+export function createAuthModule(axios, functionsAxiosClient, appId, options) {
     return {
         /**
          * Get current user information
@@ -32,6 +32,10 @@ export function createAuthModule(axios, functionsAxiosClient, appId) {
             if (typeof window === "undefined") {
                 throw new Error("Login method can only be used in a browser environment");
             }
+            if (options.onRedirectToLogin) {
+                options.onRedirectToLogin();
+                return;
+            }
             // If nextUrl is not provided, use the current URL
             const redirectUrl = nextUrl || window.location.href;
             // Build the login URL
@@ -77,6 +81,7 @@ export function createAuthModule(axios, functionsAxiosClient, appId) {
         setToken(token, saveToStorage = true) {
             if (!token)
                 return;
+            // handle token change for axios clients
             axios.defaults.headers.common["Authorization"] = `Bearer ${token}`;
             functionsAxiosClient.defaults.headers.common["Authorization"] = `Bearer ${token}`;
             // Save token to localStorage if requested

package/dist/modules/types.d.ts

@@ -0,0 +1,2 @@
+export * from "./app.types.js";
+export * from "./agents.types.js";

package/dist/modules/types.js

@@ -0,0 +1,2 @@
+export * from "./app.types.js";
+export * from "./agents.types.js";

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+export * from "./modules/types.js";
+export type ModelFilterParams = {
+    q?: Record<string, any>;
+    sort?: string | null;
+    sort_by?: string | null;
+    limit?: number | null;
+    skip?: number | null;
+    fields?: string[] | null;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export * from "./modules/types.js";

package/dist/utils/axios-client.d.ts

@@ -23,7 +23,7 @@ export declare class Base44Error extends Error {
  * @param {string} options.serverUrl - Server URL (needed for login redirect)
  * @returns {import('axios').AxiosInstance} Configured axios instance
  */
-export declare function createAxiosClient({ baseURL, headers, token, requiresAuth, appId, serverUrl, interceptResponses, }: {
+export declare function createAxiosClient({ baseURL, headers, token, requiresAuth, appId, serverUrl, interceptResponses, onError, onRedirectToLogin, }: {
     baseURL: string;
     headers?: Record<string, string>;
     token?: string;
@@ -31,4 +31,6 @@ export declare function createAxiosClient({ baseURL, headers, token, requiresAut
     appId: string;
     serverUrl: string;
     interceptResponses?: boolean;
+    onError?: (error: Error) => void;
+    onRedirectToLogin?: () => void;
 }): import("axios").AxiosInstance;

package/dist/utils/axios-client.js

@@ -64,7 +64,7 @@ function redirectToLogin(serverUrl, appId) {
  * @param {string} options.serverUrl - Server URL (needed for login redirect)
  * @returns {import('axios').AxiosInstance} Configured axios instance
  */
-export function createAxiosClient({ baseURL, headers = {}, token, requiresAuth = false, appId, serverUrl, interceptResponses = true, }) {
+export function createAxiosClient({ baseURL, headers = {}, token, requiresAuth = false, appId, serverUrl, interceptResponses = true, onError, onRedirectToLogin, }) {
     const client = axios.create({
         baseURL,
         headers: {
@@ -104,9 +104,12 @@ export function createAxiosClient({ baseURL, headers = {}, token, requiresAuth =
                 console.log("Authentication required. Redirecting to login...");
                 // Use a slight delay to allow the error to propagate first
                 setTimeout(() => {
-                    redirectToLogin(serverUrl, appId);
+                    onRedirectToLogin
+                        ? onRedirectToLogin()
+                        : redirectToLogin(serverUrl, appId);
                 }, 100);
             }
+            onError === null || onError === void 0 ? void 0 : onError(base44Error);
             return Promise.reject(base44Error);
         });
     }

package/dist/utils/socket-utils.d.ts

@@ -0,0 +1,47 @@
+import { Socket } from "socket.io-client";
+export type RoomsSocketConfig = {
+    serverUrl: string;
+    mountPath: string;
+    transports: string[];
+    appId: string;
+    token?: string;
+};
+export type TSocketRoom = string;
+export type TJsonStr = string;
+type RoomsSocketEventsMap = {
+    listen: {
+        connect: () => Promise<void> | void;
+        update_model: (msg: {
+            room: string;
+            data: TJsonStr;
+        }) => Promise<void> | void;
+        error: (error: Error) => Promise<void> | void;
+    };
+    emit: {
+        join: (room: string) => void;
+        leave: (room: string) => void;
+    };
+};
+type TEvent = keyof RoomsSocketEventsMap["listen"];
+type THandler<E extends TEvent> = RoomsSocketEventsMap["listen"][E];
+export type RoomsSocket = ReturnType<typeof RoomsSocket>;
+export declare function RoomsSocket({ config }: {
+    config: RoomsSocketConfig;
+}): {
+    socket: Socket<{
+        connect: () => Promise<void> | void;
+        update_model: (msg: {
+            room: string;
+            data: TJsonStr;
+        }) => Promise<void> | void;
+        error: (error: Error) => Promise<void> | void;
+    }, {
+        join: (room: string) => void;
+        leave: (room: string) => void;
+    }>;
+    subscribeToRoom: (room: TSocketRoom, handlers: Partial<{ [k in TEvent]: THandler<k>; }>) => () => void;
+    updateConfig: (config: Partial<RoomsSocketConfig>) => void;
+    updateModel: (room: string, data: any) => Promise<void>;
+    disconnect: () => void;
+};
+export {};

package/dist/utils/socket-utils.js

@@ -0,0 +1,115 @@
+import { io } from "socket.io-client";
+import { getAccessToken } from "./auth-utils.js";
+function initializeSocket(config, handlers) {
+    var _a;
+    const socket = io(config.serverUrl, {
+        path: config.mountPath,
+        transports: config.transports,
+        query: {
+            app_id: config.appId,
+            token: (_a = config.token) !== null && _a !== void 0 ? _a : getAccessToken(),
+        },
+    });
+    socket.on("connect", async () => {
+        var _a;
+        console.log("connect", socket.id);
+        return (_a = handlers.connect) === null || _a === void 0 ? void 0 : _a.call(handlers);
+    });
+    socket.on("update_model", async (msg) => {
+        var _a;
+        return (_a = handlers.update_model) === null || _a === void 0 ? void 0 : _a.call(handlers, msg);
+    });
+    socket.on("error", async (error) => {
+        var _a;
+        return (_a = handlers.error) === null || _a === void 0 ? void 0 : _a.call(handlers, error);
+    });
+    socket.on("connect_error", async (error) => {
+        var _a;
+        console.error("connect_error", error);
+        return (_a = handlers.error) === null || _a === void 0 ? void 0 : _a.call(handlers, error);
+    });
+    return socket;
+}
+export function RoomsSocket({ config }) {
+    let currentConfig = { ...config };
+    const roomsToListeners = {};
+    const handlers = {
+        connect: async () => {
+            const promises = [];
+            Object.keys(roomsToListeners).forEach((room) => {
+                joinRoom(room);
+                const listeners = getListeners(room);
+                listeners === null || listeners === void 0 ? void 0 : listeners.forEach(({ connect }) => {
+                    const promise = async () => connect === null || connect === void 0 ? void 0 : connect();
+                    promises.push(promise());
+                });
+            });
+            await Promise.all(promises);
+        },
+        update_model: async (msg) => {
+            const listeners = getListeners(msg.room);
+            const promises = listeners.map((listener) => { var _a; return (_a = listener.update_model) === null || _a === void 0 ? void 0 : _a.call(listener, msg); });
+            await Promise.all(promises);
+        },
+        error: async (error) => {
+            console.error("error", error);
+            const promises = Object.values(roomsToListeners)
+                .flat()
+                .map((listener) => { var _a; return (_a = listener.error) === null || _a === void 0 ? void 0 : _a.call(listener, error); });
+            await Promise.all(promises);
+        },
+    };
+    let socket = initializeSocket(config, handlers);
+    function cleanup() {
+        disconnect();
+    }
+    function disconnect() {
+        if (socket) {
+            socket.disconnect();
+        }
+    }
+    function updateConfig(config) {
+        cleanup();
+        currentConfig = {
+            ...currentConfig,
+            ...config,
+        };
+        socket = initializeSocket(currentConfig, handlers);
+    }
+    function joinRoom(room) {
+        socket.emit("join", room);
+    }
+    function leaveRoom(room) {
+        socket.emit("leave", room);
+    }
+    async function updateModel(room, data) {
+        var _a;
+        const dataStr = JSON.stringify(data);
+        return (_a = handlers.update_model) === null || _a === void 0 ? void 0 : _a.call(handlers, { room, data: dataStr });
+    }
+    function getListeners(room) {
+        return roomsToListeners[room];
+    }
+    const subscribeToRoom = (room, handlers) => {
+        if (!roomsToListeners[room]) {
+            joinRoom(room);
+            roomsToListeners[room] = [];
+        }
+        roomsToListeners[room].push(handlers);
+        return () => {
+            var _a, _b;
+            roomsToListeners[room] =
+                (_b = (_a = roomsToListeners[room]) === null || _a === void 0 ? void 0 : _a.filter((listener) => listener !== handlers)) !== null && _b !== void 0 ? _b : [];
+            if (roomsToListeners[room].length === 0) {
+                leaveRoom(room);
+            }
+        };
+    };
+    return {
+        socket,
+        subscribeToRoom,
+        updateConfig,
+        updateModel,
+        disconnect,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44/sdk",
-  "version": "0.7.0",
+  "version": "0.7.3",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "axios": "^1.6.2"
+    "axios": "^1.6.2",
+    "socket.io-client": "^4.7.5"
   },
   "devDependencies": {
     "vitest": "^1.0.0",