@membranehq/sdk 0.8.5 → 0.9.0

package/dist/index.node.js

@@ -50,6 +50,7 @@ exports.ErrorType = void 0;
     ErrorType["ACTION_INSTANCE_SETUP"] = "action_instance_setup";
     ErrorType["UNIT_RUN"] = "unit_run";
     ErrorType["CUSTOM_CODE"] = "custom_code";
+    ErrorType["INSUFFICIENT_CREDIT"] = "insufficient_credit";
 })(exports.ErrorType || (exports.ErrorType = {}));
 exports.BadRequestErrorKey = void 0;
 (function (BadRequestErrorKey) {
@@ -201,6 +202,12 @@ class CustomCodeError extends MembraneError {
         this.data.type = exports.ErrorType.CUSTOM_CODE;
     }
 }
+class InsufficientCreditsError extends MembraneError {
+    constructor(arg) {
+        super(arg);
+        this.data.type = exports.ErrorType.INSUFFICIENT_CREDIT;
+    }
+}
 
 exports.DataBuilderFormulaType = void 0;
 (function (DataBuilderFormulaType) {
@@ -3766,6 +3773,8 @@ const BaseConnection = BaseWorkspaceElement.extend({
     updatedAt: zod.z.string(),
     lastActiveAt: zod.z.string().optional(),
     nextCredentialsRefreshAt: zod.z.string().optional(),
+    nextRetryTimestamp: zod.z.string().optional(),
+    retryAttempts: zod.z.number().optional(),
     archivedAt: zod.z.string().optional(),
     isDeactivated: zod.z.boolean().optional(),
     meta: zod.z.record(zod.z.string(), zod.z.any()).optional(),
@@ -9392,6 +9401,7 @@ exports.ActionRunLogStatus = void 0;
 })(exports.ActionRunLogStatus || (exports.ActionRunLogStatus = {}));
 const BaseActionRunLogRecord = BaseWorkspaceElement.extend({
     actionId: zod.z.string(),
+    actionInstanceId: zod.z.string(),
     integrationId: zod.z.string(),
     connectionId: zod.z.string(),
     input: zod.z.any().optional(),
@@ -9400,6 +9410,7 @@ const BaseActionRunLogRecord = BaseWorkspaceElement.extend({
     createdAt: zod.z.string(),
     completedAt: zod.z.string().optional(),
     error: ErrorDataSchema.optional(),
+    duration: zod.z.number().optional(),
 });
 
 const ActionApiResponse = BaseAction.extend({
@@ -9569,12 +9580,7 @@ const ExternalEvent = BaseExternalEvent.extend({
 
 const FlowApiResponse = BaseFlow.extend({
     integration: BaseIntegration.optional(),
-    appliedToIntegrations: AppliedToIntegrations(zod.z.object({
-        id: zod.z.string(),
-        integrationId: zod.z.string().optional(),
-        isCustomized: zod.z.boolean().optional(),
-        universalFlowId: zod.z.string().optional(),
-    })).optional(),
+    appliedToIntegrations: AppliedToIntegrations(BaseFlow).optional(),
     dependencies: zod.z.array(zod.z.any()).optional(),
 });
 const FindFlowsQuery = FindIntegrationLevelMembraneInterfaceQuery.omit({ parentId: true }).extend({
@@ -9938,6 +9944,71 @@ function hasCycles(nodes) {
     return hasCycles;
 }
 
+exports.WorkspaceElementChangeType = void 0;
+(function (WorkspaceElementChangeType) {
+    WorkspaceElementChangeType["CREATE"] = "create";
+    WorkspaceElementChangeType["UPDATE"] = "update";
+    WorkspaceElementChangeType["DELETE"] = "delete";
+})(exports.WorkspaceElementChangeType || (exports.WorkspaceElementChangeType = {}));
+function compareWorkspaceExports(primaryExport, targetExport) {
+    const changes = [];
+    const result = {
+        [exports.WorkspaceElementChangeType.CREATE]: new Set(),
+        [exports.WorkspaceElementChangeType.UPDATE]: new Set(),
+        [exports.WorkspaceElementChangeType.DELETE]: new Set(),
+    };
+    const primaryMap = new Map();
+    const otherMap = new Map();
+    const typeMap = new Map();
+    const allElementTypes = new Set([...Object.keys(primaryExport), ...Object.keys(targetExport)]);
+    for (const elementType of allElementTypes) {
+        const type = elementType;
+        const primaryElements = primaryExport[type] || [];
+        for (const element of primaryElements) {
+            primaryMap.set(element.uuid, element);
+            typeMap.set(element.uuid, type);
+        }
+        const otherElements = targetExport[type] || [];
+        for (const element of otherElements) {
+            otherMap.set(element.uuid, element);
+            typeMap.set(element.uuid, type);
+        }
+    }
+    for (const [uuid] of typeMap) {
+        const primaryElement = primaryMap.get(uuid);
+        const otherElement = otherMap.get(uuid);
+        const change = compareElementExports(primaryElement, otherElement);
+        if (change) {
+            changes.push(change);
+        }
+    }
+    changes.forEach((change) => {
+        result[change.type].add(change.uuid);
+    });
+    return result;
+}
+function compareElementExports(primaryElement, targetElement) {
+    if (primaryElement && !targetElement) {
+        return {
+            type: exports.WorkspaceElementChangeType.CREATE,
+            uuid: primaryElement.uuid,
+        };
+    }
+    if (!primaryElement && targetElement) {
+        return {
+            type: exports.WorkspaceElementChangeType.DELETE,
+            uuid: targetElement.uuid,
+        };
+    }
+    if (primaryElement && targetElement && !deepEqual(primaryElement, targetElement)) {
+        return {
+            type: exports.WorkspaceElementChangeType.UPDATE,
+            uuid: primaryElement.uuid,
+        };
+    }
+    return undefined;
+}
+
 const WorkspaceElementSpecs = {
     [exports.WorkspaceElementType.Customer]: {
         type: exports.WorkspaceElementType.Customer,
@@ -10291,6 +10362,7 @@ const ERROR_CLASS_BY_TYPE = {
     [exports.ErrorType.ACTION_INSTANCE_SETUP]: ActionInstanceSetupError,
     [exports.ErrorType.UNIT_RUN]: UnitRunError,
     [exports.ErrorType.CUSTOM_CODE]: CustomCodeError,
+    [exports.ErrorType.INSUFFICIENT_CREDIT]: InsufficientCreditsError,
 };
 function getErrorFromData(data) {
     if (typeof data === 'object' &&
@@ -10646,13 +10718,137 @@ const EDITABLE_LIMITS = [
     'parallelFlowRunsPerConnection',
 ];
 
+const OrgWorkspaceSchema = zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    orgId: zod.z.string(),
+    apiBaseUri: zod.z.string().optional(),
+    key: zod.z.string(),
+    secret: zod.z.string(),
+    createdAt: zod.z.coerce.date(),
+    updatedAt: zod.z.coerce.date(),
+    engineAccessToken: zod.z.string().optional(),
+    onboardingStep: zod.z.nativeEnum(exports.WorkspaceOnboardingStep).optional(),
+    trialEndDate: zod.z.string().optional(),
+    featureFlags: zod.z.array(zod.z.string()).optional(),
+    logoUri: zod.z.string().optional(),
+});
+const OrgWorkspaceUser = zod.z.object({
+    id: zod.z.string(),
+    workspaceId: zod.z.string(),
+    testCustomerId: zod.z.string(),
+    userId: zod.z.string(),
+    role: zod.z.string(),
+});
+
+const WorkspaceLimit = zod.z.object({
+    value: zod.z.number().optional(),
+    defaultValue: zod.z.number().optional(),
+    unit: zod.z.nativeEnum(exports.LimitUnits),
+});
+const WorkspaceLimitsSchema = zod.z.object({
+    parallelEventPulls: WorkspaceLimit.optional(),
+    parallelIncrementalEventPullsPerConnection: WorkspaceLimit.optional(),
+    parallelFullSyncEventPullsPerConnection: WorkspaceLimit.optional(),
+    parallelFlowRuns: WorkspaceLimit.optional(),
+    parallelFlowRunsPerConnection: WorkspaceLimit.optional(),
+    parallelApiRequests: WorkspaceLimit.optional(),
+    parallelSseRequests: WorkspaceLimit.optional(),
+    parallelBackgroundJobs: WorkspaceLimit.optional(),
+    parallelEventLogs: WorkspaceLimit.optional(),
+    parallelEventLogsPerConnection: WorkspaceLimit.optional(),
+    ParallelWriteDatabaseRequests: WorkspaceLimit.optional(),
+    fileUploadsMbPerHour: WorkspaceLimit.optional(),
+    apiRequestsPerSecond: WorkspaceLimit.optional(),
+    apiRequestsPerHour: WorkspaceLimit.optional(),
+    webhookRequestsPerSecond: WorkspaceLimit.optional(),
+    webhookRequestsPerHour: WorkspaceLimit.optional(),
+    workspaceElementCreationsPerSecond: WorkspaceLimit.optional(),
+    workspaceElementCreationsPerHour: WorkspaceLimit.optional(),
+    createDatabaseRequestsPerSecond: WorkspaceLimit.optional(),
+    totalNumberOfCustomers: WorkspaceLimit.optional(),
+    totalNumberOfConnections: WorkspaceLimit.optional(),
+    totalNumberOfWorkspaceElements: WorkspaceLimit.optional(),
+    parallelApiRequestsPerCustomer: WorkspaceLimit.optional(),
+    parallelBackgroundJobsPerCustomer: WorkspaceLimit.optional(),
+    apiRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
+    apiRequestsPerCustomerPerHour: WorkspaceLimit.optional(),
+    webhookRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
+    webhookRequestsPerCustomerPerHour: WorkspaceLimit.optional(),
+    externalEventsPerCustomerPerDay: WorkspaceLimit.optional(),
+    createDatabaseRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
+    updateDatabaseRequestsPerCustomerPerSecond: WorkspaceLimit.optional(),
+    parallelWriteDatabaseRequestsPerCustomer: WorkspaceLimit.optional(),
+});
+const EngineWorkspaceSettingsSchema = zod.z.object({
+    enableApiLogs: zod.z.boolean().optional(),
+    enableWebhookLogs: zod.z.boolean().optional(),
+    enableActionRunLogs: zod.z.boolean().optional(),
+    disableSecretKeyAuth: zod.z.boolean().optional(),
+});
+const AppPublicKey = zod.z.object({
+    name: zod.z.string(),
+    publicKey: zod.z.string(),
+});
+const AppSchema = zod.z.object({
+    id: zod.z.string(),
+    key: zod.z.string(),
+    logoUri: zod.z.string().optional(),
+    userFieldsSchema: zod.z.any().optional(),
+    apiBaseUri: zod.z.string().optional(),
+    webhookUri: zod.z.string().optional(),
+    publicKey: zod.z.string().optional(),
+    publicKeys: zod.z.array(AppPublicKey).optional(),
+    enabledWebhookEvents: zod.z.array(zod.z.string()).optional(),
+    auth: zod.z.any().optional(),
+    credentialsSchema: zod.z.any().optional(),
+    apiClient: zod.z.any().optional(),
+    apiRequestHeaders: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    apiRequestQuery: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    isOnPrem: zod.z.boolean().optional(),
+    connectorBaseUri: zod.z.string().optional(),
+    connectorRevision: zod.z.string().optional(),
+    featureFlags: zod.z.array(zod.z.string()).optional(),
+    limits: WorkspaceLimitsSchema.optional(),
+    settings: EngineWorkspaceSettingsSchema.optional(),
+    type: zod.z.nativeEnum(exports.WorkspaceType).optional(),
+    jwksUri: zod.z.string().nullable().optional(),
+    isTrial: zod.z.boolean().optional(),
+    isThrottled: zod.z.boolean().optional(),
+    isDisabled: zod.z.boolean().optional(),
+    isBackgroundJobsDisabled: zod.z.boolean().optional(),
+});
+
+const PlatformUserSchema = zod.z.object({
+    id: zod.z.string(),
+    email: zod.z.string(),
+    name: zod.z.string(),
+    trialRequested: zod.z.boolean(),
+    introVideoStatus: zod.z.string().optional(),
+    isEligible: zod.z.boolean().optional(),
+    emailVerified: zod.z.boolean().optional(),
+});
+const FullPlatformUser = zod.z.object({
+    id: zod.z.string(),
+    auth0Id: zod.z.string().optional(),
+    email: zod.z.string(),
+    name: zod.z.string(),
+    defaultAccountId: zod.z.string().optional(),
+    defaultWorkspaceId: zod.z.string().optional(),
+    isAdmin: zod.z.boolean().optional(),
+    trialRequested: zod.z.boolean(),
+    pat: zod.z.string().optional(),
+    introVideoStatus: zod.z.string().optional(),
+    isEligible: zod.z.boolean().optional(),
+    emailVerified: zod.z.boolean().optional(),
+});
+
 exports.OrgLimitsType = void 0;
 (function (OrgLimitsType) {
     OrgLimitsType["NUMBER_OF_WORKSPACES"] = "numberOfWorkspaces";
     OrgLimitsType["TODAY_USAGE"] = "todayUsage";
     OrgLimitsType["LAST_THIRTY_DAY_USAGE"] = "lastThirtyDayUsage";
     OrgLimitsType["MEMBRANE_EXPERT_CREDITS_CAP"] = "membraneExpertCreditsCapPerMonth";
-    OrgLimitsType["MEMBRANE_AGENT_LAST_THIRTY_DAYS_USAGE"] = "membraneAgentLastThirtyDaysUsage";
 })(exports.OrgLimitsType || (exports.OrgLimitsType = {}));
 exports.OrgUserRole = void 0;
 (function (OrgUserRole) {
@@ -10664,6 +10860,55 @@ exports.OrgUserStatus = void 0;
     OrgUserStatus["Invited"] = "invited";
     OrgUserStatus["Active"] = "active";
 })(exports.OrgUserStatus || (exports.OrgUserStatus = {}));
+const OrgLimits = zod.z
+    .object({
+    numberOfWorkspaces: zod.z.number().optional(),
+    todayUsage: zod.z.number().optional(),
+    lastThirtyDayUsage: zod.z.number().optional(),
+    membraneAgentLastThirtyDaysUsage: zod.z.number().optional(),
+    membraneExpertCreditsCapPerMonth: zod.z.number().nullable().optional(),
+})
+    .optional();
+const MembraneAgentKey = zod.z
+    .object({
+    key: zod.z.string().optional(),
+    expiresAt: zod.z.string().optional(),
+})
+    .optional();
+const OrgSchema = zod.z.object({
+    id: zod.z.string(),
+    key: zod.z.string(),
+    name: zod.z.string(),
+    createdAt: zod.z.coerce.date(),
+    updatedAt: zod.z.coerce.date(),
+    trialEndDate: zod.z.string().optional(),
+    lastTrialExtensionDate: zod.z.string().optional(),
+    limits: OrgLimits,
+    thirtyDayTotalCredits: zod.z.number().optional(),
+    lastThirtyDayUsagePercent: zod.z.number().optional(),
+    todayUsagePercent: zod.z.number().optional(),
+    domains: zod.z.array(zod.z.string()).optional(),
+    featureFlags: zod.z.array(zod.z.string()).optional(),
+    freeAiMonthlyCredits: zod.z.number().optional(),
+    paidAiCredits: zod.z.number().optional(),
+    stripeCustomerId: zod.z.string().optional(),
+});
+const AccountResponse = zod.z.object({
+    user: FullPlatformUser.optional(),
+    workspace: OrgWorkspaceSchema.optional(),
+    workspaces: zod.z.array(OrgWorkspaceSchema).optional(),
+    workspaceUser: OrgWorkspaceUser.extend({
+        testCustomerId: zod.z.string(),
+    }).optional(),
+    engineTestUser: BaseCustomer.optional(),
+    testCustomer: BaseCustomer.optional(),
+    engineApp: AppSchema.optional(),
+    superAdminToken: zod.z.string().optional().nullable(),
+    orgs: zod.z.array(OrgSchema).optional(),
+    permissions: zod.z.array(zod.z.string()).optional(),
+    message: zod.z.string().optional(),
+    error: zod.z.string().optional(),
+});
 
 exports.WebhookTypeEnum = void 0;
 (function (WebhookTypeEnum) {
@@ -12428,15 +12673,39 @@ const AgentSession = zod.z.object({
     storedMessagesUri: zod.z.string().url().optional(),
     sessionFilesZipUri: zod.z.string().url().optional(),
     logs: zod.z.array(zod.z.any()).optional(),
+    usage: zod.z.number().optional(),
 });
 const CreateAgentSession = zod.z.object({
     workspaceElementType: zod.z.enum(exports.WorkspaceElementType),
     workspaceElementId: zod.z.string().min(1),
     prompt: zod.z.string().min(1),
+    testCustomerId: zod.z.string().optional(),
 });
 const AgentSessionInputSchema = zod.z.object({
-    input: zod.z.string().optional(),
-});
+    input: zod.z.string().min(1),
+    synthetic: zod.z.boolean().optional(),
+});
+
+exports.InteractiveMcpToolName = void 0;
+(function (InteractiveMcpToolName) {
+    InteractiveMcpToolName["REQUEST_TEST_CONNECTION"] = "requestTestConnection";
+})(exports.InteractiveMcpToolName || (exports.InteractiveMcpToolName = {}));
+exports.InteractiveMcpToolStatus = void 0;
+(function (InteractiveMcpToolStatus) {
+    InteractiveMcpToolStatus["AWAITING_USER_INPUT"] = "awaiting_user_input";
+})(exports.InteractiveMcpToolStatus || (exports.InteractiveMcpToolStatus = {}));
+
+const API_VERSIONS = {
+    LEGACY: 'legacy',
+    '2025-10-21': '2025-10-21',
+};
+const AVAILABLE_VERSIONS = Object.values(API_VERSIONS);
+const CHRONOLOGICAL_VERSIONS = [
+    API_VERSIONS.LEGACY,
+    ...[...AVAILABLE_VERSIONS].filter((v) => v !== API_VERSIONS.LEGACY).sort(),
+];
+const LATEST_API_VERSION = CHRONOLOGICAL_VERSIONS[CHRONOLOGICAL_VERSIONS.length - 1];
+const VERSION_HEADER = 'membrane-api-version';
 
 function decodeJWT(token) {
     if (typeof token !== 'string') {
@@ -12560,6 +12829,7 @@ class MembraneApiClient {
         params.headers = {
             ...(params.headers || {}),
             Authorization: `Bearer ${token}`,
+            [VERSION_HEADER]: LATEST_API_VERSION,
         };
         params.withCredentials = false;
         let response;
@@ -12902,6 +13172,7 @@ function hasMembraneCredentials(cwd) {
 
 exports.ACTIONS = ACTIONS;
 exports.AccessDeniedError = AccessDeniedError;
+exports.AccountResponse = AccountResponse;
 exports.ActionAccessor = ActionAccessor;
 exports.ActionApiResponse = ActionApiResponse;
 exports.ActionDependency = ActionDependency;
@@ -12931,6 +13202,8 @@ exports.AppEventSubscriptionsAccessor = AppEventSubscriptionsAccessor;
 exports.AppEventTypeAccessor = AppEventTypeAccessor;
 exports.AppEventTypeApiResponse = AppEventTypeApiResponse;
 exports.AppEventTypesAccessor = AppEventTypesAccessor;
+exports.AppPublicKey = AppPublicKey;
+exports.AppSchema = AppSchema;
 exports.AppliedToIntegrations = AppliedToIntegrations;
 exports.BadRequestError = BadRequestError;
 exports.BaseAction = BaseAction;
@@ -13093,6 +13366,7 @@ exports.ElementInstanceAccessor = ElementInstanceAccessor;
 exports.ElementInstanceListAccessor = ElementInstanceListAccessor;
 exports.ElementListAccessor = ElementListAccessor;
 exports.ElementsExportFields = ElementsExportFields;
+exports.EngineWorkspaceSettingsSchema = EngineWorkspaceSettingsSchema;
 exports.ErrorData = ErrorData;
 exports.ErrorDataSchema = ErrorDataSchema;
 exports.ExternalEvent = ExternalEvent;
@@ -13159,10 +13433,12 @@ exports.FlowRunNode = FlowRunNode;
 exports.FlowRunsAccessor = FlowRunsAccessor;
 exports.FlowsAccessor = FlowsAccessor;
 exports.Formula = Formula;
+exports.FullPlatformUser = FullPlatformUser;
 exports.HTTP_REQUEST_SCHEMA = HTTP_REQUEST_SCHEMA;
 exports.HandyScenarioTemplateElement = HandyScenarioTemplateElement;
 exports.HttpRequestSpec = HttpRequestSpec;
 exports.IncludeArchivedQuery = IncludeArchivedQuery;
+exports.InsufficientCreditsError = InsufficientCreditsError;
 exports.IntegrationAccessor = IntegrationAccessor;
 exports.IntegrationApiResponse = IntegrationApiResponse;
 exports.IntegrationAppClient = MembraneClient;
@@ -13189,6 +13465,7 @@ exports.ListFlowInstancesForConnectionQuery = ListFlowInstancesForConnectionQuer
 exports.MEMBRANE_ELEMENT_CONFIG_FILE_NAME = MEMBRANE_ELEMENT_CONFIG_FILE_NAME;
 exports.MIN_FULL_SYNC_INTERVAL_SECONDS = MIN_FULL_SYNC_INTERVAL_SECONDS;
 exports.MIN_PULL_UPDATES_INTERVAL_SECONDS = MIN_PULL_UPDATES_INTERVAL_SECONDS;
+exports.MembraneAgentKey = MembraneAgentKey;
 exports.MembraneAxiosInstance = axios;
 exports.MembraneClient = MembraneClient;
 exports.MembraneConfigLoader = MembraneConfigLoader;
@@ -13198,6 +13475,10 @@ exports.NotAuthenticatedError = NotAuthenticatedError;
 exports.NotFoundError = NotFoundError;
 exports.OAUTH1_CONFIG_SCHEMA = OAUTH1_CONFIG_SCHEMA;
 exports.OAUTH_CONFIG_SCHEMA = OAUTH_CONFIG_SCHEMA;
+exports.OrgLimits = OrgLimits;
+exports.OrgSchema = OrgSchema;
+exports.OrgWorkspaceSchema = OrgWorkspaceSchema;
+exports.OrgWorkspaceUser = OrgWorkspaceUser;
 exports.PARALLEL_EXECUTION_LIMITS = PARALLEL_EXECUTION_LIMITS;
 exports.PackageAccessor = PackageAccessor;
 exports.PackageApiResponse = PackageApiResponse;
@@ -13210,6 +13491,7 @@ exports.PackageExportProperties = PackageExportProperties;
 exports.PackagesAccessor = PackagesAccessor;
 exports.PaginationQuery = PaginationQuery;
 exports.PaginationResponse = PaginationResponse;
+exports.PlatformUserSchema = PlatformUserSchema;
 exports.RATE_LIMITS = RATE_LIMITS;
 exports.RateLimitExceededError = RateLimitExceededError;
 exports.ResetFlowInstanceOptions = ResetFlowInstanceOptions;
@@ -13242,6 +13524,7 @@ exports.UserAccessor = UserAccessor;
 exports.UsersAccessor = UsersAccessor;
 exports.WORKSPACE_SIZE_LIMITS = WORKSPACE_SIZE_LIMITS;
 exports.WorkspaceElementSpecs = WorkspaceElementSpecs;
+exports.WorkspaceLimitsSchema = WorkspaceLimitsSchema;
 exports.__resolveValue = __resolveValue;
 exports.addRequiredFieldsToSchema = addRequiredFieldsToSchema;
 exports.addUdmFallbackFields = addUdmFallbackFields;
@@ -13249,6 +13532,7 @@ exports.backwardCompatibleFilterMatch = backwardCompatibleFilterMatch;
 exports.buildData = buildData;
 exports.buildDataSchema = buildDataSchema;
 exports.buildValue = buildValue;
+exports.compareWorkspaceExports = compareWorkspaceExports;
 exports.compressDataSchema = compressDataSchema;
 exports.createCompoundSchema = createCompoundSchema;
 exports.createFlowInstanceSchema = createFlowInstanceSchema;