feat(scene): support host-provided Scene command routing

.github/workflows/check-dts.yml

@@ -71,15 +71,15 @@ jobs:
             local diff_output="$1"
             local noise_filter='grep -v "^exports\[" | grep -v "^$" | grep -v "^[[:space:]]*$" | grep -v "^\`;" | grep -v "^[[:space:]]*}[;,]\?$" | grep -v "^export { }$" | grep -v "^[[:space:]]*static readonly version" | grep -v "^export { .*_[0-9]\+ as "'
 
-            # Extract deleted lines (strip leading -, normalize quotes and Object casing)
+            # Extract deleted lines (strip leading -, normalize non-semantic syntax differences)
             local deleted
             deleted=$(echo "$diff_output" | grep '^-' | grep -v '^---' | sed 's/^-//' \
-              | eval "$noise_filter" | sed "s/\"/'/g; s/\bObject\b/object/g" | sort -u || true)
+              | eval "$noise_filter" | sed "s/\"/'/g; s/\bObject\b/object/g; s/,[[:space:]]*$//" | sort -u || true)
 
-            # Extract added lines (strip leading +, normalize quotes and Object casing)
+            # Extract added lines (strip leading +, normalize non-semantic syntax differences)
             local added
             added=$(echo "$diff_output" | grep '^+' | grep -v '^+++' | sed 's/^+//' \
-              | eval "$noise_filter" | sed "s/\"/'/g; s/\bObject\b/object/g" | sort -u || true)
+              | eval "$noise_filter" | sed "s/\"/'/g; s/\bObject\b/object/g; s/,[[:space:]]*$//" | sort -u || true)
 
             # Lines in deleted but NOT in added = truly removed
             if [ -n "$deleted" ]; then

packages/cocos-cli-types/__tests__/__snapshots__/dts-snapshot.test.ts.snap

@@ -7567,6 +7567,7 @@ export { }
 
 exports[`DTS API compatibility index.d.ts should match snapshot 1`] = `
 "import { __private } from 'cc';
+import type { ChildProcess } from 'child_process';
 import { ChunkInfo } from '@cocos/creator-programming-quick-pack/lib/loader';
 import { EventEmitter } from 'events';
 import { default as i18n_2 } from 'i18next';
@@ -8070,6 +8071,7 @@ export declare function get<T>(key: string, scope?: ConfigurationScope): Promise
 export declare function get_2(): Promise<Project_2>;
 export declare function getConfig(useDefault?: boolean): Promise<IEngineConfig>;
 export declare function getConfigPath(scope?: ConfigurationScope): Promise<string>;
+export declare function getCurrentToolCallContext(): Readonly<McpToolCallContext> | undefined;
 export declare function getInfo(): Promise<EngineInfo>;
 export declare function getInfo_2(): Promise<ProjectInfo>;
 export declare function getMetadata(): Promise<ICocosConfigurationNode[]>;
@@ -8615,6 +8617,12 @@ export declare interface IResolvedCustomJointTextureLayout {
     textureLength: number;
     contents: IResolvedChunkContent[];
 }
+export declare interface ISceneCommandProvider {
+    request(module: string, method: string, args?: any[], options?: SceneCommandRequestOptions): Promise<any>;
+    notify?(module: string, method: string, args?: any[]): void;
+    isConnect?(): boolean | undefined;
+    dispose?(): void;
+}
 export declare interface ISocketConfig {
     connection: (socket: any) => void;
     disconnect: (socket: any) => void;
@@ -8778,9 +8786,19 @@ export declare namespace Mcp {
     export {
         register,
         unregister,
-        getStatus
+        getStatus,
+        McpToolCallContext,
+        McpToolCallLifecycleState,
+        getCurrentToolCallContext,
+        registerToolCallFinalizer
     }
 }
+export declare interface McpToolCallContext {
+    readonly operationId: string;
+    readonly lifecycleState: McpToolCallLifecycleState;
+    getHeader(name: string): string | undefined;
+}
+export declare type McpToolCallLifecycleState = 'running' | 'completing' | 'completed';
 export declare interface MeshClusterOptions {
     enable: boolean;
     coneCluster?: boolean;
@@ -9036,6 +9054,7 @@ export declare function queryUUID(urlOrPath: string): Promise<string | null>;
 export declare function refresh(dir: string): Promise<number>;
 export declare function register(): Promise<string>;
 export declare function register_2(name: string, module: IMiddlewareContribution): Promise<void>;
+export declare function registerToolCallFinalizer(key: string | symbol, callback: () => void | Promise<void>): void;
 export declare function reimportAsset(pathOrUrlOrUUID: string): Promise<IAssetInfo>;
 export declare function reload(): Promise<void>;
 export declare function remove(key: string, scope?: ConfigurationScope): Promise<boolean>;
@@ -9044,6 +9063,7 @@ export declare interface RenderTextureAssetUserData extends TextureBaseAssetUser
     width: number;
     height: number;
 }
+export declare function resetCommandProvider(): void;
 export declare interface RtSpriteFrameAssetUserData {
     imageUuidOrDatabaseUri: string;
     width?: number;
@@ -9056,9 +9076,21 @@ export declare function saveSerializedData(uuidOrUrlOrPath: string, patch: Seria
 export declare namespace Scene {
     export {
         init_6 as init,
-        startupWorker
+        startupWorker,
+        setCommandProvider,
+        resetCommandProvider,
+        ISceneCommandProvider,
+        SceneCommandProviderRegistration,
+        SceneCommandRequestOptions,
+        WorkerSceneCommandProvider
     }
 }
+export declare interface SceneCommandProviderRegistration {
+    dispose(): void;
+}
+export declare interface SceneCommandRequestOptions {
+    timeout?: number;
+}
 export declare namespace Scripting {
     export {
         init_7 as init,
@@ -9108,6 +9140,7 @@ export declare namespace Server {
     }
 }
 export declare function set<T>(key: string, value: T, scope?: ConfigurationScope): Promise<boolean>;
+export declare function setCommandProvider(provider: ISceneCommandProvider): SceneCommandProviderRegistration;
 export declare function setFileSystemProvider(provider: IAssetFileSystemProvider): void;
 export declare interface SharedSettings {
     useDefineForClassFields: boolean;
@@ -9238,11 +9271,38 @@ export declare interface Vec4 {
     z: number;
     w: number;
 }
+export declare class WorkerSceneCommandProvider implements ISceneCommandProvider {
+    private readonly rpc;
+    constructor(process: ChildProcess | NodeJS.Process);
+    request(module: string, method: string, args?: any[], options?: SceneCommandRequestOptions): Promise<any>;
+    notify(module: string, method: string, args?: any[]): void;
+    isConnect(): boolean | undefined;
+    dispose(): void;
+}
 export declare type WrapMode = 'repeat' | 'clamp-to-edge' | 'mirrored-repeat';
 export { }
 "
 `;
 
+exports[`DTS API compatibility mcp.d.ts should match snapshot 1`] = `
+"export declare function getCurrentToolCallContext(): Readonly<McpToolCallContext> | undefined;
+export declare function getStatus(): {
+    registered: boolean;
+    url?: string;
+};
+export declare interface McpToolCallContext {
+    readonly operationId: string;
+    readonly lifecycleState: McpToolCallLifecycleState;
+    getHeader(name: string): string | undefined;
+}
+export declare type McpToolCallLifecycleState = 'running' | 'completing' | 'completed';
+export declare function register(): Promise<string>;
+export declare function registerToolCallFinalizer(key: string | symbol, callback: () => void | Promise<void>): void;
+export declare function unregister(): Promise<void>;
+export { }
+"
+`;
+
 exports[`DTS API compatibility project.d.ts should match snapshot 1`] = `
 "export declare function close_2(): Promise<void>;
 export { close_2 as close }
@@ -9309,6 +9369,36 @@ export { }
 "
 `;
 
+exports[`DTS API compatibility scene.d.ts should match snapshot 1`] = `
+"import type { ChildProcess } from 'child_process';
+export declare function init(): Promise<void>;
+export declare interface ISceneCommandProvider {
+    request(module: string, method: string, args?: any[], options?: SceneCommandRequestOptions): Promise<any>;
+    notify?(module: string, method: string, args?: any[]): void;
+    isConnect?(): boolean | undefined;
+    dispose?(): void;
+}
+export declare function resetCommandProvider(): void;
+export declare interface SceneCommandProviderRegistration {
+    dispose(): void;
+}
+export declare interface SceneCommandRequestOptions {
+    timeout?: number;
+}
+export declare function setCommandProvider(provider: ISceneCommandProvider): SceneCommandProviderRegistration;
+export declare function startupWorker(projectPath: string): Promise<void>;
+export declare class WorkerSceneCommandProvider implements ISceneCommandProvider {
+    private readonly rpc;
+    constructor(process: ChildProcess | NodeJS.Process);
+    request(module: string, method: string, args?: any[], options?: SceneCommandRequestOptions): Promise<any>;
+    notify(module: string, method: string, args?: any[]): void;
+    isConnect(): boolean | undefined;
+    dispose(): void;
+}
+export { }
+"
+`;
+
 exports[`DTS API compatibility scripting.d.ts should match snapshot 1`] = `
 "import { ChunkInfo } from '@cocos/creator-programming-quick-pack/lib/loader';
 export declare enum AssetActionEnum {

packages/cocos-cli-types/__tests__/dts-snapshot.test.ts

@@ -11,7 +11,9 @@ const dtsFiles = [
     'cli.d.ts',
     'configuration.d.ts',
     'engine.d.ts',
+    'mcp.d.ts',
     'project.d.ts',
+    'scene.d.ts',
     'scripting.d.ts',
 ];
 

src/api/scene/scene.ts

@@ -18,7 +18,8 @@ import {
 } from './schema';
 import { description, param, result, title, tool } from '../decorator/decorator.js';
 import { COMMON_STATUS, CommonResultType, getCommonErrorStatus } from '../base/schema-base';
-import { Scene, TSceneTemplateType } from '../../core/scene';
+import { Scene } from '../../core/scene';
+import { assetManager } from '../../core/assets';
 import { ComponentApi } from './component';
 import { NodeApi } from './node';
 import { PrefabApi } from './prefab';
@@ -126,16 +127,22 @@ export class SceneApi {
     @result(SchemaCreateResult)
     async createScene(@param(SchemaCreateOptions) options: TCreateOptions): Promise<CommonResultType<TCreateResult>> {
         try {
-            const data = await Scene.create({
-                type: 'scene',
-                baseName: options.baseName,
-                targetDirectory: options.dbURL,
-                templateType: options.templateType as TSceneTemplateType,
-            });
-
+            const assetInfo = await assetManager.createAssetByType(
+                'scene',
+                options.dbURL,
+                options.baseName,
+                { templateName: options.templateType ?? '2d' },
+            );
+            const data: TCreateResult = {
+                assetName: assetInfo.name,
+                assetUuid: assetInfo.uuid,
+                assetUrl: assetInfo.url,
+                assetType: assetInfo.type,
+            };
+
             return {
                 code: COMMON_STATUS.SUCCESS,
-                data: data as TCreateResult,
+                data,
             };
         } catch (e) {
             console.error(e);