@arcadeai/arcadejs 0.2.0 → 0.2.2

package/src/resources/tools/tools.ts

@@ -4,7 +4,6 @@ import { APIResource } from '../../resource';
 import { isRequestOptions } from '../../core';
 import * as Core from '../../core';
 import * as Shared from '../shared';
-import { ToolDefinitionsOffsetPage } from '../shared';
 import * as FormattedAPI from './formatted';
 import {
   Formatted,
@@ -14,27 +13,31 @@ import {
   FormattedListResponse,
   FormattedListResponsesOffsetPage,
 } from './formatted';
-import { type OffsetPageParams } from '../../pagination';
+import * as ScheduledAPI from './scheduled';
+import { Scheduled, ScheduledDetailsResponse, ScheduledListResponse } 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/list', ToolListResponsesOffsetPage, { query, ...options });
   }
 
   /**
@@ -50,18 +53,20 @@ export class Tools extends APIResource {
   /**
    * 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> {
+  get(query: ToolGetParams, options?: Core.RequestOptions): Core.APIPromise<ToolGetResponse> {
     return this._client.get('/v1/tools/definition', { query, ...options });
   }
 }
 
+export class ToolListResponsesOffsetPage extends OffsetPage<ToolListResponse> {}
+
 export interface AuthorizeToolRequest {
   tool_name: string;
 
@@ -82,111 +87,340 @@ export interface ExecuteToolRequest {
   inputs?: 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?: ExecuteToolRequest.RunAt;
+
+  /**
+   * 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 namespace ExecuteToolRequest {
+  /**
+   * The time at which the tool should be run (optional). If not provided, the tool
+   * is run immediately
+   */
+  export interface RunAt {
+    'time.Time'?: string;
+  }
 }
 
-export interface Output {
-  available_modes?: Array<string>;
+export interface ExecuteToolResponse {
+  id?: string;
 
-  description?: string;
+  duration?: number;
 
-  value_schema?: ValueSchema;
+  execution_type?: string;
+
+  finished_at?: ExecuteToolResponse.FinishedAt;
+
+  invocation_id?: string;
+
+  output?: ResponseOutput;
+
+  run_at?: ExecuteToolResponse.RunAt;
+
+  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 Parameter {
-  name: string;
+export namespace ExecuteToolResponse {
+  export interface FinishedAt {
+    'time.Time'?: string;
+  }
 
-  value_schema: ValueSchema;
+  export interface RunAt {
+    'time.Time'?: string;
+  }
+}
 
-  description?: string;
+export interface ResponseOutput {
+  error?: ResponseOutput.Error;
 
-  inferrable?: boolean;
+  requires_authorization?: Shared.AuthorizationResponse;
 
-  required?: boolean;
+  value?: unknown;
 }
 
-export interface Requirements {
-  authorization?: Requirements.Authorization;
+export namespace ResponseOutput {
+  export interface Error {
+    message: string;
+
+    additional_prompt_content?: string;
+
+    can_retry?: boolean;
+
+    developer_message?: string;
+
+    retry_after_ms?: number;
+  }
 }
 
-export namespace Requirements {
-  export interface Authorization {
-    oauth2?: Authorization.Oauth2;
+export interface ToolExecution {
+  id?: string;
+
+  created_at?: ToolExecution.CreatedAt;
+
+  execution_status?: string;
+
+  execution_type?: string;
+
+  finished_at?: ToolExecution.FinishedAt;
+
+  run_at?: ToolExecution.RunAt;
+
+  started_at?: ToolExecution.StartedAt;
+
+  tool_name?: string;
+
+  toolkit_name?: string;
+
+  toolkit_version?: string;
+
+  updated_at?: ToolExecution.UpdatedAt;
 
-    provider_id?: string;
+  user_id?: string;
+}
 
-    provider_type?: string;
+export namespace ToolExecution {
+  export interface CreatedAt {
+    'time.Time'?: string;
   }
 
-  export namespace Authorization {
-    export interface Oauth2 {
-      scopes?: Array<string>;
-    }
+  export interface FinishedAt {
+    'time.Time'?: string;
   }
-}
 
-export interface Response {
-  invocation_id: string;
+  export interface RunAt {
+    'time.Time'?: string;
+  }
 
-  duration?: number;
+  export interface StartedAt {
+    'time.Time'?: string;
+  }
+
+  export interface UpdatedAt {
+    'time.Time'?: string;
+  }
+}
+
+export interface ToolExecutionAttempt {
+  id?: string;
 
-  finished_at?: Response.FinishedAt;
+  finished_at?: ToolExecutionAttempt.FinishedAt;
 
   output?: ResponseOutput;
 
+  started_at?: ToolExecutionAttempt.StartedAt;
+
   success?: boolean;
+
+  system_error_message?: string;
 }
 
-export namespace Response {
+export namespace ToolExecutionAttempt {
   export interface FinishedAt {
     'time.Time'?: string;
   }
+
+  export interface StartedAt {
+    'time.Time'?: string;
+  }
 }
 
-export interface ResponseOutput {
-  error?: ResponseOutput.Error;
+export interface ToolListResponse {
+  inputs: ToolListResponse.Inputs;
 
-  requires_authorization?: Shared.AuthorizationResponse;
+  name: string;
 
-  value?: unknown;
+  toolkit: ToolListResponse.Toolkit;
+
+  description?: string;
+
+  fully_qualified_name?: string;
+
+  output?: ToolListResponse.Output;
+
+  requirements?: ToolListResponse.Requirements;
 }
 
-export namespace ResponseOutput {
-  export interface Error {
-    message: string;
+export namespace ToolListResponse {
+  export interface Inputs {
+    parameters?: Array<Inputs.Parameter>;
+  }
 
-    additional_prompt_content?: string;
+  export namespace Inputs {
+    export interface Parameter {
+      name: string;
 
-    can_retry?: boolean;
+      value_schema: Parameter.ValueSchema;
 
-    developer_message?: string;
+      description?: string;
 
-    retry_after_ms?: number;
+      inferrable?: boolean;
+
+      required?: boolean;
+    }
+
+    export namespace Parameter {
+      export interface ValueSchema {
+        val_type: string;
+
+        enum?: Array<string>;
+
+        inner_val_type?: string;
+      }
+    }
+  }
+
+  export interface Toolkit {
+    name: string;
+
+    description?: string;
+
+    version?: string;
+  }
+
+  export interface Output {
+    available_modes?: Array<string>;
+
+    description?: string;
+
+    value_schema?: Output.ValueSchema;
+  }
+
+  export namespace Output {
+    export interface ValueSchema {
+      val_type: string;
+
+      enum?: Array<string>;
+
+      inner_val_type?: string;
+    }
+  }
+
+  export interface Requirements {
+    authorization?: Requirements.Authorization;
+  }
+
+  export namespace Requirements {
+    export interface Authorization {
+      oauth2?: Authorization.Oauth2;
+
+      provider_id?: string;
+
+      provider_type?: string;
+    }
+
+    export namespace Authorization {
+      export interface Oauth2 {
+        scopes?: Array<string>;
+      }
+    }
   }
 }
 
-export interface ToolkitDefinition {
+export interface ToolGetResponse {
+  inputs: ToolGetResponse.Inputs;
+
   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 Inputs {
+    parameters?: Array<Inputs.Parameter>;
+  }
+
+  export namespace Inputs {
+    export interface Parameter {
+      name: string;
+
+      value_schema: Parameter.ValueSchema;
 
-  enum?: Array<string>;
+      description?: string;
 
-  inner_val_type?: string;
+      inferrable?: boolean;
+
+      required?: boolean;
+    }
+
+    export namespace Parameter {
+      export interface ValueSchema {
+        val_type: string;
+
+        enum?: Array<string>;
+
+        inner_val_type?: string;
+      }
+    }
+  }
+
+  export interface Toolkit {
+    name: string;
+
+    description?: string;
+
+    version?: string;
+  }
+
+  export interface Output {
+    available_modes?: Array<string>;
+
+    description?: string;
+
+    value_schema?: Output.ValueSchema;
+  }
+
+  export namespace Output {
+    export interface ValueSchema {
+      val_type: string;
+
+      enum?: Array<string>;
+
+      inner_val_type?: string;
+    }
+  }
+
+  export interface Requirements {
+    authorization?: Requirements.Authorization;
+  }
+
+  export namespace Requirements {
+    export interface Authorization {
+      oauth2?: Authorization.Oauth2;
+
+      provider_id?: string;
+
+      provider_type?: string;
+    }
+
+    export namespace Authorization {
+      export interface Oauth2 {
+        scopes?: Array<string>;
+      }
+    }
+  }
 }
 
 export interface ToolListParams extends OffsetPageParams {
@@ -216,13 +450,29 @@ export interface ToolExecuteParams {
   inputs?: 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?: ToolExecuteParams.RunAt;
+
+  /**
+   * The tool version to use (optional). If not provided, any version is used
    */
   tool_version?: string;
 
   user_id?: string;
 }
 
+export namespace ToolExecuteParams {
+  /**
+   * The time at which the tool should be run (optional). If not provided, the tool
+   * is run immediately
+   */
+  export interface RunAt {
+    'time.Time'?: string;
+  }
+}
+
 export interface ToolGetParams {
   /**
    * Tool ID
@@ -230,6 +480,8 @@ export interface ToolGetParams {
   toolId: string;
 }
 
+Tools.ToolListResponsesOffsetPage = ToolListResponsesOffsetPage;
+Tools.Scheduled = Scheduled;
 Tools.Formatted = Formatted;
 Tools.FormattedListResponsesOffsetPage = FormattedListResponsesOffsetPage;
 
@@ -237,20 +489,25 @@ 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 ExecuteToolResponse as ExecuteToolResponse,
     type ResponseOutput as ResponseOutput,
-    type ToolkitDefinition as ToolkitDefinition,
-    type ValueSchema as ValueSchema,
+    type ToolExecution as ToolExecution,
+    type ToolExecutionAttempt as ToolExecutionAttempt,
+    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 ScheduledListResponse as ScheduledListResponse,
+    type ScheduledDetailsResponse as ScheduledDetailsResponse,
+  };
+
   export {
     Formatted as Formatted,
     type FormattedListResponse as FormattedListResponse,
@@ -260,5 +517,3 @@ export declare namespace Tools {
     type FormattedGetParams as FormattedGetParams,
   };
 }
-
-export { ToolDefinitionsOffsetPage };

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.2.0'; // x-release-please-version
+export const VERSION = '0.2.2'; // x-release-please-version

package/version.d.ts

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

package/version.js

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

package/version.mjs

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