@doany-ai/sdk 0.1.0

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

@@ -0,0 +1,418 @@
+import { CustomIntegrationsModule } from "./custom-integrations.types.js";
+/**
+ * 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.
+ *
+ * An integration package is a collection of endpoint functions indexed by endpoint name.
+ * Both `Core` and `custom` are integration packages that implement this structure.
+ *
+ * @example **Core package**
+ * ```typescript
+ * await base44.integrations.Core.InvokeLLM({
+ *   prompt: 'Explain quantum computing',
+ *   model: 'gpt_5'
+ * });
+ * ```
+ *
+ * @example **custom package**
+ * ```typescript
+ * await base44.integrations.custom.call(
+ *   'github',
+ *   'get:/repos/{owner}/{repo}',
+ *   { pathParams: { owner: 'myorg', repo: 'myrepo' } }
+ * );
+ * ```
+ */
+export type IntegrationPackage = {
+    [endpointName: string]: IntegrationEndpointFunction;
+};
+/**
+ * Parameters for the InvokeLLM function.
+ */
+export interface InvokeLLMParams {
+    /** The prompt text to send to the model */
+    prompt: string;
+    /** Optionally specify a model to override the app-level model setting for this specific call.
+     *
+     * Options: `"gpt_5_mini"`, `"gemini_3_flash"`, `"gpt_5_4"`, `"gpt_5_5"`, `"gemini_3_1_pro"`, `"claude_sonnet_4_6"`, `"claude_opus_4_6"`, `"claude_opus_4_7"`, `"claude_opus_4_8"`
+     */
+    model?: 'gpt_5_mini' | 'gemini_3_flash' | 'gpt_5_4' | 'gpt_5_5' | 'gemini_3_1_pro' | 'claude_sonnet_4_6' | 'claude_opus_4_6' | 'claude_opus_4_7' | 'claude_opus_4_8';
+    /** 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.
+     *
+     * Images are generated as PNG files at approximately 1024px on the shorter side. The
+     * exact dimensions vary by aspect ratio.
+     *
+     * Prompts that violate the AI provider's content policy will be refused.
+     *
+     * @param params - Parameters for image generation
+     * @returns Promise resolving to an object containing the URL of the generated PNG image.
+     *
+     * @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 methods.
+ *
+ * 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.
+ *
+ * ## Integration Types
+ *
+ * There are two types of integrations:
+ *
+ * - **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 workspace integrations** (`custom`): Pre-configured external APIs set up by workspace administrators. Workspace integration calls are proxied through Base44's backend, so credentials are never exposed to the frontend. Access custom workspace integration methods using:
+ *   ```
+ *   base44.integrations.custom.call(slug, operationId, params)
+ *   ```
+ *
+ *   <Info>To call a custom workspace integration, it must be pre-configured by a workspace administrator who imports an OpenAPI specification. Learn more about [custom workspace integrations](/documentation/integrations/managing-workspace-integrations).</Info>
+ *
+ * ## Authentication Modes
+ *
+ * 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 the service role for backend code that needs elevated permissions.
+ */
+export type IntegrationsModule = {
+    /**
+     * Core package containing built-in Base44 integration functions.
+     *
+     * @example
+     * ```typescript
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: 'Explain quantum computing',
+     *   model: 'gpt_5'
+     * });
+     * ```
+     */
+    Core: CoreIntegrations;
+    /**
+     * Workspace integrations module for calling pre-configured external APIs.
+     *
+     * @example
+     * ```typescript
+     * const result = await base44.integrations.custom.call(
+     *   'github',
+     *   'get:/repos/{owner}/{repo}',
+     *   { pathParams: { owner: 'myorg', repo: 'myrepo' } }
+     * );
+     * ```
+     */
+    custom: CustomIntegrationsModule;
+} & {
+    /**
+     * Access to additional integration packages.
+     *
+     * Allows accessing integration packages as properties. This enables both `Core` and `custom` packages,
+     * as well as any future integration packages that may be added.
+     *
+     * @example **Use Core integrations**
+     * ```typescript
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: 'Explain quantum computing',
+     *   model: 'gpt_5'
+     * });
+     * ```
+     *
+     * @example **Use custom integrations**
+     * ```typescript
+     * const result = await base44.integrations.custom.call(
+     *   'github',
+     *   'get:/repos/{owner}/{repo}',
+     *   { pathParams: { owner: 'myorg', repo: 'myrepo' } }
+     * );
+     * ```
+     */
+    [packageName: string]: IntegrationPackage;
+};

package/dist/modules/integrations.types.js

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

package/dist/modules/sso.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from "axios";
+import { SsoModule } from "./sso.types";
+/**
+ * Creates the SSO module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns SSO module with authentication methods
+ * @internal
+ */
+export declare function createSsoModule(axios: AxiosInstance, appId: string): SsoModule;

package/dist/modules/sso.js

@@ -0,0 +1,22 @@
+/**
+ * Creates the SSO module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns SSO module with authentication methods
+ * @internal
+ */
+export function createSsoModule(axios, appId) {
+    return {
+        // Get SSO access token for a specific user
+        async getAccessToken(userid) {
+            const url = `/apps/${appId}/auth/sso/accesstoken/${userid}`;
+            return axios.get(url);
+        },
+        // Get the stored SSO OIDC ID token for a specific user
+        async getIdToken(userid) {
+            const url = `/apps/${appId}/auth/sso/idtoken/${userid}`;
+            return axios.get(url);
+        },
+    };
+}

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

@@ -0,0 +1,68 @@
+/**
+ * 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 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>;
+    /**
+     * Gets the stored SSO OIDC ID token for the current app user.
+     *
+     * The service-role client must include an on-behalf-of token for the same
+     * user specified by `userid`. This method returns the stored token as-is and
+     * does not refresh it.
+     *
+     * @param userid - The current app user's ID.
+     * @returns Promise resolving to the raw ID-token string.
+     *
+     * @example
+     * ```typescript
+     * import { createClientFromRequest } from 'npm:@base44/sdk';
+     *
+     * Deno.serve(async (req) => {
+     *   const base44 = createClientFromRequest(req);
+     *   const user = await base44.auth.me();
+     *   const idToken = await base44.asServiceRole.sso.getIdToken(user.id);
+     *
+     *   return Response.json({ idToken });
+     * });
+     * ```
+     */
+    getIdToken(userid: string): Promise<string>;
+}

package/dist/modules/sso.types.js

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

package/dist/modules/types.d.ts

@@ -0,0 +1,5 @@
+export * from "./app.types.js";
+export * from "./agents.types.js";
+export * from "./ai-gateway.types.js";
+export * from "./connectors.types.js";
+export * from "./analytics.types.js";

package/dist/modules/types.js

@@ -0,0 +1,5 @@
+export * from "./app.types.js";
+export * from "./agents.types.js";
+export * from "./ai-gateway.types.js";
+export * from "./connectors.types.js";
+export * from "./analytics.types.js";

package/dist/modules/users.d.ts

@@ -0,0 +1,16 @@
+import { AxiosInstance } from "axios";
+/**
+ * Creates the users module for the Base44 SDK
+ * @param {AxiosInstance} axios - Axios instance
+ * @param {string} appId - Application ID
+ * @returns {Object} Users module
+ */
+export declare function createUsersModule(axios: AxiosInstance, appId: string): {
+    /**
+     * Invite a user to the application
+     * @param {string} user_email - User's email address
+     * @param {'user'|'admin'} role - User's role (user or admin)
+     * @returns {Promise<any>}
+     */
+    inviteUser(user_email: string, role: "user" | "admin"): Promise<any>;
+};

package/dist/modules/users.js

@@ -0,0 +1,23 @@
+/**
+ * Creates the users module for the Base44 SDK
+ * @param {AxiosInstance} axios - Axios instance
+ * @param {string} appId - Application ID
+ * @returns {Object} Users module
+ */
+export function createUsersModule(axios, appId) {
+    return {
+        /**
+         * Invite a user to the application
+         * @param {string} user_email - User's email address
+         * @param {'user'|'admin'} role - User's role (user or admin)
+         * @returns {Promise<any>}
+         */
+        async inviteUser(user_email, role) {
+            if (role !== "user" && role !== "admin") {
+                throw new Error(`Invalid role: "${role}". Role must be either "user" or "admin".`);
+            }
+            const response = await axios.post(`/apps/${appId}/runtime/users/invite-user`, { user_email, role });
+            return response;
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,72 @@
+export * from "./modules/types.js";
+/**
+ * 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;
+}

package/dist/types.js

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