diffusers-workflow 0.4.0__py3-none-any.whl

dw/workflow_sources.py

@@ -0,0 +1,383 @@
+"""Where workflows are read from, and the one place they are written to.
+
+A workflow directory used to be a single directory that was both the library
+and the place saves landed. With the repository's own workflows/ as that
+directory - the default when a checkout is the workspace - every save from
+the editor or an MCP client wrote into the example corpus.
+
+A search path separates the two. Reads resolve front to back; writes only
+ever go to the front:
+
+    <workspace>/workflows/   the user's own, writable
+    <examples dirs>          read-only, --examples-dir
+
+A name found in an earlier source shadows the same name in a later one, so a
+workspace copy of an example is the one that runs. Saving over a read-only
+workflow is not an error and not an overwrite: it writes a copy into the
+writable source, which is what "open an example, change it, save" should do.
+"""
+
+import logging
+import os
+
+from .security import PathTraversalError, SecurityError, contained, validate_path
+
+logger = logging.getLogger("dw")
+
+# What a source is, for a client deciding whether to offer save or delete
+WORKSPACE_ORIGIN = "workspace"
+EXAMPLES_ORIGIN = "examples"
+BUILTIN_ORIGIN = "builtin"
+# Not a workflow source - the asset library shared by every workspace under
+# one root reports itself this way, so a client can tell a shared asset from
+# one of its own
+COMMON_ORIGIN = "common"
+
+
+def builtin_root():
+    """The packaged workflows that ship inside dw/ - what 'builtin:' names."""
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "workflows")
+
+
+def catalog_root(directory):
+    """The nearest ancestor of `directory` literally named 'workflows', else
+    the directory itself.
+
+    The root a run with no workflow_dir of its own confines a relative
+    sub-workflow reference to, so a template under templates/ can still climb
+    to a sibling models/ without leaving the catalog. `catalog_root_dir`
+    (dw/workflow.py) is this rule asked for a file rather than a directory.
+    """
+    directory = os.path.normpath(os.path.abspath(directory))
+    parts = directory.split(os.sep)
+    try:
+        index = len(parts) - 1 - parts[::-1].index("workflows")
+    except ValueError:
+        return directory
+
+    return os.sep.join(parts[: index + 1])
+
+
+class WorkflowSource:
+    """One root on the search path."""
+
+    def __init__(self, root, origin, writable):
+        self.root = os.path.abspath(os.path.expanduser(str(root)))
+        self.origin = origin
+        self.writable = writable
+
+    def contains(self, path):
+        """Whether a path resolves inside this root - the containment check
+        the security layer already implements, asked as a question rather
+        than raised as an error."""
+        try:
+            validate_path(path, self.root)
+            return True
+        except SecurityError:
+            return False
+
+    def names(self):
+        """Workflow names under this root, as relative paths without .json."""
+        return workflow_names(self.root)
+
+    def to_dict(self):
+        return {"root": self.root, "origin": self.origin, "writable": self.writable}
+
+    def __repr__(self):
+        return f"WorkflowSource({self.root!r}, {self.origin}, writable={self.writable})"
+
+
+def workflow_names(root):
+    """Workflow names under a root, as relative paths without .json.
+
+    A file symlink resolving outside the root is not a name here: a listing
+    opens every file it names, and reads by name already refuse the link."""
+    names = []
+    if not os.path.isdir(root):
+        return names
+    for directory, _dirs, files in os.walk(root):
+        for file_name in files:
+            if file_name.endswith(".json"):
+                path = os.path.join(directory, file_name)
+                if not contained(path, root):
+                    continue
+                relative = os.path.relpath(path, root)
+                names.append(relative[: -len(".json")].replace(os.sep, "/"))
+    return sorted(names)
+
+
+def workflow_sources(workflow_dir, examples_dirs=None, include_builtin=False):
+    """The search path: the writable directory first, then read-only roots.
+
+    A read-only root that is the writable one - a checkout whose workflows/
+    is both the workspace library and the examples - appears once, writable,
+    rather than twice with two different answers about whether it can be
+    saved to.
+
+    The packaged workflows are off the path by default. They are the pieces
+    a 'builtin:' sub-workflow step names, resolved by the engine where that
+    step is read (dw/workflow.py) - not workflows anyone browses or runs on
+    their own, and listing them would put a handful of fragments in front of
+    every user who never asked for them.
+    """
+    sources = [WorkflowSource(workflow_dir, WORKSPACE_ORIGIN, True)]
+    candidates = [(directory, EXAMPLES_ORIGIN) for directory in examples_dirs or []]
+    if include_builtin:
+        candidates.append((builtin_root(), BUILTIN_ORIGIN))
+
+    seen = {sources[0].root}
+    for root, origin in candidates:
+        source = WorkflowSource(root, origin, False)
+        if source.root in seen:
+            continue
+        seen.add(source.root)
+        sources.append(source)
+    return sources
+
+
+def writable_source(sources):
+    """The source saves go to: the front of the path."""
+    for source in sources:
+        if source.writable:
+            return source
+    return None
+
+
+def source_for_path(sources, path):
+    """Which source a resolved path belongs to, or None if it is outside
+    every root - which is what makes a path a workflow rather than an
+    arbitrary file."""
+    for source in sources:
+        if source.contains(path):
+            return source
+    return None
+
+
+def resolve_in_source(source, name, allow_create=False):
+    """The on-disk path a name has in one source, or None when the name does
+    not resolve inside it. Containment is the security layer's, so a name
+    that tries to traverse simply does not resolve."""
+    if not name.endswith(".json"):
+        name = f"{name}.json"
+    try:
+        return validate_path(
+            os.path.join(source.root, name), source.root, allow_create=allow_create
+        )
+    except SecurityError:
+        return None
+
+
+def find_workflow(sources, name):
+    """The first source that has this name, as (path, source).
+
+    Front to back, so a workspace copy shadows the example it was copied
+    from. (None, None) when no source has it.
+    """
+    for source in sources:
+        path = resolve_in_source(source, name)
+        if path and os.path.isfile(path):
+            return path, source
+    return None, None
+
+
+def suggest_workflow_names(sources, name, limit=3):
+    """Catalog names an unresolved `name` might have meant, for an error
+    message rather than a second round trip.
+
+    The catalog is organised in directories (`templates/minimax/dialogue-short`)
+    and a caller - a skill, an earlier turn - often has only the trailing
+    name (`dialogue-short`). Preferred answer: every catalog entry `name` is
+    a unique path suffix of, since that is unambiguous; failing that, a
+    close spelling match (`difflib`), for a typo rather than a shortened
+    path. Empty when neither finds anything worth naming.
+    """
+    import difflib
+
+    stripped = name[: -len(".json")] if name.endswith(".json") else name
+    catalog_names = list(listing(sources).keys())
+    suffix_matches = [
+        candidate
+        for candidate in catalog_names
+        if candidate == stripped or candidate.endswith(f"/{stripped}")
+    ]
+    if suffix_matches:
+        return suffix_matches[:limit]
+
+    # A typo is measured against the catalog entry's own name, not against
+    # its directory prefix - "dialog-short" scores 0.92 against
+    # "dialogue-short" and 0.55 against "templates/minimax/dialogue-short",
+    # so comparing full paths lets a real typo miss the cutoff (#397). The
+    # query's own prefix is stripped the same way, so "sub/Basik" is
+    # measured as "Basik" against "Basic" rather than against "sub/Basic".
+    query_basename = stripped.rsplit("/", 1)[-1]
+    by_basename = {}
+    for candidate in catalog_names:
+        by_basename.setdefault(candidate.rsplit("/", 1)[-1], []).append(candidate)
+    close_bases = difflib.get_close_matches(
+        query_basename, list(by_basename.keys()), n=limit, cutoff=0.6
+    )
+    matches = []
+    for base in close_bases:
+        for candidate in by_basename[base]:
+            if candidate not in matches:
+                matches.append(candidate)
+    return matches[:limit]
+
+
+def listing(sources):
+    """Every name the search path offers, each with the source it comes
+    from - a name in an earlier source shadowing the same name later."""
+    found = {}
+    for source in sources:
+        for name in source.names():
+            found.setdefault(name, source)
+    return dict(sorted(found.items()))
+
+
+def fallback_roots(primary=None):
+    """The read-only workflow roots a sub-workflow name is resolved against
+    after the directory the run is confined to.
+
+    Pinned in DW_WORKFLOW_PATH by dw.serve, the same way the prompt and
+    asset libraries are, so the worker resolves a composed template exactly
+    as the API would.
+    """
+    from .workspace import WORKFLOWS_SUBDIR, library_fallbacks
+
+    return library_fallbacks(WORKFLOWS_SUBDIR, primary)
+
+
+def _candidate_names(name):
+    """A name as written, and with .json appended when it has no extension -
+    the catalog reports names without it, and run_workflow's workflow_path
+    takes either (#90)."""
+    names = [name]
+    if not name.endswith(".json"):
+        names.append(f"{name}.json")
+    return names
+
+
+class SubWorkflowNotFound(Exception):
+    """A sub-workflow step's path names nothing on the search path."""
+
+    def __init__(self, path, tried):
+        self.path = path
+        # In order, each candidate once - two roots can resolve one name to
+        # the same file, and saying so twice reads as two failures
+        self.tried = list(dict.fromkeys(tried))
+        detail = "\n  ".join(self.tried)
+        super().__init__(
+            f"Sub-workflow '{path}' could not be resolved. It is read as a "
+            "catalog name from list_workflows (with or without .json), or a "
+            "path relative to the workflow that names it. Looked in:"
+            f"\n  {detail}"
+        )
+
+
+def _describe_roots(roots):
+    """Roots this resolution consulted, for a refusal message - never empty
+    text, since a run with none configured still owes an answer."""
+    return ", ".join(roots) if roots else "(no workflow sources configured)"
+
+
+def resolve_sub_workflow(path, base_dir, confine_to):
+    """Where a sub-workflow step's `path` resolves to, and the root the
+    child is confined to, as (path, root).
+
+    Order, first hit wins:
+
+      1. relative to the directory of the workflow that names it - which is
+         how a template reaches '../models/x.json', and stays first so an
+         existing composition keeps meaning what it did
+      2. the same, with '.json' supplied
+      3. the run's own workflow root (a workspace's workflows/), by catalog
+         name, with or without '.json'
+      4. each read-only root on the search path, the same way - which is
+         what lets a stored template be composed rather than copied (#90)
+
+    An absolute path is taken as written and confined to whichever root
+    holds it, so the sandbox still refuses one that belongs to no source.
+
+    A relative path that climbs out of the root it will be handed back with is
+    a PathTraversalError rather than a SubWorkflowNotFound - a refusal, not a
+    name that was absent. Otherwise raises SubWorkflowNotFound, naming every
+    candidate it looked at.
+    """
+    roots = []
+    if confine_to:
+        roots.append(os.path.abspath(os.path.expanduser(str(confine_to))))
+    for root in fallback_roots(roots[0] if roots else None):
+        if root not in roots:
+            roots.append(root)
+
+    tried = []
+    if os.path.isabs(path):
+        candidate = os.path.normpath(path)
+        tried.append(candidate)
+        for root in roots:
+            source = WorkflowSource(root, EXAMPLES_ORIGIN, False)
+            if source.contains(candidate) and os.path.isfile(candidate):
+                return candidate, root
+        if confine_to:
+            # A real confinement boundary was named and nothing on the
+            # search path holds this candidate - refuse here, naming every
+            # root this resolution consulted, rather than handing an
+            # unqualified path back to validate_workflow_path for a refusal
+            # that names only the rejected path and not where it looked
+            # (#422)
+            raise PathTraversalError(
+                f"Path outside every workflow source: {candidate}. Looked in: "
+                + _describe_roots(roots)
+            )
+        # Unconfined (a bare CLI run naming no workflow_dir) - hand it back
+        # as before and let validate_workflow_path's base=None passthrough
+        # decide, since there is no boundary to report roots for
+        return candidate, confine_to
+
+    if base_dir:
+        # The root this candidate would be handed back with: the caller's
+        # confinement when it named one, else the catalog root the run itself
+        # would confine to. Containment is checked before the stat, so a name
+        # that climbs out of the catalog is never even looked at - which is
+        # what the callers' own validate_workflow_path caught a step too late,
+        # leaving this `os.path.isfile` the dw/path-injection query's only
+        # unguarded sink. A climb out is refused rather than reported as
+        # absent, the distinction the search path below keeps: the
+        # PathTraversalError propagates to the caller
+        root = confine_to or catalog_root(base_dir)
+        search_roots = [root] + [r for r in roots if r != root]
+        for name in _candidate_names(path):
+            # normpath first: validate_path refuses a '..' outright, so a
+            # climb that stays inside the root has to be collapsed before it
+            # is judged. Its return value is what gets stat'ed - and being
+            # the validator's own, it is contained by construction
+            try:
+                candidate = validate_path(
+                    os.path.normpath(os.path.join(base_dir, name)),
+                    root,
+                    allow_create=True,
+                )
+            except PathTraversalError as e:
+                # Same refusal, naming the search path rather than only the
+                # resolved (rejected) path (#422)
+                raise PathTraversalError(
+                    f"{e} Looked in: {_describe_roots(search_roots)}"
+                ) from e
+            tried.append(candidate)
+            if os.path.isfile(candidate):
+                return candidate, confine_to
+
+    for root in roots:
+        source = WorkflowSource(root, EXAMPLES_ORIGIN, False)
+        # allow_create, because what is being asked is where the name would
+        # land rather than whether something is there - None means the name
+        # traverses out of the root, and the file check is the next line
+        candidate = resolve_in_source(source, path, allow_create=True)
+        if candidate is None:
+            tried.append(f"{os.path.join(root, path)} (outside the root)")
+            continue
+        tried.append(candidate)
+        if os.path.isfile(candidate):
+            return candidate, root
+
+    raise SubWorkflowNotFound(path, tried)

dw/workflows/h3_context_ir.json

@@ -0,0 +1,57 @@
+{
+    "id": "h3_context_ir",
+    "description": "Rewrites a user's video idea into a MiniMax-H3 Context-IR prompt. Ref2VA has no instruction block above its six sections, so a Ref2VA caller should pass keep_preamble false; the other tasks put a required instruction line there and keep it.",
+    "variables": {
+        "prompt": "Task: T2VA. Duration: 5.17 seconds. Idea: a red fox trotting through a snowy pine forest at dawn.",
+        "image": null,
+        "system_prompt": "You rewrite a user's video idea into a MiniMax-H3 Context-IR prompt, the format MiniMax's two prompt-writing guides define (docs/VIDEO_PROMPT_WRITING_GUIDE_base_en.md and docs/VIDEO_PROMPT_WRITING_GUIDE_ref_en.md in the MiniMaxAI/MiniMax-H3 model repository; this text follows them and is checked against them). Output only the rewritten prompt - no preamble, no commentary, no markdown fences, no explanation of what you did.\n\nThe user message states the task (T2VA, I2VA, FL2VA, L2VA or Ref2VA), the duration in seconds, and the idea. It may also state a continuity mode - \"Continuity: standalone\" or \"Continuity: continuation\" - which is standalone when absent. Structure the output as an optional instruction block, one blank line, then the three core fields.\n\nINSTRUCTION BLOCK, by task:\n- T2VA: none. Begin directly with the core fields.\n- I2VA: exactly \"For the target video, at 0.00 seconds into the target video, <Picture 1> (from [Shot 1]) is fully referenced.\"\n- FL2VA: exactly \"How the reference pictures align with the target video - Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; Picture 2 (from Shot N) aligns with the S.SS-second mark of the target video.\" where S.SS is the duration to two decimal places and N is the index of the final shot.\n- L2VA: exactly \"How the reference pictures align with the target video - <Picture 1> (from [Shot N]) aligns with the S.SS-second mark of the target video.\"\n- Ref2VA: none of the above. Ref2VA has its own six-section layout, given below.\n\nCORE FIELDS for T2VA, I2VA, FL2VA and L2VA, in this order, separated by blank lines:\nintegrated_multimodal_description: the timeline - visual style, initial composition, subject appearance and position, scene and key props, actions and reactions, shot changes, spoken language and synchronized diegetic sound. This field is always written in full, whatever the brief says about sound or music; a silent brief still gets its complete visual timeline here.\noverall_soundscape: ambient sound, physical action sounds and non-verbal human sounds across the whole video. If the brief says there is no sound, this field is exactly one line reading \"overall_soundscape: N/A\" - not a description of silence.\nnon_diegetic_music: background score the audience hears and the characters cannot. If the brief says there is no music, this field is exactly one line reading \"non_diegetic_music: N/A\". Never describe silence in words and never invent audio a silent brief did not ask for.\n\nREF2VA uses six sections instead, in this order, separated by blank lines:\nsubject_definitions: one line per referenced item. <Subject N> is reusable visible content - a person, animal, object, scene, costume, style, action. <Picture N> is a reference image acting as a keyframe or composition anchor; an image that only defines a subject is cited inside that subject's line instead of getting one of its own. <Video N> is a whole-video relationship - an edit source, a continuation point, or a temporal-structure reference. <Audio N> is an audio asset that is copied or referenced; when it fixes a speaker's voice, name that speaker's ID in its line (\"<Audio 1> is the voice-timbre reference for <Subject 1> (S1).\"). One subject may draw on several assets (\"whose appearance comes from <Picture 1> and whose walking motion comes from <Video 1>\"), and an image that plans shots is a storyboard reference (\"<Picture 3> is a storyboard reference for [Shot 1] and [Shot 2], defining their viewpoint, subject placement, and shot order.\"). A label keeps the same meaning in every later section. The references appear in the order the request passes them, and each label type is numbered independently within its own category: the first video is <Video 1> whether or not pictures precede it, and a video reference does not by itself produce an <Audio N> - an audio label exists only for an audio asset the request passes.\nsummary: a square-bracketed task-type prefix followed by one short paragraph on the target video and its main reference relationships. The prefix combines, with \" + \" and without repeats, only the types the references actually play: \"keyframe completion\" (an image is a concrete first, last or key frame), \"reference generation\" (an image, video or audio guides a character, scene, style, action, camera, or storyboard without being a concrete frame or an edited source), \"video editing\" (a source video is directly modified), \"video continuation\" (new content continues or extends a source video), \"audio reuse\" (all or part of an audio signal is copied into the soundtrack), \"audio reference\" (only an audio's style, timbre, content, beat or continuity is followed). A video that only lends camera, cuts or rhythm is reference generation, not editing or continuation. A video edit opens with \"The target video is an edited version of <Video N>.\"\nretention_analysis: one line per referenced item, stating its relationship marker and what that means for it. Visible content (<Subject N>, <Picture N>, <Video N>) uses exactly one of: fully_preserved (its defined role is kept whole), partially_preserved (still used, some defined characteristics changed or only partly kept), attribute_transfer (its characteristics move onto a different identifiable subject), weak_reference (only broad similarity of style, category, composition or atmosphere). Audio (<Audio N>) uses exactly one of: fully_copy (the whole signal is the whole final soundtrack), partially_copy (part of the timeline or selected layers are copied, or sounds are added or replaced around it), reference (nothing copied; timbre, rhythm, music style, dialogue content or texture followed), weak_reference (only broad similarity of category or atmosphere). Write the entry as \"<Subject 1> (appears in [Shot 1], [Shot 3]): fully_preserved - ...\", \"<Picture 2> ([Shot 1] first frame): fully_preserved - ...\", \"<Audio 1>: partially_copy - ...\". Choose the marker within the role subject_definitions gave the label; new actions, backgrounds or events in the target video are not losses of fidelity.\ndetailed_description: one or two sentences establishing the overall style before [Shot 1] (\"The target video is in a realistic photographic style with soft window light.\"), then the same shot-by-shot timeline the other tasks put in integrated_multimodal_description, as detailed and explicit as possible - composition, appearance, environment and lighting, actions and state changes, camera movement, sound, and the points where referenced content actually takes effect. A generation task runs 350-500 words here, spread across the shots by their information load; dialogue-dense content fits the whole spoken timeline first. Never reduce it to a plot summary or a list of reference relationships.\noverall_soundscape: as above.\nnon_diegetic_music: as above.\n\nCONTINUITY MODES. These are this workflow engine's convention for writing one segment of a chained take and are not part of Context-IR; the user message states one when it applies, and standalone is assumed when it does not. They decide how the clip opens:\n- standalone, the default: the clip is a complete piece. [Shot 1] establishes the scene, and when a reference image is supplied [Shot 1] opens on that image - its framing, lighting and style.\n- continuation: the clip is one segment cut out of a longer unbroken take, and a <Video N> reference holds the frames immediately before it. Write one continuous shot - no cuts, and no later timestamped shots. [Shot 1] opens already in progress, on the framing, shot size, camera position, pose and lighting that <Video N> ends on, and carries them on from there. A supplied reference image constrains subject identity, wardrobe, set and palette alone and leaves the opening composition to <Video N>; the summary prefix includes \"video continuation\", and in retention_analysis the video reference is fully_preserved (it is the continuation point) and the subject the image defines is fully_preserved in its identity role. The clip begins mid-action and ends mid-action: it establishes nothing and resolves nothing. The stated duration is this segment's own, not that of the finished video it belongs to.\n\n\nRULES for the shot-by-shot body, whichever field carries it:\n- Open [Shot 1] with the overall style and initial composition, which in continuation mode is the one <Video N> ends on (in Ref2VA the style sentence sits just before [Shot 1] instead of inside it). Styles include Cinematic, live-action, 2D-animated, 3D CG, claymation, watercolor, vintage film. Derive it from the reference image when there is one, otherwise from the user's text.\n- Do not timestamp the first shot. Every later shot opens with a strictly increasing cut time inside the duration: \"[Shot 2] At 00:03.500, the camera cuts to ...\". A cut must introduce new information; when only framing or angle changes, use camera motion instead. FL2VA favours a single continuous shot unless the user asks otherwise, and continuation mode allows no cut at all.\n- Write camera motion as natural English inside the shot, as motion type plus optional amplitude and speed. Motion types: Zoom In, Zoom Out, Push In, Pull Out, Pan Left, Pan Right, Truck Left, Truck Right, Tilt Up, Tilt Down, Pedestal Up, Pedestal Down, Arc Shot, Tracking Shot, Static Shot, Shake Slightly, Shake Strongly, POV, Roll Clockwise, Roll Counterclockwise. Amplitude: \"with small amplitude\", \"with large amplitude\". Speed: \"at slow speed\", \"at fast speed\". Omit amplitude and speed when they are medium and normal.\n- Give every subject who speaks, sings or vocalises off-screen a stable ID - (S1), (S2), and (S1,S2) for unison - kept across shots. Characters who never vocalise get no ID. The first time a speaker appears, establish identity: character type, age, gender, on- or off-screen, pitch, timbre, speaking rate, accent.\n- Put spoken and sung content inside <d>[Language] ...</d> and nothing else. Identity, action and delivery stay outside the tag. Preserve the user's wording and punctuation verbatim; never translate or rewrite supplied lines. Invent dialogue only when the user asked for speech without supplying any.\n- Dialogue fidelity: write [unclear] for a span that cannot be made out; standardise punctuation and end every <d> block with terminal punctuation before </d>; never write speaker IDs such as (Sx) inside retention_analysis, which describes references, not speech; when an <Audio N> is referenced for a speaker's timbre only, do not carry its original words over - the dialogue is what the brief supplies.\n- Voiceover uses the exact phrase \"says in an off-screen voiceover\", and the text right after every voiceover <d> block states that the character's lips remain completely closed.\n- Use <scenetrans> at both connecting points of a line that continues across a cut, and <cutoff> when speech is truncated by the end of the video.\n- Put text actually visible on screen in double quotation marks, verbatim and untranslated.\n- When a reference image is supplied, the description must match what is actually in it - subject, setting, lighting and style - and in standalone mode [Shot 1] must open on that image's framing rather than on an invented scene; in continuation mode the opening framing is <Video N>'s and the image constrains the rest. Never describe content the image contradicts.\n- Every detail must be something visible or audible, in plain words. No negative phrasing - H3 is guidance-distilled and has no negative prompt, so say what is there, never what is not.",
+        "model_name": "Qwen/Qwen3-4B-Instruct-2507",
+        "max_new_tokens": 1600,
+        "device": "cpu",
+        "sections": [
+            "subject_definitions",
+            "summary",
+            "retention_analysis",
+            "detailed_description",
+            "integrated_multimodal_description",
+            "overall_soundscape",
+            "non_diegetic_music"
+        ],
+        "keep_preamble": true
+    },
+    "steps": [
+        {
+            "name": "context_ir",
+            "task": {
+                "command": "text_generation",
+                "arguments": {
+                    "prompt": "variable:prompt",
+                    "system_prompt": "variable:system_prompt",
+                    "model_name": "variable:model_name",
+                    "max_new_tokens": "variable:max_new_tokens",
+                    "device": "variable:device",
+                    "image": "variable:image"
+                }
+            },
+            "result": {
+                "content_type": "text/plain",
+                "save": false
+            }
+        },
+        {
+            "name": "trim",
+            "task": {
+                "command": "extract_sections",
+                "arguments": {
+                    "text": "previous_result:context_ir",
+                    "sections": "variable:sections",
+                    "keep_preamble": "variable:keep_preamble"
+                }
+            },
+            "result": {
+                "content_type": "text/plain",
+                "save": false
+            }
+        }
+    ]
+}

dw/workflows/test.json

@@ -0,0 +1,31 @@
+{
+    "variables": {
+        "prompt": "an apple",
+        "num_images_per_prompt": 1
+    },
+    "id": "test_job",
+    "steps": [
+        {
+            "name": "main",
+            "pipeline": {
+                "configuration": {
+                    "component_type": "StableDiffusionPipeline"
+                },
+                "from_pretrained_arguments": {
+                    "model_name": "stable-diffusion-v1-5/stable-diffusion-v1-5",
+                    "torch_dtype": "torch.float16"
+                },
+                "arguments": {
+                    "prompt": "variable:prompt",
+                    "num_inference_steps": 25,
+                    "num_images_per_prompt": "variable:num_images_per_prompt"
+                }
+            },
+            "result": {
+                "content_type": "image/jpeg",
+                "embed_metadata": true,
+                "file_base_name": "test_image"
+            }
+        }
+    ]
+}