@rustrak/client 0.3.13 → 0.3.15

package/dist/index.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import ky, { isHTTPError } from 'ky';
 
-// src/resources/alert-integrations.ts
+// src/resources/agents.ts
 var paginatedResponseSchema = (itemSchema) => z.object({
   items: z.array(itemSchema),
   next_cursor: z.string().optional(),
@@ -32,7 +32,29 @@ z.object({
   message: z.string().optional()
 });
 
-// src/schemas/alert.ts
+// src/schemas/agent.ts
+var agentTimeseriesPointSchema = z.object({
+  bucket: dateTimeSchema,
+  value: z.number()
+});
+var agentDurationPointSchema = z.object({
+  bucket: dateTimeSchema,
+  avg_ms: z.number(),
+  p95_ms: z.number()
+});
+var genAiBreakdownRowSchema = z.object({
+  label: z.string(),
+  value: z.number()
+});
+var agentTraceSummarySchema = z.object({
+  trace_id: z.string(),
+  /** Every distinct agent that ran in this trace, earliest first. */
+  agent_names: z.array(z.string()),
+  duration_ms: z.number().nullable(),
+  total_tokens: z.number(),
+  tool_call_count: z.number().int(),
+  started_at: dateTimeSchema
+});
 var providerTypeSchema = z.enum(["webhook", "email", "slack"]);
 var alertTypeSchema = z.enum(["new_issue", "regression", "unmute"]);
 var alertStatusSchema = z.enum([
@@ -56,443 +78,73 @@ var alertIntegrationSchema = z.object({
 });
 var createAlertIntegrationSchema = z.object({
   name: z.string().min(1),
-  provider_type: providerTypeSchema,
-  credentials: z.record(z.string(), z.unknown()),
-  is_enabled: z.boolean().optional()
-});
-var updateAlertIntegrationSchema = z.object({
-  name: z.string().min(1).optional(),
-  credentials: z.record(z.string(), z.unknown()).optional(),
-  is_enabled: z.boolean().optional()
-});
-var alertRuleChannelInputSchema = z.object({
-  integration_id: z.number().int(),
-  routing_override: z.record(z.string(), z.unknown()).default({})
-});
-var alertRuleSchema = z.object({
-  id: z.number().int(),
-  project_id: z.number().int(),
-  name: z.string(),
-  alert_type: alertTypeSchema,
-  is_enabled: z.boolean(),
-  conditions: z.record(z.string(), z.unknown()),
-  cooldown_minutes: z.number().int(),
-  last_triggered_at: dateTimeSchema.nullable(),
-  created_at: dateTimeSchema,
-  updated_at: dateTimeSchema,
-  channels: z.array(alertRuleChannelInputSchema).default([]),
-  integration_ids: z.array(z.number().int())
-});
-var createAlertRuleSchema = z.object({
-  name: z.string().min(1),
-  alert_type: alertTypeSchema,
-  channels: z.array(alertRuleChannelInputSchema).default([]),
-  is_enabled: z.boolean().optional(),
-  conditions: z.record(z.string(), z.unknown()).optional(),
-  cooldown_minutes: z.number().int().min(0).optional()
-});
-var updateAlertRuleSchema = z.object({
-  name: z.string().min(1).optional(),
-  is_enabled: z.boolean().optional(),
-  conditions: z.record(z.string(), z.unknown()).optional(),
-  cooldown_minutes: z.number().int().min(0).optional(),
-  channels: z.array(alertRuleChannelInputSchema).optional()
-});
-var alertHistorySchema = z.object({
-  id: z.number().int(),
-  alert_rule_id: z.number().int().nullable(),
-  integration_id: z.number().int().nullable(),
-  issue_id: z.string().uuid().nullable(),
-  project_id: z.number().int().nullable(),
-  alert_type: z.string(),
-  channel_type: z.string(),
-  channel_name: z.string(),
-  status: alertStatusSchema,
-  attempt_count: z.number().int(),
-  next_retry_at: dateTimeSchema.nullable(),
-  error_message: z.string().nullable(),
-  http_status_code: z.number().int().nullable(),
-  idempotency_key: z.string(),
-  created_at: dateTimeSchema,
-  sent_at: dateTimeSchema.nullable()
-});
-var testChannelResponseSchema = z.object({
-  success: z.boolean(),
-  message: z.string()
-});
-var testIntegrationBodySchema = z.object({
-  routing_override: z.record(z.string(), z.unknown()).optional()
-});
-
-// src/errors/base.ts
-var RustrakError = class extends Error {
-  /**
-   * Whether this error is safe to retry
-   */
-  retryable;
-  /**
-   * HTTP status code if applicable
-   */
-  statusCode;
-  /**
-   * Original error cause
-   */
-  cause;
-  constructor(message, options) {
-    super(message);
-    this.name = this.constructor.name;
-    this.retryable = options?.retryable ?? false;
-    this.statusCode = options?.statusCode;
-    this.cause = options?.cause;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-};
-
-// src/errors/http.ts
-var NetworkError = class extends RustrakError {
-  constructor(message, cause) {
-    super(message, { retryable: true, cause });
-  }
-};
-var AuthenticationError = class extends RustrakError {
-  constructor(message = "Authentication failed") {
-    super(message, { retryable: false, statusCode: 401 });
-  }
-};
-var AuthorizationError = class extends RustrakError {
-  constructor(message = "Insufficient permissions") {
-    super(message, { retryable: false, statusCode: 403 });
-  }
-};
-var NotFoundError = class extends RustrakError {
-  constructor(resource) {
-    super(`Resource not found: ${resource}`, {
-      retryable: false,
-      statusCode: 404
-    });
-  }
-};
-var RateLimitError = class extends RustrakError {
-  /**
-   * Number of seconds to wait before retrying (from Retry-After header)
-   */
-  retryAfter;
-  constructor(message = "Rate limit exceeded", retryAfter) {
-    super(message, { retryable: true, statusCode: 429 });
-    if (retryAfter !== void 0) {
-      this.retryAfter = typeof retryAfter === "string" ? parseInt(retryAfter, 10) : retryAfter;
-    }
-  }
-};
-var ServerError = class extends RustrakError {
-  constructor(message, statusCode = 500) {
-    super(message, { retryable: true, statusCode });
-  }
-};
-var BadRequestError = class extends RustrakError {
-  constructor(message) {
-    super(message, { retryable: false, statusCode: 400 });
-  }
-};
-
-// src/errors/validation.ts
-var ValidationError = class extends RustrakError {
-  /**
-   * Zod validation errors
-   */
-  validationErrors;
-  constructor(message, validationErrors) {
-    super(message, { retryable: false });
-    this.validationErrors = validationErrors;
-  }
-  /**
-   * Get a formatted string of validation errors
-   */
-  getValidationDetails() {
-    if (!this.validationErrors) {
-      return this.message;
-    }
-    const errors = this.validationErrors.issues.map((err) => `${err.path.map(String).join(".")}: ${err.message}`).join(", ");
-    return `${this.message} - ${errors}`;
-  }
-};
-
-// src/resources/base.ts
-var BaseResource = class {
-  http;
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Validate API response against Zod schema
-   * @throws {ValidationError} if validation fails
-   */
-  validate(data, schema) {
-    const result = schema.safeParse(data);
-    if (!result.success) {
-      throw new ValidationError("API response validation failed", result.error);
-    }
-    return result.data;
-  }
-};
-
-// src/resources/alert-integrations.ts
-var AlertIntegrationsResource = class extends BaseResource {
-  /**
-   * List all alert integrations
-   */
-  async list() {
-    const data = await this.http.get("api/integrations").json();
-    return this.validate(data, z.array(alertIntegrationSchema));
-  }
-  /**
-   * Get a single alert integration by ID
-   */
-  async get(id) {
-    const data = await this.http.get(`api/integrations/${id}`).json();
-    return this.validate(data, alertIntegrationSchema);
-  }
-  /**
-   * Create a new alert integration
-   */
-  async create(input) {
-    const validatedInput = this.validate(input, createAlertIntegrationSchema);
-    const data = await this.http.post("api/integrations", { json: validatedInput }).json();
-    return this.validate(data, alertIntegrationSchema);
-  }
-  /**
-   * Update an existing alert integration
-   */
-  async update(id, input) {
-    const validatedInput = this.validate(input, updateAlertIntegrationSchema);
-    const data = await this.http.patch(`api/integrations/${id}`, { json: validatedInput }).json();
-    return this.validate(data, alertIntegrationSchema);
-  }
-  /**
-   * Delete an alert integration
-   */
-  async delete(id) {
-    await this.http.delete(`api/integrations/${id}`);
-  }
-  /**
-   * Send a test notification to verify integration configuration.
-   * For Slack bot_token integrations, routingOverride must include `channel`.
-   */
-  async test(id, routingOverride) {
-    const body = routingOverride !== void 0 ? this.validate(
-      { routing_override: routingOverride },
-      testIntegrationBodySchema
-    ) : void 0;
-    const data = await this.http.post(
-      `api/integrations/${id}/test`,
-      body !== void 0 ? { json: body } : void 0
-    ).json();
-    return this.validate(data, testChannelResponseSchema);
-  }
-};
-var AlertRulesResource = class extends BaseResource {
-  /**
-   * List all alert rules for a project
-   */
-  async list(projectId) {
-    const data = await this.http.get(`api/projects/${projectId}/alert-rules`).json();
-    return this.validate(data, z.array(alertRuleSchema));
-  }
-  /**
-   * Get a single alert rule by ID
-   */
-  async get(projectId, ruleId) {
-    const data = await this.http.get(`api/projects/${projectId}/alert-rules/${ruleId}`).json();
-    return this.validate(data, alertRuleSchema);
-  }
-  /**
-   * Create a new alert rule for a project
-   */
-  async create(projectId, input) {
-    const validatedInput = this.validate(input, createAlertRuleSchema);
-    const data = await this.http.post(`api/projects/${projectId}/alert-rules`, { json: validatedInput }).json();
-    return this.validate(data, alertRuleSchema);
-  }
-  /**
-   * Update an existing alert rule
-   */
-  async update(projectId, ruleId, input) {
-    const validatedInput = this.validate(input, updateAlertRuleSchema);
-    const data = await this.http.patch(`api/projects/${projectId}/alert-rules/${ruleId}`, {
-      json: validatedInput
-    }).json();
-    return this.validate(data, alertRuleSchema);
-  }
-  /**
-   * Delete an alert rule
-   */
-  async delete(projectId, ruleId) {
-    await this.http.delete(`api/projects/${projectId}/alert-rules/${ruleId}`);
-  }
-  /**
-   * List alert history for a project
-   */
-  async listHistory(projectId, options) {
-    const searchParams = new URLSearchParams();
-    if (options?.limit !== void 0) {
-      searchParams.set("limit", options.limit.toString());
-    }
-    const query = searchParams.toString();
-    const url = query ? `api/projects/${projectId}/alert-history?${query}` : `api/projects/${projectId}/alert-history`;
-    const data = await this.http.get(url).json();
-    return this.validate(data, z.array(alertHistorySchema));
-  }
-};
-var globalRoleSchema = z.enum(["admin", "member"]);
-var teamMemberSchema = z.object({
-  id: z.number().int(),
-  email: z.string().email(),
-  role: globalRoleSchema,
-  is_active: z.boolean(),
-  /** True for the first-registered account, which cannot be demoted or deleted. */
-  is_primary: z.boolean().optional(),
-  created_at: dateTimeSchema,
-  last_login: dateTimeSchema.nullable().optional()
-});
-var updateUserRoleSchema = z.object({
-  role: globalRoleSchema
-});
-
-// src/schemas/invitation.ts
-var invitationStatusSchema = z.string();
-var invitationSchema = z.object({
-  token: z.string(),
-  email: z.string().email(),
-  role: globalRoleSchema,
-  status: invitationStatusSchema,
-  expires_at: dateTimeSchema,
-  created_at: dateTimeSchema
-});
-var invitationInfoSchema = z.object({
-  email: z.string().email(),
-  role: globalRoleSchema,
-  status: invitationStatusSchema,
-  expires_at: dateTimeSchema
-});
-var createInvitationSchema = z.object({
-  email: z.string().email(),
-  role: globalRoleSchema
-});
-var acceptInvitationSchema = z.object({
-  token: z.string().min(1),
-  password: z.string().min(1)
-});
-var userSchema = z.object({
-  id: z.number().int().positive(),
-  email: z.string().email(),
-  role: globalRoleSchema,
-  is_admin: z.boolean()
-});
-var authResponseSchema = z.object({
-  user: userSchema
-});
-z.object({
-  user: userSchema,
-  cookies: z.array(z.string())
-});
-var loginRequestSchema = z.object({
-  email: z.string().email(),
-  password: z.string().min(1)
-});
-var registerRequestSchema = z.object({
-  email: z.string().email(),
-  password: z.string().min(1)
-});
-
-// src/resources/auth.ts
-var AuthResource = class extends BaseResource {
-  /**
-   * Register a new user account
-   * Creates a new user and automatically logs them in (sets session cookie)
-   * @param credentials - Email and password for the new account
-   * @returns LoginResult with user information and session cookies
-   */
-  async register(credentials) {
-    const validatedInput = this.validate(credentials, registerRequestSchema);
-    const response = await this.http.post("auth/register", {
-      json: validatedInput
-    });
-    const cookies = response.headers.getSetCookie();
-    const data = await response.json();
-    const authResponse = this.validate(data, authResponseSchema);
-    return {
-      user: authResponse.user,
-      cookies
-    };
-  }
-  /**
-   * Login with email and password
-   * Authenticates the user and sets a session cookie
-   * @param credentials - Email and password
-   * @returns LoginResult with user information and session cookies
-   */
-  async login(credentials) {
-    const validatedInput = this.validate(credentials, loginRequestSchema);
-    const response = await this.http.post("auth/login", {
-      json: validatedInput
-    });
-    const cookies = response.headers.getSetCookie();
-    const data = await response.json();
-    const authResponse = this.validate(data, authResponseSchema);
-    return {
-      user: authResponse.user,
-      cookies
-    };
-  }
-  /**
-   * Logout the current user
-   * Clears the session cookie
-   * @returns Array of Set-Cookie headers (typically clearing cookies)
-   */
-  async logout() {
-    const response = await this.http.post("auth/logout");
-    return response.headers.getSetCookie();
-  }
-  /**
-   * Get current authenticated user
-   * Requires a valid session cookie
-   * @returns User information
-   */
-  async getCurrentUser() {
-    const data = await this.http.get("auth/me").json();
-    return this.validate(data, userSchema);
-  }
-  /**
-   * Get the details of a pending invitation by its token (public endpoint)
-   * Used by the accept-invitation page before the user has an account
-   * @param token - Invitation token
-   * @returns Invitation info (email, role, status, expiry)
-   */
-  async getInvitation(token) {
-    const data = await this.http.get(`auth/invitation/${token}`).json();
-    return this.validate(data, invitationInfoSchema);
-  }
-  /**
-   * Accept a pending invitation, creating the user account and logging in
-   * @param input - Invitation token and the new account's password
-   * @returns LoginResult with user information and session cookies
-   */
-  async acceptInvitation(input) {
-    const validatedInput = this.validate(input, acceptInvitationSchema);
-    const response = await this.http.post("auth/accept-invitation", {
-      json: validatedInput
-    });
-    const cookies = response.headers.getSetCookie();
-    const data = await response.json();
-    const authResponse = this.validate(data, authResponseSchema);
-    return {
-      user: authResponse.user,
-      cookies
-    };
-  }
-};
+  provider_type: providerTypeSchema,
+  credentials: z.record(z.string(), z.unknown()),
+  is_enabled: z.boolean().optional()
+});
+var updateAlertIntegrationSchema = z.object({
+  name: z.string().min(1).optional(),
+  credentials: z.record(z.string(), z.unknown()).optional(),
+  is_enabled: z.boolean().optional()
+});
+var alertRuleChannelInputSchema = z.object({
+  integration_id: z.number().int(),
+  routing_override: z.record(z.string(), z.unknown()).default({})
+});
+var alertRuleSchema = z.object({
+  id: z.number().int(),
+  project_id: z.number().int(),
+  name: z.string(),
+  alert_type: alertTypeSchema,
+  is_enabled: z.boolean(),
+  conditions: z.record(z.string(), z.unknown()),
+  cooldown_minutes: z.number().int(),
+  last_triggered_at: dateTimeSchema.nullable(),
+  created_at: dateTimeSchema,
+  updated_at: dateTimeSchema,
+  channels: z.array(alertRuleChannelInputSchema).default([]),
+  integration_ids: z.array(z.number().int())
+});
+var createAlertRuleSchema = z.object({
+  name: z.string().min(1),
+  alert_type: alertTypeSchema,
+  channels: z.array(alertRuleChannelInputSchema).default([]),
+  is_enabled: z.boolean().optional(),
+  conditions: z.record(z.string(), z.unknown()).optional(),
+  cooldown_minutes: z.number().int().min(0).optional()
+});
+var updateAlertRuleSchema = z.object({
+  name: z.string().min(1).optional(),
+  is_enabled: z.boolean().optional(),
+  conditions: z.record(z.string(), z.unknown()).optional(),
+  cooldown_minutes: z.number().int().min(0).optional(),
+  channels: z.array(alertRuleChannelInputSchema).optional()
+});
+var alertHistorySchema = z.object({
+  id: z.number().int(),
+  alert_rule_id: z.number().int().nullable(),
+  integration_id: z.number().int().nullable(),
+  issue_id: z.string().uuid().nullable(),
+  project_id: z.number().int().nullable(),
+  alert_type: z.string(),
+  channel_type: z.string(),
+  channel_name: z.string(),
+  status: alertStatusSchema,
+  attempt_count: z.number().int(),
+  next_retry_at: dateTimeSchema.nullable(),
+  error_message: z.string().nullable(),
+  http_status_code: z.number().int().nullable(),
+  idempotency_key: z.string(),
+  created_at: dateTimeSchema,
+  sent_at: dateTimeSchema.nullable()
+});
+var testChannelResponseSchema = z.object({
+  success: z.boolean(),
+  message: z.string()
+});
+var testIntegrationBodySchema = z.object({
+  routing_override: z.record(z.string(), z.unknown()).optional()
+});
 var eventSchema = z.object({
   id: uuidSchema,
   event_id: eventIdSchema,
@@ -523,6 +175,45 @@ var eventDetailSchema = z.object({
   data: z.record(z.string(), z.any())
   // Full Sentry event JSON
 });
+var globalRoleSchema = z.enum(["admin", "member"]);
+var teamMemberSchema = z.object({
+  id: z.number().int(),
+  email: z.string().email(),
+  role: globalRoleSchema,
+  is_active: z.boolean(),
+  /** True for the first-registered account, which cannot be demoted or deleted. */
+  is_primary: z.boolean().optional(),
+  created_at: dateTimeSchema,
+  last_login: dateTimeSchema.nullable().optional()
+});
+var updateUserRoleSchema = z.object({
+  role: globalRoleSchema
+});
+
+// src/schemas/invitation.ts
+var invitationStatusSchema = z.string();
+var invitationSchema = z.object({
+  token: z.string(),
+  email: z.string().email(),
+  role: globalRoleSchema,
+  status: invitationStatusSchema,
+  expires_at: dateTimeSchema,
+  created_at: dateTimeSchema
+});
+var invitationInfoSchema = z.object({
+  email: z.string().email(),
+  role: globalRoleSchema,
+  status: invitationStatusSchema,
+  expires_at: dateTimeSchema
+});
+var createInvitationSchema = z.object({
+  email: z.string().email(),
+  role: globalRoleSchema
+});
+var acceptInvitationSchema = z.object({
+  token: z.string().min(1),
+  password: z.string().min(1)
+});
 var issueStatusSchema = z.enum(["unresolved", "resolved", "ignored"]);
 var issuePrioritySchema = z.enum(["low", "medium", "high"]);
 var issueSchema = z.object({
@@ -643,9 +334,6 @@ var bulkUpdateIssuesSchema = z.object({
 var bulkDeleteIssuesSchema = z.object({
   ids: z.array(uuidSchema)
 });
-var createDeploySchema = z.object({
-  version: z.string()
-});
 var logSchema = z.object({
   id: uuidSchema,
   trace_id: z.string().nullable(),
@@ -826,6 +514,8 @@ var transactionDetailSchema = z.object({
 });
 var spanSchema = z.object({
   id: uuidSchema,
+  /** Parent transaction, if this span was extracted from one. `null` for a standalone span. */
+  transaction_id: uuidSchema.nullable(),
   span_id: z.string().nullable(),
   trace_id: z.string().nullable(),
   parent_span_id: z.string().nullable(),
@@ -837,7 +527,21 @@ var spanSchema = z.object({
   duration_ms: z.number().nullable(),
   exclusive_time_ms: z.number().nullable(),
   is_segment: z.boolean(),
-  segment_id: z.string().nullable()
+  segment_id: z.string().nullable(),
+  /** Only ever set for standalone spans — a transaction-embedded span has no parent row to inherit these from. */
+  platform: z.string().nullable(),
+  release: z.string().nullable(),
+  environment: z.string().nullable(),
+  /** gen_ai.* denormalized fields — all null unless recognized as an AI span. */
+  gen_ai_operation_type: z.string().nullable(),
+  gen_ai_agent_name: z.string().nullable(),
+  gen_ai_request_model: z.string().nullable(),
+  gen_ai_response_model: z.string().nullable(),
+  gen_ai_tool_name: z.string().nullable(),
+  gen_ai_conversation_id: z.string().nullable(),
+  gen_ai_usage_input_tokens: z.number().nullable(),
+  gen_ai_usage_output_tokens: z.number().nullable(),
+  gen_ai_usage_total_tokens: z.number().nullable()
 });
 var transactionStatsSchema = z.object({
   transaction_name: z.string(),
@@ -848,6 +552,422 @@ var transactionStatsSchema = z.object({
   p99_ms: z.number(),
   failure_rate: z.number()
 });
+var userSchema = z.object({
+  id: z.number().int().positive(),
+  email: z.string().email(),
+  role: globalRoleSchema,
+  is_admin: z.boolean()
+});
+var authResponseSchema = z.object({
+  user: userSchema
+});
+z.object({
+  user: userSchema,
+  cookies: z.array(z.string())
+});
+var loginRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(1)
+});
+var registerRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(1)
+});
+
+// src/errors/base.ts
+var RustrakError = class extends Error {
+  /**
+   * Whether this error is safe to retry
+   */
+  retryable;
+  /**
+   * HTTP status code if applicable
+   */
+  statusCode;
+  /**
+   * Original error cause
+   */
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    this.retryable = options?.retryable ?? false;
+    this.statusCode = options?.statusCode;
+    this.cause = options?.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+
+// src/errors/http.ts
+var NetworkError = class extends RustrakError {
+  constructor(message, cause) {
+    super(message, { retryable: true, cause });
+  }
+};
+var AuthenticationError = class extends RustrakError {
+  constructor(message = "Authentication failed") {
+    super(message, { retryable: false, statusCode: 401 });
+  }
+};
+var AuthorizationError = class extends RustrakError {
+  constructor(message = "Insufficient permissions") {
+    super(message, { retryable: false, statusCode: 403 });
+  }
+};
+var NotFoundError = class extends RustrakError {
+  constructor(resource) {
+    super(`Resource not found: ${resource}`, {
+      retryable: false,
+      statusCode: 404
+    });
+  }
+};
+var RateLimitError = class extends RustrakError {
+  /**
+   * Number of seconds to wait before retrying (from Retry-After header)
+   */
+  retryAfter;
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, { retryable: true, statusCode: 429 });
+    if (retryAfter !== void 0) {
+      this.retryAfter = typeof retryAfter === "string" ? parseInt(retryAfter, 10) : retryAfter;
+    }
+  }
+};
+var ServerError = class extends RustrakError {
+  constructor(message, statusCode = 500) {
+    super(message, { retryable: true, statusCode });
+  }
+};
+var BadRequestError = class extends RustrakError {
+  constructor(message) {
+    super(message, { retryable: false, statusCode: 400 });
+  }
+};
+
+// src/errors/validation.ts
+var ValidationError = class extends RustrakError {
+  /**
+   * Zod validation errors
+   */
+  validationErrors;
+  constructor(message, validationErrors) {
+    super(message, { retryable: false });
+    this.validationErrors = validationErrors;
+  }
+  /**
+   * Get a formatted string of validation errors
+   */
+  getValidationDetails() {
+    if (!this.validationErrors) {
+      return this.message;
+    }
+    const errors = this.validationErrors.issues.map((err) => `${err.path.map(String).join(".")}: ${err.message}`).join(", ");
+    return `${this.message} - ${errors}`;
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Validate API response against Zod schema
+   * @throws {ValidationError} if validation fails
+   */
+  validate(data, schema) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      throw new ValidationError("API response validation failed", result.error);
+    }
+    return result.data;
+  }
+};
+
+// src/resources/agents.ts
+function timeseriesSearchParams(options) {
+  const searchParams = {};
+  if (options?.period_hours) {
+    searchParams.period_hours = String(options.period_hours);
+  }
+  if (options?.interval_hours) {
+    searchParams.interval_hours = String(options.interval_hours);
+  }
+  return searchParams;
+}
+function breakdownSearchParams(options) {
+  const searchParams = {};
+  if (options?.period_hours) {
+    searchParams.period_hours = String(options.period_hours);
+  }
+  if (options?.limit) {
+    searchParams.limit = String(options.limit);
+  }
+  return searchParams;
+}
+var AgentsResource = class extends BaseResource {
+  /**
+   * Time-bucketed count of agent-run spans (`gen_ai.operation.type:agent`).
+   */
+  async getRuns(projectId, options) {
+    const data = await this.http.get(`api/projects/${projectId}/agents/runs`, {
+      searchParams: timeseriesSearchParams(options)
+    }).json();
+    return this.validate(data, z.array(agentTimeseriesPointSchema));
+  }
+  /**
+   * Time-bucketed avg/p95 duration for `agent`/`ai_client` spans.
+   */
+  async getDuration(projectId, options) {
+    const data = await this.http.get(`api/projects/${projectId}/agents/duration`, {
+      searchParams: timeseriesSearchParams(options)
+    }).json();
+    return this.validate(data, z.array(agentDurationPointSchema));
+  }
+  /**
+   * Top models by LLM call count (`gen_ai.operation.type:ai_client`).
+   */
+  async getModelsByCalls(projectId, options) {
+    const data = await this.http.get(`api/projects/${projectId}/agents/models/calls`, {
+      searchParams: breakdownSearchParams(options)
+    }).json();
+    return this.validate(data, z.array(genAiBreakdownRowSchema));
+  }
+  /**
+   * Top models by total tokens used (`gen_ai.operation.type:ai_client`).
+   */
+  async getModelsByTokens(projectId, options) {
+    const data = await this.http.get(`api/projects/${projectId}/agents/models/tokens`, {
+      searchParams: breakdownSearchParams(options)
+    }).json();
+    return this.validate(data, z.array(genAiBreakdownRowSchema));
+  }
+  /**
+   * Top tools by call count (`gen_ai.operation.type:tool`).
+   */
+  async getTools(projectId, options) {
+    const data = await this.http.get(`api/projects/${projectId}/agents/tools`, {
+      searchParams: breakdownSearchParams(options)
+    }).json();
+    return this.validate(data, z.array(genAiBreakdownRowSchema));
+  }
+  /**
+   * Paginated per-trace_id aggregate (duration, tokens, tool usage) across
+   * all AI spans sharing that trace, regardless of origin.
+   */
+  async getTraces(projectId, options) {
+    const searchParams = {};
+    if (options?.page) {
+      searchParams.page = String(options.page);
+    }
+    if (options?.per_page) {
+      searchParams.per_page = String(options.per_page);
+    }
+    const data = await this.http.get(`api/projects/${projectId}/agents/traces`, { searchParams }).json();
+    return this.validate(
+      data,
+      offsetPaginatedResponseSchema(agentTraceSummarySchema)
+    );
+  }
+};
+var AlertIntegrationsResource = class extends BaseResource {
+  /**
+   * List all alert integrations
+   */
+  async list() {
+    const data = await this.http.get("api/integrations").json();
+    return this.validate(data, z.array(alertIntegrationSchema));
+  }
+  /**
+   * Get a single alert integration by ID
+   */
+  async get(id) {
+    const data = await this.http.get(`api/integrations/${id}`).json();
+    return this.validate(data, alertIntegrationSchema);
+  }
+  /**
+   * Create a new alert integration
+   */
+  async create(input) {
+    const validatedInput = this.validate(input, createAlertIntegrationSchema);
+    const data = await this.http.post("api/integrations", { json: validatedInput }).json();
+    return this.validate(data, alertIntegrationSchema);
+  }
+  /**
+   * Update an existing alert integration
+   */
+  async update(id, input) {
+    const validatedInput = this.validate(input, updateAlertIntegrationSchema);
+    const data = await this.http.patch(`api/integrations/${id}`, { json: validatedInput }).json();
+    return this.validate(data, alertIntegrationSchema);
+  }
+  /**
+   * Delete an alert integration
+   */
+  async delete(id) {
+    await this.http.delete(`api/integrations/${id}`);
+  }
+  /**
+   * Send a test notification to verify integration configuration.
+   * For Slack bot_token integrations, routingOverride must include `channel`.
+   */
+  async test(id, routingOverride) {
+    const body = routingOverride !== void 0 ? this.validate(
+      { routing_override: routingOverride },
+      testIntegrationBodySchema
+    ) : void 0;
+    const data = await this.http.post(
+      `api/integrations/${id}/test`,
+      body !== void 0 ? { json: body } : void 0
+    ).json();
+    return this.validate(data, testChannelResponseSchema);
+  }
+};
+var AlertRulesResource = class extends BaseResource {
+  /**
+   * List all alert rules for a project
+   */
+  async list(projectId) {
+    const data = await this.http.get(`api/projects/${projectId}/alert-rules`).json();
+    return this.validate(data, z.array(alertRuleSchema));
+  }
+  /**
+   * Get a single alert rule by ID
+   */
+  async get(projectId, ruleId) {
+    const data = await this.http.get(`api/projects/${projectId}/alert-rules/${ruleId}`).json();
+    return this.validate(data, alertRuleSchema);
+  }
+  /**
+   * Create a new alert rule for a project
+   */
+  async create(projectId, input) {
+    const validatedInput = this.validate(input, createAlertRuleSchema);
+    const data = await this.http.post(`api/projects/${projectId}/alert-rules`, { json: validatedInput }).json();
+    return this.validate(data, alertRuleSchema);
+  }
+  /**
+   * Update an existing alert rule
+   */
+  async update(projectId, ruleId, input) {
+    const validatedInput = this.validate(input, updateAlertRuleSchema);
+    const data = await this.http.patch(`api/projects/${projectId}/alert-rules/${ruleId}`, {
+      json: validatedInput
+    }).json();
+    return this.validate(data, alertRuleSchema);
+  }
+  /**
+   * Delete an alert rule
+   */
+  async delete(projectId, ruleId) {
+    await this.http.delete(`api/projects/${projectId}/alert-rules/${ruleId}`);
+  }
+  /**
+   * List alert history for a project
+   */
+  async listHistory(projectId, options) {
+    const searchParams = new URLSearchParams();
+    if (options?.limit !== void 0) {
+      searchParams.set("limit", options.limit.toString());
+    }
+    const query = searchParams.toString();
+    const url = query ? `api/projects/${projectId}/alert-history?${query}` : `api/projects/${projectId}/alert-history`;
+    const data = await this.http.get(url).json();
+    return this.validate(data, z.array(alertHistorySchema));
+  }
+};
+
+// src/resources/auth.ts
+var AuthResource = class extends BaseResource {
+  /**
+   * Register a new user account
+   * Creates a new user and automatically logs them in (sets session cookie)
+   * @param credentials - Email and password for the new account
+   * @returns LoginResult with user information and session cookies
+   */
+  async register(credentials) {
+    const validatedInput = this.validate(credentials, registerRequestSchema);
+    const response = await this.http.post("auth/register", {
+      json: validatedInput
+    });
+    const cookies = response.headers.getSetCookie();
+    const data = await response.json();
+    const authResponse = this.validate(data, authResponseSchema);
+    return {
+      user: authResponse.user,
+      cookies
+    };
+  }
+  /**
+   * Login with email and password
+   * Authenticates the user and sets a session cookie
+   * @param credentials - Email and password
+   * @returns LoginResult with user information and session cookies
+   */
+  async login(credentials) {
+    const validatedInput = this.validate(credentials, loginRequestSchema);
+    const response = await this.http.post("auth/login", {
+      json: validatedInput
+    });
+    const cookies = response.headers.getSetCookie();
+    const data = await response.json();
+    const authResponse = this.validate(data, authResponseSchema);
+    return {
+      user: authResponse.user,
+      cookies
+    };
+  }
+  /**
+   * Logout the current user
+   * Clears the session cookie
+   * @returns Array of Set-Cookie headers (typically clearing cookies)
+   */
+  async logout() {
+    const response = await this.http.post("auth/logout");
+    return response.headers.getSetCookie();
+  }
+  /**
+   * Get current authenticated user
+   * Requires a valid session cookie
+   * @returns User information
+   */
+  async getCurrentUser() {
+    const data = await this.http.get("auth/me").json();
+    return this.validate(data, userSchema);
+  }
+  /**
+   * Get the details of a pending invitation by its token (public endpoint)
+   * Used by the accept-invitation page before the user has an account
+   * @param token - Invitation token
+   * @returns Invitation info (email, role, status, expiry)
+   */
+  async getInvitation(token) {
+    const data = await this.http.get(`auth/invitation/${token}`).json();
+    return this.validate(data, invitationInfoSchema);
+  }
+  /**
+   * Accept a pending invitation, creating the user account and logging in
+   * @param input - Invitation token and the new account's password
+   * @returns LoginResult with user information and session cookies
+   */
+  async acceptInvitation(input) {
+    const validatedInput = this.validate(input, acceptInvitationSchema);
+    const response = await this.http.post("auth/accept-invitation", {
+      json: validatedInput
+    });
+    const cookies = response.headers.getSetCookie();
+    const data = await response.json();
+    const authResponse = this.validate(data, authResponseSchema);
+    return {
+      user: authResponse.user,
+      cookies
+    };
+  }
+};
 
 // src/resources/events.ts
 var EventsResource = class extends BaseResource {
@@ -1079,17 +1199,6 @@ var IssuesResource = class extends BaseResource {
     }).json();
     return this.validate(data, userReportSchema);
   }
-  /**
-   * Record a deploy of a release, finalizing resolve-in-next-release issues.
-   */
-  async createDeploy(projectId, input) {
-    const validatedInput = this.validate(input, createDeploySchema);
-    const data = await this.http.post(`api/projects/${projectId}/deploys`, { json: validatedInput }).json();
-    return this.validate(
-      data,
-      z.object({ version: z.string(), finalized: z.number().int() })
-    );
-  }
 };
 
 // src/resources/logs.ts
@@ -1324,6 +1433,37 @@ var SourceMapsResource = class extends BaseResource {
     return this.validate(data, listSourceMapsResponseSchema);
   }
 };
+
+// src/resources/spans.ts
+var SpansResource = class extends BaseResource {
+  /**
+   * List spans for a project with offset-based pagination (newest first),
+   * optionally filtered by op/status/trace_id/operation_type.
+   */
+  async list(projectId, options) {
+    const searchParams = {};
+    if (options?.page) {
+      searchParams.page = String(options.page);
+    }
+    if (options?.per_page) {
+      searchParams.per_page = String(options.per_page);
+    }
+    if (options?.op) {
+      searchParams.op = options.op;
+    }
+    if (options?.status) {
+      searchParams.status = options.status;
+    }
+    if (options?.trace_id) {
+      searchParams.trace_id = options.trace_id;
+    }
+    if (options?.operation_type) {
+      searchParams.operation_type = options.operation_type;
+    }
+    const data = await this.http.get(`api/projects/${projectId}/spans`, { searchParams }).json();
+    return this.validate(data, offsetPaginatedResponseSchema(spanSchema));
+  }
+};
 var StorageResource = class extends BaseResource {
   /**
    * Get the instance-wide storage summary: row counts per data category, the
@@ -1652,6 +1792,14 @@ var RustrakClient = class {
    * Logs API resource (standalone logs)
    */
   logs;
+  /**
+   * Spans API resource (standalone + transaction-embedded spans, shared table)
+   */
+  spans;
+  /**
+   * AI Agent Monitoring dashboard API resource
+   */
+  agents;
   /**
    * Storage API resource (usage + retention cleanup, admin only)
    */
@@ -1682,6 +1830,8 @@ var RustrakClient = class {
     this.releases = new ReleasesResource(this.http);
     this.transactions = new TransactionsResource(this.http);
     this.logs = new LogsResource(this.http);
+    this.spans = new SpansResource(this.http);
+    this.agents = new AgentsResource(this.http);
     this.storage = new StorageResource(this.http);
     this.health = new HealthResource(this.http);
   }