Extend for earlier videos and new Autopilot conversations (0.4.1)

freevideo.ps1

@@ -75,6 +75,7 @@ try {
         Write-Host 'Preparing isolated Python for setup. Model/environment installation requires the setup confirmation.'
         Write-Host "Bootstrap cache and log: $bootstrapRoot"
         $bootstrapLock = [IO.File]::Open((Join-Path $bootstrapRoot 'bootstrap.lock'), 'OpenOrCreate', 'ReadWrite', 'None')
+        $patientDownloadNotice = $false
         try {
             $versions = Get-Content -LiteralPath (Join-Path $PSScriptRoot 'freevideo_engine\bootstrap_versions.json') -Raw -Encoding UTF8 | ConvertFrom-Json
             $uvSpec = $versions.windows.uv
@@ -110,6 +111,10 @@ try {
               if ($profile.Mode -eq 'patient') {
                 if (-not $allNetworkFailures) { break }
                 Write-Host 'The network is slow. Downloading again; this may take a while.'
+                $patientDownloadNotice = $true
+                if ($env:FREEVIDEO_UI_EVENTS -eq '1') {
+                    Write-Host '{"event":"freevideo_ui","kind":"progress","key":"download-patient-python","label":"Download","detail":"The network is slow. Downloading again; this may take a while."}'
+                }
               }
               foreach ($name in @('UV_HTTP_TIMEOUT', 'UV_HTTP_RETRIES')) {
                 $value = $freevideoSavedEnvironment[$name]
@@ -139,6 +144,9 @@ try {
             $freevideoPython = (& $uv python find --managed-python $versions.python | Select-Object -Last 1).Trim()
             if ($LASTEXITCODE -ne 0 -or -not (Test-Path -LiteralPath $freevideoPython)) { throw 'Managed Python could not be located.' }
         } finally {
+            if ($patientDownloadNotice -and $env:FREEVIDEO_UI_EVENTS -eq '1') {
+                Write-Host '{"event":"freevideo_ui","kind":"progress","key":"download-patient-python","label":"Download","detail":"","state":"complete"}'
+            }
             $bootstrapLock.Dispose()
             Write-Progress -Activity 'FreeVideo bootstrap' -Completed
         }

freevideo_engine/adaln_reclaim.py

@@ -39,7 +39,7 @@
 
 from . import adaln_assets as assets
 from .long_paths import io_path
-from .variant_cleanup import inside, redirected
+from .variant_cleanup import SIDECAR, SIDECAR_LIMIT, inside, redirected
 
 RECEIPT = 'adaln-reclaim.json'
 OFFER = 'adaln-reclaim-offer.json'
@@ -286,6 +286,18 @@ def verify_sources(cache, manifest, should_stop=lambda: False):
     return None
 
 
+def _remove_sidecars(cache, listed):
+    """The small records an earlier download left beside a source (<file>.partial.source.json), so the folder can go."""
+    for _, path in listed:
+        sidecar = path.with_name(path.name + SIDECAR)
+        info = _regular(sidecar)
+        if info is not None and info.st_size <= SIDECAR_LIMIT and _contained(cache, sidecar):
+            try:
+                io_path(sidecar).unlink()
+            except OSError:
+                pass
+
+
 def _remove_tables(cache, folders):
     removed = 0
     for folder, _ in folders:
@@ -373,6 +385,7 @@ def reclaim(cache, *, should_stop=lambda: False, schedules=None, lock=None, ask=
                         return kept('redirected')
                     freed += info.st_size
                     io_path(path).unlink()
+                _remove_sidecars(cache, listed)
                 try:
                     (io_path(cache) / SOURCES).rmdir()
                 except OSError:
@@ -423,11 +436,25 @@ def apply(machine, *, should_stop=lambda: False, schedules=None):
     return result
 
 
+def _installed_engine_schedules(machine):
+    """engine_schedules for a process that has not put the engine's dependencies on its path (the background check)."""
+    ready = []
+    def answer(steps):
+        if not ready:
+            from . import paths
+            vdn = Path(machine['root']) / 'vendor' / 'vdn' if machine.get('root') else None
+            paths.add_vdn(vdn if vdn is not None and (vdn / 'src/models/hybrid_attention.py').is_file() else None)
+            ready.append(True)
+        return engine_schedules(steps)
+    return answer
+
+
 def run(machine, *, should_stop=lambda: False):
     """Entry point of the background precompile: check and leave the offer, report one event, never raise."""
     started = time.time()
     try:
-        result = reclaim(machine['cache'], should_stop=should_stop, ask=True, release=installed_release())
+        result = reclaim(machine['cache'], should_stop=should_stop, ask=True, release=installed_release(),
+                         schedules=_installed_engine_schedules(machine))
     except Exception as error:  # Best effort: the installation works either way.
         result = dict(action='kept', reason='error:' + type(error).__name__, bytes=0, tables_bytes=0)
     if result['action'] == 'kept' and result['reason'] not in ('declined', 'stopped', 'busy') \

freevideo_engine/agent/editor_runtime.py

@@ -137,6 +137,7 @@
             case 'move': record = actions.moveParts(record, op.clip_ids, {frames: op.frames, track: null}); break;
             case 'describe': record = model.describe(record, actions.linkedIds(record, op.clip_ids), op.text, by); break;
             case 'set_ref': record = model.setRef(record, actions.linkedIds(record, op.clip_ids), op.ref); break;
+            case 'note': record = model.setNote(record, actions.linkedIds(record, op.clip_ids), op.text); break;
             case 'use_version': record = model.restoreVersion(record, op.clip_id, op.index, by); break;
             // One undo on the page; rejects as subtitles / range / text / locked / overlap.
             case 'subtitles': record = texts.addSubtitles(record, op.cues, {replace: op.replace === true}); break;

freevideo_engine/agent/errors.py

@@ -55,7 +55,7 @@
     'internal_error': (500, True, 'An internal error prevented this operation from completing.', 'Read the job list and report request_id if the error persists.'),
     'local_only': (403, False, 'This endpoint does not allow requests from this peer address.', 'Run the client on the FreeVideo computer and connect using its loopback address.'),
     'origin_forbidden': (403, False, 'Origin must match this FreeVideo instance; a different origin was received.', 'Open the page served by this FreeVideo instance, or use a local command-line client without Origin.'),
-    'continuation_unavailable': (409, False, 'This backend cannot continue video blocks.', 'Use an independent shot with seconds<=15, or enable a backend with continuation inputs and resume.'),
+    'continuation_unavailable': (409, False, 'This backend cannot continue video blocks.', 'Use POST /plan for a supported single block (unknown limit: seconds<=15), or enable continuation and resume.'),
     'not_resumable': (409, False, 'Only failed, interrupted or cancelled generation jobs can resume.', 'Read the job; wait for active jobs or submit a new job for a different request.'),
     'idempotency_conflict': (409, False, 'This idempotency key was already used for different request content.', 'Resend the original content with this key, or use a new ref for the changed request.'),
     'source_missing': (409, False, 'A completed source block is no longer available.', 'Restore the completed block before resuming, or submit a new job.'),

freevideo_engine/agent/forecast.py

@@ -1,5 +1,6 @@
 """Machine-local timing forecasts shared by planning and durable films."""
 import math
+from .length import capability_table, single_frame_limit
 
 
 def generation_estimate(port, spec, chain=None):
@@ -9,9 +10,9 @@ def generation_estimate(port, spec, chain=None):
     reasons here so a film never invents a time for unsupported conditioning.
     """
     from ..chain_plan import plan as chain_plan
-    chain = chain if chain is not None else chain_plan(spec['seconds'], continued=bool(spec.get('continue_from')))
-    table = port.capability_snapshot(dict(width=str(spec['width']), height=str(spec['height']),
-                                          task=spec['task'], adapters='1' if spec['loras'] else '0'))
+    table = capability_table(port, spec)
+    chain = chain if chain is not None else chain_plan(spec['seconds'], max_frames=single_frame_limit(spec, table=table),
+                                                     continued=bool(spec.get('continue_from')))
     seconds = None
     reason = table['status'] if table['status'] in ('computing', 'unavailable') else 'no_matching_estimate'
     if table['status'] == 'ready' and not spec['preview'] and not spec['media']: