@mastra/editor 0.10.2-alpha.1 → 0.11.0-alpha.3

package/dist/composio.d.cts

@@ -1,59 +1,70 @@
-import { ToolProvider, ToolProviderInfo, ToolProviderListResult, ToolProviderToolkit, ListToolProviderToolsOptions, ToolProviderToolInfo, ResolveToolProviderToolsOptions } from '@mastra/core/tool-provider';
+import { BaseToolProvider, ToolProviderInfo, ToolProviderCapabilities, BaseToolProviderOptions, ToolProviderToolkit, ListToolsOpts, ListToolsResult, ResolveToolsOpts, AuthorizeOpts, ConnectionField, AuthFlowStatus, ListConnectionsOpts, ListConnectionsResult, ToolProviderHealth } from '@mastra/core/tool-provider';
 import { ToolAction } from '@mastra/core/tools';
-import { StorageToolConfig } from '@mastra/core/storage';
 
-interface ComposioToolProviderConfig {
-    /** Composio API key */
+interface ComposioToolProviderConfig extends BaseToolProviderOptions {
+    /** Composio API key. */
     apiKey: string;
 }
 /**
- * Composio tool provider adapter.
+ * Composio implementation of the {@link BaseToolProvider} contract.
  *
- * Uses `@composio/core` + `@composio/mastra` SDKs for both tool discovery
- * and runtime resolution. Both packages are optional peer dependencies and
- * tree-shaken if this provider class isn't imported.
+ * Discovery (`listAllToolkits`, `listAllTools`) uses the raw Composio
+ * client. Runtime (`resolveToolsVNext`) uses {@link MastraProvider} so resolved
+ * tools are already in `createTool()` shape; each tool gets a
+ * `beforeExecute` modifier that injects
+ * `connectedAccountId = connectionId`, and `outputSchema` is cleared
+ * because Composio returns union schemas that Mastra's runtime rejects.
  *
- * Discovery methods (`listToolkits`, `listTools`, `getToolSchema`) use the
- * raw Composio client (no userId required).
- *
- * Runtime method (`resolveTools`) uses the MastraProvider so returned tools are
- * already in Mastra's `createTool()` format.
+ * Allowlist filtering is layered by {@link BaseToolProvider}; this class
+ * never reads `allowedToolkits` / `allowedTools` directly.
  */
-declare class ComposioToolProvider implements ToolProvider {
+declare class ComposioToolProvider extends BaseToolProvider {
     readonly info: ToolProviderInfo;
-    private apiKey;
+    readonly capabilities: ToolProviderCapabilities;
+    private readonly apiKey;
     private rawClient;
     private mastraClient;
     constructor(config: ComposioToolProviderConfig);
-    /**
-     * Get or create a raw Composio client (no provider — for discovery only).
-     */
     private getRawClient;
-    /**
-     * Get or create a Composio client with MastraProvider (for runtime tools).
-     */
     private getMastraClient;
+    protected listAllToolkits(): Promise<ToolProviderToolkit[]>;
+    protected listAllTools(opts: ListToolsOpts): Promise<ListToolsResult>;
+    resolveToolsVNext(opts: ResolveToolsOpts): Promise<Record<string, ToolAction<any, any, any>>>;
+    authorize(opts: AuthorizeOpts): Promise<{
+        url: string;
+        authId: string;
+    }>;
+    listConnectionFields({ toolkit }: {
+        toolkit: string;
+    }): Promise<ConnectionField[]>;
+    getAuthStatus(authId: string): Promise<AuthFlowStatus>;
+    getConnectionStatus(opts: {
+        items: Array<{
+            connectionId: string;
+            toolkit: string;
+        }>;
+    }): Promise<Record<string, {
+        connected: boolean;
+    }>>;
+    listConnections(opts: ListConnectionsOpts): Promise<ListConnectionsResult>;
     /**
-     * List available toolkits via `composio.toolkits.get({})`.
-     * Returns: `ToolKitListResponse` — an array of `{ slug, name, meta: { description, logo, ... } }`.
-     */
-    listToolkits(): Promise<ToolProviderListResult<ToolProviderToolkit>>;
-    /**
-     * List available tools via `composio.tools.getRawComposioTools()`.
-     * No userId required — returns raw tool definitions for UI browsing.
-     */
-    listTools(options?: ListToolProviderToolsOptions): Promise<ToolProviderListResult<ToolProviderToolInfo>>;
-    /**
-     * Get JSON schema for a specific tool via `composio.tools.getRawComposioToolBySlug()`.
+     * Revoke a Composio connected account via
+     * `DELETE /api/v3/connected_accounts/:nanoid`. Composio performs a soft
+     * delete and responds with `{ success: boolean }`.
+     *
+     * Treats a 404 (account already deleted or never existed) as success so
+     * the caller can drop its local pin without an error path. A `success:
+     * false` response means the provider refused the delete and is surfaced
+     * as an error so the caller does not delete its local row.
      */
-    getToolSchema(toolSlug: string): Promise<Record<string, unknown> | null>;
+    revokeConnection(connectionId: string): Promise<void>;
+    getHealth(): Promise<ToolProviderHealth>;
     /**
-     * Resolve executable tools in Mastra format via `composio.tools.get(userId, { tools: [...] })`.
-     *
-     * Uses MastraProvider so returned tools are `ReturnType<typeof createTool>` — compatible
-     * with Mastra's `ToolAction` interface.
+     * Resolve the single ENABLED auth config for `toolkit`. Throws if zero
+     * or multiple configs match — the admin must enable exactly one in the
+     * Composio dashboard before agents can connect.
      */
-    resolveTools(toolSlugs: string[], toolConfigs?: Record<string, StorageToolConfig>, options?: ResolveToolProviderToolsOptions): Promise<Record<string, ToolAction<unknown, unknown>>>;
+    private resolveAuthConfig;
 }
 
 export { ComposioToolProvider, type ComposioToolProviderConfig };

package/dist/composio.d.ts

@@ -1,59 +1,70 @@
-import { ToolProvider, ToolProviderInfo, ToolProviderListResult, ToolProviderToolkit, ListToolProviderToolsOptions, ToolProviderToolInfo, ResolveToolProviderToolsOptions } from '@mastra/core/tool-provider';
+import { BaseToolProvider, ToolProviderInfo, ToolProviderCapabilities, BaseToolProviderOptions, ToolProviderToolkit, ListToolsOpts, ListToolsResult, ResolveToolsOpts, AuthorizeOpts, ConnectionField, AuthFlowStatus, ListConnectionsOpts, ListConnectionsResult, ToolProviderHealth } from '@mastra/core/tool-provider';
 import { ToolAction } from '@mastra/core/tools';
-import { StorageToolConfig } from '@mastra/core/storage';
 
-interface ComposioToolProviderConfig {
-    /** Composio API key */
+interface ComposioToolProviderConfig extends BaseToolProviderOptions {
+    /** Composio API key. */
     apiKey: string;
 }
 /**
- * Composio tool provider adapter.
+ * Composio implementation of the {@link BaseToolProvider} contract.
  *
- * Uses `@composio/core` + `@composio/mastra` SDKs for both tool discovery
- * and runtime resolution. Both packages are optional peer dependencies and
- * tree-shaken if this provider class isn't imported.
+ * Discovery (`listAllToolkits`, `listAllTools`) uses the raw Composio
+ * client. Runtime (`resolveToolsVNext`) uses {@link MastraProvider} so resolved
+ * tools are already in `createTool()` shape; each tool gets a
+ * `beforeExecute` modifier that injects
+ * `connectedAccountId = connectionId`, and `outputSchema` is cleared
+ * because Composio returns union schemas that Mastra's runtime rejects.
  *
- * Discovery methods (`listToolkits`, `listTools`, `getToolSchema`) use the
- * raw Composio client (no userId required).
- *
- * Runtime method (`resolveTools`) uses the MastraProvider so returned tools are
- * already in Mastra's `createTool()` format.
+ * Allowlist filtering is layered by {@link BaseToolProvider}; this class
+ * never reads `allowedToolkits` / `allowedTools` directly.
  */
-declare class ComposioToolProvider implements ToolProvider {
+declare class ComposioToolProvider extends BaseToolProvider {
     readonly info: ToolProviderInfo;
-    private apiKey;
+    readonly capabilities: ToolProviderCapabilities;
+    private readonly apiKey;
     private rawClient;
     private mastraClient;
     constructor(config: ComposioToolProviderConfig);
-    /**
-     * Get or create a raw Composio client (no provider — for discovery only).
-     */
     private getRawClient;
-    /**
-     * Get or create a Composio client with MastraProvider (for runtime tools).
-     */
     private getMastraClient;
+    protected listAllToolkits(): Promise<ToolProviderToolkit[]>;
+    protected listAllTools(opts: ListToolsOpts): Promise<ListToolsResult>;
+    resolveToolsVNext(opts: ResolveToolsOpts): Promise<Record<string, ToolAction<any, any, any>>>;
+    authorize(opts: AuthorizeOpts): Promise<{
+        url: string;
+        authId: string;
+    }>;
+    listConnectionFields({ toolkit }: {
+        toolkit: string;
+    }): Promise<ConnectionField[]>;
+    getAuthStatus(authId: string): Promise<AuthFlowStatus>;
+    getConnectionStatus(opts: {
+        items: Array<{
+            connectionId: string;
+            toolkit: string;
+        }>;
+    }): Promise<Record<string, {
+        connected: boolean;
+    }>>;
+    listConnections(opts: ListConnectionsOpts): Promise<ListConnectionsResult>;
     /**
-     * List available toolkits via `composio.toolkits.get({})`.
-     * Returns: `ToolKitListResponse` — an array of `{ slug, name, meta: { description, logo, ... } }`.
-     */
-    listToolkits(): Promise<ToolProviderListResult<ToolProviderToolkit>>;
-    /**
-     * List available tools via `composio.tools.getRawComposioTools()`.
-     * No userId required — returns raw tool definitions for UI browsing.
-     */
-    listTools(options?: ListToolProviderToolsOptions): Promise<ToolProviderListResult<ToolProviderToolInfo>>;
-    /**
-     * Get JSON schema for a specific tool via `composio.tools.getRawComposioToolBySlug()`.
+     * Revoke a Composio connected account via
+     * `DELETE /api/v3/connected_accounts/:nanoid`. Composio performs a soft
+     * delete and responds with `{ success: boolean }`.
+     *
+     * Treats a 404 (account already deleted or never existed) as success so
+     * the caller can drop its local pin without an error path. A `success:
+     * false` response means the provider refused the delete and is surfaced
+     * as an error so the caller does not delete its local row.
      */
-    getToolSchema(toolSlug: string): Promise<Record<string, unknown> | null>;
+    revokeConnection(connectionId: string): Promise<void>;
+    getHealth(): Promise<ToolProviderHealth>;
     /**
-     * Resolve executable tools in Mastra format via `composio.tools.get(userId, { tools: [...] })`.
-     *
-     * Uses MastraProvider so returned tools are `ReturnType<typeof createTool>` — compatible
-     * with Mastra's `ToolAction` interface.
+     * Resolve the single ENABLED auth config for `toolkit`. Throws if zero
+     * or multiple configs match — the admin must enable exactly one in the
+     * Composio dashboard before agents can connect.
      */
-    resolveTools(toolSlugs: string[], toolConfigs?: Record<string, StorageToolConfig>, options?: ResolveToolProviderToolsOptions): Promise<Record<string, ToolAction<unknown, unknown>>>;
+    private resolveAuthConfig;
 }
 
 export { ComposioToolProvider, type ComposioToolProviderConfig };

package/dist/composio.js

@@ -1,30 +1,38 @@
 // src/providers/composio.ts
+import { BaseToolProvider } from "@mastra/core/tool-provider";
 import { MASTRA_RESOURCE_ID_KEY } from "@mastra/core/request-context";
 import { Composio } from "@composio/core";
 import { MastraProvider } from "@composio/mastra";
-var ComposioToolProvider = class {
+var COMPOSIO_PROVIDER_ID = "composio";
+var DEFAULT_INTERNAL_USER_ID = "default";
+var ComposioToolProvider = class extends BaseToolProvider {
   constructor(config) {
+    super({
+      allowedToolkits: config.allowedToolkits,
+      allowedTools: config.allowedTools
+    });
     this.info = {
-      id: "composio",
+      id: COMPOSIO_PROVIDER_ID,
       name: "Composio",
       description: "Access 10,000+ tools from 150+ apps via Composio"
     };
+    this.capabilities = {
+      multipleConnectionsPerToolkit: true,
+      batchConnectionStatus: true,
+      reauthorizeReusesConnectionId: true,
+      supportsRevoke: true
+    };
     this.rawClient = null;
     this.mastraClient = null;
     this.apiKey = config.apiKey;
   }
-  /**
-   * Get or create a raw Composio client (no provider — for discovery only).
-   */
+  // ── client cache ──────────────────────────────────────────────────────
   getRawClient() {
     if (!this.rawClient) {
       this.rawClient = new Composio({ apiKey: this.apiKey });
     }
     return this.rawClient;
   }
-  /**
-   * Get or create a Composio client with MastraProvider (for runtime tools).
-   */
   getMastraClient() {
     if (!this.mastraClient) {
       this.mastraClient = new Composio({
@@ -34,85 +42,303 @@ var ComposioToolProvider = class {
     }
     return this.mastraClient;
   }
-  /**
-   * List available toolkits via `composio.toolkits.get({})`.
-   * Returns: `ToolKitListResponse` — an array of `{ slug, name, meta: { description, logo, ... } }`.
-   */
-  async listToolkits() {
+  // ── catalog (BaseToolProvider adds allowlist filter on top) ───────────
+  async listAllToolkits() {
     const composio = this.getRawClient();
     const toolkits = await composio.toolkits.get({});
-    const data = toolkits.map((tk) => ({
+    return toolkits.map((tk) => ({
       slug: tk.slug,
       name: tk.name,
       description: tk.meta?.description,
       icon: tk.meta?.logo
     }));
-    return { data };
   }
-  /**
-   * List available tools via `composio.tools.getRawComposioTools()`.
-   * No userId required — returns raw tool definitions for UI browsing.
-   */
-  async listTools(options) {
+  async listAllTools(opts) {
     const composio = this.getRawClient();
-    const limit = options?.perPage;
-    const query = options?.toolkit ? { toolkits: [options.toolkit], limit, search: options?.search } : options?.search ? { search: options.search, limit } : { toolkits: [], limit };
-    const rawTools = await composio.tools.getRawComposioTools(query);
+    const limit = opts.perPage;
+    const fallbackToolkits = this.allowedToolkits.length > 0 ? [...this.allowedToolkits] : void 0;
+    const query = opts.toolkit ? { toolkits: [opts.toolkit], limit, search: opts.search } : fallbackToolkits ? { toolkits: fallbackToolkits, limit, search: opts.search } : opts.search ? { search: opts.search, limit } : { toolkits: [], limit };
+    let rawTools = [];
+    try {
+      rawTools = await composio.tools.getRawComposioTools(query);
+    } catch (err) {
+      console.warn(
+        `[ComposioToolProvider] listAllTools failed for query ${JSON.stringify(query)} \u2014 returning empty page`,
+        err
+      );
+    }
     const data = rawTools.map((tool) => ({
       slug: tool.slug,
       name: tool.name ?? tool.slug,
       description: tool.description,
-      toolkit: tool.toolkit?.slug
+      toolkit: tool.toolkit?.slug ?? opts.toolkit ?? ""
     }));
     return {
       data,
       pagination: {
-        page: options?.page ?? 1,
+        page: opts.page ?? 1,
         perPage: limit,
         hasMore: limit !== void 0 && rawTools.length >= limit
       }
     };
   }
+  // ── runtime ───────────────────────────────────────────────────────────
+  async resolveToolsVNext(opts) {
+    if (opts.toolSlugs.length === 0) return {};
+    const internalUserId = opts.authorId && opts.authorId.length > 0 ? opts.authorId : resolveInternalUserId(opts.requestContext);
+    const composio = this.getMastraClient();
+    const modifiers = {
+      // `connectedAccountId` is not threaded through Composio's `execute`
+      // option bag in @composio/mastra; the only documented per-call hook
+      // is `beforeExecute`, which receives the params object that flows
+      // into the API call. Mutating `params.connectedAccountId` routes
+      // the call to a specific account.
+      beforeExecute: ({ params }) => {
+        params.connectedAccountId = opts.connectionId;
+        return params;
+      }
+    };
+    const mastraTools = await composio.tools.get(
+      internalUserId,
+      { tools: opts.toolSlugs },
+      modifiers
+    );
+    const result = {};
+    for (const [key, tool] of Object.entries(mastraTools ?? {})) {
+      if (!tool) continue;
+      const slug = tool.id ?? key;
+      try {
+        tool.outputSchema = void 0;
+      } catch {
+      }
+      const descOverride = opts.toolMeta?.[slug]?.description;
+      if (descOverride) {
+        try {
+          tool.description = descOverride;
+        } catch {
+        }
+      }
+      result[slug] = tool;
+    }
+    return result;
+  }
+  // ── auth surface ──────────────────────────────────────────────────────
+  async authorize(opts) {
+    const composio = this.getRawClient();
+    const { id: authConfigId, authScheme } = await this.resolveAuthConfig(opts.toolkit);
+    const internalUserId = opts.connectionId || DEFAULT_INTERNAL_USER_ID;
+    const initiateConfig = opts.config && Object.keys(opts.config).length > 0 && authScheme ? { authScheme, val: opts.config } : void 0;
+    const request = await composio.connectedAccounts.initiate(internalUserId, authConfigId, {
+      allowMultiple: true,
+      ...initiateConfig ? { config: initiateConfig } : {}
+    });
+    if (!request.redirectUrl) {
+      throw new Error(`[composio] initiate did not return a redirectUrl for toolkit "${opts.toolkit}"`);
+    }
+    return { url: request.redirectUrl, authId: request.id };
+  }
+  async listConnectionFields({ toolkit }) {
+    const composio = this.getRawClient();
+    const { authScheme } = await this.resolveAuthConfig(toolkit);
+    if (!authScheme) {
+      return [];
+    }
+    const fields = await composio.toolkits.getConnectedAccountInitiationFields(toolkit, authScheme, {
+      requiredOnly: false
+    });
+    return fields.map((f) => ({
+      name: f.name,
+      displayName: f.displayName,
+      description: f.description,
+      type: coerceFieldType(f.type),
+      required: f.required ?? false,
+      default: f.default ?? void 0
+    }));
+  }
+  async getAuthStatus(authId) {
+    const composio = this.getRawClient();
+    const account = await composio.connectedAccounts.get(authId);
+    switch (account.status) {
+      case "ACTIVE":
+        return "completed";
+      case "INITIALIZING":
+      case "INITIATED":
+        return "pending";
+      case "FAILED":
+      case "EXPIRED":
+      case "INACTIVE":
+        return "failed";
+      default:
+        return "pending";
+    }
+  }
+  async getConnectionStatus(opts) {
+    if (opts.items.length === 0) return {};
+    const composio = this.getRawClient();
+    const toolkitSlugs = Array.from(new Set(opts.items.map((i) => i.toolkit)));
+    const list = await composio.connectedAccounts.list({
+      toolkitSlugs
+    });
+    const liveById = /* @__PURE__ */ new Map();
+    for (const item of list.items) {
+      liveById.set(item.id, { status: item.status, isDisabled: item.isDisabled });
+    }
+    const result = {};
+    for (const { connectionId } of opts.items) {
+      const live = liveById.get(connectionId);
+      result[connectionId] = { connected: live ? live.status === "ACTIVE" && !live.isDisabled : false };
+    }
+    return result;
+  }
+  async listConnections(opts) {
+    const composio = this.getRawClient();
+    const page = opts.page ?? 1;
+    const perPage = clampLimit(opts.perPage);
+    const userIds = resolveUserIds(opts);
+    if (userIds && userIds.length === 0) {
+      return { items: [], pagination: { page, perPage, hasMore: false } };
+    }
+    const list = await composio.connectedAccounts.list({
+      toolkitSlugs: [opts.toolkit],
+      ...userIds ? { userIds } : {},
+      limit: perPage
+    });
+    const items = (list.items ?? []).map((account) => ({
+      connectionId: account.id,
+      status: mapComposioStatus(account.status, account.isDisabled),
+      createdAt: account.createdAt,
+      // `user_id` is preserved by the Composio SDK transform via spread but
+      // isn't on the typed shape. Read it via a narrow cast.
+      authorId: account.user_id
+    }));
+    const nextCursor = list.nextCursor ?? null;
+    const hasMore = typeof nextCursor === "string" && nextCursor.length > 0;
+    return { items, pagination: { page, perPage, hasMore } };
+  }
   /**
-   * Get JSON schema for a specific tool via `composio.tools.getRawComposioToolBySlug()`.
+   * Revoke a Composio connected account via
+   * `DELETE /api/v3/connected_accounts/:nanoid`. Composio performs a soft
+   * delete and responds with `{ success: boolean }`.
+   *
+   * Treats a 404 (account already deleted or never existed) as success so
+   * the caller can drop its local pin without an error path. A `success:
+   * false` response means the provider refused the delete and is surfaced
+   * as an error so the caller does not delete its local row.
    */
-  async getToolSchema(toolSlug) {
+  async revokeConnection(connectionId) {
+    const composio = this.getRawClient();
+    try {
+      const res = await composio.connectedAccounts.delete(connectionId);
+      if (res && res.success === false) {
+        throw new Error(`Composio refused to delete connected account ${connectionId} (success=false)`);
+      }
+    } catch (err) {
+      if (isNotFoundError(err)) return;
+      throw err;
+    }
+  }
+  async getHealth() {
     try {
       const composio = this.getRawClient();
-      const tool = await composio.tools.getRawComposioToolBySlug(toolSlug);
-      if (!tool) return null;
-      return tool.inputParameters ?? {};
-    } catch {
-      return null;
+      await composio.toolkits.get({ limit: 1 });
+      return { ok: true };
+    } catch (err) {
+      return {
+        ok: false,
+        message: err instanceof Error ? err.message : "Composio SDK reachability check failed"
+      };
     }
   }
+  // ── helpers ───────────────────────────────────────────────────────────
   /**
-   * Resolve executable tools in Mastra format via `composio.tools.get(userId, { tools: [...] })`.
-   *
-   * Uses MastraProvider so returned tools are `ReturnType<typeof createTool>` — compatible
-   * with Mastra's `ToolAction` interface.
+   * Resolve the single ENABLED auth config for `toolkit`. Throws if zero
+   * or multiple configs match — the admin must enable exactly one in the
+   * Composio dashboard before agents can connect.
    */
-  async resolveTools(toolSlugs, toolConfigs, options) {
-    if (toolSlugs.length === 0) return {};
-    const resourceId = options?.requestContext?.[MASTRA_RESOURCE_ID_KEY];
-    const userId = typeof resourceId === "string" ? resourceId : options?.userId ?? "default";
-    const composio = this.getMastraClient();
-    const mastraTools = await composio.tools.get(userId, { tools: toolSlugs });
-    const result = {};
-    const entries = Object.entries(mastraTools ?? {});
-    for (const [key, tool] of entries) {
-      if (!tool) continue;
-      const slug = tool.id ?? key;
-      const descOverride = toolConfigs?.[slug]?.description;
-      if (descOverride) {
-        result[slug] = { ...tool, description: descOverride };
-      } else {
-        result[slug] = tool;
-      }
+  async resolveAuthConfig(toolkit) {
+    const composio = this.getRawClient();
+    const response = await composio.authConfigs.list({ toolkit });
+    const enabled = response.items.filter((item) => item.status === "ENABLED");
+    if (enabled.length === 0) {
+      throw new Error(
+        `[composio] No ENABLED auth config for toolkit "${toolkit}". Enable one in the Composio dashboard.`
+      );
     }
-    return result;
+    if (enabled.length > 1) {
+      const ids = enabled.map((item) => item.id).join(", ");
+      throw new Error(
+        `[composio] Multiple ENABLED auth configs for toolkit "${toolkit}" (${ids}). Keep exactly one enabled.`
+      );
+    }
+    return { id: enabled[0].id, authScheme: enabled[0].authScheme };
   }
 };
+function isNotFoundError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.statusCode === 404 || e.status === 404) return true;
+  const msg = typeof e.message === "string" ? e.message.toLowerCase() : "";
+  return msg.includes("not found") || msg.includes("404");
+}
+function coerceFieldType(type) {
+  switch (type.toLowerCase()) {
+    case "number":
+    case "integer":
+    case "int":
+    case "float":
+      return "number";
+    case "bool":
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+function mapComposioStatus(status, isDisabled) {
+  if (isDisabled) return "inactive";
+  switch (status) {
+    case "ACTIVE":
+      return "active";
+    case "INITIALIZING":
+    case "INITIATED":
+      return "pending";
+    case "FAILED":
+    case "EXPIRED":
+      return "failed";
+    case "INACTIVE":
+      return "inactive";
+    default:
+      return "pending";
+  }
+}
+var MASTRA_USER_KEY = "mastra__user";
+function resolveInternalUserId(requestContext) {
+  const resourceId = requestContext?.[MASTRA_RESOURCE_ID_KEY];
+  if (typeof resourceId === "string" && resourceId.length > 0) {
+    return resourceId;
+  }
+  const user = requestContext?.[MASTRA_USER_KEY];
+  if (user && typeof user === "object" && "id" in user) {
+    const id = user.id;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
+    }
+  }
+  return DEFAULT_INTERNAL_USER_ID;
+}
+function resolveUserIds(opts) {
+  if (Array.isArray(opts.userIds)) return opts.userIds;
+  if (typeof opts.userId === "string" && opts.userId.length > 0) return [opts.userId];
+  return [DEFAULT_INTERNAL_USER_ID];
+}
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 200;
+function clampLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) {
+    return DEFAULT_LIMIT;
+  }
+  return Math.min(Math.floor(limit), MAX_LIMIT);
+}
 export {
   ComposioToolProvider
 };