The Reality of Physical Device Timing

Web applications typically operate in a world of milliseconds and seconds. Database queries return instantly, API calls complete in fractions of a second, and even complex form submissions finish within moments. This creates development patterns and user expectations built around immediate responses.

Physical devices operate on entirely different time scales. A coffee brewing cycle takes several minutes from start to finish. System calibration procedures can run for fifteen minutes or more. Maintenance cycles might require hours to complete properly. Firmware updates can tie up devices for extended periods while ensuring safety and reliability.

Traditional web development patterns—promises that resolve quickly, loading states that last seconds, operations that either succeed immediately or fail fast—simply don’t match the realities of device control. KOS Futures provide a sophisticated solution designed specifically for these long-running physical operations.

Understanding Futures as Smart Operation Tickets

Think of a KOS Future like a ticket you receive when you drop off clothes at a dry cleaner. The ticket isn’t your clean clothes—it’s a promise that your clothes are being processed, and it gives you a way to check on progress and eventually receive the finished result.

A Future represents a long-running operation that returns immediately with a handle, rather than blocking your application until the work completes. This handle provides real-time progress information, allows for safe cancellation when appropriate, and eventually resolves with the operation’s results.

The Future Lifecycle

Initiation Phase: When you request a device operation, you immediately receive a Future object. Your application can continue functioning normally while the backend begins orchestrating the complex device operation.

Progress Phase: The Future automatically receives real-time updates about the operation’s progress through WebSocket communication. Your UI can display current status, progress percentages, time estimates, and phase descriptions without any manual polling or refresh logic.

Resolution Phase: The operation either completes successfully with results, fails with meaningful error information, or is cancelled safely by user request. Your application receives definitive completion status and can respond appropriately.

Modern Future Implementation with @kosFutureAware

KOS now provides a streamlined decorator approach that eliminates setup boilerplate. The @kosFutureAware class decorator automatically adds all Future Container properties, while the @kosFuture method decorator transforms specific methods into Future-returning operations:

import { kosModel, kosFuture, kosFutureAware, IKosDataModel, FutureUpdateHandler } from "@kosdev-code/kos-ui-sdk";
// Interface merging provides full type safety for decorator properties
interface BrewingSystemModelImpl extends KosFutureAwareFull<BrewingResult> {}
@kosModel({ modelTypeId: "brewing-system-model", singleton: true })
@kosFutureAware() // Automatically adds futureHandler, progress, status, etc.
export class BrewingSystemModelImpl implements IKosDataModel, FutureUpdateHandler {
  id: string;
  // All Future properties added automatically: progress, status, isRunning, etc.
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No manual Future setup needed!
  }
  @kosFuture()
  async startBrewingCycle(recipe: BrewingRecipe): Promise<BrewingResult> {
    // This method returns immediately with a Future handle
    // The actual brewing operation happens asynchronously on the device
    return this.sendCommand('/brewing/start-cycle', { recipe });
  }
  @kosFuture()
  async runSystemCalibration(): Promise<CalibrationResult> {
    // Complex multi-step calibration appears as single operation
    return this.sendCommand('/system/calibrate', {});
  }
  @kosFuture()
  async executeCleaningCycle(): Promise<CleaningResult> {
    // Long-running maintenance operation with progress tracking
    return this.sendCommand('/maintenance/clean', {});
  }
  // Optional: Handle real-time Future updates
  onFutureUpdate?(future: IFutureModel<BrewingResult>): void {
    console.log(`Brewing ${future.progress * 100}% complete`);
    // This is called automatically when Future state changes
  }
}
// External interface includes all Future capabilities
export type BrewingSystemModel = PublicModelInterface<BrewingSystemModelImpl> & ExternalFutureInterface<BrewingResult>;

Each method marked with @kosFuture becomes a Future-returning operation. When called, these methods return immediately with a Future handle that provides access to progress information and eventual results, rather than blocking execution until the operation completes.

Two Decorator Modes for Different Needs

The @kosFutureAware decorator supports two modes to match your model’s requirements:

Full Mode (Default) – UI Integration

Use full mode when your UI needs direct access to Future state:

// Interface merging required for type safety
interface DeviceModelImpl extends KosFutureAwareFull<OperationResult> {}
@kosModel({ modelTypeId: "device-model", singleton: false })
@kosFutureAware() // Defaults to 'full' mode
export class DeviceModelImpl implements IKosDataModel, FutureUpdateHandler {
  // All Future properties added: progress, status, isRunning, cancelFuture, etc.
  @kosFuture()
  async performOperation(): Promise<OperationResult> {
    return this.sendCommand('/device/operation', {});
  }
}
// External interface includes Future capabilities
export type DeviceModel = PublicModelInterface<DeviceModelImpl> & ExternalFutureInterface<OperationResult>;

Minimal Mode – Internal Operations Only

Use minimal mode when you only need internal @kosFuture method support:

// Interface merging for minimal Future support
interface ServiceModelImpl extends KosFutureAwareMinimal {}
@kosModel({ modelTypeId: "service-model", singleton: false })
@kosFutureAware({ mode: 'minimal' }) // Only adds futureHandler
export class ServiceModelImpl implements IKosDataModel {
  // Only futureHandler property added for internal use
  @kosFuture()
  async backgroundTask(): Promise<TaskResult> {
    return this.sendCommand('/service/background-task', {});
  }
}
// External interface without Future properties
export type ServiceModel = PublicModelInterface<ServiceModelImpl>;

Progress Tracking and User Feedback

Futures excel at providing rich, real-time feedback about operation progress. Instead of leaving users wondering whether their device is working or stuck, Futures provide continuous updates about what’s happening and how long it might take.

Automatic Progress Updates

The Future system automatically connects to WebSocket topics that provide progress information:

// Interface merging for complete type safety
interface SystemMaintenanceModelImpl extends KosFutureAwareFull<MaintenanceResult> {}
@kosModel({ modelTypeId: "system-maintenance-model", singleton: true })
@kosFutureAware() // Adds progress, status, isRunning, cancelFuture, etc.
export class SystemMaintenanceModelImpl implements IKosDataModel, FutureUpdateHandler {
  id: string;
  currentOperation?: string;
  // All Future properties added automatically by decorator
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No Future setup needed - decorator handles everything
  }
  @kosFuture()
  async performFullMaintenance(): Promise<MaintenanceResult> {
    return this.sendCommand('/maintenance/full-cycle', {});
  }
  // Direct access to Future properties provided by decorator
  get estimatedTimeRemaining(): number | undefined {
    return this.future?.timeRemainingMs;
  }
  get currentPhaseDescription(): string {
    return this.future?.phaseDescription || "Preparing...";
  }
  // Optional: Handle Future updates in real-time
  onFutureUpdate?(future: IFutureModel<MaintenanceResult>): void {
    this.currentOperation = future.phaseDescription;
    // React components automatically re-render when this changes
  }
}
export type SystemMaintenanceModel = PublicModelInterface<SystemMaintenanceModelImpl> & ExternalFutureInterface<MaintenanceResult>;

Progress information includes not just percentage completion, but rich contextual information about what’s currently happening, estimated time remaining, and descriptions of the current operational phase.

Integration with React Components

Futures integrate seamlessly with React components to provide responsive user interfaces:

function BrewingControl() {
  const brewingSystem = useKosModel(BrewingSystemModel, 'main-brewer');
  const startBrewing = async (recipe: BrewingRecipe) => {
    try {
      const result = await brewingSystem.startBrewingCycle(recipe);
      // Operation completed successfully
      showNotification(`Brewing completed: ${result.volumeProduced}ml`);
    } catch (error) {
      // Operation failed or was cancelled
      handleBrewingError(error);
    }
  };
  // Use Future properties directly from the model (added by @kosFutureAware)
  if (brewingSystem.isRunning) {
    return (
      <BrewingProgressDisplay
        phase={brewingSystem.currentPhaseDescription}
        progress={brewingSystem.progress} // Direct property access
        timeRemaining={brewingSystem.estimatedTimeRemaining}
        status={brewingSystem.status} // "running", "completed", "cancelled", etc.
        onCancel={() => brewingSystem.cancelFuture()}
      />
    );
  }
  return (
    <BrewingRecipeSelector
      onStartBrewing={startBrewing}
      availableRecipes={brewingSystem.availableRecipes}
      isSystemReady={!brewingSystem.isRunning}
    />
  );
}

This creates interfaces where users always understand what’s happening and maintain appropriate control over long-running operations.

Smart Cancellation and Safety

Not all device operations can be safely interrupted. The Future system provides intelligent cancellation that respects operational safety requirements while giving users control when appropriate.

Context-Aware Cancellation

The backend determines when cancellation is safe and communicates this to the UI:

// Interface merging for full type safety
interface ChemicalMixerModelImpl extends KosFutureAwareFull<MixingResult> {}
@kosModel({ modelTypeId: "chemical-mixer-model", singleton: false })
@kosFutureAware() // Adds all Future properties including cancelFuture method
export class ChemicalMixerModelImpl implements IKosDataModel, FutureUpdateHandler {
  id: string;
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No Future setup needed - decorator handles everything
  }
  @kosFuture()
  async startMixingProcess(formula: ChemicalFormula): Promise<MixingResult> {
    return this.sendCommand('/mixer/start-process', { formula });
  }
  async cancelMixing(): Promise<void> {
    await this.cancelFuture(); // Method added by @kosFutureAware
  }
  // Optional: React to Future state changes
  onFutureUpdate?(future: IFutureModel<MixingResult>): void {
    console.log(`Mixing: ${future.progress * 100}% - ${future.status}`);
  }
}
export type ChemicalMixerModel = PublicModelInterface<ChemicalMixerModelImpl> & ExternalFutureInterface<MixingResult>;

Graceful Operation Termination

When cancellation is requested, the Future system ensures proper cleanup:

// User interface for cancellable operations
function MixingOperationControl() {
  const mixer = useKosModel(ChemicalMixerModel, 'main-mixer');
  const handleCancellation = async () => {
    const confirmed = await showConfirmationDialog(
      "Cancel mixing operation?",
      "The system will complete the current step safely before stopping."
    );
    if (confirmed) {
      try {
        await mixer.cancelMixing();
        showNotification("Operation cancelled safely");
      } catch (error) {
        showError("Cancellation failed: " + error.message);
      }
    }
  };
  return (
    <OperationControls>
      <ProgressDisplay
        progress={mixer.progress} // Direct access via @kosFutureAware
        status={mixer.status}
        isRunning={mixer.isRunning}
      />
      {mixer.isRunning && (
        <CancelButton onClick={handleCancellation}>
          Cancel Operation
        </CancelButton>
      )}
    </OperationControls>
  );
}

This creates user experiences where cancellation feels predictable and safe.

Complex Multi-Step Operations

One of the most powerful aspects of Futures is their ability to present complex, multi-system operations as simple, unified experiences. Behind the scenes, the backend might orchestrate dozens of steps across multiple device components, but users see coherent progress toward a single goal.

Backend Orchestration, Simple UI

Consider a complete system initialization sequence that involves:

Hardware diagnostics across multiple subsystems, service startup and configuration loading, sensor calibration and validation, inter-component communication testing, safety system verification, and final operational readiness confirmation.

From the user’s perspective, this complexity appears as a single, well-managed operation:

// Interface merging for full type safety
interface SystemStartupModelImpl extends KosFutureAwareFull<StartupResult> {}
@kosModel({ modelTypeId: "system-startup-model", singleton: true })
@kosFutureAware() // Adds all Future properties automatically
export class SystemStartupModelImpl implements IKosDataModel, FutureUpdateHandler {
  id: string;
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No Future setup needed - decorator handles everything
  }
  @kosFuture()
  async initializeSystem(): Promise<StartupResult> {
    // Single call triggers entire orchestrated startup sequence
    return this.sendCommand('/system/startup/full-initialization', {});
  }
  get startupPhase(): string {
    return this.future?.currentPhase || "Preparing";
  }
  get startupStepDescription(): string {
    return this.future?.stepDescription || "System initialization starting...";
  }
  get overallProgress(): number {
    return this.progress; // Direct property from @kosFutureAware
  }
  // Optional: Handle startup progress updates
  onFutureUpdate?(future: IFutureModel<StartupResult>): void {
    console.log(`Startup: ${future.currentPhase} - ${future.progress * 100}%`);
    // UI automatically updates when these properties change
  }
}
export type SystemStartupModel = PublicModelInterface<SystemStartupModelImpl> & ExternalFutureInterface<StartupResult>;

The backend handles all the complexity of coordinating multiple systems, determining the correct sequence of operations, handling inter-step dependencies, and recovering from temporary issues. The UI receives a clean stream of progress information that creates a coherent user experience.

Error Handling in Complex Operations

When complex operations encounter problems, Futures provide structured error information that helps users understand what happened and what options they have:

// Interface merging for full type safety
interface SystemDiagnosticsModelImpl extends KosFutureAwareFull<DiagnosticsResult> {}
@kosModel({ modelTypeId: "system-diagnostics-model", singleton: true })
@kosFutureAware() // Adds all Future properties and error handling
export class SystemDiagnosticsModelImpl implements IKosDataModel, FutureUpdateHandler {
  id: string;
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No Future setup needed - decorator handles everything
  }
  @kosFuture()
  async runComprehensiveDiagnostics(): Promise<DiagnosticsResult> {
    return this.sendCommand('/diagnostics/comprehensive-test', {});
  }
  // Optional: Handle Future updates and errors
  onFutureUpdate?(future: IFutureModel<DiagnosticsResult>): void {
    if (future.error) {
      this.handleDiagnosticsError(future.error as DiagnosticsError);
    } else {
      console.log(`Diagnostics: ${future.progress * 100}% complete`);
    }
  }
  handleDiagnosticsError(error: DiagnosticsError): void {
    switch (error.category) {
      case 'hardware-fault':
        // Hardware issue requires maintenance attention
        this.showMaintenanceAlert(error.details);
        break;
      case 'communication-timeout':
        // Network or communication issue, might be temporary
        this.suggestRetryOperation();
        break;
      case 'calibration-drift':
        // Sensors need recalibration, can be scheduled
        this.scheduleCalibrationMaintenance(error.affectedSensors);
        break;
      case 'software-conflict':
        // Configuration or software issue
        this.showConfigurationGuidance(error.conflictDetails);
        break;
      default:
        // Unexpected error
        this.showGenericErrorDialog(error.message);
    }
  }
}
export type SystemDiagnosticsModel = PublicModelInterface<SystemDiagnosticsModelImpl> & ExternalFutureInterface<DiagnosticsResult>;

This structured approach helps users understand not just that something went wrong, but what category of problem occurred and what their options are for resolution.

Future Patterns for Different Operation Types

Quick Operations with Rich Feedback

Some operations complete relatively quickly but still benefit from progress tracking:

// Interface merging for full type safety
interface BeverageDispenserModelImpl extends KosFutureAwareFull<DispenseResult> {}
@kosModel({ modelTypeId: "beverage-dispenser-model", singleton: false })
@kosFutureAware() // Adds all Future properties
export class BeverageDispenserModelImpl implements IKosDataModel, FutureUpdateHandler {
  id: string;
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No Future setup needed - decorator handles everything
  }
  @kosFuture()
  async dispenseBeverage(selection: BeverageSelection): Promise<DispenseResult> {
    // 30-60 second operation with multiple phases
    return this.sendCommand('/dispenser/dispense', { selection });
  }
  get dispensePhase(): string {
    // Phases might be: "Preparing", "Heating", "Mixing", "Dispensing", "Finishing"
    return this.future?.currentPhase || "Ready";
  }
  // Optional: Handle dispense progress
  onFutureUpdate?(future: IFutureModel<DispenseResult>): void {
    console.log(`Dispensing: ${future.currentPhase} - ${future.progress * 100}%`);
  }
}
export type BeverageDispenserModel = PublicModelInterface<BeverageDispenserModelImpl> & ExternalFutureInterface<DispenseResult>;

Even relatively quick operations benefit from progress feedback that helps users understand what’s happening and builds confidence in system reliability.

Extended Maintenance Operations

Long-running maintenance operations require rich progress information and careful cancellation handling:

// Interface merging for full type safety  
interface MaintenanceControllerModelImpl extends KosFutureAwareFull<CleaningResult | CalibrationResult> {}
@kosModel({ modelTypeId: "maintenance-controller-model", singleton: true })
@kosFutureAware() // Adds all Future properties
export class MaintenanceControllerModelImpl implements IKosDataModel, FutureUpdateHandler {
  id: string;
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No Future setup needed - decorator handles everything
  }
  @kosFuture()
  async executeDeepCleaningCycle(): Promise<CleaningResult> {
    // 45+ minute operation with multiple chemical stages
    return this.sendCommand('/maintenance/deep-clean', {});
  }
  @kosFuture()
  async performSystemCalibration(): Promise<CalibrationResult> {
    // 15+ minute operation affecting multiple subsystems
    return this.sendCommand('/calibration/full-system', {});
  }
  get maintenanceTimeRemaining(): string {
    if (!this.future?.timeRemainingMs) return "Calculating...";
    const minutes = Math.ceil(this.future.timeRemainingMs / 60000);
    return `${minutes} minutes remaining`;
  }
  // Optional: Handle maintenance progress
  onFutureUpdate?(future: IFutureModel<CleaningResult | CalibrationResult>): void {
    console.log(`Maintenance: ${future.currentPhase} - ${this.maintenanceTimeRemaining}`);
  }
}
export type MaintenanceControllerModel = PublicModelInterface<MaintenanceControllerModelImpl> & ExternalFutureInterface<CleaningResult | CalibrationResult>;

Extended operations require more sophisticated progress communication and user control options.

Building Responsive Device Interfaces

Futures enable device control interfaces that feel professional and trustworthy by providing appropriate feedback and control for physical operations that take time. Instead of leaving users wondering whether systems are working correctly, Futures create clear communication channels between complex device operations and user understanding.

This transforms device control applications from tools that occasionally check on hardware status into responsive dashboards that maintain continuous awareness of ongoing operations. Users develop trust in systems that communicate clearly about what they’re doing, how long it will take, and what options are available.

The Future system makes long-running device operations feel manageable and predictable, creating user experiences that match the reliability and professionalism that physical device control demands.

Managing Multiple Concurrent Futures with @kosMultipleFutureAware

For models that need to manage multiple concurrent Future operations simultaneously, KOS provides the @kosMultipleFutureAware decorator. This is particularly useful for devices that can perform multiple operations in parallel, such as ice dispensers that can pour and agitate simultaneously, or complex systems with independent subsystems.

When to Use Multiple Futures

Use @kosMultipleFutureAware when your model needs:

• Concurrent Operations: Multiple long-running operations that can execute simultaneously
• Named Future Access: Type-safe access to specific futures (e.g., pourFuture, agitateFuture)
• Independent Cancellation: Ability to cancel specific operations without affecting others
• Separate Progress Tracking: Individual progress and status for each operation

Basic Multiple Future Setup

The @kosMultipleFutureAware decorator works similarly to @kosFutureAware but creates a MultipleFutureHandler and provides access to named futures:

// Type intersection provides access to all named future properties
type IceAgitatorModelType = KosMultipleFutureAwareFull<
  "pour" | "agitate" | "gate"
>;
// Interface merging for complete type safety
export interface IceAgitatorModelImpl extends IceAgitatorModelType {}
@kosModel({ modelTypeId: "ice-agitator-model", singleton: false })
@kosMultipleFutureAware() // Creates MultipleFutureHandler with named futures
export class IceAgitatorModelImpl implements IKosDataModel {
  id: string;
  // All Future properties automatically added:
  // - futureHandler: MultipleFutureHandler
  // - future?: IFutureModel (default future)
  // - pourFuture?: IFutureModel
  // - agitateFuture?: IFutureModel
  // - gateFuture?: IFutureModel
  // - pourProgress, agitateProgress, gateProgress: number
  // - pourStatus, agitateStatus, gateStatus: string
  // - pourIsRunning, agitateIsRunning, gateIsRunning: boolean
  // - cancelPour(), cancelAgitate(), cancelGate(): Promise<void>
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No manual setup needed - decorator handles everything
  }
  @kosFuture({ alias: "pour" })
  async pourIce(tracker?: string): Promise<void> {
    return this.sendCommand('/ice/pour', { tracker });
  }
  @kosFuture({ alias: "agitate" })
  async testAgitate(tracker?: string): Promise<void> {
    return this.sendCommand('/ice/agitate', { tracker });
  }
  @kosFuture({ alias: "gate" })
  async testGate(tracker?: string): Promise<void> {
    return this.sendCommand('/ice/gate-test', { tracker });
  }
  // Access to individual future states
  get isPouring(): boolean {
    return !!(this.pourFuture && !this.pourFuture.endState);
  }
  get isAgitating(): boolean {
    return !!(this.agitateFuture && !this.agitateFuture.endState);
  }
  // Individual operation cancellation
  async cancelIceDispense(): Promise<void> {
    if (this.pourFuture && !this.pourFuture.endState) {
      await this.cancelPour(); // Method added by decorator
    }
  }
}
export type IceAgitatorModel = PublicModelInterface<IceAgitatorModelImpl>;

Named Future Properties

The @kosMultipleFutureAware decorator automatically generates properties for each aliased future:

Future Access: Each @kosFuture({ alias: "name" }) creates a nameFuture property
Progress Tracking: Each alias gets nameProgress, nameStatus, nameIsRunning, nameIsCancelled properties
Cancellation: Each alias gets a cancelName() method for individual operation control

Multiple Future Modes

Like @kosFutureAware, the multiple future decorator supports different modes:

Full Mode (Default) – Complete UI Integration

type MyModelType = KosMultipleFutureAwareFull<"operation1" | "operation2">;
export interface MyModelImpl extends MyModelType {}
@kosModel({ modelTypeId: "my-model", singleton: false })
@kosMultipleFutureAware() // Defaults to full mode
export class MyModelImpl implements IKosDataModel {
  // All Future properties added including progress, status, cancellation
}

Minimal Mode – Internal Operations Only

export interface MyModelImpl extends KosMultipleFutureAwareMinimal {}
@kosModel({ modelTypeId: "my-model", singleton: false })
@kosMultipleFutureAware({ mode: 'minimal' }) // Only futureHandler
export class MyModelImpl implements IKosDataModel {
  // Only futureHandler and future properties, no UI-specific properties
}

Migrating to the Modern Decorator Approach

If you have existing models that use manual Future setup, migrating to the decorator approach is straightforward and provides immediate benefits:

Before: Manual Convention-Based Setup

import { FutureHandler, FutureAwareContainer } from "@kosdev-code/kos-ui-sdk";
@kosModel({ modelTypeId: "legacy-device-model", singleton: false })
export class LegacyDeviceModelImpl implements IKosDataModel {
  id: string;
  // Manual Future Container properties
  futureHandler: FutureAwareContainer;
  future?: IFutureModel;
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // Manual Future Container setup
    this.futureHandler = new FutureHandler(this);
    // Framework automatically handles makeAutoObservable
  }
  // Standard getters - framework makes these observable automatically
  get progress(): number {
    return this.future?.progress || 0;
  }
  get status(): string {
    return this.future?.status || 'idle';
  }
  get isRunning(): boolean {
    return this.future?.isRunning || false;
  }
  // Manual cancellation implementation
  async cancelFuture(): Promise<void> {
    await this.future?.cancel();
  }
  @kosFuture()
  async performOperation(): Promise<OperationResult> {
    return this.sendCommand('/device/operation', {});
  }
  // Manual Future update handling
  onFutureUpdate(future: IFutureModel): void {
    console.log(`Operation ${future.progress * 100}% complete`);
  }
}

After: Modern Decorator Approach

// Interface merging provides full type safety
interface ModernDeviceModelImpl extends KosFutureAwareFull<OperationResult> {}
@kosModel({ modelTypeId: "modern-device-model", singleton: false })
@kosFutureAware() // Replaces manual setup completely
export class ModernDeviceModelImpl implements IKosDataModel, FutureUpdateHandler {
  constructor(modelId: string, options: any, context: KosCreationContext) {
    this.id = modelId;
    // No manual setup needed!
  }
  @kosFuture()
  async performOperation(): Promise<OperationResult> {
    return this.sendCommand('/device/operation', {});
  }
  // Optional: Handle Future updates in real-time
  onFutureUpdate?(future: IFutureModel<OperationResult>): void {
    console.log(`Operation ${future.progress * 100}% complete`);
  }
}
// External interface with complete Future capabilities
export type ModernDeviceModel = PublicModelInterface<ModernDeviceModelImpl> & ExternalFutureInterface<OperationResult>;

Migration Benefits

• Zero Boilerplate: No manual Future Container setup required
• Full Type Safety: TypeScript interface merging provides complete type information
• Better DX: Clear separation between implementation and public interfaces
• Consistent Pattern: Follows the same pattern as other KOS decorators
• Future-Proof: Built for upcoming KOS framework enhancements

Ready to explore more advanced KOS capabilities? Continue with Trouble System Integration to learn how KOS handles device health monitoring and issue management, or dive into React Integration Patterns for building responsive device control interfaces.