@arcadeai/arcadejs 0.2.1 → 1.0.0-rc.1

package/src/resources/tools/scheduled.ts

@@ -0,0 +1,76 @@
+// 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(
+    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
+   */
+  get(id: string, options?: Core.RequestOptions): Core.APIPromise<ScheduledGetResponse> {
+    return this._client.get(`/v1/scheduled_tools/${id}`, options);
+  }
+}
+
+export interface ScheduledGetResponse {
+  id?: string;
+
+  attempts?: Array<ToolsAPI.ToolExecutionAttempt>;
+
+  created_at?: string;
+
+  execution_status?: string;
+
+  execution_type?: string;
+
+  finished_at?: string;
+
+  input?: Record<string, unknown>;
+
+  run_at?: string;
+
+  started_at?: string;
+
+  tool_name?: string;
+
+  toolkit_name?: string;
+
+  toolkit_version?: string;
+
+  updated_at?: string;
+
+  user_id?: string;
+}
+
+export interface ScheduledListParams extends OffsetPageParams {}
+
+export declare namespace Scheduled {
+  export {
+    type ScheduledGetResponse as ScheduledGetResponse,
+    type ScheduledListParams as ScheduledListParams,
+  };
+}
+
+export { ToolExecutionsOffsetPage };

package/src/resources/tools/tools.ts

@@ -3,8 +3,8 @@
 import { APIResource } from '../../resource';
 import { isRequestOptions } from '../../core';
 import * as Core from '../../core';
+import * as ToolsAPI from './tools';
 import * as Shared from '../shared';
-import { ToolDefinitionsOffsetPage } from '../shared';
 import * as FormattedAPI from './formatted';
 import {
   Formatted,
@@ -14,27 +14,31 @@ import {
   FormattedListResponse,
   FormattedListResponsesOffsetPage,
 } from './formatted';
-import { type OffsetPageParams } from '../../pagination';
+import * as ScheduledAPI from './scheduled';
+import { Scheduled, ScheduledGetResponse, ScheduledListParams } from './scheduled';
+import { OffsetPage, type OffsetPageParams } from '../../pagination';
 
 export class Tools extends APIResource {
+  scheduled: ScheduledAPI.Scheduled = new ScheduledAPI.Scheduled(this._client);
   formatted: FormattedAPI.Formatted = new FormattedAPI.Formatted(this._client);
 
   /**
-   * Returns a page of tools, optionally filtered by toolkit
+   * Returns a page of tools from the engine configuration, optionally filtered by
+   * toolkit
    */
   list(
     query?: ToolListParams,
     options?: Core.RequestOptions,
-  ): Core.PagePromise<ToolDefinitionsOffsetPage, Shared.ToolDefinition>;
-  list(options?: Core.RequestOptions): Core.PagePromise<ToolDefinitionsOffsetPage, Shared.ToolDefinition>;
+  ): Core.PagePromise<ToolListResponsesOffsetPage, ToolListResponse>;
+  list(options?: Core.RequestOptions): Core.PagePromise<ToolListResponsesOffsetPage, ToolListResponse>;
   list(
     query: ToolListParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
-  ): Core.PagePromise<ToolDefinitionsOffsetPage, Shared.ToolDefinition> {
+  ): Core.PagePromise<ToolListResponsesOffsetPage, ToolListResponse> {
     if (isRequestOptions(query)) {
       return this.list({}, query);
     }
-    return this._client.getAPIList('/v1/tools/list', ToolDefinitionsOffsetPage, { query, ...options });
+    return this._client.getAPIList('/v1/tools', ToolListResponsesOffsetPage, { query, ...options });
   }
 
   /**
@@ -43,34 +47,41 @@ export class Tools extends APIResource {
   authorize(
     body: ToolAuthorizeParams,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<Shared.AuthorizationResponse> {
+  ): Core.APIPromise<Shared.AuthAuthorizationResponse> {
     return this._client.post('/v1/tools/authorize', { body, ...options });
   }
 
   /**
    * Executes a tool by name and arguments
    */
-  execute(body: ToolExecuteParams, options?: Core.RequestOptions): Core.APIPromise<Response> {
+  execute(body: ToolExecuteParams, options?: Core.RequestOptions): Core.APIPromise<ExecuteToolResponse> {
     return this._client.post('/v1/tools/execute', { body, ...options });
   }
 
   /**
    * Returns the arcade tool specification for a specific tool
    */
-  get(query: ToolGetParams, options?: Core.RequestOptions): Core.APIPromise<Shared.ToolDefinition> {
-    return this._client.get('/v1/tools/definition', { query, ...options });
+  get(name: string, options?: Core.RequestOptions): Core.APIPromise<ToolGetResponse> {
+    return this._client.get(`/v1/tools/${name}`, options);
   }
 }
 
+export class ToolListResponsesOffsetPage extends OffsetPage<ToolListResponse> {}
+
+export class ToolExecutionsOffsetPage extends OffsetPage<ToolExecution> {}
+
 export interface AuthorizeToolRequest {
   tool_name: string;
 
-  user_id: string;
-
   /**
    * Optional: if not provided, any version is used
    */
   tool_version?: string;
+
+  /**
+   * Required only when calling with an API key
+   */
+  user_id?: string;
 }
 
 export interface ExecuteToolRequest {
@@ -79,114 +90,289 @@ export interface ExecuteToolRequest {
   /**
    * JSON input to the tool, if any
    */
-  inputs?: unknown;
+  input?: Record<string, unknown>;
 
   /**
-   * Optional: if not provided, any version is used
+   * The time at which the tool should be run (optional). If not provided, the tool
+   * is run immediately
+   */
+  run_at?: string;
+
+  /**
+   * The tool version to use (optional). If not provided, any version is used
    */
   tool_version?: string;
 
   user_id?: string;
 }
 
-export interface Inputs {
-  parameters?: Array<Parameter>;
+export interface ExecuteToolResponse {
+  id?: string;
+
+  duration?: number;
+
+  execution_id?: string;
+
+  execution_type?: string;
+
+  finished_at?: string;
+
+  output?: ExecuteToolResponse.Output;
+
+  run_at?: string;
+
+  status?: string;
+
+  /**
+   * Whether the request was successful. For immediately-executed requests, this will
+   * be true if the tool call succeeded. For scheduled requests, this will be true if
+   * the request was scheduled successfully.
+   */
+  success?: boolean;
 }
 
-export interface Output {
-  available_modes?: Array<string>;
+export namespace ExecuteToolResponse {
+  export interface Output {
+    authorization?: Shared.AuthAuthorizationResponse;
 
-  description?: string;
+    error?: Output.Error;
+
+    value?: unknown;
+  }
 
-  value_schema?: ValueSchema;
+  export namespace Output {
+    export interface Error {
+      message: string;
+
+      additional_prompt_content?: string;
+
+      can_retry?: boolean;
+
+      developer_message?: string;
+
+      retry_after_ms?: number;
+    }
+  }
 }
 
-export interface Parameter {
-  name: string;
+export interface ToolExecution {
+  id?: string;
 
-  value_schema: ValueSchema;
+  created_at?: string;
 
-  description?: string;
+  execution_status?: string;
 
-  inferrable?: boolean;
+  execution_type?: string;
 
-  required?: boolean;
+  finished_at?: string;
+
+  run_at?: string;
+
+  started_at?: string;
+
+  tool_name?: string;
+
+  toolkit_name?: string;
+
+  toolkit_version?: string;
+
+  updated_at?: string;
+
+  user_id?: string;
 }
 
-export interface Requirements {
-  authorization?: Requirements.Authorization;
+export interface ToolExecutionAttempt {
+  id?: string;
+
+  finished_at?: string;
+
+  output?: ToolExecutionAttempt.Output;
+
+  started_at?: string;
+
+  success?: boolean;
+
+  system_error_message?: string;
 }
 
-export namespace Requirements {
-  export interface Authorization {
-    oauth2?: Authorization.Oauth2;
+export namespace ToolExecutionAttempt {
+  export interface Output {
+    authorization?: Shared.AuthAuthorizationResponse;
 
-    provider_id?: string;
+    error?: Output.Error;
 
-    provider_type?: string;
+    value?: unknown;
   }
 
-  export namespace Authorization {
-    export interface Oauth2 {
-      scopes?: Array<string>;
+  export namespace Output {
+    export interface Error {
+      message: string;
+
+      additional_prompt_content?: string;
+
+      can_retry?: boolean;
+
+      developer_message?: string;
+
+      retry_after_ms?: number;
     }
   }
 }
 
-export interface Response {
-  invocation_id: string;
+export interface ValueSchema {
+  val_type: string;
 
-  duration?: number;
+  enum?: Array<string>;
 
-  finished_at?: Response.FinishedAt;
+  inner_val_type?: string;
+}
 
-  output?: ResponseOutput;
+export interface ToolListResponse {
+  input: ToolListResponse.Input;
 
-  success?: boolean;
+  name: string;
+
+  toolkit: ToolListResponse.Toolkit;
+
+  description?: string;
+
+  fully_qualified_name?: string;
+
+  output?: ToolListResponse.Output;
+
+  requirements?: ToolListResponse.Requirements;
 }
 
-export namespace Response {
-  export interface FinishedAt {
-    'time.Time'?: string;
+export namespace ToolListResponse {
+  export interface Input {
+    parameters?: Array<Input.Parameter>;
   }
-}
 
-export interface ResponseOutput {
-  error?: ResponseOutput.Error;
+  export namespace Input {
+    export interface Parameter {
+      name: string;
 
-  requires_authorization?: Shared.AuthorizationResponse;
+      value_schema: ToolsAPI.ValueSchema;
 
-  value?: unknown;
-}
+      description?: string;
 
-export namespace ResponseOutput {
-  export interface Error {
-    message: string;
+      inferrable?: boolean;
 
-    additional_prompt_content?: string;
+      required?: boolean;
+    }
+  }
 
-    can_retry?: boolean;
+  export interface Toolkit {
+    name: string;
 
-    developer_message?: string;
+    description?: string;
+
+    version?: string;
+  }
+
+  export interface Output {
+    available_modes?: Array<string>;
+
+    description?: string;
+
+    value_schema?: ToolsAPI.ValueSchema;
+  }
 
-    retry_after_ms?: number;
+  export interface Requirements {
+    authorization?: Requirements.Authorization;
+  }
+
+  export namespace Requirements {
+    export interface Authorization {
+      id?: string;
+
+      oauth2?: Authorization.Oauth2;
+
+      provider_id?: string;
+
+      provider_type?: string;
+    }
+
+    export namespace Authorization {
+      export interface Oauth2 {
+        scopes?: Array<string>;
+      }
+    }
   }
 }
 
-export interface ToolkitDefinition {
+export interface ToolGetResponse {
+  input: ToolGetResponse.Input;
+
   name: string;
 
+  toolkit: ToolGetResponse.Toolkit;
+
   description?: string;
 
-  version?: string;
+  fully_qualified_name?: string;
+
+  output?: ToolGetResponse.Output;
+
+  requirements?: ToolGetResponse.Requirements;
 }
 
-export interface ValueSchema {
-  val_type: string;
+export namespace ToolGetResponse {
+  export interface Input {
+    parameters?: Array<Input.Parameter>;
+  }
 
-  enum?: Array<string>;
+  export namespace Input {
+    export interface Parameter {
+      name: string;
 
-  inner_val_type?: string;
+      value_schema: ToolsAPI.ValueSchema;
+
+      description?: string;
+
+      inferrable?: boolean;
+
+      required?: boolean;
+    }
+  }
+
+  export interface Toolkit {
+    name: string;
+
+    description?: string;
+
+    version?: string;
+  }
+
+  export interface Output {
+    available_modes?: Array<string>;
+
+    description?: string;
+
+    value_schema?: ToolsAPI.ValueSchema;
+  }
+
+  export interface Requirements {
+    authorization?: Requirements.Authorization;
+  }
+
+  export namespace Requirements {
+    export interface Authorization {
+      id?: string;
+
+      oauth2?: Authorization.Oauth2;
+
+      provider_id?: string;
+
+      provider_type?: string;
+    }
+
+    export namespace Authorization {
+      export interface Oauth2 {
+        scopes?: Array<string>;
+      }
+    }
+  }
 }
 
 export interface ToolListParams extends OffsetPageParams {
@@ -199,12 +385,15 @@ export interface ToolListParams extends OffsetPageParams {
 export interface ToolAuthorizeParams {
   tool_name: string;
 
-  user_id: string;
-
   /**
    * Optional: if not provided, any version is used
    */
   tool_version?: string;
+
+  /**
+   * Required only when calling with an API key
+   */
+  user_id?: string;
 }
 
 export interface ToolExecuteParams {
@@ -213,23 +402,24 @@ export interface ToolExecuteParams {
   /**
    * JSON input to the tool, if any
    */
-  inputs?: unknown;
+  input?: Record<string, unknown>;
 
   /**
-   * Optional: if not provided, any version is used
+   * The time at which the tool should be run (optional). If not provided, the tool
+   * is run immediately
    */
-  tool_version?: string;
-
-  user_id?: string;
-}
+  run_at?: string;
 
-export interface ToolGetParams {
   /**
-   * Tool ID
+   * The tool version to use (optional). If not provided, any version is used
    */
-  toolId: string;
+  tool_version?: string;
+
+  user_id?: string;
 }
 
+Tools.ToolListResponsesOffsetPage = ToolListResponsesOffsetPage;
+Tools.Scheduled = Scheduled;
 Tools.Formatted = Formatted;
 Tools.FormattedListResponsesOffsetPage = FormattedListResponsesOffsetPage;
 
@@ -237,18 +427,22 @@ export declare namespace Tools {
   export {
     type AuthorizeToolRequest as AuthorizeToolRequest,
     type ExecuteToolRequest as ExecuteToolRequest,
-    type Inputs as Inputs,
-    type Output as Output,
-    type Parameter as Parameter,
-    type Requirements as Requirements,
-    type Response as Response,
-    type ResponseOutput as ResponseOutput,
-    type ToolkitDefinition as ToolkitDefinition,
+    type ExecuteToolResponse as ExecuteToolResponse,
+    type ToolExecution as ToolExecution,
+    type ToolExecutionAttempt as ToolExecutionAttempt,
     type ValueSchema as ValueSchema,
+    type ToolListResponse as ToolListResponse,
+    type ToolGetResponse as ToolGetResponse,
+    ToolListResponsesOffsetPage as ToolListResponsesOffsetPage,
     type ToolListParams as ToolListParams,
     type ToolAuthorizeParams as ToolAuthorizeParams,
     type ToolExecuteParams as ToolExecuteParams,
-    type ToolGetParams as ToolGetParams,
+  };
+
+  export {
+    Scheduled as Scheduled,
+    type ScheduledGetResponse as ScheduledGetResponse,
+    type ScheduledListParams as ScheduledListParams,
   };
 
   export {
@@ -260,5 +454,3 @@ export declare namespace Tools {
     type FormattedGetParams as FormattedGetParams,
   };
 }
-
-export { ToolDefinitionsOffsetPage };

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.2.1'; // x-release-please-version
+export const VERSION = '1.0.0-rc.1'; // x-release-please-version

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.2.1";
+export declare const VERSION = "1.0.0-rc.1";
 //# sourceMappingURL=version.d.ts.map

package/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,eAAe,CAAC"}

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.2.1'; // x-release-please-version
+exports.VERSION = '1.0.0-rc.1'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,OAAO,CAAC,CAAC,2BAA2B"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,YAAY,CAAC,CAAC,2BAA2B"}

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.2.1'; // x-release-please-version
+export const VERSION = '1.0.0-rc.1'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map

package/version.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"version.mjs","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,2BAA2B"}
+{"version":3,"file":"version.mjs","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,YAAY,CAAC,CAAC,2BAA2B"}