@arcadeai/arcadejs 1.14.0 → 2.1.0

package/src/internal/utils/path.ts

@@ -0,0 +1,88 @@
+import { ArcadeError } from '../../core/error';
+
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+export function encodeURIPath(str: string) {
+  return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+
+const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
+
+export const createPathTagFunction = (pathEncoder = encodeURIPath) =>
+  function path(statics: readonly string[], ...params: readonly unknown[]): string {
+    // If there are no params, no processing is needed.
+    if (statics.length === 1) return statics[0]!;
+
+    let postPath = false;
+    const invalidSegments = [];
+    const path = statics.reduce((previousValue, currentValue, index) => {
+      if (/[?#]/.test(currentValue)) {
+        postPath = true;
+      }
+      const value = params[index];
+      let encoded = (postPath ? encodeURIComponent : pathEncoder)('' + value);
+      if (
+        index !== params.length &&
+        (value == null ||
+          (typeof value === 'object' &&
+            // handle values from other realms
+            value.toString ===
+              Object.getPrototypeOf(Object.getPrototypeOf((value as any).hasOwnProperty ?? EMPTY) ?? EMPTY)
+                ?.toString))
+      ) {
+        encoded = value + '';
+        invalidSegments.push({
+          start: previousValue.length + currentValue.length,
+          length: encoded.length,
+          error: `Value of type ${Object.prototype.toString
+            .call(value)
+            .slice(8, -1)} is not a valid path parameter`,
+        });
+      }
+      return previousValue + currentValue + (index === params.length ? '' : encoded);
+    }, '');
+
+    const pathOnly = path.split(/[?#]/, 1)[0]!;
+    const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+    let match;
+
+    // Find all invalid segments
+    while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+      invalidSegments.push({
+        start: match.index,
+        length: match[0].length,
+        error: `Value "${match[0]}" can\'t be safely passed as a path parameter`,
+      });
+    }
+
+    invalidSegments.sort((a, b) => a.start - b.start);
+
+    if (invalidSegments.length > 0) {
+      let lastEnd = 0;
+      const underline = invalidSegments.reduce((acc, segment) => {
+        const spaces = ' '.repeat(segment.start - lastEnd);
+        const arrows = '^'.repeat(segment.length);
+        lastEnd = segment.start + segment.length;
+        return acc + spaces + arrows;
+      }, '');
+
+      throw new ArcadeError(
+        `Path parameters result in path with invalid segments:\n${invalidSegments
+          .map((e) => e.error)
+          .join('\n')}\n${path}\n${underline}`,
+      );
+    }
+
+    return path;
+  };
+
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+export const path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);

package/src/internal/utils/sleep.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

package/src/internal/utils/uuid.ts

@@ -0,0 +1,17 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export let uuid4 = function () {
+  const { crypto } = globalThis as any;
+  if (crypto?.randomUUID) {
+    uuid4 = crypto.randomUUID.bind(crypto);
+    return crypto.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0]! : () => (Math.random() * 0xff) & 0xff;
+  return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) =>
+    (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16),
+  );
+};

package/src/internal/utils/values.ts

@@ -0,0 +1,105 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { ArcadeError } from '../../core/error';
+
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+
+export const isAbsoluteURL = (url: string): boolean => {
+  return startsWithSchemeRegexp.test(url);
+};
+
+export let isArray = (val: unknown): val is unknown[] => ((isArray = Array.isArray), isArray(val));
+export let isReadonlyArray = isArray as (val: unknown) => val is readonly unknown[];
+
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export function maybeObj(x: unknown): object {
+  if (typeof x !== 'object') {
+    return {};
+  }
+
+  return x ?? {};
+}
+
+// https://stackoverflow.com/a/34491287
+export function isEmptyObj(obj: Object | null | undefined): boolean {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+export function hasOwn<T extends object = object>(obj: T, key: PropertyKey): key is keyof T {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function isObj(obj: unknown): obj is Record<string, unknown> {
+  return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+
+export const ensurePresent = <T>(value: T | null | undefined): T => {
+  if (value == null) {
+    throw new ArcadeError(`Expected a value to be given but received ${value} instead.`);
+  }
+
+  return value;
+};
+
+export const validatePositiveInteger = (name: string, n: unknown): number => {
+  if (typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new ArcadeError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new ArcadeError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+
+export const coerceInteger = (value: unknown): number => {
+  if (typeof value === 'number') return Math.round(value);
+  if (typeof value === 'string') return parseInt(value, 10);
+
+  throw new ArcadeError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceFloat = (value: unknown): number => {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') return parseFloat(value);
+
+  throw new ArcadeError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceBoolean = (value: unknown): boolean => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value === 'true';
+  return Boolean(value);
+};
+
+export const maybeCoerceInteger = (value: unknown): number | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceInteger(value);
+};
+
+export const maybeCoerceFloat = (value: unknown): number | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceFloat(value);
+};
+
+export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceBoolean(value);
+};
+
+export const safeJSON = (text: string) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+};

package/src/internal/utils.ts

@@ -0,0 +1,8 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';

package/src/pagination.ts

@@ -1,79 +1,2 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-import { AbstractPage, Response, APIClient, FinalRequestOptions, PageInfo } from './core';
-
-export interface OffsetPageResponse<Item> {
-  items: Array<Item>;
-
-  total_count: number;
-
-  offset: number;
-}
-
-export interface OffsetPageParams {
-  /**
-   * The number of elements to skip.
-   */
-  offset?: number;
-
-  /**
-   * The maximum number of elements to fetch.
-   */
-  limit?: number;
-}
-
-export class OffsetPage<Item> extends AbstractPage<Item> implements OffsetPageResponse<Item> {
-  items: Array<Item>;
-
-  total_count: number;
-
-  offset: number;
-
-  constructor(
-    client: APIClient,
-    response: Response,
-    body: OffsetPageResponse<Item>,
-    options: FinalRequestOptions,
-  ) {
-    super(client, response, body, options);
-
-    this.items = body.items || [];
-    this.total_count = body.total_count || 0;
-    this.offset = body.offset || 0;
-  }
-
-  getPaginatedItems(): Item[] {
-    return this.items ?? [];
-  }
-
-  // @deprecated Please use `nextPageInfo()` instead
-  nextPageParams(): Partial<OffsetPageParams> | null {
-    const info = this.nextPageInfo();
-    if (!info) return null;
-    if ('params' in info) return info.params;
-    const params = Object.fromEntries(info.url.searchParams);
-    if (!Object.keys(params).length) return null;
-    return params;
-  }
-
-  nextPageInfo(): PageInfo | null {
-    const offset = this.offset;
-    if (typeof offset !== 'number') {
-      return null;
-    }
-
-    const length = this.getPaginatedItems().length;
-    const currentCount = offset + length;
-
-    const totalCount = this.total_count;
-    if (!totalCount) {
-      return null;
-    }
-
-    if (currentCount < totalCount) {
-      return { params: { offset: currentCount } };
-    }
-
-    return null;
-  }
-}
+/** @deprecated Import from ./core/pagination instead */
+export * from './core/pagination';

package/src/resource.ts

@@ -1,11 +1,2 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-import type { Arcade } from './index';
-
-export abstract class APIResource {
-  protected _client: Arcade;
-
-  constructor(client: Arcade) {
-    this._client = client;
-  }
-}
+/** @deprecated Import from ./core/resource instead */
+export * from './core/resource';

package/src/resources/admin/admin.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
+import { APIResource } from '../../core/resource';
 import * as AuthProvidersAPI from './auth-providers';
 import {
   AuthProviderCreateParams,
@@ -12,7 +12,7 @@ import {
   AuthProviders,
 } from './auth-providers';
 import * as SecretsAPI from './secrets';
-import { SecretListResponse, SecretResponse, Secrets } from './secrets';
+import { SecretCreateParams, SecretListResponse, SecretResponse, Secrets } from './secrets';
 import * as UserConnectionsAPI from './user-connections';
 import {
   UserConnectionListParams,
@@ -28,7 +28,6 @@ export class Admin extends APIResource {
 }
 
 Admin.UserConnections = UserConnections;
-Admin.UserConnectionResponsesOffsetPage = UserConnectionResponsesOffsetPage;
 Admin.AuthProviders = AuthProviders;
 Admin.Secrets = Secrets;
 
@@ -36,7 +35,7 @@ export declare namespace Admin {
   export {
     UserConnections as UserConnections,
     type UserConnectionResponse as UserConnectionResponse,
-    UserConnectionResponsesOffsetPage as UserConnectionResponsesOffsetPage,
+    type UserConnectionResponsesOffsetPage as UserConnectionResponsesOffsetPage,
     type UserConnectionListParams as UserConnectionListParams,
   };
 
@@ -54,5 +53,6 @@ export declare namespace Admin {
     Secrets as Secrets,
     type SecretResponse as SecretResponse,
     type SecretListResponse as SecretListResponse,
+    type SecretCreateParams as SecretCreateParams,
   };
 }

package/src/resources/admin/auth-providers.ts

@@ -1,49 +1,48 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as Core from '../../core';
+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 AuthProviders extends APIResource {
   /**
    * Create a new auth provider
    */
-  create(
-    body: AuthProviderCreateParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<AuthProviderResponse> {
+  create(body: AuthProviderCreateParams, options?: RequestOptions): APIPromise<AuthProviderResponse> {
     return this._client.post('/v1/admin/auth_providers', { body, ...options });
   }
 
   /**
    * List a page of auth providers that are available to the caller
    */
-  list(options?: Core.RequestOptions): Core.APIPromise<AuthProviderListResponse> {
+  list(options?: RequestOptions): APIPromise<AuthProviderListResponse> {
     return this._client.get('/v1/admin/auth_providers', options);
   }
 
   /**
    * Delete a specific auth provider
    */
-  delete(id: string, options?: Core.RequestOptions): Core.APIPromise<AuthProviderResponse> {
-    return this._client.delete(`/v1/admin/auth_providers/${id}`, options);
+  delete(id: string, options?: RequestOptions): APIPromise<AuthProviderResponse> {
+    return this._client.delete(path`/v1/admin/auth_providers/${id}`, options);
   }
 
   /**
    * Get the details of a specific auth provider
    */
-  get(id: string, options?: Core.RequestOptions): Core.APIPromise<AuthProviderResponse> {
-    return this._client.get(`/v1/admin/auth_providers/${id}`, options);
+  get(id: string, options?: RequestOptions): APIPromise<AuthProviderResponse> {
+    return this._client.get(path`/v1/admin/auth_providers/${id}`, options);
   }
 
   /**
    * Patch an existing auth provider
    */
   patch(
-    pathId: string,
+    pathID: string,
     body: AuthProviderPatchParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<AuthProviderResponse> {
-    return this._client.patch(`/v1/admin/auth_providers/${pathId}`, { body, ...options });
+    options?: RequestOptions,
+  ): APIPromise<AuthProviderResponse> {
+    return this._client.patch(path`/v1/admin/auth_providers/${pathID}`, { body, ...options });
   }
 }
 

package/src/resources/admin/index.ts

@@ -10,10 +10,10 @@ export {
   type AuthProviderCreateParams,
   type AuthProviderPatchParams,
 } from './auth-providers';
-export { Secrets, type SecretResponse, type SecretListResponse } from './secrets';
+export { Secrets, type SecretResponse, type SecretListResponse, type SecretCreateParams } from './secrets';
 export {
-  UserConnectionResponsesOffsetPage,
   UserConnections,
   type UserConnectionResponse,
   type UserConnectionListParams,
+  type UserConnectionResponsesOffsetPage,
 } from './user-connections';

package/src/resources/admin/secrets.ts

@@ -1,23 +1,33 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as Core from '../../core';
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
 
 export class Secrets extends APIResource {
+  /**
+   * Create or update a secret
+   */
+  create(secretKey: string, body: SecretCreateParams, options?: RequestOptions): APIPromise<SecretResponse> {
+    return this._client.post(path`/v1/admin/secrets/${secretKey}`, { body, ...options });
+  }
+
   /**
    * List all secrets that are visible to the caller
    */
-  list(options?: Core.RequestOptions): Core.APIPromise<SecretListResponse> {
+  list(options?: RequestOptions): APIPromise<SecretListResponse> {
     return this._client.get('/v1/admin/secrets', options);
   }
 
   /**
    * Delete a secret by its ID
    */
-  delete(secretId: string, options?: Core.RequestOptions): Core.APIPromise<void> {
-    return this._client.delete(`/v1/admin/secrets/${secretId}`, {
+  delete(secretID: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/v1/admin/secrets/${secretID}`, {
       ...options,
-      headers: { Accept: '*/*', ...options?.headers },
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 }
@@ -60,6 +70,16 @@ export interface SecretListResponse {
   total_count?: number;
 }
 
+export interface SecretCreateParams {
+  value: string;
+
+  description?: string;
+}
+
 export declare namespace Secrets {
-  export { type SecretResponse as SecretResponse, type SecretListResponse as SecretListResponse };
+  export {
+    type SecretResponse as SecretResponse,
+    type SecretListResponse as SecretListResponse,
+    type SecretCreateParams as SecretCreateParams,
+  };
 }

package/src/resources/admin/user-connections.ts

@@ -1,29 +1,21 @@
 // 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 { OffsetPage, type OffsetPageParams } from '../../pagination';
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { OffsetPage, type OffsetPageParams, PagePromise } from '../../core/pagination';
+import { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
 
 export class UserConnections extends APIResource {
   /**
    * List all auth connections
    */
   list(
-    query?: UserConnectionListParams,
-    options?: Core.RequestOptions,
-  ): Core.PagePromise<UserConnectionResponsesOffsetPage, UserConnectionResponse>;
-  list(
-    options?: Core.RequestOptions,
-  ): Core.PagePromise<UserConnectionResponsesOffsetPage, UserConnectionResponse>;
-  list(
-    query: UserConnectionListParams | Core.RequestOptions = {},
-    options?: Core.RequestOptions,
-  ): Core.PagePromise<UserConnectionResponsesOffsetPage, UserConnectionResponse> {
-    if (isRequestOptions(query)) {
-      return this.list({}, query);
-    }
-    return this._client.getAPIList('/v1/admin/user_connections', UserConnectionResponsesOffsetPage, {
+    query: UserConnectionListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<UserConnectionResponsesOffsetPage, UserConnectionResponse> {
+    return this._client.getAPIList('/v1/admin/user_connections', OffsetPage<UserConnectionResponse>, {
       query,
       ...options,
     });
@@ -32,15 +24,15 @@ export class UserConnections extends APIResource {
   /**
    * Delete a user/auth provider connection
    */
-  delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void> {
-    return this._client.delete(`/v1/admin/user_connections/${id}`, {
+  delete(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/v1/admin/user_connections/${id}`, {
       ...options,
-      headers: { Accept: '*/*', ...options?.headers },
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 }
 
-export class UserConnectionResponsesOffsetPage extends OffsetPage<UserConnectionResponse> {}
+export type UserConnectionResponsesOffsetPage = OffsetPage<UserConnectionResponse>;
 
 export interface UserConnectionResponse {
   id?: string;
@@ -84,12 +76,10 @@ export namespace UserConnectionListParams {
   }
 }
 
-UserConnections.UserConnectionResponsesOffsetPage = UserConnectionResponsesOffsetPage;
-
 export declare namespace UserConnections {
   export {
     type UserConnectionResponse as UserConnectionResponse,
-    UserConnectionResponsesOffsetPage as UserConnectionResponsesOffsetPage,
+    type UserConnectionResponsesOffsetPage as UserConnectionResponsesOffsetPage,
     type UserConnectionListParams as UserConnectionListParams,
   };
 }

package/src/resources/auth.ts

@@ -1,8 +1,9 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../resource';
+import { APIResource } from '../core/resource';
 import * as Shared from './shared';
-import * as Core from '../core';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
 
 export const DEFAULT_LONGPOLL_WAIT_TIME = 45;
 
@@ -35,7 +36,7 @@ export class Auth extends APIResource {
     userId: string,
     provider: string,
     options: AuthStartOptions = {},
-  ): Core.APIPromise<Shared.AuthorizationResponse> {
+  ): APIPromise<Shared.AuthorizationResponse> {
     const { providerType = 'oauth2', scopes = [] } = options;
 
     const authRequirement: AuthAuthorizeParams.AuthRequirement = {
@@ -55,20 +56,14 @@ export class Auth extends APIResource {
   /**
    * Starts the authorization process for given authorization requirements
    */
-  authorize(
-    body: AuthAuthorizeParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<Shared.AuthorizationResponse> {
+  authorize(body: AuthAuthorizeParams, options?: RequestOptions): APIPromise<Shared.AuthorizationResponse> {
     return this._client.post('/v1/auth/authorize', { body, ...options });
   }
 
   /**
    * Confirms a user's details during an authorization flow
    */
-  confirmUser(
-    body: AuthConfirmUserParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<ConfirmUserResponse> {
+  confirmUser(body: AuthConfirmUserParams, options?: RequestOptions): APIPromise<ConfirmUserResponse> {
     return this._client.post('/v1/auth/confirm_user', { body, ...options });
   }
 
@@ -77,10 +72,7 @@ export class Auth extends APIResource {
    * 'wait' param is present, does not respond until either the auth status becomes
    * completed or the timeout is reached.
    */
-  status(
-    query: AuthStatusParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<Shared.AuthorizationResponse> {
+  status(query: AuthStatusParams, options?: RequestOptions): APIPromise<Shared.AuthorizationResponse> {
     return this._client.get('/v1/auth/status', { query, ...options });
   }
 

package/src/resources/chat/chat.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
+import { APIResource } from '../../core/resource';
 import * as Shared from '../shared';
 import * as CompletionsAPI from './completions';
 import { CompletionCreateParams, Completions } from './completions';

package/src/resources/chat/completions.ts

@@ -1,14 +1,15 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import * as Core from '../../core';
+import { APIResource } from '../../core/resource';
 import * as ChatAPI from './chat';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
 
 export class Completions extends APIResource {
   /**
-   * Talk to different LLM Chat APIs via OpenAI's API
+   * Interact with language models via OpenAI's chat completions API
    */
-  create(body: CompletionCreateParams, options?: Core.RequestOptions): Core.APIPromise<ChatAPI.ChatResponse> {
+  create(body: CompletionCreateParams, options?: RequestOptions): APIPromise<ChatAPI.ChatResponse> {
     return this._client.post('/v1/chat/completions', { body, ...options });
   }
 }