Skip to main content

TttHandler

Trait TttHandler 

Source
pub trait TttHandler {
    // Required methods
    fn handle_init<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
        data: &'life3 LoraConfig,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn handle_train<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
        data: &'life3 TrainStepRequest,
    ) -> Pin<Box<dyn Future<Output = Result<TrainStepResult>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn handle_train_stream<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
        data: &'life3 TrainStepRequest,
    ) -> Pin<Box<dyn Future<Output = Result<(StreamInfo, Continuation)>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn handle_writeback<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn handle_evict<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn handle_zero<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn handle_status<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<DeltaStatusResult>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn handle_save<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
        data: &'life3 SaveAdaptationRequest,
    ) -> Pin<Box<dyn Future<Output = Result<SaveAdaptationResult>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn handle_snapshot<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotDeltaResult>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn handle_export<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
        data: &'life3 ExportPeftRequest,
    ) -> Pin<Box<dyn Future<Output = Result<ExportPeftResult>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn handle_write_ttt_config<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 EnvelopeContext,
        request_id: u64,
        model_ref: &'life2 str,
        data: &'life3 WriteTttConfigRequest,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
}
Expand description

Generated handler trait for the ttt scope.

Required Methods§

Source

fn handle_init<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, data: &'life3 LoraConfig, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Initialize the training infrastructure (LoRA parameters, optimizer, delta pool) on a loaded model. Required before ttt.train or TTT-enabled inference. Configure rank, alpha, target modules, and learning rate.

Source

fn handle_train<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, data: &'life3 TrainStepRequest, ) -> Pin<Box<dyn Future<Output = Result<TrainStepResult>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Run TTT gradient steps on input text WITHOUT generating a response. Pure training — use for pre-training on domain text before asking questions. Returns loss metrics and recommendation. Use adaptationStrategy=speculative to keep pending, then call ttt.writeback or ttt.evict.

Source

fn handle_train_stream<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, data: &'life3 TrainStepRequest, ) -> Pin<Box<dyn Future<Output = Result<(StreamInfo, Continuation)>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Stream TTT training on input text. Returns progress and results via streaming. Use for long-running training that would timeout via ttt.train.

Source

fn handle_writeback<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Write back a pending TTT adaptation to the tenant delta accumulator. Call after reviewing onlineTrainingMetrics.recommendation from infer.generateStream. Must be called within the pending rollback window (default 60 seconds, configurable via pending_rollback_ms). If the window expires, the adaptation is auto-evicted and this call will return an error.

Source

fn handle_evict<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Evict (discard) a pending TTT adaptation, restoring the tenant delta accumulator to its pre-adaptation state. Call within the pending rollback window (default 60 seconds, configurable via pending_rollback_ms) if recommendation was false or output quality was poor. If multiple adaptations were stacked, evict restores to the state before the earliest pending adaptation.

Source

fn handle_zero<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Zero the tenant delta accumulator, clearing all accumulated training. Use after ttt.save or ttt.export to free capacity.

Source

fn handle_status<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<DeltaStatusResult>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get tenant delta accumulator metrics: step count, loss improvement, drift. Use to decide if adaptations should be persisted via ttt.save or ttt.export.

Source

fn handle_save<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, data: &'life3 SaveAdaptationRequest, ) -> Pin<Box<dyn Future<Output = Result<SaveAdaptationResult>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Merge the tenant delta accumulator into an on-disk adapter file using a configurable merge strategy (replace/additive/do_merge). For incremental refinement of existing adapters. Call ttt.status first to verify quality. The result is committed to the model’s git repository.

Source

fn handle_snapshot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<SnapshotDeltaResult>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Snapshot the tenant delta accumulator to content-addressed storage without merging into an adapter file.

Source

fn handle_export<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, data: &'life3 ExportPeftRequest, ) -> Pin<Box<dyn Future<Output = Result<ExportPeftResult>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Export the tenant delta accumulator as a standalone PEFT-compatible adapter directory (adapter_config.json + adapter_model.safetensors). For interop with HuggingFace and external tools. The exported adapter can be reloaded via adapter.load.

Source

fn handle_write_ttt_config<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, model_ref: &'life2 str, data: &'life3 WriteTttConfigRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Write hyprstream_training configuration to the model worktree’s config.json and optionally reload. Required before ttt.train or TTT-enabled inference. Sets training mode to test_time_training and configures LoRA rank/alpha, target modules, and learning rate.

Implementors§