@base44-preview/sdk 0.8.17-pr.70.d526c10 → 0.8.17-pr.71.cfa9c83

package/dist/client.types.d.ts

@@ -83,10 +83,7 @@ export interface Base44Client {
     agents: AgentsModule;
     /** {@link AppLogsModule | App logs module} for tracking app usage. */
     appLogs: AppLogsModule;
-    /**
-     * {@link AnalyticsModule | Analytics module} for tracking app usage.
-     * @internal
-     */
+    /** {@link AnalyticsModule | Analytics module} for tracking app usage. */
     analytics: AnalyticsModule;
     /** Cleanup function to disconnect WebSocket connections. Call when you're done with the client. */
     cleanup: () => void;

package/dist/modules/agents.js

@@ -1,6 +1,8 @@
 import { getAccessToken } from "../utils/auth-utils.js";
 export function createAgentsModule({ axios, getSocket, appId, serverUrl, token, }) {
     const baseURL = `/apps/${appId}/agents`;
+    // Track active conversations
+    const currentConversations = {};
     const getConversations = () => {
         return axios.get(`${baseURL}/conversations`);
     };
@@ -16,22 +18,39 @@ export function createAgentsModule({ axios, getSocket, appId, serverUrl, token,
         return axios.post(`${baseURL}/conversations`, conversation);
     };
     const addMessage = async (conversation, message) => {
-        const room = `/agent-conversations/${conversation.id}`;
-        const socket = getSocket();
-        await socket.updateModel(room, {
-            ...conversation,
-            messages: [...(conversation.messages || []), message],
-        });
-        return axios.post(`${baseURL}/conversations/${conversation.id}/messages`, message);
+        return axios.post(`${baseURL}/conversations/v2/${conversation.id}/messages`, message);
     };
     const subscribeToConversation = (conversationId, onUpdate) => {
         const room = `/agent-conversations/${conversationId}`;
         const socket = getSocket();
+        // Store the promise for initial conversation state
+        const conversationPromise = getConversation(conversationId).then((conv) => {
+            currentConversations[conversationId] = conv;
+            return conv;
+        });
         return socket.subscribeToRoom(room, {
             connect: () => { },
-            update_model: ({ data: jsonStr }) => {
-                const conv = JSON.parse(jsonStr);
-                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(conv);
+            update_model: async ({ data: jsonStr }) => {
+                const data = JSON.parse(jsonStr);
+                if (data._message) {
+                    // Wait for initial conversation to be loaded
+                    await conversationPromise;
+                    const message = data._message;
+                    // Update shared conversation state
+                    const currentConversation = currentConversations[conversationId];
+                    if (currentConversation) {
+                        const messages = currentConversation.messages || [];
+                        const existingIndex = messages.findIndex((m) => m.id === message.id);
+                        const updatedMessages = existingIndex !== -1
+                            ? messages.map((m, i) => (i === existingIndex ? message : m))
+                            : [...messages, message];
+                        currentConversations[conversationId] = {
+                            ...currentConversation,
+                            messages: updatedMessages,
+                        };
+                        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(currentConversations[conversationId]);
+                    }
+                }
             },
         });
     };

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

@@ -72,7 +72,7 @@ export interface AgentMessageMetadata {
 export interface AgentConversation {
     /** Unique identifier for the conversation. */
     id: string;
-    /** App ID. */
+    /** Application ID. */
     app_id: string;
     /** Name of the agent in this conversation. */
     agent_name: string;
@@ -140,7 +140,7 @@ export interface AgentsModuleConfig {
     axios: AxiosInstance;
     /** Function to get WebSocket instance for real-time updates (lazy initialization) */
     getSocket: () => ReturnType<typeof RoomsSocket>;
-    /** App ID */
+    /** Application ID */
     appId: string;
     /** Server URL */
     serverUrl?: string;

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

@@ -11,7 +11,9 @@ export interface ConnectorAccessTokenResponse {
 /**
  * Connectors module for managing OAuth tokens for external services.
  *
- * This module allows you to retrieve OAuth access tokens for external services that the app has connected to. Connectors are app-scoped. When an app builder connects an integration like Google Calendar or Slack, all users of the app share that same connection.
+ * This module allows you to retrieve OAuth access tokens for external services
+ * that the app has connected to. Use these tokens to make API
+ * calls to external services.
  *
  * Unlike the integrations module that provides pre-built functions, connectors give you
  * raw OAuth tokens so you can call external service APIs directly with full control over
@@ -24,9 +26,9 @@ export interface ConnectorsModule {
     /**
      * Retrieves an OAuth access token for a specific external integration type.
      *
-     * Returns the OAuth token string for an external service that an app builder
-     * has connected to. This token represents the connected app builder's account
-     * and can be used to make authenticated API calls to that external service on behalf of the app.
+     * Returns the OAuth token string for an external service that the app
+     * has connected to. You can then use this token to make authenticated API calls
+     * to that external service.
      *
      * @param integrationType - The type of integration, such as `'googlecalendar'`, `'slack'`, or `'github'`.
      * @returns Promise resolving to the access token string.

package/dist/modules/custom-integrations.types.d.ts

@@ -7,13 +7,18 @@ export interface CustomIntegrationCallParams {
      */
     payload?: Record<string, any>;
     /**
-     * Path parameters to substitute in the URL. For example, `{ owner: "user", repo: "repo" }`.
+     * Path parameters to substitute in the URL (e.g., `{ owner: "user", repo: "repo" }`).
      */
     pathParams?: Record<string, string>;
     /**
      * Query string parameters to append to the URL.
      */
     queryParams?: Record<string, any>;
+    /**
+     * Additional headers to send with this specific request.
+     * These are merged with the integration's configured headers.
+     */
+    headers?: Record<string, string>;
 }
 /**
  * Response from a custom integration call.
@@ -34,17 +39,60 @@ export interface CustomIntegrationCallResponse {
     data: any;
 }
 /**
- * Module for calling custom pre-configured API integrations.
+ * Module for calling custom workspace-level API integrations.
+ *
+ * Custom integrations allow workspace administrators to connect any external API
+ * by importing an OpenAPI specification. Apps in the workspace can then call
+ * these integrations using this module.
+ *
+ * Unlike the built-in integrations (like `Core`), custom integrations:
+ * - Are defined per-workspace by importing OpenAPI specs
+ * - Use a slug-based identifier instead of package names
+ * - Proxy requests through Base44's backend (credentials never exposed to frontend)
+ *
+ * @example
+ * ```typescript
+ * // Call a custom GitHub integration
+ * const response = await base44.integrations.custom.call(
+ *   "github",        // integration slug (defined by workspace admin)
+ *   "listIssues",    // operation ID from the OpenAPI spec
+ *   {
+ *     pathParams: { owner: "myorg", repo: "myrepo" },
+ *     queryParams: { state: "open", per_page: 100 }
+ *   }
+ * );
  *
- * Custom integrations allow workspace administrators to connect any external API by importing an OpenAPI specification. Apps in the workspace can then call these integrations using this module.
+ * if (response.success) {
+ *   console.log("Issues:", response.data);
+ * } else {
+ *   console.error("API returned error:", response.status_code);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Call with request body payload
+ * const response = await base44.integrations.custom.call(
+ *   "github",
+ *   "createIssue",
+ *   {
+ *     pathParams: { owner: "myorg", repo: "myrepo" },
+ *     payload: {
+ *       title: "Bug report",
+ *       body: "Something is broken",
+ *       labels: ["bug"]
+ *     }
+ *   }
+ * );
+ * ```
  */
 export interface CustomIntegrationsModule {
     /**
      * Call a custom integration endpoint.
      *
-     * @param slug - The integration's unique identifier, as defined by the workspace admin.
-     * @param operationId - The endpoint in `method:path` format. For example, `"get:/contacts"`, or `"post:/users/{id}"`. The method is the HTTP verb in lowercase and the path matches the OpenAPI specification.
-     * @param params - Optional parameters including payload, pathParams, and queryParams.
+     * @param slug - The integration's unique identifier (slug), as defined by the workspace admin.
+     * @param operationId - The operation ID from the OpenAPI spec (e.g., "listIssues", "getUser").
+     * @param params - Optional parameters including payload, pathParams, queryParams, and headers.
      * @returns Promise resolving to the integration call response.
      *
      * @throws {Error} If slug is not provided.
@@ -52,36 +100,6 @@ export interface CustomIntegrationsModule {
      * @throws {Base44Error} If the integration or operation is not found (404).
      * @throws {Base44Error} If the external API call fails (502).
      * @throws {Base44Error} If the request times out (504).
-     *
-     * @example
-     * ```typescript
-     * // Call a custom CRM integration
-     * const response = await base44.integrations.custom.call(
-     *   "my-crm",
-     *   "get:/contacts",
-     *   { queryParams: { limit: 10 } }
-     * );
-     *
-     * if (response.success) {
-     *   console.log("Contacts:", response.data);
-     * }
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Call with path params and request body
-     * const response = await base44.integrations.custom.call(
-     *   "github",
-     *   "post:/repos/{owner}/{repo}/issues",
-     *   {
-     *     pathParams: { owner: "myorg", repo: "myrepo" },
-     *     payload: {
-     *       title: "Bug report",
-     *       body: "Something is broken"
-     *     }
-     *   }
-     * );
-     * ```
      */
     call(slug: string, operationId: string, params?: CustomIntegrationCallParams): Promise<CustomIntegrationCallResponse>;
 }

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

@@ -1,11 +1,9 @@
 /**
  * Event types for realtime entity updates.
- * @internal
  */
 export type RealtimeEventType = "create" | "update" | "delete";
 /**
  * Payload received when a realtime event occurs.
- * @internal
  */
 export interface RealtimeEvent {
     /** The type of change that occurred */
@@ -19,12 +17,10 @@ export interface RealtimeEvent {
 }
 /**
  * Callback function invoked when a realtime event occurs.
- * @internal
  */
 export type RealtimeCallback = (event: RealtimeEvent) => void;
 /**
  * Function returned from subscribe, call it to unsubscribe.
- * @internal
  */
 export type Subscription = () => void;
 /**
@@ -289,7 +285,6 @@ export interface EntityHandler {
      * // Later, unsubscribe
      * unsubscribe();
      * ```
-     * @internal
      */
     subscribe(callback: RealtimeCallback): Subscription;
 }

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

@@ -320,28 +320,22 @@ export interface CoreIntegrations {
     CreateFileSignedUrl(params: CreateFileSignedUrlParams): Promise<CreateFileSignedUrlResult>;
 }
 /**
- * Integrations module for calling integration methods.
+ * Integrations module for calling integration endpoints.
  *
- * This module provides access to integration methods for interacting with external services. Unlike the connectors module that gives you raw OAuth tokens, integrations provide pre-built functions that Base44 executes on your behalf.
+ * This module provides access to integration endpoints for interacting with external
+ * services. Integrations are organized into packages. Base44 provides built-in integrations
+ * in the `Core` package.
  *
- * There are two types of integrations:
+ * Unlike the connectors module that gives you raw OAuth tokens, integrations provide
+ * pre-built functions that Base44 executes on your behalf.
  *
- * - **Built-in integrations** (`Core`): Pre-built functions provided by Base44 for common tasks such as AI-powered text generation, image creation, file uploads, and email. Access core integration methods using:
- *   ```
- *   base44.integrations.Core.FunctionName(params)
- *   ```
- *
- * - **Custom integrations** (`custom`): Pre-configured external APIs. Custom integration calls are proxied through Base44's backend, so credentials are never exposed to the frontend. Access custom integration methods using:
- *   ```
- *   base44.integrations.custom.call(slug, operationId, params)
- *   ```
- *
- *   <Info>To call a custom integration, it must be pre-configured by a workspace administrator who imports an OpenAPI specification.</Info>
+ * Integration endpoints are accessed dynamically using the pattern:
+ * `base44.integrations.PackageName.EndpointName(params)`
  *
  * This module is available to use with a client in all authentication modes:
  *
- * - **Anonymous or User authentication** (`base44.integrations`): Integration methods are invoked with the current user's permissions. Anonymous users invoke methods without authentication, while authenticated users invoke methods with their authentication context.
- * - **Service role authentication** (`base44.asServiceRole.integrations`): Integration methods are invoked with elevated admin-level permissions. The methods execute with admin authentication context.
+ * - **Anonymous or User authentication** (`base44.integrations`): Integration endpoints are invoked with the current user's permissions. Anonymous users invoke endpoints without authentication, while authenticated users invoke endpoints with their authentication context.
+ * - **Service role authentication** (`base44.asServiceRole.integrations`): Integration endpoints are invoked with elevated admin-level permissions. The endpoints execute with admin authentication context.
  */
 export type IntegrationsModule = {
     /**
@@ -349,7 +343,22 @@ export type IntegrationsModule = {
      */
     Core: CoreIntegrations;
     /**
-     * Custom integrations module for calling pre-configured external APIs.
+     * Custom integrations module for calling workspace-level API integrations.
+     *
+     * Allows calling external APIs that workspace admins have configured
+     * by importing OpenAPI specifications.
+     *
+     * @example
+     * ```typescript
+     * const response = await base44.integrations.custom.call(
+     *   "github",        // integration slug
+     *   "listIssues",    // operation ID
+     *   {
+     *     pathParams: { owner: "myorg", repo: "myrepo" },
+     *     queryParams: { state: "open" }
+     *   }
+     * );
+     * ```
      */
     custom: CustomIntegrationsModule;
 } & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.17-pr.70.d526c10",
+  "version": "0.8.17-pr.71.cfa9c83",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",