@composio/client 0.1.0-alpha.1

package/src/resources/tools.ts

@@ -0,0 +1,265 @@
+// 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 Tools extends APIResource {
+  retrieve(toolSlug: string, options?: RequestOptions): APIPromise<ToolRetrieveResponse> {
+    return this._client.get(path`/api/v3/tools/${toolSlug}`, options);
+  }
+
+  list(
+    query: ToolListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ToolListResponse> {
+    return this._client.get('/api/v3/tools', { query, ...options });
+  }
+
+  execute(
+    action: string,
+    body: ToolExecuteParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ToolExecuteResponse> {
+    return this._client.post(path`/api/v3/tools/execute/${action}`, { body, ...options });
+  }
+
+  getInput(
+    actionName: string,
+    body: ToolGetInputParams,
+    options?: RequestOptions,
+  ): APIPromise<ToolGetInputResponse> {
+    return this._client.post(path`/api/v3/tools/execute/${actionName}/input`, { body, ...options });
+  }
+
+  proxy(body: ToolProxyParams, options?: RequestOptions): APIPromise<ToolProxyResponse> {
+    return this._client.post('/api/v3/tools/execute/proxy', { body, ...options });
+  }
+
+  retrieveEnum(options?: RequestOptions): APIPromise<string> {
+    return this._client.get('/api/v3/tools/enum', options);
+  }
+}
+
+export interface ToolRetrieveResponse {
+  available_versions: Array<string>;
+
+  description: string;
+
+  input_parameters: Record<string, unknown>;
+
+  name: string;
+
+  output_parameters: Record<string, unknown>;
+
+  slug: string;
+
+  tags: Array<string>;
+
+  toolkit: ToolRetrieveResponse.Toolkit;
+
+  version: string;
+}
+
+export namespace ToolRetrieveResponse {
+  export interface Toolkit {
+    logo: string;
+
+    name: string;
+
+    slug: string;
+  }
+}
+
+export interface ToolListResponse {
+  items: Array<ToolListResponse.Item>;
+
+  next_cursor: string | null;
+
+  total_pages: number;
+}
+
+export namespace ToolListResponse {
+  export interface Item {
+    /**
+     * The description of the tool
+     */
+    description: string;
+
+    /**
+     * The input parameters of the tool
+     */
+    input_parameters: Record<string, unknown>;
+
+    /**
+     * The name of the tool
+     */
+    name: string;
+
+    /**
+     * The output parameters of the tool
+     */
+    output_parameters: Record<string, unknown>;
+
+    /**
+     * The slug of the tool
+     */
+    slug: string;
+
+    /**
+     * The tags of the tool
+     */
+    tags: Array<string>;
+
+    toolkit: Item.Toolkit;
+  }
+
+  export namespace Item {
+    export interface Toolkit {
+      /**
+       * The name of the toolkit
+       */
+      name: string;
+
+      /**
+       * The slug of the toolkit
+       */
+      slug: string;
+    }
+  }
+}
+
+export interface ToolExecuteResponse {
+  data: Record<string, unknown>;
+
+  error: string | null;
+
+  successful: boolean;
+
+  log_id?: string;
+
+  session_info?: unknown;
+}
+
+export interface ToolGetInputResponse {
+  /**
+   * The arguments for the action needed to execute the given task.
+   */
+  arguments?: Record<string, unknown>;
+
+  /**
+   * The error message if the arguments were not generated successfully.
+   */
+  error?: string;
+}
+
+export interface ToolProxyResponse {
+  status: number;
+
+  data?: unknown;
+
+  headers?: Record<string, string>;
+}
+
+export type ToolRetrieveEnumResponse = string;
+
+export interface ToolListParams {
+  /**
+   * The cursor to paginate through the results
+   */
+  cursor?: string;
+
+  /**
+   * Whether to filter by important tools
+   */
+  important?: string;
+
+  /**
+   * The number of results to return
+   */
+  limit?: string;
+
+  /**
+   * The search query to filter by
+   */
+  search?: string;
+
+  /**
+   * The slug of the toolkit to filter by
+   */
+  toolkit_slug?: string;
+}
+
+export interface ToolExecuteParams {
+  allow_tracing?: boolean;
+
+  arguments?: Record<string, unknown>;
+
+  connected_account_id?: string;
+
+  entity_id?: string;
+
+  text?: string;
+
+  version?: string;
+}
+
+export interface ToolGetInputParams {
+  /**
+   * The use-case description for the action, this will give context to LLM to
+   * generate the correct inputs for the action.
+   */
+  text: string;
+
+  /**
+   * The custom description for the action, use this to provide customised context
+   * about the action to the LLM to suit your use-case.
+   */
+  customDescription?: string;
+
+  /**
+   * The system prompt to be used by LLM, use this to control and guide the behaviour
+   * of the LLM.
+   */
+  systemPrompt?: string;
+
+  version?: string;
+}
+
+export interface ToolProxyParams {
+  endpoint: string;
+
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
+  body?: unknown;
+
+  connected_account_id?: string;
+
+  parameters?: Array<ToolProxyParams.Parameter>;
+}
+
+export namespace ToolProxyParams {
+  export interface Parameter {
+    name: string;
+
+    type: 'header' | 'query';
+
+    value: string;
+  }
+}
+
+export declare namespace Tools {
+  export {
+    type ToolRetrieveResponse as ToolRetrieveResponse,
+    type ToolListResponse as ToolListResponse,
+    type ToolExecuteResponse as ToolExecuteResponse,
+    type ToolGetInputResponse as ToolGetInputResponse,
+    type ToolProxyResponse as ToolProxyResponse,
+    type ToolRetrieveEnumResponse as ToolRetrieveEnumResponse,
+    type ToolListParams as ToolListParams,
+    type ToolExecuteParams as ToolExecuteParams,
+    type ToolGetInputParams as ToolGetInputParams,
+    type ToolProxyParams as ToolProxyParams,
+  };
+}

package/src/resources/trigger-instances/handle.ts

@@ -0,0 +1,45 @@
+// 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 Handle extends APIResource {
+  retrieve(projectID: string, params: HandleRetrieveParams, options?: RequestOptions): APIPromise<string> {
+    const { slug } = params;
+    return this._client.get(path`/api/v3/trigger_instances/${slug}/${projectID}/handle`, options);
+  }
+
+  execute(projectID: string, params: HandleExecuteParams, options?: RequestOptions): APIPromise<string> {
+    const { slug } = params;
+    return this._client.post(path`/api/v3/trigger_instances/${slug}/${projectID}/handle`, options);
+  }
+}
+
+export type HandleRetrieveResponse = string;
+
+export type HandleExecuteResponse = string;
+
+export interface HandleRetrieveParams {
+  /**
+   * The slug of the trigger instance
+   */
+  slug: string;
+}
+
+export interface HandleExecuteParams {
+  /**
+   * The slug of the trigger instance
+   */
+  slug: string;
+}
+
+export declare namespace Handle {
+  export {
+    type HandleRetrieveResponse as HandleRetrieveResponse,
+    type HandleExecuteResponse as HandleExecuteResponse,
+    type HandleRetrieveParams as HandleRetrieveParams,
+    type HandleExecuteParams as HandleExecuteParams,
+  };
+}

package/src/resources/trigger-instances/index.ts

@@ -0,0 +1,19 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Handle,
+  type HandleRetrieveResponse,
+  type HandleExecuteResponse,
+  type HandleRetrieveParams,
+  type HandleExecuteParams,
+} from './handle';
+export {
+  TriggerInstances,
+  type TriggerInstanceListActiveResponse,
+  type TriggerInstanceRemoveUpsertResponse,
+  type TriggerInstanceUpdateStatusResponse,
+  type TriggerInstanceUpsertResponse,
+  type TriggerInstanceListActiveParams,
+  type TriggerInstanceUpdateStatusParams,
+  type TriggerInstanceUpsertParams,
+} from './trigger-instances';

package/src/resources/trigger-instances/trigger-instances.ts

@@ -0,0 +1,202 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as HandleAPI from './handle';
+import {
+  Handle,
+  HandleExecuteParams,
+  HandleExecuteResponse,
+  HandleRetrieveParams,
+  HandleRetrieveResponse,
+} from './handle';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class TriggerInstances extends APIResource {
+  handle: HandleAPI.Handle = new HandleAPI.Handle(this._client);
+
+  listActive(
+    query: TriggerInstanceListActiveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<TriggerInstanceListActiveResponse> {
+    return this._client.get('/api/v3/trigger_instances/active', { query, ...options });
+  }
+
+  removeUpsert(slug: string, options?: RequestOptions): APIPromise<TriggerInstanceRemoveUpsertResponse> {
+    return this._client.delete(path`/api/v3/trigger_instances/${slug}/upsert`, options);
+  }
+
+  updateStatus(
+    status: 'enable' | 'disable',
+    params: TriggerInstanceUpdateStatusParams,
+    options?: RequestOptions,
+  ): APIPromise<TriggerInstanceUpdateStatusResponse> {
+    const { slug } = params;
+    return this._client.patch(path`/api/v3/trigger_instances/${slug}/status/${status}`, options);
+  }
+
+  upsert(
+    slug: string,
+    body: TriggerInstanceUpsertParams,
+    options?: RequestOptions,
+  ): APIPromise<TriggerInstanceUpsertResponse> {
+    return this._client.post(path`/api/v3/trigger_instances/${slug}/upsert`, { body, ...options });
+  }
+}
+
+export interface TriggerInstanceListActiveResponse {
+  items: Array<TriggerInstanceListActiveResponse.Item>;
+
+  next_cursor: string | null;
+
+  total_pages: number;
+}
+
+export namespace TriggerInstanceListActiveResponse {
+  export interface Item {
+    /**
+     * Nano ID of the trigger instance
+     */
+    id: string;
+
+    /**
+     * ID of the connected account this trigger is associated with
+     */
+    connectedAccountId: string;
+
+    /**
+     * ISO 8601 timestamp when the trigger instance was disabled, if applicable
+     */
+    disabledAt: string | null;
+
+    /**
+     * State of the trigger instance
+     */
+    state: Record<string, unknown>;
+
+    /**
+     * Configuration for the trigger
+     */
+    triggerConfig: Record<string, unknown>;
+
+    /**
+     * Name of the trigger
+     */
+    triggerName: string;
+
+    /**
+     * ISO 8601 timestamp when the trigger instance was updated
+     */
+    updatedAt: string;
+
+    /**
+     * Additional data associated with the trigger instance
+     */
+    triggerData?: string;
+
+    /**
+     * Unique identifier of the trigger instance
+     */
+    uuid?: string;
+  }
+}
+
+export interface TriggerInstanceRemoveUpsertResponse {
+  /**
+   * ID of the updated trigger
+   */
+  triggerId: string;
+}
+
+export interface TriggerInstanceUpdateStatusResponse {
+  /**
+   * Status of the operation
+   */
+  status: 'success';
+}
+
+export interface TriggerInstanceUpsertResponse {
+  /**
+   * ID of the updated trigger
+   */
+  triggerId: string;
+}
+
+export interface TriggerInstanceListActiveParams {
+  /**
+   * Comma-separated list of auth config IDs to filter triggers by
+   */
+  authConfigIds?: string;
+
+  /**
+   * Comma-separated list of connected account IDs to filter triggers by
+   */
+  connectedAccountIds?: string;
+
+  /**
+   * Number of items to return per page.
+   */
+  limit?: number;
+
+  /**
+   * Page number for pagination. Starts from 1.
+   */
+  page?: number;
+
+  /**
+   * When set to true, includes disabled triggers in the response.
+   */
+  showDisabled?: boolean | null;
+
+  /**
+   * Comma-separated list of trigger IDs to filter triggers by
+   */
+  triggerIds?: string;
+
+  /**
+   * Comma-separated list of trigger names to filter triggers by
+   */
+  triggerNames?: string;
+}
+
+export interface TriggerInstanceUpdateStatusParams {
+  /**
+   * The slug of the trigger instance
+   */
+  slug: string;
+}
+
+export interface TriggerInstanceUpsertParams {
+  /**
+   * Connection ID
+   */
+  connectedAuthId: string;
+
+  /**
+   * Trigger configuration
+   */
+  triggerConfig: Record<string, unknown>;
+}
+
+TriggerInstances.Handle = Handle;
+
+export declare namespace TriggerInstances {
+  export {
+    type TriggerInstanceListActiveResponse as TriggerInstanceListActiveResponse,
+    type TriggerInstanceRemoveUpsertResponse as TriggerInstanceRemoveUpsertResponse,
+    type TriggerInstanceUpdateStatusResponse as TriggerInstanceUpdateStatusResponse,
+    type TriggerInstanceUpsertResponse as TriggerInstanceUpsertResponse,
+    type TriggerInstanceListActiveParams as TriggerInstanceListActiveParams,
+    type TriggerInstanceUpdateStatusParams as TriggerInstanceUpdateStatusParams,
+    type TriggerInstanceUpsertParams as TriggerInstanceUpsertParams,
+  };
+
+  export {
+    Handle as Handle,
+    type HandleRetrieveResponse as HandleRetrieveResponse,
+    type HandleExecuteResponse as HandleExecuteResponse,
+    type HandleRetrieveParams as HandleRetrieveParams,
+    type HandleExecuteParams as HandleExecuteParams,
+  };
+}

package/src/resources/trigger-instances.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './trigger-instances/index';

package/src/resources/trigger.ts

@@ -0,0 +1,108 @@
+// 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 Trigger extends APIResource {
+  log(body: TriggerLogParams, options?: RequestOptions): APIPromise<TriggerLogResponse> {
+    return this._client.post('/api/v3/internal/trigger/logs', { body, ...options });
+  }
+}
+
+export interface TriggerLogResponse {
+  nextCursor: string | null;
+
+  data?: Array<TriggerLogResponse.Data>;
+}
+
+export namespace TriggerLogResponse {
+  export interface Data {
+    id: string;
+
+    appName: string;
+
+    clientId: string;
+
+    connectionId: string;
+
+    createdAt: string;
+
+    entityId: string;
+
+    meta: Data.Meta;
+
+    status: string;
+
+    /**
+     * Log entity type (trigger or action)
+     */
+    type: 'trigger' | 'action';
+  }
+
+  export namespace Data {
+    export interface Meta {
+      id: string;
+
+      clientId: string;
+
+      connectionId: string;
+
+      createdAt: string;
+
+      provider: string;
+
+      /**
+       * Log entity type (trigger or action)
+       */
+      type: 'trigger' | 'action';
+
+      updatedAt: string;
+
+      triggerClientError?: string;
+
+      triggerClientPayload?: string;
+
+      triggerClientResponse?: string;
+
+      triggerName?: string;
+
+      triggerProviderPayload?: string;
+    }
+  }
+}
+
+export interface TriggerLogParams {
+  /**
+   * cursor that can be used to paginate through the logs
+   */
+  cursor: string | null;
+
+  entityId?: string;
+
+  integrationId?: string;
+
+  /**
+   * number of logs to return
+   */
+  limit?: number;
+
+  /**
+   * Search term to filter logs
+   */
+  search?: string;
+
+  /**
+   * Filter logs by their status level
+   */
+  status?: 'all' | 'success' | 'error';
+
+  /**
+   * Return logs from the last N time units
+   */
+  time?: '5m' | '30m' | '6h' | '1d' | '1w' | '1month' | '1y';
+}
+
+export declare namespace Trigger {
+  export { type TriggerLogResponse as TriggerLogResponse, type TriggerLogParams as TriggerLogParams };
+}