diffusers-workflow 0.4.0b6__tar.gz → 0.4.0b7__tar.gz

{diffusers_workflow-0.4.0b6/diffusers_workflow.egg-info → diffusers_workflow-0.4.0b7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffusers-workflow
-Version: 0.4.0b6
+Version: 0.4.0b7
 Summary: Declarative workflow engine and web UI for Hugging Face Diffusers
 Author: dkackman
 License: Apache-2.0
@@ -47,6 +47,7 @@ Requires-Dist: imageio-ffmpeg>=0.6.0
 Requires-Dist: av>=18.1.0
 Requires-Dist: soundfile>=0.14.0
 Requires-Dist: matplotlib>=3.11.1
+Requires-Dist: speechbrain>=1.0.3
 Requires-Dist: qrcode>=8.2
 Requires-Dist: requests>=2.34.2
 Requires-Dist: aiohttp>=3.14.3
@@ -159,7 +160,7 @@ once; without it the run fails partway through with a 401/403 from the Hub.
 
 ## Drive it from an agent
 
-Then just ask. The agent has 55 tools covering the whole surface — the
+Then just ask. The agent has 58 tools covering the whole surface — the
 workflow catalog, the real diffusers pipeline signatures, the job queue, the
 gallery, the model cache:
 

{diffusers_workflow-0.4.0b6 → diffusers_workflow-0.4.0b7}/README.md

@@ -83,7 +83,7 @@ once; without it the run fails partway through with a 401/403 from the Hub.
 
 ## Drive it from an agent
 
-Then just ask. The agent has 55 tools covering the whole surface — the
+Then just ask. The agent has 58 tools covering the whole surface — the
 workflow catalog, the real diffusers pipeline signatures, the job queue, the
 gallery, the model cache:
 

{diffusers_workflow-0.4.0b6 → diffusers_workflow-0.4.0b7/diffusers_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffusers-workflow
-Version: 0.4.0b6
+Version: 0.4.0b7
 Summary: Declarative workflow engine and web UI for Hugging Face Diffusers
 Author: dkackman
 License: Apache-2.0
@@ -47,6 +47,7 @@ Requires-Dist: imageio-ffmpeg>=0.6.0
 Requires-Dist: av>=18.1.0
 Requires-Dist: soundfile>=0.14.0
 Requires-Dist: matplotlib>=3.11.1
+Requires-Dist: speechbrain>=1.0.3
 Requires-Dist: qrcode>=8.2
 Requires-Dist: requests>=2.34.2
 Requires-Dist: aiohttp>=3.14.3
@@ -159,7 +160,7 @@ once; without it the run fails partway through with a 401/403 from the Hub.
 
 ## Drive it from an agent
 
-Then just ask. The agent has 55 tools covering the whole surface — the
+Then just ask. The agent has 58 tools covering the whole surface — the
 workflow catalog, the real diffusers pipeline signatures, the job queue, the
 gallery, the model cache:
 

{diffusers_workflow-0.4.0b6 → diffusers_workflow-0.4.0b7}/diffusers_workflow.egg-info/SOURCES.txt

@@ -19,11 +19,14 @@ dw/elision.py
 dw/events.py
 dw/for_each.py
 dw/host_memory.py
+dw/host_memory_projection.py
 dw/hub_cache.py
 dw/introspection.py
 dw/kernel_availability.py
 dw/locations.py
 dw/log_setup.py
+dw/media_audio.py
+dw/media_frames.py
 dw/media_info.py
 dw/plan.py
 dw/previous_results.py
@@ -39,8 +42,10 @@ dw/repl_worker.py
 dw/result.py
 dw/run.py
 dw/runs.py
+dw/scalar_result_validation.py
 dw/schema.py
 dw/security.py
+dw/select_validation.py
 dw/serve.py
 dw/settings.py
 dw/step.py
@@ -54,6 +59,7 @@ dw/type_helpers.py
 dw/validate.py
 dw/variable_constraints.py
 dw/variables.py
+dw/vram_estimate.py
 dw/worker.py
 dw/workflow.py
 dw/workflow_schema.json
@@ -94,6 +100,7 @@ dw/server/jobs.py
 dw/server/mcp_mount.py
 dw/server/netinfo.py
 dw/server/observed_cost.py
+dw/server/sysinfo.py
 dw/server/updater.py
 dw/server/ui/index.html
 dw/server/ui/assets/abap-08VXUWAP.js
@@ -110,45 +117,45 @@ dw/server/ui/assets/csharp-BKxtCVv1.js
 dw/server/ui/assets/csp-bTuwJoIa.js
 dw/server/ui/assets/css-DIMkf-bt.js
 dw/server/ui/assets/css.worker-B3ciXF_0.js
-dw/server/ui/assets/cssMode-1t4O7A8b.js
+dw/server/ui/assets/cssMode-xQCqMuag.js
 dw/server/ui/assets/cypher-CVaqCwHa.js
 dw/server/ui/assets/dart-onAF5SnQ.js
 dw/server/ui/assets/dockerfile-DZFCIeNp.js
 dw/server/ui/assets/ecl-D05T4iGw.js
 dw/server/ui/assets/editor-jjEx9u7D.css
-dw/server/ui/assets/editor.api-C2mqCHa9.js
+dw/server/ui/assets/editor.api-Bfiq9hmW.js
 dw/server/ui/assets/editor.worker-q-txB4vs.js
 dw/server/ui/assets/elixir-6RTg0lbw.js
 dw/server/ui/assets/flow9-C5_-GSwl.js
-dw/server/ui/assets/freemarker2-Cb6RGT42.js
+dw/server/ui/assets/freemarker2-BwDnlSuz.js
 dw/server/ui/assets/fsharp-C8Ef5oNN.js
 dw/server/ui/assets/go-C-y9NEjX.js
 dw/server/ui/assets/graphql-fmXr3nnJ.js
-dw/server/ui/assets/handlebars-LzK4_SEF.js
+dw/server/ui/assets/handlebars-Beb1we4G.js
 dw/server/ui/assets/hcl-CpzslTdj.js
-dw/server/ui/assets/html-Biz_qd50.js
+dw/server/ui/assets/html-Yw-qdTCH.js
 dw/server/ui/assets/html.worker-C93Ht9o9.js
-dw/server/ui/assets/htmlMode-CP4Kjl0x.js
-dw/server/ui/assets/index-Bt8BlCkf.js
-dw/server/ui/assets/index-D9tEUhx5.css
+dw/server/ui/assets/htmlMode-Dbp7eBPO.js
+dw/server/ui/assets/index-CsXMC8a8.css
+dw/server/ui/assets/index-DqbiZNFq.js
 dw/server/ui/assets/ini-sBoK_t0W.js
 dw/server/ui/assets/java-BEtHBSE6.js
-dw/server/ui/assets/javascript-DX4-t0BE.js
+dw/server/ui/assets/javascript-BNzP7yQZ.js
 dw/server/ui/assets/json.worker-B2V3pomh.js
-dw/server/ui/assets/jsonMode-hZa_qOEa.js
+dw/server/ui/assets/jsonMode-DxIEESAg.js
 dw/server/ui/assets/julia-Bri6UV-V.js
 dw/server/ui/assets/kotlin-BOotOW0E.js
 dw/server/ui/assets/less-B9JPFI3C.js
 dw/server/ui/assets/lexon-CfSJPG6W.js
-dw/server/ui/assets/liquid-BRkTuJ_A.js
-dw/server/ui/assets/lspLanguageFeatures-Dvt5tod9.js
+dw/server/ui/assets/liquid-CeQTai1N.js
+dw/server/ui/assets/lspLanguageFeatures-DKVB_UCB.js
 dw/server/ui/assets/lua-CsQS60Ue.js
 dw/server/ui/assets/m3-D-oSqn_W.js
 dw/server/ui/assets/markdown-Cimd5fb3.js
-dw/server/ui/assets/mdx-Bdet7qev.js
+dw/server/ui/assets/mdx-Bczl_PHr.js
 dw/server/ui/assets/mips-CIPQ_RoX.js
 dw/server/ui/assets/monaco--ixms01u.css
-dw/server/ui/assets/monaco-QRyCMGAv.js
+dw/server/ui/assets/monaco-Bu2OB6wI.js
 dw/server/ui/assets/msdax-DauUninz.js
 dw/server/ui/assets/mysql-SOo6toE5.js
 dw/server/ui/assets/objective-c-FvmIjYaQ.js
@@ -163,10 +170,10 @@ dw/server/ui/assets/powerquery-D3hlyOfw.js
 dw/server/ui/assets/powershell-DmHpPYUd.js
 dw/server/ui/assets/protobuf-C531GsRP.js
 dw/server/ui/assets/pug-Z5eAx3Zn.js
-dw/server/ui/assets/python-DO0uJyUr.js
+dw/server/ui/assets/python-CeTsj82v.js
 dw/server/ui/assets/qsharp-DkqhCAOL.js
 dw/server/ui/assets/r-BwWrilGY.js
-dw/server/ui/assets/razor-CkfVe6oz.js
+dw/server/ui/assets/razor-CN7JaWqc.js
 dw/server/ui/assets/redis-ClamHrr6.js
 dw/server/ui/assets/redshift-DT7zqm-g.js
 dw/server/ui/assets/restructuredtext-BYgofb2h.js
@@ -186,15 +193,16 @@ dw/server/ui/assets/swift-Bxkupp3x.js
 dw/server/ui/assets/systemverilog-Bz4Y3fRF.js
 dw/server/ui/assets/tcl-DISqw1ZD.js
 dw/server/ui/assets/ts.worker-D7T1-Ig5.js
-dw/server/ui/assets/tsMode-z26QXNyE.js
+dw/server/ui/assets/tsMode-CoSEMx-L.js
 dw/server/ui/assets/twig-De2hgUGE.js
-dw/server/ui/assets/typescript-DIdNc_uc.js
+dw/server/ui/assets/typescript-CcsolRTO.js
 dw/server/ui/assets/typespec-B8J7ngcE.js
 dw/server/ui/assets/vb-DV3o63ZY.js
 dw/server/ui/assets/wgsl-DpFanUEy.js
-dw/server/ui/assets/workers-Ce8CDVu5.js
-dw/server/ui/assets/xml-Djj2U0Rl.js
-dw/server/ui/assets/yaml-CePLO71e.js
+dw/server/ui/assets/workers-DLaycdy4.js
+dw/server/ui/assets/xml-QEwuyn1w.js
+dw/server/ui/assets/yaml-BB4U5D-R.js
+dw/tasks/audio_transcription.py
 dw/tasks/audio_utils.py
 dw/tasks/background_remover.py
 dw/tasks/borders.py
@@ -208,12 +216,14 @@ dw/tasks/gather.py
 dw/tasks/image_to_text.py
 dw/tasks/image_utils.py
 dw/tasks/interpolate_frames.py
+dw/tasks/judge.py
 dw/tasks/model_cache.py
 dw/tasks/pair_audio.py
 dw/tasks/qr_code.py
 dw/tasks/restore_faces.py
 dw/tasks/rife_model.py
 dw/tasks/segment.py
+dw/tasks/select.py
 dw/tasks/speech_generation.py
 dw/tasks/stabilize.py
 dw/tasks/task.py
@@ -243,6 +253,7 @@ tests/test_argument_updates.py
 tests/test_arguments.py
 tests/test_assets.py
 tests/test_audio_utils.py
+tests/test_best_of_n_template.py
 tests/test_borders.py
 tests/test_cache_blocks.py
 tests/test_catalog_shape.py
@@ -273,16 +284,19 @@ tests/test_h3_context_ir.py
 tests/test_h3_schedule.py
 tests/test_hf_placement.py
 tests/test_host_memory.py
+tests/test_host_memory_projection.py
 tests/test_hub_cache.py
 tests/test_image_to_text.py
 tests/test_image_utils.py
 tests/test_integration.py
 tests/test_interpolate_frames.py
 tests/test_introspection.py
+tests/test_job_history_wal.py
 tests/test_job_progress.py
 tests/test_job_warnings.py
 tests/test_jobs_listing.py
 tests/test_jobs_reused.py
+tests/test_judge.py
 tests/test_kernel_availability.py
 tests/test_library_sources.py
 tests/test_list_images.py
@@ -304,6 +318,8 @@ tests/test_mcp_models.py
 tests/test_mcp_prompts.py
 tests/test_mcp_server.py
 tests/test_mcp_workspaces.py
+tests/test_media_audio.py
+tests/test_media_frames.py
 tests/test_media_info.py
 tests/test_mix_audio.py
 tests/test_model_cache.py
@@ -320,6 +336,7 @@ tests/test_pipeline_components.py
 tests/test_plan.py
 tests/test_plugin_skills.py
 tests/test_previous_results.py
+tests/test_prompt_library.py
 tests/test_prompt_parser.py
 tests/test_prompt_references.py
 tests/test_prompt_weighting.py
@@ -338,10 +355,13 @@ tests/test_resize_bucket.py
 tests/test_result.py
 tests/test_result_output_naming.py
 tests/test_runs.py
+tests/test_scalar_result_validation.py
 tests/test_scheduler_config.py
 tests/test_schema.py
 tests/test_security.py
 tests/test_segment.py
+tests/test_select.py
+tests/test_select_validation.py
 tests/test_serve_main.py
 tests/test_server.py
 tests/test_server_downloads.py
@@ -366,6 +386,7 @@ tests/test_template_subfolders.py
 tests/test_tensor_image.py
 tests/test_text_generation.py
 tests/test_text_sections.py
+tests/test_transcribe_audio.py
 tests/test_type_helpers.py
 tests/test_updater.py
 tests/test_validate_arguments.py

{diffusers_workflow-0.4.0b6 → diffusers_workflow-0.4.0b7}/diffusers_workflow.egg-info/requires.txt

@@ -28,6 +28,7 @@ imageio-ffmpeg>=0.6.0
 av>=18.1.0
 soundfile>=0.14.0
 matplotlib>=3.11.1
+speechbrain>=1.0.3
 qrcode>=8.2
 requests>=2.34.2
 aiohttp>=3.14.3

{diffusers_workflow-0.4.0b6 → diffusers_workflow-0.4.0b7}/dw/arguments.py

@@ -116,7 +116,7 @@ def realize_args(arg, base_dir=None):
             # library, and does it first: what it stands for is a path, so
             # everything below - the media conventions, an object's
             # 'from_file' - then handles it as the path it always was
-            if is_path_reference(v) or isinstance(v, list):
+            if is_path_reference(v) or isinstance(v, (list, dict)):
                 v = arg[k] = resolve_path_references(v, base_dir)
             # A constant resolves under any argument name, and before the
             # conventions below - what it holds is the value, not a file to load
@@ -212,7 +212,12 @@ def resolve_path_references(value, base_dir=None):
     A list is walked in place, because an 'image' argument may be a list of
     references and the key conventions hand the whole list to the loader at
     once - by then it is too late for a reference to be recognized.
-    Dictionaries are left alone: realize_args recurses into those itself,
+    A {"location": ...} dict is walked the same way, for the same reason: the
+    media conventions hand the whole dict to the loader, which reads the
+    location out of it and joins it onto the workflow directory - so
+    {"location": "asset:x.png"} passed validation (which sees every string)
+    and then failed the run on a path that was never resolved. Other
+    dictionaries are left alone: realize_args recurses into those itself,
     and each of their values reaches this on the way through.
     """
     if is_asset_reference(value):
@@ -222,6 +227,8 @@ def resolve_path_references(value, base_dir=None):
     if isinstance(value, list):
         for index, item in enumerate(value):
             value[index] = resolve_path_references(item, base_dir)
+    elif isinstance(value, dict) and is_path_reference(value.get("location")):
+        value["location"] = resolve_path_references(value["location"], base_dir)
     return value
 
 

{diffusers_workflow-0.4.0b6 → diffusers_workflow-0.4.0b7}/dw/docs/MCP.md

@@ -187,7 +187,7 @@ Nothing in this sequence costs GPU time.
 
 ## Tool reference
 
-55 tools in six groups. Names and arguments below are transcribed from
+58 tools in six groups. Names and arguments below are transcribed from
 `dw_mcp/server.py` — nothing here is renamed or reshaped for the docs.
 
 ### Catalog (read-only)
@@ -223,8 +223,8 @@ when no single workflow covers it.
 | `get_task(command)` | `command` | Get a task command's argument schema |
 | `list_models()` | — | List what the Hugging Face model cache holds, largest first |
 | `get_memory()` | — | Get the worker's VRAM and RAM statistics. `gpu_*` is the card; `host_memory_rss_mb` / `host_memory_peak_rss_mb` are the worker process's resident and high-water host memory, beside the machine's `host_memory_total_mb` / `host_memory_available_mb` - read both, since an offloading workflow keeps its weights in host RAM and the card says little about what it holds (a host field is absent, not null, where the platform cannot measure it). `host_pinned_reserved_mb` / `host_pinned_allocated_mb`, when present, are torch's pinned-host cache - the staging buffers group offloading moves weights through, part of `host_memory_rss_mb` and invisible in every `gpu_*` figure, which is what a worker holding GB after releasing every model is usually holding (#98). `live: true` means `info` was measured now and is the worker's own memory; only live readings are comparable with each other. `live: false` with `info: null` (and `stale: false`) means nothing has been measured because nothing is resident; `live: false` with a populated `info` is a cached earlier reading, with `reason` (`job_running`, `worker_stopped`, `worker_busy`, `worker_unreachable`) and `age_seconds` - one cached while a job loads a model understates what is resident, so ask again when the server is idle rather than comparing it with a live figure |
-| `get_health()` | — | Check that the server is alive, and which machine answered: `version`, `device`, whether the worker process is up, the job running now and the queue depth |
-| `get_server_info()` | — | What this installation can do and where it keeps things: `device` (the accelerator a run will use), `version`, the `workspace` this session is working in and the workflow/asset/output/prompt `directories` of *that* workspace, the bind address and port, whether a token is required, and whether MCP is mounted. Check the device before authoring - a CUDA-only choice (bitsandbytes, `torch.compile`, flash attention) is not available on an `mps` or `cpu` server |
+| `get_health()` | — | Check that the server is alive, and which machine answered: `version`, `device`, whether a model process is currently resident (`worker_alive`), the job running now and the queue depth. `worker_alive: false` is the normal idle state on a server that has not run a job since startup or the last memory clear - not a fault - the on-demand worker starts with the next job (#206) |
+| `get_server_info()` | — | What this installation can do and where it keeps things: `device` (the accelerator a run will use), `version`, the `workspace` this session is working in and the workflow/asset/output/prompt `directories` of *that* workspace, the bind address and port, whether a token is required, and whether MCP is mounted. Check the device before authoring - a CUDA-only choice (bitsandbytes, `torch.compile`, flash attention) is not available on an `mps` or `cpu` server. `runtime` (#222) reports the Python version, torch version and the CUDA version torch was built against, the NVIDIA driver version (when `nvidia-smi` is reachable), and the installed versions of diffusers, transformers, accelerate, bitsandbytes, peft, safetensors and sentencepiece (`null` for one not installed) - for diagnosing an environment mismatch between boxes without shelling in |
 | `list_jobs(limit=20, status=None, workspace=None)` | optional `limit` (newest N), `status` (one state or a comma-separated set of `queued`, `running`, `succeeded`, `failed`, `cancelled`), `workspace` | List queued, running and recent jobs, **newest first**. Bounded by default: the unbounded listing was over a client's tool-result limit on a server with a few months of history, which made it a tool that could not be called at all. `total` says how many matched and `truncated`/`next` say so when the answer was cut - raise `limit` or narrow with `status`. Without `workspace`, a named workspace lists its own jobs and the default one lists every job the server holds |
 | `list_gallery(limit=50, subfolder=None, only_orphans=False, workspace=None)` | `limit`, `subfolder`, `only_orphans`, `workspace` | List generated output files, newest first. A name is `<workflow>/<run id>/<file>`, where `<file>` may sit in the subfolder the step chose (`final/episode.mp4`); each entry carries `folder` (the workflow) and `subfolder` (by convention `final` or `intermediate`, `''` when the step chose none, any path the workflow wrote otherwise), and `subfolder="final"` lists only deliverables. Each entry also carries a ready-made `url`, already scoped to the workspace that made it - a hand-built `/outputs/<name>` URL 404s for anything but the default workspace. `only_orphans=True` inverts the call: instead of files, it returns run directories with no media anywhere under them (`runs`, each `{name, mtime}`) - a run whose output was deleted before `delete_output` could remove it by name, or one that failed before writing anything; `subfolder` does not apply in this mode, and `name` is exactly what `delete_output` accepts (#170). `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
 | `get_gallery_metadata(name, envelope=False, workspace=None)` | `name`, `workspace` | Get the metadata embedded in a generated file — or, when `name` is an `asset:` reference, what an *input* asset holds (`source` says which; `job` is null for an asset). Reading an input's duration, frame count, fps and sample rate before a run is how a caller learns the `total_frames`, `fps` and `sample_rate` a workflow expects it to supply: the exact workflow and arguments that produced it, and, for audio/video, a `media` block (duration, rate, channels, fps, size, peak/mean dBFS). `envelope=true` adds `media.envelope` — `rms_dbfs` and `peak_dbfs` one entry per second — which is what locates something in a track rather than measuring the whole of it. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
@@ -233,10 +233,12 @@ when no single workflow covers it.
 
 | Tool | Arguments | Purpose |
 | --- | --- | --- |
-| `get_output_image(name, max_dimension=768, workspace=None)` | `name`, `max_dimension`, `workspace` | Look at a generated image, downscaled to `max_dimension` on its longest side. Returns the image plus a text part reporting `original_size`, `returned_size` and `bytes`, so a downscale is never silent. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
+| `get_output_image(name, max_dimension=768, workspace=None, crop=None)` | `name`, `max_dimension`, `workspace`, `crop` | Look at a generated image, downscaled to `max_dimension` on its longest side. Returns the image plus a text part reporting `original_size`, `returned_size` and `bytes`, so a downscale is never silent. `crop` is `[x, y, width, height]` in the original's pixels, cut before the downscale and reported back clamped - the way to see a region of a 2K still at 100%, where the whole would be shrunk past what a small element or a decode-tiling seam can be judged at. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
+| `get_output_audio(name, start=None, duration=None, workspace=None)` | `name`, `start`, `duration`, `workspace` | Listen to a generated soundtrack as base64 - an audio output, or the track muxed into a video (#193) - in its own encoding when served whole, WAV when extracted or excerpted. No downscale exists for audio, so a whole clip over the 4MB budget is refused rather than cut (#204); ask for the part instead with `start` and `duration` in seconds, and the text part names what was cut (`excerpt: 2.0s from 10.0s of 240.0s`) so a slice is never mistaken for the whole. `get_gallery_metadata`'s envelope says where in a track to look. `workspace` names the workspace for this one call without switching the session to it |
+| `get_output_frames(name, at=None, seams=None, count=None, boundaries=None, names=None, max_dimension=512, hear=None, workspace=None)` | `name`, `at`, `seams`, `count`, `boundaries`, `names`, `max_dimension`, `hear`, `workspace` | See a generated video as frames, since there is no video content type over MCP (#193). One selector per call: `count` for an evenly spaced contact sheet, `at` for moments (seconds or `"frame:N"`), `seams` (true, or seam numbers from 1) for the last frame before and first frame after each join side by side (each pair carries `difference`, the mean pixel change across the join, 0-255 - rank seams by it and look at the worst) - `boundaries` is each later shot's first frame - the running sum of the shots' `frame_count` from `get_gallery_metadata` on their own `intermediate/` files - and `names` names them. Tiles are fitted to `max_dimension` and, when the set would exceed the 4MB budget, shrunk together rather than dropped; the text part lists each tile and says so. `hear=N` also returns N seconds of soundtrack centred on each `at` moment, after its image - the way to check a hit point or lip-sync without reconciling two clocks; a mute clip keeps its frames and says `no soundtrack` |
 | `get_output_text(name, max_characters=20000, workspace=None)` | `name`, `max_characters`, `workspace` | Read a text output — a prompt enhancement, or any step whose result is `text/plain` or JSON. Reports the file's real length and whether it was truncated. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
 | `download_output(name, destination=None, overwrite=False, workspace=None)` | `name`, `destination`, `overwrite`, `workspace` | Save one output file to local disk, of any content type. `destination` may be a full path, a directory, or omitted to save under the output's own name in the current working directory; `~` expands and missing parent directories are created. `overwrite=True` is required to replace a file already at the resolved path. Over a `dw.serve --mcp` endpoint the file lands on the server, so the destination is confined to that workspace and a relative one is joined onto it. Returns nothing to the conversation but where the file landed — unlike the other media tools, the point is a file on disk, not a payload in context. Writes on the machine running the MCP server - over `dw.serve --mcp` that is the GPU box. A write that fails there (a path that exists only on the client, for instance) comes back as an error naming the server-side write and the client-side alternatives, not as an anonymous tool failure. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
-| `delete_output(name, workspace=None)` | `name`, `workspace` | Permanently remove one generated file from the output directory. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
+| `delete_output(name=None, workspace=None, job_id=None)` | exactly one of `name` / `job_id`, `workspace` | Permanently remove one generated file from the output directory, or - with `name` a `<workflow>/<run id>` run directory, or with `job_id` - a whole run. By `job_id` the run directory is read from the job record (`run_dir`) and the reply adds `job_id` and the resolved `run_dir` to the usual `name` / `deleted` / `run_swept`; a job that never wrote a run directory, or an unknown one, is an error. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it; a `job_id` delete with no `workspace` goes to the workspace the job ran in |
 
 ### Authoring, assets and workspaces
 
@@ -247,16 +249,33 @@ of its life. That is how two agents work against one GPU without saving over
 each other; see [Workspaces](WORKSPACES.md#several-workspaces-on-one-server).
 The session starts in `default` and stays there unless it is told otherwise.
 
+The pin above is per-*process* state on `client.py`'s `DwClient`, which is
+one session for the local stdio `dw-mcp`, but `dw.serve --mcp` (see
+[REMOTE.md](REMOTE.md#claude-code-no-local-install)) builds a single client
+for every agent it serves - so on that mounted surface the pin is shared by
+every concurrently connected caller, not scoped to any one of them (#298).
+A second client's `use_workspace`/`create_workspace(use=true)` can switch
+what your session reads and writes without your session calling either. This
+server is single-user by design, so nothing tracks distinct MCP sessions to
+fix that; `use_workspace`/`create_workspace` add a `warning` field to their
+result when the pin they are about to overwrite was already pointed
+somewhere other than `default` (a sign another client may depend on it), but
+they cannot warn the *other* session whose pin just moved out from under it.
+A caller that needs real isolation on a mounted server - the tester and
+regression harnesses among them - must pass `workspace=` on every call that
+accepts it (`validate_workflow`, `run_workflow`, and most of the read/media
+tools) rather than relying on the session pin.
+
 | Tool | Arguments | Purpose |
 | --- | --- | --- |
 | `validate_workflow(workflow=None, name=None, workspace=None, arguments=None)` | exactly one of `workflow` (inline definition) or `name` (a stored workflow, as `list_workflows` reports it), optional `workspace`, optional `arguments` | Check a workflow against the schema and against real pipeline signatures. Free and instant. Validating by name uses the workflow file's own directory as the base directory, so it sees what a run would. Returns every schema violation in `errors`, each with the JSON path it sits at, so a draft is fixed in one pass, and a `previous_result:` that names no earlier step is one of them. `warnings` covers what still runs but is probably wrong - a signature mismatch, and, for a list-driven variable, an entry key no step reads, at the entry's path. `workspace` names the workspace for this one call without switching the session to it - use it to pin a job whose `output:` or `asset:` references live in a workspace other than the session's. Pass the same `arguments` you will pass to `run_workflow` and they are checked too - an undeclared or renamed variable name, a value that will not coerce to the declared type, and an `asset:`, `prompt:` or `output:` reference that names nothing this workspace can reach, each reported at `arguments.<name>`. `checked_arguments` lists what was covered, so a `valid: true` about the stored defaults cannot be mistaken for one about your values. A reference set the model would refuse - too many images, videos or audio clips, or, for MiniMax-H3, audio as the only reference - is an error here too, rather than a failure minutes into a run you acknowledged. `run_workflow` makes the same check and refuses a bad argument rather than queuing a job that fails on its first step. A valid answer carries `plan` - the fingerprint, step count, list lengths, `downloads_required`, `estimate` (with `basis`) and `elided_steps` for the arguments given; quote from it. `steps` counts what will run: a step nothing reads and which saves no file does not run, and is named in `elided_steps` instead |
 | `list_workspaces()` | — | The server's workspaces and which one this session is using. Each has its own workflows, assets and outputs; the prompt library is shared by all of them |
-| `use_workspace(name)` | `name` | Work in that workspace for the rest of the session - every later call reads and writes there. This is how to keep your work out of another agent's namespace rather than sharing the default one. Checked against the server, so a typo fails here rather than scoping every later call to nothing |
-| `create_workspace(name, use=False)` | `name`, `use` | Create a workspace. Pass use=true to switch this session to it as well; otherwise the session stays where it was and the result says so |
+| `use_workspace(name)` | `name` | Work in that workspace for the rest of the session - every later call reads and writes there. This is how to keep your work out of another agent's namespace rather than sharing the default one. Checked against the server, so a typo fails here rather than scoping every later call to nothing. On a `dw.serve --mcp` endpoint the pin is shared by every connected client (#298, see the note above the table) - a `warning` field appears when this call overwrote a pin already pointed away from `default` |
+| `create_workspace(name, use=False)` | `name`, `use` | Create a workspace. Pass use=true to switch this session to it as well; otherwise the session stays where it was and the result says so. `use=true` carries the same mounted-server caveat and `warning` field as `use_workspace` |
 | `delete_workspace(name, acknowledged_cost=False)` | `name`, `acknowledged_cost` | Permanently delete a workspace and everything in it. Refuses without the acknowledgement, reporting what it would remove |
 | `list_assets()` | — | The input media on the server, each with the `asset:` reference a workflow argument carries. Look here before asking for a file - what a workflow needs may already be there. `libraries` names the roots searched and which are writable; `shadowed` lists names a nearer library hides |
 | `keep_output(name, asset_name=None, overwrite=False, shared=False, workspace=None)` | `name`, optional `asset_name`, `overwrite`, `shared`, `workspace` | Keep a generated file as an input asset under a stable `asset:` name, so a later workflow can rely on it. The copy happens on the server: nothing is downloaded or re-uploaded. `asset_name` may name a folder and takes the kept file's extension when it has none; `shared=true` keeps it in the library every workspace shares, which is where a recurring cast belongs. `workspace` names the workspace for this one call without switching the session to it - the same pin `run_workflow` takes, so a job run into another workspace stays reachable from the session that queued it |
-| `upload_asset(file_path, asset_name=None, shared=False)` | `file_path` | Push a local image, video or audio file into the server's asset library and get back its `asset:` reference. The file is read from the machine the MCP server runs on, so this is how an input reaches a dw.serve running somewhere else. `asset_name` stores it under a readable name (`cast/priya-voice.wav`) instead of a random one; `shared=true` puts it in the library every workspace shares |
+| `upload_asset(file_path=None, content=None, asset_name=None, shared=False)` | exactly one of `file_path` or `content` (base64), optional `asset_name`, `shared` | Push an image, video or audio file into the server's asset library and get back its `asset:` reference. `file_path` is read from the machine the MCP server runs on, so this is how an input reaches a dw.serve running somewhere else - but only when the caller shares a filesystem with that machine. `content` is the alternative for an agent that does not: the bytes travel inline, base64-encoded, in the tool call itself, capped at 4MB (well under `file_path`'s 200MB) because inline bytes compete with the calling agent's own context budget rather than being a bulk-transfer path (#203). `asset_name` is required with `content` (there is no file name to infer one from) and, either way, stores it under a readable name (`cast/priya-voice.wav`) instead of a random one; `shared=true` puts it in the library every workspace shares |
 | `delete_asset(name)` | `name` | Permanently remove one file from the asset library, by the name `list_assets` reports. Deletes from whichever library holds it - this workspace's own before the shared one; one from a read-only examples library is refused. Any workflow still carrying that `asset:` reference stops loading |
 | `save_workflow(name, workflow)` | `name`, `workflow` | Save a workflow into the server's writable workflow directory, overwriting any existing workflow of that name there. A name that currently resolves to a read-only source (an examples directory) is not overwritten - the copy lands in the writable directory and shadows it |
 | `delete_workflow(name)` | `name` | Permanently delete a stored workflow |
@@ -270,7 +289,7 @@ references written in the same session.
 
 | Tool | Arguments | Purpose |
 | --- | --- | --- |
-| `list_prompts()` | — | List the stored prompts with their text and descriptions |
+| `list_prompts(tag=None, intended_model=None, include_text=False)` | optional `tag`, `intended_model`, `include_text` | List the stored prompts - description, intended model, tags and `text_chars`, bodies left out; `get_prompt` for one body |
 | `get_prompt(name)` | `name` | Get one stored prompt's full definition |
 | `get_prompt_schema()` | — | Get the JSON schema every stored prompt must satisfy. Its own route rather than a name under `/api/prompts`, so a prompt called `schema` cannot shadow it |
 | `save_prompt(name, prompt)` | `name`, `prompt` | Save a prompt, overwriting any prompt of that name. The server validates first, and refuses a `text` that itself begins with a reference prefix (`variable:`, `previous_result:`, `constant:`, `asset:`, `output:`, `prompt:`) |
@@ -282,13 +301,14 @@ references written in the same session.
 
 | Tool | Arguments | Purpose |
 | --- | --- | --- |
-| `run_workflow(workflow_path=None, inline_workflow=None, arguments=None, acknowledged_cost=False, workspace=None)` | exactly one of `workflow_path` (a catalog name from `list_workflows`, with or without `.json`, or a path to a workflow file on the server) or `inline_workflow`, optional `arguments`, `acknowledged_cost`, `workspace` | Queue a workflow for generation. Returns as soon as the job is queued. `workspace` names the workspace for this one call without switching the session to it - use it to pin a job whose `output:` or `asset:` references live in a workspace other than the session's - `acknowledged_cost` is `true` or the bound `{fingerprint, minutes, downloads}` from the validate plan; a 409 means the plan changed and the message carries the new estimate |
+| `run_workflow(workflow_path=None, inline_workflow=None, arguments=None, acknowledged_cost=False, workspace=None, wait_seconds=0)` | exactly one of `workflow_path` (a catalog name from `list_workflows`, with or without `.json`, or a path to a workflow file on the server) or `inline_workflow`, optional `arguments`, `acknowledged_cost`, `workspace`, `wait_seconds` | Queue a workflow for generation. Returns as soon as the job is queued - unless `wait_seconds` is above 0, in which case the call then waits on the queued job exactly as `wait_for_job(job_id, timeout_seconds=wait_seconds)` would (same 55 s cap per call, clamped not honoured) and the result carries the queued-job fields plus that wait's (`status`, `still_running`, `waited_seconds`, `timeout_requested_seconds`, `timeout_applied_seconds`, `timeout_capped`, the slim `job`); when the cap covers the job's runtime one call is the run and the wait, and a `still_running: true` result is followed with `wait_for_job` as before. `workspace` names the workspace for this one call without switching the session to it - use it to pin a job whose `output:` or `asset:` references live in a workspace other than the session's - `acknowledged_cost` is `true` or the bound `{fingerprint, minutes, downloads}` from the validate plan; a 409 means the plan changed and the message carries the new estimate, and nothing is waited on |
 | `get_job(job_id)` | `job_id` | Get a job's status, warnings, output manifest, error and traceback; each manifest entry's `subfolder` is the in-run subfolder the step declared - by convention `final` for the deliverable, `intermediate` for scratch, `''` for none. A running job also carries `progress` (below) |
-| `get_job_workflow(job_id)` | `job_id` | The workflow the job actually ran. `realized: true` means every mutable input is pinned (arguments, seed, prompts, `output:latest`); `false` means the job predates run tracking and this is the definition as submitted. Pass it to `save_workflow` to keep it under a name |
+| `get_job_workflow(job_id)` | `job_id` | The REST equivalent is `GET /api/jobs/{id}/workflow` (see [SERVER.md](SERVER.md#jobs-api)). The workflow the job actually ran. `realized: true` means every mutable input is pinned (arguments, seed, prompts, `output:latest`); `false` means the job predates run tracking and this is the definition as submitted. Pass it to `save_workflow` to keep it under a name |
 | `export_job(job_id, overwrite=False)` | `job_id`, `overwrite` | Gather one finished job into `<workspace>/exports/<job id>/` on the server: the realized workflow, the run's manifest, the job row, a README, and copies of the assets, earlier-run inputs and outputs. Returns the directory, a zip URL, the file list with sizes and the total. The three JSON files are in the zip, not repeated here - get_job_workflow and get_job serve them individually. **The directory is on the machine running the server**, like `download_output`'s destination - fetch the zip URL and unpack it into `exports/` under the session's working directory (a deliverable, not a temp file); the archive already unpacks into one folder named after the job id |
 | `get_job_events(job_id, after=-1, limit=200)` | `job_id`, `after`, `limit` | Get a page of a job's progress events |
 | `wait_for_job(job_id, timeout_seconds=20)` | `job_id`, `timeout_seconds` | Block until a job reaches a terminal status, or `timeout_seconds` elapses. **One call blocks for at most 55 seconds** — a larger `timeout_seconds` is clamped, not honoured, because no MCP client holds a tool call open for a generation's real runtime, so budget one call per ~55s of the job. Every reply carries `waited_seconds`, `timeout_requested_seconds`, `timeout_applied_seconds` and `timeout_capped`, so a capped return is distinguishable from an elapsed one. Use instead of hand-polling `get_job`/`get_job_events` in a loop; if it returns `still_running: true`, call it again. Returns a slim job - status, warnings, error, and the manifest once finished - without the arguments; `get_job` has those. A running job also carries `progress` (below) |
 | `cancel_job(job_id)` | `job_id` | Ask a queued or running job to stop |
+| `clear_memory()` | — | Drop every loaded pipeline and the step cache, freeing VRAM/RAM immediately instead of waiting for the next job to evict one model for another. Also drops the step cache, so a seeded workflow that would otherwise reuse cached results regenerates on its next run. Refused with a 409 while a job is running or queued - the queue is FIFO, so wait for it to finish and retry rather than expecting this call to block until it does (#221) |
 | `rerun_job(job_id, acknowledged_cost=False, new_seed=False)` | `job_id`, `acknowledged_cost`, `new_seed` | Queue a fresh job from a previous job's stored specification. Costs GPU time, so it passes the same gate as `run_workflow`. `new_seed=true` draws a fresh seed into the workflow's seed variable — without it a seeded workflow's rerun repeats its arguments exactly and the step cache serves the whole run from the earlier one's files (`reused: true`), generating nothing. `get_job_workflow`'s `seed_variable` says whether there is one - `acknowledged_cost` is `true` or the bound `{fingerprint, minutes, downloads}` from the validate plan; a 409 means the plan changed and the message carries the new estimate |
 | `move_job(job_id, direction)` | `job_id`, `direction` (`up`\|`down`\|`front`\|`back`) | Reorder a queued job |
 
@@ -372,6 +392,8 @@ The intended loop:
 4. `get_job(job_id)` for the finished manifest (or the error and traceback,
    if it failed)
 5. `get_output_image(name)` to look at a result image
+6. `get_output_frames(name, count=12)` to look at a result video, and
+   `get_output_audio(name, start, duration)` to hear it
 
 While a job runs, `get_job` and `wait_for_job` carry a `progress` block -
 the step being run, the phase (`loading`, `generating`, `decoding`,
@@ -451,18 +473,26 @@ default) for any server an MCP client can reach.
   events of a finished job (`MAX_PERSISTED_EVENTS` in the job history store).
   A job that ran before this feature existed returns an empty event list
   with a `note` explaining why.
-- **Images only.** `get_output_image` decodes and returns images; it refuses
-  video and audio outputs. Use `get_gallery_metadata` to inspect other media
-  kinds.
-- **Uploads read the MCP server's disk.** `upload_asset(file_path)` pushes a
-  local file into the asset library, but "local" means the machine `dw-mcp`
-  runs on. Over `dw.serve --mcp` that is the GPU box, so a file sitting on
-  the client's laptop is not reachable that way - put it on the server, or
-  give the workflow a URL (the arguments that take a path take a URL too).
-  On a `--mcp` endpoint `file_path` is also *confined* to the directories the
-  server works in (its workspace, workflows, assets, outputs and prompts), and
-  the refusal comes before the file is looked for, so the tool cannot be used
-  to probe which paths exist on the box (#138).
+- **Images, sound and frames.** `get_output_image` returns an image,
+  `get_output_audio` a soundtrack (an audio file's, or the one muxed into a
+  video) whole or as a named excerpt, and `get_output_frames` frames of a
+  video as images - there is no video content type over MCP, so a video is
+  seen as frames and heard as its track. `get_output_audio` refuses a whole
+  clip whose base64 size would exceed the same 4MB budget; ask for an
+  excerpt instead.
+- **Uploads read the MCP server's disk, unless sent inline.**
+  `upload_asset(file_path)` pushes a local file into the asset library, but
+  "local" means the machine `dw-mcp` runs on. Over `dw.serve --mcp` that is
+  the GPU box, so a file sitting on the client's laptop is not reachable that
+  way - put it on the server, give the workflow a URL (the arguments that
+  take a path take a URL too), or use `upload_asset(content=..., asset_name=...)`
+  to send the bytes inline instead, base64-encoded in the call itself, capped
+  at 4MB (#203). On a `--mcp` endpoint `file_path` is also *confined* to the
+  directories the server works in (its workspace, workflows, assets, outputs
+  and prompts), and the refusal comes before the file is looked for, so the
+  tool cannot be used to probe which paths exist on the box (#138); `content`
+  reads no path and is not subject to this confinement, since no file on
+  either machine is ever named.
   `download_output` has the same asymmetry in the other direction: on a
   `--mcp` endpoint it writes on the GPU box, not the client's machine, and is
   confined to the workspace there.

{diffusers_workflow-0.4.0b6 → diffusers_workflow-0.4.0b7}/dw/docs/RELEASING.md

@@ -1,5 +1,20 @@
 # Releasing
 
+## Unreleased
+
+This project has no standing release-notes file - GitHub auto-generates
+notes from commits at tag time (see below). This section is a scratch pad
+for items a branch's author wants the next release note to name; clear it
+when a release ships.
+
+- `get_output_audio` now reads `GET /api/gallery/{name}/audio`, extracts a
+  video's soundtrack, and takes `start`/`duration` (moved off the
+  `/outputs` mount, which used to refuse `video/mp4`).
+- New tool `get_output_frames` (route `GET /api/gallery/{name}/frames`):
+  a video seen as moments, a contact sheet, or seam pairs.
+- `get_output_frames` takes `hear` (soundtrack around each `at` moment) and
+  reports `difference` per seam pair.
+
 Releases are cut by pushing a `v<semver>` tag. CI does the rest.
 
 ```bash

{diffusers_workflow-0.4.0b6 → diffusers_workflow-0.4.0b7}/dw/docs/REMOTE.md

@@ -59,6 +59,13 @@ Two things differ from the local stdio setup:
   result, or open `http://<box>:8765/outputs/<name>` in the browser.
 - The connection is a plain HTTP call per tool invocation; there is no
   subprocess to restart.
+- `use_workspace`/`create_workspace` pin *this box's* one MCP client, shared
+  by every agent connected to it - this server is single-user, so there is
+  no per-session isolation. If you and another agent are both against the
+  same box, either one's `use_workspace` call can move what the other reads
+  and writes next (#298). Pass `workspace=` on each call that takes it
+  (`validate_workflow`, `run_workflow`, most read/media tools) instead of
+  relying on the session pin when that matters.
 
 ## Claude Code with a local install (stdio)