ryco-cli 0.1.24 → 0.1.26

package/dist/{GrokDriver-RyyFeh_q.cjs → AcpAdapter-CadxcdZV.cjs}

@@ -1,26 +1,20 @@
 #!/usr/bin/env node
 
 const require_rolldown_runtime = require("./rolldown-runtime-LGfotAqq.cjs");
-const require_collectUint8StreamText = require("./collectUint8StreamText-DStwNTTK.cjs");
-const require_Metrics = require("./Metrics-Bcb9vCAe.cjs");
+const require_src = require("./src-BlzIcnVG.cjs");
+const require_Metrics = require("./Metrics-DCKbdeoH.cjs");
 const require_bin = require("./bin.cjs");
-const require_makeManagedServerProvider = require("./makeManagedServerProvider-VzxWN-04.cjs");
-const require_ProviderDriver = require("./ProviderDriver--rNeAi3B.cjs");
-const require_AcpNativeLogging = require("./AcpNativeLogging-COepku4a.cjs");
+const require_AcpNativeLogging = require("./AcpNativeLogging-DZPZNoju.cjs");
+const require_runtimeSession = require("./runtimeSession-Bj0OUcNJ.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_Semaphore = require("effect/Semaphore");
 effect_Semaphore = require_rolldown_runtime.__toESM(effect_Semaphore, 1);
 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_Deferred = require("effect/Deferred");
 effect_Deferred = require_rolldown_runtime.__toESM(effect_Deferred, 1);
 let effect_Exit = require("effect/Exit");
@@ -31,22 +25,28 @@ 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_Fiber = require("effect/Fiber");
 effect_Fiber = require_rolldown_runtime.__toESM(effect_Fiber, 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_DateTime = require("effect/DateTime");
-effect_DateTime = require_rolldown_runtime.__toESM(effect_DateTime, 1);
 let effect_PubSub = require("effect/PubSub");
 effect_PubSub = require_rolldown_runtime.__toESM(effect_PubSub, 1);
 let effect_SynchronizedRef = require("effect/SynchronizedRef");
 effect_SynchronizedRef = require_rolldown_runtime.__toESM(effect_SynchronizedRef, 1);
-let effect_Result = require("effect/Result");
-effect_Result = require_rolldown_runtime.__toESM(effect_Result, 1);
+//#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_Effect.succeed(input.currentModelId);
+	return input.runtime.setSessionModel(input.requestedModelId).pipe(effect_Effect.mapError(input.mapError), effect_Effect.as(input.requestedModelId));
+}
+//#endregion
 //#region src/provider/acp/XAiAcpExtension.ts
 const XAiPromptCompleteNotification = effect_Schema.Struct({
 	sessionId: effect_Schema.String,
@@ -320,228 +320,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 = require_collectUint8StreamText.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_AcpNativeLogging.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_AcpNativeLogging.AcpSessionRuntime).pipe(effect_Effect.provide(acpContext));
-	return yield* 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";
-}
-function currentGrokModelIdFromSessionSetup(sessionSetupResult) {
-	return sessionSetupResult.models?.currentModelId?.trim() || void 0;
-}
-function applyGrokAcpModelSelection(input) {
-	if (!(input.requestedModelId !== void 0 && input.requestedModelId !== input.currentModelId)) return effect_Effect.succeed(input.currentModelId);
-	return input.runtime.setSessionModel(input.requestedModelId).pipe(effect_Effect.mapError(input.mapError), effect_Effect.as(input.requestedModelId));
-}
-//#endregion
-//#region src/textGeneration/GrokTextGeneration.ts
-const GROK_TIMEOUT_MS = 18e4;
-function mapGrokAcpError(operation, detail, cause) {
-	return new require_collectUint8StreamText.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* 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_Effect.timeoutOption(GROK_TIMEOUT_MS), effect_Effect.flatMap(effect_Option.match({
-			onNone: () => effect_Effect.fail(new require_collectUint8StreamText.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_collectUint8StreamText.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_collectUint8StreamText.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_Metrics.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_Metrics.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);
-		})
-	};
-});
-//#endregion
-//#region src/provider/Layers/GrokAdapter.ts
+//#region src/provider/Layers/AcpAdapter.ts
 const encodeUnknownJsonStringExit = effect_Schema.encodeUnknownExit(effect_Schema.fromJsonString(effect_Schema.Unknown));
-const PROVIDER$1 = require_collectUint8StreamText.ProviderDriverKind.make("grok");
-const GROK_RESUME_VERSION = 1;
+const ACP_RESUME_VERSION = 1;
 function encodeJsonStringForDiagnostics(input) {
 	const result = encodeUnknownJsonStringExit(input);
 	return effect_Exit.isSuccess(result) ? result.value : void 0;
@@ -555,9 +336,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() };
 }
@@ -568,9 +349,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_Effect.gen(function* () {
-		const boundInstanceId = options?.instanceId ?? require_collectUint8StreamText.ProviderInstanceId.make("grok");
+		const boundInstanceId = options?.instanceId ?? require_src.ProviderInstanceId.make(PROVIDER);
 		const fileSystem = yield* effect_FileSystem.FileSystem;
 		const path = yield* effect_Path.Path;
 		const childProcessSpawner = yield* effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner;
@@ -582,17 +365,17 @@ function makeGrokAdapter(grokSettings, options) {
 		const runtimeEventPubSub = yield* effect_PubSub.bounded(2048);
 		const nowIso = effect_Effect.map(effect_DateTime.now, effect_DateTime.formatIso);
 		const randomUUIDv4 = effect_Effect.sync(() => crypto.randomUUID());
-		const nextEventId = effect_Effect.map(randomUUIDv4, (id) => require_collectUint8StreamText.EventId.make(id));
+		const nextEventId = effect_Effect.map(randomUUIDv4, (id) => require_src.EventId.make(id));
 		const makeEventStamp = () => effect_Effect.all({
 			eventId: nextEventId,
 			createdAt: nowIso
 		});
-		const mapAcpCallbackFailure = (effect) => effect.pipe(effect_Effect.mapError((cause) => new require_AcpNativeLogging.AcpTransportError({
-			detail: "Failed to process Grok ACP callback.",
+		const mapAcpCallbackFailure = (effect) => effect.pipe(effect_Effect.mapError((cause) => new require_bin.AcpTransportError({
+			detail: "Failed to process ACP callback.",
 			cause
 		})));
 		const offerRuntimeEventForRuntime = (runtimeSessionId, event) => {
-			return effect_PubSub.publish(runtimeEventPubSub, require_makeManagedServerProvider.stampRuntimeEvent(event, {
+			return effect_PubSub.publish(runtimeEventPubSub, require_runtimeSession.stampRuntimeEvent(event, {
 				providerInstanceId: boundInstanceId,
 				runtimeSessionId
 			})).pipe(effect_Effect.asVoid);
@@ -617,14 +400,14 @@ function makeGrokAdapter(grokSettings, options) {
 				event: {
 					id: yield* randomUUIDv4,
 					kind: "notification",
-					provider: PROVIDER$1,
+					provider: PROVIDER,
 					createdAt: observedAt,
 					method,
 					threadId,
 					payload
 				}
 			}, threadId);
-		}).pipe(effect_Effect.catchCause((cause) => effect_Effect.logWarning("Failed to write native Grok notification log.", {
+		}).pipe(effect_Effect.catchCause((cause) => effect_Effect.logWarning("Failed to write native ACP notification log.", {
 			cause,
 			threadId,
 			method
@@ -635,7 +418,7 @@ function makeGrokAdapter(grokSettings, options) {
 			ctx.lastPlanFingerprint = fingerprint;
 			yield* offerRuntimeEventForRuntime(ctx.session.runtimeSessionId, require_AcpNativeLogging.makeAcpPlanUpdatedEvent({
 				stamp: yield* makeEventStamp(),
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: ctx.threadId,
 				turnId: ctx.activeTurnId,
 				payload,
@@ -647,7 +430,7 @@ function makeGrokAdapter(grokSettings, options) {
 		const requireSession = (threadId) => {
 			const ctx = sessions.get(threadId);
 			if (!ctx || ctx.stopped) return effect_Effect.fail(new require_bin.ProviderAdapterSessionNotFoundError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId
 			}));
 			return effect_Effect.succeed(ctx);
@@ -663,42 +446,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_Effect.gen(function* () {
-			if (input.provider !== void 0 && input.provider !== PROVIDER$1) return yield* new require_bin.ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+			if (input.provider !== void 0 && input.provider !== PROVIDER) return yield* new require_bin.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 require_bin.ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				operation: "startSession",
 				issue: `Expected provider instance '${boundInstanceId}' but received '${input.providerInstanceId}'.`
 			});
-			const runtimeSessionId = yield* require_makeManagedServerProvider.requireRuntimeSessionId(PROVIDER$1, input);
+			const runtimeSessionId = yield* require_runtimeSession.requireRuntimeSessionId(PROVIDER, input);
 			if (!input.cwd?.trim()) return yield* new require_bin.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 require_bin.ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+			const acpResume = effectiveResumeCursor === void 0 ? void 0 : parseAcpResume(effectiveResumeCursor);
+			if (effectiveResumeCursor !== void 0 && acpResume === void 0) return yield* new require_bin.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 require_bin.ProviderAdapterValidationError({
-					provider: PROVIDER$1,
+					provider: PROVIDER,
 					operation: "startSession",
 					issue: `Thread '${input.threadId}' still has runtime '${existing.session.runtimeSessionId ?? "legacy"}'; stop it before starting '${runtimeSessionId}'.`
 				});
@@ -714,14 +497,13 @@ function makeGrokAdapter(grokSettings, options) {
 				isTurnActive: () => ctx !== void 0 && ctx.activeTurnId !== void 0 && !ctx.stopped
 			});
 			if (deviceToolBinding) yield* effect_Scope.addFinalizer(sessionScope, effect_Effect.sync(() => deviceToolBinding.dispose()));
-			const resumeSessionId = grokResume?.sessionId;
+			const resumeSessionId = acpResume?.sessionId;
 			const acpNativeLoggers = require_AcpNativeLogging.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,
@@ -741,22 +523,22 @@ function makeGrokAdapter(grokSettings, options) {
 				}] } : {},
 				...acpNativeLoggers
 			}).pipe(effect_Effect.provideService(effect_Scope.Scope, sessionScope), effect_Effect.mapError((cause) => new require_bin.ProviderAdapterProcessError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				threadId: input.threadId,
 				detail: cause.message,
 				cause
 			})));
 			const started = yield* effect_Effect.gen(function* () {
-				yield* effect_Effect.forEach(["x.ai/ask_user_question", "_x.ai/ask_user_question"], (method) => acp.handleExtRequest(method, XAiAskUserQuestionRequest, (params) => mapAcpCallbackFailure(effect_Effect.gen(function* () {
+				yield* effect_Effect.forEach(options.xaiExtensions ? ["x.ai/ask_user_question", "_x.ai/ask_user_question"] : [], (method) => acp.handleExtRequest(method, XAiAskUserQuestionRequest, (params) => mapAcpCallbackFailure(effect_Effect.gen(function* () {
 					yield* logNative(input.threadId, method, params);
-					const requestId = require_collectUint8StreamText.ApprovalRequestId.make(yield* randomUUIDv4);
-					const runtimeRequestId = require_collectUint8StreamText.RuntimeRequestId.make(requestId);
+					const requestId = require_src.ApprovalRequestId.make(yield* randomUUIDv4);
+					const runtimeRequestId = require_src.RuntimeRequestId.make(requestId);
 					const resolution = yield* effect_Deferred.make();
 					pendingUserInputs.set(requestId, { resolution });
 					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,
@@ -773,7 +555,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,
@@ -798,14 +580,14 @@ function makeGrokAdapter(grokSettings, options) {
 							optionId: autoApprovedOptionId
 						} };
 					}
-					const permissionRequest = require_AcpNativeLogging.parsePermissionRequest(params);
-					const requestId = require_collectUint8StreamText.ApprovalRequestId.make(yield* randomUUIDv4);
-					const runtimeRequestId = require_collectUint8StreamText.RuntimeRequestId.make(requestId);
+					const permissionRequest = require_bin.parsePermissionRequest(params);
+					const requestId = require_src.ApprovalRequestId.make(yield* randomUUIDv4);
+					const runtimeRequestId = require_src.RuntimeRequestId.make(requestId);
 					const decision = yield* effect_Deferred.make();
 					pendingApprovals.set(requestId, { decision });
 					yield* offerRuntimeEventForRuntime(runtimeSessionId, require_AcpNativeLogging.makeAcpRequestOpenedEvent({
 						stamp: yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						threadId: input.threadId,
 						turnId: sessions.get(input.threadId)?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -820,7 +602,7 @@ function makeGrokAdapter(grokSettings, options) {
 					pendingApprovals.delete(requestId);
 					yield* offerRuntimeEventForRuntime(runtimeSessionId, require_AcpNativeLogging.makeAcpRequestResolvedEvent({
 						stamp: yield* makeEventStamp(),
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						threadId: input.threadId,
 						turnId: sessions.get(input.threadId)?.activeTurnId,
 						requestId: runtimeRequestId,
@@ -834,27 +616,28 @@ function makeGrokAdapter(grokSettings, options) {
 					} : { outcome: "cancelled" } };
 				})));
 				return yield* acp.start();
-			}).pipe(effect_Effect.mapError((error) => require_AcpNativeLogging.mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/start", error)));
-			const requestedStartModelId = grokModelSelection?.model ? resolveGrokAcpBaseModelId(grokModelSelection.model) : void 0;
-			const boundModelId = yield* applyGrokAcpModelSelection({
+			}).pipe(effect_Effect.mapError((error) => require_AcpNativeLogging.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) => require_AcpNativeLogging.mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/set_model", cause)
+				currentModelId: currentAcpModelIdFromSessionSetup(started.sessionSetupResult),
+				requestedModelId: requestedStartModelId || void 0,
+				mapError: (cause) => require_AcpNativeLogging.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,
@@ -874,14 +657,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* effect_Stream.runDrain(effect_Stream.mapEffect(acp.getEvents(), (event) => effect_Effect.gen(function* () {
 				switch (event._tag) {
+					case "CommandsUpdated":
+						if (options.onCommands) yield* options.onCommands(event.commands);
+						return;
 					case "AssistantItemStarted":
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, require_AcpNativeLogging.makeAcpAssistantItemEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							itemId: event.itemId,
@@ -891,7 +678,7 @@ function makeGrokAdapter(grokSettings, options) {
 					case "AssistantItemCompleted":
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, require_AcpNativeLogging.makeAcpAssistantItemEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							itemId: event.itemId,
@@ -906,14 +693,14 @@ function makeGrokAdapter(grokSettings, options) {
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload);
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, require_AcpNativeLogging.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,
@@ -925,7 +712,7 @@ function makeGrokAdapter(grokSettings, options) {
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload);
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, require_AcpNativeLogging.makeAcpContentDeltaEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							...event.itemId ? { itemId: event.itemId } : {},
@@ -937,7 +724,7 @@ function makeGrokAdapter(grokSettings, options) {
 						yield* logNative(ctx.threadId, "session/update", event.rawPayload);
 						yield* offerRuntimeEventForRuntime(runtimeSessionId, require_AcpNativeLogging.makeAcpThoughtDeltaEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							text: event.text,
@@ -945,10 +732,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, require_AcpNativeLogging.makeAcpTokenUsageEvent({
 							stamp: yield* makeEventStamp(),
-							provider: PROVIDER$1,
+							provider: PROVIDER,
 							threadId: ctx.threadId,
 							turnId: ctx.activeTurnId,
 							usage: event.usage,
@@ -963,24 +751,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 }
 			});
@@ -989,18 +777,18 @@ function makeGrokAdapter(grokSettings, options) {
 		const sendTurn = (input) => effect_Effect.gen(function* () {
 			const prepared = yield* withThreadLock(input.threadId, effect_Effect.gen(function* () {
 				const ctx = yield* requireSession(input.threadId);
-				const turnId = require_collectUint8StreamText.TurnId.make(yield* randomUUIDv4);
+				const turnId = require_src.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) => require_AcpNativeLogging.mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/set_model", cause)
+					requestedModelId: requestedTurnModelId || void 0,
+					mapError: (cause) => require_AcpNativeLogging.mapAcpToAdapterError(PROVIDER, input.threadId, "session/set_model", cause)
 				});
 				const pathLineEntries = [];
 				const imagePromptParts = yield* effect_Effect.forEach(input.attachments ?? [], (attachment) => effect_Effect.gen(function* () {
-					if (!require_bin.isPersistableChatAttachment(attachment) || attachment.type !== "image") {
+					if (!require_bin.isPersistableChatAttachment(attachment) || attachment.type !== "image" || options.respectPromptCapabilities && !ctx.promptImages) {
 						pathLineEntries.push({
 							attachment,
 							...attachment.id === void 0 ? {} : { resolvedPath: require_bin.resolveAttachmentPath({
@@ -1015,12 +803,12 @@ function makeGrokAdapter(grokSettings, options) {
 						attachment
 					});
 					if (!attachmentPath) return yield* new require_bin.ProviderAdapterRequestError({
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						method: "session/prompt",
 						detail: `Invalid attachment id '${attachment.id}'.`
 					});
 					const bytes = yield* fileSystem.readFile(attachmentPath).pipe(effect_Effect.mapError((cause) => new require_bin.ProviderAdapterRequestError({
-						provider: PROVIDER$1,
+						provider: PROVIDER,
 						method: "session/prompt",
 						detail: cause.message,
 						cause
@@ -1031,18 +819,18 @@ function makeGrokAdapter(grokSettings, options) {
 						mimeType: attachment.mimeType
 					};
 				}));
-				const promptText = require_makeManagedServerProvider.appendAttachmentPathLines(input.input?.trim(), require_makeManagedServerProvider.formatAttachmentPathLines(pathLineEntries));
+				const promptText = require_runtimeSession.appendAttachmentPathLines(input.input?.trim(), require_runtimeSession.formatAttachmentPathLines(pathLineEntries));
 				const promptParts = [...promptText && promptText.trim().length > 0 ? [{
 					type: "text",
 					text: promptText
 				}] : [], ...imagePromptParts.filter((part) => part !== null)];
 				if (promptParts.length === 0) return yield* new require_bin.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 = {
@@ -1054,7 +842,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 } : {}
@@ -1067,13 +855,13 @@ function makeGrokAdapter(grokSettings, options) {
 					turnId
 				};
 			}));
-			const result = yield* prepared.acp.prompt({ prompt: prepared.promptParts }).pipe(effect_Effect.mapError((error) => require_AcpNativeLogging.mapAcpToAdapterError(PROVIDER$1, input.threadId, "session/prompt", error)));
+			const result = yield* prepared.acp.prompt({ prompt: prepared.promptParts }).pipe(effect_Effect.mapError((error) => require_AcpNativeLogging.mapAcpToAdapterError(PROVIDER, input.threadId, "session/prompt", error)));
 			return yield* withThreadLock(input.threadId, effect_Effect.gen(function* () {
 				const ctx = yield* requireSession(input.threadId);
 				if (ctx.acpSessionId !== prepared.acpSessionId) return yield* new require_bin.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,
@@ -1091,7 +879,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: {
@@ -1110,12 +898,12 @@ function makeGrokAdapter(grokSettings, options) {
 			const ctx = yield* requireSession(threadId);
 			yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);
 			yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);
-			yield* effect_Effect.ignore(ctx.acp.cancel.pipe(effect_Effect.mapError((error) => require_AcpNativeLogging.mapAcpToAdapterError(PROVIDER$1, threadId, "session/cancel", error))));
+			yield* effect_Effect.ignore(ctx.acp.cancel.pipe(effect_Effect.mapError((error) => require_AcpNativeLogging.mapAcpToAdapterError(PROVIDER, threadId, "session/cancel", error))));
 		});
 		const respondToRequest = (threadId, requestId, decision) => effect_Effect.gen(function* () {
 			const pending = (yield* requireSession(threadId)).pendingApprovals.get(requestId);
 			if (!pending) return yield* new require_bin.ProviderAdapterRequestError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				method: "session/request_permission",
 				detail: `Unknown pending approval request: ${requestId}`
 			});
@@ -1124,7 +912,7 @@ function makeGrokAdapter(grokSettings, options) {
 		const respondToUserInput = (threadId, requestId, answers) => effect_Effect.gen(function* () {
 			const pending = (yield* requireSession(threadId)).pendingUserInputs.get(requestId);
 			if (!pending) return yield* new require_bin.ProviderAdapterRequestError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				method: "_x.ai/ask_user_question",
 				detail: `Unknown pending user-input request: ${requestId}`
 			});
@@ -1142,14 +930,14 @@ function makeGrokAdapter(grokSettings, options) {
 		const rollbackThread = (threadId, numTurns) => effect_Effect.gen(function* () {
 			yield* requireSession(threadId);
 			if (!Number.isInteger(numTurns) || numTurns < 1) return yield* new require_bin.ProviderAdapterValidationError({
-				provider: PROVIDER$1,
+				provider: PROVIDER,
 				operation: "rollbackThread",
 				issue: "numTurns must be an integer >= 1."
 			});
 			return yield* new require_bin.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_Effect.gen(function* () {
@@ -1165,8 +953,10 @@ function makeGrokAdapter(grokSettings, options) {
 		yield* effect_Effect.addFinalizer(() => effect_Effect.ignore(stopAll()).pipe(effect_Effect.tap(() => effect_PubSub.shutdown(runtimeEventPubSub)), effect_Effect.tap(() => managedNativeEventLogger?.close() ?? effect_Effect.void)));
 		const streamEvents = effect_Stream.fromPubSub(runtimeEventPubSub);
 		return {
-			provider: PROVIDER$1,
-			capabilities: { sessionModelSwitch: "unsupported" },
+			provider: PROVIDER,
+			capabilities: { get sessionModelSwitch() {
+				return options.getSessionModelSwitch?.() ?? "unsupported";
+			} },
 			startSession,
 			sendTurn,
 			interruptTurn,
@@ -1183,300 +973,27 @@ function makeGrokAdapter(grokSettings, options) {
 	});
 }
 //#endregion
-//#region src/provider/Layers/GrokProvider.ts
-const GROK_PRESENTATION = {
-	displayName: "Grok",
-	badgeLabel: "Early Access",
-	showInteractionModeToggle: false
-};
-const PROVIDER = require_collectUint8StreamText.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."
-			}
-		});
+Object.defineProperty(exports, "applyAcpModelSelection", {
+	enumerable: true,
+	get: function() {
+		return applyAcpModelSelection;
 	}
-	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."
-			}
-		});
+});
+Object.defineProperty(exports, "currentAcpModelIdFromSessionSetup", {
+	enumerable: true,
+	get: function() {
+		return currentAcpModelIdFromSessionSetup;
 	}
-	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.`
-			}
-		});
+});
+Object.defineProperty(exports, "makeAcpAdapter", {
+	enumerable: true,
+	get: function() {
+		return makeAcpAdapter;
 	}
-	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_collectUint8StreamText.GrokSettings);
-const DRIVER_KIND = require_collectUint8StreamText.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 }
+Object.defineProperty(exports, "makeXAiPromptCompletionRuntime", {
+	enumerable: true,
+	get: function() {
+		return makeXAiPromptCompletionRuntime;
+	}
 });
-const GrokDriver = {
-	driverKind: DRIVER_KIND,
-	metadata: {
-		displayName: "Grok",
-		supportsMultipleInstances: true
-	},
-	configSchema: require_collectUint8StreamText.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;