Repository navigation
Conversation
## 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.
|
@wuzhf9 Thank you for the concrete reproduction cases. I have addressed the three findings:
I also merged main at @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 |
There was a problem hiding this comment.
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 thenativeMaskgate requires white=edit / black=preserve / binarize=0.5 / same size / multiple_of before enabling anything; - a missing document stays
unknown, and onlyunavailablerejects 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.
| ).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; |
There was a problem hiding this comment.
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.
| 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) |
There was a problem hiding this comment.
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( |
There was a problem hiding this comment.
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.
|
@wuli666 Thank you for the review. I have addressed the three findings:
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. |
|
Hi @bread-lxy — checking in on #266 before I start V1. It shows as conflicting with main, and it touches |
|
@Xingkai98 Thanks for checking before starting V1.
The overlapping form changes are the 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. |
|
@wuzhf9 @wuli666 I have merged main through
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. |
|
Follow-up review of 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:
Using the nightly startup configuration, I reproduced immediate 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 Release checks: the current run already exists for this exact SHA but remains 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. |
…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>
|
@wuzhf9 Thank you for rechecking the earlier fixes.
Using the startup commands and URLs from 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. |
|
One question before I look at CI, about two files rather than the behaviour.
So: what is the intended relationship between
Asking rather than asserting, because there is a concrete divergence already, not just duplication. 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 |
|
Small correction to my previous comment: I ran the comparison instead of describing it as a guess. On this head ( So the two already disagree on a live case rather than only duplicating code: Whether that matters depends on the answer to the question in my previous comment:
Roles split across two routes also answer differently by construction: Not filing this as a finding yet — it is the same question about intended shape, now with a concrete example attached. |
|
@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:
Changes and verification
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 Could you approve Release checks on |
|
Thanks — and a correction that is mine, not yours. My comparison overstated the divergenceI said What was actually wrong at
The duplication is gone, and the split now holds
The profile names still written in I also re-ran the count check directly on this head: And on the shape: two parsers is defensible now that the mapping and role sets are shared — strict pydantic validation of the response in
CIApproved — run 43827896440 is now executing on I will look at the result and approve if it is green. Two nits, no action needed for this round: |
|
CI on 1.
|
|
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.
def automatic(config):
return config.get('capabilityAutoCheck', config.get('connectionType') == 'self_hosted')
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 ( What I can state from the log instead:
I cannot narrow it further from the log, and I am not going to guess twice. The isolated lane's The second failure ( |
Summary
Discover optional model capabilities before submitting work, and explain incompatible requests without discarding the user's configuration, inputs or selections.
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 code745222c.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.mjsandtests/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:
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-CNanden-USwere 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.