@base44-preview/sdk 0.8.38-pr.228.85deaff → 0.8.38-pr.229.6a453f4

package/dist/client.js

@@ -7,6 +7,7 @@ import { createConnectorsModule, createUserConnectorsModule, } from "./modules/c
 import { getAccessToken } from "./utils/auth-utils.js";
 import { createFunctionsModule } from "./modules/functions.js";
 import { createAgentsModule } from "./modules/agents.js";
+import { createSuperagentModule } from "./modules/superagent.js";
 import { createAiGatewayModule } from "./modules/ai-gateway.js";
 import { createAppLogsModule } from "./modules/app-logs.js";
 import { createUsersModule } from "./modules/users.js";
@@ -160,8 +161,16 @@ export function createClient(config) {
             appId,
             userAuthModule,
         }),
+        // Deliberately not given the host app's token: superagent access is
+        // always anonymous against the sibling superagent app.
+        superagent: createSuperagentModule({
+            serverUrl,
+            headers: optionalHeaders,
+            onError: options === null || options === void 0 ? void 0 : options.onError,
+        }),
         cleanup: () => {
             userModules.analytics.cleanup();
+            userModules.superagent.cleanup();
             if (socket) {
                 socket.disconnect();
             }
@@ -346,7 +355,6 @@ export function createClientFromRequest(request) {
     const serverUrlHeader = request.headers.get("Base44-Api-Url");
     const functionsVersion = request.headers.get("Base44-Functions-Version");
     const stateHeader = request.headers.get("Base44-State");
-    const dataEnvHeader = request.headers.get("X-Data-Env");
     if (!appId) {
         throw new Error("Base44-App-Id header is required, but is was not found on the request");
     }
@@ -374,16 +382,6 @@ export function createClientFromRequest(request) {
     if (stateHeader) {
         additionalHeaders["Base44-State"] = stateHeader;
     }
-    // Propagate the data environment so entity operations from the function stay
-    // in the same environment (e.g. test data) as the triggering request. This
-    // matters for the user-scoped client: unlike the service token, the user JWT
-    // carries no data-env, so without forwarding this header the callbacks fall
-    // back to production data even when the app runs in test-data mode.
-    // Forward only the known closed set (matches the backend contract) rather
-    // than relaying an arbitrary attacker-supplied header value onward.
-    if (dataEnvHeader === "dev" || dataEnvHeader === "prod") {
-        additionalHeaders["X-Data-Env"] = dataEnvHeader;
-    }
     return createClient({
         serverUrl: serverUrlHeader || "https://base44.app",
         appId,

package/dist/client.types.d.ts

@@ -5,6 +5,7 @@ import type { SsoModule } from "./modules/sso.types.js";
 import type { ConnectorsModule, UserConnectorsModule } from "./modules/connectors.types.js";
 import type { FunctionsModule } from "./modules/functions.types.js";
 import type { AgentsModule } from "./modules/agents.types.js";
+import type { SuperagentModule } from "./modules/superagent.types.js";
 import type { AiGatewayModule } from "./modules/ai-gateway.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
 import type { AnalyticsModule } from "./modules/analytics.types.js";
@@ -98,6 +99,8 @@ export interface Base44Client {
     functions: FunctionsModule;
     /** {@link IntegrationsModule | Integrations module} for calling pre-built integration endpoints. */
     integrations: IntegrationsModule;
+    /** {@link SuperagentModule | Superagent module} for anonymous chat with the app's linked public superagent. */
+    superagent: SuperagentModule;
     /** Cleanup function to disconnect WebSocket connections. Call when you're done with the client. */
     cleanup: () => void;
     /**

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export type { AuthModule, LoginResponse, RegisterParams, VerifyOtpParams, Change
 export type { IntegrationsModule, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
 export type { FunctionsModule, FunctionName, FunctionNameRegistry, } from "./modules/functions.types.js";
 export type { AgentsModule, AgentName, AgentNameRegistry, AgentConversation, AgentMessage, AgentMessageReasoning, AgentMessageToolCall, AgentMessageUsage, AgentMessageCustomContext, AgentMessageMetadata, CreateConversationParams, } from "./modules/agents.types.js";
+export type { SuperagentModule, SuperagentHandle, CreateSuperagentConversationParams, } from "./modules/superagent.types.js";
 export type { AiGatewayModule, AiGatewayConnection, } from "./modules/ai-gateway.types.js";
 export type { AppLogsModule } from "./modules/app-logs.types.js";
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";

package/dist/modules/superagent.d.ts

@@ -0,0 +1,2 @@
+import { SuperagentModule, SuperagentModuleConfig } from "./superagent.types.js";
+export declare function createSuperagentModule({ serverUrl, headers, onError, }: SuperagentModuleConfig): SuperagentModule;

package/dist/modules/superagent.js

@@ -0,0 +1,110 @@
+import { createAxiosClient } from "../utils/axios-client.js";
+import { RoomsSocket } from "../utils/socket-utils.js";
+// A public superagent app always exposes its agent under this fixed name.
+const SUPERAGENT_AGENT_NAME = "your_agent";
+export function createSuperagentModule({ serverUrl, headers, onError, }) {
+    const handles = {};
+    const sockets = {};
+    const createHandle = (appId) => {
+        const baseURL = `/apps/${appId}/agents`;
+        // Dedicated anonymous client for the superagent app: no Authorization
+        // token, so the request interceptor attaches X-Base44-Anonymous-Id and
+        // the backend serves the caller as an anonymous visitor of the sibling
+        // superagent app.
+        const axios = createAxiosClient({
+            baseURL: `${serverUrl}/api`,
+            headers: {
+                ...headers,
+                "X-App-Id": String(appId),
+            },
+            onError,
+        });
+        const getSocket = () => {
+            if (!sockets[appId]) {
+                sockets[appId] = RoomsSocket({
+                    config: {
+                        serverUrl,
+                        mountPath: "/ws-user-apps/socket.io/",
+                        transports: ["websocket"],
+                        appId,
+                        anonymous: true,
+                    },
+                });
+            }
+            return sockets[appId];
+        };
+        // Track active conversations
+        const currentConversations = {};
+        const createConversation = (params = {}) => {
+            return axios.post(`${baseURL}/conversations`, {
+                agent_name: SUPERAGENT_AGENT_NAME,
+                ...params,
+            });
+        };
+        const listConversations = (filterParams = {}) => {
+            return axios.get(`${baseURL}/conversations`, {
+                params: filterParams,
+            });
+        };
+        const getConversation = (conversationId) => {
+            return axios.get(`${baseURL}/conversations/${conversationId}`);
+        };
+        const addMessage = async (conversation, 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: 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]);
+                        }
+                    }
+                },
+            });
+        };
+        return {
+            createConversation,
+            listConversations,
+            getConversation,
+            addMessage,
+            subscribeToConversation,
+        };
+    };
+    const forApp = (appId) => {
+        if (!handles[appId]) {
+            handles[appId] = createHandle(appId);
+        }
+        return handles[appId];
+    };
+    const cleanup = () => {
+        Object.values(sockets).forEach((socket) => socket.disconnect());
+    };
+    return {
+        forApp,
+        cleanup,
+    };
+}

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

@@ -0,0 +1,161 @@
+import { ModelFilterParams } from "../types.js";
+import { AgentConversation, AgentMessage } from "./agents.types.js";
+export type { AgentConversation, AgentMessage, AgentMessageReasoning, AgentMessageToolCall, AgentMessageUsage, AgentMessageCustomContext, AgentMessageMetadata, } from "./agents.types.js";
+/**
+ * Parameters for creating a new superagent conversation.
+ *
+ * Unlike {@linkcode CreateConversationParams | agent conversations}, no agent
+ * name is accepted: a public superagent is always exposed under a single
+ * fixed agent name, which the SDK sets internally.
+ */
+export interface CreateSuperagentConversationParams {
+    /** Optional metadata to attach to the conversation. */
+    metadata?: Record<string, any>;
+}
+/**
+ * Configuration for creating the superagent module.
+ * @internal
+ */
+export interface SuperagentModuleConfig {
+    /** Server URL */
+    serverUrl: string;
+    /** Additional headers to include in API requests */
+    headers?: Record<string, string>;
+    /** Optional error handler for API errors */
+    onError?: (error: Error) => void;
+}
+/**
+ * A handle bound to a specific public superagent app.
+ *
+ * A public superagent is a separate Base44 app linked to a host app, serving
+ * the host app's end users as an anonymous-visitor chat agent. All requests
+ * made through a handle target the superagent app's ID and are sent
+ * anonymously: no Authorization token is attached, and the caller is
+ * identified by a stable anonymous visitor ID instead (the
+ * `X-Base44-Anonymous-Id` header on HTTP requests, and the `anonymous_id`
+ * handshake parameter on the realtime socket).
+ */
+export interface SuperagentHandle {
+    /**
+     * Creates a new conversation with the public superagent.
+     *
+     * The agent name is set internally — a public superagent always exposes a
+     * single fixed agent.
+     *
+     * @param params - Optional conversation parameters (metadata).
+     * @returns Promise resolving to the created conversation.
+     *
+     * @example
+     * ```typescript
+     * const agent = base44.superagent.forApp('superagent-app-id');
+     * const conversation = await agent.createConversation({
+     *   metadata: { source: 'help-widget' }
+     * });
+     * ```
+     */
+    createConversation(params?: CreateSuperagentConversationParams): Promise<AgentConversation>;
+    /**
+     * Lists the current anonymous visitor's conversations with the superagent.
+     *
+     * @param filterParams - Optional filter parameters for querying conversations.
+     * @returns Promise resolving to an array of conversations.
+     *
+     * @example
+     * ```typescript
+     * const conversations = await agent.listConversations();
+     * ```
+     */
+    listConversations(filterParams?: ModelFilterParams): Promise<AgentConversation[]>;
+    /**
+     * Gets a specific conversation by ID, including its full message history.
+     *
+     * @param conversationId - The unique identifier of the conversation.
+     * @returns Promise resolving to the conversation, or undefined if not found.
+     */
+    getConversation(conversationId: string): Promise<AgentConversation | undefined>;
+    /**
+     * Adds a message to a conversation.
+     *
+     * Sends a message to the superagent and updates the conversation. The
+     * agent's response is delivered through the realtime subscription (see
+     * {@linkcode subscribeToConversation | subscribeToConversation()}).
+     *
+     * @param conversation - The conversation to add the message to.
+     * @param message - The message to add.
+     * @returns Promise resolving to the created message.
+     *
+     * @example
+     * ```typescript
+     * await agent.addMessage(conversation, {
+     *   role: 'user',
+     *   content: 'How do I reset my password?'
+     * });
+     * ```
+     */
+    addMessage(conversation: AgentConversation, message: Partial<AgentMessage>): Promise<AgentMessage>;
+    /**
+     * Subscribes to realtime updates for a conversation.
+     *
+     * Establishes a dedicated anonymous WebSocket connection to the superagent
+     * app and receives instant updates when messages are added or updated.
+     * Returns an unsubscribe function to clean up the subscription.
+     *
+     * @param conversationId - The conversation ID to subscribe to.
+     * @param onUpdate - Callback invoked with the updated conversation.
+     * @returns Unsubscribe function to stop receiving updates.
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = agent.subscribeToConversation(
+     *   conversation.id,
+     *   (updated) => {
+     *     const latest = updated.messages[updated.messages.length - 1];
+     *     console.log('New message:', latest.content);
+     *   }
+     * );
+     *
+     * // Later, clean up the subscription
+     * unsubscribe();
+     * ```
+     */
+    subscribeToConversation(conversationId: string, onUpdate?: (conversation: AgentConversation) => void): () => void;
+}
+/**
+ * Superagent module for chatting with an app's linked public superagent.
+ *
+ * A host app can have a linked "public superagent" — a separate Base44 app
+ * that serves the host app's end users as a chat agent without requiring
+ * them to sign in. This module provides anonymous access to that superagent
+ * app: it never uses the host app's authentication token. Instead, requests
+ * carry a stable anonymous visitor ID so the backend can group conversations
+ * per visitor.
+ *
+ * @example
+ * ```typescript
+ * const agent = base44.superagent.forApp('superagent-app-id');
+ *
+ * const conversation = await agent.createConversation();
+ * const unsubscribe = agent.subscribeToConversation(
+ *   conversation.id,
+ *   (updated) => console.log(updated.messages)
+ * );
+ * await agent.addMessage(conversation, { role: 'user', content: 'Hi!' });
+ * ```
+ */
+export interface SuperagentModule {
+    /**
+     * Gets a handle bound to a public superagent app.
+     *
+     * Handles are cached per app ID, so repeated calls with the same ID return
+     * the same handle (and reuse its HTTP client and socket connection).
+     *
+     * @param appId - The superagent app's ID (not the host app's ID).
+     * @returns A handle for interacting with the superagent.
+     */
+    forApp(appId: string): SuperagentHandle;
+    /**
+     * Disconnects all superagent socket connections.
+     * @internal
+     */
+    cleanup(): void;
+}

package/dist/modules/superagent.types.js

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

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

@@ -5,6 +5,12 @@ export interface RoomsSocketConfig {
     transports: string[];
     appId: string;
     token?: string;
+    /**
+     * Force an anonymous handshake: never attach a token (including the stored
+     * access token fallback), so the connection is identified only by its
+     * anonymous visitor id.
+     */
+    anonymous?: boolean;
 }
 export type TSocketRoom = string;
 export type TJsonStr = string;

package/dist/utils/socket-utils.js

@@ -8,7 +8,9 @@ function initializeSocket(config, handlers) {
     // handshake so the backend can verify room access for anonymous agent
     // conversations (mirrors the X-Base44-Anonymous-Id HTTP header). Authenticated
     // clients are identified by their token instead.
-    const resolvedToken = (_a = config.token) !== null && _a !== void 0 ? _a : getAccessToken();
+    const resolvedToken = config.anonymous
+        ? undefined
+        : (_a = config.token) !== null && _a !== void 0 ? _a : getAccessToken();
     const query = {
         app_id: config.appId,
         token: resolvedToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.38-pr.228.85deaff",
+  "version": "0.8.38-pr.229.6a453f4",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",