@sogni-ai/expo-client 1.0.0-alpha.10

package/src/Projects/restNormalize.ts

@@ -0,0 +1,154 @@
+/**
+ * Translate RawProject / RawJob shapes returned by the /v1/projects/:id
+ * endpoint into our public Project / Job types.
+ *
+ * Same wire-quirk pattern as the socket normalizer: the server uses `imgID`
+ * to mean "job id" and its `status` enum uses different values from ours.
+ * Everything gets translated here so the rest of the SDK only sees clean
+ * public shapes.
+ */
+
+import { Job, JobStatus, Project, ProjectParams, ProjectStatus } from './types';
+import { SupernetType } from '../ApiClient/WebSocketClient/types';
+
+/* === Wire shapes (kept faithful to /v1/projects/:id response) === */
+
+export type RawProjectStatus =
+  | 'pending'
+  | 'active'
+  | 'assigned'
+  | 'progress'
+  | 'errored'
+  | 'completed'
+  | 'cancelled';
+
+export type RawWorkerJobStatus =
+  | 'pending'
+  | 'jobStarted'
+  | 'initiatingModel'
+  | 'jobProgress'
+  | 'jobCompleted'
+  | 'jobError'
+  | 'cancelled';
+
+export interface RawAccount {
+  id?: string;
+  address?: string;
+  name?: string;
+  username?: string;
+}
+
+export interface RawWorkerJob {
+  id: string;
+  imgID?: string;
+  worker?: RawAccount;
+  createTime?: number;
+  startTime?: number | null;
+  updateTime?: number;
+  endTime?: number;
+  status: RawWorkerJobStatus;
+  reason?: string;
+  performedSteps?: number;
+  triggeredNSFWFilter?: boolean;
+  seedUsed?: number;
+  resultUrl?: string | null;
+}
+
+export interface RawProject {
+  id: string;
+  imageCount: number;
+  stepCount?: number;
+  previewCount?: number;
+  createTime?: number;
+  updateTime?: number;
+  endTime?: number;
+  status: RawProjectStatus;
+  reason?: string;
+  network?: SupernetType;
+  workerJobs?: RawWorkerJob[];
+  completedWorkerJobs?: RawWorkerJob[];
+  model?: { id?: string };
+}
+
+/* === Mappers === */
+
+const PROJECT_STATUS_MAP: Record<RawProjectStatus, ProjectStatus> = {
+  pending: 'pending',
+  active: 'queued',
+  assigned: 'queued',
+  progress: 'processing',
+  errored: 'failed',
+  completed: 'completed',
+  cancelled: 'canceled'
+};
+
+const JOB_STATUS_MAP: Record<RawWorkerJobStatus, JobStatus> = {
+  pending: 'pending',
+  jobStarted: 'processing',
+  initiatingModel: 'initiatingModel',
+  jobProgress: 'processing',
+  jobCompleted: 'completed',
+  jobError: 'failed',
+  cancelled: 'canceled'
+};
+
+function rawJobToJob(projectId: string, raw: RawWorkerJob): Job {
+  return {
+    // Wire quirk: imgID is the job ID. Fall back to raw.id for older payloads.
+    id: (raw.imgID ?? raw.id ?? '').toUpperCase(),
+    projectId,
+    status: JOB_STATUS_MAP[raw.status] ?? 'pending',
+    progress: raw.status === 'jobCompleted' ? 1 : 0,
+    step: raw.performedSteps ?? 0,
+    stepCount: 0,
+    seed: raw.seedUsed ?? null,
+    resultUrl: raw.resultUrl ?? null,
+    previewUrl: null,
+    isNSFW: !!raw.triggeredNSFWFilter,
+    workerName: raw.worker?.username ?? raw.worker?.name ?? null,
+    error: null
+  };
+}
+
+/**
+ * Build a Project snapshot from the REST GET /v1/projects/:id payload.
+ * `params` is best-effort reconstructed from the few fields the server
+ * returns — most generation-time settings (prompt, model options, etc.)
+ * are NOT in the REST response, so callers that need the full params
+ * should pass them in via `paramsOverride` (e.g., from local storage).
+ */
+export function rawProjectToProject(raw: RawProject, paramsOverride?: ProjectParams): Project {
+  const projectId = raw.id.toUpperCase();
+  const allJobs: RawWorkerJob[] = [...(raw.workerJobs ?? []), ...(raw.completedWorkerJobs ?? [])];
+  const jobsById = new Map<string, Job>();
+  for (const rawJob of allJobs) {
+    const job = rawJobToJob(projectId, rawJob);
+    if (!jobsById.has(job.id) || job.status === 'completed') {
+      jobsById.set(job.id, job);
+    }
+  }
+  const jobs = Array.from(jobsById.values());
+  const status: ProjectStatus = PROJECT_STATUS_MAP[raw.status] ?? 'pending';
+  const resultUrls = jobs.map((j) => j.resultUrl).filter((u): u is string => !!u);
+
+  const params: ProjectParams = paramsOverride ?? {
+    type: 'image',
+    modelId: raw.model?.id ?? '',
+    positivePrompt: '',
+    numberOfMedia: raw.imageCount || 1,
+    ...(raw.network ? { network: raw.network } : {})
+  };
+
+  return {
+    id: projectId,
+    params,
+    status,
+    progress: jobs.length ? jobs.reduce((a, j) => a + j.progress, 0) / jobs.length : 0,
+    eta: null,
+    jobs,
+    resultUrls,
+    error: null,
+    createdAt: raw.createTime ?? Date.now(),
+    updatedAt: raw.updateTime ?? Date.now()
+  };
+}

package/src/Projects/types.ts

@@ -0,0 +1,266 @@
+import { SupernetType } from '../ApiClient/WebSocketClient/types';
+import { TokenType } from '../types/token';
+import ErrorData from '../types/ErrorData';
+import { MediaInput } from '../lib/mediaInput';
+import { ControlNetParams } from './ControlNet';
+
+export type { MediaInput };
+export type { ControlNetMode, ControlNetName, ControlNetParams } from './ControlNet';
+
+export type ProjectStatus =
+  | 'pending'
+  | 'queued'
+  | 'processing'
+  | 'completed'
+  | 'failed'
+  | 'canceled';
+
+export type JobStatus =
+  | 'pending'
+  | 'initiatingModel'
+  | 'processing'
+  | 'completed'
+  | 'failed'
+  | 'canceled';
+
+export type JobErrorReason =
+  | 'serverRestarting'
+  | 'workerDisconnected'
+  | 'jobTimedOut'
+  | 'artistCanceled'
+  | 'workerCanceled'
+  | 'sensitiveContent'
+  | 'imgUploadFailure'
+  | 'imgDownloadFailure'
+  | 'unknown';
+
+export type ImageOutputFormat = 'png' | 'jpg' | 'webp';
+export type VideoOutputFormat = 'mp4';
+export type AudioOutputFormat = 'mp3' | 'flac' | 'wav';
+
+/** Parameters for creating an image generation project. */
+export interface ImageProjectParams {
+  /** Discriminator. Defaults to 'image' if omitted. */
+  type?: 'image';
+  /** Model ID from `sogni.projects.getAvailableModels()`. */
+  modelId: string;
+  /** Required. The generation prompt. */
+  positivePrompt: string;
+  /** Optional. Negative prompt; uses server default if omitted. */
+  negativePrompt?: string;
+  /** Optional. Style prompt; uses server default if omitted. */
+  stylePrompt?: string;
+  /** Number of images to generate. */
+  numberOfMedia: number;
+  /** Number of inference steps. Optimal value depends on the model. */
+  steps?: number;
+  /** Classifier-free guidance scale. Typical values 1-15. */
+  guidance?: number;
+  /** Optional seed (Uint32). Other images in the batch get random seeds. */
+  seed?: number;
+  /** Sampler ID. Model-specific; query via getAvailableModels metadata. */
+  sampler?: string;
+  /** Scheduler ID. Model-specific. */
+  scheduler?: string;
+  /** Size preset ID, or 'custom' to use explicit width/height. */
+  sizePreset?: 'custom' | string;
+  /** Output width in pixels. Only used when sizePreset === 'custom'. */
+  width?: number;
+  /** Output height in pixels. Only used when sizePreset === 'custom'. */
+  height?: number;
+  /** 'png' | 'jpg' | 'webp'. Defaults to 'png'. */
+  outputFormat?: ImageOutputFormat;
+  /** If true, skip NSFW filtering on output images. Default false. */
+  disableNSFWFilter?: boolean;
+  /** Override the client's current Supernet ('fast' or 'relaxed'). */
+  network?: SupernetType;
+  /** Number of preview images to stream during generation. */
+  numberOfPreviews?: number;
+  /** Token type ('sogni' | 'spark'). Default 'sogni'. */
+  tokenType?: TokenType;
+  /** Optional app source label for server-side attribution. */
+  appSource?: string;
+  /** LoRA IDs to apply. Each LoRA must be available in the model's config. */
+  loras?: string[];
+  /** LoRA strength values, 1:1 with `loras`. Typical 0.0-2.0; default 1.0. */
+  loraStrengths?: number[];
+
+  /**
+   * Optional starting image for img2img workflows. The SDK uploads the image
+   * to the server before sending the generation request.
+   *
+   * Pass either `{uri, type, name}` (as returned by expo-image-picker) or
+   * a `Uint8Array` of raw bytes.
+   */
+  startingImage?: MediaInput;
+  /**
+   * How strongly the starting image should influence the result. 0..1, default 0.5.
+   * Higher values preserve more of the source image.
+   */
+  startingImageStrength?: number;
+  /**
+   * Multiple reference images for multi-image-aware models (GPT Image 2, Flux.2,
+   * Qwen Image Edit, Flux Kontext). Max count depends on the model — see
+   * `getMaxContextImages(modelId)`.
+   */
+  contextImages?: MediaInput[];
+  /**
+   * Apply a ControlNet to constrain generation by the given control image.
+   * The control image is uploaded before the generation request.
+   */
+  controlNet?: ControlNetParams;
+}
+
+/**
+ * Parameters for creating a video generation project.
+ *
+ * Two model families with different FPS / frame behavior:
+ * - **WAN 2.2** (`wan_v2.2-*`): always generates at 16 fps internally. The
+ *   `fps` value (16 or 32) only controls post-render FILM interpolation.
+ *   Frame count is `duration * 16 + 1` regardless of fps.
+ * - **LTX-2.3** (`ltx2-*`, `ltx23-*`): generates at the requested fps directly.
+ *   Frame count is `duration * fps + 1`, snapped to the pattern `1 + n*8`.
+ *
+ * The SDK computes `frames` from `duration` + `fps` automatically using
+ * `calculateVideoFrames(modelId, duration, fps)`. You can override by passing
+ * `frames` directly.
+ */
+export interface VideoProjectParams {
+  type: 'video';
+  /** Video model ID. Must be a `wan_v2.2-*` or `ltx2-*` / `ltx23-*` model. */
+  modelId: string;
+  positivePrompt: string;
+  negativePrompt?: string;
+  stylePrompt?: string;
+  /** Number of videos to generate. */
+  numberOfMedia: number;
+  /**
+   * Duration in seconds. WAN: 1-10s typical. LTX-2.3: 4-20s typical.
+   * SDK derives frames from this — only pass `frames` directly if you need
+   * fine-grained control.
+   */
+  duration?: number;
+  /**
+   * Frames per second. WAN: 16 or 32 (32 = post-render interpolation).
+   * LTX-2.3: 1-60, default 24.
+   */
+  fps?: number;
+  /**
+   * Explicit frame count. Overrides duration-derived calculation. Use this
+   * only if you need exact frame counts; the SDK does the math otherwise.
+   */
+  frames?: number;
+  steps?: number;
+  guidance?: number;
+  seed?: number;
+  sampler?: string;
+  scheduler?: string;
+  width?: number;
+  height?: number;
+  /** Shift parameter (model-sampler). Affects denoise distribution. */
+  shift?: number;
+  outputFormat?: VideoOutputFormat;
+  disableNSFWFilter?: boolean;
+  network?: SupernetType;
+  tokenType?: TokenType;
+  appSource?: string;
+  loras?: string[];
+  loraStrengths?: number[];
+  /** First-frame image (img2video). */
+  referenceImage?: MediaInput;
+  /** Last-frame image for keyframe interpolation (LTX-2.3). */
+  referenceImageEnd?: MediaInput;
+  /** Reference audio for s2v workflows. */
+  referenceAudio?: MediaInput;
+  /** Reference video for v2v workflows. */
+  referenceVideo?: MediaInput;
+  /** LTX-2.3 first-frame strength when both referenceImage and referenceImageEnd are given. */
+  firstFrameStrength?: number;
+  /** LTX-2.3 last-frame strength when both referenceImage and referenceImageEnd are given. */
+  lastFrameStrength?: number;
+}
+
+/** Parameters for creating an audio generation project (ACE-Step 1.5 models). */
+export interface AudioProjectParams {
+  type: 'audio';
+  /** Audio model ID, e.g. 'ace_step_1.5_turbo'. */
+  modelId: string;
+  positivePrompt: string;
+  negativePrompt?: string;
+  /** Number of audio files to generate. */
+  numberOfMedia: number;
+  /** Duration in seconds. Typical range 10-600. */
+  duration?: number;
+  /** Beats per minute, 30-300. */
+  bpm?: number;
+  /** Time signature: '2', '3', '4', or '6'. */
+  timesignature?: string;
+  /** ISO language code for lyrics. */
+  language?: string;
+  /** Lyrics. Omit for instrumental. */
+  lyrics?: string;
+  /** Musical key, e.g. 'C major' or 'A minor'. */
+  keyscale?: string;
+  /** Enable AI composer mode (higher quality). Default true. */
+  composerMode?: boolean;
+  /** How closely the composer follows the prompt (0-10, default 2.0). */
+  promptStrength?: number;
+  /** Composition variation / temperature (0-2, default 0.85). */
+  creativity?: number;
+  /** Sampler shift (1-6, default 3 for turbo). */
+  shift?: number;
+  steps?: number;
+  guidance?: number;
+  seed?: number;
+  sampler?: string;
+  scheduler?: string;
+  outputFormat?: AudioOutputFormat;
+  network?: SupernetType;
+  tokenType?: TokenType;
+  appSource?: string;
+}
+
+export type ProjectParams = ImageProjectParams | VideoProjectParams | AudioProjectParams;
+
+export interface Job {
+  id: string;
+  projectId: string;
+  status: JobStatus;
+  /** 0..1 */
+  progress: number;
+  step: number;
+  stepCount: number;
+  /** Set on completed jobs. */
+  seed: number | null;
+  /** Populated by waitForCompletion() or explicit fetchResultUrl(). */
+  resultUrl: string | null;
+  /** Server-provided preview URL (if any). */
+  previewUrl: string | null;
+  /** True if the result was withheld by the NSFW filter. */
+  isNSFW: boolean;
+  workerName: string | null;
+  error: ErrorData | null;
+}
+
+export interface Project {
+  id: string;
+  params: ProjectParams;
+  status: ProjectStatus;
+  /** 0..1 — average of all jobs' progress. */
+  progress: number;
+  /** Estimated seconds until completion (most recent value from server). */
+  eta: number | null;
+  jobs: Job[];
+  /** Populated as jobs complete and waitForCompletion fetches URLs. */
+  resultUrls: string[];
+  error: ErrorData | null;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface AvailableModel {
+  id: string;
+  name: string;
+  workerCount: number;
+  media: 'image' | 'video' | 'audio';
+}

package/src/Projects/utils.ts

@@ -0,0 +1,60 @@
+const COMFY_MODEL_PREFIXES = ['z_image_', 'qwen_image_', 'flux2_', 'wan_', 'ace_step'];
+
+export function isComfyModel(modelId: string): boolean {
+  return COMFY_MODEL_PREFIXES.some((p) => modelId.startsWith(p));
+}
+
+export function isVideoModel(modelId: string): boolean {
+  return isWanModel(modelId) || isLtx2Model(modelId) || isSeedanceModel(modelId);
+}
+
+export function isWanModel(modelId: string): boolean {
+  return modelId.startsWith('wan_v2.2-') || modelId.startsWith('wan_');
+}
+
+export function isLtx2Model(modelId: string): boolean {
+  return modelId.startsWith('ltx2-') || modelId.startsWith('ltx23-');
+}
+
+export function isSeedanceModel(modelId: string): boolean {
+  return modelId.startsWith('seedance-2-0');
+}
+
+export function isAudioModel(modelId: string): boolean {
+  return modelId.startsWith('ace_step_');
+}
+
+const LTX2_FRAME_STEP = 8;
+
+/**
+ * Compute the actual frame count to request from the server for a given
+ * model, duration, and fps.
+ *
+ * - **WAN 2.2**: always uses 16 fps internally regardless of the `fps` param,
+ *   so frames = round(duration * 16) + 1.
+ * - **LTX-2.3**: uses `fps` directly, then snaps the frame count to the
+ *   pattern `1 + n*8` required by the model architecture.
+ * - **Seedance / other video**: uses `fps` directly.
+ *
+ * Returns the recommended frame count; the SDK passes this through to the
+ * server as `frames` on the keyframe payload.
+ */
+export function calculateVideoFrames(modelId: string, duration: number, fps: number): number {
+  if (isWanModel(modelId)) {
+    return Math.round(duration * 16) + 1;
+  }
+  let frames = Math.round(duration * fps) + 1;
+  if (isLtx2Model(modelId)) {
+    const n = Math.round((frames - 1) / LTX2_FRAME_STEP);
+    frames = n * LTX2_FRAME_STEP + 1;
+  }
+  return frames;
+}
+
+/** Approximate per-model maximum duration in seconds. */
+export function getMaxVideoDuration(modelId: string): number {
+  if (isWanModel(modelId)) return 10;
+  if (isLtx2Model(modelId)) return 20;
+  if (isSeedanceModel(modelId)) return 15;
+  return 10;
+}

package/src/index.ts

@@ -0,0 +1,217 @@
+import AccountApi from './Account';
+import { AccountSnapshot, Balances, LoginData, MeData, SignupParams } from './Account/types';
+import ChatApi from './Chat';
+import ChatStream from './Chat/ChatStream';
+import { parseToolCallArguments } from './Chat/tools';
+import {
+  ChatCompletionChunk,
+  ChatCompletionParams,
+  ChatCompletionResult,
+  ChatMessage,
+  ContentPart,
+  ImageUrlContentPart,
+  LLMModelInfo,
+  TextContentPart,
+  TokenUsage,
+  ToolCall,
+  ToolCallDelta,
+  ToolChoice,
+  ToolDefinition,
+  ToolRound
+} from './Chat/types';
+import ApiClient, { ApiError, ApiErrorResponse, ApiResponse } from './ApiClient';
+import { SupernetType } from './ApiClient/WebSocketClient/types';
+import {
+  AuthenticatedEvent,
+  BalanceUpdateEvent,
+  ChangeNetworkEvent,
+  ConnectedEvent,
+  DisconnectedEvent,
+  ToastMessageEvent
+} from './ApiClient/WebSocketClient/events';
+import ProjectsApi from './Projects';
+import {
+  AudioOutputFormat,
+  AudioProjectParams,
+  AvailableModel,
+  ControlNetMode,
+  ControlNetName,
+  ControlNetParams,
+  ImageOutputFormat,
+  ImageProjectParams,
+  Job,
+  JobErrorReason,
+  JobStatus,
+  MediaInput,
+  Project,
+  ProjectParams,
+  ProjectStatus,
+  VideoOutputFormat,
+  VideoProjectParams
+} from './Projects/types';
+import { DefaultLogger, Logger, LogLevel } from './lib/DefaultLogger';
+import { ApiKeyAuthManager, AuthStorage, TokenAuthData, TokenAuthManager } from './lib/AuthManager';
+import ErrorData from './types/ErrorData';
+import { TokenType } from './types/token';
+import { LIB_VERSION } from './version';
+
+export type {
+  AccountSnapshot,
+  ApiErrorResponse,
+  ApiResponse,
+  AudioOutputFormat,
+  AudioProjectParams,
+  AuthenticatedEvent,
+  AuthStorage,
+  AvailableModel,
+  Balances,
+  BalanceUpdateEvent,
+  ChangeNetworkEvent,
+  ChatCompletionChunk,
+  ChatCompletionParams,
+  ChatCompletionResult,
+  ChatMessage,
+  ConnectedEvent,
+  ContentPart,
+  ControlNetMode,
+  ControlNetName,
+  ControlNetParams,
+  DisconnectedEvent,
+  ErrorData,
+  ImageOutputFormat,
+  ImageProjectParams,
+  ImageUrlContentPart,
+  Job,
+  JobErrorReason,
+  JobStatus,
+  LLMModelInfo,
+  LoginData,
+  Logger,
+  LogLevel,
+  MediaInput,
+  MeData,
+  SignupParams,
+  Project,
+  ProjectParams,
+  ProjectStatus,
+  SupernetType,
+  TextContentPart,
+  ToastMessageEvent,
+  TokenAuthData,
+  TokenType,
+  TokenUsage,
+  ToolCall,
+  ToolCallDelta,
+  ToolChoice,
+  ToolDefinition,
+  ToolRound,
+  VideoOutputFormat,
+  VideoProjectParams
+};
+export { ApiError, ApiKeyAuthManager, ChatStream, LIB_VERSION, parseToolCallArguments };
+
+export interface SogniClientConfig {
+  /** Unique application ID. Multiple connections with the same ID will be rejected by the server. */
+  appId: string;
+  /** Optional source label for server-side attribution. */
+  appSource?: string;
+  /** Override the default REST API endpoint. Internal use. */
+  restEndpoint?: string;
+  /** Override the default WebSocket endpoint. Internal use. */
+  socketEndpoint?: string;
+  /** Which Supernet to connect to. Defaults to 'fast'. */
+  network?: SupernetType;
+  /** Connect to testnet instead of mainnet. */
+  testnet?: boolean;
+  /** API key for authentication. When provided, the client uses API key auth. */
+  apiKey?: string;
+  /** Authentication type. Defaults to 'token'. Forced to 'apiKey' when apiKey is provided. */
+  authType?: 'token' | 'apiKey';
+  /** Logger instance. Defaults to a console-backed logger at logLevel. */
+  logger?: Logger;
+  /** Log level for the default logger. Ignored if a custom logger is provided. */
+  logLevel?: LogLevel;
+  /** Custom storage adapter for token persistence. Defaults to expo-secure-store. */
+  authStorage?: AuthStorage;
+  /** Disable the WebSocket connection. Most APIs will not work without it. */
+  disableSocket?: boolean;
+}
+
+function assertCryptoPolyfill(): void {
+  if (
+    typeof globalThis.crypto === 'undefined' ||
+    typeof globalThis.crypto.getRandomValues !== 'function'
+  ) {
+    throw new Error(
+      "@sogni-ai/expo-client requires crypto.getRandomValues. At your app entry point (e.g. app/_layout.tsx) add:\n  import { polyfillWebCrypto } from 'expo-standard-web-crypto';\n  polyfillWebCrypto();\nSee README for details."
+    );
+  }
+}
+
+export class SogniClient {
+  apiClient: ApiClient;
+  account: AccountApi;
+  projects: ProjectsApi;
+  chat: ChatApi;
+
+  private constructor(client: ApiClient, options: { testnet?: boolean } = {}) {
+    this.apiClient = client;
+    this.account = new AccountApi(client, { testnet: options.testnet });
+    this.projects = new ProjectsApi(client);
+    this.chat = new ChatApi(client);
+  }
+
+  get isAuthenticated(): boolean {
+    return this.apiClient.isAuthenticated;
+  }
+
+  /**
+   * For token-based auth, restore a session from refresh+access tokens.
+   * Typically called once at app startup; the SDK also auto-restores from
+   * secure storage in `create()`, so this is only needed when migrating
+   * tokens from another source.
+   */
+  async setTokens(tokens: TokenAuthData): Promise<void> {
+    const auth = this.apiClient.auth;
+    if (!(auth instanceof TokenAuthManager)) {
+      throw new Error('setTokens can only be used with token authentication');
+    }
+    await auth.authenticate(tokens);
+  }
+
+  /** Disconnect and tear down resources. Instance should not be reused after dispose(). */
+  dispose() {
+    this.apiClient.dispose();
+  }
+
+  static async create(config: SogniClientConfig): Promise<SogniClient> {
+    assertCryptoPolyfill();
+
+    const restEndpoint = config.restEndpoint || 'https://api.sogni.ai';
+    const socketEndpoint = config.socketEndpoint || 'wss://socket.sogni.ai';
+    const network: SupernetType = config.network || 'fast';
+    const logger = config.logger || new DefaultLogger(config.logLevel || 'warn');
+    const authType: 'token' | 'apiKey' = config.apiKey ? 'apiKey' : config.authType || 'token';
+
+    const apiClient = new ApiClient({
+      baseUrl: restEndpoint,
+      socketUrl: socketEndpoint,
+      appId: config.appId,
+      appSource: config.appSource,
+      networkType: network,
+      authType,
+      logger,
+      authStorage: config.authStorage,
+      disableSocket: config.disableSocket
+    });
+
+    if (config.apiKey) {
+      const auth = apiClient.auth as ApiKeyAuthManager;
+      await auth.authenticate(config.apiKey);
+    } else if (apiClient.auth instanceof TokenAuthManager) {
+      await apiClient.auth.restore();
+    }
+
+    return new SogniClient(apiClient, { testnet: config.testnet });
+  }
+}