@amigo-ai/platform-sdk 0.4.0 → 0.4.2

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,20 @@ 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/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 +347,106 @@ 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;
 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 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 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 baseFetch(prepared.request, init);
+        } finally {
+          timedOut = prepared.timedOut;
+          prepared.cleanup();
+        }
       } catch (err) {
         error = err;
       }
@@ -348,6 +454,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 +468,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;
       }
@@ -369,7 +478,8 @@ function createPlatformClient(config) {
   };
   const client = createClient({
     baseUrl: config.baseUrl,
-    fetch: retryingFetch
+    fetch: retryingFetch,
+    headers: config.headers
   });
   const errorMiddleware = {
     async onResponse({ response }) {
@@ -380,32 +490,95 @@ function createPlatformClient(config) {
     }
   };
   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));
 }
-
-// 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 getRequestOption(request, key) {
+  const value = request[key];
+  return value;
 }
-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
@@ -2184,20 +2357,6 @@ 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;
@@ -2211,7 +2370,11 @@ var WebhookVerificationError = class extends Error {
 async function verifyWebhookSignature(payloadOrOptions, signature, secret) {
   const options = normalizeVerificationOptions(payloadOrOptions, signature, secret);
   const payloadBytes = toUint8Array(options.payload);
-  const expectedSignature = await signWebhookPayload(payloadBytes, options.secret, options.timestamp);
+  const expectedSignature = await signWebhookPayload(
+    payloadBytes,
+    options.secret,
+    options.timestamp
+  );
   const actualSignature = normalizeSignature(options.signature);
   if (!actualSignature || !constantTimeEqual(expectedSignature, actualSignature)) {
     return false;
@@ -2292,7 +2455,7 @@ async function signWebhookPayload(payload, secret, timestamp) {
     ["sign"]
   );
   const message = timestamp ? concatUint8Arrays(textEncoder.encode(`v1:${timestamp}:`), payload) : payload;
-  const mac = await crypto.subtle.sign("HMAC", key, message);
+  const mac = await crypto.subtle.sign("HMAC", key, toCryptoBuffer(message));
   return new Uint8Array(mac);
 }
 function normalizeSignature(signature) {
@@ -2328,10 +2491,16 @@ function concatUint8Arrays(left, right) {
   combined.set(right, left.length);
   return combined;
 }
+function toCryptoBuffer(bytes) {
+  const copy = Uint8Array.from(bytes);
+  return copy.buffer;
+}
 
 // src/index.ts
 var DEFAULT_BASE_URL = "https://api.platform.amigo.ai";
 var AmigoClient = class {
+  workspaceId;
+  baseUrl;
   workspaces;
   apiKeys;
   agents;
@@ -2360,6 +2529,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");
@@ -2372,9 +2542,16 @@ 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.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);
@@ -2403,5 +2580,56 @@ var AmigoClient = class {
     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))
+    );
+  }
 };
+function withWorkspaceId(path, init, workspaceId2) {
+  if (!path.includes("{workspace_id}")) {
+    return init ?? {};
+  }
+  const current = init ?? {};
+  return {
+    ...current,
+    params: {
+      ...current.params ?? {},
+      path: {
+        workspace_id: workspaceId2,
+        ...current.params?.path ?? {}
+      }
+    }
+  };
+}
 //# sourceMappingURL=index.cjs.map