@base44-preview/sdk 0.7.0-dev.e78162e → 0.7.0-pr.26.0b8f663

package/dist/client.d.ts

@@ -1,3 +1,4 @@
+import { AgentsModuleConfig } from "./modules/agents.js";
 /**
  * Create a Base44 client instance
  * @param {Object} config - Client configuration
@@ -6,6 +7,7 @@
  * @param {string} [config.token] - Authentication token
  * @param {string} [config.serviceToken] - Service role authentication token
  * @param {boolean} [config.requiresAuth=false] - Whether the app requires authentication
+ * @param {AgentsModuleConfig} [config.agents] - Configuration for agents module
  * @returns {Object} Base44 client instance
  */
 export declare function createClient(config: {
@@ -14,6 +16,7 @@ export declare function createClient(config: {
     token?: string;
     serviceToken?: string;
     requiresAuth?: boolean;
+    agents?: AgentsModuleConfig;
 }): {
     /**
      * Set authentication token for all requests
@@ -38,6 +41,21 @@ export declare function createClient(config: {
         functions: {
             invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
         };
+        agents: {
+            listConversations(filterParams?: import("./modules/agents.js").FilterParams): Promise<import("./modules/agents.js").AgentConversation[]>;
+            getConversation(conversationId: string): Promise<import("./modules/agents.js").AgentConversation>;
+            createConversation(payload: import("./modules/agents.js").CreateConversationPayload): Promise<import("./modules/agents.js").AgentConversation>;
+            updateConversation(conversationId: string, payload: import("./modules/agents.js").UpdateConversationPayload): Promise<import("./modules/agents.js").AgentConversation>;
+            sendMessage(conversationId: string, message: Omit<import("./modules/agents.js").Message, "id">): Promise<import("./modules/agents.js").Message>;
+            deleteMessage(conversationId: string, messageId: string): Promise<void>;
+            subscribeToConversation(conversationId: string, onUpdate: (conversation: import("./modules/agents.js").AgentConversation) => void): () => void;
+            getWebSocketStatus(): {
+                enabled: boolean;
+                connected: boolean;
+            };
+            connectWebSocket(): Promise<void>;
+            disconnectWebSocket(): void;
+        };
     };
     entities: {};
     integrations: {};
@@ -56,6 +74,21 @@ export declare function createClient(config: {
     functions: {
         invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
     };
+    agents: {
+        listConversations(filterParams?: import("./modules/agents.js").FilterParams): Promise<import("./modules/agents.js").AgentConversation[]>;
+        getConversation(conversationId: string): Promise<import("./modules/agents.js").AgentConversation>;
+        createConversation(payload: import("./modules/agents.js").CreateConversationPayload): Promise<import("./modules/agents.js").AgentConversation>;
+        updateConversation(conversationId: string, payload: import("./modules/agents.js").UpdateConversationPayload): Promise<import("./modules/agents.js").AgentConversation>;
+        sendMessage(conversationId: string, message: Omit<import("./modules/agents.js").Message, "id">): Promise<import("./modules/agents.js").Message>;
+        deleteMessage(conversationId: string, messageId: string): Promise<void>;
+        subscribeToConversation(conversationId: string, onUpdate: (conversation: import("./modules/agents.js").AgentConversation) => void): () => void;
+        getWebSocketStatus(): {
+            enabled: boolean;
+            connected: boolean;
+        };
+        connectWebSocket(): Promise<void>;
+        disconnectWebSocket(): void;
+    };
 };
 export declare function createClientFromRequest(request: Request): {
     /**
@@ -81,6 +114,21 @@ export declare function createClientFromRequest(request: Request): {
         functions: {
             invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
         };
+        agents: {
+            listConversations(filterParams?: import("./modules/agents.js").FilterParams): Promise<import("./modules/agents.js").AgentConversation[]>;
+            getConversation(conversationId: string): Promise<import("./modules/agents.js").AgentConversation>;
+            createConversation(payload: import("./modules/agents.js").CreateConversationPayload): Promise<import("./modules/agents.js").AgentConversation>;
+            updateConversation(conversationId: string, payload: import("./modules/agents.js").UpdateConversationPayload): Promise<import("./modules/agents.js").AgentConversation>;
+            sendMessage(conversationId: string, message: Omit<import("./modules/agents.js").Message, "id">): Promise<import("./modules/agents.js").Message>;
+            deleteMessage(conversationId: string, messageId: string): Promise<void>;
+            subscribeToConversation(conversationId: string, onUpdate: (conversation: import("./modules/agents.js").AgentConversation) => void): () => void;
+            getWebSocketStatus(): {
+                enabled: boolean;
+                connected: boolean;
+            };
+            connectWebSocket(): Promise<void>;
+            disconnectWebSocket(): void;
+        };
     };
     entities: {};
     integrations: {};
@@ -99,4 +147,19 @@ export declare function createClientFromRequest(request: Request): {
     functions: {
         invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
     };
+    agents: {
+        listConversations(filterParams?: import("./modules/agents.js").FilterParams): Promise<import("./modules/agents.js").AgentConversation[]>;
+        getConversation(conversationId: string): Promise<import("./modules/agents.js").AgentConversation>;
+        createConversation(payload: import("./modules/agents.js").CreateConversationPayload): Promise<import("./modules/agents.js").AgentConversation>;
+        updateConversation(conversationId: string, payload: import("./modules/agents.js").UpdateConversationPayload): Promise<import("./modules/agents.js").AgentConversation>;
+        sendMessage(conversationId: string, message: Omit<import("./modules/agents.js").Message, "id">): Promise<import("./modules/agents.js").Message>;
+        deleteMessage(conversationId: string, messageId: string): Promise<void>;
+        subscribeToConversation(conversationId: string, onUpdate: (conversation: import("./modules/agents.js").AgentConversation) => void): () => void;
+        getWebSocketStatus(): {
+            enabled: boolean;
+            connected: boolean;
+        };
+        connectWebSocket(): Promise<void>;
+        disconnectWebSocket(): void;
+    };
 };

package/dist/client.js

@@ -5,6 +5,7 @@ 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";
 /**
  * Create a Base44 client instance
  * @param {Object} config - Client configuration
@@ -13,10 +14,11 @@ import { createFunctionsModule } from "./modules/functions.js";
  * @param {string} [config.token] - Authentication token
  * @param {string} [config.serviceToken] - Service role authentication token
  * @param {boolean} [config.requiresAuth=false] - Whether the app requires authentication
+ * @param {AgentsModuleConfig} [config.agents] - Configuration for agents module
  * @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, agents = {}, } = config;
     const axiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
         headers: {
@@ -62,12 +64,14 @@ export function createClient(config) {
         integrations: createIntegrationsModule(axiosClient, appId),
         auth: createAuthModule(axiosClient, functionsAxiosClient, appId),
         functions: createFunctionsModule(functionsAxiosClient, appId),
+        agents: createAgentsModule(axiosClient, appId, agents),
     };
     const serviceRoleModules = {
         entities: createEntitiesModule(serviceRoleAxiosClient, appId),
         integrations: createIntegrationsModule(serviceRoleAxiosClient, appId),
         sso: createSsoModule(serviceRoleAxiosClient, appId, token),
         functions: createFunctionsModule(serviceRoleFunctionsAxiosClient, appId),
+        agents: createAgentsModule(serviceRoleAxiosClient, appId, agents),
     };
     // Always try to get token from localStorage or URL parameters
     if (typeof window !== "undefined") {
@@ -120,10 +124,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;
 }
@@ -139,16 +143,20 @@ 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",

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { createClient, createClientFromRequest } from "./client.js";
 import { Base44Error } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from "./utils/auth-utils.js";
+export type { Message, AgentConversation, CreateConversationPayload, UpdateConversationPayload, FilterParams, AgentsModuleConfig, AgentsModule, } from "./modules/agents.js";
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };

package/dist/modules/agents.d.ts

@@ -0,0 +1,85 @@
+import { AxiosInstance } from "axios";
+export interface Message {
+    id: string;
+    role: "user" | "assistant";
+    content: string;
+    timestamp?: string;
+    metadata?: Record<string, any>;
+}
+export interface AgentConversation {
+    id: string;
+    app_id: string;
+    created_by_id: string;
+    agent_name: string;
+    messages: Message[];
+    metadata: Record<string, any>;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface CreateConversationPayload {
+    agent_name: string;
+    metadata?: Record<string, any>;
+}
+export interface UpdateConversationPayload {
+    metadata?: Record<string, any>;
+}
+export interface FilterParams {
+    query?: Record<string, any>;
+    sort?: Record<string, 1 | -1>;
+    limit?: number;
+    skip?: number;
+}
+export interface AgentsModuleConfig {
+    enableWebSocket?: boolean;
+    socketUrl?: string;
+}
+/**
+ * Create agents module for managing AI agent conversations
+ */
+export declare function createAgentsModule(axiosClient: AxiosInstance, appId: string, config?: AgentsModuleConfig): {
+    /**
+     * List all conversations for the current user
+     */
+    listConversations(filterParams?: FilterParams): Promise<AgentConversation[]>;
+    /**
+     * Get a specific conversation by ID
+     */
+    getConversation(conversationId: string): Promise<AgentConversation>;
+    /**
+     * Create a new agent conversation
+     */
+    createConversation(payload: CreateConversationPayload): Promise<AgentConversation>;
+    /**
+     * Update conversation metadata
+     */
+    updateConversation(conversationId: string, payload: UpdateConversationPayload): Promise<AgentConversation>;
+    /**
+     * Send a message to an agent and get response
+     */
+    sendMessage(conversationId: string, message: Omit<Message, "id">): Promise<Message>;
+    /**
+     * Delete a message from a conversation
+     */
+    deleteMessage(conversationId: string, messageId: string): Promise<void>;
+    /**
+     * Subscribe to real-time updates for a conversation
+     * Requires WebSocket to be enabled in config
+     */
+    subscribeToConversation(conversationId: string, onUpdate: (conversation: AgentConversation) => void): () => void;
+    /**
+     * Get WebSocket connection status
+     */
+    getWebSocketStatus(): {
+        enabled: boolean;
+        connected: boolean;
+    };
+    /**
+     * Manually connect WebSocket
+     */
+    connectWebSocket(): Promise<void>;
+    /**
+     * Disconnect WebSocket
+     */
+    disconnectWebSocket(): void;
+};
+export type AgentsModule = ReturnType<typeof createAgentsModule>;

package/dist/modules/agents.js

@@ -0,0 +1,251 @@
+/**
+ * WebSocket manager for real-time agent conversations
+ */
+class AgentWebSocketManager {
+    constructor(socketUrl, appId, token) {
+        this.socket = null;
+        this.listeners = new Map();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000;
+        this.socketUrl = socketUrl;
+        this.appId = appId;
+        this.token = token;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            var _a;
+            // Check if WebSocket is available (browser environment)
+            if (typeof WebSocket === "undefined") {
+                reject(new Error("WebSocket is not available in this environment"));
+                return;
+            }
+            if (((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                resolve();
+                return;
+            }
+            try {
+                const wsUrl = new URL(this.socketUrl);
+                wsUrl.searchParams.set("appId", this.appId);
+                if (this.token) {
+                    wsUrl.searchParams.set("token", this.token);
+                }
+                this.socket = new WebSocket(wsUrl.toString());
+                this.socket.onopen = () => {
+                    this.reconnectAttempts = 0;
+                    resolve();
+                };
+                this.socket.onmessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        this.handleMessage(data);
+                    }
+                    catch (error) {
+                        console.error("Failed to parse WebSocket message:", error);
+                    }
+                };
+                this.socket.onclose = () => {
+                    this.attemptReconnect();
+                };
+                this.socket.onerror = (error) => {
+                    console.error("WebSocket error:", error);
+                    reject(error);
+                };
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    handleMessage(data) {
+        var _a;
+        if (data.event === "update_model" && ((_a = data.data) === null || _a === void 0 ? void 0 : _a.room)) {
+            const listeners = this.listeners.get(data.data.room);
+            if (listeners) {
+                const parsedData = typeof data.data.data === "string"
+                    ? JSON.parse(data.data.data)
+                    : data.data.data;
+                listeners.forEach((callback) => callback(parsedData));
+            }
+        }
+    }
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error("Max reconnection attempts reached");
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        setTimeout(() => {
+            console.log(`Attempting to reconnect (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
+            this.connect().catch((error) => {
+                console.error("Reconnection failed:", error);
+            });
+        }, delay);
+    }
+    subscribe(room, callback) {
+        if (!this.listeners.has(room)) {
+            this.listeners.set(room, new Set());
+        }
+        this.listeners.get(room).add(callback);
+        // Send subscription message if connected
+        if (typeof WebSocket !== "undefined" &&
+            this.socket &&
+            this.socket.readyState === WebSocket.OPEN &&
+            this.socket.send) {
+            this.socket.send(JSON.stringify({
+                type: "subscribe",
+                room: room,
+            }));
+        }
+        // Return unsubscribe function
+        return () => {
+            const roomListeners = this.listeners.get(room);
+            if (roomListeners) {
+                roomListeners.delete(callback);
+                if (roomListeners.size === 0) {
+                    this.listeners.delete(room);
+                    // Send unsubscribe message if connected
+                    if (typeof WebSocket !== "undefined" &&
+                        this.socket &&
+                        this.socket.readyState === WebSocket.OPEN &&
+                        this.socket.send) {
+                        this.socket.send(JSON.stringify({
+                            type: "unsubscribe",
+                            room: room,
+                        }));
+                    }
+                }
+            }
+        };
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+        this.listeners.clear();
+    }
+    isConnected() {
+        var _a;
+        if (typeof WebSocket === "undefined") {
+            return false;
+        }
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN;
+    }
+}
+/**
+ * Create agents module for managing AI agent conversations
+ */
+export function createAgentsModule(axiosClient, appId, config = {}) {
+    var _a, _b;
+    let webSocketManager = null;
+    let currentConversation = null;
+    // Initialize WebSocket if enabled
+    if (config.enableWebSocket) {
+        const socketUrl = config.socketUrl || "wss://base44.app/ws";
+        // Extract token from axios client if available
+        const token = (_b = (_a = axiosClient.defaults.headers.common) === null || _a === void 0 ? void 0 : _a.Authorization) === null || _b === void 0 ? void 0 : _b.toString().replace("Bearer ", "");
+        webSocketManager = new AgentWebSocketManager(socketUrl, appId, token);
+    }
+    return {
+        /**
+         * List all conversations for the current user
+         */
+        async listConversations(filterParams) {
+            const response = await axiosClient.get(`/apps/${appId}/agents/conversations`, {
+                params: filterParams,
+            });
+            return response;
+        },
+        /**
+         * Get a specific conversation by ID
+         */
+        async getConversation(conversationId) {
+            const response = await axiosClient.get(`/apps/${appId}/agents/conversations/${conversationId}`);
+            return response;
+        },
+        /**
+         * Create a new agent conversation
+         */
+        async createConversation(payload) {
+            const response = await axiosClient.post(`/apps/${appId}/agents/conversations`, payload);
+            return response;
+        },
+        /**
+         * Update conversation metadata
+         */
+        async updateConversation(conversationId, payload) {
+            const response = await axiosClient.put(`/apps/${appId}/agents/conversations/${conversationId}`, payload);
+            return response;
+        },
+        /**
+         * Send a message to an agent and get response
+         */
+        async sendMessage(conversationId, message) {
+            // Update current conversation for WebSocket tracking
+            if ((currentConversation === null || currentConversation === void 0 ? void 0 : currentConversation.id) === conversationId) {
+                currentConversation.messages = [
+                    ...currentConversation.messages,
+                    { ...message, id: "temp-" + Date.now() },
+                ];
+            }
+            const response = await axiosClient.post(`/apps/${appId}/agents/conversations/${conversationId}/messages`, message);
+            return response;
+        },
+        /**
+         * Delete a message from a conversation
+         */
+        async deleteMessage(conversationId, messageId) {
+            await axiosClient.delete(`/apps/${appId}/agents/conversations/${conversationId}/messages/${messageId}`);
+        },
+        /**
+         * Subscribe to real-time updates for a conversation
+         * Requires WebSocket to be enabled in config
+         */
+        subscribeToConversation(conversationId, onUpdate) {
+            if (!webSocketManager) {
+                throw new Error("WebSocket is not enabled. Set enableWebSocket: true in agents config");
+            }
+            // Connect WebSocket if not already connected
+            if (!webSocketManager.isConnected()) {
+                webSocketManager.connect().catch((error) => {
+                    console.error("Failed to connect WebSocket:", error);
+                });
+            }
+            return webSocketManager.subscribe(`/agent-conversations/${conversationId}`, (data) => {
+                // Update current conversation reference
+                if (data.id === conversationId) {
+                    currentConversation = data;
+                }
+                onUpdate(data);
+            });
+        },
+        /**
+         * Get WebSocket connection status
+         */
+        getWebSocketStatus() {
+            return {
+                enabled: !!webSocketManager,
+                connected: (webSocketManager === null || webSocketManager === void 0 ? void 0 : webSocketManager.isConnected()) || false,
+            };
+        },
+        /**
+         * Manually connect WebSocket
+         */
+        async connectWebSocket() {
+            if (!webSocketManager) {
+                throw new Error("WebSocket is not enabled. Set enableWebSocket: true in agents config");
+            }
+            await webSocketManager.connect();
+        },
+        /**
+         * Disconnect WebSocket
+         */
+        disconnectWebSocket() {
+            if (webSocketManager) {
+                webSocketManager.disconnect();
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.7.0-dev.e78162e",
+  "version": "0.7.0-pr.26.0b8f663",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",