@amigo-ai/platform-sdk 0.4.2 → 0.4.4

package/dist/index.cjs

@@ -314,9 +314,94 @@ function parseRateLimitHeaders(headers) {
   };
 }
 
+// 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]);
+var jitterCounter = 0;
 function shouldRetry(ctx) {
   const { method, attempt, response, options } = ctx;
   if (attempt >= options.maxAttempts) return false;
@@ -336,7 +421,7 @@ function computeDelay(attempt, response, options) {
     if (seconds !== void 0) return seconds * 1e3;
   }
   const exponential = Math.min(options.maxDelayMs, options.baseDelayMs * Math.pow(2, attempt));
-  return Math.random() * exponential;
+  return jitterFraction() * exponential;
 }
 function parseRetryAfterHeader(header) {
   const seconds = Number(header);
@@ -355,6 +440,31 @@ function resolveRetryOptions(opts, maxRetries) {
     maxDelayMs: opts?.maxDelayMs ?? 3e4
   };
 }
+function jitterFraction() {
+  const cryptoApi = getCryptoApi();
+  if (cryptoApi) {
+    const value = new Uint32Array(1);
+    cryptoApi.getRandomValues(value);
+    return (value[0] ?? 0) / 4294967296;
+  }
+  jitterCounter = jitterCounter + 1 >>> 0;
+  const mixed = mixUint32((Date.now() ^ Math.imul(jitterCounter, 2654435769)) >>> 0);
+  return mixed / 4294967296;
+}
+function getCryptoApi() {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi && typeof cryptoApi.getRandomValues === "function") {
+    return cryptoApi;
+  }
+  return void 0;
+}
+function mixUint32(value) {
+  let mixed = (value ^ value >>> 16) >>> 0;
+  mixed = Math.imul(mixed, 2146121005) >>> 0;
+  mixed = (mixed ^ mixed >>> 15) >>> 0;
+  mixed = Math.imul(mixed, 2221713035) >>> 0;
+  return (mixed ^ mixed >>> 16) >>> 0;
+}
 
 // src/core/utils.ts
 function extractRequestId(response) {
@@ -422,18 +532,89 @@ function defineHiddenMetadata(target, key, value) {
 
 // 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 baseFetch = config.fetch ?? globalThis.fetch;
-  const retryingFetch = async (input, init) => {
+  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 requestRetry = getRequestOption(baseRequest, "retry");
-    const requestMaxRetries = getRequestOption(baseRequest, "maxRetries");
-    const retryOpts = resolveRetryOptions(
-      requestRetry ?? config.retry,
-      requestMaxRetries ?? config.maxRetries
-    );
-    const timeoutMs = getRequestOption(baseRequest, "timeout") ?? config.timeout;
+    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;
@@ -442,7 +623,7 @@ function createPlatformClient(config) {
       try {
         const prepared = prepareRequestForAttempt(baseRequest, timeoutMs);
         try {
-          response = await baseFetch(prepared.request, init);
+          response = await transport(prepared.request);
         } finally {
           timedOut = prepared.timedOut;
           prepared.cleanup();
@@ -476,53 +657,12 @@ function createPlatformClient(config) {
     }
     throw new NetworkError("Retry loop exhausted");
   };
-  const client = createClient({
-    baseUrl: config.baseUrl,
-    fetch: retryingFetch,
-    headers: config.headers
-  });
-  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 sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function getRequestOption(request, key) {
-  const value = request[key];
-  return value;
+function toRequestTransport(fetcher) {
+  return async (input) => fetcher(input);
 }
 function prepareRequestForAttempt(request, timeoutMs) {
   const attemptRequest = request.clone();
@@ -582,12 +722,98 @@ function createTimeoutSignal(upstream, timeoutMs) {
 }
 
 // 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 {
@@ -2360,6 +2586,7 @@ var dataSourceId = (id) => id;
 // 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);
@@ -2447,6 +2674,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),
@@ -2458,6 +2686,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) {
@@ -2498,7 +2733,7 @@ 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;
@@ -2548,72 +2783,97 @@ var AmigoClient = class {
       hooks: config.hooks,
       fetch: config.fetch
     });
-    const ws = config.workspaceId;
-    this.workspaceId = ws;
-    this.baseUrl = baseUrl;
-    this.api = client;
-    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);
-  }
-  async GET(path, init) {
-    return withResponse(
-      await this.api.GET(path, withWorkspaceId(path, init, this.workspaceId))
-    );
-  }
-  async POST(path, init) {
-    return withResponse(
-      await this.api.POST(path, withWorkspaceId(path, init, this.workspaceId))
-    );
-  }
-  async PUT(path, init) {
-    return withResponse(
-      await this.api.PUT(path, withWorkspaceId(path, init, this.workspaceId))
-    );
-  }
-  async PATCH(path, init) {
-    return withResponse(
-      await this.api.PATCH(path, withWorkspaceId(path, init, this.workspaceId))
-    );
-  }
-  async DELETE(path, init) {
-    return withResponse(
-      await this.api.DELETE(path, withWorkspaceId(path, init, this.workspaceId))
-    );
-  }
-  async HEAD(path, init) {
-    return withResponse(
-      await this.api.HEAD(path, withWorkspaceId(path, init, this.workspaceId))
-    );
-  }
-  async OPTIONS(path, init) {
-    return withResponse(
-      await this.api.OPTIONS(path, withWorkspaceId(path, init, this.workspaceId))
-    );
+    _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) {
@@ -2626,8 +2886,8 @@ function withWorkspaceId(path, init, workspaceId2) {
     params: {
       ...current.params ?? {},
       path: {
-        workspace_id: workspaceId2,
-        ...current.params?.path ?? {}
+        ...current.params?.path ?? {},
+        workspace_id: workspaceId2
       }
     }
   };