kiapi 0.1.0__py3-none-any.whl

kiapi/capabilities/qwen/README.md

@@ -0,0 +1,235 @@
+# qwen
+
+**English** | [日本語](README.ja.md)
+
+[mflux Qwen Image](https://github.com/filipstrand/mflux/blob/main/src/mflux/models/qwen/README.md) provides image generation and image editing functions.
+Qwen Image is a strong model for multilingual prompts and text in images.
+
+- **generate**:
+  - Generate images from text
+  - img2img if you pass `init_image` FileRef
+- **edit**:
+  - Natural language editing using one or more reference images from the Files API
+
+
+## API
+
+| Endpoint | Name | Description |
+|---|---|---|
+| `POST /v1/image/qwen/generate` | Image generation | Generate image from prompt and reference image. |
+| `POST /v1/image/qwen/edit` | Image editing | Generate an image from multiple reference images. |
+| `GET /v1/image/qwen/models` | Model list | Returns a list of available models. |
+| `GET /v1/image/qwen/openapi.json` | OpenAPI | Returns detailed input/output specifications, usage, and TIPS. |
+
+## API Docs
+
+- [OpenAPI JSON](https://kiarina.github.io/kiapi/v1/image/qwen/openapi.json)
+- [Swagger UI](https://kiarina.github.io/kiapi/v1/image/qwen/docs.html)
+- [ReDoc](https://kiarina.github.io/kiapi/v1/image/qwen/redoc.html)
+
+## Dependencies
+
+| Package | License | Description |
+|---|---|---|
+| [mflux](https://github.com/filipstrand/mflux) | MIT | Run Qwen Image / Qwen Image Edit on MLX. |
+
+## Models
+
+| Model | License | Terms | Size | Description |
+|---|---|---|---:|---|
+| [Qwen/Qwen-Image](https://huggingface.co/Qwen/Qwen-Image) | Apache-2.0 | Not required | 58 GB | `image` (default). Used with `generate`. txt2img/img2img. Defaults are `steps: 30`, `guidance: 4.0`, `quantize: 8`. |
+| [Qwen/Qwen-Image-Edit-2509](https://huggingface.co/Qwen/Qwen-Image-Edit-2509) | Apache-2.0 | Not required | 58 GB | `edit-2509`. Used with `edit`. Single/multiple reference image editing. Defaults are `steps: 30`, `guidance: 2.5`, `quantize: 8`. |
+
+`POST /v1/image/qwen/generate` is only `image`, `POST /v1/image/qwen/edit` is
+Only `edit-2509` is accepted. Defaults for each endpoint are compensated on the router side
+Therefore, `model` can usually be omitted.
+
+## Notes
+
+- **Image size**:
+  `width` / `height` are multiples of 16. Default is `1024 x 1024`, upper limit is `2048 x 2048`.
+- **steps/guidance**:
+  `steps` is `1..100`. If omitted, both generate/edit are `30`. `guidance` is generated by
+  `4.0`, edit is `2.5`.
+- **quantize**:
+  Default is `8`. If you want to overwrite, you can specify `3` / `4` / `5` / `6` / `8`.
+  If omitted or passed `null`, the default value will be used.
+- **LoRA applied**:
+  Apply the adapter with `loras: [{"file": {"type": "file_id", "file_id": "..."}, "scale": 1.0}]`. Up to 4.
+  Adapter files must be stored in the Files API.
+- **transient model**:
+  mflux fixes the quantization level and LoRA during model construction, so if you have `loras` or
+  A request to override `quantize` from its default value builds a temporary model for that call.
+  It is slower than a plain `image` / `edit-2509` call because it does not reuse the resident model.
+- **Output format**:
+  `format` is `png` (default) / `jpeg` / `webp`. `quality` for `jpeg` / `webp`
+  Use `1..100` (default `90`).
+- **Memory guideline**:
+  `image` / `edit-2509` are both large models. The registered value of kiapi has a weight of approximately
+  Expected to be `22.0 GiB`, with runtime headroom of approximately `8.0 GiB`.
+
+## Quickstart
+
+### generate - generate image from text
+
+Save only the image:
+```bash
+PARAMS=$(
+jq -n \
+--arg prompt "a cafe storefront, a wooden sign clearly reads カフェ, bright daylight" \
+--arg negative_prompt "blurry, low quality, distorted text" \
+'{
+  model: "image",
+  mode: "sync",
+  prompt: $prompt,
+  negative_prompt: $negative_prompt,
+  width: 512,
+  height: 512,
+  seed: 1
+}'
+)
+
+curl -sS -X POST http://localhost:${PORT:-8000}/v1/image/qwen/generate \
+-H 'Content-Type: application/json' \
+--data-binary "$PARAMS" \
+-o qwen.png
+```
+Returns Job JSON:
+```bash
+PARAMS=$(
+jq -n \
+--arg prompt "a clean product label design, the main text reads KIAPI, white background" \
+'{
+  mode: "sync",
+  prompt: $prompt,
+  width: 512,
+  height: 512,
+  seed: 2
+}'
+)
+
+curl -sS -X POST http://localhost:${PORT:-8000}/v1/image/qwen/generate \
+-H 'Accept: application/json' \
+-H 'Content-Type: application/json' \
+--data-binary "$PARAMS" |
+jq .
+```
+### generate - img2img
+
+Upload the source image first.
+```bash
+IMG=$(curl -sS -X POST http://localhost:${PORT:-8000}/v1/files \
+-F "file=@source.png" | jq -r .file_id)
+```
+Generate based on the uploaded image.
+```bash
+PARAMS=$(
+jq -n \
+--arg img "$IMG" \
+--arg prompt "turn this into a polished cozy illustration" \
+'{
+  model: "image",
+  mode: "sync",
+  prompt: $prompt,
+  init_image: {type: "file_id", file_id: $img},
+  image_strength: 0.45,
+  width: 1024,
+  height: 576,
+  seed: 7
+}'
+)
+
+curl -sS -X POST http://localhost:${PORT:-8000}/v1/image/qwen/generate \
+-H 'Content-Type: application/json' \
+--data-binary "$PARAMS" \
+-o qwen-img2img.png
+```
+`image_strength` is `0..1`. The smaller the value, the stronger the input image will remain, and the larger the value, the stronger the prompt side.
+The changes will become stronger.
+
+### edit - Edit single/multiple images
+```bash
+REF1=$(curl -sS -X POST http://localhost:${PORT:-8000}/v1/files \
+-F "file=@mascot.png" | jq -r .file_id)
+REF2=$(curl -sS -X POST http://localhost:${PORT:-8000}/v1/files \
+-F "file=@object.png" | jq -r .file_id)
+
+PARAMS=$(
+jq -n \
+--arg ref1 "$REF1" \
+--arg ref2 "$REF2" \
+--arg prompt "combine the mascot and object into a bright product key visual; keep the mascot recognizable" \
+'{
+  model: "edit-2509",
+  mode: "sync",
+  prompt: $prompt,
+  images: [{type: "file_id", file_id: $ref1}, {type: "file_id", file_id: $ref2}],
+  width: 1024,
+  height: 576,
+  seed: 9
+}'
+)
+
+curl -sS -X POST http://localhost:${PORT:-8000}/v1/image/qwen/edit \
+-H 'Content-Type: application/json' \
+--data-binary "$PARAMS" \
+-o qwen-edit.png
+```
+`images` is one or more. For editing a single image or for compositing and reconstructing using multiple reference images.
+You can use it.
+
+###async
+```bash
+PARAMS=$(
+jq -n \
+--arg prompt "a typography poster, large readable text says LOCAL AI" \
+'{
+  mode: "async",
+  prompt: $prompt,
+  width: 512,
+  height: 512,
+  seed: 11
+}'
+)
+
+JOB=$(curl -sS -X POST http://localhost:${PORT:-8000}/v1/image/qwen/generate \
+-H 'Accept: application/json' \
+-H 'Content-Type: application/json' \
+--data-binary "$PARAMS" |
+jq -r .job_id)
+
+curl -sS http://localhost:${PORT:-8000}/v1/jobs/$JOB | jq .
+```
+After completion, use the Job's `artifacts[0]` or `result.file_id` to get the image.
+```bash
+FID=$(curl -sS http://localhost:${PORT:-8000}/v1/jobs/$JOB | jq -r .result.file_id)
+curl -sS http://localhost:${PORT:-8000}/v1/files/$FID/download -o qwen-async.png
+```
+### Generated by applying LoRA
+
+Upload `.safetensors`, such as learned adapters, to the Files API and reference them with `loras`.
+```bash
+ADAPTER=$(curl -sS -X POST http://localhost:${PORT:-8000}/v1/files \
+-F "file=@adapter.safetensors" | jq -r .file_id)
+
+PARAMS=$(
+jq -n \
+--arg adapter "$ADAPTER" \
+--arg prompt "<your trigger word> as a clean editorial illustration" \
+'{
+  model: "image",
+  mode: "sync",
+  prompt: $prompt,
+  width: 512,
+  height: 512,
+  seed: 13,
+  loras: [{file: {type: "file_id", file_id: $adapter}, scale: 1.0}]
+}'
+)
+
+curl -sS -X POST http://localhost:${PORT:-8000}/v1/image/qwen/generate \
+-H 'Content-Type: application/json' \
+--data-binary "$PARAMS" \
+-o qwen-lora.png
+```
+`scale` is the strength of the effect. Every request using `loras` builds a temporary model.

kiapi/capabilities/qwen/__init__.py

@@ -0,0 +1,30 @@
+"""qwen family — Qwen Image generation/editing via mflux.
+
+Endpoints: ``POST /v1/image/qwen/{generate,edit}``. ``generate`` is txt2img by
+default and img2img when ``init_image_file_id`` is supplied; ``edit`` does
+natural-language single/multi-image editing. LoRA adapters and a ``quantize``
+override run on a one-off transient model; otherwise the resident model is used.
+"""
+
+from kiapi.capabilities import ValidationError
+
+from ._helpers.register import register
+from ._helpers.validate_edit import validate_edit
+from ._helpers.validate_generate import validate_generate
+from ._operations.handle_edit import handle_edit
+from ._operations.handle_generate import handle_generate
+from ._settings import settings_manager
+from ._views.edit_request import EditRequest
+from ._views.generate_request import GenerateRequest
+
+__all__ = [
+    "EditRequest",  # ._views
+    "GenerateRequest",  # ._views
+    "ValidationError",  # kiapi.capabilities
+    "handle_edit",  # ._operations
+    "handle_generate",  # ._operations
+    "register",  # ._helpers
+    "settings_manager",  # ._settings
+    "validate_edit",  # ._helpers
+    "validate_generate",  # ._helpers
+]

kiapi/capabilities/qwen/_constants/description.py

@@ -0,0 +1,53 @@
+DESCRIPTION = """Image generation and editing (Qwen-Image via mflux).
+
+Two operations on Alibaba's Qwen-Image models: `/generate` (text-to-image, or
+image-to-image when `init_image` is supplied) and `/edit` (natural-language
+single/multi-image editing). Qwen-Image is strong at rendered text and
+instruction-following edits.
+
+## Upstream docs
+- [mflux — Qwen Image](https://github.com/filipstrand/mflux/blob/main/src/mflux/models/qwen/README.md) — the MLX engine kiapi runs
+- [Qwen/Qwen-Image](https://huggingface.co/Qwen/Qwen-Image) — generate weights
+- [Qwen/Qwen-Image-Edit-2509](https://huggingface.co/Qwen/Qwen-Image-Edit-2509) — edit weights
+
+## Models
+- **image** (default) — text-to-image / img2img. The only variant `/generate`
+  accepts.
+- **edit-2509** — instruction-based editing. The only variant `/edit` accepts.
+
+Each endpoint is pinned to its variant, so `model` is effectively fixed per
+operation; discover variants at `GET /v1/image/qwen/models`. Omitted
+`steps`/`guidance`/`quantize`/size are filled in server-side and the resolved
+values are recorded in the result `params`.
+
+## generate vs edit
+- **generate** is text-to-image; pass `init_image` (+ optional `image_strength`
+  in 0..1) to seed an img2img run from one image.
+- **edit** takes a list of reference `images` for single- or multi-image editing
+  / composition under one natural-language prompt.
+
+## Resident vs transient runs
+The warmed, resident model uses the server-default quantization (q8). A request
+that either supplies `loras` or sets a `quantize` differing from the resident
+model builds a **one-off transient model** for that call — weights load fresh, so
+it is slower and not reused. For the fast path, omit `loras` and leave `quantize`
+unset.
+
+## LoRA
+Apply adapters by passing their `file` ids in `loras` (up to 4, each
+`{file, scale}`). Any lora forces a transient run.
+
+## TIPS
+- For a quick image, call `sync` without `Accept: application/json` to get the
+  raw bytes straight back (`curl -o out.png`).
+- `width`/`height` must be multiples of 16 and at most 2048x2048 (default 1024).
+- Qwen-Image renders legible text well — describe the wanted text explicitly in
+  the prompt.
+- First use downloads the Qwen weights (~58 GB full); run `kiapi activate` ahead
+  of time to avoid a cold-start download on the first request.
+
+## Performance
+- Upstream weights are large (~58 GB full); kiapi defaults to q8.
+- Transient runs (any `loras` or a `quantize` override) rebuild the model each
+  call and are slower than the resident path.
+"""

kiapi/capabilities/qwen/_helpers/register.py

@@ -0,0 +1,60 @@
+"""Register qwen's models + OpenAPI description in the global registries."""
+
+from kiapi.core.capability import CapabilitySpec, capability_spec_registry
+from kiapi.core.model import ModelSpec, model_registry
+from kiapi.core.setup import HfSnapshotResource
+
+from .._constants.description import DESCRIPTION
+from .._models import qwen
+from .._settings import settings_manager
+
+
+def register() -> None:
+    capability_spec_registry.register(
+        CapabilitySpec(
+            name="qwen",
+            domain="image",
+            title="kiapi Qwen Image API",
+            summary="Generate and edit images with Qwen Image models.",
+            description=DESCRIPTION,
+            openapi_path="/v1/image/qwen/openapi.json",
+            docs_path="/v1/image/qwen/docs",
+            redoc_path="/v1/image/qwen/redoc",
+            path_prefixes=("/v1/image/qwen",),
+        )
+    )
+
+    _s = settings_manager.get_settings()
+
+    model_registry.register(
+        ModelSpec(
+            name="image",
+            family="qwen",
+            domain="image",
+            repo=_s.image_model,
+            module=qwen,
+            weight_gb=22.0,
+            peak_headroom_gb=8.0,
+            framework="mlx",
+            priority=0,
+            aliases=("qwen-image", "Qwen/Qwen-Image"),
+            default=True,
+            setup_resources=(HfSnapshotResource(repo=_s.image_model, disk_gb=58.0),),
+        )
+    )
+
+    model_registry.register(
+        ModelSpec(
+            name="edit-2509",
+            family="qwen",
+            domain="image",
+            repo=_s.edit_model,
+            module=qwen,
+            weight_gb=22.0,
+            peak_headroom_gb=8.0,
+            framework="mlx",
+            priority=0,
+            aliases=("qwen-edit", "qwen-image-edit", "Qwen/Qwen-Image-Edit-2509"),
+            setup_resources=(HfSnapshotResource(repo=_s.edit_model, disk_gb=58.0),),
+        )
+    )

kiapi/capabilities/qwen/_helpers/validate_edit.py

@@ -0,0 +1,12 @@
+from kiapi.capabilities import ValidationError
+
+from .._operations.validate_common import validate_common
+from .._settings import settings_manager
+from .._views.edit_request import EditRequest
+
+
+def validate_edit(req: EditRequest) -> None:
+    settings = settings_manager.get_settings()
+    validate_common(req, settings, role="edit")
+    if not req.images:
+        raise ValidationError("edit requires at least one image")

kiapi/capabilities/qwen/_helpers/validate_generate.py

@@ -0,0 +1,12 @@
+from kiapi.capabilities import ValidationError
+
+from .._operations.validate_common import validate_common
+from .._settings import settings_manager
+from .._views.generate_request import GenerateRequest
+
+
+def validate_generate(req: GenerateRequest) -> None:
+    settings = settings_manager.get_settings()
+    validate_common(req, settings, role="generate")
+    if req.image_strength is not None and not 0 <= req.image_strength <= 1:
+        raise ValidationError("image_strength must be in 0..1")

kiapi/capabilities/qwen/_models/qwen.py

@@ -0,0 +1,224 @@
+"""Handler for Qwen Image generate/edit via mflux."""
+
+import gc
+import time
+from types import SimpleNamespace
+from typing import Any
+
+from kiapi.capabilities import attach_mflux_progress
+from kiapi.core.file import FileStore
+from kiapi.core.model import ModelSpec
+from kiapi.core.workdir import create_work_dir
+
+from .._views.edit_params import EditParams
+from .._views.generate_params import GenerateParams
+
+FEATURES = {"text", "image"}
+
+
+def _role(spec: ModelSpec) -> str:
+    return "edit" if spec.name == "edit-2509" else "generate"
+
+
+def _build_generate_model(
+    spec: ModelSpec,
+    *,
+    quantize: int | None,
+    lora_paths: list[str] | None = None,
+    lora_scales: list[float] | None = None,
+) -> Any:
+    from mflux.models.common.config import ModelConfig  # type: ignore
+    from mflux.models.qwen.variants.txt2img.qwen_image import QwenImage  # type: ignore
+
+    return QwenImage(
+        quantize=quantize,
+        model_path=spec.repo,
+        lora_paths=lora_paths or None,
+        lora_scales=lora_scales or None,
+        model_config=ModelConfig.qwen_image(),
+    )
+
+
+def _build_edit_model(
+    spec: ModelSpec,
+    *,
+    quantize: int | None,
+    lora_paths: list[str] | None = None,
+    lora_scales: list[float] | None = None,
+) -> Any:
+    from mflux.models.common.config import ModelConfig
+    from mflux.models.qwen.variants.edit.qwen_image_edit import (  # type: ignore[import-untyped]
+        QwenImageEdit,
+    )
+
+    return QwenImageEdit(
+        quantize=quantize,
+        model_path=spec.repo,
+        lora_paths=lora_paths or None,
+        lora_scales=lora_scales or None,
+        model_config=ModelConfig.qwen_image_edit(),
+    )
+
+
+def load(spec: ModelSpec) -> SimpleNamespace:
+    from .._settings import settings_manager
+
+    settings = settings_manager.get_settings()
+    role = _role(spec)
+    quantize = settings.default_quantize
+    model = (
+        _build_edit_model(spec, quantize=quantize)
+        if role == "edit"
+        else _build_generate_model(spec, quantize=quantize)
+    )
+    return SimpleNamespace(model=model, spec=spec, role=role, quantize=quantize)
+
+
+def warmup(payload: SimpleNamespace) -> None:
+    if payload.role == "edit":
+        return
+    payload.model.generate_image(
+        seed=0, prompt="warmup", num_inference_steps=1, width=256, height=256
+    )
+
+
+def _store_image(
+    image: Any,
+    *,
+    fmt: str,
+    quality: int,
+    files: FileStore,
+    meta: dict[str, Any],
+) -> dict[str, Any]:
+    pil = getattr(image, "image", image)
+    ext = "jpg" if fmt == "jpeg" else fmt
+    tmp_dir = create_work_dir("image/qwen")
+    out_path = tmp_dir / f"image.{ext}"
+    save_kwargs: dict[str, Any] = {}
+    if fmt in ("jpeg", "webp"):
+        save_kwargs["quality"] = quality
+    if fmt == "jpeg":
+        pil = pil.convert("RGB")
+    pil.save(out_path, format=fmt.upper(), **save_kwargs)
+    if not out_path.exists():
+        raise RuntimeError("generation finished but no image file was produced")
+    rec = files.put_path(
+        out_path,
+        filename=f"qwen_{int(time.time())}.{ext}",
+        content_type=f"image/{fmt}",
+        meta=meta,
+        move=True,
+    )
+    return {"file_id": rec.file_id, "image_bytes": rec.size, **meta}
+
+
+def _generate(model: Any, params: GenerateParams, files: FileStore) -> dict[str, Any]:
+    t0 = time.time()
+    attach_mflux_progress(model)
+    image = model.generate_image(
+        seed=params.seed,
+        prompt=params.prompt,
+        negative_prompt=params.negative_prompt,
+        image_path=params.image_path,
+        image_strength=params.image_strength,
+        num_inference_steps=params.steps,
+        width=params.width,
+        height=params.height,
+        guidance=params.guidance,
+        scheduler=params.scheduler,
+    )
+    total_s = round(time.time() - t0, 2)
+    meta = {
+        "model": params.model,
+        "prompt": params.prompt,
+        "params": params.model_dump(exclude={"image_path"}),
+        "width": params.width,
+        "height": params.height,
+        "timings": {"total_s": total_s},
+    }
+    return _store_image(
+        image, fmt=params.format, quality=params.quality, files=files, meta=meta
+    )
+
+
+def _edit(model: Any, params: EditParams, files: FileStore) -> dict[str, Any]:
+    t0 = time.time()
+    attach_mflux_progress(model)
+    image = model.generate_image(
+        seed=params.seed,
+        prompt=params.prompt,
+        negative_prompt=params.negative_prompt,
+        image_paths=params.image_paths,
+        image_path=params.image_paths[0],
+        num_inference_steps=params.steps,
+        width=params.width,
+        height=params.height,
+        guidance=params.guidance,
+        scheduler=params.scheduler,
+    )
+    total_s = round(time.time() - t0, 2)
+    meta = {
+        "model": params.model,
+        "prompt": params.prompt,
+        "params": params.model_dump(exclude={"image_paths"}),
+        "width": params.width,
+        "height": params.height,
+        "timings": {"total_s": total_s},
+    }
+    return _store_image(
+        image, fmt=params.format, quality=params.quality, files=files, meta=meta
+    )
+
+
+def run_generate(
+    payload: SimpleNamespace, params: GenerateParams, files: FileStore
+) -> dict[str, Any]:
+    return _generate(payload.model, params, files)
+
+
+def run_edit(
+    payload: SimpleNamespace, params: EditParams, files: FileStore
+) -> dict[str, Any]:
+    return _edit(payload.model, params, files)
+
+
+def run_generate_transient(
+    spec: ModelSpec,
+    params: GenerateParams,
+    files: FileStore,
+    *,
+    lora_paths: list[str],
+    lora_scales: list[float],
+) -> dict[str, Any]:
+    model = _build_generate_model(
+        spec, quantize=params.quantize, lora_paths=lora_paths, lora_scales=lora_scales
+    )
+    try:
+        return _generate(model, params, files)
+    finally:
+        _free(model)
+
+
+def run_edit_transient(
+    spec: ModelSpec,
+    params: EditParams,
+    files: FileStore,
+    *,
+    lora_paths: list[str],
+    lora_scales: list[float],
+) -> dict[str, Any]:
+    model = _build_edit_model(
+        spec, quantize=params.quantize, lora_paths=lora_paths, lora_scales=lora_scales
+    )
+    try:
+        return _edit(model, params, files)
+    finally:
+        _free(model)
+
+
+def _free(model: Any) -> None:
+    del model
+    gc.collect()
+    import mlx.core as mx
+
+    mx.clear_cache()

kiapi/capabilities/qwen/_operations/handle_edit.py

@@ -0,0 +1,44 @@
+"""Qwen Image edit service entry (worker-thread thunk body)."""
+
+from kiapi.capabilities import CapabilityError, get_file_path
+from kiapi.core.app import AppContext
+from kiapi.core.file import FileID
+from kiapi.core.job import JobResult
+from kiapi.core.model import model_registry
+
+from .._settings import settings_manager
+from .._views.edit_request import EditRequest
+from .is_quantize_override import is_quantize_override
+from .resolve_edit_params import resolve_edit_params
+from .resolve_lora_params import resolve_lora_params
+
+
+def handle_edit(ctx: AppContext, req: EditRequest) -> tuple[JobResult, list[FileID]]:
+    settings = settings_manager.get_settings()
+    spec = model_registry.resolve("qwen", req.model or "edit-2509")
+    ctx.ensure_model_ready(spec)
+    if spec.name != "edit-2509":
+        raise CapabilityError("qwen edit requires model 'edit-2509'")
+    image_paths = [
+        get_file_path(ctx.file_store, image, kind="image") for image in req.images
+    ]
+    lora_params = resolve_lora_params(ctx, req.loras)
+    override = is_quantize_override(settings, req)
+    params = resolve_edit_params(
+        settings, req, variant=spec.name, image_paths=image_paths
+    )
+
+    if lora_params.paths or override:
+        ctx.memory_manager.reserve(spec.weight_gb + spec.peak_headroom_gb)
+        result = spec.module.run_edit_transient(
+            spec,
+            params,
+            ctx.file_store,
+            lora_paths=lora_params.paths,
+            lora_scales=lora_params.scales,
+        )
+    else:
+        payload = ctx.memory_manager.acquire(spec)
+        result = spec.module.run_edit(payload, params, ctx.file_store)
+
+    return result, [result["file_id"]]