ryco-cli 0.1.24 → 0.1.26

package/dist/GrokDriver-BFOniP_K.cjs

@@ -0,0 +1,567 @@
+#!/usr/bin/env node
+
+const require_rolldown_runtime = require("./rolldown-runtime-LGfotAqq.cjs");
+const require_src = require("./src-BlzIcnVG.cjs");
+require("./Metrics-DCKbdeoH.cjs");
+const require_git = require("./git-irmB8_k7.cjs");
+const require_bin = require("./bin.cjs");
+const require_AcpAdapter = require("./AcpAdapter-CadxcdZV.cjs");
+const require_ProviderDriver = require("./ProviderDriver--rNeAi3B.cjs");
+const require_makeManagedServerProvider = require("./makeManagedServerProvider-DGbd8BhM.cjs");
+let effect_Effect = require("effect/Effect");
+effect_Effect = require_rolldown_runtime.__toESM(effect_Effect, 1);
+let effect_Layer = require("effect/Layer");
+effect_Layer = require_rolldown_runtime.__toESM(effect_Layer, 1);
+let effect_Schema = require("effect/Schema");
+effect_Schema = require_rolldown_runtime.__toESM(effect_Schema, 1);
+let effect_unstable_http = require("effect/unstable/http");
+let effect_unstable_process = require("effect/unstable/process");
+let effect_Scope = require("effect/Scope");
+effect_Scope = require_rolldown_runtime.__toESM(effect_Scope, 1);
+let effect_Cause = require("effect/Cause");
+effect_Cause = require_rolldown_runtime.__toESM(effect_Cause, 1);
+let effect_Exit = require("effect/Exit");
+effect_Exit = require_rolldown_runtime.__toESM(effect_Exit, 1);
+let effect_Option = require("effect/Option");
+effect_Option = require_rolldown_runtime.__toESM(effect_Option, 1);
+let effect_Ref = require("effect/Ref");
+effect_Ref = require_rolldown_runtime.__toESM(effect_Ref, 1);
+let effect_Stream = require("effect/Stream");
+effect_Stream = require_rolldown_runtime.__toESM(effect_Stream, 1);
+let effect_Duration = require("effect/Duration");
+effect_Duration = require_rolldown_runtime.__toESM(effect_Duration, 1);
+let effect_DateTime = require("effect/DateTime");
+effect_DateTime = require_rolldown_runtime.__toESM(effect_DateTime, 1);
+let effect_FileSystem = require("effect/FileSystem");
+effect_FileSystem = require_rolldown_runtime.__toESM(effect_FileSystem, 1);
+let effect_Path = require("effect/Path");
+effect_Path = require_rolldown_runtime.__toESM(effect_Path, 1);
+let effect_Result = require("effect/Result");
+effect_Result = require_rolldown_runtime.__toESM(effect_Result, 1);
+//#region src/provider/acp/GrokAcpSupport.ts
+const GROK_API_KEY_ENV = "XAI_API_KEY";
+const GROK_OAUTH2_REFERRER_ENV = "GROK_OAUTH2_REFERRER";
+const RYCO_OAUTH_REFERRER = "ryco";
+const GROK_AUTH_METHOD_API_KEY = "xai.api_key";
+const GROK_AUTH_METHOD_CACHED_TOKEN = "cached_token";
+const GROK_DRIVER_KIND = require_src.ProviderDriverKind.make("grok");
+function buildGrokAcpSpawnInput(grokSettings, cwd, environment) {
+	return {
+		command: grokSettings?.binaryPath || "grok",
+		args: ["agent", "stdio"],
+		cwd,
+		env: {
+			...environment,
+			[GROK_OAUTH2_REFERRER_ENV]: RYCO_OAUTH_REFERRER
+		}
+	};
+}
+function resolveGrokAuthMethodId(environment) {
+	return environment?.[GROK_API_KEY_ENV]?.trim() ? GROK_AUTH_METHOD_API_KEY : GROK_AUTH_METHOD_CACHED_TOKEN;
+}
+const makeGrokAcpRuntime = (input) => effect_Effect.gen(function* () {
+	const acpContext = yield* effect_Layer.build(require_bin.AcpSessionRuntime.layer({
+		...input,
+		spawn: buildGrokAcpSpawnInput(input.grokSettings, input.cwd, input.environment),
+		authMethodId: resolveGrokAuthMethodId(input.environment)
+	}).pipe(effect_Layer.provide(effect_Layer.succeed(effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner, input.childProcessSpawner))));
+	const runtime = yield* effect_Effect.service(require_bin.AcpSessionRuntime).pipe(effect_Effect.provide(acpContext));
+	return yield* require_AcpAdapter.makeXAiPromptCompletionRuntime(runtime);
+});
+function resolveGrokAcpBaseModelId(model) {
+	const trimmed = model?.trim();
+	const base = trimmed && trimmed.length > 0 ? trimmed : "grok-build";
+	return require_bin.normalizeModelSlug(base, GROK_DRIVER_KIND) ?? "grok-build";
+}
+//#endregion
+//#region src/textGeneration/GrokTextGeneration.ts
+const GROK_TIMEOUT_MS = 18e4;
+function mapGrokAcpError(operation, detail, cause) {
+	return new require_src.TextGenerationError({
+		operation,
+		detail,
+		...cause !== void 0 ? { cause } : {}
+	});
+}
+function isTextGenerationError(error) {
+	return typeof error === "object" && error !== null && "_tag" in error && error._tag === "TextGenerationError";
+}
+const makeGrokTextGeneration = effect_Effect.fn("makeGrokTextGeneration")(function* (grokSettings, environment = process.env) {
+	const commandSpawner = yield* effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner;
+	const runGrokJson = ({ operation, cwd, prompt, outputSchemaJson, modelSelection }) => effect_Effect.gen(function* () {
+		const resolvedModel = resolveGrokAcpBaseModelId(modelSelection.model);
+		const outputRef = yield* effect_Ref.make("");
+		const runtime = yield* makeGrokAcpRuntime({
+			grokSettings,
+			environment,
+			childProcessSpawner: commandSpawner,
+			cwd,
+			clientInfo: {
+				name: "ryco-git-text",
+				version: "0.0.0"
+			}
+		});
+		yield* runtime.handleSessionUpdate((notification) => {
+			const update = notification.update;
+			if (update.sessionUpdate !== "agent_message_chunk") return effect_Effect.void;
+			const content = update.content;
+			if (content.type !== "text") return effect_Effect.void;
+			return effect_Ref.update(outputRef, (current) => current + content.text);
+		});
+		const promptResult = yield* effect_Effect.gen(function* () {
+			const started = yield* runtime.start();
+			yield* require_AcpAdapter.applyAcpModelSelection({
+				runtime,
+				currentModelId: require_AcpAdapter.currentAcpModelIdFromSessionSetup(started.sessionSetupResult),
+				requestedModelId: resolvedModel,
+				mapError: (cause) => mapGrokAcpError(operation, "Failed to set Grok ACP base model for text generation.", cause)
+			});
+			return yield* runtime.prompt({ prompt: [{
+				type: "text",
+				text: prompt
+			}] });
+		}).pipe(effect_Effect.timeoutOption(GROK_TIMEOUT_MS), effect_Effect.flatMap(effect_Option.match({
+			onNone: () => effect_Effect.fail(new require_src.TextGenerationError({
+				operation,
+				detail: "Grok ACP request timed out."
+			})),
+			onSome: (value) => effect_Effect.succeed(value)
+		})), effect_Effect.mapError((cause) => isTextGenerationError(cause) ? cause : mapGrokAcpError(operation, "Grok ACP request failed.", cause)));
+		const trimmed = (yield* effect_Ref.get(outputRef)).trim();
+		if (!trimmed) return yield* new require_src.TextGenerationError({
+			operation,
+			detail: promptResult.stopReason === "cancelled" ? "Grok ACP request was cancelled." : "Grok Agent returned empty output."
+		});
+		return yield* effect_Schema.decodeEffect(effect_Schema.fromJsonString(outputSchemaJson))(require_bin.extractJsonObject(trimmed)).pipe(effect_Effect.catchTag("SchemaError", (cause) => effect_Effect.fail(new require_src.TextGenerationError({
+			operation,
+			detail: "Grok Agent returned invalid structured output.",
+			cause
+		}))));
+	}).pipe(effect_Effect.mapError((cause) => isTextGenerationError(cause) ? cause : mapGrokAcpError(operation, "Grok ACP text generation failed.", cause)), effect_Effect.scoped);
+	return {
+		generateCommitMessage: effect_Effect.fn("GrokTextGeneration.generateCommitMessage")(function* (input) {
+			const { prompt, outputSchema } = require_bin.buildCommitMessagePrompt({
+				branch: input.branch,
+				stagedSummary: input.stagedSummary,
+				stagedPatch: input.stagedPatch,
+				includeBranch: input.includeBranch === true
+			});
+			const generated = yield* runGrokJson({
+				operation: "generateCommitMessage",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return {
+				subject: require_bin.sanitizeCommitSubject(generated.subject),
+				body: generated.body.trim(),
+				..."branch" in generated && typeof generated.branch === "string" ? { branch: require_git.sanitizeFeatureBranchName(generated.branch) } : {}
+			};
+		}),
+		generatePrContent: effect_Effect.fn("GrokTextGeneration.generatePrContent")(function* (input) {
+			const { prompt, outputSchema } = require_bin.buildPrContentPrompt({
+				baseBranch: input.baseBranch,
+				headBranch: input.headBranch,
+				commitSummary: input.commitSummary,
+				diffSummary: input.diffSummary,
+				diffPatch: input.diffPatch
+			});
+			const generated = yield* runGrokJson({
+				operation: "generatePrContent",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return {
+				title: require_bin.sanitizePrTitle(generated.title),
+				body: generated.body.trim()
+			};
+		}),
+		generateBranchName: effect_Effect.fn("GrokTextGeneration.generateBranchName")(function* (input) {
+			const { prompt, outputSchema } = require_bin.buildBranchNamePrompt({
+				message: input.message,
+				attachments: input.attachments
+			});
+			const generated = yield* runGrokJson({
+				operation: "generateBranchName",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return { branch: require_git.sanitizeBranchFragment(generated.branch) };
+		}),
+		generateThreadTitle: effect_Effect.fn("GrokTextGeneration.generateThreadTitle")(function* (input) {
+			const { prompt, outputSchema } = require_bin.buildThreadTitlePrompt({
+				message: input.message,
+				attachments: input.attachments
+			});
+			const generated = yield* runGrokJson({
+				operation: "generateThreadTitle",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return { title: require_bin.sanitizeThreadTitle(generated.title) };
+		}),
+		generateIssueContent: effect_Effect.fn("GrokTextGeneration.generateIssueContent")(function* (input) {
+			if (input.mode === "polish") {
+				const { prompt, outputSchema } = require_bin.buildIssueContentPolishPrompt({
+					rough: input.rough,
+					...input.currentTitle ? { currentTitle: input.currentTitle } : {},
+					...input.customInstructions ? { customInstructions: input.customInstructions } : {}
+				});
+				const decoded = yield* runGrokJson({
+					operation: "generateIssueContent",
+					cwd: input.cwd,
+					prompt,
+					outputSchemaJson: outputSchema,
+					modelSelection: input.modelSelection
+				});
+				return {
+					title: decoded.title.trim(),
+					body: decoded.body.trim()
+				};
+			}
+			const { prompt, outputSchema } = require_bin.buildIssueContentTitlePrompt({ body: input.body });
+			return { title: (yield* runGrokJson({
+				operation: "generateIssueContent",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			})).title.trim() };
+		}),
+		rankInboxThreads: effect_Effect.fn("GrokTextGeneration.rankInboxThreads")(function* (input) {
+			const { prompt, outputSchema } = require_bin.buildThreadPriorityPrompt({ serializedCandidates: input.chunk.serializedCandidates });
+			const generated = yield* runGrokJson({
+				operation: "rankInboxThreads",
+				cwd: input.cwd,
+				prompt,
+				outputSchemaJson: outputSchema,
+				modelSelection: input.modelSelection
+			});
+			return yield* require_bin.validateRankInboxThreadsResult(input, generated.rankings);
+		}),
+		answerSideQuestion: (_input) => effect_Effect.fail(new require_src.TextGenerationError({
+			operation: "answerSideQuestion",
+			detail: "Grok does not provide an enforceable tool-free side question mode. Select Codex, Claude, or GitHub Copilot for side chat."
+		}))
+	};
+});
+//#endregion
+//#region src/provider/Layers/GrokAdapter.ts
+function makeGrokAdapter(grokSettings, options) {
+	return require_AcpAdapter.makeAcpAdapter({
+		...options,
+		provider: require_src.ProviderDriverKind.make("grok"),
+		normalizeModel: resolveGrokAcpBaseModelId,
+		xaiExtensions: true,
+		makeRuntime: (input) => makeGrokAcpRuntime({
+			...input,
+			grokSettings,
+			...options?.environment ? { environment: options.environment } : {}
+		})
+	});
+}
+//#endregion
+//#region src/provider/Layers/GrokProvider.ts
+const GROK_PRESENTATION = {
+	displayName: "Grok",
+	badgeLabel: "Early Access",
+	showInteractionModeToggle: false
+};
+const PROVIDER = require_src.ProviderDriverKind.make("grok");
+const EMPTY_CAPABILITIES = require_bin.createModelCapabilities({ optionDescriptors: [] });
+const VERSION_PROBE_TIMEOUT_MS = 4e3;
+const GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
+const GROK_BUILT_IN_MODELS = [{
+	slug: "grok-build",
+	name: "Grok Build",
+	isCustom: false,
+	capabilities: EMPTY_CAPABILITIES
+}];
+function buildInitialGrokProviderSnapshot(grokSettings) {
+	const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const models = grokModelsFromSettings(grokSettings.customModels);
+	if (!grokSettings.enabled) return require_bin.buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: false,
+		checkedAt,
+		models,
+		probe: {
+			installed: false,
+			version: null,
+			status: "warning",
+			auth: { status: "unknown" },
+			message: "Grok is disabled in Ryco settings."
+		}
+	});
+	return require_bin.buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: true,
+		checkedAt,
+		models,
+		probe: {
+			installed: true,
+			version: null,
+			status: "warning",
+			auth: { status: "unknown" },
+			message: "Checking Grok CLI availability..."
+		}
+	});
+}
+function grokModelsFromSettings(customModels, builtInModels = GROK_BUILT_IN_MODELS) {
+	return require_bin.providerModelsFromSettings(builtInModels, PROVIDER, customModels ?? [], EMPTY_CAPABILITIES);
+}
+function buildGrokDiscoveredModelsFromSessionModelState(modelState) {
+	if (!modelState || modelState.availableModels.length === 0) return [];
+	const seen = /* @__PURE__ */ new Set();
+	return modelState.availableModels.map((model) => {
+		const slug = resolveGrokAcpBaseModelId(model.modelId);
+		if (!slug || seen.has(slug)) return;
+		seen.add(slug);
+		return {
+			slug,
+			name: model.name.trim() || slug,
+			isCustom: false,
+			capabilities: EMPTY_CAPABILITIES
+		};
+	}).filter((model) => model !== void 0);
+}
+const discoverGrokModelsViaAcp = (grokSettings, environment = process.env) => effect_Effect.gen(function* () {
+	const childProcessSpawner = yield* effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner;
+	return buildGrokDiscoveredModelsFromSessionModelState((yield* (yield* makeGrokAcpRuntime({
+		grokSettings,
+		environment,
+		childProcessSpawner,
+		cwd: process.cwd(),
+		clientInfo: {
+			name: "ryco-provider-probe",
+			version: "0.0.0"
+		}
+	})).start()).sessionSetupResult.models);
+}).pipe(effect_Effect.scoped);
+const runGrokVersionCommand = (grokSettings, environment = process.env) => {
+	const command = grokSettings.binaryPath || "grok";
+	return require_bin.spawnAndCollect(command, effect_unstable_process.ChildProcess.make(command, ["--version"], {
+		env: environment,
+		shell: process.platform === "win32"
+	}));
+};
+const checkGrokProviderStatus = effect_Effect.fn("checkGrokProviderStatus")(function* (grokSettings, environment = process.env) {
+	const checkedAt = effect_DateTime.formatIso(yield* effect_DateTime.now);
+	const fallbackModels = grokModelsFromSettings(grokSettings.customModels);
+	if (!grokSettings.enabled) return require_bin.buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: false,
+		checkedAt,
+		models: fallbackModels,
+		probe: {
+			installed: false,
+			version: null,
+			status: "warning",
+			auth: { status: "unknown" },
+			message: "Grok is disabled in Ryco settings."
+		}
+	});
+	const versionResult = yield* runGrokVersionCommand(grokSettings, environment).pipe(effect_Effect.timeoutOption(VERSION_PROBE_TIMEOUT_MS), effect_Effect.result);
+	if (effect_Result.isFailure(versionResult)) {
+		const error = versionResult.failure;
+		yield* effect_Effect.logWarning("Grok CLI health check failed.", { errorTag: error.name });
+		return require_bin.buildServerProvider({
+			presentation: GROK_PRESENTATION,
+			enabled: grokSettings.enabled,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: !require_bin.isCommandMissingCause(error),
+				version: null,
+				status: "error",
+				auth: { status: "unknown" },
+				message: require_bin.isCommandMissingCause(error) ? "Grok CLI (`grok`) is not installed or not on PATH." : "Failed to execute Grok CLI health check."
+			}
+		});
+	}
+	if (effect_Option.isNone(versionResult.success)) return require_bin.buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: grokSettings.enabled,
+		checkedAt,
+		models: fallbackModels,
+		probe: {
+			installed: true,
+			version: null,
+			status: "error",
+			auth: { status: "unknown" },
+			message: "Grok CLI is installed but timed out while running `grok --version`."
+		}
+	});
+	const versionOutput = versionResult.success.value;
+	const version = require_bin.parseGenericCliVersion(`${versionOutput.stdout}\n${versionOutput.stderr}`);
+	if (versionOutput.code !== 0) {
+		yield* effect_Effect.logWarning("Grok CLI version probe exited with a non-zero status.", {
+			exitCode: versionOutput.code,
+			stdoutLength: versionOutput.stdout.length,
+			stderrLength: versionOutput.stderr.length
+		});
+		return require_bin.buildServerProvider({
+			presentation: GROK_PRESENTATION,
+			enabled: grokSettings.enabled,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: true,
+				version,
+				status: "error",
+				auth: { status: "unknown" },
+				message: "Grok CLI is installed but failed to run."
+			}
+		});
+	}
+	const discoveryExit = yield* discoverGrokModelsViaAcp(grokSettings, environment).pipe(effect_Effect.timeoutOption(GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS), effect_Effect.exit);
+	if (effect_Exit.isFailure(discoveryExit)) {
+		yield* effect_Effect.logWarning("Grok ACP model discovery failed", { cause: effect_Cause.pretty(discoveryExit.cause) });
+		return require_bin.buildServerProvider({
+			presentation: GROK_PRESENTATION,
+			enabled: grokSettings.enabled,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: true,
+				version,
+				status: "error",
+				auth: { status: "unknown" },
+				message: "Grok CLI is installed but ACP startup failed. Check server logs for details."
+			}
+		});
+	}
+	if (effect_Option.isNone(discoveryExit.value)) {
+		yield* effect_Effect.logWarning(`Grok ACP model discovery timed out after ${GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS}ms.`);
+		return require_bin.buildServerProvider({
+			presentation: GROK_PRESENTATION,
+			enabled: grokSettings.enabled,
+			checkedAt,
+			models: fallbackModels,
+			probe: {
+				installed: true,
+				version,
+				status: "error",
+				auth: { status: "unknown" },
+				message: `Grok CLI is installed but ACP startup timed out after ${GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS}ms.`
+			}
+		});
+	}
+	const discoveredModels = discoveryExit.value.value;
+	const models = discoveredModels.length > 0 ? grokModelsFromSettings(grokSettings.customModels, discoveredModels) : fallbackModels;
+	return require_bin.buildServerProvider({
+		presentation: GROK_PRESENTATION,
+		enabled: grokSettings.enabled,
+		checkedAt,
+		models,
+		probe: {
+			installed: true,
+			version,
+			status: "ready",
+			auth: { status: "unknown" }
+		}
+	});
+});
+const enrichGrokSnapshot = (input) => {
+	const { snapshot, publishSnapshot } = input;
+	return require_bin.enrichProviderSnapshotWithVersionAdvisory(snapshot, input.maintenanceCapabilities).pipe(effect_Effect.provideService(effect_unstable_http.HttpClient.HttpClient, input.httpClient), effect_Effect.provideService(require_bin.ServerSettingsService, input.serverSettings), effect_Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot)), effect_Effect.catchCause((cause) => effect_Effect.logWarning("Grok version advisory enrichment failed", { cause: effect_Cause.pretty(cause) })), effect_Effect.asVoid);
+};
+//#endregion
+//#region src/provider/Drivers/GrokDriver.ts
+const decodeGrokSettings = effect_Schema.decodeSync(require_src.GrokSettings);
+const DRIVER_KIND = require_src.ProviderDriverKind.make("grok");
+const SNAPSHOT_REFRESH_INTERVAL = effect_Duration.minutes(5);
+const UPDATE = require_bin.makeStaticProviderMaintenanceResolver(require_bin.makeManualOnlyProviderMaintenanceCapabilities({
+	provider: DRIVER_KIND,
+	packageName: null
+}));
+const withInstanceIdentity = (input) => (snapshot) => ({
+	...snapshot,
+	instanceId: input.instanceId,
+	driver: DRIVER_KIND,
+	...input.displayName ? { displayName: input.displayName } : {},
+	...input.accentColor ? { accentColor: input.accentColor } : {},
+	continuation: { groupKey: input.continuationGroupKey }
+});
+const GrokDriver = {
+	driverKind: DRIVER_KIND,
+	metadata: {
+		displayName: "Grok",
+		supportsMultipleInstances: true
+	},
+	configSchema: require_src.GrokSettings,
+	defaultConfig: () => decodeGrokSettings({}),
+	create: ({ instanceId, displayName, accentColor, environment, enabled, config }) => effect_Effect.gen(function* () {
+		const spawner = yield* effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner;
+		const httpClient = yield* effect_unstable_http.HttpClient.HttpClient;
+		const serverSettings = yield* require_bin.ServerSettingsService;
+		const eventLoggers = yield* require_bin.ProviderEventLoggers;
+		const processEnv = require_bin.mergeProviderInstanceEnvironment(environment);
+		const continuationIdentity = require_ProviderDriver.defaultProviderContinuationIdentity({
+			driverKind: DRIVER_KIND,
+			instanceId
+		});
+		const stampIdentity = withInstanceIdentity({
+			instanceId,
+			displayName,
+			accentColor,
+			continuationGroupKey: continuationIdentity.continuationKey
+		});
+		const effectiveConfig = {
+			...config,
+			enabled
+		};
+		const maintenanceCapabilities = yield* require_bin.resolveProviderMaintenanceCapabilitiesEffect(UPDATE, {
+			binaryPath: effectiveConfig.binaryPath,
+			env: processEnv
+		});
+		const adapter = yield* makeGrokAdapter(effectiveConfig, {
+			environment: processEnv,
+			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {},
+			instanceId
+		});
+		const textGeneration = yield* makeGrokTextGeneration(effectiveConfig, processEnv);
+		const checkProvider = checkGrokProviderStatus(effectiveConfig, processEnv).pipe(effect_Effect.map(stampIdentity), effect_Effect.provideService(effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner, spawner));
+		const snapshot = yield* require_makeManagedServerProvider.makeManagedServerProvider({
+			maintenanceCapabilities,
+			getSettings: effect_Effect.succeed(effectiveConfig),
+			streamSettings: effect_Stream.never,
+			haveSettingsChanged: () => false,
+			initialSnapshot: (settings) => stampIdentity(buildInitialGrokProviderSnapshot(settings)),
+			checkProvider,
+			enrichSnapshot: ({ snapshot: currentSnapshot, publishSnapshot }) => enrichGrokSnapshot({
+				snapshot: currentSnapshot,
+				maintenanceCapabilities,
+				publishSnapshot,
+				httpClient,
+				serverSettings
+			}),
+			refreshInterval: SNAPSHOT_REFRESH_INTERVAL
+		}).pipe(effect_Effect.mapError((cause) => new require_bin.ProviderDriverError({
+			driver: DRIVER_KIND,
+			instanceId,
+			detail: `Failed to build Grok snapshot: ${cause.message ?? String(cause)}`,
+			cause
+		})));
+		return {
+			instanceId,
+			driverKind: DRIVER_KIND,
+			continuationIdentity,
+			displayName,
+			accentColor,
+			enabled,
+			snapshot,
+			adapter,
+			textGeneration
+		};
+	})
+};
+//#endregion
+exports.GrokDriver = GrokDriver;