@seamapi/http 0.3.0 → 0.5.0

package/src/lib/seam/connect/auth.ts

@@ -1,9 +1,13 @@
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from './options.js'
 import type { Options } from './parse-options.js'
 
@@ -22,8 +26,23 @@ export const getAuthHeaders = (options: Options): Headers => {
     return getAuthHeadersForClientSessionToken(options)
   }
 
+  if (isSeamHttpOptionsWithConsoleSessionToken(options)) {
+    return getAuthHeadersForConsoleSessionToken(options)
+  }
+
+  if (isSeamHttpOptionsWithPersonalAccessToken(options)) {
+    return getAuthHeadersForPersonalAccessToken(options)
+  }
+
   throw new SeamHttpInvalidOptionsError(
-    'Must specify an apiKey, clientSessionToken, or publishableKey',
+    [
+      'Must specify',
+      'an apiKey,',
+      'clientSessionToken,',
+      'publishableKey,',
+      'consoleSessionToken with a workspaceId',
+      'or personalAccessToken with a workspaceId',
+    ].join(' '),
   )
 }
 
@@ -96,6 +115,74 @@ const getAuthHeadersForClientSessionToken = ({
   }
 }
 
+const getAuthHeadersForConsoleSessionToken = ({
+  consoleSessionToken,
+  workspaceId,
+}: SeamHttpOptionsWithConsoleSessionToken): Headers => {
+  if (isAccessToken(consoleSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      'An Access Token cannot be used as a consoleSessionToken',
+    )
+  }
+
+  if (isClientSessionToken(consoleSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      'A Client Session Token cannot be used as a consoleSessionToken',
+    )
+  }
+
+  if (isPublishableKey(consoleSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      'A Publishable Key cannot be used as a consoleSessionToken',
+    )
+  }
+
+  if (!isJwt(consoleSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      `Unknown or invalid consoleSessionToken format, expected a JWT which starts with ${jwtPrefix}`,
+    )
+  }
+
+  return {
+    authorization: `Bearer ${consoleSessionToken}`,
+    'seam-workspace-id': workspaceId,
+  }
+}
+
+const getAuthHeadersForPersonalAccessToken = ({
+  personalAccessToken,
+  workspaceId,
+}: SeamHttpOptionsWithPersonalAccessToken): Headers => {
+  if (isJwt(personalAccessToken)) {
+    throw new SeamHttpInvalidTokenError(
+      'A JWT cannot be used as a personalAccessToken',
+    )
+  }
+
+  if (isClientSessionToken(personalAccessToken)) {
+    throw new SeamHttpInvalidTokenError(
+      'A Client Session Token cannot be used as a personalAccessToken',
+    )
+  }
+
+  if (isPublishableKey(personalAccessToken)) {
+    throw new SeamHttpInvalidTokenError(
+      'A Publishable Key cannot be used as a personalAccessToken',
+    )
+  }
+
+  if (!isAccessToken(personalAccessToken)) {
+    throw new SeamHttpInvalidTokenError(
+      `Unknown or invalid personalAccessToken format, expected token to start with ${accessTokenPrefix}`,
+    )
+  }
+
+  return {
+    authorization: `Bearer ${personalAccessToken}`,
+    'seam-workspace-id': workspaceId,
+  }
+}
+
 const getAuthHeadersForPublishableKey = (publishableKey: string): Headers => {
   if (isJwt(publishableKey)) {
     throw new SeamHttpInvalidTokenError(
@@ -153,6 +240,10 @@ export const warnOnInsecureuserIdentifierKey = (
 
 const tokenPrefix = 'seam_'
 
+const accessTokenPrefix = 'seam_at'
+
+const jwtPrefix = 'ey'
+
 const clientSessionTokenPrefix = 'seam_cst'
 
 const publishableKeyTokenPrefix = 'seam_pk'
@@ -160,9 +251,10 @@ const publishableKeyTokenPrefix = 'seam_pk'
 const isClientSessionToken = (token: string): boolean =>
   token.startsWith(clientSessionTokenPrefix)
 
-const isAccessToken = (token: string): boolean => token.startsWith('seam_at')
+const isAccessToken = (token: string): boolean =>
+  token.startsWith(accessTokenPrefix)
 
-const isJwt = (token: string): boolean => token.startsWith('ey')
+const isJwt = (token: string): boolean => token.startsWith(jwtPrefix)
 
 const isSeamToken = (token: string): boolean => token.startsWith(tokenPrefix)
 

package/src/lib/seam/connect/client.ts

@@ -1,8 +1,12 @@
 import axios, { type AxiosInstance, type AxiosRequestConfig } from 'axios'
+// @ts-expect-error https://github.com/svsool/axios-better-stacktrace/issues/12
+import axiosBetterStacktrace from 'axios-better-stacktrace'
 import axiosRetry, { type AxiosRetry, exponentialDelay } from 'axios-retry'
 
 import { paramsSerializer } from 'lib/params-serializer.js'
 
+import { errorInterceptor } from './error-interceptor.js'
+
 export type Client = AxiosInstance
 
 export interface ClientOptions {
@@ -21,6 +25,8 @@ export const createClient = (options: ClientOptions): AxiosInstance => {
     ...options.axiosOptions,
   })
 
+  axiosBetterStacktrace(axios)
+
   // @ts-expect-error https://github.com/softonic/axios-retry/issues/159
   axiosRetry(client, {
     retries: 2,
@@ -28,5 +34,7 @@ export const createClient = (options: ClientOptions): AxiosInstance => {
     ...options.axiosRetryOptions,
   })
 
+  client.interceptors.response.use(undefined, errorInterceptor)
+
   return client
 }

package/src/lib/seam/connect/error-interceptor.ts

@@ -0,0 +1,61 @@
+import { type AxiosError, isAxiosError } from 'axios'
+
+import type { ApiErrorResponse } from './api-error-type.js'
+import {
+  SeamHttpApiError,
+  SeamHttpInvalidInputError,
+  SeamHttpUnauthorizedError,
+} from './seam-http-error.js'
+
+export const errorInterceptor = async (err: unknown): Promise<void> => {
+  if (!isAxiosError(err)) throw err
+
+  const { response } = err
+  const status = response?.status
+  const headers = response?.headers
+  const requestId = headers?.['seam-request-id'] ?? ''
+
+  if (status == null) throw err
+
+  if (status === 401) {
+    throw new SeamHttpUnauthorizedError(requestId)
+  }
+
+  if (!isApiErrorResponse(response)) throw err
+
+  const { type } = response.data.error
+
+  const args = [response.data.error, status, requestId] as const
+
+  if (type === 'invalid_input') throw new SeamHttpInvalidInputError(...args)
+  throw new SeamHttpApiError(...args)
+}
+
+const isApiErrorResponse = (
+  response: AxiosError['response'],
+): response is NonNullable<AxiosError<ApiErrorResponse>['response']> => {
+  if (response == null) return false
+  const { headers, data } = response
+
+  if (headers == null) return false
+
+  const contentType = headers['content-type']
+  if (
+    typeof contentType === 'string' &&
+    !contentType.startsWith('application/json')
+  ) {
+    return false
+  }
+
+  if (typeof data === 'object' && data != null) {
+    return (
+      'error' in data &&
+      typeof data.error === 'object' &&
+      data.error != null &&
+      'type' in data.error &&
+      typeof data.error.type === 'string'
+    )
+  }
+
+  return false
+}

package/src/lib/seam/connect/index.ts

@@ -1,4 +1,6 @@
+export * from './error-interceptor.js'
 export * from './options.js'
-export * from './routes//index.js'
+export * from './routes/index.js'
 export * from './seam-http.js'
+export * from './seam-http-error.js'
 export * from 'lib/params-serializer.js'

package/src/lib/seam/connect/options.ts

@@ -5,6 +5,8 @@ export type SeamHttpOptions =
   | SeamHttpOptionsWithClient
   | SeamHttpOptionsWithApiKey
   | SeamHttpOptionsWithClientSessionToken
+  | SeamHttpOptionsWithConsoleSessionToken
+  | SeamHttpOptionsWithPersonalAccessToken
 
 interface SeamHttpCommonOptions extends ClientOptions {
   endpoint?: string
@@ -53,6 +55,18 @@ export const isSeamHttpOptionsWithApiKey = (
     )
   }
 
+  if ('consoleSessionToken' in options && options.consoleSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The consoleSessionToken option cannot be used with the apiKey option',
+    )
+  }
+
+  if ('personalAccessToken' in options && options.personalAccessToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The personalAccessToken option cannot be used with the apiKey option',
+    )
+  }
+
   return true
 }
 
@@ -69,7 +83,97 @@ export const isSeamHttpOptionsWithClientSessionToken = (
 
   if ('apiKey' in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
-      'The clientSessionToken option cannot be used with the apiKey option',
+      'The apiKey option cannot be used with the clientSessionToken option',
+    )
+  }
+
+  if ('consoleSessionToken' in options && options.consoleSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The consoleSessionToken option cannot be used with the clientSessionToken option',
+    )
+  }
+
+  if ('personalAccessToken' in options && options.personalAccessToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The personalAccessToken option cannot be used with the clientSessionToken option',
+    )
+  }
+
+  return true
+}
+
+export interface SeamHttpOptionsWithConsoleSessionToken
+  extends SeamHttpCommonOptions {
+  consoleSessionToken: string
+  workspaceId: string
+}
+
+export const isSeamHttpOptionsWithConsoleSessionToken = (
+  options: SeamHttpOptions,
+): options is SeamHttpOptionsWithConsoleSessionToken => {
+  if (!('consoleSessionToken' in options)) return false
+  if (options.consoleSessionToken == null) return false
+
+  if (!('workspaceId' in options) || options.workspaceId == null) {
+    throw new SeamHttpInvalidOptionsError(
+      'Must pass a workspaceId when using a consoleSessionToken',
+    )
+  }
+
+  if ('apiKey' in options && options.apiKey != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The apiKey option cannot be used with the consoleSessionToken option',
+    )
+  }
+
+  if ('clientSessionToken' in options && options.clientSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The clientSessionToken option cannot be used with the consoleSessionToken option',
+    )
+  }
+
+  if ('personalAccessToken' in options && options.personalAccessToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The personalAccessToken option cannot be used with the consoleSessionToken option',
+    )
+  }
+
+  return true
+}
+
+export interface SeamHttpOptionsWithPersonalAccessToken
+  extends SeamHttpCommonOptions {
+  personalAccessToken: string
+  workspaceId: string
+}
+
+export const isSeamHttpOptionsWithPersonalAccessToken = (
+  options: SeamHttpOptions,
+): options is SeamHttpOptionsWithPersonalAccessToken => {
+  if (!('personalAccessToken' in options)) return false
+  if (options.personalAccessToken == null) return false
+
+  if (!('workspaceId' in options) || options.workspaceId == null) {
+    throw new SeamHttpInvalidOptionsError(
+      'Must pass a workspaceId when using a personalAccessToken',
+    )
+  }
+
+  if ('apiKey' in options && options.apiKey != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The apiKey option cannot be used with the personalAccessToken option',
+    )
+  }
+
+  if ('clientSessionToken' in options && options.clientSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The clientSessionToken option cannot be used with the personalAccessToken option',
+    )
+  }
+
+  if ('consoleSessionToken' in options && options.consoleSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      'The consoleSessionToken option cannot be used with the personalAccessToken option',
     )
   }
 

package/src/lib/seam/connect/routes/access-codes-unmanaged.ts

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -82,6 +86,40 @@ export class SeamHttpAccessCodesUnmanaged {
     return SeamHttpAccessCodesUnmanaged.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAccessCodesUnmanaged {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpAccessCodesUnmanaged(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAccessCodesUnmanaged {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpAccessCodesUnmanaged(constructorOptions)
+  }
+
   async convertToManaged(
     body?: AccessCodesUnmanagedConvertToManagedBody,
   ): Promise<void> {

package/src/lib/seam/connect/routes/access-codes.ts

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -83,6 +87,40 @@ export class SeamHttpAccessCodes {
     return SeamHttpAccessCodes.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAccessCodes {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpAccessCodes(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAccessCodes {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpAccessCodes(constructorOptions)
+  }
+
   get unmanaged(): SeamHttpAccessCodesUnmanaged {
     return SeamHttpAccessCodesUnmanaged.fromClient(this.client)
   }

package/src/lib/seam/connect/routes/acs-access-groups.ts

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -82,6 +86,40 @@ export class SeamHttpAcsAccessGroups {
     return SeamHttpAcsAccessGroups.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAcsAccessGroups {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpAcsAccessGroups(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAcsAccessGroups {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpAcsAccessGroups(constructorOptions)
+  }
+
   async addUser(body?: AcsAccessGroupsAddUserBody): Promise<void> {
     await this.client.request<AcsAccessGroupsAddUserResponse>({
       url: '/acs/access_groups/add_user',

package/src/lib/seam/connect/routes/acs-credentials.ts

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -82,6 +86,40 @@ export class SeamHttpAcsCredentials {
     return SeamHttpAcsCredentials.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAcsCredentials {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpAcsCredentials(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAcsCredentials {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpAcsCredentials(constructorOptions)
+  }
+
   async create(
     body?: AcsCredentialsCreateBody,
   ): Promise<AcsCredentialsCreateResponse['acs_credential']> {

package/src/lib/seam/connect/routes/acs-systems.ts

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -82,6 +86,40 @@ export class SeamHttpAcsSystems {
     return SeamHttpAcsSystems.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAcsSystems {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpAcsSystems(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAcsSystems {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpAcsSystems(constructorOptions)
+  }
+
   async get(
     body?: AcsSystemsGetParams,
   ): Promise<AcsSystemsGetResponse['acs_system']> {