babylonjs-editor 5.5.2-alpha.0 → 5.5.2

package/build/src/index.js

@@ -99,7 +99,7 @@ electron_1.ipcMain.on("app:quit", () => {
     }
 });
 let dashboardWindow = null;
-let menuOptions = { enableExperimentalFeatures: false, openedTabs: [] };
+let menuOptions = { enableExperimentalFeatures: false, openedTabs: [], assistantOpen: false };
 electron_1.ipcMain.on("editor:setup-menu", (_, options) => {
     menuOptions = options;
     (0, menu_1.setupEditorMenu)(options);

package/declaration/src/editor/layout/assets-browser/events/gui.d.ts

@@ -1,2 +1,9 @@
 import { Editor } from "../../../main";
 export declare function listenGuiAssetsEvents(editor: Editor): void;
+/**
+ * Parses again the content of the GUI of the scene created from the given serialized GUI, matched by its unique id.
+ * @param editor defines the reference to the editor.
+ * @param data defines the content of the GUI asset (.gui).
+ * @returns the number of GUI reloaded.
+ */
+export declare function reloadGuiTexture(editor: Editor, data: any): number;

package/declaration/src/editor/layout/assets-browser/events/material.d.ts

@@ -1,2 +1,9 @@
+import { NodeMaterial } from "babylonjs";
 import { Editor } from "../../../main";
 export declare function listenMaterialAssetsEvents(editor: Editor): void;
+/**
+ * Rebuilds the given node material from the given serialized node material.
+ * @param material defines the node material of the scene to rebuild.
+ * @param materialData defines the content of the node material asset (.material).
+ */
+export declare function reloadNodeMaterial(material: NodeMaterial, materialData: any): void;

package/declaration/src/editor/layout/assets-browser/events/particles.d.ts

@@ -1,2 +1,10 @@
 import { Editor } from "../../../main";
 export declare function listenParticleAssetsEvents(editor: Editor): void;
+/**
+ * Rebuilds every node particle system set of the scene created from the given serialized node particle system
+ * set, matched by its id.
+ * @param editor defines the reference to the editor.
+ * @param particlesData defines the content of the node particle system set asset (.npss).
+ * @returns the number of node particle system sets rebuilt.
+ */
+export declare function reloadNodeParticleSystemSets(editor: Editor, particlesData: any): Promise<number>;

package/declaration/src/editor/layout/assets-browser/events/scene.d.ts

@@ -1,2 +1,9 @@
 import { Editor } from "../../../main";
 export declare function listenSceneAssetsEvents(editor: Editor): void;
+/**
+ * Reloads every link of the current scene to the given scene.
+ * @param editor defines the reference to the editor.
+ * @param absolutePath defines the absolute path of the linked scene (.scene).
+ * @returns the number of scene links reloaded.
+ */
+export declare function reloadSceneLinks(editor: Editor, absolutePath: string): Promise<number>;

package/declaration/src/editor/layout/assets-browser.d.ts

@@ -37,6 +37,7 @@ export declare class EditorAssetsBrowser extends Component<IEditorAssetsBrowserP
      * Returns wether or not the currently browsed folder is the /src folder.
      */
     isSrcFolder(): boolean;
+    private _isAgentDataFolder;
     private _refreshFilesTreeNodes;
     /**
      * Sets the new path being browsed by the assets browser.

package/declaration/src/editor/layout/assistant/agents.d.ts

@@ -0,0 +1,47 @@
+import { IAssistantExecutable } from "./executable";
+/**
+ * Defines the coding agents the AI assistant can run.
+ */
+export type EditorAssistantAgentId = "claude" | "codex" | "antigravity";
+export interface IEditorAssistantAgent {
+    /**
+     * Defines the identifier of the agent, used to remember the choice of the user.
+     */
+    id: EditorAssistantAgentId;
+    /**
+     * Defines the name of the agent shown to the user.
+     */
+    name: string;
+    /**
+     * Defines the name of the model the agent talks with, shown to the user.
+     */
+    modelName: string;
+    /**
+     * Defines the account the user signs in with in the agent.
+     */
+    account: string;
+    /**
+     * Defines the desktop app that comes with the agent, if any.
+     */
+    desktopApp: string | null;
+    /**
+     * Defines the URL of the documentation explaining how to install the agent.
+     */
+    setupUrl: string;
+    /**
+     * Returns the command installing the agent, run in PowerShell on Windows and in a terminal elsewhere.
+     * @param windows defines wether or not the user is on Windows.
+     */
+    getInstallCommand(windows: boolean): string;
+    /**
+     * Finds the executable of the agent installed on this computer.
+     * @param customPath defines the path of the executable chosen by the user, if any.
+     */
+    findExecutable(customPath?: string | null): Promise<IAssistantExecutable | null>;
+}
+export declare const assistantAgents: IEditorAssistantAgent[];
+/**
+ * Returns the agent of the given identifier, or Claude Code when it is not known.
+ * @param id defines the identifier of the agent, as stored in the preferences of the user.
+ */
+export declare function getAssistantAgent(id: string | null): IEditorAssistantAgent;

package/declaration/src/editor/layout/assistant/antigravity.d.ts

@@ -0,0 +1,107 @@
+import type { EditorAssistantWorkState, IAssistantHooksServer } from "./hooks";
+import { IAssistantMcpConfigurationOptions } from "./config";
+import { IAssistantExecutable, IExecutableLocationOptions } from "./executable";
+/**
+ * Defines the name of the plugin the assistant gives to Antigravity CLI: its MCP server is "babylonjs_editor" in
+ * Antigravity CLI, which prefixes the MCP servers of plugins with their name. Kept short: Antigravity CLI refuses the
+ * tools whose full name, "mcp_babylonjs_editor_<tool>", is longer than 64 characters.
+ */
+export declare const antigravityPluginName = "babylonjs";
+/**
+ * Defines the description of the plugin, which also tells it was written by the editor.
+ */
+export declare const antigravityPluginDescription = "Babylon.js Editor: the tools and skills of the editor, added by its AI assistant while it runs Antigravity CLI.";
+/**
+ * Defines the name of the folder of the plugin holding one file per session of the assistant using it, with the
+ * identifier of the process of its editor window.
+ */
+export declare const antigravityPluginSessionsDirectoryName = ".sessions";
+/**
+ * Defines the hook events of Antigravity CLI the assistant follows to know what it is doing. "PreToolUse" is not one of
+ * them: Antigravity CLI denies the tool when its hook doesn't decide.
+ */
+export declare const antigravityHookEvents: string[];
+/**
+ * Defines the answer the hooks server of the assistant gives to Antigravity CLI, which reads the output of its hooks as
+ * JSON: an empty object lets it go on as if there was no hook.
+ */
+export declare const antigravityHookAnswer = "{}";
+/**
+ * Returns the paths where the installers of Antigravity CLI put its executable, in order of preference.
+ * @param options defines the platform, the home directory and the environment of the user.
+ */
+export declare function getAntigravityInstallationCandidates(options?: IExecutableLocationOptions): string[];
+/**
+ * Extracts the version of Antigravity CLI from the output of "agy --version", e.g. "1.2.12": Antigravity CLI prints
+ * the version alone.
+ * @param output defines the output of the command.
+ */
+export declare function parseAntigravityVersion(output: string): string | null;
+/**
+ * Finds the Antigravity CLI executable installed on this computer: the one chosen by the user, the one in the PATH of
+ * the user, then the one the installers of Antigravity CLI create.
+ * @param customPath defines the path of the executable chosen by the user, if any.
+ * @returns the first executable that answers "agy --version", or null when none is found.
+ */
+export declare function findAntigravityExecutable(customPath?: string | null): Promise<IAssistantExecutable | null>;
+/**
+ * Returns the absolute path of the plugin of the assistant among the plugins of the user: Antigravity CLI can't be
+ * given MCP servers nor plugins for a single session, and doesn't load the ones of the project before the user signed
+ * in.
+ * @param options defines the platform, the home directory and the environment of the user.
+ */
+export declare function getAntigravityPluginDirectory(options?: IExecutableLocationOptions): string;
+/**
+ * Returns the hooks of the plugin: each hook event is sent to the hooks server of the assistant with curl, which comes
+ * with macOS, Windows and most Linux distributions. Like the MCP server, the hooks get the URL and the token of the
+ * server from the environment of Antigravity CLI, which runs them with "sh -c" or "cmd /c".
+ * @param platform defines the platform of the user.
+ */
+export declare function createAntigravityHooks(platform?: NodeJS.Platform): object;
+/**
+ * Returns what the assistant is doing after the given hook event of Antigravity CLI.
+ * @param event defines the name of the hook event.
+ */
+export declare function getAssistantWorkStateAfterAntigravityHook(event: string): EditorAssistantWorkState;
+/**
+ * Returns wether or not the given output of Antigravity CLI, without its escape sequences, asks the user to allow a
+ * tool, a command or a URL.
+ * @param text defines the output of Antigravity CLI.
+ */
+export declare function isAntigravityApprovalPrompt(text: string): boolean;
+/**
+ * Returns the MCP configuration of the plugin: the MCP server of the editor, run by the executable of the editor itself.
+ * It has no token nor URL: it gets the ones of the editor window from the environment of Antigravity CLI, which the
+ * processes it starts inherit.
+ * @param options defines the MCP server of the editor.
+ */
+export declare function createAntigravityMcpConfiguration(options: IAssistantMcpConfigurationOptions): object;
+/**
+ * Writes the plugin of the assistant among the plugins of Antigravity CLI for the given session: the MCP server of the
+ * editor, its skills and the hooks telling the assistant what Antigravity CLI is doing. A plugin of the same name that
+ * wasn't written by the editor is left untouched.
+ * @param sessionId defines the identifier of the session of the assistant.
+ * @param options defines the MCP server of the editor.
+ * @param skillsPluginDirectory defines the absolute path of the plugin of the assistant bundled with the editor, holding
+ * its skills, if built.
+ * @throws when a plugin of the same name, not written by the editor, exists.
+ */
+export declare function addAntigravityPlugin(sessionId: string, options: IAssistantMcpConfigurationOptions, skillsPluginDirectory: string | null): Promise<void>;
+/**
+ * Removes the given session from the plugin of the assistant, and the plugin once no session of the assistant uses it
+ * anymore: the other sessions of Antigravity CLI of the user don't start the MCP server of the editor. Never throws.
+ * @param sessionId defines the identifier of the session of the assistant.
+ */
+export declare function removeAntigravityPlugin(sessionId: string): Promise<void>;
+/**
+ * Returns the arguments Antigravity CLI is started with.
+ * @param resume defines wether or not to continue the last conversation of the project instead of starting a new one.
+ */
+export declare function getAntigravityArguments(resume: boolean): string[];
+/**
+ * Returns the environment variables to give to Antigravity CLI so the MCP server of the editor it starts is connected
+ * to the window the assistant belongs to, and its hooks to the assistant.
+ * @param options defines the HTTP server of the editor window.
+ * @param hooksServer defines the HTTP server of the assistant receiving the hook events.
+ */
+export declare function getAntigravityEnvironment(options: IAssistantMcpConfigurationOptions, hooksServer: IAssistantHooksServer): Record<string, string>;

package/declaration/src/editor/layout/assistant/claude.d.ts

@@ -0,0 +1,30 @@
+import { IAssistantExecutable, IExecutableLocationOptions } from "./executable";
+/**
+ * Returns the paths where the installers of Claude Code put its executable, in order of preference.
+ * @param options defines the platform, the home directory and the environment of the user.
+ */
+export declare function getClaudeInstallationCandidates(options?: IExecutableLocationOptions): string[];
+/**
+ * Returns the folder where the Claude desktop app keeps the versions of Claude Code it downloaded, or null when the
+ * platform has no desktop app.
+ * @param options defines the platform, the home directory and the environment of the user.
+ */
+export declare function getClaudeDesktopAppCodeDirectory(options?: IExecutableLocationOptions): string | null;
+/**
+ * Returns the paths the executable of Claude Code can have in a version folder of the Claude desktop app.
+ * @param versionDirectory defines the absolute path of the folder of the version.
+ * @param platform defines the platform of the user.
+ */
+export declare function getClaudeDesktopAppExecutableCandidates(versionDirectory: string, platform: NodeJS.Platform): string[];
+/**
+ * Extracts the version of Claude Code from the output of "claude --version", e.g. "2.1.283 (Claude Code)".
+ * @param output defines the output of the command.
+ */
+export declare function parseClaudeVersion(output: string): string | null;
+/**
+ * Finds the Claude Code executable installed on this computer: the one chosen by the user, the one in the PATH of the
+ * user, the ones the installers of Claude Code create, and finally the one downloaded by the Claude desktop app.
+ * @param customPath defines the path of the executable chosen by the user, if any.
+ * @returns the first executable that answers "claude --version", or null when none is found.
+ */
+export declare function findClaudeExecutable(customPath?: string | null): Promise<IAssistantExecutable | null>;

package/declaration/src/editor/layout/assistant/codex.d.ts

@@ -0,0 +1,84 @@
+import type { EditorAssistantWorkState } from "./hooks";
+import { IAssistantMcpConfigurationOptions } from "./config";
+import { IAssistantExecutable, IExecutableLocationOptions } from "./executable";
+/**
+ * Defines the time, in seconds, Codex waits for the MCP server of the editor to start. It is run by the executable of
+ * the editor, which starts slower than Node.js.
+ */
+export declare const codexMcpStartupTimeout = 30;
+/**
+ * Defines the time, in seconds, Codex waits for a tool of the editor. Importing a large asset takes longer than the 60
+ * seconds Codex waits by default.
+ */
+export declare const codexMcpToolTimeout = 600;
+/**
+ * Defines the items of the title Codex gives to its terminal. The assistant follows what Codex is doing through it:
+ * Codex tells it only there when it doesn't run hooks the user trusted.
+ */
+export declare const codexTerminalTitleItems: string[];
+/**
+ * Defines the oldest version of Codex known to have the "--no-daemon" option: an unknown option makes Codex refuse to
+ * start. The overrides of the configuration can't be given to the shared background server of Codex, which it says in
+ * a warning unless it is told not to use it.
+ */
+export declare const codexNoDaemonMinimumVersion = "0.158.0";
+/**
+ * Defines the instructions given to the model of Codex. Codex doesn't give the instructions of the MCP servers to its
+ * models, and the recent ones only see the tools they search for: without them, the model doesn't know the editor is
+ * connected and edits the files of the project instead. Written without quotes nor line breaks to stay a TOML literal
+ * string (see toTomlString).
+ */
+export declare const codexDeveloperInstructions: string;
+/**
+ * Defines the environment variables Codex gives to the MCP server of the editor. They are given to Codex rather than
+ * written in its arguments, which the other users of the computer can read.
+ */
+export declare const codexForwardedEnvironmentVariables: string[];
+/**
+ * Returns the paths where the installers of Codex put its executable, in order of preference.
+ * @param options defines the platform, the home directory and the environment of the user.
+ */
+export declare function getCodexInstallationCandidates(options?: IExecutableLocationOptions): string[];
+/**
+ * Returns the paths of the executable of Codex the desktop apps of OpenAI come with, in order of preference.
+ * @param options defines the platform, the home directory and the environment of the user.
+ */
+export declare function getCodexDesktopAppCandidates(options?: IExecutableLocationOptions): string[];
+/**
+ * Extracts the version of Codex from the output of "codex --version", e.g. "codex-cli 0.158.0".
+ * @param output defines the output of the command.
+ */
+export declare function parseCodexVersion(output: string): string | null;
+/**
+ * Finds the Codex executable installed on this computer: the one chosen by the user, the one in the PATH of the user,
+ * the ones the installers of Codex create, and finally the one of the desktop apps of OpenAI.
+ * @param customPath defines the path of the executable chosen by the user, if any.
+ * @returns the first executable that answers "codex --version", or null when none is found.
+ */
+export declare function findCodexExecutable(customPath?: string | null): Promise<IAssistantExecutable | null>;
+/**
+ * Returns the given text as a TOML string. It is a literal string when possible: it keeps the backslashes of the paths
+ * on Windows as they are, and has no double quotes, which cmd.exe can't give to the batch file npm creates for Codex.
+ * @param value defines the text to write.
+ */
+export declare function toTomlString(value: string): string;
+/**
+ * Returns the arguments Codex is started with. The MCP server of the editor and the title of the terminal are given as
+ * overrides of the configuration of the user, which stays untouched.
+ * @param options defines the MCP server of the editor, run by the executable of the editor itself so no Node.js
+ * installation is needed.
+ * @param resume defines wether or not to continue the last conversation of the project instead of starting a new one.
+ * @param version defines the version of Codex, like "0.158.0".
+ */
+export declare function getCodexArguments(options: IAssistantMcpConfigurationOptions, resume: boolean, version: string): string[];
+/**
+ * Returns the environment variables to give to Codex so it connects the MCP server of the editor to its window.
+ * @param options defines the HTTP server of the editor window the assistant belongs to.
+ */
+export declare function getCodexEnvironment(options: IAssistantMcpConfigurationOptions): Record<string, string>;
+/**
+ * Returns what Codex is doing according to the title it gives to its terminal, like "⠋ Working", "Ready" or
+ * "[ ! ] Action Required", or null when the title doesn't tell it.
+ * @param title defines the title of the terminal.
+ */
+export declare function getAssistantWorkStateFromCodexTitle(title: string): EditorAssistantWorkState | null;

package/declaration/src/editor/layout/assistant/config.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Defines the name of the MCP server of the editor in the configuration given to Claude Code. Its tools are named
+ * "mcp__babylonjs-editor__<tool>" in Claude Code.
+ */
+export declare const assistantMcpServerName = "babylonjs-editor";
+/**
+ * Defines the time, in seconds, Claude Code waits for the assistant to receive a hook event. The assistant answers
+ * right away: a busy editor must not keep Claude Code waiting for longer.
+ */
+export declare const assistantHookTimeout = 5;
+/**
+ * Defines the tools of the editor Claude Code may use without asking the user first: reading the project, and
+ * composing the scene with content the user sees appear live. Deleting, saving, downloading, writing or running code
+ * (playing the scene runs the scripts of the project) and batches (which can run any tool) keep asking, as Claude
+ * Code does by default.
+ */
+export declare const assistantAllowedEditorTools: string[];
+export interface IAssistantMcpConfigurationOptions {
+    /**
+     * Defines the absolute path of the executable of the editor, which runs the MCP server as Node.js does.
+     */
+    executablePath: string;
+    /**
+     * Defines the absolute path of the bundled MCP server script.
+     */
+    serverScriptPath: string;
+    /**
+     * Defines the URL of the HTTP server of the editor window the assistant belongs to.
+     */
+    url: string;
+    /**
+     * Defines the token the HTTP server of the editor expects.
+     */
+    token: string;
+}
+/**
+ * Creates the MCP configuration given to Claude Code: the MCP server of the editor, run by the executable of the
+ * editor itself so no Node.js installation is needed, and connected to the window the assistant belongs to.
+ */
+export declare function createAssistantMcpConfiguration(options: IAssistantMcpConfigurationOptions): object;
+export interface IAssistantHooksConfigurationOptions {
+    /**
+     * Defines the URL of the HTTP server of the assistant that receives the hook events.
+     */
+    url: string;
+    /**
+     * Defines the token the HTTP server of the assistant expects.
+     */
+    token: string;
+}
+/**
+ * Creates the hooks given to Claude Code so it tells the assistant what it is doing: each event is sent as a POST
+ * request to "<url>/<event>".
+ */
+export declare function createAssistantHooks(options: IAssistantHooksConfigurationOptions): object;
+/**
+ * Creates the additional settings given to Claude Code for the session.
+ * @param hooks defines the HTTP server of the assistant the hook events are sent to, if the version of Claude Code
+ * supports it.
+ */
+export declare function createAssistantSettings(hooks?: IAssistantHooksConfigurationOptions | null): object;
+/**
+ * Defines the oldest version of Claude Code the assistant gives its plugin to. Claude Code refuses to start with an
+ * option it doesn't know, and "--plugin-dir" is known to exist in this version.
+ */
+export declare const assistantPluginMinimumClaudeVersion = "2.1.101";
+/**
+ * Returns wether or not the given version of Claude Code can load the plugin of the assistant for the session.
+ * @param claudeVersion defines the version of Claude Code, like "2.1.283".
+ */
+export declare function supportsAssistantPlugin(claudeVersion: string): boolean;
+/**
+ * Returns the arguments Claude Code is started with.
+ * @param mcpConfigurationPath defines the absolute path of the MCP configuration file.
+ * @param settingsPath defines the absolute path of the settings file.
+ * @param resume defines wether or not to continue the last conversation of the project instead of starting a new one.
+ * @param pluginDirectory defines the absolute path of the plugin of the assistant, holding the skills of the editor,
+ * loaded for the session only.
+ */
+export declare function getClaudeArguments(mcpConfigurationPath: string, settingsPath: string, resume: boolean, pluginDirectory?: string | null): string[];
+/**
+ * Returns the command line cmd.exe runs a batch file (like the "claude.cmd" npm creates) with, on Windows.
+ * @param batchFile defines the absolute path of the batch file.
+ * @param args defines the arguments, which must not contain double quotes.
+ */
+export declare function getWindowsBatchCommandLine(batchFile: string, args: string[]): string;
+/**
+ * Returns the absolute path of the MCP server bundled with the editor. In a packaged editor, it is unpacked from the
+ * asar archive so another process can run it.
+ * @param appPath defines the path of the application, as returned by "app.getAppPath()".
+ */
+export declare function getAssistantMcpServerScriptPath(appPath: string): string;
+/**
+ * Returns the absolute path of the plugin of the assistant bundled with the editor: the skills of the editor, built
+ * from the ones of the website. In a packaged editor, it is unpacked from the asar archive so the agents can read it.
+ * @param appPath defines the path of the application, as returned by "app.getAppPath()".
+ */
+export declare function getAssistantPluginDirectory(appPath: string): string;
+/**
+ * Writes the MCP configuration and the settings of the session in the given folder, only readable by the user as
+ * they hold the tokens of the editor.
+ * @param hooks defines the HTTP server of the assistant the hook events are sent to, if the version of Claude Code
+ * supports it.
+ * @returns the absolute paths of the two files.
+ */
+export declare function writeAssistantConfiguration(directory: string, options: IAssistantMcpConfigurationOptions, hooks?: IAssistantHooksConfigurationOptions | null): Promise<{
+    mcpConfigurationPath: string;
+    settingsPath: string;
+}>;

package/declaration/src/editor/layout/assistant/executable.d.ts

@@ -0,0 +1,80 @@
+export type AssistantExecutableSource = "custom" | "path" | "installation" | "desktop-app";
+export interface IAssistantExecutable {
+    /**
+     * Defines the absolute path of the executable of the agent.
+     */
+    path: string;
+    /**
+     * Defines where the executable was found.
+     */
+    source: AssistantExecutableSource;
+    /**
+     * Defines the version of the agent, as reported by "<executable> --version".
+     */
+    version: string;
+}
+export interface IAssistantExecutableCandidate {
+    /**
+     * Defines the absolute path the executable may have.
+     */
+    path: string;
+    /**
+     * Defines where the executable comes from when it is found at this path.
+     */
+    source: AssistantExecutableSource;
+}
+export interface IExecutableLocationOptions {
+    platform: NodeJS.Platform;
+    home: string;
+    env: NodeJS.ProcessEnv;
+}
+export declare function getDefaultLocationOptions(): IExecutableLocationOptions;
+/**
+ * Compares two versions made of numbers separated by dots, like "2.1.283".
+ * @returns a negative number when a is older than b, a positive one when it is newer, 0 when they are equal.
+ */
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * Extracts the absolute path of the executable from the output of "command -v <command>" (macOS, Linux) or "where
+ * <command>" (Windows). Interactive shells may print other lines, and an alias prints its command.
+ * @param output defines the output of the command.
+ * @param platform defines the platform of the user.
+ * @param command defines the name of the command that was looked up, like "claude".
+ */
+export declare function parseCommandLookupOutput(output: string, platform: NodeJS.Platform, command: string): string | null;
+export declare function execFileOutput(file: string, args: string[], timeout: number): Promise<string | null>;
+/**
+ * Returns the version of the given executable, or null when it is not a working executable of the agent.
+ * @param path defines the absolute path of the executable.
+ * @param parseVersion defines the function extracting the version from the output of "<executable> --version".
+ */
+export declare function getExecutableVersion(path: string, parseVersion: (output: string) => string | null): Promise<string | null>;
+/**
+ * Returns the absolute path of the given command in the PATH of the user, or null when it is not found.
+ * @param command defines the name of the command, like "claude".
+ */
+export declare function findCommandInPath(command: string): Promise<string | null>;
+export interface IFindExecutableOptions {
+    /**
+     * Defines the name of the command of the agent, looked up in the PATH of the user.
+     */
+    command: string;
+    /**
+     * Defines the path of the executable chosen by the user, if any.
+     */
+    customPath?: string | null;
+    /**
+     * Defines the function extracting the version from the output of "<executable> --version".
+     */
+    parseVersion: (output: string) => string | null;
+    /**
+     * Defines the function returning the other paths the executable may have, in order of preference.
+     */
+    getCandidates: () => Promise<IAssistantExecutableCandidate[]>;
+}
+/**
+ * Finds the executable of an agent installed on this computer: the one chosen by the user, the one in the PATH of the
+ * user, then the given candidates.
+ * @returns the first executable that answers "<executable> --version", or null when none is found.
+ */
+export declare function findExecutable(options: IFindExecutableOptions): Promise<IAssistantExecutable | null>;

package/declaration/src/editor/layout/assistant/hooks.d.ts

@@ -0,0 +1,105 @@
+import { IncomingMessage, ServerResponse } from "http";
+/**
+ * Defines what the AI assistant is doing: nothing, working on a request of the user, or waiting for the user to answer
+ * it, to allow a tool for example.
+ */
+export type EditorAssistantWorkState = "idle" | "working" | "waiting";
+/**
+ * Defines the oldest version of Claude Code the assistant follows with hooks. HTTP hooks exist since 2.1.63, and before
+ * 2.1.101 a hook event Claude Code didn't know made it ignore the whole settings file, permissions included.
+ */
+export declare const assistantHooksMinimumClaudeVersion = "2.1.101";
+/**
+ * Defines the hook events of Claude Code the assistant follows to know what it is doing. Claude Code sends each of them
+ * to the HTTP server of the assistant as a POST request on "/<event>".
+ */
+export declare const assistantHookEvents: string[];
+/**
+ * Defines the fields of the input of the hook events the assistant reads.
+ */
+export interface IAssistantHookInput {
+    /**
+     * Defines the type of the notification, for "Notification" events.
+     */
+    notification_type?: string;
+    /**
+     * Defines the text of the notification, for "Notification" events.
+     */
+    message?: string;
+    /**
+     * Defines the type of the error, for "StopFailure" events.
+     */
+    error?: string;
+    /**
+     * Defines the last message of the turn, which is the text of the error for "StopFailure" events.
+     */
+    last_assistant_message?: string;
+    /**
+     * Defines why Antigravity CLI stopped, like "NO_TOOL_CALL" or "error", for its "Stop" events.
+     */
+    terminationReason?: string;
+}
+export interface IAssistantHooksServer {
+    /**
+     * Defines the URL of the server, on the loopback interface.
+     */
+    readonly url: string;
+    /**
+     * Defines the token the requests must send in the "x-babylonjs-editor-token" header.
+     */
+    readonly token: string;
+    /**
+     * Stops listening.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Returns wether or not the given version of Claude Code can tell the assistant what it is doing through hooks.
+ * @param claudeVersion defines the version of Claude Code, like "2.1.283".
+ */
+export declare function supportsAssistantHooks(claudeVersion: string): boolean;
+/**
+ * Returns wether or not the given "Notification" hook event tells that Claude Code waits for the user to answer.
+ * @param input defines the input of the hook event.
+ */
+export declare function isAssistantInputNotification(input: IAssistantHookInput): boolean;
+/**
+ * Returns what the assistant is doing after the given hook event of Claude Code.
+ * @param state defines what the assistant was doing.
+ * @param event defines the name of the hook event.
+ * @param input defines the input of the hook event.
+ */
+export declare function getAssistantWorkStateAfterHook(state: EditorAssistantWorkState, event: string, input: IAssistantHookInput): EditorAssistantWorkState;
+/**
+ * Returns what the assistant is doing after the user typed the given data in its terminal. Claude Code stops the
+ * current request, without running any hook, when the user presses Escape or Ctrl+C.
+ * @param state defines what the assistant was doing.
+ * @param data defines the data typed by the user.
+ */
+export declare function getAssistantWorkStateAfterInput(state: EditorAssistantWorkState, data: string): EditorAssistantWorkState;
+export interface IAssistantHooksServerOptions {
+    /**
+     * Defines the hook events the server accepts. Defaults to the ones of Claude Code.
+     */
+    events?: string[];
+    /**
+     * Defines the body of the answers, which the agent reads as the result of the hook. Defaults to an empty body, which
+     * lets Claude Code go on as if there was no hook.
+     */
+    body?: string;
+}
+/**
+ * Creates the function handling the hook events the agent sends to the assistant. It always answers with the same body,
+ * which lets the agent go on as if there was no hook.
+ * @param token defines the token requests must send in the "x-babylonjs-editor-token" header.
+ * @param onHook defines the function called with the name and the input of each hook event.
+ * @param options defines the events accepted and the body of the answers.
+ */
+export declare function createAssistantHooksListener(token: string, onHook: (event: string, input: IAssistantHookInput) => void, options?: IAssistantHooksServerOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+/**
+ * Starts the HTTP server the agent sends the hook events of the assistant to. It only listens on the loopback
+ * interface, on a port chosen by the system, and expects a new random token.
+ * @param onHook defines the function called with the name and the input of each hook event.
+ * @param options defines the events accepted and the body of the answers.
+ */
+export declare function startAssistantHooksServer(onHook: (event: string, input: IAssistantHookInput) => void, options?: IAssistantHooksServerOptions): Promise<IAssistantHooksServer>;

package/declaration/src/editor/layout/assistant/icon.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from "react";
+import type { EditorAssistantWorkState } from "./hooks";
+export interface IEditorAssistantIconProps {
+    /**
+     * Defines what the assistant is doing.
+     */
+    workState: EditorAssistantWorkState;
+    /**
+     * Defines the size of the icon, in pixels.
+     */
+    size: number;
+    /**
+     * Defines wether or not the icon is painted with a multicolor gradient instead of the color of the text. The
+     * spinner shown while the assistant works always has the color of the text.
+     */
+    multicolor?: boolean;
+}
+/**
+ * Displays the icon of the AI assistant: a spinner while it works, and a dot while it waits for the user to answer.
+ */
+export declare function EditorAssistantIcon(props: IEditorAssistantIconProps): ReactNode;