@arcadeai/arcadejs 0.2.2 → 1.0.0

package/src/index.ts

@@ -14,17 +14,15 @@ import {
   AuthorizeToolRequest,
   ExecuteToolRequest,
   ExecuteToolResponse,
-  ResponseOutput,
   ToolAuthorizeParams,
+  ToolDefinition,
+  ToolDefinitionsOffsetPage,
   ToolExecuteParams,
   ToolExecution,
   ToolExecutionAttempt,
-  ToolGetParams,
-  ToolGetResponse,
   ToolListParams,
-  ToolListResponse,
-  ToolListResponsesOffsetPage,
   Tools,
+  ValueSchema,
 } from './resources/tools/tools';
 
 export interface ClientOptions {
@@ -47,7 +45,7 @@ export interface ClientOptions {
    * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
    * much longer than this timeout before the promise succeeds or fails.
    */
-  timeout?: number;
+  timeout?: number | undefined;
 
   /**
    * An HTTP agent used to manage HTTP(S) connections.
@@ -55,7 +53,7 @@ export interface ClientOptions {
    * If not provided, an agent will be constructed by default in the Node.js environment,
    * otherwise no agent is used.
    */
-  httpAgent?: Agent;
+  httpAgent?: Agent | undefined;
 
   /**
    * Specify a custom `fetch` function implementation.
@@ -71,7 +69,7 @@ export interface ClientOptions {
    *
    * @default 2
    */
-  maxRetries?: number;
+  maxRetries?: number | undefined;
 
   /**
    * Default headers to include with every request to the API.
@@ -79,7 +77,7 @@ export interface ClientOptions {
    * These can be removed in individual requests by explicitly setting the
    * header to `undefined` or `null` in request options.
    */
-  defaultHeaders?: Core.Headers;
+  defaultHeaders?: Core.Headers | undefined;
 
   /**
    * Default query parameters to include with every request to the API.
@@ -87,7 +85,7 @@ export interface ClientOptions {
    * These can be removed in individual requests by explicitly setting the
    * param to `undefined` in request options.
    */
-  defaultQuery?: Core.DefaultQuery;
+  defaultQuery?: Core.DefaultQuery | undefined;
 }
 
 /**
@@ -102,7 +100,7 @@ export class Arcade extends Core.APIClient {
    * API Client for interfacing with the Arcade API.
    *
    * @param {string | undefined} [opts.apiKey=process.env['ARCADE_API_KEY'] ?? undefined]
-   * @param {string} [opts.baseURL=process.env['ARCADE_BASE_URL'] ?? https://api.arcade-ai.com] - Override the default base URL for the API.
+   * @param {string} [opts.baseURL=process.env['ARCADE_BASE_URL'] ?? https://api.arcade.dev] - Override the default base URL for the API.
    * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
    * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
    * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
@@ -124,7 +122,7 @@ export class Arcade extends Core.APIClient {
     const options: ClientOptions = {
       apiKey,
       ...opts,
-      baseURL: baseURL || `https://api.arcade-ai.com`,
+      baseURL: baseURL || `https://api.arcade.dev`,
     };
 
     super({
@@ -186,7 +184,7 @@ Arcade.Auth = Auth;
 Arcade.Health = Health;
 Arcade.Chat = Chat;
 Arcade.Tools = Tools;
-Arcade.ToolListResponsesOffsetPage = ToolListResponsesOffsetPage;
+Arcade.ToolDefinitionsOffsetPage = ToolDefinitionsOffsetPage;
 export declare namespace Arcade {
   export type RequestOptions = Core.RequestOptions;
 
@@ -216,18 +214,17 @@ export declare namespace Arcade {
     type AuthorizeToolRequest as AuthorizeToolRequest,
     type ExecuteToolRequest as ExecuteToolRequest,
     type ExecuteToolResponse as ExecuteToolResponse,
-    type ResponseOutput as ResponseOutput,
+    type ToolDefinition as ToolDefinition,
     type ToolExecution as ToolExecution,
     type ToolExecutionAttempt as ToolExecutionAttempt,
-    type ToolListResponse as ToolListResponse,
-    type ToolGetResponse as ToolGetResponse,
-    ToolListResponsesOffsetPage as ToolListResponsesOffsetPage,
+    type ValueSchema as ValueSchema,
+    ToolDefinitionsOffsetPage as ToolDefinitionsOffsetPage,
     type ToolListParams as ToolListParams,
     type ToolAuthorizeParams as ToolAuthorizeParams,
     type ToolExecuteParams as ToolExecuteParams,
-    type ToolGetParams as ToolGetParams,
   };
 
+  export type AuthorizationContext = API.AuthorizationContext;
   export type AuthorizationResponse = API.AuthorizationResponse;
   export type Error = API.Error;
 }

package/src/resources/auth.ts

@@ -1,10 +1,57 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../resource';
-import * as Core from '../core';
 import * as Shared from './shared';
+import * as Core from '../core';
+
+export const DEFAULT_LONGPOLL_WAIT_TIME = 45;
+
+/**
+ * Error thrown when authorization-related operations fail
+ */
+export class AuthorizationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'AuthorizationError';
+  }
+}
 
 export class Auth extends APIResource {
+  /**
+   * Starts the authorization process for a given provider and scopes.
+   * @param userId - The user ID for which authorization is being requested
+   * @param provider - The authorization provider (e.g., 'github', 'google', 'linkedin', 'microsoft', 'slack', 'spotify', 'x', 'zoom')
+   * @param options - Optional parameters
+   * @param options.providerType - The type of authorization provider. Defaults to 'oauth2'
+   * @param options.scopes - A list of scopes required for authorization, if any. Defaults to []
+   * @returns The authorization response
+   *
+   * Example:
+   * ```ts
+   * const authResponse = await client.auth.start("user@example.com", "github");
+   * ```
+   */
+  start(
+    userId: string,
+    provider: string,
+    options: AuthStartOptions = {},
+  ): Core.APIPromise<Shared.AuthorizationResponse> {
+    const { providerType = 'oauth2', scopes = [] } = options;
+
+    const authRequirement: AuthAuthorizeParams.AuthRequirement = {
+      provider_id: provider,
+      provider_type: providerType,
+      oauth2: {
+        scopes,
+      },
+    };
+
+    return this.authorize({
+      auth_requirement: authRequirement,
+      user_id: userId,
+    });
+  }
+
   /**
    * Starts the authorization process for given authorization requirements
    */
@@ -26,6 +73,52 @@ export class Auth extends APIResource {
   ): Core.APIPromise<Shared.AuthorizationResponse> {
     return this._client.get('/v1/auth/status', { query, ...options });
   }
+
+  /**
+   * Waits for the authorization process to complete.
+   * @param authResponseOrId - The authorization response or ID to wait for completion
+   * @returns The completed authorization response
+   * @throws {AuthorizationError} When the authorization ID is missing or invalid
+   *
+   * Example:
+   * ```ts
+   * const authResponse = await client.auth.start("user@example.com", "github");
+   * try {
+   *   const completedAuth = await client.auth.waitForCompletion(authResponse);
+   *   console.log('Authorization completed:', completedAuth);
+   * } catch (error) {
+   *   if (error instanceof AuthorizationError) {
+   *     console.error('Authorization failed:', error.message);
+   *   }
+   * }
+   * ```
+   */
+  async waitForCompletion(
+    authResponseOrId: Shared.AuthorizationResponse | string,
+  ): Promise<Shared.AuthorizationResponse> {
+    let authId: string;
+    let authResponse: Shared.AuthorizationResponse;
+
+    if (typeof authResponseOrId === 'string') {
+      authId = authResponseOrId;
+      authResponse = { status: 'pending' } as Shared.AuthorizationResponse;
+    } else {
+      if (!authResponseOrId.id) {
+        throw new AuthorizationError('Authorization ID is required');
+      }
+      authId = authResponseOrId.id;
+      authResponse = authResponseOrId;
+    }
+
+    while (authResponse.status !== 'completed') {
+      authResponse = await this.status({
+        id: authId,
+        wait: DEFAULT_LONGPOLL_WAIT_TIME,
+      });
+    }
+
+    return authResponse;
+  }
 }
 
 export interface AuthRequest {
@@ -36,8 +129,16 @@ export interface AuthRequest {
 
 export namespace AuthRequest {
   export interface AuthRequirement {
+    /**
+     * one of ID or ProviderID must be set
+     */
+    id?: string;
+
     oauth2?: AuthRequirement.Oauth2;
 
+    /**
+     * one of ID or ProviderID must be set
+     */
     provider_id?: string;
 
     provider_type?: string;
@@ -58,8 +159,16 @@ export interface AuthAuthorizeParams {
 
 export namespace AuthAuthorizeParams {
   export interface AuthRequirement {
+    /**
+     * one of ID or ProviderID must be set
+     */
+    id?: string;
+
     oauth2?: AuthRequirement.Oauth2;
 
+    /**
+     * one of ID or ProviderID must be set
+     */
     provider_id?: string;
 
     provider_type?: string;
@@ -76,17 +185,26 @@ export interface AuthStatusParams {
   /**
    * Authorization ID
    */
-  authorizationId: string;
+  id: string;
+
+  /**
+   * Timeout in seconds (max 59)
+   */
+  wait?: number;
+}
 
+export interface AuthStartOptions {
   /**
-   * Scopes
+   * The type of authorization provider
+   * @default 'oauth2'
    */
-  scopes?: string;
+  providerType?: string;
 
   /**
-   * Timeout in seconds (max 59)
+   * A list of scopes required for authorization
+   * @default []
    */
-  wait?: number;
+  scopes?: string[];
 }
 
 export declare namespace Auth {
@@ -94,5 +212,6 @@ export declare namespace Auth {
     type AuthRequest as AuthRequest,
     type AuthAuthorizeParams as AuthAuthorizeParams,
     type AuthStatusParams as AuthStatusParams,
+    type AuthStartOptions as AuthStartOptions,
   };
 }

package/src/resources/chat/chat.ts

@@ -88,7 +88,7 @@ export interface ChatRequest {
 
   presence_penalty?: number;
 
-  response_format?: 'json_object' | 'text';
+  response_format?: ChatRequest.ResponseFormat;
 
   seed?: number;
 
@@ -123,6 +123,10 @@ export interface ChatRequest {
 }
 
 export namespace ChatRequest {
+  export interface ResponseFormat {
+    type?: 'json_object' | 'text';
+  }
+
   /**
    * Options for streaming response. Only set this when you set stream: true.
    */

package/src/resources/chat/completions.ts

@@ -47,7 +47,7 @@ export interface CompletionCreateParams {
 
   presence_penalty?: number;
 
-  response_format?: 'json_object' | 'text';
+  response_format?: CompletionCreateParams.ResponseFormat;
 
   seed?: number;
 
@@ -82,6 +82,10 @@ export interface CompletionCreateParams {
 }
 
 export namespace CompletionCreateParams {
+  export interface ResponseFormat {
+    type?: 'json_object' | 'text';
+  }
+
   /**
    * Options for streaming response. Only set this when you set stream: true.
    */

package/src/resources/index.ts

@@ -12,18 +12,17 @@ export {
 } from './chat/chat';
 export { Health, type HealthSchema } from './health';
 export {
-  ToolListResponsesOffsetPage,
+  ToolExecutionsOffsetPage,
+  ToolDefinitionsOffsetPage,
   Tools,
   type AuthorizeToolRequest,
   type ExecuteToolRequest,
   type ExecuteToolResponse,
-  type ResponseOutput,
+  type ToolDefinition,
   type ToolExecution,
   type ToolExecutionAttempt,
-  type ToolListResponse,
-  type ToolGetResponse,
+  type ValueSchema,
   type ToolListParams,
   type ToolAuthorizeParams,
   type ToolExecuteParams,
-  type ToolGetParams,
 } from './tools/tools';

package/src/resources/shared.ts

@@ -1,11 +1,15 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export interface AuthorizationResponse {
-  authorization_id?: string;
+export interface AuthorizationContext {
+  token?: string;
+
+  user_info?: Record<string, unknown>;
+}
 
-  authorization_url?: string;
+export interface AuthorizationResponse {
+  id?: string;
 
-  context?: AuthorizationResponse.Context;
+  context?: AuthorizationContext;
 
   provider_id?: string;
 
@@ -13,15 +17,9 @@ export interface AuthorizationResponse {
 
   status?: 'pending' | 'completed' | 'failed';
 
-  user_id?: string;
-}
+  url?: string;
 
-export namespace AuthorizationResponse {
-  export interface Context {
-    token?: string;
-
-    user_info?: Record<string, unknown>;
-  }
+  user_id?: string;
 }
 
 export interface Error {

package/src/resources/tools/formatted.ts

@@ -24,7 +24,7 @@ export class Formatted extends APIResource {
     if (isRequestOptions(query)) {
       return this.list({}, query);
     }
-    return this._client.getAPIList('/v1/tools/formatted/list', FormattedListResponsesOffsetPage, {
+    return this._client.getAPIList('/v1/formatted_tools', FormattedListResponsesOffsetPage, {
       query,
       ...options,
     });
@@ -33,8 +33,17 @@ export class Formatted extends APIResource {
   /**
    * Returns the formatted tool specification for a specific tool, given a provider
    */
-  get(query: FormattedGetParams, options?: Core.RequestOptions): Core.APIPromise<unknown> {
-    return this._client.get('/v1/tools/formatted/definition', { query, ...options });
+  get(name: string, query?: FormattedGetParams, options?: Core.RequestOptions): Core.APIPromise<unknown>;
+  get(name: string, options?: Core.RequestOptions): Core.APIPromise<unknown>;
+  get(
+    name: string,
+    query: FormattedGetParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<unknown> {
+    if (isRequestOptions(query)) {
+      return this.get(name, {}, query);
+    }
+    return this._client.get(`/v1/formatted_tools/${name}`, { query, ...options });
   }
 }
 
@@ -57,11 +66,6 @@ export interface FormattedListParams extends OffsetPageParams {
 }
 
 export interface FormattedGetParams {
-  /**
-   * Tool ID
-   */
-  toolId: string;
-
   /**
    * Provider format
    */

package/src/resources/tools/index.ts

@@ -8,20 +8,19 @@ export {
   type FormattedListParams,
   type FormattedGetParams,
 } from './formatted';
-export { Scheduled, type ScheduledListResponse, type ScheduledDetailsResponse } from './scheduled';
+export { Scheduled, type ScheduledGetResponse, type ScheduledListParams } from './scheduled';
 export {
-  ToolListResponsesOffsetPage,
+  ToolExecutionsOffsetPage,
+  ToolDefinitionsOffsetPage,
   Tools,
   type AuthorizeToolRequest,
   type ExecuteToolRequest,
   type ExecuteToolResponse,
-  type ResponseOutput,
+  type ToolDefinition,
   type ToolExecution,
   type ToolExecutionAttempt,
-  type ToolListResponse,
-  type ToolGetResponse,
+  type ValueSchema,
   type ToolListParams,
   type ToolAuthorizeParams,
   type ToolExecuteParams,
-  type ToolGetParams,
 } from './tools';

package/src/resources/tools/scheduled.ts

@@ -1,55 +1,57 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../resource';
+import { isRequestOptions } from '../../core';
 import * as Core from '../../core';
 import * as ToolsAPI from './tools';
+import { ToolExecutionsOffsetPage } from './tools';
+import { type OffsetPageParams } from '../../pagination';
 
 export class Scheduled extends APIResource {
   /**
    * Returns a page of scheduled tool executions
    */
-  list(options?: Core.RequestOptions): Core.APIPromise<ScheduledListResponse> {
-    return this._client.get('/v1/tools/scheduled', options);
+  list(
+    query?: ScheduledListParams,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<ToolExecutionsOffsetPage, ToolsAPI.ToolExecution>;
+  list(options?: Core.RequestOptions): Core.PagePromise<ToolExecutionsOffsetPage, ToolsAPI.ToolExecution>;
+  list(
+    query: ScheduledListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<ToolExecutionsOffsetPage, ToolsAPI.ToolExecution> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
+    return this._client.getAPIList('/v1/scheduled_tools', ToolExecutionsOffsetPage, { query, ...options });
   }
 
   /**
    * Returns the details for a specific scheduled tool execution
    */
-  details(id: string, options?: Core.RequestOptions): Core.APIPromise<ScheduledDetailsResponse> {
-    return this._client.get(`/v1/tools/scheduled/${id}`, options);
+  get(id: string, options?: Core.RequestOptions): Core.APIPromise<ScheduledGetResponse> {
+    return this._client.get(`/v1/scheduled_tools/${id}`, options);
   }
 }
 
-export interface ScheduledListResponse {
-  items?: Array<ToolsAPI.ToolExecution>;
-
-  limit?: number;
-
-  offset?: number;
-
-  page_count?: number;
-
-  total_count?: number;
-}
-
-export interface ScheduledDetailsResponse {
+export interface ScheduledGetResponse {
   id?: string;
 
   attempts?: Array<ToolsAPI.ToolExecutionAttempt>;
 
-  created_at?: ScheduledDetailsResponse.CreatedAt;
+  created_at?: string;
 
   execution_status?: string;
 
   execution_type?: string;
 
-  finished_at?: ScheduledDetailsResponse.FinishedAt;
+  finished_at?: string;
 
-  inputs?: Record<string, unknown>;
+  input?: Record<string, unknown>;
 
-  run_at?: ScheduledDetailsResponse.RunAt;
+  run_at?: string;
 
-  started_at?: ScheduledDetailsResponse.StartedAt;
+  started_at?: string;
 
   tool_name?: string;
 
@@ -57,36 +59,18 @@ export interface ScheduledDetailsResponse {
 
   toolkit_version?: string;
 
-  updated_at?: ScheduledDetailsResponse.UpdatedAt;
+  updated_at?: string;
 
   user_id?: string;
 }
 
-export namespace ScheduledDetailsResponse {
-  export interface CreatedAt {
-    'time.Time'?: string;
-  }
-
-  export interface FinishedAt {
-    'time.Time'?: string;
-  }
-
-  export interface RunAt {
-    'time.Time'?: string;
-  }
-
-  export interface StartedAt {
-    'time.Time'?: string;
-  }
-
-  export interface UpdatedAt {
-    'time.Time'?: string;
-  }
-}
+export interface ScheduledListParams extends OffsetPageParams {}
 
 export declare namespace Scheduled {
   export {
-    type ScheduledListResponse as ScheduledListResponse,
-    type ScheduledDetailsResponse as ScheduledDetailsResponse,
+    type ScheduledGetResponse as ScheduledGetResponse,
+    type ScheduledListParams as ScheduledListParams,
   };
 }
+
+export { ToolExecutionsOffsetPage };