@sogni-ai/sogni-client 4.2.0-alpha.2 → 4.2.0-alpha.21

package/src/CreativeWorkflows/index.ts

@@ -0,0 +1,290 @@
+import ApiGroup, { ApiConfig } from '../ApiGroup';
+import { ApiError, ApiResponse } from '../ApiClient';
+import {
+  CreativeWorkflowRecord,
+  CreativeWorkflowEvent,
+  CreativeWorkflowSseEvent,
+  ListCreativeWorkflowOptions,
+  StartCreativeWorkflowOptions,
+  StartCreativeWorkflowParams,
+  StartHostedToolSequenceWorkflowInput,
+  StartImageToVideoWorkflowInput,
+  StreamCreativeWorkflowEventsOptions
+} from './types';
+
+interface CreativeWorkflowEnvelope {
+  workflow?: CreativeWorkflowRecord;
+  workflows?: CreativeWorkflowRecord[];
+  events?: CreativeWorkflowEvent[];
+  cancelled?: boolean;
+  [key: string]: unknown;
+}
+
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled']);
+
+function toQuery(params: Record<string, string | number | undefined>): string {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined) {
+      query.set(key, String(value));
+    }
+  }
+  const serialized = query.toString();
+  return serialized ? `?${serialized}` : '';
+}
+
+function isTerminalWorkflowStatus(value: unknown): boolean {
+  return typeof value === 'string' && TERMINAL_STATUSES.has(value);
+}
+
+function parseJsonResponse(text: string): unknown {
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { status: 'error', message: text, errorCode: 0 };
+  }
+}
+
+function parseEnvelope<T>(response: ApiResponse<CreativeWorkflowEnvelope>, key: string): T {
+  const data = response.data;
+  if (!data || typeof data !== 'object') {
+    throw new Error('Creative workflow response did not include data');
+  }
+  if (!(key in data)) {
+    throw new Error(`Creative workflow response did not include data.${key}`);
+  }
+  return data[key] as T;
+}
+
+export function parseCreativeWorkflowSseChunk(chunk: string): CreativeWorkflowSseEvent[] {
+  return chunk
+    .split(/\r?\n\r?\n/)
+    .map((block) => block.trim())
+    .filter(Boolean)
+    .map((block) => {
+      const frame: CreativeWorkflowSseEvent = {
+        event: 'message',
+        data: null,
+        raw: block
+      };
+      const dataLines: string[] = [];
+
+      for (const line of block.split(/\r?\n/)) {
+        if (!line || line.startsWith(':')) continue;
+        const separator = line.indexOf(':');
+        const field = separator === -1 ? line : line.slice(0, separator);
+        const value = separator === -1 ? '' : line.slice(separator + 1).replace(/^ /, '');
+
+        if (field === 'id') {
+          frame.id = value;
+        } else if (field === 'event') {
+          frame.event = value || 'message';
+        } else if (field === 'data') {
+          dataLines.push(value);
+        }
+      }
+
+      const data = dataLines.join('\n');
+      if (data) {
+        try {
+          frame.data = JSON.parse(data);
+        } catch {
+          frame.data = data;
+        }
+      }
+
+      return frame;
+    });
+}
+
+class CreativeWorkflowsApi extends ApiGroup {
+  constructor(config: ApiConfig) {
+    super(config);
+  }
+
+  async start(
+    params: StartCreativeWorkflowParams,
+    options: StartCreativeWorkflowOptions = {}
+  ): Promise<CreativeWorkflowRecord> {
+    const body: Record<string, unknown> = {
+      kind: params.kind,
+      input: params.input
+    };
+    const tokenType = params.token_type ?? params.tokenType;
+    if (tokenType) {
+      body.token_type = tokenType;
+    }
+
+    const response = await this.request<CreativeWorkflowEnvelope>('/v1/creative-agent/workflows', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body),
+      signal: options.signal
+    });
+    return parseEnvelope<CreativeWorkflowRecord>(response, 'workflow');
+  }
+
+  startImageToVideo(
+    input: StartImageToVideoWorkflowInput,
+    options: StartCreativeWorkflowOptions & {
+      tokenType?: StartCreativeWorkflowParams['tokenType'];
+    } = {}
+  ): Promise<CreativeWorkflowRecord> {
+    return this.start(
+      {
+        kind: 'image_to_video',
+        input,
+        tokenType: options.tokenType
+      },
+      options
+    );
+  }
+
+  startHostedToolSequence(
+    input: StartHostedToolSequenceWorkflowInput,
+    options: StartCreativeWorkflowOptions & {
+      tokenType?: StartCreativeWorkflowParams['tokenType'];
+    } = {}
+  ): Promise<CreativeWorkflowRecord> {
+    return this.start(
+      {
+        kind: 'hosted_tool_sequence',
+        input,
+        tokenType: options.tokenType
+      },
+      options
+    );
+  }
+
+  async list(options: ListCreativeWorkflowOptions = {}): Promise<CreativeWorkflowRecord[]> {
+    const response = await this.request<CreativeWorkflowEnvelope>(
+      `/v1/creative-agent/workflows${toQuery({
+        limit: options.limit,
+        offset: options.offset
+      })}`
+    );
+    return parseEnvelope<CreativeWorkflowRecord[]>(response, 'workflows');
+  }
+
+  async get(workflowId: string): Promise<CreativeWorkflowRecord> {
+    const response = await this.request<CreativeWorkflowEnvelope>(
+      `/v1/creative-agent/workflows/${encodeURIComponent(workflowId)}`
+    );
+    return parseEnvelope<CreativeWorkflowRecord>(response, 'workflow');
+  }
+
+  async events(workflowId: string): Promise<CreativeWorkflowEvent[]> {
+    const response = await this.request<CreativeWorkflowEnvelope>(
+      `/v1/creative-agent/workflows/${encodeURIComponent(workflowId)}/events`
+    );
+    return parseEnvelope<CreativeWorkflowEvent[]>(response, 'events');
+  }
+
+  async cancel(workflowId: string): Promise<CreativeWorkflowRecord> {
+    const response = await this.request<CreativeWorkflowEnvelope>(
+      `/v1/creative-agent/workflows/${encodeURIComponent(workflowId)}/cancel`,
+      {
+        method: 'POST'
+      }
+    );
+    return parseEnvelope<CreativeWorkflowRecord>(response, 'workflow');
+  }
+
+  async *streamEvents(
+    workflowId: string,
+    options: StreamCreativeWorkflowEventsOptions = {}
+  ): AsyncIterableIterator<CreativeWorkflowSseEvent> {
+    const after = options.after ?? options.lastEventId;
+    const query = toQuery({ after });
+    const headers: Record<string, string> = {
+      Accept: 'text/event-stream'
+    };
+    if (options.lastEventId !== undefined) {
+      headers['Last-Event-ID'] = String(options.lastEventId);
+    }
+
+    const response = await this.fetch(
+      `/v1/creative-agent/workflows/${encodeURIComponent(workflowId)}/events/stream${query}`,
+      {
+        method: 'GET',
+        headers,
+        signal: options.signal
+      }
+    );
+
+    if (!response.ok) {
+      throw await this.toApiError(response);
+    }
+    if (!response.body) {
+      return;
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split(/\r?\n\r?\n/);
+        buffer = parts.pop() ?? '';
+
+        for (const frame of parseCreativeWorkflowSseChunk(parts.join('\n\n'))) {
+          yield frame;
+          const data = frame.data as { status?: unknown } | null;
+          if (data && isTerminalWorkflowStatus(data.status)) {
+            await reader.cancel();
+            return;
+          }
+        }
+      }
+
+      buffer += decoder.decode();
+      for (const frame of parseCreativeWorkflowSseChunk(buffer)) {
+        yield frame;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  private async request<T = CreativeWorkflowEnvelope>(
+    path: string,
+    options: RequestInit = {}
+  ): Promise<ApiResponse<T>> {
+    const response = await this.fetch(path, options);
+    if (!response.ok) {
+      throw await this.toApiError(response);
+    }
+    return (await response.json()) as ApiResponse<T>;
+  }
+
+  private async fetch(path: string, options: RequestInit = {}): Promise<Response> {
+    const url = new URL(path, this.client.rest.baseUrl).toString();
+    const authenticated = await this.client.auth.authenticateRequest(options);
+    return fetch(url, authenticated);
+  }
+
+  private async toApiError(response: Response): Promise<ApiError> {
+    if (response.status === 401 && this.client.auth.isAuthenticated) {
+      this.client.auth.clear();
+    }
+    const body = parseJsonResponse(await response.text()) as Record<string, unknown>;
+    const payload =
+      body.status === 'error' ? body : ((body.data as Record<string, unknown>) ?? body);
+    return new ApiError(response.status, {
+      status: 'error',
+      message: typeof payload.message === 'string' ? payload.message : response.statusText,
+      errorCode: typeof payload.errorCode === 'number' ? payload.errorCode : 0
+    });
+  }
+}
+
+export default CreativeWorkflowsApi;
+export * from './types';

package/src/CreativeWorkflows/types.ts

@@ -0,0 +1,134 @@
+import { TokenType } from '../types/token';
+
+export type CreativeWorkflowStatus =
+  | 'queued'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | string;
+
+export type CreativeWorkflowKind = 'image_to_video' | 'hosted_tool_sequence' | string;
+export type CreativeWorkflowHostedToolName =
+  | 'sogni_generate_image'
+  | 'sogni_edit_image'
+  | 'sogni_generate_video'
+  | 'sogni_sound_to_video'
+  | 'sogni_video_to_video'
+  | 'sogni_generate_music';
+
+export interface CreativeWorkflowArtifact {
+  id?: string;
+  url?: string;
+  type?: string;
+  mediaType?: string;
+  mimeType?: string;
+  width?: number;
+  height?: number;
+  duration?: number;
+  [key: string]: unknown;
+}
+
+export interface CreativeWorkflowEvent {
+  id?: string | number;
+  event?: string;
+  type?: string;
+  status?: CreativeWorkflowStatus;
+  message?: string;
+  timestamp?: number;
+  data?: unknown;
+  [key: string]: unknown;
+}
+
+export interface CreativeWorkflowRecord {
+  workflowId: string;
+  kind?: CreativeWorkflowKind;
+  title?: string;
+  status?: CreativeWorkflowStatus;
+  input?: Record<string, unknown>;
+  plan?: Record<string, unknown>;
+  steps?: unknown[];
+  events?: CreativeWorkflowEvent[];
+  artifacts?: CreativeWorkflowArtifact[];
+  billingPreview?: unknown;
+  billingPreviews?: unknown[];
+  createTime?: number;
+  updateTime?: number;
+  createdAt?: string;
+  updatedAt?: string;
+  error?: unknown;
+  [key: string]: unknown;
+}
+
+export interface StartImageToVideoWorkflowInput {
+  prompt: string;
+  videoPrompt?: string;
+  negativePrompt?: string;
+  width?: number;
+  height?: number;
+  duration?: number;
+  imageModel?: string;
+  videoModel?: string;
+  numberOfMedia?: number;
+  seed?: number;
+  [key: string]: unknown;
+}
+
+export interface StartHostedToolSequenceWorkflowDependency {
+  sourceStepId: string;
+  targetArgument: string;
+  transform: 'artifact_url' | 'artifact_data_uri';
+  sourceArtifactId?: string;
+  sourceArtifactIndex?: number;
+  mediaType?: 'image' | 'video' | 'audio';
+  required?: boolean;
+}
+
+export interface StartHostedToolSequenceWorkflowStep {
+  id?: string;
+  toolName: CreativeWorkflowHostedToolName;
+  arguments: Record<string, unknown>;
+  dependsOn?: StartHostedToolSequenceWorkflowDependency[];
+}
+
+export interface StartHostedToolSequenceWorkflowInput {
+  title?: string;
+  steps: StartHostedToolSequenceWorkflowStep[];
+  [key: string]: unknown;
+}
+
+export type StartCreativeWorkflowParams =
+  | {
+      kind: 'image_to_video';
+      input: StartImageToVideoWorkflowInput;
+      tokenType?: TokenType;
+      token_type?: TokenType;
+    }
+  | {
+      kind: 'hosted_tool_sequence';
+      input: StartHostedToolSequenceWorkflowInput;
+      tokenType?: TokenType;
+      token_type?: TokenType;
+    };
+
+export interface StartCreativeWorkflowOptions {
+  signal?: AbortSignal;
+}
+
+export interface ListCreativeWorkflowOptions {
+  limit?: number;
+  offset?: number;
+}
+
+export interface StreamCreativeWorkflowEventsOptions {
+  after?: string | number;
+  lastEventId?: string | number;
+  signal?: AbortSignal;
+}
+
+export interface CreativeWorkflowSseEvent {
+  id?: string;
+  event: string;
+  data: unknown;
+  raw: string;
+}

package/src/Projects/Job.ts

@@ -43,6 +43,44 @@ const JOB_STATUS_MAP: Record<RawJob['status'], JobStatus> = {
   jobError: 'failed'
 };
 
+function clampProgress(value: number): number {
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+
+function normalizeProgressPercent(value: unknown): number | undefined {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined;
+  return clampProgress(value >= 0 && value <= 1 ? value * 100 : value);
+}
+
+function directResultUrlFromRawJob(rawJob: RawJob): string | null {
+  const legacy = rawJob as RawJob & {
+    imageUrl?: string | null;
+    imageFile?: string | null;
+    videoUrl?: string | null;
+    videoFile?: string | null;
+  };
+  return (
+    rawJob.resultUrl ||
+    legacy.imageUrl ||
+    legacy.imageFile ||
+    legacy.videoUrl ||
+    legacy.videoFile ||
+    null
+  );
+}
+
+function etaProgressPercent(
+  startedAt: Date | undefined,
+  eta: Date | undefined
+): number | undefined {
+  if (!startedAt || !eta) return undefined;
+  const totalMs = eta.getTime() - startedAt.getTime();
+  if (!Number.isFinite(totalMs) || totalMs <= 0) return undefined;
+  const elapsedMs = Date.now() - startedAt.getTime();
+  if (!Number.isFinite(elapsedMs) || elapsedMs <= 0) return 1;
+  return Math.max(1, Math.min(95, Math.round((elapsedMs / totalMs) * 100)));
+}
+
 /**
  * @inline
  */
@@ -62,6 +100,11 @@ export interface JobData {
   positivePrompt?: string;
   negativePrompt?: string;
   jobIndex?: number;
+  /**
+   * Direct progress percentage from external API-backed workers. Values may be
+   * 0-1 or 0-100 depending on the upstream provider event.
+   */
+  externalProgress?: number;
   /**
    * Estimated time remaining in seconds (for long-running jobs like video generation).
    * Updated by ComfyUI workers during inference.
@@ -73,6 +116,7 @@ export interface JobData {
    * Updated by ComfyUI workers during inference.
    */
   eta?: Date;
+  etaStartedAt?: Date;
 }
 
 export interface JobEventMap extends EntityEvents {
@@ -98,7 +142,8 @@ class Job extends DataEntity<JobData, JobEventMap> {
         stepCount: rawProject.stepCount,
         workerName: rawJob.worker.name,
         seed: rawJob.seedUsed,
-        isNSFW: rawJob.triggeredNSFWFilter
+        isNSFW: rawJob.triggeredNSFWFilter,
+        resultUrl: directResultUrlFromRawJob(rawJob)
       },
       options
     );
@@ -143,7 +188,13 @@ class Job extends DataEntity<JobData, JobEventMap> {
    * Progress of the job in percentage (0-100).
    */
   get progress() {
-    return Math.round((this.data.step / this.data.stepCount) * 100);
+    if (this.status === 'completed') return 100;
+    const externalProgress = normalizeProgressPercent(this.data.externalProgress);
+    if (externalProgress !== undefined) return externalProgress;
+    if (this.data.stepCount > 0) {
+      return clampProgress((this.data.step / this.data.stepCount) * 100);
+    }
+    return etaProgressPercent(this.data.etaStartedAt, this.data.eta) ?? 0;
   }
 
   /**
@@ -261,6 +312,9 @@ class Job extends DataEntity<JobData, JobEventMap> {
    * For video jobs, this returns a video URL. For image jobs, this returns an image URL.
    */
   async getResultUrl(): Promise<string> {
+    if (this.data.resultUrl) {
+      return this.data.resultUrl;
+    }
     if (this.data.status !== 'completed') {
       throw new Error('Job is not completed yet');
     }
@@ -326,16 +380,25 @@ class Job extends DataEntity<JobData, JobEventMap> {
    * @param data
    */
   async _syncWithRestData(data: RawJob) {
+    const directResultUrl = directResultUrlFromRawJob(data);
     const delta: Partial<JobData> = {
       step: data.performedSteps,
-      workerName: data.worker.name,
+      workerName: data.worker?.name,
       seed: data.seedUsed,
       isNSFW: data.triggeredNSFWFilter
     };
     if (JOB_STATUS_MAP[data.status]) {
       delta.status = JOB_STATUS_MAP[data.status];
     }
-    if (!this.data.resultUrl && delta.status === 'completed' && !data.triggeredNSFWFilter) {
+    if (!this.data.resultUrl && directResultUrl) {
+      delta.resultUrl = directResultUrl;
+    }
+    if (
+      !this.data.resultUrl &&
+      !delta.resultUrl &&
+      delta.status === 'completed' &&
+      !data.triggeredNSFWFilter
+    ) {
       try {
         if (this.type === 'video' || this.type === 'audio') {
           delta.resultUrl = await this._api.mediaDownloadUrl({
@@ -369,13 +432,21 @@ class Job extends DataEntity<JobData, JobEventMap> {
       // Keeping etaSeconds for backwards compatibility
       if (delta.eta) {
         delta.etaSeconds = Math.round((delta.eta.getTime() - Date.now()) / 1000);
+        if (!this.data.etaStartedAt && !delta.etaStartedAt) {
+          delta.etaStartedAt = new Date();
+        }
       }
     }
     super._update(delta);
   }
 
   private handleUpdated(keys: string[]) {
-    if (keys.includes('step') || keys.includes('stepCount')) {
+    if (
+      keys.includes('step') ||
+      keys.includes('stepCount') ||
+      keys.includes('externalProgress') ||
+      keys.includes('eta')
+    ) {
       this.emit('progress', this.progress);
     }
     if (keys.includes('status') && this.status === 'completed') {

package/src/Projects/Project.ts

@@ -126,11 +126,17 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
    * Progress of the project in percentage (0-100).
    */
   get progress() {
+    if (this.status === 'completed') return 100;
     // Worker can reduce the number of steps in the job, so we need to calculate the progress based on the actual number of steps
-    const stepsPerJob = this.jobs.length ? this.jobs[0].stepCount : (this.data.params.steps ?? 0);
-    const jobCount = this.data.params.numberOfMedia;
+    const jobCount = Math.max(1, this.data.params.numberOfMedia);
+    if (this._jobs.length) {
+      const progressTotal = this._jobs.reduce((acc, job) => acc + job.progress, 0);
+      return Math.max(0, Math.min(100, Math.round(progressTotal / jobCount)));
+    }
+    const stepsPerJob = this.data.params.steps ?? 0;
+    if (stepsPerJob <= 0) return 0;
     const stepsDone = this._jobs.reduce((acc, job) => acc + job.step, 0);
-    return Math.round((stepsDone / ((stepsPerJob ?? 1) * jobCount)) * 100);
+    return Math.max(0, Math.min(100, Math.round((stepsDone / (stepsPerJob * jobCount)) * 100)));
   }
 
   get queuePosition() {
@@ -268,6 +274,10 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
           this._logger.error(
             `Failed to sync project data after ${MAX_FAILED_SYNC_ATTEMPTS} attempts. Stopping further attempts.`
           );
+          this._api._notifyProjectTimedOut(this.id).catch((cancelError) => {
+            this._logger.error(`Failed to notify socket server that project ${this.id} timed out`);
+            this._logger.error(cancelError);
+          });
           clearInterval(this._timeout!);
           this._timeout = null;
           this.jobs.forEach((job) => {