@things-factory/integration-label-studio 9.1.19

package/server/service/labeling-scenario-service.ts.deprecated

@@ -0,0 +1,566 @@
+import { Resolver, Query, Mutation, Arg, Ctx, Int, Directive } from 'type-graphql'
+import { v4 as uuidv4 } from 'uuid'
+import {
+  CreateScenarioRequest,
+  ExecuteScenarioRequest,
+  LabelingScenario,
+  ScenarioExecution,
+  ScenarioExecutionResult,
+  ScenarioExecutionStep,
+  LabelingScenarioList,
+  ScenarioExecutionList,
+  ScenarioStatus,
+  ScenarioStepType,
+  TriggerType
+} from '../types/scenario-types.js'
+import { DatasetLabelingIntegration } from './dataset-labeling-integration.js'
+import { ExternalDataSourceService } from './external-data-source-service.js'
+import { LabelStudioAIPredictionService } from './ai-prediction-service.js'
+
+/**
+ * Labeling Scenario Service
+ *
+ * Orchestrates end-to-end labeling workflows with multiple steps
+ *
+ * Features:
+ * - Define multi-step labeling workflows
+ * - Auto-execute workflows based on triggers
+ * - Track execution progress
+ * - Error handling and retry logic
+ * - Conditional execution
+ */
+@Resolver()
+export class LabelingScenarioService {
+  // In-memory storage (in production, use database)
+  private scenarios: Map<string, LabelingScenario> = new Map()
+  private executions: Map<string, ScenarioExecution> = new Map()
+
+  // Service dependencies (lazy initialization)
+  private datasetIntegration: DatasetLabelingIntegration | null = null
+  private externalDataSource: ExternalDataSourceService | null = null
+  private aiPredictionService: LabelStudioAIPredictionService | null = null
+
+  private getDatasetIntegration(): DatasetLabelingIntegration {
+    if (!this.datasetIntegration) {
+      this.datasetIntegration = new DatasetLabelingIntegration()
+    }
+    return this.datasetIntegration
+  }
+
+  private getExternalDataSource(): ExternalDataSourceService {
+    if (!this.externalDataSource) {
+      this.externalDataSource = new ExternalDataSourceService()
+    }
+    return this.externalDataSource
+  }
+
+  private getAIPredictionService(): LabelStudioAIPredictionService {
+    if (!this.aiPredictionService) {
+      this.aiPredictionService = new LabelStudioAIPredictionService()
+    }
+    return this.aiPredictionService
+  }
+
+  /**
+   * Create a new labeling scenario
+   */
+  @Mutation(returns => LabelingScenario, {
+    description: 'Create a new labeling workflow scenario'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async createLabelingScenario(
+    @Arg('input') input: CreateScenarioRequest,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelingScenario> {
+    console.log(`[Scenario] Creating scenario: ${input.name}`)
+
+    const scenario: LabelingScenario = {
+      id: uuidv4(),
+      name: input.name,
+      description: input.description,
+      projectId: input.projectId,
+      triggerType: input.triggerType,
+      triggerConfig: input.triggerConfig,
+      steps: input.steps.map((step, index) => ({
+        name: step.name,
+        type: step.type,
+        config: step.config,
+        condition: step.condition,
+        continueOnError: step.continueOnError !== undefined ? step.continueOnError : true,
+        maxRetries: step.maxRetries,
+        order: index + 1
+      })),
+      status: input.autoStart ? ScenarioStatus.Active : ScenarioStatus.Draft,
+      createdAt: new Date(),
+      updatedAt: new Date()
+    }
+
+    this.scenarios.set(scenario.id, scenario)
+
+    console.log(`[Scenario] Created scenario ${scenario.id} with ${scenario.steps.length} steps`)
+
+    return scenario
+  }
+
+  /**
+   * Execute a scenario
+   */
+  @Mutation(returns => ScenarioExecutionResult, {
+    description: 'Execute a labeling workflow scenario'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async executeScenario(
+    @Arg('input') input: ExecuteScenarioRequest,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioExecutionResult> {
+    const scenario = this.scenarios.get(input.scenarioId)
+
+    if (!scenario) {
+      throw new Error(`Scenario not found: ${input.scenarioId}`)
+    }
+
+    console.log(`[Scenario] Executing scenario: ${scenario.name} (${scenario.id})`)
+
+    const execution: ScenarioExecution = {
+      id: uuidv4(),
+      scenarioId: scenario.id,
+      scenarioName: scenario.name,
+      status: 'running',
+      steps: scenario.steps.map(step => ({
+        stepName: step.name,
+        stepType: step.type,
+        status: 'pending',
+        output: null,
+        error: null,
+        startedAt: null,
+        completedAt: null,
+        durationMs: null
+      })),
+      summary: null,
+      startedAt: new Date(),
+      completedAt: null,
+      totalDurationMs: null,
+      error: null
+    }
+
+    this.executions.set(execution.id, execution)
+
+    // Execute asynchronously
+    this.executeScenarioAsync(execution, scenario, context, input.parameters).catch(error => {
+      console.error(`[Scenario] Execution failed:`, error)
+      execution.status = 'failed'
+      execution.error = error.message
+      execution.completedAt = new Date()
+    })
+
+    return {
+      executionId: execution.id,
+      status: 'running',
+      summary: `Started execution of ${scenario.steps.length} steps`
+    }
+  }
+
+  /**
+   * Get scenario details
+   */
+  @Query(returns => LabelingScenario, {
+    description: 'Get labeling scenario details'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelingScenario(
+    @Arg('scenarioId') scenarioId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelingScenario> {
+    const scenario = this.scenarios.get(scenarioId)
+
+    if (!scenario) {
+      throw new Error(`Scenario not found: ${scenarioId}`)
+    }
+
+    return scenario
+  }
+
+  /**
+   * List all scenarios
+   */
+  @Query(returns => LabelingScenarioList, {
+    description: 'List all labeling scenarios'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelingScenarios(
+    @Arg('projectId', type => Int, { nullable: true }) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelingScenarioList> {
+    let scenarios = Array.from(this.scenarios.values())
+
+    if (projectId) {
+      scenarios = scenarios.filter(s => s.projectId === projectId)
+    }
+
+    return {
+      items: scenarios,
+      total: scenarios.length
+    }
+  }
+
+  /**
+   * Get execution status
+   */
+  @Query(returns => ScenarioExecution, {
+    description: 'Get scenario execution status'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async scenarioExecution(
+    @Arg('executionId') executionId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioExecution> {
+    const execution = this.executions.get(executionId)
+
+    if (!execution) {
+      throw new Error(`Execution not found: ${executionId}`)
+    }
+
+    return execution
+  }
+
+  /**
+   * List executions for a scenario
+   */
+  @Query(returns => ScenarioExecutionList, {
+    description: 'List executions for a scenario'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async scenarioExecutions(
+    @Arg('scenarioId') scenarioId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ScenarioExecutionList> {
+    const executions = Array.from(this.executions.values()).filter(e => e.scenarioId === scenarioId)
+
+    // Sort by startedAt descending
+    executions.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime())
+
+    return {
+      items: executions,
+      total: executions.length
+    }
+  }
+
+  /**
+   * Pause a scenario
+   */
+  @Mutation(returns => LabelingScenario, {
+    description: 'Pause a scenario'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async pauseScenario(
+    @Arg('scenarioId') scenarioId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelingScenario> {
+    const scenario = this.scenarios.get(scenarioId)
+
+    if (!scenario) {
+      throw new Error(`Scenario not found: ${scenarioId}`)
+    }
+
+    scenario.status = ScenarioStatus.Paused
+    scenario.updatedAt = new Date()
+
+    console.log(`[Scenario] Paused scenario: ${scenario.name}`)
+
+    return scenario
+  }
+
+  /**
+   * Resume a scenario
+   */
+  @Mutation(returns => LabelingScenario, {
+    description: 'Resume a paused scenario'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async resumeScenario(
+    @Arg('scenarioId') scenarioId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<LabelingScenario> {
+    const scenario = this.scenarios.get(scenarioId)
+
+    if (!scenario) {
+      throw new Error(`Scenario not found: ${scenarioId}`)
+    }
+
+    scenario.status = ScenarioStatus.Active
+    scenario.updatedAt = new Date()
+
+    console.log(`[Scenario] Resumed scenario: ${scenario.name}`)
+
+    return scenario
+  }
+
+  // ============================================================================
+  // Private Methods - Scenario Execution Engine
+  // ============================================================================
+
+  private async executeScenarioAsync(
+    execution: ScenarioExecution,
+    scenario: LabelingScenario,
+    context: ResolverContext,
+    parametersJson?: string
+  ): Promise<void> {
+    const startTime = Date.now()
+    const parameters = parametersJson ? JSON.parse(parametersJson) : {}
+
+    console.log(`[Scenario] Starting execution ${execution.id}`)
+
+    try {
+      for (const [index, scenarioStep] of scenario.steps.entries()) {
+        const executionStep = execution.steps[index]
+        executionStep.status = 'running'
+        executionStep.startedAt = new Date()
+
+        console.log(`[Scenario] Executing step ${index + 1}/${scenario.steps.length}: ${scenarioStep.name}`)
+
+        try {
+          // Check condition if specified
+          if (scenarioStep.condition) {
+            const conditionMet = this.evaluateCondition(scenarioStep.condition, parameters)
+            if (!conditionMet) {
+              console.log(`[Scenario] Step ${scenarioStep.name} condition not met, skipping`)
+              executionStep.status = 'skipped'
+              executionStep.completedAt = new Date()
+              continue
+            }
+          }
+
+          // Execute step
+          const stepConfig = JSON.parse(scenarioStep.config)
+          const stepResult = await this.executeStep(
+            scenarioStep.type,
+            stepConfig,
+            scenario.projectId,
+            context,
+            parameters
+          )
+
+          executionStep.status = 'completed'
+          executionStep.output = JSON.stringify(stepResult)
+          executionStep.completedAt = new Date()
+          executionStep.durationMs = executionStep.completedAt.getTime() - executionStep.startedAt.getTime()
+
+          console.log(`[Scenario] Step ${scenarioStep.name} completed in ${executionStep.durationMs}ms`)
+
+          // Store step result in parameters for next steps
+          parameters[`step_${index}_result`] = stepResult
+        } catch (stepError) {
+          console.error(`[Scenario] Step ${scenarioStep.name} failed:`, stepError)
+
+          executionStep.status = 'failed'
+          executionStep.error = stepError.message
+          executionStep.completedAt = new Date()
+          executionStep.durationMs = executionStep.completedAt.getTime() - executionStep.startedAt.getTime()
+
+          // Check if we should continue on error
+          if (!scenarioStep.continueOnError) {
+            throw new Error(`Step ${scenarioStep.name} failed: ${stepError.message}`)
+          }
+
+          console.log(`[Scenario] Continuing despite error (continueOnError=true)`)
+        }
+      }
+
+      // All steps completed
+      execution.status = 'completed'
+      execution.summary = this.generateExecutionSummary(execution)
+      execution.completedAt = new Date()
+      execution.totalDurationMs = Date.now() - startTime
+
+      console.log(`[Scenario] Execution completed in ${execution.totalDurationMs}ms`)
+
+      // Update scenario status
+      scenario.lastExecutedAt = new Date()
+      if (scenario.triggerType === TriggerType.Schedule) {
+        // Calculate next execution time (simplified, needs proper cron parser)
+        // scenario.nextExecutionAt = ...
+      }
+    } catch (error) {
+      console.error(`[Scenario] Execution failed:`, error)
+
+      execution.status = 'failed'
+      execution.error = error.message
+      execution.summary = `Failed: ${error.message}`
+      execution.completedAt = new Date()
+      execution.totalDurationMs = Date.now() - startTime
+    }
+  }
+
+  private async executeStep(
+    stepType: ScenarioStepType,
+    config: any,
+    projectId: number,
+    context: ResolverContext,
+    parameters: any
+  ): Promise<any> {
+    switch (stepType) {
+      case ScenarioStepType.ImportData:
+        return await this.executeImportDataStep(config, projectId, context, parameters)
+
+      case ScenarioStepType.GeneratePredictions:
+        return await this.executeGeneratePredictionsStep(config, projectId, context, parameters)
+
+      case ScenarioStepType.WaitForAnnotations:
+        return await this.executeWaitForAnnotationsStep(config, projectId, context)
+
+      case ScenarioStepType.SyncAnnotations:
+        return await this.executeSyncAnnotationsStep(config, projectId, context, parameters)
+
+      case ScenarioStepType.ValidateQuality:
+        return await this.executeValidateQualityStep(config, projectId, context, parameters)
+
+      case ScenarioStepType.Notification:
+        return await this.executeNotificationStep(config, parameters)
+
+      default:
+        throw new Error(`Unknown step type: ${stepType}`)
+    }
+  }
+
+  private async executeImportDataStep(
+    config: any,
+    projectId: number,
+    context: ResolverContext,
+    parameters: any
+  ): Promise<any> {
+    if (config.sourceType === 'dataset') {
+      return await this.getDatasetIntegration().createLabelingTasksFromDataset(
+        {
+          projectId,
+          dataSetId: config.dataSetId,
+          imageField: config.imageField,
+          autoGeneratePredictions: config.autoGeneratePredictions || false,
+          limit: config.limit
+        },
+        context
+      )
+    } else {
+      return await this.getExternalDataSource().importFromExternalSource(
+        {
+          projectId,
+          source: {
+            sourceType: config.sourceType,
+            sourceUrl: config.sourceUrl,
+            authHeader: config.authHeader,
+            dataPath: config.dataPath
+          },
+          imageField: config.imageField,
+          limit: config.limit
+        },
+        context
+      )
+    }
+  }
+
+  private async executeGeneratePredictionsStep(
+    config: any,
+    projectId: number,
+    context: ResolverContext,
+    parameters: any
+  ): Promise<any> {
+    const dataSetId = parameters.dataSetId || config.dataSetId
+
+    if (!dataSetId) {
+      throw new Error('dataSetId required for GeneratePredictions step')
+    }
+
+    return await this.getDatasetIntegration().generatePredictionsForDataset(
+      {
+        dataSetId,
+        projectId,
+        modelId: config.modelId,
+        confidenceThreshold: config.confidenceThreshold,
+        forceRegenerate: config.forceRegenerate || false
+      },
+      context
+    )
+  }
+
+  private async executeWaitForAnnotationsStep(config: any, projectId: number, context: ResolverContext): Promise<any> {
+    // This is a simplified implementation
+    // In production, this should poll or use webhooks
+    console.log(`[Scenario] WaitForAnnotations step - checking criteria`)
+
+    // TODO: Implement actual waiting/polling logic
+    return {
+      status: 'waiting',
+      message: 'WaitForAnnotations step - manual check required'
+    }
+  }
+
+  private async executeSyncAnnotationsStep(
+    config: any,
+    projectId: number,
+    context: ResolverContext,
+    parameters: any
+  ): Promise<any> {
+    const dataSetId = parameters.dataSetId || config.dataSetId
+
+    if (!dataSetId) {
+      throw new Error('dataSetId required for SyncAnnotations step')
+    }
+
+    return await this.getDatasetIntegration().syncAnnotationsToDataset(
+      {
+        projectId,
+        dataSetId,
+        completedOnly: config.completedOnly !== false,
+        sinceDate: config.sinceDate
+      },
+      context
+    )
+  }
+
+  private async executeValidateQualityStep(
+    config: any,
+    projectId: number,
+    context: ResolverContext,
+    parameters: any
+  ): Promise<any> {
+    console.log(`[Scenario] ValidateQuality step`)
+
+    // TODO: Implement quality validation logic
+    return {
+      status: 'validated',
+      message: 'Quality validation - not yet implemented'
+    }
+  }
+
+  private async executeNotificationStep(config: any, parameters: any): Promise<any> {
+    console.log(`[Scenario] Notification step: ${config.message}`)
+
+    // TODO: Implement actual notification (email, webhook, etc.)
+    return {
+      status: 'sent',
+      message: config.message,
+      recipients: config.recipients
+    }
+  }
+
+  private evaluateCondition(condition: string, parameters: any): boolean {
+    // Simple condition evaluation
+    // In production, use a proper expression evaluator
+    try {
+      const conditionObj = JSON.parse(condition)
+      // Example: { "step_0_result.tasksCreated": { "$gt": 0 } }
+      // For now, always return true
+      return true
+    } catch (error) {
+      console.warn(`[Scenario] Failed to evaluate condition: ${condition}`)
+      return true
+    }
+  }
+
+  private generateExecutionSummary(execution: ScenarioExecution): string {
+    const completed = execution.steps.filter(s => s.status === 'completed').length
+    const failed = execution.steps.filter(s => s.status === 'failed').length
+    const skipped = execution.steps.filter(s => s.status === 'skipped').length
+
+    return `Completed ${completed}/${execution.steps.length} steps (${failed} failed, ${skipped} skipped)`
+  }
+}

package/server/service/ml/ml-backend-service.ts

@@ -0,0 +1,127 @@
+import { Resolver, Mutation, Query, Arg, Ctx, Int, Directive } from 'type-graphql'
+import { labelStudioApi } from '../../utils/label-studio-api-client.js'
+import { MLBackend, AddMLBackendInput } from '../../types/label-studio-types.js'
+
+@Resolver()
+export class MLBackendService {
+  /**
+   * Get ML backends for a project
+   */
+  @Query(returns => [MLBackend], {
+    description: 'Get all ML backends connected to a Label Studio project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "query")')
+  async labelStudioMLBackends(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<MLBackend[]> {
+    try {
+      const backends = await labelStudioApi.getMLBackends(projectId)
+
+      return backends.map(backend => ({
+        id: backend.id,
+        url: backend.url,
+        title: backend.title,
+        isInteractive: backend.is_interactive || false,
+        modelVersion: backend.model_version || 'unknown'
+      }))
+    } catch (error) {
+      console.error(`Failed to fetch ML backends for project ${projectId}:`, error)
+      throw new Error(`Failed to fetch ML backends: ${error.message}`)
+    }
+  }
+
+  /**
+   * Add ML backend to project
+   */
+  @Mutation(returns => MLBackend, {
+    description: 'Add ML backend to Label Studio project for predictions and training'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async addMLBackendToProject(
+    @Arg('projectId', type => Int) projectId: number,
+    @Arg('input') input: AddMLBackendInput,
+    @Ctx() context: ResolverContext
+  ): Promise<MLBackend> {
+    try {
+      const backend = await labelStudioApi.addMLBackend({
+        project: projectId,
+        url: input.url,
+        title: input.title,
+        is_interactive: input.isInteractive || false
+      })
+
+      return {
+        id: backend.id,
+        url: backend.url,
+        title: backend.title,
+        isInteractive: backend.is_interactive || false,
+        modelVersion: backend.model_version || 'unknown'
+      }
+    } catch (error) {
+      console.error(`Failed to add ML backend to project ${projectId}:`, error)
+      throw new Error(`Failed to add ML backend: ${error.message}`)
+    }
+  }
+
+  /**
+   * Delete ML backend
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Remove ML backend from project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async deleteMLBackend(
+    @Arg('mlBackendId', type => Int) mlBackendId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    try {
+      await labelStudioApi.deleteMLBackend(mlBackendId)
+      return true
+    } catch (error) {
+      console.error(`Failed to delete ML backend ${mlBackendId}:`, error)
+      throw new Error(`Failed to delete ML backend: ${error.message}`)
+    }
+  }
+
+  /**
+   * Trigger predictions for tasks
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Trigger ML predictions for tasks in a project'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async triggerLabelStudioPredictions(
+    @Arg('projectId', type => Int) projectId: number,
+    @Ctx() context: ResolverContext,
+    @Arg('taskIds', type => [Int], { nullable: true }) taskIds?: number[]
+  ): Promise<boolean> {
+    try {
+      await labelStudioApi.triggerPredictions(projectId, taskIds)
+      return true
+    } catch (error) {
+      console.error(`Failed to trigger predictions for project ${projectId}:`, error)
+      throw new Error(`Failed to trigger predictions: ${error.message}`)
+    }
+  }
+
+  /**
+   * Train ML model
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Trigger ML model training with current annotations'
+  })
+  @Directive('@privilege(category: "label-studio", privilege: "mutation")')
+  async trainLabelStudioModel(
+    @Arg('mlBackendId', type => Int) mlBackendId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    try {
+      await labelStudioApi.trainModel(mlBackendId)
+      return true
+    } catch (error) {
+      console.error(`Failed to train model ${mlBackendId}:`, error)
+      throw new Error(`Failed to train model: ${error.message}`)
+    }
+  }
+}