@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/runtime/opencode-runtime.js

@@ -2,88 +2,74 @@ import { loadPipelineConfig } from "../config/load.js";
 import "../config.js";
 import { createOpencodeExecutor, createOpencodeSessionRegistry } from "./opencode-session-executor.js";
 import { OpencodeRuntimeServerService, OpencodeRuntimeServerServiceLive } from "./services/opencode-runtime-server-service.js";
-import { Effect } from "effect";
+import { createYeetExecutor } from "./yeet-executor.js";
+import { Effect, Option } from "effect";
 //#region src/runtime/opencode-runtime.ts
+const NO_AVAILABLE_MODELS = Option.none();
 /**
 * True when the config declares any opencode runner, i.e. the SDK transport is
 * relevant for this run. Command-only configs never start a server.
 */
-function configUsesOpencode(config) {
-	return Object.values(config.runners).some((runner) => runner.type === "opencode");
-}
-/**
-* Return an SDK-backed executor plus a release() that tears the server down.
-* The opencode server is started LAZILY on the first executor call, not at
-* lease time: a run whose ready nodes are all command/builtin (or that fails
-* before any agent node executes) never spawns opencode, so the binary is only
-* required when an agent node actually runs. release() is a no-op if the server
-* was never started. Caller owns the lifecycle:
-*
-*   const lease = await leaseOpencodeRuntime({ config, worktreePath });
-*   try { ...run with lease.executor... } finally { await lease.release(); }
-*/
-function leaseOpencodeRuntime(input) {
-	return Effect.runPromise(Effect.provide(leaseOpencodeRuntimeEffect(input), OpencodeRuntimeServerServiceLive));
-}
-function withOpencodeRuntime(options, run) {
-	return Effect.gen(function* () {
-		if (options.executor) return yield* run(options);
-		const { config, worktreePath } = resolveConfigForRun(options);
-		if (configUsesOpencode(config)) return yield* runWithLeasedOpencode(options, config, worktreePath, run);
-		return yield* run({
-			...options,
-			config
-		});
-	});
-}
-function resolveConfigForRun(options) {
+const configUsesOpencode = (config) => Object.values(config.runners).some((runner) => runner.type === "opencode");
+const resolveConfigForRun = (options) => {
 	const worktreePath = options.worktreePath ?? process.cwd();
 	return {
 		config: options.config ?? loadPipelineConfig(worktreePath),
 		worktreePath
 	};
-}
-function runWithLeasedOpencode(options, config, worktreePath, run) {
-	return Effect.scoped(Effect.gen(function* () {
-		const lease = yield* Effect.acquireRelease(Effect.tryPromise(() => leaseOpencodeRuntime({
-			config,
-			...options.reporter ? { onSession: opencodeSessionReporter(options.reporter) } : {},
-			...options.signal ? { signal: options.signal } : {},
-			worktreePath
-		})), (lease) => Effect.promise(() => lease.release()));
-		const availableModels = yield* Effect.promise(() => lease.availableModels());
-		return yield* run({
-			...options,
-			config,
-			executor: lease.executor,
-			...availableModels ? { availableModels } : {}
-		});
-	}));
-}
-function opencodeSessionReporter(reporter) {
-	return (nodeId, sessionId) => {
-		reporter({
-			nodeId,
-			sessionId,
-			type: "node.session"
-		});
+};
+const opencodeSessionReporter = (reporter) => (nodeId, sessionId) => {
+	reporter({
+		nodeId,
+		sessionId,
+		type: "node.session"
+	});
+};
+/**
+* Collect every model the leased server can resolve (each authenticated
+* provider's models as `provider/model`) from the opencode `/config/providers`
+* endpoint, for availability-aware model selection.
+*/
+const queryAvailableOpencodeModels = async (client) => {
+	const providers = (await client.config.providers()).data?.providers ?? [];
+	return new Set(providers.flatMap((provider) => Object.keys(provider.models).map((modelId) => `${provider.id}/${modelId}`)));
+};
+const ensureExecutorEffect = (input, registry) => Effect.gen(function* effectBody() {
+	const handle = yield* (yield* OpencodeRuntimeServerService).open(input);
+	return {
+		delegate: createOpencodeExecutor({
+			client: handle.client,
+			directory: input.worktreePath,
+			...input.onSession ? { onSession: input.onSession } : {},
+			registry
+		}),
+		handle
 	};
-}
-function leaseOpencodeRuntimeEffect(input) {
+});
+const leaseOpencodeRuntimeEffect = (input) => {
 	const registry = createOpencodeSessionRegistry();
-	let handle;
-	let pending;
-	let availableModelsPending;
-	const ensureExecutor = () => {
-		pending ??= Effect.runPromise(Effect.provide(ensureExecutorEffect(input, registry), OpencodeRuntimeServerServiceLive)).then((executor) => {
-			handle = executor.handle;
-			return executor.delegate;
+	let handle = Option.none();
+	let pending = Option.none();
+	let availableModelsPending = Option.none();
+	const ensureExecutor = async () => {
+		return await Option.getOrElse(pending, async () => {
+			const next = Effect.runPromise(Effect.provide(ensureExecutorEffect(input, registry), OpencodeRuntimeServerServiceLive)).then((executor) => {
+				handle = Option.some(executor.handle);
+				return executor.delegate;
+			});
+			pending = Option.some(next);
+			return await next;
 		});
-		return pending;
 	};
-	const resolveAvailableModels = () => {
-		availableModelsPending ??= ensureExecutor().then(() => handle ? queryAvailableOpencodeModels(handle.client) : void 0).catch(() => void 0);
-		return availableModelsPending;
+	const resolveAvailableModels = async () => {
+		return await Option.getOrElse(availableModelsPending, async () => {
+			const next = ensureExecutor().then(async () => {
+				if (Option.isNone(handle)) return Option.none();
+				return Option.some(await queryAvailableOpencodeModels(handle.value.client));
+			}).catch(() => NO_AVAILABLE_MODELS);
+			availableModelsPending = Option.some(next);
+			return await next;
+		});
 	};
 	return Effect.succeed({
 		availableModels: resolveAvailableModels,
@@ -91,35 +77,71 @@ function leaseOpencodeRuntimeEffect(input) {
 			return await (await ensureExecutor())(plan, options);
 		},
 		release: async () => {
-			if (handle) {
-				await handle.close();
-				handle = void 0;
+			if (Option.isSome(handle)) {
+				await handle.value.close();
+				handle = Option.none();
 			}
 		}
 	});
-}
+};
 /**
-* Collect every model the leased server can resolve (each authenticated
-* provider's models as `provider/model`) from the opencode `/config/providers`
-* endpoint, for availability-aware model selection.
+* Return an SDK-backed executor plus a release() that tears the server down.
+* The opencode server is started LAZILY on the first executor call, not at
+* lease time: a run whose ready nodes are all command/builtin (or that fails
+* before any agent node executes) never spawns opencode, so the binary is only
+* required when an agent node actually runs. release() is a no-op if the server
+* was never started. Caller owns the lifecycle:
+*
+*   const lease = await leaseOpencodeRuntime({ config, worktreePath });
+*   try { ...run with lease.executor... } finally { await lease.release(); }
 */
-async function queryAvailableOpencodeModels(client) {
-	const providers = (await client.config.providers()).data?.providers ?? [];
-	return new Set(providers.flatMap((provider) => Object.keys(provider.models ?? {}).map((modelId) => `${provider.id}/${modelId}`)));
-}
-function ensureExecutorEffect(input, registry) {
-	return Effect.gen(function* () {
-		const handle = yield* (yield* OpencodeRuntimeServerService).open(input);
-		return {
-			delegate: createOpencodeExecutor({
-				client: handle.client,
-				directory: input.worktreePath,
-				...input.onSession ? { onSession: input.onSession } : {},
-				registry
-			}),
-			handle
-		};
+const leaseOpencodeRuntime = async (input) => await Effect.runPromise(Effect.provide(leaseOpencodeRuntimeEffect(input), OpencodeRuntimeServerServiceLive));
+const runWithLeasedOpencode = (options, config, worktreePath, run, lease) => Effect.scoped(Effect.gen(function* effectBody() {
+	const acquired = yield* Effect.acquireRelease(Effect.tryPromise(async () => await lease({
+		config,
+		...options.reporter === void 0 ? {} : { onSession: opencodeSessionReporter(options.reporter) },
+		...options.signal === void 0 ? {} : { signal: options.signal },
+		worktreePath
+	})), (leased) => Effect.promise(async () => {
+		await leased.release();
+	}));
+	const availableModels = yield* Effect.promise(async () => await acquired.availableModels());
+	return yield* run({
+		...options,
+		config,
+		executor: acquired.executor,
+		...Option.isSome(availableModels) ? { availableModels: availableModels.value } : {}
+	});
+}));
+/**
+* Build the yeet-backed executor for this run and hand it to `run`. Unlike the
+* SDK transport, yeet needs no leased server (it spawns `yeet run opencode` per
+* node), so there is nothing to release. Session ids are reported through the
+* same reporter seam as the SDK path.
+*/
+const runWithYeetExecutor = (options, config, run, createExecutor) => {
+	const deps = options.reporter === void 0 ? {} : { onSession: opencodeSessionReporter(options.reporter) };
+	return run({
+		...options,
+		config,
+		executor: createExecutor(deps)
+	});
+};
+/**
+* Which transport drives opencode agent nodes for this config. The gate lives
+* in config (`runtime.executor`) and defaults to the in-process SDK session
+* executor; "yeet" selects the subprocess yeet runtime (ENG-18.1).
+*/
+const resolveOpencodeExecutorKind = (config) => config.runtime.executor;
+const withOpencodeRuntime = (options, run, overrides = {}) => Effect.gen(function* effectBody() {
+	if (options.executor !== void 0) return yield* run(options);
+	const { config, worktreePath } = resolveConfigForRun(options);
+	if (!configUsesOpencode(config)) return yield* run({
+		...options,
+		config
 	});
-}
+	if (resolveOpencodeExecutorKind(config) === "yeet") return yield* runWithYeetExecutor(options, config, run, overrides.createYeetExecutor ?? createYeetExecutor);
+	return yield* runWithLeasedOpencode(options, config, worktreePath, run, overrides.leaseOpencodeRuntime ?? leaseOpencodeRuntime);
+});
 //#endregion
-export { configUsesOpencode, leaseOpencodeRuntime, withOpencodeRuntime };
+export { configUsesOpencode, leaseOpencodeRuntime, resolveOpencodeExecutorKind, withOpencodeRuntime };

package/dist/runtime/opencode-server.js

@@ -6,63 +6,30 @@ const DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
 var OpencodeServerStartupError = class extends Data.TaggedError("OpencodeServerStartupError") {
 	constructor(message, options) {
 		super({
-			message,
-			cause: options?.cause
+			cause: options?.cause,
+			message
 		});
 	}
 };
-function openOpencodeServer(options) {
-	return Effect.runPromise(Effect.provide(openOpencodeServerEffect(options), OpencodeSdkServiceLive));
-}
-function openOpencodeServerEffect(options) {
-	const externalUrl = options.serverUrl ?? process.env.OPENCODE_SERVER_URL ?? "";
-	if (externalUrl.length > 0) return connectExternalServer(externalUrl, options.directory).pipe(Effect.mapError(startupError));
-	return spawnOwnedServer(options);
-}
-function connectExternalServer(url, directory) {
-	return Effect.gen(function* () {
-		return {
-			close: () => Promise.resolve(),
-			client: yield* (yield* OpencodeSdkService).createClient({
-				baseUrl: url,
-				directory
-			}),
-			owned: false,
-			url
-		};
-	});
-}
-function spawnOwnedServer(options) {
-	return Effect.gen(function* () {
-		const { client, server } = yield* (yield* OpencodeSdkService).spawnServer(spawnArgs(options), options.spawn);
-		return ownedHandle(client, server, options.directory);
-	}).pipe(Effect.catch((error) => Effect.fail(startupError(error))));
-}
-function startupError(error) {
-	return new OpencodeServerStartupError(`Failed to start opencode server: ${errorText(error)}`, { cause: error });
-}
-function spawnArgs(options) {
+const connectExternalServer = (url, directory) => Effect.gen(function* effectBody() {
 	return {
-		port: 0,
-		...options.signal ? { signal: options.signal } : {},
-		timeout: options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS
-	};
-}
-function ownedHandle(client, server, directory) {
-	return {
-		close: () => {
-			server.close();
-			return Promise.resolve();
-		},
-		client: withDirectory(client, server.url, directory),
-		owned: true,
-		url: server.url
+		client: yield* (yield* OpencodeSdkService).createClient({
+			baseUrl: url,
+			directory
+		}),
+		close: async () => {},
+		owned: false,
+		url
 	};
-}
-function errorText(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function withDirectory(fallback, url, directory) {
+});
+const spawnArgs = (options) => ({
+	port: 0,
+	...options.signal ? { signal: options.signal } : {},
+	timeout: options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS
+});
+const errorText = (error) => error instanceof Error ? error.message : String(error);
+const startupError = (error) => new OpencodeServerStartupError(`Failed to start opencode server: ${errorText(error)}`, { cause: error });
+const withDirectory = (fallback, url, directory) => {
 	try {
 		return createOpencodeClient({
 			baseUrl: url,
@@ -71,6 +38,25 @@ function withDirectory(fallback, url, directory) {
 	} catch {
 		return fallback;
 	}
-}
+};
+const ownedHandle = (client, server, directory) => ({
+	client: withDirectory(client, server.url, directory),
+	close: async () => {
+		server.close();
+		await Promise.resolve();
+	},
+	owned: true,
+	url: server.url
+});
+const spawnOwnedServer = (options) => Effect.gen(function* effectBody() {
+	const { client, server } = yield* (yield* OpencodeSdkService).spawnServer(spawnArgs(options), options.spawn);
+	return ownedHandle(client, server, options.directory);
+}).pipe(Effect.catch((error) => Effect.fail(startupError(error))));
+const openOpencodeServerEffect = (options) => {
+	const externalUrl = options.serverUrl ?? process.env.OPENCODE_SERVER_URL ?? "";
+	if (externalUrl.length > 0) return connectExternalServer(externalUrl, options.directory).pipe(Effect.mapError(startupError));
+	return spawnOwnedServer(options);
+};
+const openOpencodeServer = async (options) => await Effect.runPromise(Effect.provide(openOpencodeServerEffect(options), OpencodeSdkServiceLive));
 //#endregion
 export { OpencodeServerStartupError, openOpencodeServer };