@base44-preview/sdk 0.8.5-pr.52.f01053f → 0.8.6-pr.48.9e4e306

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

@@ -0,0 +1,352 @@
+/**
+ * Function signature for calling an integration endpoint.
+ *
+ * If any parameter is a `File` object, the request will automatically be
+ * sent as `multipart/form-data`. Otherwise, it will be sent as JSON.
+ *
+ * @param data - An object containing named parameters for the integration endpoint.
+ * @returns Promise resolving to the integration endpoint's response.
+ */
+export type IntegrationEndpointFunction = (data: Record<string, any>) => Promise<any>;
+/**
+ * A package containing integration endpoints.
+ *
+ * Provides dynamic access to integration endpoints within a package.
+ * Each endpoint is accessed as a property that returns a function to invoke it.
+ *
+ * @example
+ * ```typescript
+ * // Access endpoints dynamically
+ * const result = await integrations.Core.SendEmail({
+ *   to: 'user@example.com',
+ *   subject: 'Hello',
+ *   body: 'Message'
+ * });
+ * ```
+ */
+export type IntegrationPackage = {
+    [endpointName: string]: IntegrationEndpointFunction;
+};
+/**
+ * Parameters for the InvokeLLM function.
+ */
+export interface InvokeLLMParams {
+    /** The prompt text to send to the model */
+    prompt: string;
+    /** If set to `true`, the LLM will use Google Search, Maps, and News to gather real-time context before answering.
+     * @default false
+     */
+    add_context_from_internet?: boolean;
+    /** If you want structured data back, provide a [JSON schema object](https://json-schema.org/understanding-json-schema/reference/object) here. If provided, the function returns a JSON object; otherwise, it returns a string. */
+    response_json_schema?: object;
+    /** A list of file URLs (uploaded via UploadFile) to provide as context/attachments to the LLM. Do not use this together with `add_context_from_internet`. */
+    file_urls?: string[];
+}
+/**
+ * Parameters for the GenerateImage function.
+ */
+export interface GenerateImageParams {
+    /** Description of the image to generate. */
+    prompt: string;
+}
+export interface GenerateImageResult {
+    /** URL of the generated image. */
+    url: string;
+}
+/**
+ * Parameters for the UploadFile function.
+ */
+export interface UploadFileParams {
+    /** The file object to upload. */
+    file: File;
+}
+export interface UploadFileResult {
+    /** URL of the uploaded file. */
+    file_url: string;
+}
+/**
+ * Parameters for the SendEmail function.
+ */
+export interface SendEmailParams {
+    /** Recipient email address. */
+    to: string;
+    /** Email subject line. */
+    subject: string;
+    /** Plain text email body content. */
+    body: string;
+    /** The name of the sender. If omitted, the app's name will be used. */
+    from_name?: string;
+}
+export type SendEmailResult = any;
+/**
+ * Parameters for the ExtractDataFromUploadedFile function.
+ */
+export interface ExtractDataFromUploadedFileParams {
+    /** The URL of the uploaded file to extract data from. */
+    file_url: string;
+    /** A [JSON schema object](https://json-schema.org/understanding-json-schema/reference/object) defining what data fields you want to extract. */
+    json_schema: object;
+}
+export type ExtractDataFromUploadedFileResult = object;
+/**
+ * Parameters for the UploadPrivateFile function.
+ */
+export interface UploadPrivateFileParams {
+    /** The file object to upload. */
+    file: File;
+}
+export interface UploadPrivateFileResult {
+    /** URI of the uploaded private file, used to create a signed URL. */
+    file_uri: string;
+}
+/**
+ * Parameters for the CreateFileSignedUrl function.
+ */
+export interface CreateFileSignedUrlParams {
+    /** URI of the uploaded private file. */
+    file_uri: string;
+    /** How long the signed URL should be valid for, in seconds.
+     * @default 300 (5 minutes)
+     */
+    expires_in?: number;
+}
+export interface CreateFileSignedUrlResult {
+    /** Temporary signed URL to access the private file. */
+    signed_url: string;
+}
+/**
+ * Core package containing built-in Base44 integration functions.
+ */
+export interface CoreIntegrations {
+    /**
+     * Generate text or structured JSON data using AI models.
+     *
+     * @param params - Parameters for the LLM invocation
+     * @returns Promise resolving to a string (when no schema provided) or an object (when schema provided).
+     *
+     * @example
+     * ```typescript
+     * // Basic prompt
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: "Write a haiku about coding."
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Prompt with internet context
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: "What is the current stock price of Wix and what was the latest major news about it?",
+     *   add_context_from_internet: true
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Structured JSON response
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: "Analyze the sentiment of this review: 'The service was slow but the food was amazing.'",
+     *   response_json_schema: {
+     *     type: "object",
+     *     properties: {
+     *       sentiment: { type: "string", enum: ["positive", "negative", "mixed"] },
+     *       score: { type: "number", description: "Score from 1-10" },
+     *       key_points: { type: "array", items: { type: "string" } }
+     *     }
+     *   }
+     * });
+     * // Returns object: { sentiment: "mixed", score: 7, key_points: ["slow service", "amazing food"] }
+     * ```
+     */
+    InvokeLLM(params: InvokeLLMParams): Promise<string | object>;
+    /**
+     * Create AI-generated images from text prompts.
+     *
+     * @param params - Parameters for image generation
+     * @returns Promise resolving to the generated image URL.
+     *
+     * @example
+     * ```typescript
+     * // Generate an image from a text prompt
+     * const {url} = await base44.integrations.Core.GenerateImage({
+     *   prompt: "A serene mountain landscape with a lake in the foreground"
+     * });
+     * console.log(url); // https://...generated_image.png
+     * ```
+     */
+    GenerateImage(params: GenerateImageParams): Promise<GenerateImageResult>;
+    /**
+     * Upload files to public storage and get a URL.
+     *
+     * @param params - Parameters for file upload
+     * @returns Promise resolving to an object containing the uploaded file URL.
+     *
+     * @example
+     * ```typescript
+     * // Upload a file in React
+     * const handleFileUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
+     *   const file = event.target.files?.[0];
+     *   if (!file) return;
+     *
+     *   const { file_url } = await base44.integrations.Core.UploadFile({ file });
+     *   console.log(file_url); // https://...uploaded_file.pdf
+     * };
+     * ```
+     */
+    UploadFile(params: UploadFileParams): Promise<UploadFileResult>;
+    /**
+     * Send emails to registered users of your app.
+     *
+     * @param params - Parameters for sending email
+     * @returns Promise resolving when the email is sent.
+     */
+    SendEmail(params: SendEmailParams): Promise<SendEmailResult>;
+    /**
+     * Extract structured data from uploaded files based on the specified schema.
+     *
+     * Start by uploading the file to public storage using the {@linkcode UploadFile | UploadFile()} function. Then, use the `file_url` parameter to extract structured data from the uploaded file.
+     *
+     * @param params - Parameters for data extraction
+     * @returns Promise resolving to the extracted data.
+     *
+     * @example
+     * ```typescript
+     * // Extract data from an already uploaded file
+     * const result = await base44.integrations.Core.ExtractDataFromUploadedFile({
+     *   file_url: "https://example.com/files/invoice.pdf",
+     *   json_schema: {
+     *     type: "object",
+     *     properties: {
+     *       invoice_number: { type: "string" },
+     *       total_amount: { type: "number" },
+     *       date: { type: "string" },
+     *       vendor_name: { type: "string" }
+     *     }
+     *   }
+     * });
+     * console.log(result); // { invoice_number: "INV-12345", total_amount: 1250.00, ... }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Upload a file and extract data in React
+     * const handleFileExtraction = async (event: React.ChangeEvent<HTMLInputElement>) => {
+     *   const file = event.target.files?.[0];
+     *   if (!file) return;
+     *
+     *   // First, upload the file
+     *   const { file_url } = await base44.integrations.Core.UploadFile({ file });
+     *
+     *   // Then extract structured data from it
+     *   const result = await base44.integrations.Core.ExtractDataFromUploadedFile({
+     *     file_url,
+     *     json_schema: {
+     *       type: "object",
+     *       properties: {
+     *         summary: {
+     *           type: "string",
+     *           description: "A brief summary of the file content"
+     *         },
+     *         keywords: {
+     *           type: "array",
+     *           items: { type: "string" }
+     *         },
+     *         document_type: {
+     *           type: "string"
+     *         }
+     *       }
+     *     }
+     *   });
+     *   console.log(result); // { summary: "...", keywords: [...], document_type: "..." }
+     * };
+     * ```
+     */
+    ExtractDataFromUploadedFile(params: ExtractDataFromUploadedFileParams): Promise<ExtractDataFromUploadedFileResult>;
+    /**
+     * Upload files to private storage that requires a signed URL to access.
+     *
+     * Create a signed URL to access uploaded files using the {@linkcode CreateFileSignedUrl | CreateFileSignedUrl()} function.
+     *
+     * @param params - Parameters for private file upload
+     * @returns Promise resolving to an object with a `file_uri` used to create a signed URL to access the uploaded file.
+     *
+     * @example
+     * ```typescript
+     * // Upload a private file
+     * const { file_uri } = await base44.integrations.Core.UploadPrivateFile({ file });
+     * console.log(file_uri); // "private/user123/document.pdf"
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Upload a private file and create a signed URL
+     * const handlePrivateUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
+     *   const file = event.target.files?.[0];
+     *   if (!file) return;
+     *
+     *   // Upload to private storage
+     *   const { file_uri } = await base44.integrations.Core.UploadPrivateFile({ file });
+     *
+     *   // Create a signed URL that expires in 1 hour (3600 seconds)
+     *   const { signed_url } = await base44.integrations.Core.CreateFileSignedUrl({
+     *     file_uri,
+     *     expires_in: 3600
+     *   });
+     *
+     *   console.log(signed_url); // Temporary URL to access the private file
+     * };
+     * ```
+     */
+    UploadPrivateFile(params: UploadPrivateFileParams): Promise<UploadPrivateFileResult>;
+    /**
+     * Generate temporary access links for private files.
+     *
+     * Start by uploading the file to private storage using the {@linkcode UploadPrivateFile | UploadPrivateFile()} function. Then, use the `file_uri` parameter to create a signed URL to access the uploaded file.
+     *
+     * @param params - Parameters for creating signed URL
+     * @returns Promise resolving to an object with a temporary `signed_url`.
+     *
+     * @example
+     * ```typescript
+     * // Create a signed URL for a private file
+     * const { signed_url } = await base44.integrations.Core.CreateFileSignedUrl({
+     *   file_uri: "private/user123/document.pdf",
+     *   expires_in: 7200 // URL expires in 2 hours
+     * });
+     * console.log(signed_url); // https://...?signature=...
+     * ```
+     */
+    CreateFileSignedUrl(params: CreateFileSignedUrlParams): Promise<CreateFileSignedUrlResult>;
+}
+/**
+ * Integrations module for calling integration endpoints.
+ *
+ * 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.
+ *
+ * Unlike the connectors module that gives you raw OAuth tokens, integrations provide
+ * pre-built functions that Base44 executes on your behalf.
+ *
+ * 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 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 = {
+    /**
+     * Core package containing built-in Base44 integration functions.
+     */
+    Core: CoreIntegrations;
+} & {
+    /**
+     * Access to additional integration packages.
+     *
+     * Additional integration packages may be added in the future and will be
+     * accessible using the same pattern as Core.
+     */
+    [packageName: string]: IntegrationPackage;
+};

package/dist/modules/integrations.types.js

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

package/dist/modules/sso.d.ts

@@ -1,17 +1,12 @@
 import { AxiosInstance } from "axios";
+import { SsoModule } from "./sso.types";
 /**
- * Creates the SSO module for the Base44 SDK
- * @param {import('axios').AxiosInstance} axios - Axios instance
- * @param {string} appId - Application ID
- * @param {string} [userToken] - User authentication token
- * @param {string} [serviceToken] - Service role authentication token
- * @returns {Object} SSO module with SSO authentication methods
+ * Creates the SSO module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @param userToken - User authentication token
+ * @returns SSO module with authentication methods
+ * @internal
  */
-export declare function createSsoModule(axios: AxiosInstance, appId: string, userToken?: string): {
-    /**
-     * Get current user sso access token
-     * @param {string} userid - User ID to include as path parameter
-     * @returns {Promise<Object>} Current user sso access_token
-     */
-    getAccessToken(userid: string): Promise<import("axios").AxiosResponse<any, any>>;
-};
+export declare function createSsoModule(axios: AxiosInstance, appId: string, userToken?: string): SsoModule;

package/dist/modules/sso.js

@@ -1,24 +1,21 @@
 /**
- * Creates the SSO module for the Base44 SDK
- * @param {import('axios').AxiosInstance} axios - Axios instance
- * @param {string} appId - Application ID
- * @param {string} [userToken] - User authentication token
- * @param {string} [serviceToken] - Service role authentication token
- * @returns {Object} SSO module with SSO authentication methods
+ * Creates the SSO module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @param userToken - User authentication token
+ * @returns SSO module with authentication methods
+ * @internal
  */
 export function createSsoModule(axios, appId, userToken) {
     return {
-        /**
-         * Get current user sso access token
-         * @param {string} userid - User ID to include as path parameter
-         * @returns {Promise<Object>} Current user sso access_token
-         */
+        // Get SSO access token for a specific user
         async getAccessToken(userid) {
             const url = `/apps/${appId}/auth/sso/accesstoken/${userid}`;
             // Prepare headers with both tokens if available
             const headers = {};
             if (userToken) {
-                headers['on-behalf-of'] = `Bearer ${userToken}`;
+                headers["on-behalf-of"] = `Bearer ${userToken}`;
             }
             return axios.get(url, { headers });
         },

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

@@ -0,0 +1,44 @@
+/**
+ * Response from SSO access token endpoint.
+ * @internal
+ */
+export interface SsoAccessTokenResponse {
+    access_token: string;
+}
+/**
+ * SSO (Single Sign-On) module for managing SSO authentication.
+ *
+ * This module provides methods for retrieving SSO access tokens for users.
+ * These tokens allow you to authenticate Base44 users with external
+ * systems or services.
+ *
+ * This module is only available to use with a client in service role authentication mode, which means it can only be used in backend environments.
+ *
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * // Access SSO module with service role
+ * const response = await base44.asServiceRole.sso.getAccessToken('user_123');
+ * console.log(response.data.access_token);
+ * ```
+ */
+export interface SsoModule {
+    /**
+     * Gets SSO access token for a specific user.
+     *
+     * Retrieves a Single Sign-On access token that can be used to authenticate
+     * a user with external services or systems.
+     *
+     * @param userid - The user ID to get the access token for.
+     * @returns Promise resolving to the SSO access token response.
+     *
+     * @example
+     * ```typescript
+     * // Get SSO access token for a user
+     * const response = await base44.asServiceRole.sso.getAccessToken('user_123');
+     * console.log(response.access_token);
+     * ```
+     */
+    getAccessToken(userid: string): Promise<SsoAccessTokenResponse>;
+}

package/dist/modules/sso.types.js

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

package/dist/types.d.ts

@@ -1,9 +1,72 @@
 export * from "./modules/types.js";
-export type ModelFilterParams = {
+/**
+ * Parameters for filtering, sorting, and paginating agent model data.
+ *
+ * Used in the agents module for querying agent conversations. Provides a structured way to specify query criteria, sorting, pagination, and field selection.
+ *
+ * @property q - Query object with field-value pairs for filtering.
+ * @property sort - Sort parameter. For example, "-created_date" for descending order.
+ * @property sort_by - Alternative sort parameter. Use either `sort` or `sort_by`.
+ * @property limit - Maximum number of results to return.
+ * @property skip - Number of results to skip. Used for pagination.
+ * @property fields - Array of field names to include in the response.
+ *
+ * @example
+ * ```typescript
+ * // Filter conversations by agent name
+ * const conversations = await base44.agents.listConversations({
+ *   q: { agent_name: 'support-bot' }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filter conversations with sorting
+ * const conversations = await base44.agents.listConversations({
+ *   q: { status: 'active' },
+ *   sort: '-created_at'  // Sort by created_at descending
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filter conversations with pagination
+ * const conversations = await base44.agents.listConversations({
+ *   q: { agent_name: 'support-bot' },
+ *   limit: 20,  // Get 20 results
+ *   skip: 40    // Skip first 40 (page 3)
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filter conversations with field selection
+ * const conversations = await base44.agents.listConversations({
+ *   q: { status: 'active' },
+ *   fields: ['id', 'agent_name', 'created_at']
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filter conversations with multiple filters
+ * const conversations = await base44.agents.listConversations({
+ *   q: {
+ *     agent_name: 'support-bot',
+ *     'metadata.priority': 'high',
+ *     status: 'active'
+ *   },
+ *   sort: '-updated_at',
+ *   limit: 50,
+ *   skip: 0
+ * });
+ * ```
+ */
+export interface ModelFilterParams {
     q?: Record<string, any>;
     sort?: string | null;
     sort_by?: string | null;
     limit?: number | null;
     skip?: number | null;
     fields?: string[] | null;
-};
+}