Skip to content

feat(providers): discover capabilities and validate generation inputs - #266

Open
bread-lxy wants to merge 43 commits into
ThinkFlowLab:mainfrom
bread-lxy:codex/v2-capabilities
Open

bread-lxy wants to merge 43 commits into
ThinkFlowLab:mainfrom
bread-lxy:codex/v2-capabilities

Conversation

@bread-lxy

@bread-lxy bread-lxy commented Nov 10, 2026 •

Copy link
Copy Markdown

Summary

Discover optional model capabilities before submitting work, and explain incompatible requests without discarding the user's configuration, inputs or selections.

  • Share capability lookup and request checks across connection settings, generation, the assistant, API, CLI and Agent tools. Match the exact model, route, inputs, parameters and required output.
  • Reject new work only on fresh, applicable negative evidence. Deduct source observation age from the 30-second declaration and independent five-second execution lifetimes, with at most two seconds of future clock tolerance. Expired declarations, including their request constraints, become unknown. Preserve existing validation for older services and failed or unknown discovery.
  • Check image counts without truncation. Region-editing tools use native masks when both the declared route and local adapter support them, preserving requested dimensions and final compositing.
  • Check the exact parameters sent by adapters, including MiniMax's fixed output/response formats, adjusted tool dimensions and the music seed frozen at acceptance. Unsupported mask transport cannot silently discard an input. Keep accepted-task recovery and replay unchanged.
  • Keep Chinese and English states current, including generation history after a language change. Explain stale declarations, invalid observation times, busy services and blocked result downloads without weakening download security.

Linked issue

Refs #224 (V2). The companion Omni S2 PR supplies the discovery endpoint.

Labels

type:feat, area:provider, area:canvas, area:agent.

Test plan

Windows, Python 3.12.7 and Node 24.22.1. Integrated upstream 0bdc3a7; final code 745222c.

  • 265 distinct Python cases passed across capability freshness, model decisions, actual input projection, generation acceptance, request serialization, creation parameters and recovery. Cases cover the 21-day-old declaration, exact age boundaries, remaining lifetimes, future timestamps, old pauses in fresh documents and wall-clock changes after receipt.
  • Service, HTTP and Agent checks verify that fresh negative evidence creates zero jobs and zero generation requests. Stale declarations and constraints allow valid requests through the existing adapters; tests verify both transmitted images, persisted input/model snapshots and successful result files. Music checks compare admission, wire and saved seed values; replay and recovery preserve the accepted seed.
  • 801 frontend tests passed. Contract generation, import boundaries, bilingual catalogs, browser locale/manifest checks and the production build passed.
  • The capability browser workflow passed in both languages: save/refresh, unchanged drafts and selected model, unknown/stale/time-error states, zero-job rejection, successful UI submission under an old negative declaration, decoded saved media, pause expiry and preserved history.
  • The merged generation-feedback browser workflow passed all ten scenarios, including cancellation, retry, reopening, batch identity and history language changes.

Focused entry points: tests/test_capability_freshness.py, tests/test_model_availability.py, tests/test_request_capability_acceptance.py, tests/test_creation_parameters.py, tests/test_generation_recovery.py, tests/browser/capability_discovery.mjs and tests/browser/generation_feedback.mjs. Setup and commands are in the validation guide. The full release workflow remains for CI on this revision.

Upstream Z-Image sampling defaults apply only to text-to-image jobs. Capability validation checks the saved sampling values; editing and accepted-task recovery retain their applicable parameters. MiniMax retains its existing routes, image ordering, 16-image limit and result-download checks.

Evidence that it works

Example capability cards from the controlled UI regression:

English capability card

中文能力卡

The current browser regression also checks both new freshness messages, then submits through the normal UI against a 21-day-old negative declaration. It verifies one accepted job, the unchanged selected model and prompt, a saved image decoded as 320×240, and an unchanged historical input snapshot after pause expiry.

Provider verification

Earlier verification for this PR completed real GLM chat and MOSS speech requests through the normal application. The saved speech file played successfully; its transcription matched the submitted text. A failed capability lookup against a legacy service was followed by a successful real chat request without changing configuration or existing tasks.

The freshness, parameter and image-edit regressions use controlled services and fixture media. Real-model mask adherence remains unverified.

Bilingual UI

Both zh-CN and en-US were checked in the browser, including live language switching, stale and invalid-time messages, rejection reasons and retained selections. Earlier voice-library checks verified retained voice selections.

AI assistance

This contribution was made with assistance from Codex.

## summary

- Apply declared string enum normalization only while comparing values,
  retaining original input and treating unknown rules as unknown.
- Count content references without treating metadata or cached video
  continuations as uploaded media; retain endpoint pause enforcement.
- Share specific constraint errors across admission and execution, keep
  nested receipt codes, and present image geometry failures bilingually.
- Document accepted image request policies and cover actual speech
  payloads, continuation job IDs, and rejection before task creation.

## validation

- Targeted capability, Agent and cache checks: 106 passed, 1 skipped.
- Actual request projection and H3 checks: 61 passed, model doubles.
- Frontend unit tests: 763 passed with PYTHONUTF8=1 on Windows.
- TypeScript/build, i18n, browser manifests, generated contracts and
  import-layer checks passed. Full Python suite is still running.
## summary

Honor a globally disabled exact HTTP endpoint when a continuation
profile is undeclared, without borrowing another profile's inputs.
Keep route_disabled as the rejection reason during a fresh pause.
Verify the public command API creates no continuation job or request
on the disabled endpoint and preserves the original remote job ID
when the endpoint is available.

## validation

The projection and public HTTP regressions both failed before the fix.
The three affected test modules now pass all 110 cases with model
doubles and real temporary media; no real model inference was run.
## summary

Apply the exact global HTTP endpoint closure after profile matching so
both a missing profile and missing profile-route details still reject
new work. Preserve already explicit operation and profile rejections.

## validation

The missing-profile-route regression failed before the fix. All 111
capability projection, availability and H3 tests pass afterward,
including public command rejection without a new model request.
@FayeSpica FayeSpica added type:feat New capability or behaviour area:provider Model providers and generation protocols area:canvas Canvas, nodes and direct manipulation area:agent Agent runtime, assistant chat and tools labels Nov 10, 2026
@bread-lxy

Copy link
Copy Markdown
Author

@wuzhf9 Thank you for the concrete reproduction cases. I have addressed the three findings:

  1. Continuation — 54b42a0: the UI now identifies continuation references and reads the backend's video_continuation decision. An unsupported V2V profile no longer blocks a cached-job continuation. Endpoint closure, an unsupported operation and a fresh deployment pause still block new work. The browser check verifies that pause expiry re-enables submission without losing the draft or source, and that the real adapter sends the original continue_from ID with no video upload.
  2. Dynamic poster — 2947567: the exact regression uses a fully supported first-frame declaration with only num_frames.maximum=10. The prepared 124-frame / 24-fps request is rejected for the frame-count limit before any tool task or generation request is created. With a maximum of 124, the checked, transmitted and saved parameters agree. Tightening the declaration after acceptance does not regenerate an existing task when its submission is replayed.
  3. Top-level route closure — d01109f: a fresh closure of the exact HTTP method and path is checked before returning for a missing model or operation. Tests cover service, HTTP and Agent entry points, including zero created jobs and zero inference requests. Other methods, paths, transports and expired declarations do not cause a refusal.

I also merged main at 53a2cfc9 in 7dfe8c1, preserving the published history and regenerating the contracts. Local verification: 468 related Python tests and all 831 frontend tests passed, along with contract/layer/i18n checks, the build, the full PR-diff pre-commit check, and browser workflows for both languages, capability discovery, HEIF and assistant sessions.

@Xingkai98 I checked the exported Omni responses against #266 with their original observation time held fixed: Wan I2V permits first-frame use; VACE refuses first-frame use; SeedVR2 refuses the editing inputs required by our tool; H3 t2va remains unknown for that editing request. These regression fixtures are included in 2947567. These changes do not yet integrate #278's shared mapping module; #266 still uses its existing operation mappings.

@wuli666 wuli666 left a comment •

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Reviewed the backend judgment path (model_availability.py, capability_probe.py, omni_capabilities.py), the frontend presentation (availability.ts, capabilityErrorText.ts, generationFailureText.ts) and the acceptance entry points. Three behavioural defects are attached inline; each is a wrong accept or a wrong reject, not a style issue.

Positives worth keeping, since they are the parts that will be hardest to restore later:

  • the probe performs I/O only and returns neutral facts; catalogs never do I/O;
  • assert_identity() closes the prepare → submit window, so a settings change mid-flight asks for a resubmit instead of executing against a different service;
  • a remote declaration cannot widen a local limit (local_maximum), and the nativeMask gate requires white=edit / black=preserve / binarize=0.5 / same size / multiple_of before enabling anything;
  • a missing document stays unknown, and only unavailable rejects new work;
  • observations more than 2s in the future are rejected rather than trusted;
  • the response body is capped at 1 MB and redirects are disabled.

Comment thread src/backend/rules.ts Outdated
).length;
for (const kind of ["image", "video", "audio"] as const) {
const limit = availabilityInputLimit(config, profile, kind);
const current = references.filter((item) => item.node.data.kind === kind).length;

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This loop and the local-rule loop further down disagree about whether a continuation source counts as an upload.

Here current counts every reference of the kind, continuation included:

const current = references.filter((item) => item.node.data.kind === kind).length;

The loop below uses the count() helper defined immediately above, which excludes role === "continuation".

Consequence: a service that declares video.max_count = 0 — it accepts continuation and no video upload — rejects any valid continuation clip with errors.rules.serviceInputLimit, because current is 1 while limit is 0. An upload that never happens is charged against the upload budget.

Suggestion: use count(kind) here too. availabilityInputLimit describes transmitted uploads, which is exactly what count() models.

Comment thread apps/api/src/opendirector_api/agent.py Outdated
if config is not None:
prepared = await asyncio.to_thread(generation.availability.prepare, config)
current = await asyncio.to_thread(configs.resolve, str(value.modelId), 'agent')
generation.availability.require(current, requests_for(current, inputs={'text'})[0], prepared)

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This admission check cannot fail on a parameter constraint. requests_for(config, inputs={'text'}) builds its RequestOperation through the inner request() helper, which sets inputs and leaves parameters at (). decision() then runs constraint_failure(contract, counts, {}) with no parameters at all.

The gateway sends a fixed ceiling regardless — packages/core/src/opendirector/integrations/chat_completions.py:15:

value = {"model": config["modelId"], "messages": messages, "stream": True, "max_tokens": 8192}

So a service declaring e.g. max_tokens with maximum: 1024 passes admission here and the request fails upstream instead. The validate_connection() closure added just below has the same shape.

Suggestion: pass the parameters the gateway will actually send, or a single named constant that the gateway and this check both import, so the declaration is compared against the real request. generation_capability_parameters() already does this for the generation path.

timing: AvailabilityClock = clock,
): string | null {
if (model?.availability) receiveAvailability(model.availability, timing);
const item = model?.availability?.operations.find(

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This lookup matches one exact profile, but ModelAvailability.model() publishes a second entry for multi-image input: it replaces the image_to_image row with a decision computed from exactly one image and inserts an images_to_image row beside it.

rules.ts derives the profile as image_to_image whenever any image is transmitted, and this function returns only that entry. For a service whose multi-image profile requires two images (for example image.min_count = 2), the single-image row is unavailable with required_inputs_missing, because that row is evaluated with input_counts=(('text', 1), ('image', 1)).

Result: a valid two-image request is blocked in the UI while backend admission accepts it. availabilityInputLimit() has the same single-profile lookup, so the declared image limit is also read from the single-image row.

Suggestion: select images_to_image when more than one image is transmitted, or take the widest applicable profile.

@bread-lxy

Copy link
Copy Markdown
Author

@wuli666 Thank you for the review. I have addressed the three findings:

  1. Continuation upload counts — 4fc1e25. Service limits now use the existing count helper, which excludes continuation sources. A continuation is allowed when the video-upload limit is zero, while actual uploaded media still obey the limits. The bilingual browser regression checks that the request sends continue_from without uploading the source video; endpoint closure and pause checks remain effective.

  2. Assistant parameters — 4ecd06e. The gateway payload and both assistant admission checks now use the same CHAT_MAX_TOKENS constant, retaining the existing value of 8192. A declared maximum of 1024 rejects the request before a conversation turn is accepted or a model request is sent. Tests also cover an allowed 8192 request through the actual loopback gateway, a changed connection, and a stricter declaration refreshed between the two checks.

  3. Multi-image selection — 769b5bb. The frontend selects text_to_image, image_to_image, or images_to_image from the number of images actually transmitted, and reads the count limit from that same entry. With a two-image minimum and maximum, one and three images are rejected and two images succeed. Service, HTTP and Agent tests check the uploaded files and saved inputs; bilingual browser checks also verify the image flow and preserved assistant drafts after rejection. The image acceptance fixtures now use an exact fixed clock so media preparation cannot change freshness-boundary cases.

Validation: 256 related Python tests and all 833 frontend tests passed, along with both bilingual browser workflows, contract generation, dependency-layer checks, i18n, browser-manifest checks, the production build and the full PR-diff static checks. The workflow checks use local test services and media fixtures.

@Xingkai98

Copy link
Copy Markdown
Contributor

Hi @bread-lxy — checking in on #266 before I start V1. It shows as conflicting with main, and it touches ModelServiceForm.tsx and i18n/models.ts, which my proposed split assigns to me. Two questions: (1) are you rebasing #266 soon, and (2) does #266 add a vLLM-Omni local-service preset, or only capability display? I will keep V1 to providerPresets.ts plus the preset resolution in model_catalog.py until we agree, so we do not both write the same form changes.

@bread-lxy

Copy link
Copy Markdown
Author

@Xingkai98 Thanks for checking before starting V1.

  1. Main integration: 8749150 merges main through b375cc3 and resolves the conflicts, preserving the published history. The tip is 8d21526, which also makes capability selection include pinned references after [bugfix] canvas: include pinned assets in generation precheck (#122) #308. The affected checks and browser workflows passed.

  2. Preset scope: feat(providers): discover capabilities and validate generation inputs #266 implements capability discovery, display, and pre-submission checks. It does not add V1's localhost service preset or endpoint mappings. providerPresets.ts is unchanged from main. The existing per-modality vLLM-Omni entries already come from main and still have an empty URL; the 127.0.0.1 defaults and V1 preset work remain yours.

The overlapping form changes are the capabilityAutoCheck setting, per-model DraftAvailabilityCheck, and generic URL/model placeholders replacing the hard-coded examples, with matching Chinese/English copy. These controls also work with a preset-populated connection. In model_catalog.py, my changes attach cached availability to list(), add check_availability(), and check capabilities before test_agent(); they do not add preset resolution.

The connection form already includes V2's automatic checks and per-model capability checks. Please preserve these when adding the V1 preset. If you need to change the same code, we can review those changes together in your PR.

@bread-lxy

Copy link
Copy Markdown
Author

@wuzhf9 @wuli666 I have merged main through b375cc3 in 8749150, resolved the conflicts, and regenerated the contracts from the combined definitions.

8d21526 also fixes an interaction with #308: capability selection now includes pinned references and uses the same prepared reference list as the count checks. With a two-image requirement, one pinned image is rejected; two pinned images or one followed plus one pinned image are accepted; three images are rejected. The browser regressions check the uploaded bytes, their order, saved asset IDs, and results after reopening the project. A pin and a followed reference to the same asset are counted only once.

Local validation: 541 related Python tests passed, with 5 POSIX-only storage tests skipped on Windows; all 850 frontend tests passed. Five browser workflows passed, covering image/assistant admission, continuation and dynamic posters, HEIF import/export, project reopening, and the voice library including MiniMax. Contract generation, import boundaries, bilingual checks, the build, and the full PR-diff static checks also passed. The earlier continuation, route-closure, video-parameter, and assistant fixes remain covered after the merge.

Could you re-review the updated head? Could a maintainer also approve Release checks for this revision so the full CI jobs can run? Thank you.

@wuzhf9

wuzhf9 commented Nov 16, 2026

Copy link
Copy Markdown
Collaborator

Follow-up review of 8d21526c4772e23884f7c10c7a0c946c11a4a029, Refs #224.

I independently verified the fixes for the three findings in my earlier review: latent continuation is separate from V2V, video-tool admission checks the prepared parameters, and exact global endpoint closures remain effective when model/operation facts are absent. The follow-up fixes for continuation upload counts, assistant token limits, and multi-image/pinned-reference selection also have passing coverage.

One new [P2] browser-CI integration defect remains:

  • manifest.json:3–14 registers input_admission_review.mjs and video_review_regressions.mjs in extendedFixture.
  • Both require creation_server.py --http-generation-fixture; the image/assistant workflow also requires --assistant-fixture.
  • The nightly runner starts this lane's API with only --assistant-fixture.

Using the nightly startup configuration, I reproduced immediate false !== true failures at input_admission_review.mjs:30 and video_review_regressions.mjs:36: health.httpGenerationFixture is false. Neither reaches its business assertions. With the required HTTP fixture enabled, both workflows pass in Chinese and English.

Please configure a separate HTTP-generation fixture service for these two workflows, enable the assistant fixture where required, and route them to its matching API/web URLs. Preserve the existing fixture service for scripts that expect the generic substitute provider. Also add a startup/manifest validation that checks required fixture flags against the runner's actual configuration: the current manifest check passes despite this mismatch.

Main integration: the earlier integration through b375cc3 is acknowledged, but main has advanced again. The current PR is still conflicting. Please resolve the latest conflicts, including src/backend/rules.ts, src/canvas/ModelServiceForm.tsx, src/contracts/generated.ts, and src/i18n/messages/en-US/models.ts; regenerate contracts from the combined definitions and rerun the affected checks.

Release checks: the current run already exists for this exact SHA but remains action_required, with zero test jobs. The workflow is configured for pull_request, pushes to main, and manual dispatch. After resolving conflicts and pushing the updated PR branch, the PR event should create a new run; a maintainer with write access should review and approve the fork workflow if GitHub requests approval. GitHub does not run pull_request workflows while merge conflicts remain. See fork workflow approval and workflow troubleshooting. Please obtain complete Release checks results on the updated PR revision; a manual run of main does not validate the fork's updated PR merge.

Validation I observed on this tip: 412 related Python tests and all 850 frontend tests passed, along with the production build, contracts, import boundaries, and i18n/browser static checks. Both new bilingual browser workflows passed with their required fixture configuration and failed with the current nightly configuration. Models were substituted by local services; this is not real-provider or full Release checks evidence.

My recommendation remains REQUEST CHANGES until the fixture integration is fixed, the latest conflicts are resolved, and complete CI passes on the resulting tip.

@allendyu
allendyu requested a review from wuzhf9 November 16, 2026 03:04
wuzhf9 pushed a commit that referenced this pull request Nov 16, 2026
…ds (#278)

* feat(contract): stage/route capability mapping table

* fix(contract): key the table by (operation, profile) per upstream vocabulary

vllm-omni#10102 publishes six operations and twelve profiles; `stages[]` is
deployment topology (`id`/`type`/`depends_on`, numeric strings, the same full
list for every model) and a route cannot separate the three profiles that share
`/v1/audio/speech`.  The table is therefore keyed by (operation, profile), with
OPERATION_ROUTES kept as the ownership check that reports `route_mismatch`.

- OPERATION_PROFILES replaces STAGE_ROUTES, covering all twelve profiles
- capabilities are available only on a supported profile in an enabled
  operation; `missing` needs positive evidence, everything else stays `unknown`
- segmentations/depth keep a route but no operation, so image.segment,
  video.matting and video.motion_capture are `unknown` with `no_upstream_profile`
- `asr` reports `unmapped_stage`: upstream publishes no recognition operation
- fixtures follow the real response shape; five regressions pin the pairs,
  the shared speech path, topology-only stages and absent fields

* fix(contract): separate states, validate transport/method, make fixtures schema-valid

Round-2 fixes for the three independent reviews of #278.

Product decisions (P1-P5):
- P1: image_response / audio_response no longer map to text.chat; they stay
  unknown with no_local_capability, since text.chat is served by a text-only
  adapter and an image-only deployment must not read as able to chat.
- P2: text_to_audio (audio_generation, /v1/audio/generate) maps to audio.music
  alongside lyrics_to_music; the StableAudio/LTX2-t2a shape no longer reads
  audio.music as missing.
- P3: support=unsupported and exposure=disabled stay "missing" but are told
  apart: resolve() now returns a `reasons` map (unsupported /
  endpoint_disabled / route_disabled) instead of dropping reason_code.
- P4: profiles[*].routes[*].exposure is read: all routes disabled -> missing +
  route_disabled, all unknown or routes: [] -> unknown, one enabled -> available.
- P5: one unrecognised route no longer voids a profile that answered; only when
  nothing usable remains does it fall to unknown.

Contract and implementation (I1-I3):
- I1: OPERATION_ROUTES is (transport, method, path); _check_route compares all
  three, so DELETE /v1/chat/completions and a websocket-declared http route are
  route_mismatch.
- I2: endpoint distinguishes absent (no answer: None, no models, models not a
  list) from empty (answered, no operation declared) from present.
- I3: the unreachable `item in UNROUTED` branch is deleted; unrouted ids never
  collect evidence, and the disjointness invariant is enforced by
  test_every_capability_id_is_routed_or_explained instead of dead runtime code.
  Malformed routes and supported profiles with no route are now reported
  (malformed_route / no_route_declared) instead of silently unknown.

Fixtures (F1-F3):
- All three fixtures are upstream-shaped: six operations per model, support and
  exposure on every operation, profile support present, profiles: [] instead of
  a missing key, image_response/audio_response outputs ["image"]/["audio"].
- Defensive shapes (asr key, misplaced profile, absent required support) moved
  out of the fixtures into the tests that defend against malformed input.
- test_fixtures_are_schema_valid asserts upstream's structural invariants only.
- exclude_none is described correctly (it drops None-valued optional fields such
  as `request`; default_factory lists serialize as []).

Tests (T1-T5):
- The tautological order assertion is now a literal vocabulary list, and the
  twelve pairs are literal too instead of an echo of OPERATION_PROFILES.
- test_a_profile_without_support_is_unknown_even_when_its_operation_is_supported
  covers profile-level absence (old N4 mutant now dies).
- test_a_profile_that_declares_no_route_is_unknown covers `supported + routes: []`
  (old M7/P3 mutant now dies).
- New cases: profile routes all disabled / all unknown, one unknown route does
  not void a profile, DELETE and websocket mismatches, image-only chat, text_to_audio
  -> audio.music, absent vs empty endpoints, reason separation, non-dict operation
  values, profile order independence.
- UNROUTED expectations are a literal table, not recomputed from the constant.

Docs (D1-D2):
- Corrected the exclude_none claim and the audio.score / /v1/audio/transcriptions
  statement (the capabilities body never publishes that path, so audio.score can
  only be unknown).
- Added the status/reason mapping table (CN + EN) covering every declaration
  shape, plus the profile/route/profile-output tables.

Tests: 60 passed (was 40); related subset 122 passed, 1 skipped. Nine mutations
of the new rules (including removing route_disabled) all fail the suite.

* fix(contract): keep audio_generation local-unknown, align required_inputs with upstream

* fix(contract): fixture construction invariants and unrecognised-route exposure cases

* fix(contract): fixtures obey the realtime-exposure rule, gate now asserts it

`/v1/realtime/video` is the one route whose exposure upstream rewrites:
`entrypoints/openai/serving_capabilities.py:342-347` forces `disabled` when
the profile's `required_inputs` intersect `{video, audio}` and otherwise keeps
the route's own value. Three fixture rows disagreed with that rule:

- full/`image_to_video` (`text`,`image`) carried `disabled` -> `enabled`
- partial/`mixed-operations`/`image_to_video` same
- partial/`unknown-enums`/`video_to_video` (`video`) carried `unknown` ->
  `disabled` (the override is unconditional on the route's own value)

`test_fixtures_obey_upstream_construction_invariants` claimed in its docstring
to pin this rule but only checked route-key sets, so the drift went unseen. It
now asserts the rule itself plus same-path exposure consistency inside one
operation; reverting any of the three rows turns it red (verified).

Resolution output is unchanged by these rows: no `expected` block moved.
Docs/PR body refreshed: upstream is now `43ff7b9` (vocabulary byte-identical to
`d1104f8`), test/doc counts and line references re-measured.

* fix(contract): map each video profile to the id its request shape serves

text_to_video / image_to_video / video_to_video are three different request
shapes in VllmOmniVideo (no reference + task=t2va, input_reference + task=fl2va,
source_video + masks). Folding all three onto video.generate left
video.first_frame and video.edit permanently unknown, so an image-to-video-only
deployment read as able to do text-to-video.

Add candidates_for() as the reverse index over the same table so a caller
starting from a local capability id does not need a second vocabulary, and say
explicitly that resolve() is catalogue-level: it never authorises a request.

Document that a top-level route is what upstream aggregates exposure from, so a
top-level disabled route closes the operation and no profile can reopen it.

* docs(contract): cite line numbers that exist on main

VllmOmniMusic / OpenAIChat moved with main, and application/model_availability.py
only exists on #266, so evidence has to point at application/tool_tasks.py:362
for the capability a request selects, plus #266 for its own request table.

* docs(contract): correct citations and the narrowing claim

An independent pass found stale line numbers (VllmOmniMusic, VllmOmniScore),
a count that mixed UNROUTED with no_upstream_profile, a branch-local path in
#266's section, and a prescription ("keep the top level enabled, disable the
profile route") that this projection cannot emit: profile routes copy the
top-level exposure except on /v1/realtime/video. Say that instead.

* docs(contract): keep the contract doc in English only

The bilingual file carried the same tables twice and the two halves had already
drifted (a count wrong in one, a citation wrong in the other). Keep the English
half, promote its headings, and drop the duplicate from the doc-pin test: the
pinning is upstream literal table <-> doc table <-> fixtures, which does not
need a translation to be checked against.

* fix(contract): gate the narrow video ids on declared input roles

A modality-level profile does not prove a narrower tool: VACE hands the image
to reference_images, SeedVR2 declares V2V without latent-mask editing, and H3's
resolver marks V2V unsupported. REQUIRED_ROLES plus declared_roles() keep
video.first_frame / video.edit unknown unless one of the profile's own open
routes names the role with support=supported, reported as role_not_declared.

Two fixture cases pin the counterexamples, and the structural check now accepts
the optional route-level request instead of rejecting a body upstream emits.

* fix(contract): count roles only on this operation's open routes

A role declared on a closed route, or on a path the operation does not own, is
not evidence: filter by exposure and ownership, and read only the route
reference (upstream's projection already copies the profile-level constraints
into it, so reading the profile again would re-add what a route narrowed).

Fixtures now carry the request shape the projection emits (profile-level base
inputs, last_frame unsupported, the four transport parameters), the structural
guard asserts that shape, and a unit test proves the guard bites.

* docs(contract): name the per-route scope the gate does not decide

The gate answers whether a profile's own open routes name the role, not which
route a request will take; that stays #266's per-request check.

* fix(contract): decide required roles per route and keep a refusal distinct

A required role gathered from a different route is not a request: an edit
call leaves on /v1/videos or on /v1/videos/sync, so source_video on one and
the two noise masks on the other used to read as available while neither
route would accept the call. Support is now decided per route and per
capability, so a gated id can no longer lend its verdict to an ungated one
in the same row.

A document that has decided every required role on every open route and
still offers no complete one is a positive no — one role refused everywhere,
or two routes each refusing a different role — and resolves to
missing/unsupported instead of unknown/role_not_declared. Silence, an
undecided support value, an owned route whose exposure cannot be read and an
unplaceable route left enabled all keep it unknown.

Signed-off-by: Xingkai98 <xingkai98@126.com>

* fix(contract): read the whole declaration inside the role gate

A three-argument role_verdict() used to judge one profile differently from
resolve(), which passed the unplaceable routes in separately: the same
declaration read missing when called directly and unknown inside the
report. The gate now reads those routes itself, so the public call and the
catalogue result cannot disagree, and the extra parameter is gone.

Also pins the remaining wording gaps the review found: the module rule and
the doc table now say at least one route has to be open, and the doc tells a
caller to ask role_verdict() instead of re-deriving the rule.

Signed-off-by: Xingkai98 <xingkai98@126.com>

* fix(contract): a malformed route reference is not a channel

A reference with no usable path was classified as an unplaceable route by
the role gate while _route_exposures() reports it as malformed_route and
keeps it out of the reachability decision, so one broken reference could
turn a refusal into unknown. The gate now skips it the same way.

Also pins the gate against resolve() with a parametrised consistency case
set, and splits the boundary assertions (bare role string, undecided route,
unplaceable route) out of one long test so each rule has its own guard.

Signed-off-by: Xingkai98 <xingkai98@126.com>

* fix(contract): honour count bounds, per-route refusals and the protocol envelope

- read `min_count`/`max_count` beside `support`: a window that cannot admit
  the single item the tool sends is a refusal (`missing` with `unsupported`),
  and a bound that is not a whole number leaves the entry undecided
- a route refusing one required role is out of the running whatever it leaves
  unmentioned, so every open route refusing at least one is `no` instead of
  `unknown`; undecided and unplaceable alternatives still keep `unknown`
- refuse a body whose `object`/`schema_version` names another contract:
  `endpoint="unreadable"`, neither `models` nor `stages` read, one
  `unsupported_format` note; `declarations()` applies the same gate
- `missing` now needs every model to say no, and a `models[]` element listing
  no operation is reported as `malformed_model` instead of being dropped
- docs: rule paragraphs, state table, reason list (eleven codes), endpoint
  states and the regression inventory

* fix(contract): validate count bounds and read only the postable route as evidence

Count bounds now validate domain as well as type: a negative whole number, a
fractional value, a bool and a numeric string are unreadable, and a window whose
`min_count` exceeds its `max_count` decides nothing. An unreadable bound can
neither grant a role nor turn it into a refusal, so the id follows the rest of
the declaration; `max_count: 0` and `min_count: 2` stay genuine refusals, and an
explicit `support: unsupported` still refuses whatever its counts say.

The same review found three places where an unreadable or unpostable declaration
was read in the permissive direction, so the table now:

- counts only the route this adapter actually posts as evidence
  (`POSTABLE_ROUTES`); `/v1/videos/sync`, the websocket route and another
  operation's paths are reported, never decisive
- reads `transport` as upstream's default only when the key is absent; a present
  but unreadable `transport`, `method` or `path` is `malformed_route`
- normalizes `support`/`exposure` at the route, profile and operation levels and
  normalizes published ids in all three readers

That last tightening needs three reasons: `exposure_unknown` for a postable
route whose exposure is absent or unreadable, `malformed_profile` for a profile
element that cannot be read, and `malformed_operation` for an operation value
that is not an object. Notes that explain a verdict are now emitted after the
cross-model aggregate, and only for a pair that still has an `unknown` id.

Verification: tests/test_capability_contract.py 147 passed; full local run 1761
passed / 1 failed / 100 skipped, the failure being
test_cancel_native_process_group[default], which fails identically on the parent
commit and needs a real agent CLI.

* docs(contract): state the postable-only rule everywhere and pin it

The status table, the role-gate exception and the "two boundaries to keep"
paragraph still prescribed `unknown` for a case the resolver decides as
`missing` with `route_disabled`: a profile whose postable route is disabled
beside an enabled route this table cannot place. The resolver moved to
`POSTABLE_ROUTES`; the prose did not follow.

- Rewrite the affected rows and paragraphs: an unplaceable route is a
  diagnostic only, and only an absent, unreadable or literal `unknown`
  exposure on a postable route keeps a verdict undecided.
- State the precondition every status row is read under (profile supported,
  operation supported + enabled) and scope `no_local_capability` to an open
  postable route, like every other profile-level note.
- Add a regression built from the documented table case: disabled
  `/v1/videos` beside an enabled unknown path, the sync and socket variants
  under every exposure, the open-route control, the role-gated neighbours
  and the `no_local_capability` pair.
- Pin the two rule sections and the `REQUIRED_ROLES` paragraph against
  `tests/fixtures/omni-capabilities/contract-rule.txt`, compared whole: an
  edit to either side turns the contract test red, so prose and resolver
  cannot drift apart unseen.

Module changes are docstrings only; resolver behaviour is unchanged.

* docs(contract): check the role vocabulary against vllm-omni 12d834c2

`vllm-omni` `b934b642` (head `12d834c2`) now publishes the four request roles
this table's `REQUIRED_ROLES` names, and the paragraph that introduced them
still said upstream published no such role — so it prescribed `unknown` for
declarations that now exist and are decidable.

- State what the tree declares: Wan I2V `first_frame` supported with
  `min_count: 0` / `max_count: 1` beside a required `image` whose counts are not
  additive; both VACE architectures `first_frame` `unsupported` with
  `max_count: 0`; the three editing roles supported `0..1` where the handler
  takes latent masks and `unsupported` `max_count: 0` where it does not.
- State the statuses that follow from the existing gate — `available` on Wan
  I2V, `missing` with `unsupported` on VACE and on a refusing V2V profile,
  `unknown` where the profile's own support is `unknown` — with no module
  change, because the gate reads the declaration rather than a role list.
- Add a test built from those four declarations, citing the upstream test
  anchors rather than prose, and regenerate the pinned copy of the sections in
  the same commit as the prose it pins.

The module change is a comment above `REQUIRED_ROLES`; behaviour is unchanged.

---------

Signed-off-by: Xingkai98 <xingkai98@126.com>
Co-authored-by: OpenDirector Bot <bot@opendirector.local>
@bread-lxy

Copy link
Copy Markdown
Author

@wuzhf9 Thank you for rechecking the earlier fixes.

  • Browser CI (ef1c0c7): The two new tests were assigned to a server without the HTTP-generation mode they require. They now use a separate server with the required options, and their web frontend connects to that server. Existing tests keep their original server. A startup check verifies the service modes and web connection before either group runs.

  • Main conflicts (a092141): Merged main through c2ced6c, resolved all four conflicts and regenerated contracts. The merge retains upstream's CogVideoX-3 support and prompts supplied by text references, together with feat(providers): discover capabilities and validate generation inputs #266's capability checks.

Using the startup commands and URLs from nightly.yml, I completed both new browser workflows and all four existing fixture workflows. Deliberately connecting the new tests to the original server produces a clear startup rejection. The merge regression also confirms that text-supplied prompts still obey image-count limits and route closures. On this revision, 865 frontend and 832 related Python tests passed; five POSIX-only storage tests were skipped on Windows.

Could a maintainer approve the updated PR's Release checks run if GitHub requests approval? Once the complete checks finish, could you re-review this revision? Thank you.

@kunkunblueberry

Copy link
Copy Markdown
Collaborator

One question before I look at CI, about two files rather than the behaviour.

a0921413 merges main through c2ced6c, which brings in domain/capability_contract.py from #278. But git grep capability_contract pr-266 -- '*.py' finds no production caller on this branch, and the blob is byte-identical to main's (5d6a3e5a) — it arrived with the merge, it is not used. #266 instead does the same job with its own pieces:

Job #278 (now on main) #266 (this branch)
parse omni.capabilities domain/capability_contract.py, hand-written dict parsing, 1334 lines domain/omni_capabilities.py, pydantic models, 121 lines
required roles for video.first_frame / video.edit REQUIRED_ROLES hardcoded at application/model_availability.py:144-145, same two sets
role vocabulary inside the module domain/request_constraints.py:7-9 INPUT_ROLES
fixtures tests/fixtures/omni-capabilities/ tests/fixtures/omni_capabilities/ (underscore, 5 separate files)

So: what is the intended relationship between omni_capabilities.py and capability_contract.py? Three shapes I can see, and I do not know which you and @Xingkai98 agreed on:

  1. Deliberate split — pydantic strict validation at the HTTP boundary, tolerant parsing for catalogue decisions, and [feat] provider: wire the capability contract into the vLLM-Omni precheck path #340 wires the latter into prepare_inputs. Then the duplicated role constants are still a hazard and should collapse to one source.
  2. feat(providers): discover capabilities and validate generation inputs #266 should use capability_contract.resolve() and omni_capabilities.py is transitional — then [feat] provider: wire the capability contract into the vLLM-Omni precheck path #340 and this PR overlap and one of them should be rewritten.
  3. Both are needed and [feat] provider: wire the capability contract into the vLLM-Omni precheck path #340 is now obsolete.

Asking rather than asserting, because there is a concrete divergence already, not just duplication. request_constraints.py:22 treats only max_count == 0 as a refusal, and :24 requires every role support == 'supported'. capability_contract also refuses on min_count above one item, and additionally requires the whole role set on a single open postable route — its docs are explicit that roles split across /v1/videos and /v1/videos/sync count for nothing. On a declaration with first_frame: {min_count: 2} the two would answer differently; #266 reads it as no limit, the contract reads it as missing.

If (1) is the plan, say so and I will only ask for the constants to be shared. If (2), I will hold this PR until the overlap is resolved — either way I am not treating it as a defect yet, since nothing here reaches the resolver.

CI: I can trigger the fork run on a0921413 — I did it for #278 (run 43371926745, attempt 2). Say whether you want that before or after answering the above; I would rather not burn a green run on a head whose shape may change.

@kunkunblueberry

Copy link
Copy Markdown
Collaborator

Small correction to my previous comment: I ran the comparison instead of describing it as a guess. On this head (a0921413) both functions are importable, so I called them on the same declaration.

case                                                     #266 role_evidence      #278 resolve
------------------------------------------------------------------------------------------------
min_count=2 on first_frame (one route)                   None                    missing/unsupported
max_count=0 on first_frame                               input_count_unsupported missing/unsupported
first_frame supported, no bound                          None                    available
all three edit roles supported, no bound                 None                    available

So the two already disagree on a live case rather than only duplicating code: #266's role_evidence returns None — no objection — for first_frame: {support: "supported", min_count: 2}, while capability_contract.resolve() reads that same window as missing with reason unsupported, because the tool sends one item and a minimum of two cannot be met. role_evidence checks support == 'unsupported' and max_count == 0 (request_constraints.py:20-23) but never looks at min_count.

Whether that matters depends on the answer to the question in my previous comment:

Roles split across two routes also answer differently by construction: resolve() returns unknown because it requires one open postable route carrying the whole set, while role_evidence only ever sees the single route the caller passes in, so its answer is whatever that route says.

Not filing this as a finding yet — it is the same question about intended shape, now with a concrete example attached.

@github-actions github-actions Bot added the area:ci Continuous integration and checks label Nov 16, 2026
@github-actions
github-actions Bot requested a review from wangtiance November 16, 2026 08:01
@bread-lxy

Copy link
Copy Markdown
Author

@kunkunblueberry Thank you for checking the two implementations, running the comparison cases, and offering to start CI.

Responsibilities of #266 and #278

The division follows the earlier agreement with Xingkai98:

  • capability_contract.py from feat(contract): map (operation, profile) declarations to capability ids #278 maintains the shared operation/profile mappings and the input roles each tool requires. Its tolerant parser and resolve() serve deployment-wide catalogue summaries.
  • omni_capabilities.py from feat(providers): discover capabilities and validate generation inputs #266 strictly validates the structure and fields of the HTTP response. The application service then checks the selected model and the request the adapter will actually send, including its route, inputs, outputs and parameters. Declaration expiry, endpoint closure and pause checks remain here. It uses the shared mappings and required roles, while retaining these request checks; another model's or route's support cannot authorize the current request.

Changes and verification

  1. You pointed out that feat(contract): map (operation, profile) declarations to capability ids #278 had arrived through the main merge but was not being called, while feat(providers): discover capabilities and validate generation inputs #266 still maintained duplicate definitions. In 15c163e, tool_request() now reads candidates_for() and required_roles_for(), and the duplicate mapping and required-role sets have been removed. It still selects an operation/profile pair that matches the adapter's actual request. Tests confirm that another model's support does not allow a request rejected for the selected model.

  2. For first_frame.min_count=2, your observation that role_evidence() returns no refusal is correct. That function checks input-role support; the full flow has a separate check of the actual quantity. I checked the one-image request on a092141: the catalogue marks the tool unavailable, and the API rejects submission with no task created and no generation request sent to the model service. In 236ee53, I added regressions for both paths to preserve this behaviour. I also improved the refusal message: instead of asking the user to add an image they already supplied, it now states that at least two are required and the request provides one, in both languages.

  3. For your split-route example, the checks use only the interface that the request will call. A source-video declaration on one interface and mask declarations on another are not combined into editing support; the result stays unknown. The new regressions cover this alongside a complete declaration, max_count=0, and expired declarations.

The bilingual browser checks confirm that the count refusal preserves the draft and source image. After the service restriction is removed, the same input can generate successfully. The module responsibilities and check order are documented in docs/architecture/capability-contract.md.

Could you approve Release checks on 236ee53 and review these changes? Thank you.

@kunkunblueberry

Copy link
Copy Markdown
Collaborator

Thanks — and a correction that is mine, not yours.

My comparison overstated the divergence

I said min_count: 2 was "a real hole" because role_evidence() returns None. That was wrong, and your description is the accurate one: decision() already composes two checks, and I compared only one of them against resolve(). At a0921413, model_availability.py:329 already called constraint_failure(...) and request_constraints.py:46 already tested count < min_count. So the flow did refuse — I isolated a helper, found it silent, and reported that as if it were the decision.

What was actually wrong at a0921413 is narrower and you fixed both halves of it:

  • details = {'input': 'first_frame', 'minimum': 2, 'actual': 1} has no 'inputs' key, so the old message fell through to 请添加{name}。 — telling the user to add a first frame when they had just supplied one. The new :88-89 branch says at least two are required and one was provided.
  • No regression covered that window. tests/test_capability_contract_integration.py:100-107 now pins minimum_two, maximum_zero, complete, split_routes and missing_roles, each parametrised over actual=False/True, and :140-143 asserts require() raises capability_unavailable rather than only reading decision().

The duplication is gone, and the split now holds

15c163e does what I asked for. tool_request() at :137-148 reads capability_contract.candidates_for() and required_roles_for(), and the local copies are removed — the old {...'video.first_frame': 'image_to_video'...} dict and the frozenset({'first_frame'}) / frozenset({'source_video', ...}) pair are both gone. I checked the shared readers answer the same way:

required_roles_for('video.first_frame') = ('first_frame',)
required_roles_for('video.edit')        = ('source_video', 'video_noise_mask', 'audio_noise_mask')
candidates_for('video.first_frame')     = (('video_generation', 'image_to_video'),)

The profile names still written in requests_for() (:56-59) and generation_request() (:80-82) are the adapter's own wire shapes, not the capability mapping, so keeping them local is right.

I also re-ran the count check directly on this head:

min_count=2, one supplied   -> ('required_inputs_missing', {minimum: 2, actual: 1})
min_count=2, two supplied   -> None
max_count=0, one supplied   -> ('input_count_exceeded', {maximum: 0, actual: 1})
no bound, one supplied      -> None

And on the shape: two parsers is defensible now that the mapping and role sets are shared — strict pydantic validation of the response in omni_capabilities.py, tolerant catalogue reading in capability_contract.py, with one source for the ids. That is option 1 from my earlier comment and it answers my question.

tests/test_capability_contract.py: 149 passed on this head. zh-CN/en-US errors.ts key sets are identical (680 each, no drift), and errors.capability.minimumInputCount exists in both with the same placeholders.

CI

Approved — run 43827896440 is now executing on 236ee536 (attempt 2, triggered by me). I merged main's state into my own clone to check the two things that bit earlier PRs: the branch is 0 commits behind and merge-tree is clean, so no rebase is needed behind this run.

I will look at the result and approve if it is green. Two nits, no action needed for this round: tests/fixtures/omni-capabilities/ (from #278) and tests/fixtures/omni_capabilities/ (yours) differ only by a hyphen, which makes the two suites easy to confuse; and role_evidence's docstring now correctly says constraint_failure owns quantities, which is the kind of note that would have saved me the hour I spent on the wrong conclusion.

@kunkunblueberry

Copy link
Copy Markdown
Collaborator

CI on 236ee536 is red — run 43827896440, attempt 2. Two lanes failed, and both look like regressions on this head rather than inherited flakes, because main's identical lanes are green on c2ced6c9 (run 43796562744, all seven jobs success).

1. checks / browser (isolated) — minimax h3 fails

=== minimax h3: tests/browser/minimax_h3.mjs ===
tests/browser/minimax_h3.mjs:68
      if (attempt === 149) throw Error(await page.locator("body").innerText());
Error: first.png
FAIL minimax h3 (exit 1, 19.1s)

On main the same script is PASS minimax h3 (7.8s). The failure is at minimax_h3.mjs:65-70: after uploading first.png it polls for canvasItems.length === 1 for 15 s and never sees the item; the dumped body text is only first.png.

The likely cause is the interaction with your own creation_server.py change, and it is worth checking before anything else. You set capability_auto_check=False on the configs the fixture server seeds (creation_server.py:39-52), with the comment that they have no HTTP capability service and must not occupy the bounded query workers. But minimax_h3.mjs:30-38 creates its MiniMax-H3 config through /api/model-configs/batch, which does not pass capability_auto_check, and model_configs.py:130 falls back to the existing value — None for a new record. So that config keeps automatic checking on while pointing at https://fixture.invalid/v2, which cannot resolve. Six other isolated scripts that create configs the same way would be in the same position.

Either the fixture server should be able to answer the capability query for test-created configs, or the scripts that create them need the same explicit opt-out you gave the seeded ones.

2. checks / python — test_self_hosted_proxy fails

FAILED tests/test_self_hosted_proxy.py::test_all_model_kinds_submit_resume_and_cancel_use_direct_connection
opendirector.domain.generation.GenerationError: 生成服务返回了无法识别或不完整的结果。

It fails at test_self_hosted_proxy.py:109, the first provider.generate(video_config, task, submitted) in the loop over ('FastH3-Omni-3090', 'MiniMaxAI/MiniMax-H3'). Main passes this test; the file is untouched by this PR, but the path it drives is not — integrations/model_adapters.py is +180/−56 here and adds constraint validation to the video serialization path. I have not isolated which change turns the mocked POST into "submission unknown", so treat that as a starting point rather than a diagnosis.

Check full layer inventory then fails as a consequence (PR representative execution is missing, skipped or failed), not on its own.

Neither failure is on the known-flake list in docs/development/ci-failures.md; the one entry there is test_self_hosted.py::test_video_reference_acceptance_follows_model_rules, a different file.

So

I am not approving yet. The rest of what I checked above still stands — the shared mapping is wired, the count refusal is correct, the message and both locales are right — this is the CI evidence saying something in the request path changed. When you push a fix I will approve the new run myself; the approval endpoint works for me (attempt 2 on this one was my click, triggering_actor=kunkunblueberry).

One correction to my previous comment: I wrote that I "merged main's state into my own clone". I did not merge anything — I used a read-only git merge-tree against origin/main plus git rev-list --count, which is why I could report 0 commits behind and a clean tree without touching the branch. The conclusion was right; the sentence was sloppy.

@kunkunblueberry

Copy link
Copy Markdown
Collaborator

Correction to the first item in my previous comment — the cause I suggested is wrong, and the scope number was wrong too. Please do not chase it.

capability_probe.py:44 decides this:

def automatic(config):
    return config.get('capabilityAutoCheck', config.get('connectionType') == 'self_hosted')

minimax_h3.mjs:30-38 saves its config with connectionType: "api", so capabilityAutoCheck is absent and the default is False — automatic capability checking is already off for it. The capability_auto_check=False you added to the seeded configs is the opposite case: those are self_hosted, where the default is True.

The scope was also wrong: four gate-lane scripts POST model configs without that flag, not six, and three of the four passed on this run (provider_settings, reference_reconnect, voice_library). Only minimax_h3 failed.

What I can state from the log instead:

  • The script fails at minimax_h3.mjs:65-70 — after setInputFiles, it polls /api/creation/projects/<id> for canvasItems.length === 1 for 15 s and never sees the item.
  • The dumped body text is only first.png, so the page rendered essentially nothing beyond the file name.
  • In the printed service logs for that window there is no 4xx/5xx at all; the only non-200 is GET /api/creation/projects/<id>/receipts/<uuid> → 404, which is the normal "receipt not accepted" read. So the failure is not a rejected request the test could have surfaced — something stopped the item from being created, or the page from getting that far.
  • Nothing was found for POST .../assets, but that endpoint name appears nowhere in the successful scripts either, so its absence tells us nothing.

I cannot narrow it further from the log, and I am not going to guess twice. The isolated lane's Print isolated service logs on failure output is what I worked from; a local run of just tests/browser/minimax_h3.mjs against the isolated server should show whether the client ever issues the create command.

The second failure (test_self_hosted_proxy.py:109, submission unknown on the mocked vLLM-Omni submit) is unrelated to any of the above and still stands as reported.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

area:agent Agent runtime, assistant chat and tools area:canvas Canvas, nodes and direct manipulation area:ci Continuous integration and checks area:docs Documentation / 文档 area:i18n Localisation and bilingual UI area:provider Model providers and generation protocols type:feat New capability or behaviour

Projects

None yet

Development

Successfully merging this pull request may close these issues.

6 participants