ryco-cli 0.1.24 → 0.1.26

package/dist/{GrokDriver-DSPEmiwq.mjs → AcpAdapter-BemMQNbj.mjs}

@@ -1,32 +1,36 @@
 #!/usr/bin/env node
 
-import { $a as ProviderInstanceId, Ln as TextGenerationError, Qa as ProviderDriverKind, Yo as ApprovalRequestId, _s as TurnId, ds as RuntimeRequestId, rs as EventId, sr as GrokSettings } from "./collectUint8StreamText-C_VNyArd.mjs";
-import { nt as sanitizeFeatureBranchName, st as ServerConfig, tt as sanitizeBranchFragment } from "./Metrics-a1h4iBQi.mjs";
-import { $ as mergeProviderInstanceEnvironment, $n as resolveAttachmentPath, B as buildPrContentPrompt, Ct as ProviderAdapterSessionNotFoundError, F as validateRankInboxThreadsResult, G as sanitizeCommitSubject, H as buildThreadTitlePrompt, Hn as enrichProviderSnapshotWithVersionAdvisory, I as buildBranchNamePrompt, Jn as resolveProviderMaintenanceCapabilitiesEffect, K as sanitizePrTitle, Kn as makeStaticProviderMaintenanceResolver, L as buildCommitMessagePrompt, M as makeEventNdjsonLogger, R as buildIssueContentPolishPrompt, Tt as ProviderDriverError, U as extractJsonObject, Un as makeManualOnlyProviderMaintenanceCapabilities, V as buildThreadPriorityPrompt, Xn as ServerSettingsService, Zn as isPersistableChatAttachment, bt as ProviderAdapterProcessError, dt as parseGenericCliVersion, ft as providerModelsFromSettings, j as ProviderEventLoggers, lr as normalizeModelSlug, lt as isCommandMissingCause, nr as createModelCapabilities, ot as buildServerProvider, pt as spawnAndCollect, q as sanitizeThreadTitle, wt as ProviderAdapterValidationError, xt as ProviderAdapterRequestError, yt as createProcessDeviceToolBinding, z as buildIssueContentTitlePrompt } from "./bin.mjs";
-import { a as formatAttachmentPathLines, i as appendAttachmentPathLines, n as requireRuntimeSessionId, r as stampRuntimeEvent, t as makeManagedServerProvider } from "./makeManagedServerProvider-GZcpSLrW.mjs";
-import { t as defaultProviderContinuationIdentity } from "./ProviderDriver-kCV60GKk.mjs";
-import { a as makeAcpRequestOpenedEvent, c as makeAcpTokenUsageEvent, d as mapAcpToAdapterError, f as makeAcpSubagentRuntimeEvents, h as AcpTransportError, i as makeAcpPlanUpdatedEvent, l as makeAcpToolCallEvent, m as parsePermissionRequest, n as makeAcpAssistantItemEvent, o as makeAcpRequestResolvedEvent, p as AcpSessionRuntime, r as makeAcpContentDeltaEvent, s as makeAcpThoughtDeltaEvent, t as makeAcpNativeLoggers } from "./AcpNativeLogging-D7e1dn7s.mjs";
+import { As as EventId, Eo as ProviderInstanceId, Rs as RuntimeRequestId, Ss as ApprovalRequestId, Ws as TurnId } from "./src-DtEOcXdl.mjs";
+import { Z as ServerConfig } from "./Metrics-C-3MahDy.mjs";
+import { A as makeEventNdjsonLogger, Ht as ProviderAdapterValidationError, K as parsePermissionRequest, Lt as createProcessDeviceToolBinding, Rt as ProviderAdapterProcessError, Vt as ProviderAdapterSessionNotFoundError, Y as AcpTransportError, _r as resolveAttachmentPath, hr as isPersistableChatAttachment, zt as ProviderAdapterRequestError } from "./bin.mjs";
+import { a as makeAcpRequestOpenedEvent, c as makeAcpTokenUsageEvent, d as mapAcpToAdapterError, f as makeAcpSubagentRuntimeEvents, i as makeAcpPlanUpdatedEvent, l as makeAcpToolCallEvent, n as makeAcpAssistantItemEvent, o as makeAcpRequestResolvedEvent, r as makeAcpContentDeltaEvent, s as makeAcpThoughtDeltaEvent, t as makeAcpNativeLoggers } from "./AcpNativeLogging-BsbZRRD7.mjs";
+import { i as formatAttachmentPathLines, n as stampRuntimeEvent, r as appendAttachmentPathLines, t as requireRuntimeSessionId } from "./runtimeSession-CA6cLWg0.mjs";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
-import { HttpClient } from "effect/unstable/http";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ChildProcessSpawner } from "effect/unstable/process";
 import * as Semaphore from "effect/Semaphore";
 import * as Scope from "effect/Scope";
-import * as Cause from "effect/Cause";
 import * as Deferred from "effect/Deferred";
 import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
 import * as Stream from "effect/Stream";
-import * as Duration from "effect/Duration";
 import * as Fiber from "effect/Fiber";
+import * as DateTime from "effect/DateTime";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import * as DateTime from "effect/DateTime";
 import * as PubSub from "effect/PubSub";
 import * as SynchronizedRef from "effect/SynchronizedRef";
-import * as Result from "effect/Result";
+//#region src/provider/acp/AcpModelSelection.ts
+function currentAcpModelIdFromSessionSetup(sessionSetupResult) {
+	const option = sessionSetupResult.configOptions?.find((entry) => entry.category === "model" && entry.type === "select");
+	return sessionSetupResult.models?.currentModelId?.trim() || (typeof option?.currentValue === "string" ? option.currentValue : void 0);
+}
+function applyAcpModelSelection(input) {
+	if (!(input.requestedModelId !== void 0 && input.requestedModelId !== input.currentModelId)) return Effect.succeed(input.currentModelId);
+	return input.runtime.setSessionModel(input.requestedModelId).pipe(Effect.mapError(input.mapError), Effect.as(input.requestedModelId));
+}
+//#endregion
 //#region src/provider/acp/XAiAcpExtension.ts
 const XAiPromptCompleteNotification = Schema.Struct({
 	sessionId: Schema.String,
@@ -300,228 +304,9 @@ function normalizeXAiStopReason(value) {
 	}
 }
 //#endregion
-//#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 = 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.gen(function* () {
-	const acpContext = yield* Layer.build(AcpSessionRuntime.layer({
-		...input,
-		spawn: buildGrokAcpSpawnInput(input.grokSettings, input.cwd, input.environment),
-		authMethodId: resolveGrokAuthMethodId(input.environment)
-	}).pipe(Layer.provide(Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, input.childProcessSpawner))));
-	const runtime = yield* Effect.service(AcpSessionRuntime).pipe(Effect.provide(acpContext));
-	return yield* makeXAiPromptCompletionRuntime(runtime);
-});
-function resolveGrokAcpBaseModelId(model) {
-	const trimmed = model?.trim();
-	const base = trimmed && trimmed.length > 0 ? trimmed : "grok-build";
-	return normalizeModelSlug(base, GROK_DRIVER_KIND) ?? "grok-build";
-}
-function currentGrokModelIdFromSessionSetup(sessionSetupResult) {
-	return sessionSetupResult.models?.currentModelId?.trim() || void 0;
-}
-function applyGrokAcpModelSelection(input) {
-	if (!(input.requestedModelId !== void 0 && input.requestedModelId !== input.currentModelId)) return Effect.succeed(input.currentModelId);
-	return input.runtime.setSessionModel(input.requestedModelId).pipe(Effect.mapError(input.mapError), Effect.as(input.requestedModelId));
-}
-//#endregion
-//#region src/textGeneration/GrokTextGeneration.ts
-const GROK_TIMEOUT_MS = 18e4;
-function mapGrokAcpError(operation, detail, cause) {
-	return new 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.fn("makeGrokTextGeneration")(function* (grokSettings, environment = process.env) {
-	const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	const runGrokJson = ({ operation, cwd, prompt, outputSchemaJson, modelSelection }) => Effect.gen(function* () {
-		const resolvedModel = resolveGrokAcpBaseModelId(modelSelection.model);
-		const outputRef = yield* 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.void;
-			const content = update.content;
-			if (content.type !== "text") return Effect.void;
-			return Ref.update(outputRef, (current) => current + content.text);
-		});
-		const promptResult = yield* Effect.gen(function* () {
-			const started = yield* runtime.start();
-			yield* applyGrokAcpModelSelection({
-				runtime,
-				currentModelId: currentGrokModelIdFromSessionSetup(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.timeoutOption(GROK_TIMEOUT_MS), Effect.flatMap(Option.match({
-			onNone: () => Effect.fail(new TextGenerationError({
-				operation,
-				detail: "Grok ACP request timed out."
-			})),
-			onSome: (value) => Effect.succeed(value)
-		})), Effect.mapError((cause) => isTextGenerationError(cause) ? cause : mapGrokAcpError(operation, "Grok ACP request failed.", cause)));
-		const trimmed = (yield* Ref.get(outputRef)).trim();
-		if (!trimmed) return yield* new TextGenerationError({
-			operation,
-			detail: promptResult.stopReason === "cancelled" ? "Grok ACP request was cancelled." : "Grok Agent returned empty output."
-		});
-		return yield* Schema.decodeEffect(Schema.fromJsonString(outputSchemaJson))(extractJsonObject(trimmed)).pipe(Effect.catchTag("SchemaError", (cause) => Effect.fail(new TextGenerationError({
-			operation,
-			detail: "Grok Agent returned invalid structured output.",
-			cause
-		}))));
-	}).pipe(Effect.mapError((cause) => isTextGenerationError(cause) ? cause : mapGrokAcpError(operation, "Grok ACP text generation failed.", cause)), Effect.scoped);
-	return {
-		generateCommitMessage: Effect.fn("GrokTextGeneration.generateCommitMessage")(function* (input) {
-			const { prompt, outputSchema } = 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: sanitizeCommitSubject(generated.subject),
-				body: generated.body.trim(),
-				..."branch" in generated && typeof generated.branch === "string" ? { branch: sanitizeFeatureBranchName(generated.branch) } : {}
-			};
-		}),
-		generatePrContent: Effect.fn("GrokTextGeneration.generatePrContent")(function* (input) {
-			const { prompt, outputSchema } = 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: sanitizePrTitle(generated.title),
-				body: generated.body.trim()
-			};
-		}),
-		generateBranchName: Effect.fn("GrokTextGeneration.generateBranchName")(function* (input) {
-			const { prompt, outputSchema } = buildBranchNamePrompt({
-				message: input.message,
-				attachments: input.attachments
-			});
-			const generated = yield* runGrokJson({
-				operation: "generateBranchName",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				modelSelection: input.modelSelection
-			});
-			return { branch: sanitizeBranchFragment(generated.branch) };
-		}),
-		generateThreadTitle: Effect.fn("GrokTextGeneration.generateThreadTitle")(function* (input) {
-			const { prompt, outputSchema } = buildThreadTitlePrompt({
-				message: input.message,
-				attachments: input.attachments
-			});
-			const generated = yield* runGrokJson({
-				operation: "generateThreadTitle",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				modelSelection: input.modelSelection
-			});
-			return { title: sanitizeThreadTitle(generated.title) };
-		}),
-		generateIssueContent: Effect.fn("GrokTextGeneration.generateIssueContent")(function* (input) {
-			if (input.mode === "polish") {
-				const { prompt, outputSchema } = 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 } = buildIssueContentTitlePrompt({ body: input.body });
-			return { title: (yield* runGrokJson({
-				operation: "generateIssueContent",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				modelSelection: input.modelSelection
-			})).title.trim() };
-		}),
-		rankInboxThreads: Effect.fn("GrokTextGeneration.rankInboxThreads")(function* (input) {
-			const { prompt, outputSchema } = buildThreadPriorityPrompt({ serializedCandidates: input.chunk.serializedCandidates });
-			const generated = yield* runGrokJson({
-				operation: "rankInboxThreads",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				modelSelection: input.modelSelection
-			});
-			return yield* validateRankInboxThreadsResult(input, generated.rankings);
-		})
-	};
-});
-//#endregion
-//#region src/provider/Layers/GrokAdapter.ts
+//#region src/provider/Layers/AcpAdapter.ts
 const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown));
-const PROVIDER$1 = ProviderDriverKind.make("grok");
-const GROK_RESUME_VERSION = 1;
+const ACP_RESUME_VERSION = 1;
 function encodeJsonStringForDiagnostics(input) {
 	const result = encodeUnknownJsonStringExit(input);
 	return Exit.isSuccess(result) ? result.value : void 0;
@@ -535,9 +320,9 @@ function settlePendingUserInputsAsCancelled(pendingUserInputs) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parseGrokResume(raw) {
+function parseAcpResume(raw) {
 	if (!isRecord(raw)) return void 0;
-	if (raw.schemaVersion !== GROK_RESUME_VERSION) return void 0;
+	if (raw.schemaVersion !== ACP_RESUME_VERSION) return void 0;
 	if (typeof raw.sessionId !== "string" || !raw.sessionId.trim()) return void 0;
 	return { sessionId: raw.sessionId.trim() };
 }
@@ -548,9 +333,11 @@ function selectPermissionOptionId(request, decision) {
 function selectAutoApprovedPermissionOption(request) {
 	return selectPermissionOptionId(request, "acceptForSession") ?? selectPermissionOptionId(request, "accept");
 }
-function makeGrokAdapter(grokSettings, options) {
+function makeAcpAdapter(options) {
+	const PROVIDER = options.provider;
+	const normalizeModel = options.normalizeModel;
 	return Effect.gen(function* () {
-		const boundInstanceId = options?.instanceId ?? ProviderInstanceId.make("grok");
+		const boundInstanceId = options?.instanceId ?? ProviderInstanceId.make(PROVIDER);
 		const fileSystem = yield* FileSystem.FileSystem;
 		const path = yield* Path.Path;
 		const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
@@ -568,7 +355,7 @@ function makeGrokAdapter(grokSettings, options) {
 			createdAt: nowIso
 		});
 		const mapAcpCallbackFailure = (effect) => effect.pipe(Effect.mapError((cause) => new AcpTransportError({
-			detail: "Failed to process Grok ACP callback.",
+			detail: "Failed to process ACP callback.",
 			cause
 		})));
 		const offerRuntimeEventForRuntime = (runtimeSessionId, event) => {
@@ -597,14 +384,14 @@ function makeGrokAdapter(grokSettings, options) {
 				event: {
 					id: yield* randomUUIDv4,
 					kind: "notification",
-					provider: PROVIDER$1,
+					provider: PROVIDER,
 					createdAt: observedAt,
 					method,
 					threadId,
 					payload
 				}
 			}, threadId);
-		}).pipe(Effect.catchCause((cause) => Effect.logWarning("Failed to write native Grok notification log.", {
+		}).pipe(Effect.catchCause((cause) => Effect.logWarning("Failed to write native ACP notification log.", {
 			cause,
 			threadId,
 			method
@@ -615,7 +402,7 @@ function makeGrokAdapter(grokSettings, options) {
 			ctx.lastPlanFingerprint = fingerprint;
 			yield* offerRuntimeEventForRuntime(ctx.session.runtimeSessionId, makeAcpPlanUpdatedEvent({
 				stamp: yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: ctx.threadId,
 				turnId: ctx.activeTurnId,
 				payload,
@@ -627,7 +414,7 @@ function makeGrokAdapter(grokSettings, options) {
 		const requireSession = (threadId) => {
 			const ctx = sessions.get(threadId);
 			if (!ctx || ctx.stopped) return Effect.fail(new ProviderAdapterSessionNotFoundError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId
 			}));
 			return Effect.succeed(ctx);
@@ -643,42 +430,42 @@ function makeGrokAdapter(grokSettings, options) {
 			yield* offerRuntimeEventForRuntime(ctx.session.runtimeSessionId, {
 				type: "session.exited",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: ctx.threadId,
 				payload: { exitKind: "graceful" }
 			});
 		});
 		const startSession = (input) => withThreadLock(input.threadId, Effect.gen(function* () {
-			if (input.provider !== void 0 && input.provider !== PROVIDER$1) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+			if (input.provider !== void 0 && input.provider !== PROVIDER) return yield* new ProviderAdapterValidationError({
+				provider: PROVIDER,
 				operation: "startSession",
-				issue: `Expected provider '${PROVIDER$1}' but received '${input.provider}'.`
+				issue: `Expected provider '${PROVIDER}' but received '${input.provider}'.`
 			});
 			if (input.providerInstanceId !== void 0 && input.providerInstanceId !== boundInstanceId) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				operation: "startSession",
 				issue: `Expected provider instance '${boundInstanceId}' but received '${input.providerInstanceId}'.`
 			});
-			const runtimeSessionId = yield* requireRuntimeSessionId(PROVIDER$1, input);
+			const runtimeSessionId = yield* requireRuntimeSessionId(PROVIDER, input);
 			if (!input.cwd?.trim()) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				operation: "startSession",
 				issue: "cwd is required and must be non-empty."
 			});
 			const effectiveResumeCursor = input.resumePolicy === "fresh" ? void 0 : input.resumeCursor;
-			const grokResume = effectiveResumeCursor === void 0 ? void 0 : parseGrokResume(effectiveResumeCursor);
-			if (effectiveResumeCursor !== void 0 && grokResume === void 0) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+			const acpResume = effectiveResumeCursor === void 0 ? void 0 : parseAcpResume(effectiveResumeCursor);
+			if (effectiveResumeCursor !== void 0 && acpResume === void 0) return yield* new ProviderAdapterValidationError({
+				provider: PROVIDER,
 				operation: "startSession",
 				issue: "resumeCursor must use schema version 1 and contain a non-empty sessionId."
 			});
 			const cwd = path.resolve(input.cwd.trim());
-			const grokModelSelection = input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : void 0;
+			const acpModelSelection = input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : void 0;
 			const existing = sessions.get(input.threadId);
 			if (existing && !existing.stopped) {
 				if (existing.session.runtimeSessionId === runtimeSessionId) return existing.session;
 				return yield* new ProviderAdapterValidationError({
-					provider: PROVIDER$1,
+					provider: PROVIDER,
 					operation: "startSession",
 					issue: `Thread '${input.threadId}' still has runtime '${existing.session.runtimeSessionId ?? "legacy"}'; stop it before starting '${runtimeSessionId}'.`
 				});
@@ -694,14 +481,13 @@ function makeGrokAdapter(grokSettings, options) {
 				isTurnActive: () => ctx !== void 0 && ctx.activeTurnId !== void 0 && !ctx.stopped
 			});
 			if (deviceToolBinding) yield* Scope.addFinalizer(sessionScope, Effect.sync(() => deviceToolBinding.dispose()));
-			const resumeSessionId = grokResume?.sessionId;
+			const resumeSessionId = acpResume?.sessionId;
 			const acpNativeLoggers = makeAcpNativeLoggers({
 				nativeEventLogger,
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: input.threadId
 			});
-			const acp = yield* makeGrokAcpRuntime({
-				grokSettings,
+			const acp = yield* options.makeRuntime({
 				...options?.environment ? { environment: options.environment } : {},
 				childProcessSpawner,
 				cwd,
@@ -721,13 +507,13 @@ function makeGrokAdapter(grokSettings, options) {
 				}] } : {},
 				...acpNativeLoggers
 			}).pipe(Effect.provideService(Scope.Scope, sessionScope), Effect.mapError((cause) => new ProviderAdapterProcessError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: input.threadId,
 				detail: cause.message,
 				cause
 			})));
 			const started = yield* Effect.gen(function* () {
-				yield* Effect.forEach(["x.ai/ask_user_question", "_x.ai/ask_user_question"], (method) => acp.handleExtRequest(method, XAiAskUserQuestionRequest, (params) => mapAcpCallbackFailure(Effect.gen(function* () {
+				yield* Effect.forEach(options.xaiExtensions ? ["x.ai/ask_user_question", "_x.ai/ask_user_question"] : [], (method) => acp.handleExtRequest(method, XAiAskUserQuestionRequest, (params) => mapAcpCallbackFailure(Effect.gen(function* () {
 					yield* logNative(input.threadId, method, params);
 					const requestId = ApprovalRequestId.make(yield* randomUUIDv4);
 					const runtimeRequestId = RuntimeRequestId.make(requestId);
@@ -736,7 +522,7 @@ function makeGrokAdapter(grokSettings, options) {
 					yield* offerRuntimeEventForRuntime(runtimeSessionId, {
 						type: "user-input.requested",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						threadId: input.threadId,
 						turnId: sessions.get(input.threadId)?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -753,7 +539,7 @@ function makeGrokAdapter(grokSettings, options) {
 					yield* offerRuntimeEventForRuntime(runtimeSessionId, {
 						type: "user-input.resolved",
 						...yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						threadId: input.threadId,
 						turnId: sessions.get(input.threadId)?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -785,7 +571,7 @@ function makeGrokAdapter(grokSettings, options) {
 					pendingApprovals.set(requestId, { decision });
 					yield* offerRuntimeEventForRuntime(runtimeSessionId, makeAcpRequestOpenedEvent({
 						stamp: yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						threadId: input.threadId,
 						turnId: sessions.get(input.threadId)?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -800,7 +586,7 @@ function makeGrokAdapter(grokSettings, options) {
 					pendingApprovals.delete(requestId);
 					yield* offerRuntimeEventForRuntime(runtimeSessionId, makeAcpRequestResolvedEvent({
 						stamp: yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						threadId: input.threadId,
 						turnId: sessions.get(input.threadId)?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -814,27 +600,28 @@ function makeGrokAdapter(grokSettings, options) {
 					} : { outcome: "cancelled" } };
 				})));
 				return yield* acp.start();
-			}).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/start", error)));
-			const requestedStartModelId = grokModelSelection?.model ? resolveGrokAcpBaseModelId(grokModelSelection.model) : void 0;
-			const boundModelId = yield* applyGrokAcpModelSelection({
+			}).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER, input.threadId, "session/start", error)));
+			if (options.onStarted) yield* options.onStarted(started);
+			const requestedStartModelId = acpModelSelection?.model ? normalizeModel(acpModelSelection.model) : void 0;
+			const boundModelId = yield* applyAcpModelSelection({
 				runtime: acp,
-				currentModelId: currentGrokModelIdFromSessionSetup(started.sessionSetupResult),
-				requestedModelId: requestedStartModelId,
-				mapError: (cause) => mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/set_model", cause)
+				currentModelId: currentAcpModelIdFromSessionSetup(started.sessionSetupResult),
+				requestedModelId: requestedStartModelId || void 0,
+				mapError: (cause) => mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_model", cause)
 			});
 			const now = yield* nowIso;
 			const session = {
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				providerInstanceId: boundInstanceId,
 				runtimeSessionId,
 				status: "ready",
 				runtimeMode: input.runtimeMode,
 				tokenMode: input.tokenMode ?? "balanced",
 				cwd,
-				...boundModelId ? { model: resolveGrokAcpBaseModelId(boundModelId) } : {},
+				...boundModelId ? { model: normalizeModel(boundModelId) } : {},
 				threadId: input.threadId,
 				resumeCursor: {
-					schemaVersion: GROK_RESUME_VERSION,
+					schemaVersion: ACP_RESUME_VERSION,
 					sessionId: started.sessionId
 				},
 				createdAt: now,
@@ -854,14 +641,18 @@ function makeGrokAdapter(grokSettings, options) {
 				lastPlanFingerprint: void 0,
 				activeTurnId: void 0,
 				currentModelId: boundModelId,
+				promptImages: started.initializeResult.agentCapabilities?.promptCapabilities?.image === true,
 				stopped: false
 			};
 			const nf = yield* Stream.runDrain(Stream.mapEffect(acp.getEvents(), (event) => Effect.gen(function* () {
 				switch (event._tag) {
+					case "CommandsUpdated":
+						if (options.onCommands) yield* options.onCommands(event.commands);
+						return;
 					case "AssistantItemStarted":
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, makeAcpAssistantItemEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							itemId: event.itemId,
@@ -871,7 +662,7 @@ function makeGrokAdapter(grokSettings, options) {
 					case "AssistantItemCompleted":
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, makeAcpAssistantItemEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							itemId: event.itemId,
@@ -886,14 +677,14 @@ function makeGrokAdapter(grokSettings, options) {
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload);
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, makeAcpToolCallEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							toolCall: event.toolCall,
 							rawPayload: event.rawPayload
 						}));
 						for (const subagentEvent of yield* ctx.subagentEvents({
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							state: event.toolCall.subagent,
@@ -905,7 +696,7 @@ function makeGrokAdapter(grokSettings, options) {
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload);
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, makeAcpContentDeltaEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							...event.itemId ? { itemId: event.itemId } : {},
@@ -917,7 +708,7 @@ function makeGrokAdapter(grokSettings, options) {
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload);
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, makeAcpThoughtDeltaEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							text: event.text,
@@ -925,10 +716,11 @@ function makeGrokAdapter(grokSettings, options) {
 						}));
 						return;
 					case "UsageUpdated":
+						if (options.onUsage) yield* options.onUsage();
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload);
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, makeAcpTokenUsageEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							usage: event.usage,
@@ -943,24 +735,24 @@ function makeGrokAdapter(grokSettings, options) {
 			yield* offerRuntimeEventForRuntime(runtimeSessionId, {
 				type: "session.started",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: input.threadId,
 				payload: { resume: started.initializeResult }
 			});
 			yield* offerRuntimeEventForRuntime(runtimeSessionId, {
 				type: "session.state.changed",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: input.threadId,
 				payload: {
 					state: "ready",
-					reason: "Grok ACP session ready"
+					reason: "ACP session ready"
 				}
 			});
 			yield* offerRuntimeEventForRuntime(runtimeSessionId, {
 				type: "thread.started",
 				...yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: input.threadId,
 				payload: { providerThreadId: started.sessionId }
 			});
@@ -971,16 +763,16 @@ function makeGrokAdapter(grokSettings, options) {
 				const ctx = yield* requireSession(input.threadId);
 				const turnId = TurnId.make(yield* randomUUIDv4);
 				const turnModelSelection = input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : void 0;
-				const requestedTurnModelId = turnModelSelection?.model ? resolveGrokAcpBaseModelId(turnModelSelection.model) : void 0;
-				const currentModelId = yield* applyGrokAcpModelSelection({
+				const requestedTurnModelId = turnModelSelection?.model ? normalizeModel(turnModelSelection.model) : void 0;
+				const currentModelId = yield* applyAcpModelSelection({
 					runtime: ctx.acp,
 					currentModelId: ctx.currentModelId,
-					requestedModelId: requestedTurnModelId,
-					mapError: (cause) => mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/set_model", cause)
+					requestedModelId: requestedTurnModelId || void 0,
+					mapError: (cause) => mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_model", cause)
 				});
 				const pathLineEntries = [];
 				const imagePromptParts = yield* Effect.forEach(input.attachments ?? [], (attachment) => Effect.gen(function* () {
-					if (!isPersistableChatAttachment(attachment) || attachment.type !== "image") {
+					if (!isPersistableChatAttachment(attachment) || attachment.type !== "image" || options.respectPromptCapabilities && !ctx.promptImages) {
 						pathLineEntries.push({
 							attachment,
 							...attachment.id === void 0 ? {} : { resolvedPath: resolveAttachmentPath({
@@ -995,12 +787,12 @@ function makeGrokAdapter(grokSettings, options) {
 						attachment
 					});
 					if (!attachmentPath) return yield* new ProviderAdapterRequestError({
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						method: "session/prompt",
 						detail: `Invalid attachment id '${attachment.id}'.`
 					});
 					const bytes = yield* fileSystem.readFile(attachmentPath).pipe(Effect.mapError((cause) => new ProviderAdapterRequestError({
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						method: "session/prompt",
 						detail: cause.message,
 						cause
@@ -1017,12 +809,12 @@ function makeGrokAdapter(grokSettings, options) {
 					text: promptText
 				}] : [], ...imagePromptParts.filter((part) => part !== null)];
 				if (promptParts.length === 0) return yield* new ProviderAdapterValidationError({
-					provider: PROVIDER$1,
+					provider: PROVIDER,
 					operation: "sendTurn",
 					issue: "Turn requires non-empty text or attachments."
 				});
 				ctx.currentModelId = currentModelId;
-				const displayModel = currentModelId ? resolveGrokAcpBaseModelId(currentModelId) : void 0;
+				const displayModel = currentModelId ? normalizeModel(currentModelId) : void 0;
 				ctx.activeTurnId = turnId;
 				ctx.lastPlanFingerprint = void 0;
 				ctx.session = {
@@ -1034,7 +826,7 @@ function makeGrokAdapter(grokSettings, options) {
 				yield* offerRuntimeEventForRuntime(ctx.session.runtimeSessionId, {
 					type: "turn.started",
 					...yield* makeEventStamp(),
-					provider: PROVIDER$1,
+					provider: PROVIDER,
 					threadId: input.threadId,
 					turnId,
 					payload: displayModel ? { model: displayModel } : {}
@@ -1047,13 +839,13 @@ function makeGrokAdapter(grokSettings, options) {
 					turnId
 				};
 			}));
-			const result = yield* prepared.acp.prompt({ prompt: prepared.promptParts }).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/prompt", error)));
+			const result = yield* prepared.acp.prompt({ prompt: prepared.promptParts }).pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER, input.threadId, "session/prompt", error)));
 			return yield* withThreadLock(input.threadId, Effect.gen(function* () {
 				const ctx = yield* requireSession(input.threadId);
 				if (ctx.acpSessionId !== prepared.acpSessionId) return yield* new ProviderAdapterRequestError({
-					provider: PROVIDER$1,
+					provider: PROVIDER,
 					method: "session/prompt",
-					detail: "Grok session changed before the turn completed."
+					detail: "ACP session changed before the turn completed."
 				});
 				ctx.turns = [...ctx.turns, {
 					id: prepared.turnId,
@@ -1071,7 +863,7 @@ function makeGrokAdapter(grokSettings, options) {
 				yield* offerRuntimeEventForRuntime(ctx.session.runtimeSessionId, {
 					type: "turn.completed",
 					...yield* makeEventStamp(),
-					provider: PROVIDER$1,
+					provider: PROVIDER,
 					threadId: input.threadId,
 					turnId: prepared.turnId,
 					payload: {
@@ -1090,12 +882,12 @@ function makeGrokAdapter(grokSettings, options) {
 			const ctx = yield* requireSession(threadId);
 			yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);
 			yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);
-			yield* Effect.ignore(ctx.acp.cancel.pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER$1, threadId, "session/cancel", error))));
+			yield* Effect.ignore(ctx.acp.cancel.pipe(Effect.mapError((error) => mapAcpToAdapterError(PROVIDER, threadId, "session/cancel", error))));
 		});
 		const respondToRequest = (threadId, requestId, decision) => Effect.gen(function* () {
 			const pending = (yield* requireSession(threadId)).pendingApprovals.get(requestId);
 			if (!pending) return yield* new ProviderAdapterRequestError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				method: "session/request_permission",
 				detail: `Unknown pending approval request: ${requestId}`
 			});
@@ -1104,7 +896,7 @@ function makeGrokAdapter(grokSettings, options) {
 		const respondToUserInput = (threadId, requestId, answers) => Effect.gen(function* () {
 			const pending = (yield* requireSession(threadId)).pendingUserInputs.get(requestId);
 			if (!pending) return yield* new ProviderAdapterRequestError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				method: "_x.ai/ask_user_question",
 				detail: `Unknown pending user-input request: ${requestId}`
 			});
@@ -1122,14 +914,14 @@ function makeGrokAdapter(grokSettings, options) {
 		const rollbackThread = (threadId, numTurns) => Effect.gen(function* () {
 			yield* requireSession(threadId);
 			if (!Number.isInteger(numTurns) || numTurns < 1) return yield* new ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				operation: "rollbackThread",
 				issue: "numTurns must be an integer >= 1."
 			});
 			return yield* new ProviderAdapterRequestError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				method: "thread/rollback",
-				detail: "Grok ACP sessions do not support provider-side rollback yet."
+				detail: "ACP sessions do not support provider-side rollback yet."
 			});
 		});
 		const stopSession = (threadId) => withThreadLock(threadId, Effect.gen(function* () {
@@ -1145,8 +937,10 @@ function makeGrokAdapter(grokSettings, options) {
 		yield* Effect.addFinalizer(() => Effect.ignore(stopAll()).pipe(Effect.tap(() => PubSub.shutdown(runtimeEventPubSub)), Effect.tap(() => managedNativeEventLogger?.close() ?? Effect.void)));
 		const streamEvents = Stream.fromPubSub(runtimeEventPubSub);
 		return {
-			provider: PROVIDER$1,
-			capabilities: { sessionModelSwitch: "unsupported" },
+			provider: PROVIDER,
+			capabilities: { get sessionModelSwitch() {
+				return options.getSessionModelSwitch?.() ?? "unsupported";
+			} },
 			startSession,
 			sendTurn,
 			interruptTurn,
@@ -1163,300 +957,4 @@ function makeGrokAdapter(grokSettings, options) {
 	});
 }
 //#endregion
-//#region src/provider/Layers/GrokProvider.ts
-const GROK_PRESENTATION = {
-	displayName: "Grok",
-	badgeLabel: "Early Access",
-	showInteractionModeToggle: false
-};
-const PROVIDER = ProviderDriverKind.make("grok");
-const EMPTY_CAPABILITIES = 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 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 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 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.gen(function* () {
-	const childProcessSpawner = yield* 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.scoped);
-const runGrokVersionCommand = (grokSettings, environment = process.env) => {
-	const command = grokSettings.binaryPath || "grok";
-	return spawnAndCollect(command, ChildProcess.make(command, ["--version"], {
-		env: environment,
-		shell: process.platform === "win32"
-	}));
-};
-const checkGrokProviderStatus = Effect.fn("checkGrokProviderStatus")(function* (grokSettings, environment = process.env) {
-	const checkedAt = DateTime.formatIso(yield* DateTime.now);
-	const fallbackModels = grokModelsFromSettings(grokSettings.customModels);
-	if (!grokSettings.enabled) return 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.timeoutOption(VERSION_PROBE_TIMEOUT_MS), Effect.result);
-	if (Result.isFailure(versionResult)) {
-		const error = versionResult.failure;
-		yield* Effect.logWarning("Grok CLI health check failed.", { errorTag: error.name });
-		return buildServerProvider({
-			presentation: GROK_PRESENTATION,
-			enabled: grokSettings.enabled,
-			checkedAt,
-			models: fallbackModels,
-			probe: {
-				installed: !isCommandMissingCause(error),
-				version: null,
-				status: "error",
-				auth: { status: "unknown" },
-				message: isCommandMissingCause(error) ? "Grok CLI (`grok`) is not installed or not on PATH." : "Failed to execute Grok CLI health check."
-			}
-		});
-	}
-	if (Option.isNone(versionResult.success)) return 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 = parseGenericCliVersion(`${versionOutput.stdout}\n${versionOutput.stderr}`);
-	if (versionOutput.code !== 0) {
-		yield* Effect.logWarning("Grok CLI version probe exited with a non-zero status.", {
-			exitCode: versionOutput.code,
-			stdoutLength: versionOutput.stdout.length,
-			stderrLength: versionOutput.stderr.length
-		});
-		return 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.timeoutOption(GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS), Effect.exit);
-	if (Exit.isFailure(discoveryExit)) {
-		yield* Effect.logWarning("Grok ACP model discovery failed", { cause: Cause.pretty(discoveryExit.cause) });
-		return 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 (Option.isNone(discoveryExit.value)) {
-		yield* Effect.logWarning(`Grok ACP model discovery timed out after ${GROK_ACP_MODEL_DISCOVERY_TIMEOUT_MS}ms.`);
-		return 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 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 enrichProviderSnapshotWithVersionAdvisory(snapshot, input.maintenanceCapabilities).pipe(Effect.provideService(HttpClient.HttpClient, input.httpClient), Effect.provideService(ServerSettingsService, input.serverSettings), Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot)), Effect.catchCause((cause) => Effect.logWarning("Grok version advisory enrichment failed", { cause: Cause.pretty(cause) })), Effect.asVoid);
-};
-//#endregion
-//#region src/provider/Drivers/GrokDriver.ts
-const decodeGrokSettings = Schema.decodeSync(GrokSettings);
-const DRIVER_KIND = ProviderDriverKind.make("grok");
-const SNAPSHOT_REFRESH_INTERVAL = Duration.minutes(5);
-const UPDATE = makeStaticProviderMaintenanceResolver(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: GrokSettings,
-	defaultConfig: () => decodeGrokSettings({}),
-	create: ({ instanceId, displayName, accentColor, environment, enabled, config }) => Effect.gen(function* () {
-		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-		const httpClient = yield* HttpClient.HttpClient;
-		const serverSettings = yield* ServerSettingsService;
-		const eventLoggers = yield* ProviderEventLoggers;
-		const processEnv = mergeProviderInstanceEnvironment(environment);
-		const continuationIdentity = defaultProviderContinuationIdentity({
-			driverKind: DRIVER_KIND,
-			instanceId
-		});
-		const stampIdentity = withInstanceIdentity({
-			instanceId,
-			displayName,
-			accentColor,
-			continuationGroupKey: continuationIdentity.continuationKey
-		});
-		const effectiveConfig = {
-			...config,
-			enabled
-		};
-		const maintenanceCapabilities = yield* 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.map(stampIdentity), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
-		const snapshot = yield* makeManagedServerProvider({
-			maintenanceCapabilities,
-			getSettings: Effect.succeed(effectiveConfig),
-			streamSettings: 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.mapError((cause) => new 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
-export { GrokDriver };
+export { currentAcpModelIdFromSessionSetup as i, makeXAiPromptCompletionRuntime as n, applyAcpModelSelection as r, makeAcpAdapter as t };