@amigo-ai/platform-sdk 0.4.1 → 0.4.3

package/dist/index.cjs

@@ -42,6 +42,7 @@ __export(index_exports, {
   ParseError: () => ParseError,
   PermissionError: () => PermissionError,
   RateLimitError: () => RateLimitError,
+  RequestTimeoutError: () => RequestTimeoutError,
   ServerError: () => ServerError,
   ServiceUnavailableError: () => ServiceUnavailableError,
   ValidationError: () => ValidationError,
@@ -49,17 +50,20 @@ __export(index_exports, {
   actionId: () => actionId,
   agentId: () => agentId,
   apiKeyId: () => apiKeyId,
+  buildLastResponse: () => buildLastResponse,
   callId: () => callId,
   contextGraphId: () => contextGraphId,
   dataSourceId: () => dataSourceId,
   entityId: () => entityId,
   eventId: () => eventId,
+  extractRequestId: () => extractRequestId,
   functionId: () => functionId,
   integrationId: () => integrationId,
   isAmigoError: () => isAmigoError,
   isAuthenticationError: () => isAuthenticationError,
   isNotFoundError: () => isNotFoundError,
   isRateLimitError: () => isRateLimitError,
+  isRequestTimeoutError: () => isRequestTimeoutError,
   paginate: () => paginate,
   parseRateLimitHeaders: () => parseRateLimitHeaders,
   parseWebhookEvent: () => parseWebhookEvent,
@@ -191,6 +195,13 @@ var NetworkError = class extends AmigoError {
     }
   }
 };
+var RequestTimeoutError = class extends NetworkError {
+  timeoutMs;
+  constructor(message, timeoutMs, cause) {
+    super(message, cause);
+    this.timeoutMs = timeoutMs;
+  }
+};
 var ParseError = class extends AmigoError {
   body;
   constructor(message, body) {
@@ -264,6 +275,9 @@ function isRateLimitError(err) {
 function isAuthenticationError(err) {
   return err instanceof AuthenticationError;
 }
+function isRequestTimeoutError(err) {
+  return err instanceof RequestTimeoutError;
+}
 
 // src/core/openapi-client.ts
 var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
@@ -286,6 +300,104 @@ function createAuthMiddleware(config) {
   };
 }
 
+// src/core/rate-limit.ts
+function parseRateLimitHeaders(headers) {
+  const limit = headers.get("x-ratelimit-limit");
+  const remaining = headers.get("x-ratelimit-remaining");
+  const reset = headers.get("x-ratelimit-reset");
+  const retryAfter = headers.get("retry-after");
+  return {
+    limit: limit ? parseInt(limit, 10) : null,
+    remaining: remaining ? parseInt(remaining, 10) : null,
+    reset: reset ? new Date(parseInt(reset, 10) * 1e3) : null,
+    retryAfter: retryAfter ? parseInt(retryAfter, 10) : null
+  };
+}
+
+// src/core/request-options.ts
+function stripRequestControls(options) {
+  if (!options) {
+    return void 0;
+  }
+  const rest = { ...options };
+  delete rest.timeout;
+  delete rest.maxRetries;
+  delete rest.retry;
+  return rest;
+}
+function mergeRequestOptions(base, override) {
+  if (!base) {
+    return override;
+  }
+  if (!override) {
+    return base;
+  }
+  const mergeableOverride = override;
+  return {
+    ...base,
+    ...override,
+    headers: mergeHeaders(base.headers, mergeableOverride.headers),
+    signal: mergeableOverride.signal ?? base.signal,
+    timeout: mergeableOverride.timeout ?? base.timeout,
+    maxRetries: mergeableOverride.maxRetries ?? base.maxRetries,
+    retry: mergeableOverride.retry ?? base.retry
+  };
+}
+function mergeScopedRequestOptions(base, override) {
+  return mergeRequestOptions(base, override) ?? override;
+}
+function mergeHeaders(base, override) {
+  if (!base && !override) {
+    return void 0;
+  }
+  const headers = new Headers();
+  let hasEntries = false;
+  applyHeaders(headers, base, () => {
+    hasEntries = true;
+  });
+  applyHeaders(headers, override, () => {
+    hasEntries = true;
+  });
+  return hasEntries ? headers : void 0;
+}
+function applyHeaders(target, source, onSet) {
+  if (!source) {
+    return;
+  }
+  if (source instanceof Headers) {
+    source.forEach((value, key) => {
+      target.set(key, value);
+      onSet();
+    });
+    return;
+  }
+  if (Array.isArray(source)) {
+    for (const [key, value] of source) {
+      if (!key) {
+        continue;
+      }
+      if (value === null || value === void 0) {
+        target.delete(key);
+        continue;
+      }
+      target.set(key, String(value));
+      onSet();
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (value === null || value === void 0) {
+      target.delete(key);
+      continue;
+    }
+    target.set(
+      key,
+      Array.isArray(value) ? value.map((item) => String(item)).join(", ") : String(value)
+    );
+    onSet();
+  }
+}
+
 // src/core/retry.ts
 var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
 var POST_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429]);
@@ -319,28 +431,177 @@ function parseRetryAfterHeader(header) {
   }
   return void 0;
 }
-function resolveRetryOptions(opts) {
+function resolveRetryOptions(opts, maxRetries) {
+  const maxAttempts = typeof maxRetries === "number" && Number.isFinite(maxRetries) ? Math.max(1, Math.floor(maxRetries) + 1) : opts?.maxAttempts ?? 3;
   return {
-    maxAttempts: opts?.maxAttempts ?? 3,
+    maxAttempts,
     baseDelayMs: opts?.baseDelayMs ?? 250,
     maxDelayMs: opts?.maxDelayMs ?? 3e4
   };
 }
 
+// src/core/utils.ts
+function extractRequestId(response) {
+  return response.headers.get("x-request-id");
+}
+function buildLastResponse(response) {
+  return {
+    requestId: extractRequestId(response),
+    statusCode: response.status,
+    headers: response.headers,
+    rateLimit: parseRateLimitHeaders(response.headers)
+  };
+}
+function extractData(result) {
+  if (result.data !== void 0) {
+    return attachResponseMetadata(result.data, result.response);
+  }
+  throw new ParseError(
+    "Unexpected empty response from API",
+    result.error !== void 0 ? JSON.stringify(result.error) : void 0
+  );
+}
+function withResponse(result) {
+  const data = extractData(result);
+  const lastResponse = buildLastResponse(result.response);
+  return {
+    data,
+    response: result.response,
+    requestId: lastResponse.requestId,
+    rateLimit: lastResponse.rateLimit
+  };
+}
+async function* paginate(fetcher) {
+  let token = void 0;
+  while (true) {
+    const page = await fetcher(token);
+    for (const item of page.items) {
+      yield item;
+    }
+    if (!page.has_more || page.continuation_token === null) break;
+    token = page.continuation_token;
+  }
+}
+function attachResponseMetadata(data, response) {
+  if (!response || typeof data !== "object" || data === null) {
+    return data;
+  }
+  const target = data;
+  const lastResponse = buildLastResponse(response);
+  defineHiddenMetadata(target, "_request_id", lastResponse.requestId);
+  defineHiddenMetadata(target, "lastResponse", lastResponse);
+  return target;
+}
+function defineHiddenMetadata(target, key, value) {
+  try {
+    Object.defineProperty(target, key, {
+      value,
+      enumerable: false,
+      configurable: true,
+      writable: false
+    });
+  } catch {
+  }
+}
+
 // src/core/openapi-client.ts
 var createClient = typeof import_openapi_fetch.default === "function" ? import_openapi_fetch.default : import_openapi_fetch.default.default;
+var platformClientContext = /* @__PURE__ */ new WeakMap();
 function createPlatformClient(config) {
-  const retryOpts = resolveRetryOptions(config.retry);
-  const baseFetch = config.fetch ?? globalThis.fetch;
-  const retryingFetch = async (input, init) => {
-    const method = (init?.method ?? "GET").toUpperCase();
-    const signal = init?.signal;
+  const transport = toRequestTransport(config.fetch ?? globalThis.fetch);
+  const defaults = {
+    retry: config.retry,
+    maxRetries: config.maxRetries,
+    timeout: config.timeout
+  };
+  const client = createClient({
+    baseUrl: config.baseUrl,
+    fetch: createRetryingFetch(transport, defaults),
+    headers: config.headers
+  });
+  platformClientContext.set(client, { transport, defaults });
+  const errorMiddleware = {
+    async onResponse({ response }) {
+      if (!response.ok) {
+        throw await createApiError(response);
+      }
+      return response;
+    }
+  };
+  const authMiddleware = createAuthMiddleware({ apiKey: config.apiKey });
+  const hookMiddleware = config.hooks ? {
+    async onRequest({ request, schemaPath, id }) {
+      await config.hooks?.onRequest?.({ request, schemaPath, id });
+      return request;
+    },
+    async onResponse({ request, response, schemaPath, id }) {
+      await config.hooks?.onResponse?.({
+        id,
+        request,
+        response,
+        schemaPath,
+        requestId: extractRequestId(response),
+        rateLimit: parseRateLimitHeaders(response.headers)
+      });
+      return response;
+    },
+    async onError({ request, error, schemaPath, id }) {
+      await config.hooks?.onError?.({ id, request, error, schemaPath });
+    }
+  } : void 0;
+  client.use(authMiddleware);
+  client.use(errorMiddleware);
+  if (hookMiddleware) {
+    client.use(hookMiddleware);
+  }
+  return client;
+}
+function applyPlatformRequestOptions(client, init) {
+  if (!init) {
+    return void 0;
+  }
+  const context = platformClientContext.get(client);
+  const stripped = stripRequestControls(init);
+  if (!context) {
+    return stripped;
+  }
+  const overrideFetch = stripped?.fetch;
+  const hasControlOverride = overrideFetch !== void 0 || init.timeout !== void 0 || init.maxRetries !== void 0 || init.retry !== void 0;
+  if (!hasControlOverride) {
+    return stripped;
+  }
+  const transport = toRequestTransport(
+    overrideFetch ?? context.transport
+  );
+  const fetch = createRetryingFetch(transport, {
+    timeout: init.timeout ?? context.defaults.timeout,
+    maxRetries: init.maxRetries ?? context.defaults.maxRetries,
+    retry: init.retry ?? context.defaults.retry
+  });
+  return {
+    ...stripped,
+    fetch
+  };
+}
+function createRetryingFetch(transport, defaults) {
+  return async (input, init) => {
+    const baseRequest = input instanceof Request ? input : new Request(input, init);
+    const method = baseRequest.method.toUpperCase();
+    const retryOpts = resolveRetryOptions(defaults.retry, defaults.maxRetries);
+    const timeoutMs = defaults.timeout;
     const isIdempotent = method === "GET" || method === "HEAD" || method === "OPTIONS";
     for (let attempt = 0; attempt < retryOpts.maxAttempts; attempt++) {
       let response;
       let error;
+      let timedOut = false;
       try {
-        response = await baseFetch(input, init);
+        const prepared = prepareRequestForAttempt(baseRequest, timeoutMs);
+        try {
+          response = await transport(prepared.request);
+        } finally {
+          timedOut = prepared.timedOut;
+          prepared.cleanup();
+        }
       } catch (err) {
         error = err;
       }
@@ -348,6 +609,9 @@ function createPlatformClient(config) {
       const ctx = { method, attempt, response, options: retryOpts };
       const attemptsRemain = attempt + 1 < retryOpts.maxAttempts;
       if (error) {
+        if (timedOut) {
+          throw new RequestTimeoutError(`Request timed out after ${timeoutMs}ms`, timeoutMs, error);
+        }
         if (isIdempotent && attemptsRemain) {
           await sleep(computeDelay(attempt, new Response(), retryOpts));
           continue;
@@ -359,7 +623,7 @@ function createPlatformClient(config) {
       }
       if (response && attemptsRemain && shouldRetry(ctx)) {
         const delay = computeDelay(attempt, response, retryOpts);
-        if (signal?.aborted) return response;
+        if (baseRequest.signal.aborted) return response;
         await sleep(delay);
         continue;
       }
@@ -367,54 +631,163 @@ function createPlatformClient(config) {
     }
     throw new NetworkError("Retry loop exhausted");
   };
-  const client = createClient({
-    baseUrl: config.baseUrl,
-    fetch: retryingFetch
-  });
-  const errorMiddleware = {
-    async onResponse({ response }) {
-      if (!response.ok) {
-        throw await createApiError(response);
-      }
-      return response;
-    }
-  };
-  const authMiddleware = createAuthMiddleware({ apiKey: config.apiKey });
-  client.use(authMiddleware);
-  client.use(errorMiddleware);
-  return client;
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
-// src/core/utils.ts
-function extractData(result) {
-  if (result.data !== void 0) return result.data;
-  throw new ParseError(
-    "Unexpected empty response from API",
-    result.error !== void 0 ? JSON.stringify(result.error) : void 0
-  );
+function toRequestTransport(fetcher) {
+  return async (input) => fetcher(input);
 }
-async function* paginate(fetcher) {
-  let token = void 0;
-  while (true) {
-    const page = await fetcher(token);
-    for (const item of page.items) {
-      yield item;
+function prepareRequestForAttempt(request, timeoutMs) {
+  const attemptRequest = request.clone();
+  const timeout = createTimeoutSignal(attemptRequest.signal, timeoutMs);
+  if (!timeout.signal) {
+    return {
+      request: attemptRequest,
+      timedOut: false,
+      cleanup: timeout.cleanup
+    };
+  }
+  return {
+    request: new Request(attemptRequest, { signal: timeout.signal }),
+    get timedOut() {
+      return timeout.didTimeout;
+    },
+    cleanup: timeout.cleanup
+  };
+}
+function createTimeoutSignal(upstream, timeoutMs) {
+  if (!timeoutMs || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return {
+      signal: upstream ?? void 0,
+      didTimeout: false,
+      cleanup: () => {
+      }
+    };
+  }
+  const controller = new AbortController();
+  let didTimeout = false;
+  const cleanups = [];
+  const onAbort = () => controller.abort(upstream?.reason);
+  if (upstream) {
+    if (upstream.aborted) {
+      controller.abort(upstream.reason);
+    } else {
+      upstream.addEventListener("abort", onAbort, { once: true });
+      cleanups.push(() => upstream.removeEventListener("abort", onAbort));
     }
-    if (!page.has_more || page.continuation_token === null) break;
-    token = page.continuation_token;
   }
+  const timer = setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, timeoutMs);
+  cleanups.push(() => clearTimeout(timer));
+  return {
+    signal: controller.signal,
+    get didTimeout() {
+      return didTimeout;
+    },
+    cleanup: () => {
+      for (const cleanup of cleanups) {
+        cleanup();
+      }
+    }
+  };
 }
 
 // src/resources/base.ts
+var scopedClientState = /* @__PURE__ */ new WeakMap();
 var WorkspaceScopedResource = class {
   constructor(client, workspaceId2) {
     this.client = client;
     this.workspaceId = workspaceId2;
   }
+  withOptions(options) {
+    const ResourceCtor = this.constructor;
+    return new ResourceCtor(scopePlatformClient(this.client, options), this.workspaceId);
+  }
 };
+function scopePlatformClient(client, options) {
+  const { baseClient, options: existingOptions } = resolveScopedPlatformClient(client);
+  const mergedOptions = mergeScopedRequestOptions(existingOptions, options);
+  const scopedClient = {
+    request: (method, path, init) => baseClient.request(
+      method,
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    GET: (path, init) => baseClient.GET(
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    PUT: (path, init) => baseClient.PUT(
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    POST: (path, init) => baseClient.POST(
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    DELETE: (path, init) => baseClient.DELETE(
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    OPTIONS: (path, init) => baseClient.OPTIONS(
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    HEAD: (path, init) => baseClient.HEAD(
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    PATCH: (path, init) => baseClient.PATCH(
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    TRACE: (path, init) => baseClient.TRACE(
+      path,
+      applyPlatformRequestOptions(
+        baseClient,
+        mergeRequestOptions(mergedOptions, init)
+      )
+    ),
+    use: (...middleware) => baseClient.use(...middleware),
+    eject: (...middleware) => baseClient.eject(...middleware)
+  };
+  scopedClientState.set(scopedClient, { baseClient, options: mergedOptions });
+  return scopedClient;
+}
+function resolveScopedPlatformClient(client) {
+  const existing = scopedClientState.get(client);
+  return {
+    baseClient: existing?.baseClient ?? client,
+    options: existing?.options
+  };
+}
 
 // src/resources/workspaces.ts
 var WorkspacesResource = class extends WorkspaceScopedResource {
@@ -2184,23 +2557,10 @@ var simulationSessionId = (id) => id;
 var functionId = (id) => id;
 var dataSourceId = (id) => id;
 
-// src/core/rate-limit.ts
-function parseRateLimitHeaders(headers) {
-  const limit = headers.get("x-ratelimit-limit");
-  const remaining = headers.get("x-ratelimit-remaining");
-  const reset = headers.get("x-ratelimit-reset");
-  const retryAfter = headers.get("retry-after");
-  return {
-    limit: limit ? parseInt(limit, 10) : null,
-    remaining: remaining ? parseInt(remaining, 10) : null,
-    reset: reset ? new Date(parseInt(reset, 10) * 1e3) : null,
-    retryAfter: retryAfter ? parseInt(retryAfter, 10) : null
-  };
-}
-
 // src/core/webhooks.ts
 var textEncoder = new TextEncoder();
 var MAX_TIMESTAMP_SKEW_MS = 5 * 60 * 1e3;
+var webCryptoPromise;
 var WebhookVerificationError = class extends Error {
   constructor(message) {
     super(message);
@@ -2288,6 +2648,7 @@ function toUint8Array(payload) {
   return new Uint8Array(payload);
 }
 async function signWebhookPayload(payload, secret, timestamp) {
+  const crypto = await resolveWebCrypto();
   const key = await crypto.subtle.importKey(
     "raw",
     textEncoder.encode(secret),
@@ -2299,6 +2660,13 @@ async function signWebhookPayload(payload, secret, timestamp) {
   const mac = await crypto.subtle.sign("HMAC", key, toCryptoBuffer(message));
   return new Uint8Array(mac);
 }
+async function resolveWebCrypto() {
+  if (globalThis.crypto?.subtle) {
+    return globalThis.crypto;
+  }
+  webCryptoPromise ??= import("node:crypto").then(({ webcrypto }) => webcrypto);
+  return await webCryptoPromise;
+}
 function normalizeSignature(signature) {
   const normalized = signature.startsWith("sha256=") ? signature.slice(7) : signature;
   if (!/^[a-fA-F0-9]+$/.test(normalized) || normalized.length % 2 !== 0) {
@@ -2339,7 +2707,9 @@ function toCryptoBuffer(bytes) {
 
 // src/index.ts
 var DEFAULT_BASE_URL = "https://api.platform.amigo.ai";
-var AmigoClient = class {
+var AmigoClient = class _AmigoClient {
+  workspaceId;
+  baseUrl;
   workspaces;
   apiKeys;
   agents;
@@ -2368,6 +2738,7 @@ var AmigoClient = class {
   safety;
   compliance;
   functions;
+  api;
   constructor(config) {
     if (!config.apiKey || typeof config.apiKey !== "string") {
       throw new ConfigurationError("apiKey is required and must be a non-empty string");
@@ -2380,36 +2751,119 @@ var AmigoClient = class {
       apiKey: config.apiKey,
       baseUrl,
       retry: config.retry,
+      maxRetries: config.maxRetries,
+      timeout: config.timeout,
+      headers: config.headers,
+      hooks: config.hooks,
       fetch: config.fetch
     });
-    const ws = config.workspaceId;
-    this.workspaces = new WorkspacesResource(client, ws);
-    this.apiKeys = new ApiKeysResource(client, ws);
-    this.agents = new AgentsResource(client, ws);
-    this.skills = new SkillsResource(client, ws);
-    this.actions = new ActionsResource(client, ws);
-    this.operators = new OperatorsResource(client, ws);
-    this.triggers = new TriggersResource(client, ws);
-    this.services = new ServicesResource(client, ws);
-    this.contextGraphs = new ContextGraphsResource(client, ws);
-    this.dataSources = new DataSourcesResource(client, ws);
-    this.world = new WorldResource(client, ws);
-    this.calls = new CallsResource(client, ws);
-    this.phoneNumbers = new PhoneNumbersResource(client, ws);
-    this.integrations = new IntegrationsResource(client, ws);
-    this.analytics = new AnalyticsResource(client, ws);
-    this.simulations = new SimulationsResource(client, ws);
-    this.settings = new SettingsResource(client, ws);
-    this.billing = new BillingResource(client, ws);
-    this.memory = new MemoryResource(client, ws);
-    this.personas = new PersonasResource(client, ws);
-    this.reviewQueue = new ReviewQueueResource(client, ws);
-    this.recordings = new RecordingsResource(client, ws);
-    this.audit = new AuditResource(client, ws);
-    this.webhookDestinations = new WebhookDestinationsResource(client, ws);
-    this.safety = new SafetyResource(client, ws);
-    this.compliance = new ComplianceResource(client, ws);
-    this.functions = new FunctionsResource(client, ws);
+    _AmigoClient.hydrate(this, client, config.workspaceId, baseUrl);
+  }
+  withOptions(options) {
+    return _AmigoClient.fromPlatformClient(
+      scopePlatformClient(this.api, options),
+      this.workspaceId,
+      this.baseUrl
+    );
+  }
+  async GET(path, ...[init]) {
+    return withResponse(await this.resolveApiRequest(path, "GET", init));
+  }
+  async POST(path, ...[init]) {
+    return withResponse(await this.resolveApiRequest(path, "POST", init));
+  }
+  async PUT(path, ...[init]) {
+    return withResponse(await this.resolveApiRequest(path, "PUT", init));
+  }
+  async PATCH(path, ...[init]) {
+    return withResponse(await this.resolveApiRequest(path, "PATCH", init));
+  }
+  async DELETE(path, ...[init]) {
+    return withResponse(await this.resolveApiRequest(path, "DELETE", init));
+  }
+  async HEAD(path, ...[init]) {
+    return withResponse(await this.resolveApiRequest(path, "HEAD", init));
+  }
+  async OPTIONS(path, ...[init]) {
+    return withResponse(await this.resolveApiRequest(path, "OPTIONS", init));
+  }
+  static fromPlatformClient(client, workspaceId2, baseUrl) {
+    const instance = Object.create(_AmigoClient.prototype);
+    _AmigoClient.hydrate(instance, client, workspaceId2, baseUrl);
+    return instance;
+  }
+  static hydrate(target, client, workspaceId2, baseUrl) {
+    const mutable = target;
+    mutable.workspaceId = workspaceId2;
+    mutable.baseUrl = baseUrl;
+    target.api = client;
+    mutable.workspaces = new WorkspacesResource(client, workspaceId2);
+    mutable.apiKeys = new ApiKeysResource(client, workspaceId2);
+    mutable.agents = new AgentsResource(client, workspaceId2);
+    mutable.skills = new SkillsResource(client, workspaceId2);
+    mutable.actions = new ActionsResource(client, workspaceId2);
+    mutable.operators = new OperatorsResource(client, workspaceId2);
+    mutable.triggers = new TriggersResource(client, workspaceId2);
+    mutable.services = new ServicesResource(client, workspaceId2);
+    mutable.contextGraphs = new ContextGraphsResource(client, workspaceId2);
+    mutable.dataSources = new DataSourcesResource(client, workspaceId2);
+    mutable.world = new WorldResource(client, workspaceId2);
+    mutable.calls = new CallsResource(client, workspaceId2);
+    mutable.phoneNumbers = new PhoneNumbersResource(client, workspaceId2);
+    mutable.integrations = new IntegrationsResource(client, workspaceId2);
+    mutable.analytics = new AnalyticsResource(client, workspaceId2);
+    mutable.simulations = new SimulationsResource(client, workspaceId2);
+    mutable.settings = new SettingsResource(client, workspaceId2);
+    mutable.billing = new BillingResource(client, workspaceId2);
+    mutable.memory = new MemoryResource(client, workspaceId2);
+    mutable.personas = new PersonasResource(client, workspaceId2);
+    mutable.reviewQueue = new ReviewQueueResource(client, workspaceId2);
+    mutable.recordings = new RecordingsResource(client, workspaceId2);
+    mutable.audit = new AuditResource(client, workspaceId2);
+    mutable.webhookDestinations = new WebhookDestinationsResource(client, workspaceId2);
+    mutable.safety = new SafetyResource(client, workspaceId2);
+    mutable.compliance = new ComplianceResource(client, workspaceId2);
+    mutable.functions = new FunctionsResource(client, workspaceId2);
+  }
+  async resolveApiRequest(path, method, init) {
+    const { baseClient, options } = resolveScopedPlatformClient(this.api);
+    const mergedInit = mergeRequestOptions(options, withWorkspaceId(path, init, this.workspaceId));
+    const requestInit = applyPlatformRequestOptions(
+      baseClient,
+      mergedInit
+    );
+    switch (method) {
+      case "GET":
+        return await baseClient.GET(path, requestInit);
+      case "POST":
+        return await baseClient.POST(path, requestInit);
+      case "PUT":
+        return await baseClient.PUT(path, requestInit);
+      case "PATCH":
+        return await baseClient.PATCH(path, requestInit);
+      case "DELETE":
+        return await baseClient.DELETE(path, requestInit);
+      case "HEAD":
+        return await baseClient.HEAD(path, requestInit);
+      case "OPTIONS":
+        return await baseClient.OPTIONS(path, requestInit);
+    }
   }
 };
+function withWorkspaceId(path, init, workspaceId2) {
+  if (!path.includes("{workspace_id}")) {
+    return init ?? {};
+  }
+  const current = init ?? {};
+  return {
+    ...current,
+    params: {
+      ...current.params ?? {},
+      path: {
+        ...current.params?.path ?? {},
+        workspace_id: workspaceId2
+      }
+    }
+  };
+}
 //# sourceMappingURL=index.cjs.map