diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts index 2fd2abedcc57f..709a8315820ed 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts @@ -705,4 +705,36 @@ it.layer(layerTest)("AntigravityDriver", (it) => { expect(yield* fs.exists(legacyRoot)).toBe(false); }), ); + + it.effect.skipIf(windowsHost)( + "rechecks startup configuration after prepareSpawn before spawning ACP for text generation", + () => + Effect.gen(function* () { + const path = yield* Path.Path; + const h = yield* makeHarness(); + const pluginDirectory = path.join(h.profileDirectory, "config", "plugins", "late-hooks"); + h.controls.beforeAcquire = h.fs + .makeDirectory(pluginDirectory, { recursive: true }) + .pipe( + Effect.andThen( + h.fs.writeFileString( + path.join(pluginDirectory, "hooks.json"), + '{"default":{"SessionStart":[{"command":"echo hi"}]}}', + ), + ), + Effect.orDie, + ); + const error = yield* h.instance.textGeneration + .generateThreadTitle({ + cwd: h.profileDirectory, + message: "Name this thread", + modelSelection: { instanceId: h.instance.instanceId, model: "gemini-test-low" }, + }) + .pipe(Effect.flip); + expect(error._tag).toBe("TextGenerationError"); + expect(error.detail).toContain("hooks or MCP configuration"); + expect(h.launches.filter((launch) => launch.tempDirectory !== undefined)).toEqual([]); + yield* h.assertClosed; + }), + ); }); diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.ts b/apps/server/src/provider/Drivers/AntigravityDriver.ts index df84bcb74914b..f38acbc244485 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.ts @@ -29,6 +29,7 @@ import * as AcpErrors from "effect-acp/errors"; import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; import { + ANTIGRAVITY_TEXT_GENERATION_UNAVAILABLE_MESSAGE, isAntigravityTextGenerationAvailable, makeAntigravityTextGeneration, } from "../../textGeneration/AntigravityTextGeneration.ts"; @@ -292,7 +293,9 @@ export const AntigravityDriver: ProviderDriver< }); const makeRuntime = Effect.fn("AntigravityDriver.makeRuntime")(function* ( - input: AntigravityAdapterV2RuntimeInput, + input: AntigravityAdapterV2RuntimeInput & { + readonly beforeSpawn?: Effect.Effect; + }, ): Effect.fn.Return< AcpSessionRuntime.AcpSessionRuntime["Service"], AcpErrors.AcpError | ProviderSetupError, @@ -300,13 +303,14 @@ export const AntigravityDriver: ProviderDriver< > { // `buildAntigravityAcpSpawnInput` sets `extendEnv: false`, so thread variables only reach the // agent's shell through `baseEnv`. - const { processEnvironment: threadEnvironment, ...runtimeInput } = input; + const { processEnvironment: threadEnvironment, beforeSpawn, ...runtimeInput } = input; const { executable, spawn } = yield* prepareSpawn( runtimeInput.cwd, threadEnvironment === undefined ? processEnvironment : { ...processEnvironment, ...threadEnvironment }, ); + if (beforeSpawn) yield* beforeSpawn; const runtime = yield* makeAntigravityAcpRuntime({ ...runtimeInput, runtimeVersion: executable.version, @@ -565,6 +569,14 @@ export const AntigravityDriver: ProviderDriver< Effect.provideService(Digest.Digest, digest), Effect.provideService(HttpClient.HttpClient, httpClient), ); + const textGenerationAvailable = isAntigravityTextGenerationAvailable({ + profileDirectory, + userHome, + }).pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + Effect.orElseSucceed(() => false), + ); const provider = yield* makeAntigravityProvider(settings, { environment: processEnvironment, stampIdentity: classifyModels, @@ -572,14 +584,7 @@ export const AntigravityDriver: ProviderDriver< probeUsage: usage.probe, clearUsage: usage.clear, auth: { type: auth.authMethod, label: antigravityAuthLabel(auth.authMethod) }, - supportsTextGeneration: isAntigravityTextGenerationAvailable({ - profileDirectory, - userHome, - }).pipe( - Effect.provideService(FileSystem.FileSystem, fileSystem), - Effect.provideService(Path.Path, path), - Effect.orElseSucceed(() => false), - ), + supportsTextGeneration: textGenerationAvailable, }).pipe( Effect.mapError( (cause) => @@ -631,6 +636,20 @@ export const AntigravityDriver: ProviderDriver< makeRuntime({ cwd, mcpServers: [], + // Recheck after prepareSpawn prepares the profile, before spawning ACP. + beforeSpawn: textGenerationAvailable.pipe( + Effect.flatMap((available) => + available + ? Effect.void + : Effect.fail( + new ProviderSetupError({ + instanceId, + operation: "textGeneration", + detail: ANTIGRAVITY_TEXT_GENERATION_UNAVAILABLE_MESSAGE, + }), + ), + ), + ), }), }); diff --git a/apps/server/src/provider/Drivers/AntigravitySkills.test.ts b/apps/server/src/provider/Drivers/AntigravitySkills.test.ts index eae7a05b75843..ab032b64dce46 100644 --- a/apps/server/src/provider/Drivers/AntigravitySkills.test.ts +++ b/apps/server/src/provider/Drivers/AntigravitySkills.test.ts @@ -169,13 +169,14 @@ it.layer(NodeServices.layer)("discoverAntigravitySkills", (it) => { const config = path.join(input.userHome, ".gemini", "config"); const profileConfig = path.join(input.profileDirectory, "config"); for (const [plugin, manifest, text] of [ - ["on", "plugin.json"], + ["on", "plugin.json", '{"skills":["./extra-skills"]}'], ["ag", ".antigravity-plugin/plugin.json"], ["gem", ".gemini-plugin/plugin.json"], ["off", "plugin.json"], ["bare", undefined], ["profile-off", "plugin.json"], ["shadowed", "plugin.json"], + ["blocked-by-file", "plugin.json"], ["invalid", "plugin.json", "{"], ["string-flag", "plugin.json", '{"disabled":"yes"}'], ["null-flag", "plugin.json", '{"disabled":null}'], @@ -192,6 +193,15 @@ it.layer(NodeServices.layer)("discoverAntigravitySkills", (it) => { yield* fileSystem.writeFileString(path.join(directory, manifest), text ?? "{}"); } } + yield* writeSkill( + path.join(config, "plugins", "on", "extra-skills", "extra"), + "---\nname: extra\n---\n", + ); + // Root manifest disabled, but .antigravity-plugin/plugin.json takes precedence. + yield* fileSystem.writeFileString( + path.join(config, "plugins", "ag", "plugin.json"), + '{"disabled":true}', + ); yield* fileSystem.writeFileString( path.join(config, "config.json"), JSON.stringify({ @@ -206,6 +216,10 @@ it.layer(NodeServices.layer)("discoverAntigravitySkills", (it) => { path.join(profileConfig, "plugins", "shadowed", "skills", "own"), "---\nname: profile-shadowed\n---\n", ); + yield* fileSystem.writeFileString( + path.join(profileConfig, "plugins", "blocked-by-file"), + "not a directory", + ); yield* fileSystem.writeFileString( path.join(profileConfig, "config.json"), JSON.stringify({ @@ -222,6 +236,7 @@ it.layer(NodeServices.layer)("discoverAntigravitySkills", (it) => { (yield* discoverAntigravitySkills(input)).map((skill) => [skill.name, skill.scope]), [ ["ag", "user"], + ["extra", "user"], ["gem", "user"], ["null-flag", "user"], ["on", "user"], diff --git a/apps/server/src/provider/Drivers/AntigravitySkills.ts b/apps/server/src/provider/Drivers/AntigravitySkills.ts index 06785db77bf9f..b0ec67c01aafd 100644 --- a/apps/server/src/provider/Drivers/AntigravitySkills.ts +++ b/apps/server/src/provider/Drivers/AntigravitySkills.ts @@ -71,7 +71,10 @@ const decodePluginPreferences = Schema.decodeUnknownOption( const decodePluginManifest = Schema.decodeUnknownOption( // agy decodes like Go's encoding/json, so null leaves the default and a string is invalid. Schema.fromJsonString( - Schema.Struct({ disabled: Schema.optional(Schema.NullOr(Schema.Boolean)) }), + Schema.Struct({ + disabled: Schema.optional(Schema.NullOr(Schema.Boolean)), + skills: Schema.optional(Schema.Unknown), + }), ), ); @@ -141,13 +144,33 @@ const readAntigravityPluginPreferences = Effect.fn("readAntigravityPluginPrefere ); }); -/** agy skips a plugin folder without one of these manifests, or whose manifest is not valid JSON. */ +/** agy skips a plugin folder without one of these manifests; provider-specific manifests win over root. */ const ANTIGRAVITY_PLUGIN_MANIFESTS = [ - "plugin.json", ".antigravity-plugin/plugin.json", ".gemini-plugin/plugin.json", + "plugin.json", ] as const; +function extractManifestSkillPaths(raw: unknown): ReadonlyArray { + if (typeof raw === "string") return [raw]; + if (!Array.isArray(raw)) return []; + return raw.filter((entry): entry is string => typeof entry === "string"); +} + +function resolvePluginSkillDirectories( + path: Path.Path, + pluginDirectory: string, + extraSkills: ReadonlyArray | undefined, +): ReadonlyArray { + const directories = new Set([path.resolve(pluginDirectory, "skills")]); + for (const entry of extraSkills ?? []) { + const trimmed = entry.trim(); + if (!trimmed) continue; + directories.add(path.resolve(pluginDirectory, trimmed)); + } + return [...directories]; +} + const readAntigravityPluginManifest = Effect.fn("readAntigravityPluginManifest")(function* ( pluginDirectory: string, ) { @@ -156,7 +179,12 @@ const readAntigravityPluginManifest = Effect.fn("readAntigravityPluginManifest") const text = yield* readAntigravityBoundedFile(path.join(pluginDirectory, manifest)); if (text === undefined) continue; const decoded = decodePluginManifest(text); - return decoded._tag === "Some" ? { disabled: decoded.value.disabled === true } : undefined; + return decoded._tag === "Some" + ? { + disabled: decoded.value.disabled === true, + skills: extractManifestSkillPaths(decoded.value.skills), + } + : undefined; } return undefined; }); @@ -171,10 +199,14 @@ export const readAntigravityUserPlugins = Effect.fn("readAntigravityUserPlugins" ) { const fileSystem = yield* FileSystem.FileSystem; const path = yield* Path.Path; - const pluginsDirectory = path.join(userHome, ".gemini", "config", "plugins"); + const pluginsDirectory = path.resolve(userHome, ".gemini", "config", "plugins"); const plugins = new Map< string, - { readonly directory: string; readonly disabledByDefault: boolean } + { + readonly directory: string; + readonly disabledByDefault: boolean; + readonly skillDirectories: ReadonlyArray; + } >(); const names = yield* readIfPresent(fileSystem.readDirectory(pluginsDirectory), pluginsDirectory); for (const name of names?.toSorted() ?? []) { @@ -183,11 +215,15 @@ export const readAntigravityUserPlugins = Effect.fn("readAntigravityUserPlugins" if (info?.type !== "Directory") continue; const manifest = yield* readAntigravityPluginManifest(directory); if (manifest === undefined) continue; - plugins.set(name, { directory, disabledByDefault: manifest.disabled }); + plugins.set(name, { + directory, + disabledByDefault: manifest.disabled, + skillDirectories: resolvePluginSkillDirectories(path, directory, manifest.skills), + }); } if (plugins.size === 0) return plugins; const preferences = yield* readAntigravityPluginPreferences( - path.join(userHome, ".gemini", "config", "config.json"), + path.resolve(userHome, ".gemini", "config", "config.json"), ); for (const [name, plugin] of plugins) { if (!isAntigravityPluginEnabled(plugin.disabledByDefault, preferences.get(name))) { @@ -198,49 +234,67 @@ export const readAntigravityUserPlugins = Effect.fn("readAntigravityUserPlugins" }); /** Plugins agy loads from the profile once its next launch relinks the enabled user plugins. */ +const readAntigravityEffectivePlugins = Effect.fn("readAntigravityEffectivePlugins")( + function* (input: { readonly profileDirectory: string; readonly userHome: string }) { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const pluginsDirectory = path.resolve(input.profileDirectory, "config", "plugins"); + const userPluginsDirectory = path.resolve(input.userHome, ".gemini", "config", "plugins"); + // The profile linker carries a user's enabled override for a plugin that ships disabled. + const plugins = new Map( + [...(yield* readAntigravityUserPlugins(input.userHome))].map(([name, plugin]) => [ + name, + { + directory: plugin.directory, + disabledByDefault: false, + skillDirectories: plugin.skillDirectories, + }, + ]), + ); + const names = yield* readIfPresent( + fileSystem.readDirectory(pluginsDirectory), + pluginsDirectory, + ); + for (const name of names ?? []) { + const pluginDirectory = path.join(pluginsDirectory, name); + const target = yield* fileSystem.readLink(pluginDirectory).pipe( + Effect.map((value) => path.resolve(pluginsDirectory, value)), + Effect.orElseSucceed(() => undefined), + ); + // Profile preparation replaces its links into the user's plugins, so those come from above. + if (target !== undefined && path.dirname(target) === userPluginsDirectory) continue; + const info = yield* readIfPresent(fileSystem.stat(pluginDirectory), pluginDirectory); + if (info?.type !== "Directory") { + // A non-directory entry in profile plugins blocks linking the user plugin of the same name. + plugins.delete(name); + continue; + } + // Profile folders count without a manifest, as they did before user plugins were linked. + const manifest = yield* readAntigravityPluginManifest(pluginDirectory); + plugins.set(name, { + directory: pluginDirectory, + disabledByDefault: manifest?.disabled === true, + skillDirectories: resolvePluginSkillDirectories(path, pluginDirectory, manifest?.skills), + }); + } + if (plugins.size === 0) return []; + const preferences = yield* readAntigravityPluginPreferences( + path.resolve(input.profileDirectory, "config", "config.json"), + ); + return [...plugins] + .filter(([name, plugin]) => + isAntigravityPluginEnabled(plugin.disabledByDefault, preferences.get(name)), + ) + .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)) + .map(([, plugin]) => plugin); + }, +); + export const readAntigravityPlugins = Effect.fn("readAntigravityPlugins")(function* (input: { readonly profileDirectory: string; readonly userHome: string; }) { - const fileSystem = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const pluginsDirectory = path.join(input.profileDirectory, "config", "plugins"); - const userPluginsDirectory = path.join(input.userHome, ".gemini", "config", "plugins"); - // The profile linker carries a user's enabled override for a plugin that ships disabled. - const plugins = new Map( - [...(yield* readAntigravityUserPlugins(input.userHome))].map(([name, plugin]) => [ - name, - { directory: plugin.directory, disabledByDefault: false }, - ]), - ); - const names = yield* readIfPresent(fileSystem.readDirectory(pluginsDirectory), pluginsDirectory); - for (const name of names ?? []) { - const pluginDirectory = path.join(pluginsDirectory, name); - const target = yield* fileSystem.readLink(pluginDirectory).pipe( - Effect.map((value) => path.resolve(pluginsDirectory, value)), - Effect.orElseSucceed(() => undefined), - ); - // Profile preparation replaces its links into the user's plugins, so those come from above. - if (target !== undefined && path.dirname(target) === userPluginsDirectory) continue; - const info = yield* readIfPresent(fileSystem.stat(pluginDirectory), pluginDirectory); - if (info?.type !== "Directory") continue; - // Profile folders count without a manifest, as they did before user plugins were linked. - const manifest = yield* readAntigravityPluginManifest(pluginDirectory); - plugins.set(name, { - directory: pluginDirectory, - disabledByDefault: manifest?.disabled === true, - }); - } - if (plugins.size === 0) return []; - const preferences = yield* readAntigravityPluginPreferences( - path.join(input.profileDirectory, "config", "config.json"), - ); - return [...plugins] - .filter(([name, plugin]) => - isAntigravityPluginEnabled(plugin.disabledByDefault, preferences.get(name)), - ) - .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)) - .map(([, plugin]) => plugin.directory); + return (yield* readAntigravityEffectivePlugins(input)).map((plugin) => plugin.directory); }); function parseSkillFrontmatter(contents: string, fileName: string) { @@ -617,8 +671,10 @@ export const discoverAntigravitySkills = Effect.fn("discoverAntigravitySkills")( ); } - for (const pluginDirectory of yield* readAntigravityPlugins(input)) { - yield* scanDirectory(path.join(pluginDirectory, "skills"), "user", true); + for (const plugin of yield* readAntigravityEffectivePlugins(input)) { + for (const skillDirectory of plugin.skillDirectories) { + yield* scanDirectory(skillDirectory, "user", true); + } } return [...skillsByName.values()].sort((left, right) => left.name.localeCompare(right.name)); }); diff --git a/apps/server/src/provider/antigravityAuthSupport.test.ts b/apps/server/src/provider/antigravityAuthSupport.test.ts index b6e711e610c2f..c4ed24f4e89e3 100644 --- a/apps/server/src/provider/antigravityAuthSupport.test.ts +++ b/apps/server/src/provider/antigravityAuthSupport.test.ts @@ -791,6 +791,36 @@ it.layer(NodeServices.layer)("Antigravity profile preparation", (it) => { yield* prepareAntigravityProfile({ profileDirectory, userHome }); expect(yield* linkTarget("opted-in")).toBeUndefined(); expect(yield* linkTarget("kept-off")).toBeUndefined(); + + // A malformed plugins map in profile config.json is never repaired during preparation. + const malformedProfileConfig = JSON.stringify({ + plugins: { "opted-in": { enabled: "invalid" }, other: { enabled: true } }, + }); + yield* configure({ "opted-in": true }); + yield* write(profileConfig, malformedProfileConfig); + yield* prepareAntigravityProfile({ profileDirectory, userHome }); + expect(yield* fs.readFileString(profileConfig)).toBe(malformedProfileConfig); + + // Plugin names colliding with Object.prototype still receive own enablement overrides. + for (const name of ["constructor", "__proto__"]) { + yield* write(path.join(userPlugins, name, "plugin.json"), '{"disabled":true}'); + } + yield* write( + path.join(config, "config.json"), + '{"plugins":{"constructor":{"enabled":true},"__proto__":{"enabled":true}}}', + ); + yield* fs.remove(profileConfig); + yield* prepareAntigravityProfile({ profileDirectory, userHome }); + const protoPlugins = JSON.parse(yield* fs.readFileString(profileConfig)).plugins as Record< + string, + unknown + >; + expect(Object.hasOwn(protoPlugins, "constructor")).toBe(true); + expect(protoPlugins.constructor).toEqual({ enabled: true }); + expect(Object.hasOwn(protoPlugins, "__proto__")).toBe(true); + expect(Object.getOwnPropertyDescriptor(protoPlugins, "__proto__")?.value).toEqual({ + enabled: true, + }); }), ); diff --git a/apps/server/src/provider/antigravityAuthSupport.ts b/apps/server/src/provider/antigravityAuthSupport.ts index 2fb54908ae105..f079fd1bc75e9 100644 --- a/apps/server/src/provider/antigravityAuthSupport.ts +++ b/apps/server/src/provider/antigravityAuthSupport.ts @@ -343,6 +343,9 @@ const ProfileConfigJson = Schema.fromJsonString( ); const decodeProfileConfig = Schema.decodeUnknownEffect(ProfileConfigJson); const encodeProfileConfig = Schema.encodeSync(ProfileConfigJson); +const isValidProfilePluginPreferences = Schema.is( + Schema.Record(Schema.String, Schema.Struct({ enabled: Schema.optional(Schema.Boolean) })), +); /** agy reads plugin overrides only from the profile's config.json, and an explicit profile value wins. */ const enableAntigravityProfilePlugins = Effect.fn("enableAntigravityProfilePlugins")( @@ -351,8 +354,20 @@ const enableAntigravityProfilePlugins = Effect.fn("enableAntigravityProfilePlugi const config = yield* decodeProfileConfig( (yield* readAntigravityBoundedFile(configPath)) ?? "{}", ); - const plugins = { ...config.plugins }; - const missing = names.filter((name) => plugins[name]?.enabled === undefined); + if (config.plugins !== undefined && !isValidProfilePluginPreferences(config.plugins)) { + yield* Effect.logWarning("Antigravity plugin overrides are not carried into the profile.", { + configPath, + }); + return; + } + const plugins: Record> = Object.assign( + Object.create(null) as Record>, + config.plugins, + ); + const missing = names.filter((name) => { + const current = plugins[name]; + return current === undefined || !Object.hasOwn(current, "enabled"); + }); if (missing.length === 0) return; for (const name of missing) plugins[name] = { ...plugins[name], enabled: true }; yield* fs.writeFileString(configPath, encodeProfileConfig({ ...config, plugins })); @@ -376,8 +391,8 @@ const linkAntigravityUserPlugins = Effect.fn("linkAntigravityUserPlugins")(funct }): Effect.fn.Return { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; - const userPlugins = path.join(input.userHome, ".gemini", "config", "plugins"); - const profilePlugins = path.join(input.profileDirectory, "config", "plugins"); + const userPlugins = path.resolve(input.userHome, ".gemini", "config", "plugins"); + const profilePlugins = path.resolve(input.profileDirectory, "config", "plugins"); yield* Effect.gen(function* () { const enabled = yield* readAntigravityUserPlugins(input.userHome); const existing = new Set( diff --git a/apps/server/src/textGeneration/AntigravityTextGeneration.test.ts b/apps/server/src/textGeneration/AntigravityTextGeneration.test.ts index f6b6aa22b31d7..fad5eaa01edf3 100644 --- a/apps/server/src/textGeneration/AntigravityTextGeneration.test.ts +++ b/apps/server/src/textGeneration/AntigravityTextGeneration.test.ts @@ -652,6 +652,11 @@ it.layer(NodeServices.layer)("AntigravityTextGeneration", (it) => { available: true, }, { case: "hooks.json", files: { "hooks.json": '{"hooks":{"Stop":[]}}' }, available: false }, + { + case: "hooks.json with empty hooks group alongside populated group", + files: { "hooks.json": '{"hooks":{},"default":{"SessionStart":[{"command":"echo hi"}]}}' }, + available: false, + }, { case: "mcp_config.json", files: { "mcp_config.json": '{"mcpServers":{"s":{"command":"do-not-run"}}}' }, @@ -672,6 +677,15 @@ it.layer(NodeServices.layer)("AntigravityTextGeneration", (it) => { }, available: true, }, + { + case: "a disabled root manifest overridden by .antigravity-plugin/plugin.json", + files: { + "plugin.json": '{"name":"p","disabled":true}', + ".antigravity-plugin/plugin.json": '{"name":"p"}', + "hooks.json": '{"default":{"SessionStart":[{"command":"echo hi"}]}}', + }, + available: false, + }, ])( "checks plugin startup configuration before starting a helper: $case", ({ files, disabled, available }) => diff --git a/apps/server/src/textGeneration/AntigravityTextGeneration.ts b/apps/server/src/textGeneration/AntigravityTextGeneration.ts index c3f424b18c354..14fb6df21bbdc 100644 --- a/apps/server/src/textGeneration/AntigravityTextGeneration.ts +++ b/apps/server/src/textGeneration/AntigravityTextGeneration.ts @@ -25,6 +25,9 @@ import type * as AcpSessionRuntime from "@t3tools/provider-acp/server/AcpSession import { collectSessionConfigOptionValues } from "@t3tools/provider-acp/server/runtimeModel"; import * as TextGenerationOperations from "@t3tools/provider-core/server/textGenerationOperations"; +export const ANTIGRAVITY_TEXT_GENERATION_UNAVAILABLE_MESSAGE = + "Antigravity text generation is unavailable for profiles with global or plugin hooks or MCP configuration. Select another system model."; + const ANTIGRAVITY_TIMEOUT_MS = 180_000; const MAX_OUTPUT_CHARS = 128_000; const isTextGenerationError = Schema.is(TextGenerationError); @@ -98,11 +101,18 @@ export const isAntigravityTextGenerationAvailable = Effect.fn( ? Effect.succeed(true) : decodeConfiguration(text).pipe( Effect.flatMap((configuration) => - decodeConfigurationObject( - configuration[name === "hooks.json" ? "hooks" : "mcpServers"] ?? configuration, - ), + name === "hooks.json" + ? Effect.forEach(Object.values(configuration), (group) => + decodeConfigurationObject(group), + ).pipe( + Effect.map((groups) => + groups.every((group) => Object.keys(group).length === 0), + ), + ) + : decodeConfigurationObject(configuration.mcpServers ?? configuration).pipe( + Effect.map((servers) => Object.keys(servers).length === 0), + ), ), - Effect.map((configuration) => Object.keys(configuration).length === 0), ), ), Effect.orElseSucceed(() => false), @@ -149,6 +159,7 @@ export const makeAntigravityTextGeneration = Effect.fn("makeAntigravityTextGener const available = isAntigravityTextGenerationAvailable(options).pipe( Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path), + Effect.orElseSucceed(() => false), ); const runAntigravityJson = Effect.fn("AntigravityTextGeneration.runJson")( @@ -160,8 +171,7 @@ export const makeAntigravityTextGeneration = Effect.fn("makeAntigravityTextGener if (!(yield* available)) { return yield* new TextGenerationError({ operation, - detail: - "Antigravity text generation is unavailable for profiles with global or plugin hooks or MCP configuration. Select another system model.", + detail: ANTIGRAVITY_TEXT_GENERATION_UNAVAILABLE_MESSAGE, }); }