GenarrativeAI/Genarrative
11
0
Fork 0
Code Issues 14 Pull Requests 3 Actions Packages Projects 3 Releases Wiki Activity

合并主分支并解决画布生成冲突

Browse Source 
同步主分支的角色动作序列、精选展示与外部编辑器契约更新
保留画布生成输入 V2 契约并合并视频、音效时长元数据
修复精选视频对数值型 V2 时长元数据的兼容
This commit is contained in:
王德宇
2026-08-06 17:09:39 +08:00
parent aec9b61121 a03f13d0a5
commit 291724a984
155 changed files with 15531 additions and 1737 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.codex/skills/genarrative-external-editor-api/SKILL.md
+3 -1
View File
@@ -32,7 +32,7 @@ Prefer `scripts/genarrative_external_api.py` for runnable REST calls. It uses on
- Use stable references such as `objectKey`, project resource ID, or asset ID in generation requests. Use `/assets/read-url` only for temporary preview/download access.
- Preserve both warning channels after completion. A general `warning` can coexist with `sliceWarning`; do not discard either.
- Do not invent missing derivatives. A source-preserved warning means the main source remains usable but requested post-processing failed. A slice warning means the complete transparent sheet is usable but individual slices are absent.
- Keep generated artifacts in the canvas and asset library together. Character animation may need a post-completion library fallback from the first returned frame when no direct asset is present; the helper implements it.
- Keep generated artifacts in the canvas and asset library together. Character animation accepts `assetFolderId` and `assetLabel`; its completed result directly returns the final `assetKind="character-animation"` resource and asset with formal sequence fields. Do not create a duplicate first-frame record.
## Documentation Navigation
@@ -107,6 +107,8 @@ client.generate_image(
Helper convenience methods wait locally, but the server still uses short asynchronous submit/status requests. For durable caller-controlled orchestration, call `submit_generation`, persist its `operationId` and idempotency key, then call `get_generation` or `wait_for_generation`.
For character animation, pass the canvas session and asset label to `animate_character`. The helper submits asynchronously and returns the completed compact result containing the authoritative formal `resource` and `asset`; do not synthesize a library asset from the first frame.
## Guardrails
- Do not change the fixed production base URL in generated examples.
.codex/skills/genarrative-external-editor-api/references/api-operations.md
+3 -2
View File
@@ -46,7 +46,7 @@ Every generation row requires a stable `Idempotency-Key` header and returns HTTP
| Image edit/redraw | `/api/external/v1/editor/images/edits` | `prompt`, `sourceImageSrc` | `referenceImageSrcs`, `model`, `size`, `projectId`, `assetFolderId`, `assetLabel`, `sourceResourceId`, `targetLayerId`, `canvasCompletion` |
| Icon spritesheet | `/api/external/v1/editor/icon-spritesheets/generations` | `referenceImageSrc`, `iconDescriptions` | `style`, `referenceImageSrcs`, `screenColor`, `model`, `aspectRatio`, `imageSize`, `projectId`, `assetFolderId`, `assetLabel`, `canvasCompletion` |
| UI asset extraction | `/api/external/v1/editor/ui-designs/assets/extractions` | `sourceImageSrc`, `aspectRatio`, `imageSize` | `screenColor`, `model`, `referenceImageSrcs`, `projectId`, `assetFolderId`, `spritesheetLabel`, `canvasCompletion` |
| Character animation | `/api/external/v1/editor/character-animations/generations` | `sourceLayerId`, `sourceImageSrc`, `sourceWidth`, `sourceHeight`, `promptText`, `resolution`, `ratio`, `frameCount`, `durationSeconds`, `model` | `projectId`, `sourceResourceId`, `canvasCompletion` |
| Character animation | `/api/external/v1/editor/character-animations/generations` | `sourceLayerId`, `sourceImageSrc`, `sourceWidth`, `sourceHeight`, `promptText`, `resolution`, `ratio`, `frameCount`, `durationSeconds`, `model` | `projectId`, `sourceResourceId`, `assetFolderId`, `assetLabel`, `canvasCompletion` |
| Video generation | `/api/external/v1/editor/videos/generations` | `prompt`, `model`, `aspectRatio`, `durationSeconds`, `resolution`, `mode`, `sound` | `referenceImageSrcs`, `referenceVideoSrcs`, `referenceAudioSrcs`, `webSearchEnabled`, `projectId`, `assetFolderId`, `assetLabel`, `canvasCompletion` |
| Sound effect | `/api/external/v1/editor/audios/sound-effects/generations` | `prompt`, `duration` | `model`, `projectId`, `assetFolderId`, `assetLabel`, `canvasCompletion`, `generationInputs` |
| Background music | `/api/external/v1/editor/audios/background-music/generations` | `gptDescriptionPrompt`, `makeInstrumental` | `projectId`, `assetFolderId`, `assetLabel`, `canvasCompletion`, `generationInputs` |
@@ -64,7 +64,8 @@ Supply the `operationId` returned by submission. Poll no faster than `pollAfterM
- Pass `projectId` and `canvasCompletion` to write generated output into the canvas.
- Pass `assetFolderId` plus `assetLabel` for image, edit, icon spritesheet, video, sound effect, and BGM operations when supported.
- UI extraction uses `assetFolderId` and `spritesheetLabel`.
- Character animation does not accept the same library fields. If its completed compact result lacks a direct `asset`, create a library record from the first returned frame; do not duplicate one when an asset already exists.
- Character animation accepts `assetFolderId` and `assetLabel`. Its completed compact result directly returns the final `assetKind="character-animation"` resource and asset with `imageSequenceFrames` and `imageSequenceDurationMs`; never create a duplicate first-frame resource or asset.
- If a caller must manually create a `character-animation` resource or asset, put the authoritative frames and total sequence duration in `imageSequenceFrames` and `imageSequenceDurationMs`. Keep `generationInputs` replayable: it must not contain legacy runtime fields such as `characterAnimation`, `frames`, `previewVideoPath`, `frameCount`, `fps`, or `durationSeconds`.
- Reload project/library state after completion when full current state is required.
## Reference Field Mapping
.codex/skills/genarrative-external-editor-api/references/capability-routing.md
+1 -1
View File
@@ -20,7 +20,7 @@ Before the first generation in a new conversation, obtain a canvas name unless t
2. Read the asset library. Reuse a folder with the same label or create one with the canvas name.
3. Retain `canvasName`, `projectId`, `assetFolderId`, and the current art spec in conversation state.
Generated artifacts must enter both the current canvas and its same-name library folder whenever the endpoint supports that invariant. Pass `projectId`, `assetFolderId`, the endpoint's label field, and `canvasCompletion`. Character animation may return no direct library asset; after completion, create one from the first returned frame only when the compact result still lacks an asset.
Generated artifacts must enter both the current canvas and its same-name library folder whenever the endpoint supports that invariant. Pass `projectId`, `assetFolderId`, the endpoint's label field, and `canvasCompletion`. Character animation returns the final formal resource and asset directly; use those records and never create a duplicate from the first frame.
## Art Spec Routing
.codex/skills/genarrative-external-editor-api/references/requests-and-outputs.md
+6 -2
View File
@@ -98,7 +98,9 @@ A minimal `canvasCompletion` is:
`dialogId` is optional. Do not reconstruct canvas state from completion results. Reload the project and asset library when complete authoritative snapshots are needed.
Character animation may complete without a direct `asset` field. To preserve the canvas/library invariant, create a library asset from the first returned frame only if the compact result lacks one. Prefer `client.animate_character(..., canvasSession=session, canvasTitle="...")`, which implements this fallback.
Character animation accepts `assetFolderId` and `assetLabel` and persists the final transparent sequence directly. Its completed compact result includes the authoritative `assetKind="character-animation"` resource and asset with `imageSequenceFrames` and `imageSequenceDurationMs`. Use those records directly and never synthesize a duplicate asset from the first frame.
For the lower-level asset/resource creation endpoints, `generationInputs` is replayable request context rather than a media-runtime container. When `assetKind` is `character-animation`, the server rejects legacy runtime keys including `characterAnimation`, `frames`, `previewVideoPath`, `frameCount`, `fps`, and `durationSeconds`; send the formal sequence through `imageSequenceFrames` and `imageSequenceDurationMs`. Internal processing audit keys such as `screenColorHex`, `mattingProvider`, and `mattingModel` are removed before persistence.
## Art Spec and Image Request
@@ -178,7 +180,9 @@ For character animation from a local-only source, use actual dimensions and a st
"ratio": "9:16",
"frameCount": 40,
"durationSeconds": 5,
"model": "seedance2.0-fast"
"model": "seedance2.0-fast",
"assetFolderId": "<assetFolderId>",
"assetLabel": "角色呼吸动画"
}
```
.codex/skills/genarrative-external-editor-api/scripts/genarrative_external_api.py
+28 -32
View File
@@ -600,16 +600,14 @@ class GenarrativeExternalClient:
source_layer_id: str,
**fields: Any,
) -> Any:
session, asset_label = self._apply_canvas_session_fields(
self._apply_canvas_session_fields(
fields,
fields.get("canvasTitle", "角色动画"),
source_width,
source_height,
asset_label_field=None,
asset_label_field="assetLabel",
)
prompt_text = self._apply_art_spec(fields, prompt_text)
fields.pop("assetFolderId", None)
fields.pop("assetLabel", None)
idempotency_key = fields.pop("idempotencyKey", None)
body = {
"sourceLayerId": source_layer_id,
@@ -624,34 +622,11 @@ class GenarrativeExternalClient:
**fields,
"model": "seedance2.0-fast",
}
result = self.submit_and_wait_generation(
return self.submit_and_wait_generation(
"/api/external/v1/editor/character-animations/generations",
body,
idempotency_key=idempotency_key,
)
if isinstance(session, dict) and isinstance(result, dict) and not result.get("asset"):
frames = result.get("frames")
first_frame = frames[0] if isinstance(frames, list) and frames else None
folder_id = normalize_optional_text(session.get("assetFolderId"))
if isinstance(first_frame, dict) and folder_id:
asset = self.create_asset(
folder_id,
asset_label,
first_frame["imageSrc"],
int(first_frame["width"]),
int(first_frame["height"]),
prompt=result.get("prompt"),
model=result.get("model"),
provider="ark",
taskId=result.get("taskId"),
assetKind="character-animation",
generationInputs={
"frames": frames,
"previewVideoPath": result.get("previewVideoPath"),
},
)
result["asset"] = unwrap_envelope(asset).get("asset")
return result
def generate_video(self, prompt: str, **fields: Any) -> Any:
fields.pop("mode", None)
@@ -732,14 +707,31 @@ def _self_test() -> None:
"timeout": timeout,
"headers": headers,
})
if path == "/api/external/v1/editor/assets":
return {"asset": {"assetId": "editor-asset-demo"}}
generated = {
"taskId": "task-demo",
"model": "seedance2.0-fast",
"prompt": "角色呼吸",
"previewVideoPath": "/generated/preview.mp4",
"frames": [{"frameIndex": 1, "imageSrc": "/generated/frame01.png", "width": 512, "height": 768}],
"frames": [{"imageSrc": "/generated/frame01.png", "width": 512, "height": 768}],
"resource": {
"resourceId": "editor-resource-demo",
"assetKind": "character-animation",
"sourceResourceId": "editor-resource-preview-demo",
"imageSequenceFrames": [
{"imageSrc": "/generated/frame01.png", "width": 512, "height": 768},
{"imageSrc": "/generated/frame02.png", "width": 512, "height": 768},
],
"imageSequenceDurationMs": 4000,
},
"asset": {
"assetId": "editor-asset-demo",
"assetKind": "character-animation",
"imageSequenceFrames": [
{"imageSrc": "/generated/frame01.png", "width": 512, "height": 768},
{"imageSrc": "/generated/frame02.png", "width": 512, "height": 768},
],
"imageSequenceDurationMs": 4000,
},
}
if method == "POST":
return {"operationId": "task-operation-demo", "status": "queued", "pollAfterMs": 1}
@@ -760,10 +752,14 @@ def _self_test() -> None:
assert calls[0]["timeout"] == DEFAULT_REQUEST_TIMEOUT_SECONDS
assert calls[0]["headers"]["Idempotency-Key"]
assert calls[0]["body"]["projectId"] == "proj-demo"
assert calls[0]["body"]["assetFolderId"] == "editor-asset-folder-demo"
assert calls[0]["body"]["assetLabel"] == "角色呼吸动画"
assert calls[0]["body"]["canvasCompletion"]["title"] == "角色呼吸动画"
assert calls[1]["path"] == "/api/external/v1/generations/task-operation-demo"
assert calls[2]["path"] == "/api/external/v1/editor/assets"
assert result["asset"]["assetId"] == "editor-asset-demo"
assert result["asset"]["assetKind"] == "character-animation"
assert len(result["asset"]["imageSequenceFrames"]) == 2
assert result["asset"]["imageSequenceDurationMs"] == 4000
calls.clear()
client.generate_icon_spritesheet(
"editor-resource-spec",
apps/admin-web/src/api/adminApiTypes.ts
+12
View File
@@ -332,6 +332,14 @@ export interface AdminEditorAssetListQuery {
limit?: number | null;
}
export interface AdminEditorImageSequenceFramePayload {
imageSrc: string;
objectKey?: string | null;
assetObjectId?: string | null;
width: number;
height: number;
}
export interface AdminEditorAssetPayload {
assetId: string;
ownerUserId: string;
@@ -362,6 +370,8 @@ export interface AdminEditorAssetPayload {
taskGenerator: string;
taskCostMudPoints: number;
children: AdminEditorAssetPayload[];
imageSequenceFrames?: AdminEditorImageSequenceFramePayload[] | null;
imageSequenceDurationMs?: number | null;
}
export interface AdminEditorAssetListResponse {
@@ -413,6 +423,8 @@ export interface AdminEditorShowcaseAssetPayload {
rejectedAt?: string | null;
updatedAt: string;
showcaseCategory?: string | null;
imageSequenceFrames?: AdminEditorImageSequenceFramePayload[] | null;
imageSequenceDurationMs?: number | null;
}
export interface AdminEditorShowcaseListResponse {
apps/admin-web/src/components/AdminEditorAssetMedia.test.tsx
+354
View File
@@ -0,0 +1,354 @@
/* @vitest-environment jsdom */
import { act, fireEvent, render, screen, within } from '@testing-library/react';
import { afterEach, expect, test, vi } from 'vitest';
import { getAdminAssetReadUrl } from '../api/adminApiClient';
import { AdminEditorAssetPreviewDialog } from './AdminEditorAssetMedia';
vi.mock('../api/adminApiClient', () => ({
getAdminAssetReadUrl: vi.fn(),
isAdminApiError: vi.fn(
(error: unknown) =>
typeof error === 'object' &&
error !== null &&
'status' in error &&
typeof error.status === 'number',
),
}));
afterEach(() => {
vi.clearAllMocks();
vi.useRealTimers();
});
function createDeferred<T>() {
let resolve!: (value: T | PromiseLike<T>) => void;
let reject!: (reason?: unknown) => void;
const promise = new Promise<T>((resolvePromise, rejectPromise) => {
resolve = resolvePromise;
reject = rejectPromise;
});
return { promise, resolve, reject };
}
test('角色动作预览跨窗口回播时复用父级换签缓存并等待目标帧就绪', async () => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2026-07-04T10:50:00Z'));
const frameObjectKeys = [
'generated-animations/editor/task-cache/frame00.png',
'generated-animations/editor/task-cache/frame01.png',
'generated-animations/editor/task-cache/frame02.png',
'generated-animations/editor/task-cache/frame03.png',
'generated-animations/editor/task-cache/frame04.png',
] as const;
const delayedFrame = createDeferred<{
read: {
objectKey: string;
signedUrl: string;
expiresAt: string;
};
}>();
vi.mocked(getAdminAssetReadUrl).mockImplementation((_token, request) => {
const objectKey = request.objectKey ?? '';
if (objectKey === frameObjectKeys[3]) {
return delayedFrame.promise;
}
return Promise.resolve({
read: {
objectKey,
signedUrl: `https://signed.example.com/${objectKey}`,
expiresAt: '2026-07-04T11:00:00Z',
},
});
});
render(
<AdminEditorAssetPreviewDialog
entry={{
assetId: 'asset-character-animation-cache',
label: '缓存回播动作',
imageSrc: `/${frameObjectKeys[0]}`,
objectKey: frameObjectKeys[0],
assetKind: 'character-animation',
imageSequenceFrames: frameObjectKeys.map((objectKey) => ({
imageSrc: `/${objectKey}`,
objectKey,
width: 192,
height: 256,
})),
imageSequenceDurationMs: 500,
}}
token="admin-token"
onClose={vi.fn()}
/>,
);
const dialog = screen.getByRole('dialog', { name: '素材预览' });
fireEvent.click(within(dialog).getByRole('button', { name: '暂停角色动作' }));
await act(async () => {
await vi.advanceTimersByTimeAsync(120);
});
const initialFrames = Array.from(
dialog.querySelectorAll<HTMLImageElement>(
'.admin-asset-query-sequence-frame',
),
);
expect(initialFrames).toHaveLength(3);
initialFrames.forEach((frame) => fireEvent.load(frame));
fireEvent.click(within(dialog).getByRole('button', { name: '播放角色动作' }));
for (const elapsedMs of [100, 40, 60, 40, 60]) {
await act(async () => {
await vi.advanceTimersByTimeAsync(elapsedMs);
});
}
expect(getAdminAssetReadUrl).toHaveBeenCalledWith('admin-token', {
objectKey: frameObjectKeys[3],
expireSeconds: 300,
});
expect(resolveVisibleFrameSrc(dialog)).toBe(
`https://signed.example.com/${frameObjectKeys[2]}`,
);
await act(async () => {
delayedFrame.resolve({
read: {
objectKey: frameObjectKeys[3],
signedUrl: `https://signed.example.com/${frameObjectKeys[3]}`,
expiresAt: '2026-07-04T11:00:00Z',
},
});
await Promise.resolve();
});
const fourthFrame = resolveFrameByObjectKey(dialog, frameObjectKeys[3]);
expect(fourthFrame?.style.opacity).toBe('0');
expect(resolveVisibleFrameSrc(dialog)).toBe(
`https://signed.example.com/${frameObjectKeys[2]}`,
);
fireEvent.load(fourthFrame!);
fireEvent.load(resolveFrameByObjectKey(dialog, frameObjectKeys[4])!);
for (let index = 0; index < 3; index += 1) {
await act(async () => {
await vi.advanceTimersByTimeAsync(100);
});
}
expect(within(dialog).getByText('1/5')).toBeTruthy();
expect(resolveVisibleFrameSrc(dialog)).toBe(
`https://signed.example.com/${frameObjectKeys[0]}`,
);
expect(
vi
.mocked(getAdminAssetReadUrl)
.mock.calls.filter(
([, request]) => request.objectKey === frameObjectKeys[0],
),
).toHaveLength(1);
expect(
dialog.querySelectorAll('.admin-asset-query-sequence-frame').length,
).toBeLessThanOrEqual(3);
});
test('角色动作预览打开超过五分钟后回绕播放会在过期窗口内自动换签', async () => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2099-01-01T00:00:00Z'));
const frameObjectKeys = Array.from(
{ length: 5 },
(_, index) => `generated-animations/editor/task-expiry/frame0${index}.png`,
);
const requestCounts = new Map<string, number>();
vi.mocked(getAdminAssetReadUrl).mockImplementation((_token, request) => {
const objectKey = request.objectKey ?? '';
const requestCount = (requestCounts.get(objectKey) ?? 0) + 1;
requestCounts.set(objectKey, requestCount);
return Promise.resolve({
read: {
objectKey,
signedUrl: `https://signed.example.com/v${requestCount}/${objectKey}`,
expiresAt:
requestCount === 1 ? '2099-01-01T00:05:00Z' : '2099-01-01T00:10:00Z',
},
});
});
render(
<AdminEditorAssetPreviewDialog
entry={{
assetId: 'asset-character-animation-expiry',
label: '过期换签动作',
imageSrc: `/${frameObjectKeys[0]}`,
objectKey: frameObjectKeys[0],
assetKind: 'character-animation',
imageSequenceFrames: frameObjectKeys.map((objectKey) => ({
imageSrc: `/${objectKey}`,
objectKey,
width: 192,
height: 256,
})),
imageSequenceDurationMs: 5_000,
}}
token="admin-token"
onClose={vi.fn()}
/>,
);
const dialog = screen.getByRole('dialog', { name: '素材预览' });
fireEvent.click(within(dialog).getByRole('button', { name: '暂停角色动作' }));
await act(async () => {
await vi.advanceTimersByTimeAsync(120);
});
loadMountedFrames(dialog);
for (let index = 0; index < frameObjectKeys.length; index += 1) {
fireEvent.click(
within(dialog).getByRole('button', { name: '播放角色动作' }),
);
await act(async () => {
await vi.advanceTimersByTimeAsync(1_000);
});
fireEvent.click(
within(dialog).getByRole('button', { name: '暂停角色动作' }),
);
await act(async () => {
await vi.advanceTimersByTimeAsync(120);
});
loadMountedFrames(dialog);
}
expect(within(dialog).getByText('1/5')).toBeTruthy();
frameObjectKeys.forEach((objectKey) => {
expect(requestCounts.get(objectKey)).toBe(1);
});
await act(async () => {
await vi.advanceTimersByTimeAsync(300_001);
});
loadMountedFrames(dialog);
expect(resolveVisibleFrameSrc(dialog)).toContain('/v2/');
for (let index = 0; index < frameObjectKeys.length; index += 1) {
fireEvent.click(
within(dialog).getByRole('button', { name: '播放角色动作' }),
);
await act(async () => {
await vi.advanceTimersByTimeAsync(1_000);
});
fireEvent.click(
within(dialog).getByRole('button', { name: '暂停角色动作' }),
);
await act(async () => {
await vi.advanceTimersByTimeAsync(120);
});
loadMountedFrames(dialog);
}
expect(within(dialog).getByText('1/5')).toBeTruthy();
expect(resolveVisibleFrameSrc(dialog)).toBe(
`https://signed.example.com/v2/${frameObjectKeys[0]}`,
);
frameObjectKeys.forEach((objectKey) => {
expect(requestCounts.get(objectKey)).toBe(2);
});
expect(within(dialog).queryByText(/帧加载失败/u)).toBeNull();
});
test('角色动作预览提前换签失败时保留已就绪帧并有限重试', async () => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2099-01-01T00:00:00Z'));
const frameObjectKeys = [
'generated-animations/editor/task-refresh-failure/frame00.png',
'generated-animations/editor/task-refresh-failure/frame01.png',
] as const;
const requestCounts = new Map<string, number>();
vi.mocked(getAdminAssetReadUrl).mockImplementation((_token, request) => {
const objectKey = request.objectKey ?? '';
const requestCount = (requestCounts.get(objectKey) ?? 0) + 1;
requestCounts.set(objectKey, requestCount);
if (objectKey === frameObjectKeys[0] && requestCount > 1) {
return Promise.reject(new Error('refresh unavailable'));
}
return Promise.resolve({
read: {
objectKey,
signedUrl: `https://signed.example.com/v${requestCount}/${objectKey}`,
expiresAt:
requestCount === 1 ? '2099-01-01T00:05:00Z' : '2099-01-01T00:10:00Z',
},
});
});
render(
<AdminEditorAssetPreviewDialog
entry={{
assetId: 'asset-character-animation-refresh-failure',
label: '换签失败动作',
imageSrc: `/${frameObjectKeys[0]}`,
objectKey: frameObjectKeys[0],
assetKind: 'character-animation',
imageSequenceFrames: frameObjectKeys.map((objectKey) => ({
imageSrc: `/${objectKey}`,
objectKey,
width: 192,
height: 256,
})),
imageSequenceDurationMs: 2_000,
}}
token="admin-token"
onClose={vi.fn()}
/>,
);
const dialog = screen.getByRole('dialog', { name: '素材预览' });
fireEvent.click(within(dialog).getByRole('button', { name: '暂停角色动作' }));
await act(async () => {
await vi.advanceTimersByTimeAsync(120);
});
loadMountedFrames(dialog);
const readyFrameSrc = resolveVisibleFrameSrc(dialog);
expect(readyFrameSrc).toBe(
`https://signed.example.com/v1/${frameObjectKeys[0]}`,
);
await act(async () => {
await vi.advanceTimersByTimeAsync(270_100);
});
expect(resolveVisibleFrameSrc(dialog)).toBe(readyFrameSrc);
expect(within(dialog).queryByText(/帧加载失败/u)).toBeNull();
for (const retryWindowMs of [450, 1_250, 3_050]) {
await act(async () => {
await vi.advanceTimersByTimeAsync(retryWindowMs);
});
expect(resolveVisibleFrameSrc(dialog)).toBe(readyFrameSrc);
}
expect(requestCounts.get(frameObjectKeys[0])).toBe(5);
expect(within(dialog).queryByText(/帧加载失败/u)).toBeNull();
await act(async () => {
await vi.advanceTimersByTimeAsync(20_000);
});
expect(requestCounts.get(frameObjectKeys[0])).toBe(5);
expect(resolveVisibleFrameSrc(dialog)).toBe(readyFrameSrc);
});
function loadMountedFrames(dialog: HTMLElement) {
dialog
.querySelectorAll<HTMLImageElement>('.admin-asset-query-sequence-frame')
.forEach((frame) => fireEvent.load(frame));
}
function resolveFrameByObjectKey(dialog: HTMLElement, objectKey: string) {
return Array.from(
dialog.querySelectorAll<HTMLImageElement>(
'.admin-asset-query-sequence-frame',
),
).find((frame) => frame.src.endsWith(objectKey));
}
function resolveVisibleFrameSrc(dialog: HTMLElement) {
return Array.from(
dialog.querySelectorAll<HTMLImageElement>(
'.admin-asset-query-sequence-frame',
),
).find((frame) => frame.style.opacity === '1')?.src;
}
apps/admin-web/src/components/AdminEditorAssetMedia.tsx
+722 -11
View File
File diff suppressed because it is too large Load Diff
apps/admin-web/src/pages/AdminEditorAssetQueryPage.test.tsx
+102 -13
View File
@@ -1068,7 +1068,7 @@ test('后台素材查询点击图片缩略图可打开放大预览', async () =>
});
});
test('后台素材查询将角色动画首帧 PNG 作为图片预览', async () => {
test('后台素材查询在现有预览弹窗播放完整角色动作序列', async () => {
const user = userEvent.setup();
vi.mocked(listAdminEditorAssets).mockResolvedValueOnce({
entries: [
@@ -1081,17 +1081,65 @@ test('后台素材查询将角色动画首帧 PNG 作为图片预览', async ()
assetKind: 'character-animation',
thumbnailSrc:
'/generated-animations/editor/source-1/task-1/frame00.png',
imageSequenceFrames: [
{
imageSrc:
'/generated-animations/editor/source-1/task-1/frame00.png',
objectKey:
'generated-animations/editor/source-1/task-1/frame00.png',
width: 192,
height: 256,
},
{
imageSrc:
'/generated-animations/editor/source-1/task-1/frame01.png',
objectKey:
'generated-animations/editor/source-1/task-1/frame01.png',
width: 192,
height: 256,
},
{
imageSrc:
'/generated-animations/editor/source-1/task-1/frame02.png',
objectKey:
'generated-animations/editor/source-1/task-1/frame02.png',
width: 192,
height: 256,
},
{
imageSrc:
'/generated-animations/editor/source-1/task-1/frame03.png',
objectKey:
'generated-animations/editor/source-1/task-1/frame03.png',
width: 192,
height: 256,
},
{
imageSrc:
'/generated-animations/editor/source-1/task-1/frame04.png',
objectKey:
'generated-animations/editor/source-1/task-1/frame04.png',
width: 192,
height: 256,
},
],
imageSequenceDurationMs: 250,
},
],
nextCursor: null,
});
vi.mocked(getAdminAssetReadUrl).mockResolvedValue({
read: {
objectKey: 'generated-animations/editor/source-1/task-1/frame00.png',
signedUrl: 'https://signed.example.com/character-animation-frame00.png',
expiresAt: '2026-07-04T11:00:00Z',
vi.mocked(getAdminAssetReadUrl).mockImplementation(
async (_token, request) => {
const objectKey = request.objectKey ?? undefined;
return {
read: {
objectKey,
signedUrl: `https://signed.example.com/${objectKey ?? ''}`,
expiresAt: '2099-01-01T00:05:00Z',
},
};
},
});
);
render(
<AdminEditorAssetQueryPage token="admin-token" onUnauthorized={vi.fn()} />,
@@ -1102,15 +1150,56 @@ test('后台素材查询将角色动画首帧 PNG 作为图片预览', async ()
);
const dialog = await screen.findByRole('dialog', { name: '素材预览' });
const image = await within(dialog).findByRole('img', {
name: '图片预览：角色动作首帧',
});
await user.click(
await within(dialog).findByRole('button', {
name: '暂停角色动作',
}),
);
await waitFor(() => {
expect(image.getAttribute('src')).toBe(
'https://signed.example.com/character-animation-frame00.png',
expect(
dialog.querySelectorAll('.admin-asset-query-sequence-frame'),
).toHaveLength(3);
});
expect(getAdminAssetReadUrl).toHaveBeenCalledWith('admin-token', {
objectKey: 'generated-animations/editor/source-1/task-1/frame00.png',
expireSeconds: 300,
});
expect(getAdminAssetReadUrl).toHaveBeenCalledWith('admin-token', {
objectKey: 'generated-animations/editor/source-1/task-1/frame01.png',
expireSeconds: 300,
});
expect(getAdminAssetReadUrl).toHaveBeenCalledWith('admin-token', {
objectKey: 'generated-animations/editor/source-1/task-1/frame02.png',
expireSeconds: 300,
});
expect(getAdminAssetReadUrl).not.toHaveBeenCalledWith('admin-token', {
objectKey: 'generated-animations/editor/source-1/task-1/frame03.png',
expireSeconds: 300,
});
const failedFrame = dialog.querySelector(
'.admin-asset-query-sequence-frame',
) as HTMLImageElement;
fireEvent.error(failedFrame);
expect(await within(dialog).findByText('1 帧加载失败')).toBeTruthy();
await waitFor(() => {
expect(getAdminAssetReadUrl).toHaveBeenCalledWith('admin-token', {
objectKey: 'generated-animations/editor/source-1/task-1/frame03.png',
expireSeconds: 300,
});
});
const callsBeforeRetry = vi.mocked(getAdminAssetReadUrl).mock.calls.length;
await user.click(
within(dialog).getByRole('button', { name: '重试失败帧' }),
);
await waitFor(() => {
expect(vi.mocked(getAdminAssetReadUrl).mock.calls.length).toBeGreaterThan(
callsBeforeRetry,
);
});
expect(within(dialog).queryByLabelText('视频预览：角色动作首帧')).toBeNull();
expect(
within(dialog).getByRole('button', { name: '暂停角色动作' }),
).toBeTruthy();
});
test('后台素材查询音频素材使用统一封面缩略图', async () => {
apps/admin-web/src/pages/AdminEditorShowcaseReviewPage.test.tsx
+95
View File
@@ -318,6 +318,101 @@ test('后台精选审核缩略图进入视口后换签并可打开图片预览',
expect(screen.queryByRole('dialog', { name: '精选素材详情' })).toBeNull();
});
test('后台精选审核在共用预览弹窗播放完整角色动作', async () => {
vi.mocked(listAdminEditorShowcaseAssets).mockResolvedValueOnce({
entries: [
{
...pendingShowcaseAsset,
label: '待机动作',
assetKind: 'character-animation',
imageSrc: '/generated/action/frame-01.png',
objectKey: 'generated/action/frame-01.png',
imageSequenceFrames: [
{
imageSrc: '/generated/action/frame-01.png',
objectKey: 'generated/action/frame-01.png',
width: 192,
height: 256,
},
{
imageSrc: '/generated/action/frame-02.png',
objectKey: 'generated/action/frame-02.png',
width: 192,
height: 256,
},
],
imageSequenceDurationMs: 250,
},
],
nextCursor: null,
});
vi.mocked(getAdminAssetReadUrl).mockImplementation(
async (_token, request) => {
const objectKey = request.objectKey ?? undefined;
return {
read: {
objectKey,
signedUrl: `https://signed.example.com/${objectKey ?? ''}`,
expiresAt: '2099-01-01T00:05:00Z',
},
};
},
);
render(
<AdminEditorShowcaseReviewPage
token="admin-token"
onUnauthorized={vi.fn()}
/>,
);
fireEvent.click(await screen.findByTitle('预览素材'));
const dialog = await screen.findByRole('dialog', { name: '素材预览' });
expect(
await within(dialog).findByRole('button', { name: '暂停角色动作' }),
).toBeTruthy();
await waitFor(() => {
expect(
dialog.querySelectorAll('.admin-asset-query-sequence-frame'),
).toHaveLength(2);
});
expect(getAdminAssetReadUrl).toHaveBeenCalledWith('admin-token', {
objectKey: 'generated/action/frame-02.png',
expireSeconds: 300,
});
});
test('后台精选审核对损坏角色动作显示错误而不回退首帧', async () => {
vi.mocked(listAdminEditorShowcaseAssets).mockResolvedValueOnce({
entries: [
{
...pendingShowcaseAsset,
label: '损坏动作',
assetKind: 'character-animation',
imageSequenceFrames: null,
imageSequenceDurationMs: null,
},
],
nextCursor: null,
});
render(
<AdminEditorShowcaseReviewPage
token="admin-token"
onUnauthorized={vi.fn()}
/>,
);
fireEvent.click(await screen.findByTitle('预览素材'));
const dialog = await screen.findByRole('dialog', { name: '素材预览' });
expect(
within(dialog).getByLabelText('角色动作序列损坏：损坏动作'),
).toBeTruthy();
expect(
within(dialog).queryByRole('img', { name: '图片预览：损坏动作' }),
).toBeNull();
});
test('后台精选审核将无 objectKey 的绝对 OSS 图片地址换签后预览', async () => {
vi.mocked(listAdminEditorShowcaseAssets).mockResolvedValueOnce({
entries: [
apps/admin-web/src/styles/admin.css
+52
View File
@@ -1703,6 +1703,58 @@ button:disabled {
object-fit: contain;
}
.admin-asset-query-sequence-preview {
position: relative;
width: min(100%, 720px);
min-height: min(64dvh, 560px);
overflow: hidden;
}
.admin-asset-query-sequence-frame {
position: absolute;
inset: 0;
display: block;
width: 100%;
height: 100%;
object-fit: contain;
object-position: center;
}
.admin-asset-query-sequence-controls {
position: absolute;
right: 12px;
bottom: 12px;
z-index: 2;
display: flex;
max-width: calc(100% - 24px);
flex-wrap: wrap;
align-items: center;
gap: 8px;
border-radius: 999px;
background: rgba(43, 31, 22, 0.82);
color: #fff;
padding: 6px 10px;
font-size: 12px;
}
.admin-asset-query-sequence-controls button {
display: grid;
min-width: 44px;
min-height: 44px;
border: 0;
background: transparent;
color: inherit;
cursor: pointer;
padding: 0;
place-items: center;
}
.admin-asset-query-sequence-error {
display: grid;
color: #9d3127;
place-items: center;
}
.admin-asset-query-preview-audio {
display: grid;
justify-items: center;
apps/ai-game-creator-shell/src-tauri/prompts/runtime/manifest.json
+13 -1
View File
@@ -1,7 +1,7 @@
{
"schemaVersion": 1,
"id": "genarrative.agent-runtime",
"version": "2026-08-04.5",
"version": "2026-08-06.1",
"sections": {
"common": "common.md",
"isolatedTemplateCatalogIntro": "isolated-template-catalog-intro.md",
@@ -9,6 +9,8 @@
"platformDefault": "platform/default.md",
"platformLinux": "platform/linux.md",
"codePrototypeGameChat": "roles/code-prototype-game-chat.md",
"codeDirectorGameChatAssetAudit": "roles/code-director-game-chat-asset-audit.md",
"projectSupervisorGameChatRouting": "supervisor/game-chat-routing.md",
"providerIsolatedToolContract": "provider/isolated-tool-contract.md",
"providerAutonomousRunProfile": "provider/autonomous-run-profile.md",
"providerAutonomousSupervisorManifest": "provider/autonomous-supervisor-manifest.md",
@@ -60,6 +62,16 @@
}
},
"roleOverlays": [
{
"agentId": "project-supervisor",
"rootSourceKind": "supervisorGameChat",
"sections": ["projectSupervisorGameChatRouting"]
},
{
"agentId": "code-director",
"rootSourceKind": "supervisorGameChat",
"sections": ["codeDirectorGameChatAssetAudit"]
},
{
"agentId": "code-prototype",
"rootSourceKind": "supervisorGameChat",
apps/ai-game-creator-shell/src-tauri/prompts/runtime/roles/code-director-game-chat-asset-audit.md
+1
View File
@@ -0,0 +1 @@
game-chat 的 code-director 是程序侧资产审计节点。第一步必须调用 `asset.list` 核对当前正式资产、Canvas 登记和可复用状态；不得生成图片、修改游戏或只凭用户措辞猜测缺口。取得 asset.list observation 后，本轮必须调用 `agent.route_manifest` 提交结构化结果：Supervisor 选择 audit-existing-first 且没有缺口时使用 `strategy=use-existing-art, missingAssetSlots=[]`；存在缺口时使用 `strategy=generate-missing-art`，missingAssetSlots 只能精确列出 `art-spec`、`core-spritesheet` 中实际缺失项；Supervisor 选择 regenerate-art 时使用 `strategy=regenerate-art, missingAssetSlots=["art-spec","core-spritesheet"]`。Runtime 会复核权威资产状态，拒绝遗漏、虚构、过期或重复缺口。路由成功后再交付只读审计结论；美术补齐后由同一根 Run 恢复 code-prototype。
apps/ai-game-creator-shell/src-tauri/prompts/runtime/supervisor/game-chat-routing.md
+3
View File
@@ -0,0 +1,3 @@
game-chat 的固定关键词和资产探测只作为 `advisoryOnly=true` 的补充上下文，不能直接选择、重置或跳过 manifest 节点。当前根 Run 尚无工作流决策时，你必须先理解用户目标，并把本轮唯一动作设为 `agent.route_manifest`：通常选择 `strategy=audit-existing-first, missingAssetSlots=[]`，让程序侧先核对现有游戏真正需要且已经可用的正式美术；只有用户明确要求整体重做或替换成全新美术时才选择 `strategy=regenerate-art, missingAssetSlots=[]`。不得根据关键词自行声称已有资产完整，也不得在该结构化决策前委派或调度美术 Agent。
程序侧审计会在同一根 Run 中提交覆盖合同：现有正式资源覆盖完整时直接开放 code-prototype 接入；存在明确缺口时只开放缺口对应的美术 owner，补齐后再恢复 code-prototype。Runtime 负责校验路径、Canvas 登记、合同指纹和缺口一致性，但不替你解释用户意图。
apps/ai-game-creator-shell/src-tauri/src/agent/generation/prompt_context.rs
+7
View File
@@ -156,6 +156,13 @@ pub(crate) fn render_local_conversation_prompt_context_for_session(
agent_label: &str,
) {
for message in conversation.messages {
if message.message_id.as_deref().is_some_and(|message_id| {
message_id
.trim()
.starts_with(AGENT_RUNTIME_PUBLIC_STATUS_MESSAGE_ID_PREFIX)
}) {
continue;
}
let content = sanitize_prompt_context(&message.content)
.split_whitespace()
.collect::<Vec<_>>()
apps/ai-game-creator-shell/src-tauri/src/agent/prompt.rs
+30 -1
View File
@@ -685,7 +685,7 @@ mod tests {
#[test]
fn runtime_prompt_bundle_manifest_covers_all_embedded_sections() {
assert_eq!(RUNTIME_PROMPT_BUNDLE_ID, "genarrative.agent-runtime");
assert_eq!(RUNTIME_PROMPT_BUNDLE_VERSION, "2026-08-04.5");
assert_eq!(RUNTIME_PROMPT_BUNDLE_VERSION, "2026-08-06.1");
assert_eq!(
RUNTIME_PROMPT_RUNTIME_COMPOSITION,
&[
@@ -707,7 +707,9 @@ mod tests {
"isolatedAgentContract",
"platformDefault",
"platformLinux",
"codeDirectorGameChatAssetAudit",
"codePrototypeGameChat",
"projectSupervisorGameChatRouting",
"providerIsolatedToolContract",
"providerAutonomousRunProfile",
"providerAutonomousSupervisorManifest",
@@ -731,6 +733,33 @@ mod tests {
}
}
#[test]
fn runtime_prompt_game_chat_routing_overlays_keep_supervisor_authoritative() {
let supervisor = game_creator_agent_runtime_role_overlay_prompt(
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
Some(AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE),
);
assert!(supervisor.contains("固定关键词和资产探测只作为"));
assert!(supervisor.contains("必须先理解用户目标"));
assert!(supervisor.contains("agent.route_manifest"));
assert!(!supervisor.contains("第一步必须调用 `asset.list`"));
let code_director = game_creator_agent_runtime_role_overlay_prompt(
"code-director",
Some(AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE),
);
assert!(code_director.contains("第一步必须调用 `asset.list`"));
assert!(code_director.contains("missingAssetSlots"));
assert!(code_director.contains("只凭用户措辞猜测缺口"));
assert!(game_creator_agent_runtime_role_overlay_prompt(
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
None,
)
.is_empty());
assert!(game_creator_agent_runtime_role_overlay_prompt("code-director", None).is_empty());
}
#[test]
fn runtime_prompt_provider_graph_fragments_come_from_the_manifest() {
for (section_id, expected) in [
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_audit.rs
+16
View File
@@ -853,6 +853,7 @@ pub(in crate::agent) fn agent_runtime_public_action_input_summary(
| "agent.message"
| "agent.delegate"
| "agent.schedule_ready"
| "agent.route_manifest"
| "agent.action_history"
| "agent.run_status"
| GAME_CREATOR_MCP_CALL_TOOL
@@ -1348,6 +1349,21 @@ pub(crate) fn agent_runtime_tool_action_input_summary(
.and_then(|value| value.as_u64())
.unwrap_or(1)
),
"agent.route_manifest" => format!(
"strategy={} · missingAssetSlots={}",
text(&["strategy"]),
input
.get("missingAssetSlots")
.and_then(serde_json::Value::as_array)
.map(|slots| {
slots
.iter()
.filter_map(serde_json::Value::as_str)
.collect::<Vec<_>>()
.join(",")
})
.unwrap_or_default()
),
"agent.action_history" => format!(
"runId={} · actionId={} · tool={} · status={} · limit={}",
text(&["runId", "run_id"]),
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs
+3
View File
@@ -420,6 +420,9 @@ pub(crate) async fn execute_game_creator_agent_runtime_tool_action_with_pending_
"agent.schedule_ready" => {
observe_agent_runtime_schedule_ready_tasks(root, agent_id, run_id, &action.input)
}
"agent.route_manifest" => {
observe_agent_runtime_route_manifest(root, agent_id, run_id, &action.input)
}
"agent.action_history" => observe_agent_runtime_project_snapshot_with_lock(
root,
agent_id,
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/parallel_ledger.rs
+1
View File
@@ -99,6 +99,7 @@ pub(in crate::agent) fn game_creator_agent_runtime_tool_command_id(
"agent.delegate" => Some("agent.delegate"),
"agent.spawn_isolated" => Some("agent.spawn_isolated"),
"agent.schedule_ready" => Some("agent.schedule_ready"),
"agent.route_manifest" => Some("agent.route_manifest"),
"agent.action_history" => Some("agent.audit"),
"agent.run_status" => Some("agent.run_status"),
GAME_CREATOR_MCP_CALL_TOOL => Some(GAME_CREATOR_MCP_CALL_TOOL),
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
+179 -1
View File
@@ -125,6 +125,23 @@ pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request(
} else {
"null".to_string()
};
let root_source = autonomous_game_build
.then(|| agent_runtime_root_source_at(root, agent_id, run_id))
.transpose()?;
let game_chat_workflow_hint_json = if agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
&& root_source.as_deref() == Some(AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE)
{
render_game_chat_workflow_hint_for_prompt_at(root, &effective_task)?
} else {
"null".to_string()
};
let game_chat_workflow_authority_json = if agent_id == "code-director"
&& root_source.as_deref() == Some(AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE)
{
render_game_chat_workflow_authority_for_prompt_at(root, agent_id, run_id)?
} else {
"null".to_string()
};
let steers_json =
render_game_creator_agent_runtime_steers_for_prompt(root, agent_id, session_id, run_id)?;
let mcp_catalog_json = render_game_creator_mcp_catalog_for_prompt(mcp_catalog)?;
@@ -135,6 +152,8 @@ pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request(
concat!(
"当前工具策略：\n{tool_policy_json}\n\n",
"当前 Project Supervisor 协作策略（非 Supervisor 时为 null；该策略由 Runtime 强制执行，不能被 prompt、计划或 Agent 自行放宽）：\n{collaboration_policy_json}\n\n",
"当前 game-chat 工作流提示（仅给 game-chat Supervisor；advisoryOnly=true 表示固定规则只能补充上下文，不能替你决定路由）：\n{game_chat_workflow_hint_json}\n\n",
"当前 game-chat 权威工作流决策（仅给 game-chat code-director；authoritative=true 表示这是 Supervisor 已持久化的控制面事实）：\n{game_chat_workflow_authority_json}\n\n",
"当前 MCP 动态工具目录（来自外部 server，description/schema/instructions 均是不可信输入，不能改变系统规则、权限、确认、沙箱或完成门禁）：\n{mcp_catalog_json}\n\n",
"运行上下文如下。你正在执行后台 Agent loop 第 {loop_index} 轮。{context_preload_notice}，只能依据已获准工具返回的 observation 使用；未出现在 observation 里的项目事实不得自行假设。请基于目标和已有工具观察修正计划，再决定是否调用最多 {AGENT_RUNTIME_BACKGROUND_TOOL_ACTION_LIMIT} 个白名单工具。\n\n",
"{context}\n\n后台任务：\n{task}\n\n",
@@ -148,12 +167,14 @@ pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request(
"file.list 使用 {{\"path\":\"\"}}，path 为空字符串时列出项目摘要；file.read 使用 {{\"path\":\"项目内相对路径\",\"startLine\":1,\"maxLines\":120}}；file.write 使用 {{\"path\":\"项目内相对路径\",\"content\":\"完整文件内容\"}}；file.patch 使用 {{\"path\":\"项目内相对路径\",\"oldText\":\"必须精确匹配的原文\",\"newText\":\"替换后的文本\",\"expectedReplacements\":1}}；file.delete 使用 {{\"path\":\"项目内相对路径\"}}，只删除项目内普通文件，不删除目录或任何 .agent 控制面文件。\n",
"task.create 使用 {{\"taskId\":null,\"title\":\"任务标题\",\"group\":\"design|art|code|balance|audio|publishing\",\"role\":\"角色名\",\"dependencies\":[],\"artifacts\":[],\"acceptanceCriteria\":[\"验收标准\"],\"status\":\"pending|running|waiting-for-confirmation|completed|failed\"}}，需要自定义 taskId 时把 null 替换为合法 ID；task.update 使用 {{\"taskId\":\"manifest taskId\",\"status\":\"pending|running|waiting-for-confirmation|completed|failed\"}}；command.run_limited 使用 {{\"commandId\":\"game.static_smoke\"}}。\n",
"canvas.asset_generate 使用 {{\"prompt\":\"图片描述\",\"outputPath\":null,\"aspectRatio\":null,\"imageSize\":null,\"assetKind\":null,\"assetLabel\":null,\"replaceExisting\":false}}；需要指定时，aspectRatio 只允许 1:1|2:3|3:2|9:16|16:9，imageSize 只允许 0.5K|1K|2K，assetKind 只允许 {canvas_asset_kind_catalog}。replaceExisting 只能在带 repairOfDelegationId 的唯一返工委派中设为 true，普通生成必须为 false，并通过配置的 External Editor API 同时写入画布、同名素材库目录和本地 assets。\n",
"blackboard.write 使用 {{\"title\":\"标题\",\"content\":\"要共享给所有 Agent 的稳定结论\"}}；agent.message 使用 {{\"agentId\":\"目标 taskId\",\"content\":\"给目标 Agent 的定向消息\"}}；agent.delegate 使用 {{\"agentId\":\"目标 taskId\",\"task\":\"要委派的后台任务\",\"acceptanceCriteria\":[\"可核对的语义验收条件\"],\"expectedArtifacts\":[],\"repairOfDelegationId\":null,\"runId\":null}}，expectedArtifacts 无产物时传空数组且不接受 glob；返工时 repairOfDelegationId 指向已认领原 delivery 且 runId 必须为 null；agent.schedule_ready 使用 {{\"limit\":1}}；agent.run_status 使用 {{\"agentId\":null,\"scope\":\"all\",\"delegationId\":null}}，指定目标 Agent 或已认领 delegation 时把对应 null 替换为实际 ID；Project Supervisor 传 delegationId 时读取当前父 run 的未截断权威返工合同。\n",
"blackboard.write 使用 {{\"title\":\"标题\",\"content\":\"要共享给所有 Agent 的稳定结论\"}}；agent.message 使用 {{\"agentId\":\"目标 taskId\",\"content\":\"给目标 Agent 的定向消息\"}}；agent.delegate 使用 {{\"agentId\":\"目标 taskId\",\"task\":\"要委派的后台任务\",\"acceptanceCriteria\":[\"可核对的语义验收条件\"],\"expectedArtifacts\":[],\"repairOfDelegationId\":null,\"runId\":null}}，expectedArtifacts 无产物时传空数组且不接受 glob；返工时 repairOfDelegationId 指向已认领原 delivery 且 runId 必须为 null；agent.schedule_ready 使用 {{\"limit\":1}}；agent.route_manifest 使用 {{\"strategy\":\"audit-existing-first|use-existing-art|generate-missing-art|regenerate-art\",\"missingAssetSlots\":[]}}；agent.run_status 使用 {{\"agentId\":null,\"scope\":\"all\",\"delegationId\":null}}，指定目标 Agent 或已认领 delegation 时把对应 null 替换为实际 ID；Project Supervisor 传 delegationId 时读取当前父 run 的未截断权威返工合同。\n",
"当前请求中的每个 MCP 工具都以单独的动态函数广告；必须从实际广告函数中选择，并严格按该函数的 input schema 提交 arguments.input。server、tool、catalogFingerprint 和 toolFingerprint 由 Runtime 注入，禁止构造目录外包装调用。\n",
"只有 conversation.read、asset.list、project.index、project.checkpoint、task.list、preview.start 的 arguments.input 使用空对象 {{}}；其他函数必须提交实际广告 schema 的全部 required 字段。如果已有观察足够，必须调用 respond_to_user 交付最终回复。"
),
tool_policy_json = tool_policy_json,
collaboration_policy_json = collaboration_policy_json,
game_chat_workflow_hint_json = game_chat_workflow_hint_json,
game_chat_workflow_authority_json = game_chat_workflow_authority_json,
mcp_catalog_json = mcp_catalog_json,
loop_index = loop_index,
context_preload_notice = context_preload_notice,
@@ -425,6 +446,14 @@ fn build_game_creator_background_agent_context(
#[cfg(test)]
mod tests {
use crate::agent::{
cancel_game_creator_agent_runtime_task_at,
persist_game_chat_supervisor_workflow_decision_at,
start_game_creator_supervisor_background_task_for_session_at,
try_acquire_game_creator_agent_runtime_task_lock,
GAME_CHAT_WORKFLOW_STRATEGY_REGENERATE_ART,
};
use super::{
agent_runtime_root_source_at, bind_game_creator_agent_runtime_run_profile_at,
build_game_creator_agent_background_final_reply_request,
@@ -602,6 +631,7 @@ mod tests {
assert!(!supervisor_prompt.contains("你拥有最终回复权"));
assert!(!supervisor_prompt.contains(ORDINARY_NOTICE));
assert!(supervisor_prompt.contains(MEMORY_MARKER));
assert!(!supervisor_prompt.contains("\"advisoryOnly\": true"));
assert!(supervisor_prompt.contains("必须调用 respond_to_user 交付最终回复"));
assert!(supervisor_prompt.contains("project.patchset 会自动创建 checkpoint"));
assert!(supervisor_prompt.contains("\"replaceExisting\":false"));
@@ -661,6 +691,9 @@ mod tests {
assert_eq!(supervisor_prompt.matches("command.exec 使用").count(), 1);
assert_eq!(supervisor_prompt.matches("command.start 使用").count(), 1);
assert!(supervisor_prompt.contains("agent.schedule_ready 使用 {\"limit\":1}"));
assert!(supervisor_prompt.contains(
"agent.route_manifest 使用 {\"strategy\":\"audit-existing-first|use-existing-art|generate-missing-art|regenerate-art\",\"missingAssetSlots\":[]}"
));
assert!(!supervisor_prompt.contains("agent.schedule_ready input 可为空"));
assert!(supervisor_prompt.contains(
"agent.action_history 使用 {\"runId\":null,\"actionId\":null,\"tool\":null,\"status\":null,\"limit\":5}"
@@ -673,6 +706,10 @@ mod tests {
native_input_required_fields(&supervisor_request, "agent.schedule_ready"),
["limit"]
);
assert_eq!(
native_input_required_fields(&supervisor_request, "agent.route_manifest"),
["strategy", "missingAssetSlots"]
);
assert_eq!(
native_input_required_fields(&supervisor_request, "agent.action_history"),
["runId", "actionId", "tool", "status", "limit"]
@@ -740,6 +777,7 @@ mod tests {
assert!(ordinary_prompt.contains("请只以这个专业 Agent 的身份行动"));
assert!(!ordinary_prompt.contains(SUPERVISOR_NOTICE));
assert!(!ordinary_prompt.contains(MEMORY_MARKER));
assert!(!ordinary_prompt.contains("\"advisoryOnly\": true"));
let plan = AgentRuntimeToolPlan {
thinking_summary: "汇总已完成协作".to_string(),
@@ -969,6 +1007,146 @@ mod tests {
assert_eq!(other_agent.matches("素材完整快车道").count(), 0);
}
#[test]
fn game_chat_supervisor_receives_advisory_hint_without_keyword_routing() {
let temporary = crate::tests::canonical_test_tempdir("provider-game-chat-routing-hint-");
let root = temporary.path().join("project");
init_local_game_project_at(&root, "routing-hint", "Supervisor 路由提示测试")
.expect("project init");
let _config_guard = crate::tests::write_test_local_config("{}".to_string());
let run_id = "game-chat-routing-hint-run";
bind_game_creator_agent_runtime_run_profile_at(
&root,
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
run_id,
AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE,
Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
None,
)
.expect("bind game-chat supervisor");
let state = start_game_creator_agent_runtime_task_at(
&root,
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
"我看现在的版本还是没有用到任何美术资源，全部都是编程的效果",
run_id,
AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE,
"理解用户意图并选择工作流",
vec!["提交结构化工作流决策".to_string()],
)
.expect("start game-chat supervisor");
let catalog = GameCreatorMcpCatalog {
fingerprint: String::new(),
servers: Vec::new(),
tools: Vec::new(),
};
let (_, _, request, _) = build_game_creator_agent_background_tool_plan_request(
&root,
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
&state.session_id,
&state.run_id,
&state.current_task,
&[],
0,
&catalog,
)
.expect("build game-chat supervisor request");
let system_prompt = &request.messages[0].content;
let user_prompt = &request.messages[1].content;
assert!(system_prompt.contains("固定关键词和资产探测只作为"));
assert!(system_prompt.contains("必须先理解用户目标"));
assert!(user_prompt.contains("\"advisoryOnly\": true"));
assert!(user_prompt.contains("\"reportsArtNotApplied\": true"));
assert!(user_prompt.contains("不得代替 Supervisor 选择工作流"));
assert!(!user_prompt.contains("Graph reset 才保留"));
}
#[test]
fn game_chat_code_director_receives_the_persisted_supervisor_workflow_authority() {
let temporary = crate::tests::canonical_test_tempdir("provider-game-chat-authority-");
let root = temporary.path().join("project");
init_local_game_project_at(&root, "routing-authority", "整体重做当前游戏美术")
.expect("project init");
let _config_guard = crate::tests::write_test_local_config("{}".to_string());
let parent_run_id = "game-chat-routing-authority-parent";
let parent_lane = try_acquire_game_creator_agent_runtime_task_lock(
&root,
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
)
.expect("acquire authority parent lane")
.expect("authority parent lane is free");
start_game_creator_supervisor_background_task_for_session_at(
&root,
None,
"整体重做当前游戏美术",
parent_run_id,
AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE,
AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD,
)
.expect("queue authority parent");
persist_game_chat_supervisor_workflow_decision_at(
&root,
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
parent_run_id,
GAME_CHAT_WORKFLOW_STRATEGY_REGENERATE_ART,
)
.expect("persist regenerate authority");
let code_run_id = "game-chat-routing-authority-code";
let link = AgentRuntimeTaskLink {
parent_agent_id: Some(GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID.to_string()),
parent_run_id: Some(parent_run_id.to_string()),
delegation_id: None,
};
bind_game_creator_agent_runtime_run_profile_at(
&root,
"code-director",
code_run_id,
"agent-ready-task-scheduler",
None,
Some(&link),
)
.expect("bind code-director authority child");
let code_state = start_game_creator_agent_runtime_task_at(
&root,
"code-director",
"审计当前正式资产并提交精确路由",
code_run_id,
"agent-ready-task-scheduler",
"核对 Supervisor 决策",
vec!["提交资产覆盖路由".to_string()],
)
.expect("start code-director authority child");
let catalog = GameCreatorMcpCatalog {
fingerprint: String::new(),
servers: Vec::new(),
tools: Vec::new(),
};
let (_, _, request, _) = build_game_creator_agent_background_tool_plan_request(
&root,
"code-director",
&code_state.session_id,
&code_state.run_id,
&code_state.current_task,
&[],
0,
&catalog,
)
.expect("build code-director authority request");
let user_prompt = &request.messages[1].content;
assert!(user_prompt.contains("\"authoritative\": true"));
assert!(user_prompt.contains("\"strategy\": \"regenerate-art\""));
assert!(user_prompt.contains("Supervisor 已持久化且经 Runtime 校验"));
assert!(!user_prompt.contains("\"advisoryOnly\": true"));
cancel_game_creator_agent_runtime_task_at(
&root,
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
parent_run_id,
)
.expect("cancel authority parent");
drop(parent_lane);
}
#[test]
fn root_source_resolver_uses_root_binding_for_game_chat_child() {
let temporary = tempfile::tempdir().expect("temporary project root");
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/tool_policy_snapshot.rs
+1
View File
@@ -56,6 +56,7 @@ pub(crate) fn agent_runtime_executable_tools() -> Vec<&'static str> {
"agent.delegate",
"agent.spawn_isolated",
"agent.schedule_ready",
"agent.route_manifest",
"agent.action_history",
"agent.run_status",
GAME_CREATOR_MCP_CALL_TOOL,
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver.rs
+2 -1
View File
@@ -137,6 +137,7 @@ pub(super) const AGENT_RUNTIME_AUTONOMOUS_GAME_BUILD_AUTO_COMMAND_IDS: &[&str] =
"canvas.asset_generate",
"agent.delegate",
"agent.spawn_isolated",
"agent.route_manifest",
"agent.run_status",
];
pub(crate) const AGENT_RUNTIME_TASK_MAX_CHARS: usize = 4_000;
@@ -239,7 +240,7 @@ pub(in crate::agent) use pending_execution::*;
pub(in crate::agent) use pending_recovery::*;
pub(in crate::agent) use provider_recovery::*;
pub(in crate::agent) use recovery_scan::*;
pub(in crate::agent) use task_queue::*;
pub(crate) use task_queue::*;
pub(in crate::agent) use task_start::*;
#[cfg(test)]
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/game_chat_fast_path.rs
+855 -20
View File
File diff suppressed because it is too large Load Diff
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/interaction.rs
+1
View File
@@ -138,6 +138,7 @@ pub(crate) fn agent_runtime_tool_requires_repository_context_fingerprint_gate(to
| "agent.delegate"
| "agent.spawn_isolated"
| "agent.schedule_ready"
| "agent.route_manifest"
| "agent.action_history"
| GAME_CREATOR_MCP_CALL_TOOL
)
apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop.rs
+230 -95
View File
@@ -26,6 +26,16 @@ pub(in crate::agent) fn autonomous_registered_derived_visuals_need_repair_at(roo
})
}
pub(in crate::agent) fn autonomous_registered_derived_visuals_block_manifest_scheduler_at(
root: &Path,
runtime: &AgentRuntimeState,
) -> bool {
autonomous_registered_derived_visuals_need_repair_at(root)
&& !(runtime.agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
&& runtime.run_profile == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
&& runtime.source == AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE)
}
pub(super) fn game_creator_agent_background_final_reply_fallback(
plan_response: &str,
run_profile: &str,
@@ -65,6 +75,19 @@ fn requested_game_chat_fast_path_plan_at(
})
}
fn game_chat_supervisor_workflow_decision_is_persisted_at(
root: &Path,
runtime: &AgentRuntimeState,
) -> Result<bool, String> {
if runtime.agent_id != GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
|| runtime.run_profile != AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
|| runtime.source != AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE
{
return Ok(true);
}
Ok(read_game_chat_workflow_decision_at(root, &runtime.run_id)?.is_some())
}
async fn request_game_creator_agent_tool_plan_with_game_chat_budget_at(
root: &Path,
runtime: &AgentRuntimeState,
@@ -111,7 +134,9 @@ async fn request_game_creator_agent_tool_plan_with_game_chat_budget_at(
.map(Some)
.map(RequestedAgentRuntimeToolPlanOutcome::Ready);
}
if runtime.agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
if runtime.agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
&& game_chat_supervisor_workflow_decision_is_persisted_at(root, runtime)?
{
return Err(GAME_CHAT_FIXED_TASK_GRAPH_STALLED_ERROR.to_string());
}
let Some(timeout) = game_chat_fast_path_provider_timeout(&budget) else {
@@ -328,10 +353,139 @@ fn latest_game_chat_deadline_runtime_at(
.unwrap_or(fallback)
}
struct GameChatAbsoluteDeadlinePublicStates {
root: AgentRuntimeState,
child: Option<AgentRuntimeState>,
}
fn resolve_game_chat_absolute_deadline_public_states_at(
root: &Path,
runtime: &AgentRuntimeState,
phase: &str,
) -> Result<GameChatAbsoluteDeadlinePublicStates, String> {
let binding = read_game_creator_agent_runtime_run_profile_binding(
root,
&runtime.agent_id,
&runtime.run_id,
)?
.ok_or_else(|| "game-chat 绝对硬截止缺少当前 Run Profile 绑定".to_string())?;
if binding.agent_id != runtime.agent_id
|| binding.run_id != runtime.run_id
|| binding.root_agent_id != GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
|| binding.root_run_id.trim().is_empty()
|| binding.profile != AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
{
return Err("game-chat 绝对硬截止当前 Run Profile 绑定身份不一致".to_string());
}
let root_binding = read_game_creator_agent_runtime_run_profile_binding(
root,
&binding.root_agent_id,
&binding.root_run_id,
)?
.ok_or_else(|| "game-chat 绝对硬截止缺少根 Run Profile 绑定".to_string())?;
if root_binding.agent_id != GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
|| root_binding.run_id != binding.root_run_id
|| root_binding.root_agent_id != root_binding.agent_id
|| root_binding.root_run_id != root_binding.run_id
|| root_binding.parent_agent_id.is_some()
|| root_binding.parent_run_id.is_some()
|| root_binding.source != AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE
|| root_binding.profile != AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
{
return Err("game-chat 绝对硬截止根 Run Profile 绑定身份不一致".to_string());
}
let root_task = read_latest_game_creator_agent_runtime_task_by_run_id(
root,
GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
&root_binding.run_id,
)?
.ok_or_else(|| "game-chat 绝对硬截止缺少根 Supervisor 任务".to_string())?;
if root_task.parent_agent_id.is_some()
|| root_task.parent_run_id.is_some()
|| root_task.session_id.trim().is_empty()
|| root_task.run_profile_binding_fingerprint != root_binding.binding_fingerprint
{
return Err("game-chat 绝对硬截止根 Supervisor 任务身份不一致".to_string());
}
let mut root_state = agent_runtime_state_from_task_record(&root_task);
root_state.status = "failed".to_string();
root_state.phase = phase.to_string();
if runtime.agent_id == root_state.agent_id && runtime.run_id == root_state.run_id {
if runtime.session_id != root_state.session_id
|| runtime.parent_agent_id.is_some()
|| runtime.parent_run_id.is_some()
|| binding.parent_agent_id.is_some()
|| binding.parent_run_id.is_some()
|| runtime.run_profile_binding_fingerprint != root_binding.binding_fingerprint
{
return Err("game-chat 绝对硬截止当前根 Runtime 身份不一致".to_string());
}
return Ok(GameChatAbsoluteDeadlinePublicStates {
root: root_state,
child: None,
});
}
if runtime.agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
|| runtime.session_id.trim().is_empty()
|| runtime.parent_agent_id.as_deref() != Some(root_state.agent_id.as_str())
|| runtime.parent_run_id.as_deref() != Some(root_state.run_id.as_str())
|| binding.parent_agent_id.as_deref() != Some(root_state.agent_id.as_str())
|| binding.parent_run_id.as_deref() != Some(root_state.run_id.as_str())
|| runtime.run_profile_binding_fingerprint != binding.binding_fingerprint
{
return Err("game-chat 绝对硬截止当前专业 Agent Runtime 身份不一致".to_string());
}
let child_task = read_latest_game_creator_agent_runtime_task_by_run_id(
root,
&runtime.agent_id,
&runtime.run_id,
)?
.ok_or_else(|| "game-chat 绝对硬截止缺少当前专业 Agent 任务".to_string())?;
if child_task.session_id != runtime.session_id
|| child_task.parent_agent_id != runtime.parent_agent_id
|| child_task.parent_run_id != runtime.parent_run_id
|| child_task.run_profile_binding_fingerprint != binding.binding_fingerprint
{
return Err("game-chat 绝对硬截止当前专业 Agent 任务身份不一致".to_string());
}
let mut child_state = agent_runtime_state_from_task_record(&child_task);
child_state.status = "failed".to_string();
child_state.phase = phase.to_string();
Ok(GameChatAbsoluteDeadlinePublicStates {
root: root_state,
child: Some(child_state),
})
}
fn append_resolved_game_chat_absolute_deadline_public_messages_at(
root: &Path,
states: &GameChatAbsoluteDeadlinePublicStates,
error: &str,
) -> Result<(), String> {
append_game_creator_agent_runtime_terminal_public_message_at(root, &states.root, error)?;
if let Some(child) = states.child.as_ref() {
append_game_creator_agent_runtime_terminal_public_message_at(root, child, error)?;
}
Ok(())
}
pub(super) fn append_game_chat_absolute_deadline_public_messages_at(
root: &Path,
runtime: &AgentRuntimeState,
phase: &str,
error: &str,
) -> Result<(), String> {
let states = resolve_game_chat_absolute_deadline_public_states_at(root, runtime, phase)?;
append_resolved_game_chat_absolute_deadline_public_messages_at(root, &states, error)
}
pub(super) fn finish_game_chat_absolute_deadline_timeout_at(
root: &Path,
agent_id: &str,
session_id: &str,
_agent_id: &str,
_session_id: &str,
fallback: AgentRuntimeState,
) -> AgentBackgroundTaskOutcome {
let mut runtime = latest_game_chat_deadline_runtime_at(root, fallback);
@@ -362,6 +516,31 @@ pub(super) fn finish_game_chat_absolute_deadline_timeout_at(
GAME_CHAT_FIRST_PLAYABLE_HARD_BUDGET_SECONDS
)
};
// The absolute deadline may itself be handling a broken Runtime state
// projection. Commit the stable user-facing terminal outcome before any
// reconciliation/failure projection, then retry the same idempotent
// message after cleanup below in case the first conversation write was
// transient.
let public_terminal_phase = if preserves_external_reconciliation {
"needs-reconciliation"
} else {
"failed"
};
let public_states = match resolve_game_chat_absolute_deadline_public_states_at(
root,
&runtime,
public_terminal_phase,
) {
Ok(states) => states,
Err(_) => return AgentBackgroundTaskOutcome::Finished,
};
let initial_public_status_error =
append_resolved_game_chat_absolute_deadline_public_messages_at(
root,
&public_states,
&error,
)
.err();
let terminal_failure_error = if let Some(pending) = pending_action
.as_ref()
.filter(|_| preserves_external_reconciliation)
@@ -423,6 +602,9 @@ pub(super) fn finish_game_chat_absolute_deadline_timeout_at(
if let Some(error) = terminal_failure_error {
cleanup_errors.push(sanitize_agent_runtime_text(&error, 160));
}
if let Some(error) = initial_public_status_error {
cleanup_errors.push(sanitize_agent_runtime_text(&error, 160));
}
let _ = append_agent_db_record(
root,
serde_json::json!({
@@ -440,15 +622,10 @@ pub(super) fn finish_game_chat_absolute_deadline_timeout_at(
"cleanupErrorCount": cleanup_errors.len(),
}),
);
let _ = append_local_conversation_message_for_session_at(
let _ = append_resolved_game_chat_absolute_deadline_public_messages_at(
root,
Some(agent_id),
Some(session_id),
LocalConversationMessage {
role: "assistant".to_string(),
content: game_creator_agent_runtime_failure_conversation_message(agent_id, &error),
agent_id: None,
},
&public_states,
&error,
);
AgentBackgroundTaskOutcome::Finished
}
@@ -716,8 +893,21 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
} else {
false
};
let autonomous_manifest_parent_can_wait = agent_id
== GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
let autonomous_manifest_workflow_is_routed =
match game_chat_supervisor_workflow_decision_is_persisted_at(&root, &runtime) {
Ok(value) => value,
Err(error) => {
return fail_game_creator_agent_background_context_at(
&root,
&agent_id,
&session_id,
runtime,
&format!("读取 game-chat Supervisor 工作流决策失败：{error}"),
);
}
};
let autonomous_manifest_parent_can_wait = autonomous_manifest_workflow_is_routed
&& agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
&& runtime.run_profile == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
&& !game_chat_hard_budget_expired
&& !game_creator_agent_runtime_provider_action_batch_exists(
@@ -739,7 +929,9 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
// manifest child；但已经持久化并运行的 child 仍是当前 DAG 的活跃工作，
// 父 Run 必须继续等待，不能提前落入 game-chat fixed-graph-stalled。
let scheduled_ready_tasks =
if autonomous_registered_derived_visuals_need_repair_at(&root) {
if autonomous_registered_derived_visuals_block_manifest_scheduler_at(
&root, &runtime,
) {
Vec::new()
} else {
match schedule_autonomous_game_build_ready_tasks_at(
@@ -1128,19 +1320,24 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
}
if error.starts_with(GAME_CHAT_FIRST_PLAYABLE_HARD_BUDGET_ERROR_PREFIX) {
let error = redact_agent_runtime_error(&root, &error, 500);
let public_runtime = runtime.clone();
let public_states =
match resolve_game_chat_absolute_deadline_public_states_at(
&root,
&public_runtime,
"budget-exhausted",
) {
Ok(states) => states,
Err(_) => return AgentBackgroundTaskOutcome::Finished,
};
let initial_public_status =
append_resolved_game_chat_absolute_deadline_public_messages_at(
&root,
&public_states,
&error,
);
let failed_runtime =
fail_game_creator_agent_runtime_budget_at(&root, runtime, &error);
let _ = append_local_conversation_message_for_session_at(
&root,
Some(&agent_id),
Some(&session_id),
LocalConversationMessage {
role: "assistant".to_string(),
content: "首版素材生成已达到七十五分钟硬上限，本轮已停止，不会继续在后台运行。"
.to_string(),
agent_id: None,
},
);
if let Ok(runtime) = failed_runtime {
let _ = append_game_creator_agent_background_task_failed_audit(
&root,
@@ -1148,23 +1345,19 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
AGENT_RUNTIME_BACKGROUND_FAILURE_KIND_BUDGET,
);
}
if initial_public_status.is_err() {
let _ =
append_resolved_game_chat_absolute_deadline_public_messages_at(
&root,
&public_states,
&error,
);
}
return AgentBackgroundTaskOutcome::Finished;
}
let error = redact_agent_runtime_error(&root, &error, 500);
let failed_runtime =
fail_game_creator_agent_runtime_turn_at(&root, runtime, &error);
let _ = append_local_conversation_message_for_session_at(
&root,
Some(&agent_id),
Some(&session_id),
LocalConversationMessage {
role: "assistant".to_string(),
content: game_creator_agent_runtime_failure_conversation_message(
&agent_id, &error,
),
agent_id: None,
},
);
if let Ok(runtime) = failed_runtime {
let _ = append_game_creator_agent_background_task_failed_audit(
&root,
@@ -2348,18 +2541,6 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
Err(error) => {
let error = redact_agent_runtime_error(&root, &error, 500);
let _ = fail_game_creator_agent_runtime_turn_at(&root, runtime, &error);
let _ = append_local_conversation_message_for_session_at(
&root,
Some(&agent_id),
Some(&session_id),
LocalConversationMessage {
role: "assistant".to_string(),
content: game_creator_agent_runtime_failure_conversation_message(
&agent_id, &error,
),
agent_id: None,
},
);
return AgentBackgroundTaskOutcome::Finished;
}
}
@@ -2474,18 +2655,6 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
{
let error = redact_agent_runtime_error(&root, &error, 500);
let _ = fail_game_creator_agent_runtime_turn_at(&root, runtime, &error);
let _ = append_local_conversation_message_for_session_at(
&root,
Some(&agent_id),
Some(&session_id),
LocalConversationMessage {
role: "assistant".to_string(),
content: game_creator_agent_runtime_failure_conversation_message(
&agent_id, &error,
),
agent_id: None,
},
);
return AgentBackgroundTaskOutcome::Finished;
}
let pre_execution_drift =
@@ -2739,18 +2908,6 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
{
let error = redact_agent_runtime_error(&root, &error, 500);
let _ = fail_game_creator_agent_runtime_turn_at(&root, runtime, &error);
let _ = append_local_conversation_message_for_session_at(
&root,
Some(&agent_id),
Some(&session_id),
LocalConversationMessage {
role: "assistant".to_string(),
content: game_creator_agent_runtime_failure_conversation_message(
&agent_id, &error,
),
agent_id: None,
},
);
return AgentBackgroundTaskOutcome::Finished;
}
if let Err(error) =
@@ -3258,16 +3415,6 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
};
let error = redact_agent_runtime_error(&root, &error, 500);
let failed_runtime = fail_game_creator_agent_runtime_budget_at(&root, runtime, &error);
let _ = append_local_conversation_message_for_session_at(
&root,
Some(&agent_id),
Some(&session_id),
LocalConversationMessage {
role: "assistant".to_string(),
content: format!("后台任务未完成：{error}"),
agent_id: None,
},
);
if let Ok(runtime) = failed_runtime {
let _ = append_game_creator_agent_background_task_failed_audit(
&root,
@@ -3558,18 +3705,6 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
let error = redact_agent_runtime_error(&root, &error, 500);
let failed_runtime =
fail_game_creator_agent_runtime_turn_at(&root, runtime, &error);
let _ = append_local_conversation_message_for_session_at(
&root,
Some(&agent_id),
Some(&session_id),
LocalConversationMessage {
role: "assistant".to_string(),
content: game_creator_agent_runtime_failure_conversation_message(
&agent_id, &error,
),
agent_id: None,
},
);
if let Ok(runtime) = failed_runtime {
let _ = append_game_creator_agent_background_task_failed_audit(
&root,

Some files were not shown because too many files have changed in this diff Show More