@composio/client 0.1.0-alpha.15 → 0.1.0-alpha.17

package/src/resources/v3/admin.ts

@@ -0,0 +1,141 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Admin extends APIResource {
+  /**
+   * Administrative endpoint that retrieves all active connections for a given
+   * toolkit slug. This is primarily used for token refresh operations and system
+   * maintenance. Only includes non-deleted connections with OAuth2 or JWT
+   * authentication types.
+   *
+   * @example
+   * ```ts
+   * const response = await client.v3.admin.listConnections({
+   *   toolkit_slug: 'google-drive',
+   *   'x-composio-admin-token': 'adm_123456789abcdef',
+   * });
+   * ```
+   */
+  listConnections(
+    params: AdminListConnectionsParams,
+    options?: RequestOptions,
+  ): APIPromise<AdminListConnectionsResponse> {
+    const { 'x-composio-admin-token': xComposioAdminToken, ...query } = params;
+    return this._client.get('/api/v3/admin/connections', {
+      query,
+      ...options,
+      headers: buildHeaders([{ 'x-composio-admin-token': xComposioAdminToken }, options?.headers]),
+    });
+  }
+
+  /**
+   * Administrative endpoint that refreshes authentication tokens for multiple
+   * connected accounts in parallel. This is useful for proactive token refresh to
+   * prevent authentication failures or for recovering from authentication issues
+   * across multiple connections.
+   *
+   * @example
+   * ```ts
+   * const response = await client.v3.admin.refreshAuthTokens({
+   *   connectionIds: ['conn_123abc', 'conn_456def'],
+   *   'x-composio-admin-token': 'adm_123456789abcdef',
+   * });
+   * ```
+   */
+  refreshAuthTokens(
+    params: AdminRefreshAuthTokensParams,
+    options?: RequestOptions,
+  ): APIPromise<AdminRefreshAuthTokensResponse> {
+    const { 'x-composio-admin-token': xComposioAdminToken, ...body } = params;
+    return this._client.post('/api/v3/admin/auth-refresh', {
+      body,
+      ...options,
+      headers: buildHeaders([{ 'x-composio-admin-token': xComposioAdminToken }, options?.headers]),
+    });
+  }
+}
+
+export interface AdminListConnectionsResponse {
+  /**
+   * Collection of account connection objects, may be empty if no connections exist
+   */
+  items: Array<AdminListConnectionsResponse.Item>;
+}
+
+export namespace AdminListConnectionsResponse {
+  export interface Item {
+    /**
+     * Identifier that can be used with other API endpoints that operate on connections
+     */
+    id: string;
+  }
+}
+
+export interface AdminRefreshAuthTokensResponse {
+  /**
+   * Array of connections that failed to refresh with detailed error information
+   */
+  failures: Array<AdminRefreshAuthTokensResponse.Failure>;
+
+  /**
+   * List of connections where token refresh was successful or not needed
+   */
+  success: Array<string>;
+}
+
+export namespace AdminRefreshAuthTokensResponse {
+  export interface Failure {
+    /**
+     * Connection ID that failed during refresh
+     */
+    connectionId: string;
+
+    /**
+     * Specific error code identifying why the refresh operation failed
+     */
+    error: string;
+  }
+}
+
+export interface AdminListConnectionsParams {
+  /**
+   * Query param: The unique identifier slug of the toolkit to filter connections by
+   */
+  toolkit_slug: string;
+
+  /**
+   * Header param: Admin authentication token required for administrative operations
+   */
+  'x-composio-admin-token': string;
+}
+
+export interface AdminRefreshAuthTokensParams {
+  /**
+   * Body param: List of connection identifiers that need token refresh
+   */
+  connectionIds: Array<string>;
+
+  /**
+   * Header param: Admin authentication token required for administrative operations
+   */
+  'x-composio-admin-token': string;
+
+  /**
+   * Body param: Controls processing speed and system load. Higher values process
+   * faster but increase load.
+   */
+  parallelism?: number;
+}
+
+export declare namespace Admin {
+  export {
+    type AdminListConnectionsResponse as AdminListConnectionsResponse,
+    type AdminRefreshAuthTokensResponse as AdminRefreshAuthTokensResponse,
+    type AdminListConnectionsParams as AdminListConnectionsParams,
+    type AdminRefreshAuthTokensParams as AdminRefreshAuthTokensParams,
+  };
+}

package/src/resources/{auth → v3/auth}/auth.ts

@@ -1,8 +1,8 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../core/resource';
+import { APIResource } from '../../../core/resource';
 import * as SessionAPI from './session';
-import { Session, SessionRetrieveResponse } from './session';
+import { Session, SessionRetrieveInfoResponse } from './session';
 
 export class Auth extends APIResource {
   session: SessionAPI.Session = new SessionAPI.Session(this._client);
@@ -11,5 +11,5 @@ export class Auth extends APIResource {
 Auth.Session = Session;
 
 export declare namespace Auth {
-  export { Session as Session, type SessionRetrieveResponse as SessionRetrieveResponse };
+  export { Session as Session, type SessionRetrieveInfoResponse as SessionRetrieveInfoResponse };
 }

package/src/resources/{auth → v3/auth}/index.ts

@@ -1,4 +1,4 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 export { Auth } from './auth';
-export { Session, type SessionRetrieveResponse } from './session';
+export { Session, type SessionRetrieveInfoResponse } from './session';

package/src/resources/{auth → v3/auth}/session.ts

@@ -1,8 +1,8 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../core/resource';
-import { APIPromise } from '../../core/api-promise';
-import { RequestOptions } from '../../internal/request-options';
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
 
 export class Session extends APIResource {
   /**
@@ -11,8 +11,14 @@ export class Session extends APIResource {
    * applicable. This endpoint is useful for verifying authentication status and
    * retrieving contextual information about the authenticated user and their access
    * privileges.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.v3.auth.session.retrieveInfo();
+   * ```
    */
-  retrieve(options?: RequestOptions): APIPromise<SessionRetrieveResponse> {
+  retrieveInfo(options?: RequestOptions): APIPromise<SessionRetrieveInfoResponse> {
     return this._client.get('/api/v3/auth/session/info', options);
   }
 }
@@ -20,25 +26,25 @@ export class Session extends APIResource {
 /**
  * Response containing user session information
  */
-export interface SessionRetrieveResponse {
+export interface SessionRetrieveInfoResponse {
   /**
    * Details of the API key used for authentication (null if using session auth)
    */
-  api_key: SessionRetrieveResponse.APIKey | null;
+  api_key: SessionRetrieveInfoResponse.APIKey | null;
 
   /**
    * Information about the authenticated user
    */
-  org_member: SessionRetrieveResponse.OrgMember;
+  org_member: SessionRetrieveInfoResponse.OrgMember;
 
   /**
    * Details of the current active project (null if accessing with org-level
    * credentials)
    */
-  project: SessionRetrieveResponse.Project | null;
+  project: SessionRetrieveInfoResponse.Project | null;
 }
 
-export namespace SessionRetrieveResponse {
+export namespace SessionRetrieveInfoResponse {
   /**
    * Details of the API key used for authentication (null if using session auth)
    */
@@ -288,5 +294,5 @@ export namespace SessionRetrieveResponse {
 }
 
 export declare namespace Session {
-  export { type SessionRetrieveResponse as SessionRetrieveResponse };
+  export { type SessionRetrieveInfoResponse as SessionRetrieveInfoResponse };
 }

package/src/resources/v3/cli.ts

@@ -0,0 +1,209 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Cli extends APIResource {
+  /**
+   * Generates a new CLI session with a random 6-character code. This endpoint is the
+   * first step in the CLI authentication flow, creating a session that can later be
+   * linked to a user account. The generated code is displayed to the user in the CLI
+   * and should be entered in the web interface to complete authentication.
+   *
+   * @example
+   * ```ts
+   * const response = await client.v3.cli.createSession();
+   * ```
+   */
+  createSession(options?: RequestOptions): APIPromise<CliCreateSessionResponse> {
+    return this._client.post('/api/v3/cli/create-session', options);
+  }
+
+  /**
+   * Links a pending CLI session to the currently authenticated user. This is the
+   * final step in the CLI authentication flow, where the user enters the code in the
+   * web interface and their account is associated with the CLI session, allowing the
+   * CLI to act on their behalf.
+   *
+   * @example
+   * ```ts
+   * const response = await client.v3.cli.linkSession({
+   *   id: 'ABC123',
+   * });
+   * ```
+   */
+  linkSession(body: CliLinkSessionParams, options?: RequestOptions): APIPromise<CliLinkSessionResponse> {
+    return this._client.put('/api/v3/cli/link-session', { body, ...options });
+  }
+
+  /**
+   * Retrieves the current state of a CLI session using either the session ID (UUID)
+   * or the 6-character code. This endpoint is used by both the CLI client to check
+   * if the session has been linked, and by the web interface to display session
+   * details before linking.
+   *
+   * @example
+   * ```ts
+   * const response = await client.v3.cli.retrieveSession({
+   *   id: 'ABC123',
+   * });
+   * ```
+   */
+  retrieveSession(
+    query: CliRetrieveSessionParams,
+    options?: RequestOptions,
+  ): APIPromise<CliRetrieveSessionResponse> {
+    return this._client.get('/api/v3/cli/get-session', { query, ...options });
+  }
+}
+
+export interface CliCreateSessionResponse {
+  /**
+   * Unique identifier for the CLI session. UUID v4 format used for tracking and
+   * retrieval.
+   */
+  id: string;
+
+  /**
+   * The 6-character hexadecimal code used for CLI login
+   */
+  code: string;
+
+  /**
+   * The ISO timestamp when the session expires
+   */
+  expiresAt: string;
+
+  /**
+   * The current status of the session
+   */
+  status: 'pending' | 'linked';
+}
+
+export interface CliLinkSessionResponse {
+  /**
+   * The unique identifier for the CLI session
+   */
+  id: string;
+
+  /**
+   * Information about the linked account. Always present for successful responses
+   * from this endpoint.
+   */
+  account: CliLinkSessionResponse.Account;
+
+  /**
+   * The 6-character hexadecimal code used for CLI login
+   */
+  code: string;
+
+  /**
+   * The ISO timestamp when the session expires
+   */
+  expiresAt: string;
+
+  /**
+   * The current status of the session
+   */
+  status: 'pending' | 'linked';
+}
+
+export namespace CliLinkSessionResponse {
+  /**
+   * Information about the linked account. Always present for successful responses
+   * from this endpoint.
+   */
+  export interface Account {
+    /**
+     * The ID of the linked account
+     */
+    id: string;
+
+    /**
+     * The email address of the linked account
+     */
+    email: string;
+
+    /**
+     * The display name of the linked account
+     */
+    name: string;
+  }
+}
+
+export interface CliRetrieveSessionResponse {
+  /**
+   * The unique identifier for the CLI session
+   */
+  id: string;
+
+  /**
+   * Information about the linked account, if any. Null if the session status is
+   * "pending".
+   */
+  account: CliRetrieveSessionResponse.Account | null;
+
+  /**
+   * The 6-character hexadecimal code used for CLI login
+   */
+  code: string;
+
+  /**
+   * The ISO timestamp when the session expires
+   */
+  expiresAt: string;
+
+  /**
+   * The current status of the session
+   */
+  status: 'pending' | 'linked';
+}
+
+export namespace CliRetrieveSessionResponse {
+  /**
+   * Information about the linked account, if any. Null if the session status is
+   * "pending".
+   */
+  export interface Account {
+    /**
+     * The ID of the linked account
+     */
+    id: string;
+
+    /**
+     * The email address of the linked account
+     */
+    email: string;
+
+    /**
+     * The display name of the linked account
+     */
+    name: string;
+  }
+}
+
+export interface CliLinkSessionParams {
+  /**
+   * The CLI session ID or code to link to the current user
+   */
+  id: string;
+}
+
+export interface CliRetrieveSessionParams {
+  /**
+   * CLI session ID (UUID format) or 6-character code to check. Both formats are
+   * supported for flexibility in client implementations.
+   */
+  id: string;
+}
+
+export declare namespace Cli {
+  export {
+    type CliCreateSessionResponse as CliCreateSessionResponse,
+    type CliLinkSessionResponse as CliLinkSessionResponse,
+    type CliRetrieveSessionResponse as CliRetrieveSessionResponse,
+    type CliLinkSessionParams as CliLinkSessionParams,
+    type CliRetrieveSessionParams as CliRetrieveSessionParams,
+  };
+}

package/src/resources/v3/index.ts

@@ -0,0 +1,20 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Admin,
+  type AdminListConnectionsResponse,
+  type AdminRefreshAuthTokensResponse,
+  type AdminListConnectionsParams,
+  type AdminRefreshAuthTokensParams,
+} from './admin';
+export { Auth } from './auth/index';
+export {
+  Cli,
+  type CliCreateSessionResponse,
+  type CliLinkSessionResponse,
+  type CliRetrieveSessionResponse,
+  type CliLinkSessionParams,
+  type CliRetrieveSessionParams,
+} from './cli';
+export { Internal } from './internal/index';
+export { V3 } from './v3';

package/src/resources/v3/internal/action-execution.ts

@@ -0,0 +1,236 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class ActionExecution extends APIResource {
+  /**
+   * Get detailed execution log by ID
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.v3.internal.actionExecution.retrieveLog(
+   *     'id',
+   *   );
+   * ```
+   */
+  retrieveLog(id: string, options?: RequestOptions): APIPromise<ActionExecutionRetrieveLogResponse> {
+    return this._client.get(path`/api/v3/internal/action_execution/log/${id}`, options);
+  }
+
+  /**
+   * Search and retrieve action execution logs
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.v3.internal.actionExecution.searchLogs({
+   *     cursor: 0,
+   *   });
+   * ```
+   */
+  searchLogs(
+    body: ActionExecutionSearchLogsParams,
+    options?: RequestOptions,
+  ): APIPromise<ActionExecutionSearchLogsResponse> {
+    return this._client.post('/api/v3/internal/action_execution/logs', { body, ...options });
+  }
+}
+
+export interface ActionExecutionRetrieveLogResponse {
+  actionId: string;
+
+  actionLogId: string;
+
+  app: ActionExecutionRetrieveLogResponse.App;
+
+  connection: ActionExecutionRetrieveLogResponse.Connection;
+
+  endTime: number;
+
+  error: Record<string, unknown>;
+
+  executionMetadata: Record<string, unknown>;
+
+  payloadReceived: Record<string, unknown>;
+
+  response: Record<string, unknown>;
+
+  session: Record<string, unknown>;
+
+  startTime: number;
+
+  status: 'success' | 'error' | 'warning' | 'info';
+
+  steps: Array<ActionExecutionRetrieveLogResponse.Step>;
+
+  totalDuration: string;
+
+  version: string;
+}
+
+export namespace ActionExecutionRetrieveLogResponse {
+  export interface App {
+    icon: string;
+
+    name: string;
+
+    uniqueId: string;
+  }
+
+  export interface Connection {
+    entity: string;
+
+    id?: string;
+  }
+
+  export interface Step {
+    endTime: number;
+
+    message: string;
+
+    startTime: number;
+
+    status: 'success' | 'failure' | 'error';
+
+    totalDuration: number;
+
+    type: 'tool_execution' | 'fetch_connection_details';
+
+    logs?: Array<Step.Log>;
+
+    metadata?: Step.Metadata;
+  }
+
+  export namespace Step {
+    export interface Log {
+      level: string;
+
+      message: string;
+
+      request: Log.Request;
+
+      requestId: string;
+
+      response: Log.Response;
+
+      time: number;
+
+      type: 'network' | 'system';
+    }
+
+    export namespace Log {
+      export interface Request {
+        method: string;
+
+        url: string;
+
+        headers?: Record<string, string>;
+
+        json?: Record<string, unknown>;
+
+        params?: Record<string, unknown>;
+
+        timeout?: number;
+      }
+
+      export interface Response {
+        status: number;
+
+        time: string;
+      }
+    }
+
+    export interface Metadata {
+      encryption?: string;
+    }
+  }
+}
+
+export interface ActionExecutionSearchLogsResponse {
+  data: Array<ActionExecutionSearchLogsResponse.Data>;
+
+  nextCursor: number | null;
+}
+
+export namespace ActionExecutionSearchLogsResponse {
+  export interface Data {
+    id: string;
+
+    actionKey: string;
+
+    app: Data.App;
+
+    appKey: string;
+
+    connectedAccountId: string;
+
+    createdAt: number;
+
+    entityId: string;
+
+    executionTime: number;
+
+    minimalResponse: string;
+
+    status: 'success' | 'failed';
+  }
+
+  export namespace Data {
+    export interface App {
+      icon: string;
+
+      name: string;
+    }
+  }
+}
+
+export interface ActionExecutionSearchLogsParams {
+  /**
+   * cursor_that_can_be_used_to_paginate_through_the_logs
+   */
+  cursor: number | null;
+
+  /**
+   * whether_the_search_is_case_sensitive_or_not
+   */
+  case_sensitive?: boolean;
+
+  /**
+   * start_time_of_the_logs_in_epoch_time
+   */
+  from?: number;
+
+  /**
+   * number_of_logs_to_return
+   */
+  limit?: number;
+
+  search_params?: Array<ActionExecutionSearchLogsParams.SearchParam>;
+
+  /**
+   * end_time_of_the_logs_in_epoch_time
+   */
+  to?: number;
+}
+
+export namespace ActionExecutionSearchLogsParams {
+  export interface SearchParam {
+    field?: string;
+
+    operation?: string;
+
+    value?: string;
+  }
+}
+
+export declare namespace ActionExecution {
+  export {
+    type ActionExecutionRetrieveLogResponse as ActionExecutionRetrieveLogResponse,
+    type ActionExecutionSearchLogsResponse as ActionExecutionSearchLogsResponse,
+    type ActionExecutionSearchLogsParams as ActionExecutionSearchLogsParams,
+  };
+}

package/src/resources/v3/internal/index.ts

@@ -0,0 +1,10 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  ActionExecution,
+  type ActionExecutionRetrieveLogResponse,
+  type ActionExecutionSearchLogsResponse,
+  type ActionExecutionSearchLogsParams,
+} from './action-execution';
+export { Internal } from './internal';
+export { Trigger, type TriggerSearchLogsResponse, type TriggerSearchLogsParams } from './trigger';