@arcadeai/arcadejs 0.2.2 → 1.0.0

package/src/resources/tools/tools.ts

@@ -3,6 +3,7 @@
 import { APIResource } from '../../resource';
 import { isRequestOptions } from '../../core';
 import * as Core from '../../core';
+import * as ToolsAPI from './tools';
 import * as Shared from '../shared';
 import * as FormattedAPI from './formatted';
 import {
@@ -14,7 +15,7 @@ import {
   FormattedListResponsesOffsetPage,
 } from './formatted';
 import * as ScheduledAPI from './scheduled';
-import { Scheduled, ScheduledDetailsResponse, ScheduledListResponse } from './scheduled';
+import { Scheduled, ScheduledGetResponse, ScheduledListParams } from './scheduled';
 import { OffsetPage, type OffsetPageParams } from '../../pagination';
 
 export class Tools extends APIResource {
@@ -28,16 +29,16 @@ export class Tools extends APIResource {
   list(
     query?: ToolListParams,
     options?: Core.RequestOptions,
-  ): Core.PagePromise<ToolListResponsesOffsetPage, ToolListResponse>;
-  list(options?: Core.RequestOptions): Core.PagePromise<ToolListResponsesOffsetPage, ToolListResponse>;
+  ): Core.PagePromise<ToolDefinitionsOffsetPage, ToolDefinition>;
+  list(options?: Core.RequestOptions): Core.PagePromise<ToolDefinitionsOffsetPage, ToolDefinition>;
   list(
     query: ToolListParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
-  ): Core.PagePromise<ToolListResponsesOffsetPage, ToolListResponse> {
+  ): Core.PagePromise<ToolDefinitionsOffsetPage, ToolDefinition> {
     if (isRequestOptions(query)) {
       return this.list({}, query);
     }
-    return this._client.getAPIList('/v1/tools/list', ToolListResponsesOffsetPage, { query, ...options });
+    return this._client.getAPIList('/v1/tools', ToolDefinitionsOffsetPage, { query, ...options });
   }
 
   /**
@@ -60,22 +61,27 @@ export class Tools extends APIResource {
   /**
    * Returns the arcade tool specification for a specific tool
    */
-  get(query: ToolGetParams, options?: Core.RequestOptions): Core.APIPromise<ToolGetResponse> {
-    return this._client.get('/v1/tools/definition', { query, ...options });
+  get(name: string, options?: Core.RequestOptions): Core.APIPromise<ToolDefinition> {
+    return this._client.get(`/v1/tools/${name}`, options);
   }
 }
 
-export class ToolListResponsesOffsetPage extends OffsetPage<ToolListResponse> {}
+export class ToolDefinitionsOffsetPage extends OffsetPage<ToolDefinition> {}
+
+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 {
@@ -84,13 +90,13 @@ export interface ExecuteToolRequest {
   /**
    * JSON input to the tool, if any
    */
-  inputs?: unknown;
+  input?: Record<string, unknown>;
 
   /**
    * The time at which the tool should be run (optional). If not provided, the tool
    * is run immediately
    */
-  run_at?: ExecuteToolRequest.RunAt;
+  run_at?: string;
 
   /**
    * The tool version to use (optional). If not provided, any version is used
@@ -100,30 +106,20 @@ export interface ExecuteToolRequest {
   user_id?: string;
 }
 
-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 ExecuteToolResponse {
   id?: string;
 
   duration?: number;
 
-  execution_type?: string;
+  execution_id?: string;
 
-  finished_at?: ExecuteToolResponse.FinishedAt;
+  execution_type?: string;
 
-  invocation_id?: string;
+  finished_at?: string;
 
-  output?: ResponseOutput;
+  output?: ExecuteToolResponse.Output;
 
-  run_at?: ExecuteToolResponse.RunAt;
+  run_at?: string;
 
   status?: string;
 
@@ -136,135 +132,55 @@ export interface ExecuteToolResponse {
 }
 
 export namespace ExecuteToolResponse {
-  export interface FinishedAt {
-    'time.Time'?: string;
-  }
-
-  export interface RunAt {
-    'time.Time'?: string;
-  }
-}
-
-export interface ResponseOutput {
-  error?: ResponseOutput.Error;
-
-  requires_authorization?: Shared.AuthorizationResponse;
-
-  value?: unknown;
-}
-
-export namespace ResponseOutput {
-  export interface Error {
-    message: string;
-
-    additional_prompt_content?: string;
-
-    can_retry?: boolean;
-
-    developer_message?: string;
-
-    retry_after_ms?: number;
-  }
-}
-
-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;
-
-  user_id?: string;
-}
-
-export namespace ToolExecution {
-  export interface CreatedAt {
-    'time.Time'?: string;
-  }
-
-  export interface FinishedAt {
-    'time.Time'?: string;
-  }
+  export interface Output {
+    authorization?: Shared.AuthorizationResponse;
 
-  export interface RunAt {
-    'time.Time'?: string;
-  }
+    error?: Output.Error;
 
-  export interface StartedAt {
-    'time.Time'?: string;
+    value?: unknown;
   }
 
-  export interface UpdatedAt {
-    'time.Time'?: string;
-  }
-}
-
-export interface ToolExecutionAttempt {
-  id?: string;
-
-  finished_at?: ToolExecutionAttempt.FinishedAt;
-
-  output?: ResponseOutput;
+  export namespace Output {
+    export interface Error {
+      message: string;
 
-  started_at?: ToolExecutionAttempt.StartedAt;
+      additional_prompt_content?: string;
 
-  success?: boolean;
+      can_retry?: boolean;
 
-  system_error_message?: string;
-}
+      developer_message?: string;
 
-export namespace ToolExecutionAttempt {
-  export interface FinishedAt {
-    'time.Time'?: string;
-  }
-
-  export interface StartedAt {
-    'time.Time'?: string;
+      retry_after_ms?: number;
+    }
   }
 }
 
-export interface ToolListResponse {
-  inputs: ToolListResponse.Inputs;
+export interface ToolDefinition {
+  input: ToolDefinition.Input;
 
   name: string;
 
-  toolkit: ToolListResponse.Toolkit;
+  toolkit: ToolDefinition.Toolkit;
 
   description?: string;
 
   fully_qualified_name?: string;
 
-  output?: ToolListResponse.Output;
+  output?: ToolDefinition.Output;
 
-  requirements?: ToolListResponse.Requirements;
+  requirements?: ToolDefinition.Requirements;
 }
 
-export namespace ToolListResponse {
-  export interface Inputs {
-    parameters?: Array<Inputs.Parameter>;
+export namespace ToolDefinition {
+  export interface Input {
+    parameters?: Array<Input.Parameter>;
   }
 
-  export namespace Inputs {
+  export namespace Input {
     export interface Parameter {
       name: string;
 
-      value_schema: Parameter.ValueSchema;
+      value_schema: ToolsAPI.ValueSchema;
 
       description?: string;
 
@@ -272,16 +188,6 @@ export namespace ToolListResponse {
 
       required?: boolean;
     }
-
-    export namespace Parameter {
-      export interface ValueSchema {
-        val_type: string;
-
-        enum?: Array<string>;
-
-        inner_val_type?: string;
-      }
-    }
   }
 
   export interface Toolkit {
@@ -297,17 +203,7 @@ export namespace ToolListResponse {
 
     description?: string;
 
-    value_schema?: Output.ValueSchema;
-  }
-
-  export namespace Output {
-    export interface ValueSchema {
-      val_type: string;
-
-      enum?: Array<string>;
-
-      inner_val_type?: string;
-    }
+    value_schema?: ToolsAPI.ValueSchema;
   }
 
   export interface Requirements {
@@ -316,6 +212,8 @@ export namespace ToolListResponse {
 
   export namespace Requirements {
     export interface Authorization {
+      id?: string;
+
       oauth2?: Authorization.Oauth2;
 
       provider_id?: string;
@@ -331,96 +229,76 @@ export namespace ToolListResponse {
   }
 }
 
-export interface ToolGetResponse {
-  inputs: ToolGetResponse.Inputs;
-
-  name: string;
+export interface ToolExecution {
+  id?: string;
 
-  toolkit: ToolGetResponse.Toolkit;
+  created_at?: string;
 
-  description?: string;
+  execution_status?: string;
 
-  fully_qualified_name?: string;
+  execution_type?: string;
 
-  output?: ToolGetResponse.Output;
+  finished_at?: string;
 
-  requirements?: ToolGetResponse.Requirements;
-}
+  run_at?: string;
 
-export namespace ToolGetResponse {
-  export interface Inputs {
-    parameters?: Array<Inputs.Parameter>;
-  }
+  started_at?: string;
 
-  export namespace Inputs {
-    export interface Parameter {
-      name: string;
+  tool_name?: string;
 
-      value_schema: Parameter.ValueSchema;
+  toolkit_name?: string;
 
-      description?: string;
+  toolkit_version?: string;
 
-      inferrable?: boolean;
+  updated_at?: string;
 
-      required?: boolean;
-    }
+  user_id?: string;
+}
 
-    export namespace Parameter {
-      export interface ValueSchema {
-        val_type: string;
+export interface ToolExecutionAttempt {
+  id?: string;
 
-        enum?: Array<string>;
+  finished_at?: string;
 
-        inner_val_type?: string;
-      }
-    }
-  }
+  output?: ToolExecutionAttempt.Output;
 
-  export interface Toolkit {
-    name: string;
+  started_at?: string;
 
-    description?: string;
+  success?: boolean;
 
-    version?: string;
-  }
+  system_error_message?: string;
+}
 
+export namespace ToolExecutionAttempt {
   export interface Output {
-    available_modes?: Array<string>;
+    authorization?: Shared.AuthorizationResponse;
 
-    description?: string;
+    error?: Output.Error;
 
-    value_schema?: Output.ValueSchema;
+    value?: unknown;
   }
 
   export namespace Output {
-    export interface ValueSchema {
-      val_type: string;
+    export interface Error {
+      message: string;
 
-      enum?: Array<string>;
+      additional_prompt_content?: string;
 
-      inner_val_type?: string;
-    }
-  }
+      can_retry?: boolean;
 
-  export interface Requirements {
-    authorization?: Requirements.Authorization;
-  }
+      developer_message?: string;
 
-  export namespace Requirements {
-    export interface Authorization {
-      oauth2?: Authorization.Oauth2;
+      retry_after_ms?: number;
+    }
+  }
+}
 
-      provider_id?: string;
+export interface ValueSchema {
+  val_type: string;
 
-      provider_type?: string;
-    }
+  enum?: Array<string>;
 
-    export namespace Authorization {
-      export interface Oauth2 {
-        scopes?: Array<string>;
-      }
-    }
-  }
+  inner_val_type?: string;
 }
 
 export interface ToolListParams extends OffsetPageParams {
@@ -433,12 +311,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 {
@@ -447,13 +328,13 @@ export interface ToolExecuteParams {
   /**
    * JSON input to the tool, if any
    */
-  inputs?: unknown;
+  input?: Record<string, unknown>;
 
   /**
    * The time at which the tool should be run (optional). If not provided, the tool
    * is run immediately
    */
-  run_at?: ToolExecuteParams.RunAt;
+  run_at?: string;
 
   /**
    * The tool version to use (optional). If not provided, any version is used
@@ -463,24 +344,7 @@ export interface ToolExecuteParams {
   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
-   */
-  toolId: string;
-}
-
-Tools.ToolListResponsesOffsetPage = ToolListResponsesOffsetPage;
+Tools.ToolDefinitionsOffsetPage = ToolDefinitionsOffsetPage;
 Tools.Scheduled = Scheduled;
 Tools.Formatted = Formatted;
 Tools.FormattedListResponsesOffsetPage = FormattedListResponsesOffsetPage;
@@ -490,22 +354,20 @@ export declare namespace Tools {
     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 {
     Scheduled as Scheduled,
-    type ScheduledListResponse as ScheduledListResponse,
-    type ScheduledDetailsResponse as ScheduledDetailsResponse,
+    type ScheduledGetResponse as ScheduledGetResponse,
+    type ScheduledListParams as ScheduledListParams,
   };
 
   export {

package/src/version.ts

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

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.2.2";
+export declare const VERSION = "1.0.0";
 //# 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.2'; // x-release-please-version
+exports.VERSION = '1.0.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

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