@evalgate/sdk 2.0.0

package/dist/client.js

@@ -0,0 +1,893 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIEvalClient = void 0;
+const batch_1 = require("./batch");
+const cache_1 = require("./cache");
+const context_1 = require("./context");
+const errors_1 = require("./errors");
+const logger_1 = require("./logger");
+const version_1 = require("./version");
+/**
+ * Safe environment variable access (works in both Node.js and browsers).
+ * Prefers EVALGATE_* vars; falls back to EVALAI_* with deprecation warning.
+ */
+function getEnvVar(newName, legacyName) {
+    if (typeof process === "undefined" || !process.env)
+        return undefined;
+    const val = process.env[newName];
+    if (val)
+        return val;
+    if (legacyName && process.env[legacyName]) {
+        if (typeof process !== "undefined" &&
+            !process.__EVALGATE_LEGACY_WARNED) {
+            console.warn(`[EvalGate] Deprecation: ${legacyName} is deprecated. Use ${newName} instead.`);
+            process.__EVALGATE_LEGACY_WARNED = true;
+        }
+        return process.env[legacyName];
+    }
+    return undefined;
+}
+/**
+ * EvalGate SDK Client
+ *
+ * @example
+ * ```typescript
+ * import { AIEvalClient } from '@ai-eval-platform/sdk';
+ *
+ * // Zero-config initialization (uses env variables)
+ * const client = AIEvalClient.init();
+ *
+ * // Or with explicit config
+ * const client = new AIEvalClient({
+ *   apiKey: 'your-api-key',
+ *   organizationId: 123,
+ *   debug: true
+ * });
+ *
+ * // Create a trace with automatic context propagation
+ * const trace = await client.traces.create({
+ *   name: 'User Query',
+ *   traceId: 'trace-123'
+ * });
+ * ```
+ */
+class AIEvalClient {
+    constructor(config = {}) {
+        // Tier 1.1: Zero-config with env variable detection (works in Node.js and browsers)
+        this.apiKey =
+            config.apiKey ||
+                getEnvVar("EVALGATE_API_KEY", "EVALAI_API_KEY") ||
+                getEnvVar("AI_EVAL_API_KEY") ||
+                "";
+        if (!this.apiKey) {
+            throw new errors_1.EvalGateError("API key is required. Provide via config.apiKey or EVALGATE_API_KEY environment variable.", "MISSING_API_KEY", 0);
+        }
+        // Auto-detect organization ID from env
+        const orgIdFromEnv = getEnvVar("EVALGATE_ORGANIZATION_ID", "EVALAI_ORGANIZATION_ID") ||
+            getEnvVar("AI_EVAL_ORGANIZATION_ID");
+        this.organizationId =
+            config.organizationId ||
+                (orgIdFromEnv ? parseInt(orgIdFromEnv, 10) : undefined);
+        const isBrowser = typeof globalThis.window !== "undefined";
+        this.baseUrl =
+            config.baseUrl ||
+                getEnvVar("EVALGATE_BASE_URL", "EVALAI_BASE_URL") ||
+                (isBrowser ? "" : "http://localhost:3000");
+        this.timeout = config.timeout || 30000;
+        // Tier 4.17: Debug mode with request logging
+        const logLevel = config.logLevel || (config.debug ? "debug" : "info");
+        this.logger = (0, logger_1.createLogger)({
+            level: logLevel,
+            pretty: config.debug,
+            prefix: "EvalGate",
+        });
+        this.requestLogger = new logger_1.RequestLogger(this.logger);
+        // Retry configuration
+        this.retryConfig = {
+            maxAttempts: config.retry?.maxAttempts || 3,
+            backoff: config.retry?.backoff || "exponential",
+            retryableErrors: config.retry?.retryableErrors || [
+                "RATE_LIMIT_EXCEEDED",
+                "TIMEOUT",
+                "NETWORK_ERROR",
+                "INTERNAL_SERVER_ERROR",
+            ],
+        };
+        // Initialize cache for GET requests
+        this.cache = new cache_1.RequestCache(config.cacheSize || 1000);
+        // Initialize request batcher if enabled (default: enabled)
+        if (config.enableBatching !== false) {
+            const MAX_CONCURRENCY = 5;
+            this.batcher = new batch_1.RequestBatcher(async (requests) => {
+                const results = [];
+                const executing = [];
+                for (const req of requests) {
+                    const task = (async () => {
+                        try {
+                            const data = await this.request(req.endpoint, {
+                                method: req.method,
+                                body: req.body ? JSON.stringify(req.body) : undefined,
+                                headers: req.headers,
+                            });
+                            results.push({ id: req.id, status: 200, data });
+                        }
+                        catch (err) {
+                            const errorObj = err;
+                            results.push({
+                                id: req.id,
+                                status: errorObj?.statusCode || 500,
+                                data: null,
+                                error: errorObj?.message || "Unknown error",
+                            });
+                        }
+                    })();
+                    executing.push(task);
+                    if (executing.length >= MAX_CONCURRENCY) {
+                        await Promise.race(executing);
+                        // Remove settled promises
+                        for (let i = executing.length - 1; i >= 0; i--) {
+                            const settled = await Promise.race([
+                                executing[i].then(() => true),
+                                Promise.resolve(false),
+                            ]);
+                            if (settled)
+                                executing.splice(i, 1);
+                        }
+                    }
+                }
+                await Promise.allSettled(executing);
+                return results;
+            }, {
+                maxBatchSize: config.batchSize || 10,
+                batchDelay: config.batchDelay || 50,
+            });
+        }
+        else {
+            this.batcher = null;
+        }
+        // Initialize API modules
+        this.traces = new TraceAPI(this);
+        this.evaluations = new EvaluationAPI(this);
+        this.llmJudge = new LLMJudgeAPI(this);
+        this.annotations = new AnnotationsAPI(this);
+        this.developer = new DeveloperAPI(this);
+        this.organizations = new OrganizationsAPI(this);
+        this.logger.info("SDK initialized", {
+            hasOrganizationId: !!this.organizationId,
+            baseUrl: this.baseUrl,
+        });
+    }
+    /**
+     * Zero-config initialization using environment variables
+     *
+     * Works in both Node.js and browsers. In Node.js, reads from environment variables.
+     * In browsers, you must provide config explicitly.
+     *
+     * Environment variables (Node.js only):
+     * - EVALGATE_API_KEY (or EVALAI_API_KEY): Your API key
+     * - EVALGATE_ORGANIZATION_ID (or EVALAI_ORGANIZATION_ID): Your organization ID
+     * - EVALGATE_BASE_URL (or EVALAI_BASE_URL): Custom API base URL (optional)
+     *
+     * @example
+     * ```typescript
+     * // Node.js - reads from env vars:
+     * // EVALGATE_API_KEY=your-key
+     * // EVALGATE_ORGANIZATION_ID=123
+     * const client = AIEvalClient.init();
+     *
+     * // Browser - must provide config:
+     * const client = AIEvalClient.init({
+     *   apiKey: 'your-key',
+     *   organizationId: 123
+     * });
+     * ```
+     */
+    static init(config = {}) {
+        return new AIEvalClient({
+            baseUrl: getEnvVar("EVALGATE_BASE_URL", "EVALAI_BASE_URL"),
+            ...config,
+        });
+    }
+    /**
+     * Internal method to make HTTP requests with retry logic and error handling
+     */
+    async request(endpoint, options = {}, attempt = 1) {
+        const method = (options.method || "GET").toUpperCase();
+        const url = `${this.baseUrl}${endpoint}`;
+        // Check cache for GET requests
+        if (method === "GET" && (0, cache_1.shouldCache)(method, endpoint)) {
+            const cached = this.cache.get(method, endpoint, options.body);
+            if (cached !== null) {
+                this.logger.debug("Cache hit", { endpoint });
+                return cached;
+            }
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const startTime = Date.now();
+        // Log request
+        this.requestLogger.logRequest({
+            method: options.method || "GET",
+            url,
+            headers: options.headers,
+            body: options.body,
+        });
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "X-EvalGate-SDK-Version": version_1.SDK_VERSION,
+                    "X-EvalGate-Spec-Version": version_1.SPEC_VERSION,
+                    ...options.headers,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            const duration = Date.now() - startTime;
+            let data;
+            try {
+                data = await response.json();
+            }
+            catch (_e) {
+                data = {};
+            }
+            // Log response
+            this.requestLogger.logResponse({
+                method: options.method || "GET",
+                url,
+                status: response.status,
+                duration,
+                body: data,
+            });
+            if (!response.ok) {
+                const error = (0, errors_1.createErrorFromResponse)(response, data);
+                // Retry logic
+                if (attempt < this.retryConfig.maxAttempts &&
+                    this.retryConfig.retryableErrors.includes(error.code)) {
+                    const delay = this.calculateBackoff(attempt);
+                    this.logger.warn(`Retrying request (attempt ${attempt + 1}/${this.retryConfig.maxAttempts}) after ${delay}ms`, {
+                        error: error.code,
+                        url,
+                    });
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    return this.request(endpoint, options, attempt + 1);
+                }
+                throw error;
+            }
+            // Cache successful GET responses
+            if (method === "GET" && (0, cache_1.shouldCache)(method, endpoint)) {
+                const ttl = (0, cache_1.getTTL)(endpoint);
+                this.cache.set(method, endpoint, data, ttl, options.body);
+                this.logger.debug("Cached response", { endpoint, ttl });
+            }
+            // Invalidate cache for mutation operations
+            if (["POST", "PUT", "DELETE", "PATCH"].includes(method)) {
+                // Invalidate related cached entries
+                const resourceMatch = endpoint.match(/\/api\/(\w+)/);
+                if (resourceMatch) {
+                    this.cache.invalidatePattern(resourceMatch[1]);
+                }
+            }
+            return data;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof errors_1.EvalGateError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                if (error.name === "AbortError") {
+                    throw new errors_1.EvalGateError("Request timeout", "TIMEOUT", 408);
+                }
+                throw new errors_1.EvalGateError(error.message, "NETWORK_ERROR", 0);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Calculate backoff delay for retries
+     */
+    calculateBackoff(attempt) {
+        const baseDelay = 1000; // 1 second
+        switch (this.retryConfig.backoff) {
+            case "exponential":
+                return baseDelay * 2 ** (attempt - 1);
+            case "linear":
+                return baseDelay * attempt;
+            default:
+                return baseDelay;
+        }
+    }
+    getOrganizationId() {
+        return this.organizationId;
+    }
+    /**
+     * Get the logger instance for custom logging
+     */
+    getLogger() {
+        return this.logger;
+    }
+    /**
+     * @deprecated The /api/organizations/:id/limits endpoint does not exist.
+     * Use `organizations.getCurrent()` to get org info instead.
+     */
+    async getOrganizationLimits() {
+        return {};
+    }
+}
+exports.AIEvalClient = AIEvalClient;
+/**
+ * Trace API methods
+ */
+class TraceAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create a new trace with automatic context propagation
+     *
+     * @example
+     * ```typescript
+     * const trace = await client.traces.create({
+     *   name: 'User Query',
+     *   traceId: 'trace-123',
+     *   metadata: { userId: '456' }
+     * });
+     * ```
+     */
+    async create(params) {
+        const orgId = params.organizationId || this.client.getOrganizationId();
+        if (!orgId) {
+            throw new errors_1.EvalGateError("Organization ID is required", "MISSING_ORGANIZATION_ID", 0);
+        }
+        // Merge with context
+        const metadata = (0, context_1.mergeWithContext)(params.metadata || {});
+        return this.client.request("/api/traces", {
+            method: "POST",
+            body: JSON.stringify({ ...params, organizationId: orgId, metadata }),
+        });
+    }
+    /**
+     * List traces with optional filtering
+     */
+    async list(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        if (params.organizationId)
+            searchParams.set("organizationId", params.organizationId.toString());
+        if (params.status)
+            searchParams.set("status", params.status);
+        if (params.search)
+            searchParams.set("search", params.search);
+        const query = searchParams.toString();
+        const endpoint = query ? `/api/traces?${query}` : "/api/traces";
+        return this.client.request(endpoint);
+    }
+    /**
+     * Delete a trace by ID
+     */
+    async delete(id) {
+        return this.client.request(`/api/traces?id=${id}`, {
+            method: "DELETE",
+        });
+    }
+    /**
+     * Get a single trace by ID, including its spans
+     */
+    async get(id) {
+        return this.client.request(`/api/traces/${id}`);
+    }
+    /**
+     * Update an existing trace (e.g. set status, duration, metadata on completion)
+     *
+     * @example
+     * ```typescript
+     * await client.traces.update(42, {
+     *   status: 'success',
+     *   durationMs: 1234,
+     *   metadata: { output: 'done' }
+     * });
+     * ```
+     */
+    async update(id, params) {
+        return this.client.request(`/api/traces/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Create a span for a trace
+     */
+    async createSpan(traceId, params) {
+        return this.client.request(`/api/traces/${traceId}/spans`, {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List spans for a trace
+     */
+    async listSpans(traceId) {
+        return this.client.request(`/api/traces/${traceId}/spans`);
+    }
+}
+/**
+ * Evaluation API methods
+ */
+class EvaluationAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create a new evaluation
+     */
+    async create(params) {
+        const orgId = params.organizationId || this.client.getOrganizationId();
+        if (!orgId) {
+            throw new errors_1.EvalGateError("Organization ID is required", "MISSING_ORGANIZATION_ID", 0);
+        }
+        return this.client.request("/api/evaluations", {
+            method: "POST",
+            body: JSON.stringify({ ...params, organizationId: orgId }),
+        });
+    }
+    /**
+     * Get a single evaluation by ID
+     */
+    async get(id) {
+        return this.client.request(`/api/evaluations?id=${id}`);
+    }
+    /**
+     * List evaluations with optional filtering
+     */
+    async list(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        if (params.organizationId)
+            searchParams.set("organizationId", params.organizationId.toString());
+        if (params.type)
+            searchParams.set("type", params.type);
+        if (params.status)
+            searchParams.set("status", params.status);
+        if (params.search)
+            searchParams.set("search", params.search);
+        const query = searchParams.toString();
+        const endpoint = query ? `/api/evaluations?${query}` : "/api/evaluations";
+        return this.client.request(endpoint);
+    }
+    /**
+     * Update an evaluation
+     */
+    async update(id, params) {
+        return this.client.request(`/api/evaluations?id=${id}`, {
+            method: "PUT",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Delete an evaluation
+     */
+    async delete(id) {
+        return this.client.request(`/api/evaluations?id=${id}`, {
+            method: "DELETE",
+        });
+    }
+    /**
+     * Create a test case for an evaluation
+     */
+    async createTestCase(evaluationId, params) {
+        return this.client.request(`/api/evaluations/${evaluationId}/test-cases`, {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List test cases for an evaluation
+     */
+    async listTestCases(evaluationId) {
+        return this.client.request(`/api/evaluations/${evaluationId}/test-cases`);
+    }
+    /**
+     * Create a run for an evaluation
+     */
+    async createRun(evaluationId, params) {
+        return this.client.request(`/api/evaluations/${evaluationId}/runs`, {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List runs for an evaluation
+     */
+    async listRuns(evaluationId) {
+        return this.client.request(`/api/evaluations/${evaluationId}/runs`);
+    }
+    /**
+     * Get a specific run with its results
+     */
+    async getRun(evaluationId, runId) {
+        return this.client.request(`/api/evaluations/${evaluationId}/runs/${runId}`);
+    }
+}
+/**
+ * LLM Judge API methods
+ */
+class LLMJudgeAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Run an LLM judge evaluation
+     */
+    async evaluate(params) {
+        return this.client.request("/api/llm-judge/evaluate", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Create an LLM judge configuration
+     */
+    async createConfig(params) {
+        return this.client.request("/api/llm-judge/configs", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List LLM judge configurations
+     */
+    async listConfigs(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.organizationId)
+            searchParams.set("organizationId", params.organizationId.toString());
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        const query = searchParams.toString();
+        const endpoint = query
+            ? `/api/llm-judge/configs?${query}`
+            : "/api/llm-judge/configs";
+        return this.client.request(endpoint);
+    }
+    /**
+     * List LLM judge results
+     */
+    async listResults(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.configId)
+            searchParams.set("configId", params.configId.toString());
+        if (params.evaluationId)
+            searchParams.set("evaluationId", params.evaluationId.toString());
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        const query = searchParams.toString();
+        const endpoint = query
+            ? `/api/llm-judge/results?${query}`
+            : "/api/llm-judge/results";
+        return this.client.request(endpoint);
+    }
+    /**
+     * Get alignment analysis
+     */
+    async getAlignment(params) {
+        const searchParams = new URLSearchParams();
+        searchParams.set("evaluationRunId", params.evaluationRunId.toString());
+        const query = searchParams.toString();
+        return this.client.request(`/api/llm-judge/alignment?${query}`);
+    }
+}
+/**
+ * Annotations API methods
+ */
+class AnnotationsAPI {
+    constructor(client) {
+        this.client = client;
+        this.tasks = new AnnotationTasksAPI(client);
+    }
+    /**
+     * Create an annotation
+     */
+    async create(params) {
+        return this.client
+            .request("/api/annotations", {
+            method: "POST",
+            body: JSON.stringify(params),
+        })
+            .then((res) => res.annotation);
+    }
+    /**
+     * List annotations
+     */
+    async list(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.evaluationRunId)
+            searchParams.set("evaluationRunId", params.evaluationRunId.toString());
+        if (params.testCaseId)
+            searchParams.set("testCaseId", params.testCaseId.toString());
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        const query = searchParams.toString();
+        const endpoint = query ? `/api/annotations?${query}` : "/api/annotations";
+        return this.client
+            .request(endpoint)
+            .then((res) => res.annotations);
+    }
+}
+/**
+ * Annotation Tasks API methods
+ */
+class AnnotationTasksAPI {
+    constructor(client) {
+        this.client = client;
+        this.items = new AnnotationTaskItemsAPI(client);
+    }
+    /**
+     * Create an annotation task
+     */
+    async create(params) {
+        return this.client.request("/api/annotations/tasks", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List annotation tasks
+     */
+    async list(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.organizationId)
+            searchParams.set("organizationId", params.organizationId.toString());
+        if (params.status)
+            searchParams.set("status", params.status);
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        const query = searchParams.toString();
+        const endpoint = query
+            ? `/api/annotations/tasks?${query}`
+            : "/api/annotations/tasks";
+        return this.client.request(endpoint);
+    }
+    /**
+     * Get an annotation task
+     */
+    async get(taskId) {
+        return this.client
+            .request(`/api/annotations/tasks/${taskId}`)
+            .then((res) => res.task);
+    }
+}
+/**
+ * Annotation Task Items API methods
+ */
+class AnnotationTaskItemsAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create an annotation item
+     */
+    async create(taskId, params) {
+        return this.client.request(`/api/annotations/tasks/${taskId}/items`, {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List annotation items
+     */
+    async list(taskId, params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        const query = searchParams.toString();
+        const endpoint = query
+            ? `/api/annotations/tasks/${taskId}/items?${query}`
+            : `/api/annotations/tasks/${taskId}/items`;
+        return this.client.request(endpoint);
+    }
+}
+/**
+ * Developer API methods
+ */
+class DeveloperAPI {
+    constructor(client) {
+        this.client = client;
+        this.apiKeys = new APIKeysAPI(client);
+        this.webhooks = new WebhooksAPI(client);
+    }
+    /**
+     * Get usage statistics
+     */
+    async getUsage(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.period)
+            searchParams.set("period", params.period);
+        if (params.groupBy)
+            searchParams.set("groupBy", params.groupBy);
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        const query = searchParams.toString();
+        const endpoint = query
+            ? `/api/developer/usage?${query}`
+            : "/api/developer/usage";
+        return this.client.request(endpoint);
+    }
+    /**
+     * Get usage summary
+     */
+    async getUsageSummary(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.period)
+            searchParams.set("period", params.period);
+        const query = searchParams.toString();
+        const endpoint = query
+            ? `/api/developer/usage/summary?${query}`
+            : "/api/developer/usage/summary";
+        return this.client.request(endpoint);
+    }
+}
+/**
+ * API Keys API methods
+ */
+class APIKeysAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create an API key
+     */
+    async create(params) {
+        return this.client.request("/api/developer/api-keys", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List API keys
+     */
+    async list(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.organizationId)
+            searchParams.set("organizationId", params.organizationId.toString());
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        const query = searchParams.toString();
+        const endpoint = query
+            ? `/api/developer/api-keys?${query}`
+            : "/api/developer/api-keys";
+        return this.client.request(endpoint);
+    }
+    /**
+     * Update an API key
+     */
+    async update(keyId, params) {
+        return this.client.request(`/api/developer/api-keys/${keyId}`, {
+            method: "PATCH",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Revoke an API key
+     */
+    async revoke(keyId) {
+        return this.client.request(`/api/developer/api-keys/${keyId}`, {
+            method: "DELETE",
+        });
+    }
+    /**
+     * Get API key usage
+     */
+    async getUsage(keyId) {
+        return this.client.request(`/api/developer/api-keys/${keyId}/usage`);
+    }
+}
+/**
+ * Webhooks API methods
+ */
+class WebhooksAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create a webhook
+     */
+    async create(params) {
+        return this.client.request("/api/developer/webhooks", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * List webhooks
+     */
+    async list(params) {
+        const searchParams = new URLSearchParams();
+        searchParams.set("organizationId", params.organizationId.toString());
+        if (params.status)
+            searchParams.set("status", params.status);
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        const query = searchParams.toString();
+        return this.client.request(`/api/developer/webhooks?${query}`);
+    }
+    /**
+     * Get a webhook
+     */
+    async get(webhookId) {
+        return this.client.request(`/api/developer/webhooks/${webhookId}`);
+    }
+    /**
+     * Update a webhook
+     */
+    async update(webhookId, params) {
+        return this.client.request(`/api/developer/webhooks/${webhookId}`, {
+            method: "PATCH",
+            body: JSON.stringify(params),
+        });
+    }
+    /**
+     * Delete a webhook
+     */
+    async delete(webhookId) {
+        return this.client.request(`/api/developer/webhooks/${webhookId}`, {
+            method: "DELETE",
+        });
+    }
+    /**
+     * Get webhook deliveries
+     */
+    async getDeliveries(webhookId, params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params.offset)
+            searchParams.set("offset", params.offset.toString());
+        if (params.status)
+            searchParams.set("status", params.status);
+        const query = searchParams.toString();
+        const endpoint = query
+            ? `/api/developer/webhooks/${webhookId}/deliveries?${query}`
+            : `/api/developer/webhooks/${webhookId}/deliveries`;
+        return this.client.request(endpoint);
+    }
+}
+/**
+ * Organizations API methods
+ */
+class OrganizationsAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get current organization
+     */
+    async getCurrent() {
+        return this.client
+            .request("/api/organizations/current")
+            .then((res) => res.organization);
+    }
+}