@flue/cli 0.0.9 → 0.0.11

package/dist/dist-C2CPKdvn.mjs

@@ -0,0 +1,2406 @@
+import { exec } from "node:child_process";
+
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/core/serverSentEvents.gen.js
+const createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const response = await fetch(url, {
+					...options,
+					headers,
+					signal
+				});
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				await sleep(Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4));
+			}
+		}
+	};
+	return { stream: createStream() };
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/core/auth.gen.js
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/core/bodySerializer.gen.js
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/core/pathSerializer.gen.js
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/core/utils.gen.js
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/client/utils.gen.js
+const createQuerySerializer = ({ allowReserved, array, object } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+const setAuthParams = async ({ security, ...options }) => {
+	for (const auth of security) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+};
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header || typeof header !== "object") continue;
+		const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	_fns;
+	constructor() {
+		this._fns = [];
+	}
+	clear() {
+		this._fns = [];
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this._fns[id] ? id : -1;
+		else return this._fns.indexOf(id);
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return !!this._fns[index];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this._fns[index]) this._fns[index] = null;
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this._fns[index]) {
+			this._fns[index] = fn;
+			return id;
+		} else return false;
+	}
+	use(fn) {
+		this._fns = [...this._fns, fn];
+		return this._fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/client/client.gen.js
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams({
+			...opts,
+			security: opts.security
+		});
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.serializedBody === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		return {
+			opts,
+			url: buildUrl(opts)
+		};
+	};
+	const request = async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		const requestInit = {
+			redirect: "follow",
+			...opts,
+			body: opts.serializedBody
+		};
+		let request = new Request(url, requestInit);
+		for (const fn of interceptors.request._fns) if (fn) request = await fn(request, opts);
+		const _fetch = opts.fetch;
+		let response = await _fetch(request);
+		for (const fn of interceptors.response._fns) if (fn) response = await fn(response, request, opts);
+		const result = {
+			request,
+			response
+		};
+		if (response.ok) {
+			if (response.status === 204 || response.headers.get("Content-Length") === "0") return opts.responseStyle === "data" ? {} : {
+				data: {},
+				...result
+			};
+			const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+			let data;
+			switch (parseAs) {
+				case "arrayBuffer":
+				case "blob":
+				case "formData":
+				case "json":
+				case "text":
+					data = await response[parseAs]();
+					break;
+				case "stream": return opts.responseStyle === "data" ? response.body : {
+					data: response.body,
+					...result
+				};
+			}
+			if (parseAs === "json") {
+				if (opts.responseValidator) await opts.responseValidator(data);
+				if (opts.responseTransformer) data = await opts.responseTransformer(data);
+			}
+			return opts.responseStyle === "data" ? data : {
+				data,
+				...result
+			};
+		}
+		const textError = await response.text();
+		let jsonError;
+		try {
+			jsonError = JSON.parse(textError);
+		} catch {}
+		const error = jsonError ?? textError;
+		let finalError = error;
+		for (const fn of interceptors.error._fns) if (fn) finalError = await fn(error, response, request, opts);
+		finalError = finalError || {};
+		if (opts.throwOnError) throw finalError;
+		return opts.responseStyle === "data" ? void 0 : {
+			error: finalError,
+			...result
+		};
+	};
+	const makeMethod = (method) => {
+		const fn = (options) => request({
+			...options,
+			method
+		});
+		fn.sse = async (options) => {
+			const { opts, url } = await beforeRequest(options);
+			return createSseClient({
+				...opts,
+				body: opts.body,
+				headers: opts.headers,
+				method,
+				url
+			});
+		};
+		return fn;
+	};
+	return {
+		buildUrl,
+		connect: makeMethod("CONNECT"),
+		delete: makeMethod("DELETE"),
+		get: makeMethod("GET"),
+		getConfig,
+		head: makeMethod("HEAD"),
+		interceptors,
+		options: makeMethod("OPTIONS"),
+		patch: makeMethod("PATCH"),
+		post: makeMethod("POST"),
+		put: makeMethod("PUT"),
+		request,
+		setConfig,
+		trace: makeMethod("TRACE")
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/core/params.gen.js
+const extraPrefixes = Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/client.gen.js
+const client = createClient(createConfig({ baseUrl: "http://localhost:4096" }));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/gen/sdk.gen.js
+var _HeyApiClient = class {
+	_client = client;
+	constructor(args) {
+		if (args?.client) this._client = args.client;
+	}
+};
+var Global = class extends _HeyApiClient {
+	/**
+	* Get events
+	*/
+	event(options) {
+		return (options?.client ?? this._client).get.sse({
+			url: "/global/event",
+			...options
+		});
+	}
+};
+var Project = class extends _HeyApiClient {
+	/**
+	* List all projects
+	*/
+	list(options) {
+		return (options?.client ?? this._client).get({
+			url: "/project",
+			...options
+		});
+	}
+	/**
+	* Get the current project
+	*/
+	current(options) {
+		return (options?.client ?? this._client).get({
+			url: "/project/current",
+			...options
+		});
+	}
+};
+var Pty = class extends _HeyApiClient {
+	/**
+	* List all PTY sessions
+	*/
+	list(options) {
+		return (options?.client ?? this._client).get({
+			url: "/pty",
+			...options
+		});
+	}
+	/**
+	* Create a new PTY session
+	*/
+	create(options) {
+		return (options?.client ?? this._client).post({
+			url: "/pty",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* Remove a PTY session
+	*/
+	remove(options) {
+		return (options.client ?? this._client).delete({
+			url: "/pty/{id}",
+			...options
+		});
+	}
+	/**
+	* Get PTY session info
+	*/
+	get(options) {
+		return (options.client ?? this._client).get({
+			url: "/pty/{id}",
+			...options
+		});
+	}
+	/**
+	* Update PTY session
+	*/
+	update(options) {
+		return (options.client ?? this._client).put({
+			url: "/pty/{id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Connect to a PTY session
+	*/
+	connect(options) {
+		return (options.client ?? this._client).get({
+			url: "/pty/{id}/connect",
+			...options
+		});
+	}
+};
+var Config = class extends _HeyApiClient {
+	/**
+	* Get config info
+	*/
+	get(options) {
+		return (options?.client ?? this._client).get({
+			url: "/config",
+			...options
+		});
+	}
+	/**
+	* Update config
+	*/
+	update(options) {
+		return (options?.client ?? this._client).patch({
+			url: "/config",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* List all providers
+	*/
+	providers(options) {
+		return (options?.client ?? this._client).get({
+			url: "/config/providers",
+			...options
+		});
+	}
+};
+var Tool = class extends _HeyApiClient {
+	/**
+	* List all tool IDs (including built-in and dynamically registered)
+	*/
+	ids(options) {
+		return (options?.client ?? this._client).get({
+			url: "/experimental/tool/ids",
+			...options
+		});
+	}
+	/**
+	* List tools with JSON schema parameters for a provider/model
+	*/
+	list(options) {
+		return (options.client ?? this._client).get({
+			url: "/experimental/tool",
+			...options
+		});
+	}
+};
+var Instance = class extends _HeyApiClient {
+	/**
+	* Dispose the current instance
+	*/
+	dispose(options) {
+		return (options?.client ?? this._client).post({
+			url: "/instance/dispose",
+			...options
+		});
+	}
+};
+var Path = class extends _HeyApiClient {
+	/**
+	* Get the current path
+	*/
+	get(options) {
+		return (options?.client ?? this._client).get({
+			url: "/path",
+			...options
+		});
+	}
+};
+var Vcs = class extends _HeyApiClient {
+	/**
+	* Get VCS info for the current instance
+	*/
+	get(options) {
+		return (options?.client ?? this._client).get({
+			url: "/vcs",
+			...options
+		});
+	}
+};
+var Session = class extends _HeyApiClient {
+	/**
+	* List all sessions
+	*/
+	list(options) {
+		return (options?.client ?? this._client).get({
+			url: "/session",
+			...options
+		});
+	}
+	/**
+	* Create a new session
+	*/
+	create(options) {
+		return (options?.client ?? this._client).post({
+			url: "/session",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* Get session status
+	*/
+	status(options) {
+		return (options?.client ?? this._client).get({
+			url: "/session/status",
+			...options
+		});
+	}
+	/**
+	* Delete a session and all its data
+	*/
+	delete(options) {
+		return (options.client ?? this._client).delete({
+			url: "/session/{id}",
+			...options
+		});
+	}
+	/**
+	* Get session
+	*/
+	get(options) {
+		return (options.client ?? this._client).get({
+			url: "/session/{id}",
+			...options
+		});
+	}
+	/**
+	* Update session properties
+	*/
+	update(options) {
+		return (options.client ?? this._client).patch({
+			url: "/session/{id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get a session's children
+	*/
+	children(options) {
+		return (options.client ?? this._client).get({
+			url: "/session/{id}/children",
+			...options
+		});
+	}
+	/**
+	* Get the todo list for a session
+	*/
+	todo(options) {
+		return (options.client ?? this._client).get({
+			url: "/session/{id}/todo",
+			...options
+		});
+	}
+	/**
+	* Analyze the app and create an AGENTS.md file
+	*/
+	init(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/init",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Fork an existing session at a specific message
+	*/
+	fork(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/fork",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Abort a session
+	*/
+	abort(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/abort",
+			...options
+		});
+	}
+	/**
+	* Unshare the session
+	*/
+	unshare(options) {
+		return (options.client ?? this._client).delete({
+			url: "/session/{id}/share",
+			...options
+		});
+	}
+	/**
+	* Share a session
+	*/
+	share(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/share",
+			...options
+		});
+	}
+	/**
+	* Get the diff for this session
+	*/
+	diff(options) {
+		return (options.client ?? this._client).get({
+			url: "/session/{id}/diff",
+			...options
+		});
+	}
+	/**
+	* Summarize the session
+	*/
+	summarize(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/summarize",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* List messages for a session
+	*/
+	messages(options) {
+		return (options.client ?? this._client).get({
+			url: "/session/{id}/message",
+			...options
+		});
+	}
+	/**
+	* Create and send a new message to a session
+	*/
+	prompt(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/message",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Get a message from a session
+	*/
+	message(options) {
+		return (options.client ?? this._client).get({
+			url: "/session/{id}/message/{messageID}",
+			...options
+		});
+	}
+	/**
+	* Create and send a new message to a session, start if needed and return immediately
+	*/
+	promptAsync(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/prompt_async",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Send a new command to a session
+	*/
+	command(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/command",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Run a shell command
+	*/
+	shell(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/shell",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Revert a message
+	*/
+	revert(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/revert",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Restore all reverted messages
+	*/
+	unrevert(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/unrevert",
+			...options
+		});
+	}
+};
+var Command = class extends _HeyApiClient {
+	/**
+	* List all commands
+	*/
+	list(options) {
+		return (options?.client ?? this._client).get({
+			url: "/command",
+			...options
+		});
+	}
+};
+var Oauth = class extends _HeyApiClient {
+	/**
+	* Authorize a provider using OAuth
+	*/
+	authorize(options) {
+		return (options.client ?? this._client).post({
+			url: "/provider/{id}/oauth/authorize",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Handle OAuth callback for a provider
+	*/
+	callback(options) {
+		return (options.client ?? this._client).post({
+			url: "/provider/{id}/oauth/callback",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Provider = class extends _HeyApiClient {
+	/**
+	* List all providers
+	*/
+	list(options) {
+		return (options?.client ?? this._client).get({
+			url: "/provider",
+			...options
+		});
+	}
+	/**
+	* Get provider authentication methods
+	*/
+	auth(options) {
+		return (options?.client ?? this._client).get({
+			url: "/provider/auth",
+			...options
+		});
+	}
+	oauth = new Oauth({ client: this._client });
+};
+var Find = class extends _HeyApiClient {
+	/**
+	* Find text in files
+	*/
+	text(options) {
+		return (options.client ?? this._client).get({
+			url: "/find",
+			...options
+		});
+	}
+	/**
+	* Find files
+	*/
+	files(options) {
+		return (options.client ?? this._client).get({
+			url: "/find/file",
+			...options
+		});
+	}
+	/**
+	* Find workspace symbols
+	*/
+	symbols(options) {
+		return (options.client ?? this._client).get({
+			url: "/find/symbol",
+			...options
+		});
+	}
+};
+var File$1 = class extends _HeyApiClient {
+	/**
+	* List files and directories
+	*/
+	list(options) {
+		return (options.client ?? this._client).get({
+			url: "/file",
+			...options
+		});
+	}
+	/**
+	* Read a file
+	*/
+	read(options) {
+		return (options.client ?? this._client).get({
+			url: "/file/content",
+			...options
+		});
+	}
+	/**
+	* Get file status
+	*/
+	status(options) {
+		return (options?.client ?? this._client).get({
+			url: "/file/status",
+			...options
+		});
+	}
+};
+var App = class extends _HeyApiClient {
+	/**
+	* Write a log entry to the server logs
+	*/
+	log(options) {
+		return (options?.client ?? this._client).post({
+			url: "/log",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* List all agents
+	*/
+	agents(options) {
+		return (options?.client ?? this._client).get({
+			url: "/agent",
+			...options
+		});
+	}
+};
+var Auth = class extends _HeyApiClient {
+	/**
+	* Remove OAuth credentials for an MCP server
+	*/
+	remove(options) {
+		return (options.client ?? this._client).delete({
+			url: "/mcp/{name}/auth",
+			...options
+		});
+	}
+	/**
+	* Start OAuth authentication flow for an MCP server
+	*/
+	start(options) {
+		return (options.client ?? this._client).post({
+			url: "/mcp/{name}/auth",
+			...options
+		});
+	}
+	/**
+	* Complete OAuth authentication with authorization code
+	*/
+	callback(options) {
+		return (options.client ?? this._client).post({
+			url: "/mcp/{name}/auth/callback",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	/**
+	* Start OAuth flow and wait for callback (opens browser)
+	*/
+	authenticate(options) {
+		return (options.client ?? this._client).post({
+			url: "/mcp/{name}/auth/authenticate",
+			...options
+		});
+	}
+	/**
+	* Set authentication credentials
+	*/
+	set(options) {
+		return (options.client ?? this._client).put({
+			url: "/auth/{id}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+};
+var Mcp = class extends _HeyApiClient {
+	/**
+	* Get MCP server status
+	*/
+	status(options) {
+		return (options?.client ?? this._client).get({
+			url: "/mcp",
+			...options
+		});
+	}
+	/**
+	* Add MCP server dynamically
+	*/
+	add(options) {
+		return (options?.client ?? this._client).post({
+			url: "/mcp",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* Connect an MCP server
+	*/
+	connect(options) {
+		return (options.client ?? this._client).post({
+			url: "/mcp/{name}/connect",
+			...options
+		});
+	}
+	/**
+	* Disconnect an MCP server
+	*/
+	disconnect(options) {
+		return (options.client ?? this._client).post({
+			url: "/mcp/{name}/disconnect",
+			...options
+		});
+	}
+	auth = new Auth({ client: this._client });
+};
+var Lsp = class extends _HeyApiClient {
+	/**
+	* Get LSP server status
+	*/
+	status(options) {
+		return (options?.client ?? this._client).get({
+			url: "/lsp",
+			...options
+		});
+	}
+};
+var Formatter = class extends _HeyApiClient {
+	/**
+	* Get formatter status
+	*/
+	status(options) {
+		return (options?.client ?? this._client).get({
+			url: "/formatter",
+			...options
+		});
+	}
+};
+var Control = class extends _HeyApiClient {
+	/**
+	* Get the next TUI request from the queue
+	*/
+	next(options) {
+		return (options?.client ?? this._client).get({
+			url: "/tui/control/next",
+			...options
+		});
+	}
+	/**
+	* Submit a response to the TUI request queue
+	*/
+	response(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/control/response",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+};
+var Tui = class extends _HeyApiClient {
+	/**
+	* Append prompt to the TUI
+	*/
+	appendPrompt(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/append-prompt",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* Open the help dialog
+	*/
+	openHelp(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/open-help",
+			...options
+		});
+	}
+	/**
+	* Open the session dialog
+	*/
+	openSessions(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/open-sessions",
+			...options
+		});
+	}
+	/**
+	* Open the theme dialog
+	*/
+	openThemes(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/open-themes",
+			...options
+		});
+	}
+	/**
+	* Open the model dialog
+	*/
+	openModels(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/open-models",
+			...options
+		});
+	}
+	/**
+	* Submit the prompt
+	*/
+	submitPrompt(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/submit-prompt",
+			...options
+		});
+	}
+	/**
+	* Clear the prompt
+	*/
+	clearPrompt(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/clear-prompt",
+			...options
+		});
+	}
+	/**
+	* Execute a TUI command (e.g. agent_cycle)
+	*/
+	executeCommand(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/execute-command",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* Show a toast notification in the TUI
+	*/
+	showToast(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/show-toast",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	/**
+	* Publish a TUI event
+	*/
+	publish(options) {
+		return (options?.client ?? this._client).post({
+			url: "/tui/publish",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
+			}
+		});
+	}
+	control = new Control({ client: this._client });
+};
+var Event = class extends _HeyApiClient {
+	/**
+	* Get events
+	*/
+	subscribe(options) {
+		return (options?.client ?? this._client).get.sse({
+			url: "/event",
+			...options
+		});
+	}
+};
+var OpencodeClient = class extends _HeyApiClient {
+	/**
+	* Respond to a permission request
+	*/
+	postSessionIdPermissionsPermissionId(options) {
+		return (options.client ?? this._client).post({
+			url: "/session/{id}/permissions/{permissionID}",
+			...options,
+			headers: {
+				"Content-Type": "application/json",
+				...options.headers
+			}
+		});
+	}
+	global = new Global({ client: this._client });
+	project = new Project({ client: this._client });
+	pty = new Pty({ client: this._client });
+	config = new Config({ client: this._client });
+	tool = new Tool({ client: this._client });
+	instance = new Instance({ client: this._client });
+	path = new Path({ client: this._client });
+	vcs = new Vcs({ client: this._client });
+	session = new Session({ client: this._client });
+	command = new Command({ client: this._client });
+	provider = new Provider({ client: this._client });
+	find = new Find({ client: this._client });
+	file = new File$1({ client: this._client });
+	app = new App({ client: this._client });
+	mcp = new Mcp({ client: this._client });
+	lsp = new Lsp({ client: this._client });
+	formatter = new Formatter({ client: this._client });
+	tui = new Tui({ client: this._client });
+	auth = new Auth({ client: this._client });
+	event = new Event({ client: this._client });
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opencode-ai+sdk@1.1.55/node_modules/@opencode-ai/sdk/dist/client.js
+function createOpencodeClient(config) {
+	if (!config?.fetch) {
+		const customFetch = (req) => {
+			req.timeout = false;
+			return fetch(req);
+		};
+		config = {
+			...config,
+			fetch: customFetch
+		};
+	}
+	if (config?.directory) config.headers = {
+		...config.headers,
+		"x-opencode-directory": config.directory
+	};
+	return new OpencodeClient({ client: createClient(config) });
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/valibot@1.2.0_typescript@5.9.3/node_modules/valibot/dist/index.mjs
+let store$4;
+/**
+* Returns the global configuration.
+*
+* @param config The config to merge.
+*
+* @returns The configuration.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config$1) {
+	return {
+		lang: config$1?.lang ?? store$4?.lang,
+		message: config$1?.message,
+		abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+		abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+	};
+}
+/**
+* Returns the default value of the schema.
+*
+* @param schema The schema to get it from.
+* @param dataset The input dataset if available.
+* @param config The config if available.
+*
+* @returns The default value.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config$1) {
+	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+/**
+* Parses an unknown input based on a schema.
+*
+* @param schema The schema to be used.
+* @param input The input to be parsed.
+* @param config The parse configuration.
+*
+* @returns The parse result.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function safeParse(schema, input, config$1) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+	return {
+		typed: dataset.typed,
+		success: !dataset.issues,
+		output: dataset.value,
+		issues: dataset.issues
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@valibot+to-json-schema@1.5.0_valibot@1.2.0_typescript@5.9.3_/node_modules/@valibot/to-json-schema/dist/index.mjs
+/**
+* Adds an error message to the errors array.
+*
+* @param errors The array of error messages.
+* @param message The error message to add.
+*
+* @returns The new errors.
+*/
+function addError(errors, message) {
+	if (errors) {
+		errors.push(message);
+		return errors;
+	}
+	return [message];
+}
+/**
+* Throws an error or logs a warning based on the configuration.
+*
+* @param message The message to throw or log.
+* @param config The conversion configuration.
+*/
+function handleError(message, config) {
+	switch (config?.errorMode) {
+		case "ignore": break;
+		case "warn":
+			console.warn(message);
+			break;
+		default: throw new Error(message);
+	}
+}
+/**
+* Converts any supported Valibot action to the JSON Schema format.
+*
+* @param jsonSchema The JSON Schema object.
+* @param valibotAction The Valibot action object.
+* @param config The conversion configuration.
+*
+* @returns The converted JSON Schema.
+*/
+function convertAction(jsonSchema, valibotAction, config) {
+	if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
+	let errors;
+	switch (valibotAction.type) {
+		case "base64":
+			jsonSchema.contentEncoding = "base64";
+			break;
+		case "bic":
+		case "cuid2":
+		case "decimal":
+		case "digits":
+		case "emoji":
+		case "hexadecimal":
+		case "hex_color":
+		case "nanoid":
+		case "octal":
+		case "ulid":
+			jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		case "description":
+			jsonSchema.description = valibotAction.description;
+			break;
+		case "email":
+			jsonSchema.format = "email";
+			break;
+		case "empty":
+			if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.maxLength = 0;
+			}
+			break;
+		case "entries":
+			jsonSchema.minProperties = valibotAction.requirement;
+			jsonSchema.maxProperties = valibotAction.requirement;
+			break;
+		case "examples":
+			if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.examples];
+			else jsonSchema.examples = valibotAction.examples;
+			break;
+		case "integer":
+			jsonSchema.type = "integer";
+			break;
+		case "ipv4":
+			jsonSchema.format = "ipv4";
+			break;
+		case "ipv6":
+			jsonSchema.format = "ipv6";
+			break;
+		case "iso_date":
+			jsonSchema.format = "date";
+			break;
+		case "iso_date_time":
+		case "iso_timestamp":
+			jsonSchema.format = "date-time";
+			break;
+		case "iso_time":
+			jsonSchema.format = "time";
+			break;
+		case "length":
+			if (jsonSchema.type === "array") {
+				jsonSchema.minItems = valibotAction.requirement;
+				jsonSchema.maxItems = valibotAction.requirement;
+			} else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = valibotAction.requirement;
+				jsonSchema.maxLength = valibotAction.requirement;
+			}
+			break;
+		case "max_entries":
+			jsonSchema.maxProperties = valibotAction.requirement;
+			break;
+		case "max_length":
+			if (jsonSchema.type === "array") jsonSchema.maxItems = valibotAction.requirement;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.maxLength = valibotAction.requirement;
+			}
+			break;
+		case "max_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
+			jsonSchema.maximum = valibotAction.requirement;
+			break;
+		case "metadata":
+			if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
+			if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
+			if (Array.isArray(valibotAction.metadata.examples)) if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.metadata.examples];
+			else jsonSchema.examples = valibotAction.metadata.examples;
+			break;
+		case "min_entries":
+			jsonSchema.minProperties = valibotAction.requirement;
+			break;
+		case "min_length":
+			if (jsonSchema.type === "array") jsonSchema.minItems = valibotAction.requirement;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = valibotAction.requirement;
+			}
+			break;
+		case "min_value":
+			if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
+			jsonSchema.minimum = valibotAction.requirement;
+			break;
+		case "multiple_of":
+			jsonSchema.multipleOf = valibotAction.requirement;
+			break;
+		case "non_empty":
+			if (jsonSchema.type === "array") jsonSchema.minItems = 1;
+			else {
+				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
+				jsonSchema.minLength = 1;
+			}
+			break;
+		case "regex":
+			if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
+			jsonSchema.pattern = valibotAction.requirement.source;
+			break;
+		case "title":
+			jsonSchema.title = valibotAction.title;
+			break;
+		case "url":
+			jsonSchema.format = "uri";
+			break;
+		case "uuid":
+			jsonSchema.format = "uuid";
+			break;
+		case "value":
+			jsonSchema.const = valibotAction.requirement;
+			break;
+		default: errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
+	}
+	if (config?.overrideAction) {
+		const actionOverride = config.overrideAction({
+			valibotAction,
+			jsonSchema,
+			errors
+		});
+		if (actionOverride) return { ...actionOverride };
+	}
+	if (errors) for (const message of errors) handleError(message, config);
+	return jsonSchema;
+}
+/**
+* Flattens a Valibot pipe by recursively expanding nested pipes.
+*
+* @param pipe The pipeline to flatten.
+*
+* @returns A flat pipeline.
+*/
+function flattenPipe(pipe) {
+	return pipe.flatMap((item) => "pipe" in item ? flattenPipe(item.pipe) : item);
+}
+let refCount = 0;
+/**
+* Converts any supported Valibot schema to the JSON Schema format.
+*
+* @param jsonSchema The JSON Schema object.
+* @param valibotSchema The Valibot schema object.
+* @param config The conversion configuration.
+* @param context The conversion context.
+* @param skipRef Whether to skip using a reference.
+*
+* @returns The converted JSON Schema.
+*/
+function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = false) {
+	if (!skipRef) {
+		const referenceId = context.referenceMap.get(valibotSchema);
+		if (referenceId) {
+			jsonSchema.$ref = `#/$defs/${referenceId}`;
+			if (config?.overrideRef) {
+				const refOverride = config.overrideRef({
+					...context,
+					referenceId,
+					valibotSchema,
+					jsonSchema
+				});
+				if (refOverride) jsonSchema.$ref = refOverride;
+			}
+			return jsonSchema;
+		}
+	}
+	if ("pipe" in valibotSchema) {
+		const flatPipe = flattenPipe(valibotSchema.pipe);
+		let startIndex = 0;
+		let stopIndex = flatPipe.length - 1;
+		if (config?.typeMode === "input") {
+			const inputStopIndex = flatPipe.slice(1).findIndex((item) => item.kind === "schema" || item.kind === "transformation" && (item.type === "find_item" || item.type === "parse_json" || item.type === "raw_transform" || item.type === "reduce_items" || item.type === "stringify_json" || item.type === "to_bigint" || item.type === "to_boolean" || item.type === "to_date" || item.type === "to_number" || item.type === "to_string" || item.type === "transform"));
+			if (inputStopIndex !== -1) stopIndex = inputStopIndex;
+		} else if (config?.typeMode === "output") {
+			const outputStartIndex = flatPipe.findLastIndex((item) => item.kind === "schema");
+			if (outputStartIndex !== -1) startIndex = outputStartIndex;
+		}
+		for (let index = startIndex; index <= stopIndex; index++) {
+			const valibotPipeItem = flatPipe[index];
+			if (valibotPipeItem.kind === "schema") {
+				if (index > startIndex) handleError("Set the \"typeMode\" config to \"input\" or \"output\" to convert pipelines with multiple schemas.", config);
+				jsonSchema = convertSchema(jsonSchema, valibotPipeItem, config, context, true);
+			} else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
+		}
+		return jsonSchema;
+	}
+	let errors;
+	switch (valibotSchema.type) {
+		case "boolean":
+			jsonSchema.type = "boolean";
+			break;
+		case "null":
+			if (config?.target === "openapi-3.0") jsonSchema.enum = [null];
+			else jsonSchema.type = "null";
+			break;
+		case "number":
+			jsonSchema.type = "number";
+			break;
+		case "string":
+			jsonSchema.type = "string";
+			break;
+		case "array":
+			jsonSchema.type = "array";
+			jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
+			break;
+		case "tuple":
+		case "tuple_with_rest":
+		case "loose_tuple":
+		case "strict_tuple":
+			jsonSchema.type = "array";
+			if (config?.target === "openapi-3.0") {
+				jsonSchema.items = { anyOf: [] };
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.items.anyOf.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.items.anyOf.push(convertSchema({}, valibotSchema.rest, config, context));
+				else if (valibotSchema.type === "strict_tuple" || valibotSchema.type === "tuple") jsonSchema.maxItems = valibotSchema.items.length;
+			} else if (config?.target === "draft-2020-12") {
+				jsonSchema.prefixItems = [];
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.prefixItems.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.items = convertSchema({}, valibotSchema.rest, config, context);
+				else if (valibotSchema.type === "strict_tuple") jsonSchema.items = false;
+			} else {
+				jsonSchema.items = [];
+				jsonSchema.minItems = valibotSchema.items.length;
+				for (const item of valibotSchema.items) jsonSchema.items.push(convertSchema({}, item, config, context));
+				if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
+				else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
+			}
+			break;
+		case "object":
+		case "object_with_rest":
+		case "loose_object":
+		case "strict_object":
+			jsonSchema.type = "object";
+			jsonSchema.properties = {};
+			jsonSchema.required = [];
+			for (const key in valibotSchema.entries) {
+				const entry = valibotSchema.entries[key];
+				jsonSchema.properties[key] = convertSchema({}, entry, config, context);
+				if (entry.type !== "exact_optional" && entry.type !== "nullish" && entry.type !== "optional") jsonSchema.required.push(key);
+			}
+			if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
+			else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
+			break;
+		case "record":
+			if (config?.target === "openapi-3.0" && "pipe" in valibotSchema.key) errors = addError(errors, "The \"record\" schema with a schema for the key that contains a \"pipe\" cannot be converted to JSON Schema.");
+			if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
+			jsonSchema.type = "object";
+			if (config?.target !== "openapi-3.0") jsonSchema.propertyNames = convertSchema({}, valibotSchema.key, config, context);
+			jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
+			break;
+		case "any":
+		case "unknown": break;
+		case "nullable":
+		case "nullish":
+			if (config?.target === "openapi-3.0") {
+				const innerSchema = convertSchema({}, valibotSchema.wrapped, config, context);
+				Object.assign(jsonSchema, innerSchema);
+				jsonSchema.nullable = true;
+			} else jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
+			if (valibotSchema.default !== void 0) jsonSchema.default = getDefault(valibotSchema);
+			break;
+		case "exact_optional":
+		case "optional":
+		case "undefinedable":
+			jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
+			if (valibotSchema.default !== void 0) jsonSchema.default = getDefault(valibotSchema);
+			break;
+		case "literal":
+			if (typeof valibotSchema.literal !== "boolean" && typeof valibotSchema.literal !== "number" && typeof valibotSchema.literal !== "string") errors = addError(errors, "The value of the \"literal\" schema is not JSON compatible.");
+			if (config?.target === "openapi-3.0") jsonSchema.enum = [valibotSchema.literal];
+			else jsonSchema.const = valibotSchema.literal;
+			break;
+		case "enum":
+			jsonSchema.enum = valibotSchema.options;
+			break;
+		case "picklist":
+			if (valibotSchema.options.some((option) => typeof option !== "number" && typeof option !== "string")) errors = addError(errors, "An option of the \"picklist\" schema is not JSON compatible.");
+			jsonSchema.enum = valibotSchema.options;
+			break;
+		case "union":
+			jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "variant":
+			jsonSchema.oneOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "intersect":
+			jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
+			break;
+		case "lazy": {
+			let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
+			if (!wrappedValibotSchema) {
+				wrappedValibotSchema = valibotSchema.getter(void 0);
+				context.getterMap.set(valibotSchema.getter, wrappedValibotSchema);
+			}
+			let referenceId = context.referenceMap.get(wrappedValibotSchema);
+			if (!referenceId) {
+				referenceId = `${refCount++}`;
+				context.referenceMap.set(wrappedValibotSchema, referenceId);
+				context.definitions[referenceId] = convertSchema({}, wrappedValibotSchema, config, context, true);
+			}
+			jsonSchema.$ref = `#/$defs/${referenceId}`;
+			if (config?.overrideRef) {
+				const refOverride = config.overrideRef({
+					...context,
+					referenceId,
+					valibotSchema: wrappedValibotSchema,
+					jsonSchema
+				});
+				if (refOverride) jsonSchema.$ref = refOverride;
+			}
+			break;
+		}
+		default: errors = addError(errors, `The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`);
+	}
+	if (config?.overrideSchema) {
+		const schemaOverride = config.overrideSchema({
+			...context,
+			referenceId: context.referenceMap.get(valibotSchema),
+			valibotSchema,
+			jsonSchema,
+			errors
+		});
+		if (schemaOverride) return { ...schemaOverride };
+	}
+	if (errors) for (const message of errors) handleError(message, config);
+	return jsonSchema;
+}
+let store;
+/**
+* Returns the current global schema definitions.
+*
+* @returns The schema definitions.
+*
+* @beta
+*/
+function getGlobalDefs() {
+	return store;
+}
+/**
+* Converts a Valibot schema to the JSON Schema format.
+*
+* @param schema The Valibot schema object.
+* @param config The JSON Schema configuration.
+*
+* @returns The converted JSON Schema.
+*/
+function toJsonSchema(schema, config) {
+	const context = {
+		definitions: {},
+		referenceMap: /* @__PURE__ */ new Map(),
+		getterMap: /* @__PURE__ */ new Map()
+	};
+	const definitions = config?.definitions ?? getGlobalDefs();
+	if (definitions) {
+		for (const key in definitions) context.referenceMap.set(definitions[key], key);
+		for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
+	}
+	const jsonSchema = convertSchema({}, schema, config, context);
+	const target = config?.target ?? "draft-07";
+	if (target === "draft-2020-12") jsonSchema.$schema = "https://json-schema.org/draft/2020-12/schema";
+	else if (target === "draft-07") jsonSchema.$schema = "http://json-schema.org/draft-07/schema#";
+	if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
+	return jsonSchema;
+}
+
+//#endregion
+//#region ../client/dist/index.mjs
+/**
+* Error thrown when skill result extraction or validation fails.
+*/
+var SkillOutputError = class extends Error {
+	sessionId;
+	rawOutput;
+	validationErrors;
+	constructor(message, opts) {
+		super(message);
+		this.name = "SkillOutputError";
+		this.sessionId = opts.sessionId;
+		this.rawOutput = opts.rawOutput;
+		this.validationErrors = opts.validationErrors;
+	}
+};
+/**
+* Summarize tool input into a short human-readable string.
+*/
+function summarizeInput(tool, input) {
+	if (input.command) return String(input.command).slice(0, 500);
+	if (input.filePath) return String(input.filePath);
+	if (input.pattern) return String(input.pattern);
+	if (input.url) return String(input.url);
+	if (input.name) return String(input.name);
+	return tool;
+}
+/**
+* Attempt to parse a raw OpenCode SSE event and convert it to a FlueEvent.
+* Returns null if the event should be filtered out (not relevant for logs).
+*/
+function transformEvent(raw) {
+	const type = raw?.type;
+	if (!type) return null;
+	const now = Date.now();
+	if (type === "message.part.updated") {
+		const part = raw.properties?.part;
+		if (!part) return null;
+		const sessionId = part.sessionID ?? "";
+		if (part.type === "tool") {
+			const tool = part.tool ?? "?";
+			const state = part.state;
+			if (!state) return null;
+			const input = summarizeInput(tool, state.input ?? {});
+			switch (state.status) {
+				case "pending": return {
+					timestamp: now,
+					sessionId,
+					type: "tool.pending",
+					tool,
+					input
+				};
+				case "running": return {
+					timestamp: now,
+					sessionId,
+					type: "tool.running",
+					tool,
+					input
+				};
+				case "completed": return {
+					timestamp: now,
+					sessionId,
+					type: "tool.complete",
+					tool,
+					input,
+					output: (state.output ?? "").slice(0, 1e3),
+					duration: state.time?.end && state.time?.start ? state.time.end - state.time.start : 0
+				};
+				case "error": {
+					const duration = state.time?.end && state.time?.start ? state.time.end - state.time.start : 0;
+					return {
+						timestamp: now,
+						sessionId,
+						type: "tool.error",
+						tool,
+						input,
+						error: state.error ?? "unknown error",
+						duration
+					};
+				}
+			}
+			return null;
+		}
+		if (part.type === "text") {
+			const delta = raw.properties?.delta;
+			if (delta) return {
+				timestamp: now,
+				sessionId,
+				type: "text",
+				text: delta
+			};
+			return null;
+		}
+		if (part.type === "step-start") return {
+			timestamp: now,
+			sessionId: part.sessionID ?? "",
+			type: "step.start"
+		};
+		if (part.type === "step-finish") return {
+			timestamp: now,
+			sessionId: part.sessionID ?? "",
+			type: "step.finish",
+			reason: part.reason ?? "",
+			tokens: {
+				input: part.tokens?.input ?? 0,
+				output: part.tokens?.output ?? 0
+			},
+			cost: part.cost ?? 0
+		};
+		return null;
+	}
+	if (type === "session.status") {
+		const sessionId = raw.properties?.sessionID ?? "";
+		const status = raw.properties?.status;
+		if (status?.type === "busy") return {
+			timestamp: now,
+			sessionId,
+			type: "status",
+			status: "busy"
+		};
+		if (status?.type === "idle") return {
+			timestamp: now,
+			sessionId,
+			type: "status",
+			status: "idle"
+		};
+		if (status?.type === "retry") return {
+			timestamp: now,
+			sessionId,
+			type: "status",
+			status: "retry",
+			message: status.message
+		};
+		return null;
+	}
+	if (type === "session.idle") return {
+		timestamp: now,
+		sessionId: raw.properties?.sessionID ?? "",
+		type: "status",
+		status: "idle"
+	};
+	if (type === "session.compacted") return {
+		timestamp: now,
+		sessionId: raw.properties?.sessionID ?? "",
+		type: "status",
+		status: "compacted"
+	};
+	if (type === "session.error") return {
+		timestamp: now,
+		sessionId: raw.properties?.sessionID ?? "",
+		type: "error",
+		message: raw.properties?.error ?? "unknown error"
+	};
+	return null;
+}
+async function runShell(command, options) {
+	return new Promise((resolve) => {
+		const child = exec(command, {
+			cwd: options?.cwd,
+			env: options?.env ? {
+				...process.env,
+				...options.env
+			} : process.env,
+			timeout: options?.timeout
+		}, (error, stdout, stderr) => {
+			const rawCode = error && typeof error.code === "number" ? error.code : 0;
+			resolve({
+				stdout: stdout ?? "",
+				stderr: stderr ?? "",
+				exitCode: error ? rawCode || 1 : 0
+			});
+		});
+		if (options?.stdin) {
+			child.stdin?.write(options.stdin);
+			child.stdin?.end();
+		}
+	});
+}
+/**
+* Checks if a Valibot schema represents a plain string type.
+*/
+function isStringSchema(schema) {
+	return schema.type === "string";
+}
+/**
+* Checks if a skill name is a file path (contains '/' or ends with '.md').
+*/
+function isFilePath(name) {
+	return name.includes("/") || name.endsWith(".md");
+}
+/**
+* Build the prompt text for a skill invocation.
+*
+* If `name` looks like a file path (contains '/' or ends with '.md'), the
+* prompt instructs the agent to read and follow that file under
+* `.opencode/skills/`. Otherwise, it instructs the agent to use the named
+* skill.
+*
+* @param name - A skill name or a file path relative to .opencode/skills/.
+* @param args - Key-value arguments to include in the prompt.
+* @param schema - Optional Valibot schema for result extraction.
+* @returns The complete prompt string.
+*/
+function buildSkillPrompt(name, args, schema) {
+	const parts = [
+		"You are running in headless mode with no human operator. Work autonomously — never ask questions, never wait for user input, never use the question tool. Make your best judgment and proceed independently.",
+		"",
+		isFilePath(name) ? `Read and use the .opencode/skills/${name} skill.` : `Use the ${name} skill.`
+	];
+	if (args && Object.keys(args).length > 0) parts.push(`\nArguments:\n${JSON.stringify(args, null, 2)}`);
+	if (schema) if (isStringSchema(schema)) parts.push("\nWhen complete, output your result between these exact delimiters (the result can contain any content including code blocks):", "---RESULT_START---", "Your text output here", "---RESULT_END---");
+	else {
+		const { $schema: _, ...schemaWithoutMeta } = toJsonSchema(schema, { errorMode: "ignore" });
+		parts.push("\nWhen complete, output your result between these exact delimiters as JSON conforming to this schema:", "```json", JSON.stringify(schemaWithoutMeta, null, 2), "```", "", "Format:", "---RESULT_START---", "{\"key\": \"value\"}", "---RESULT_END---");
+	}
+	return parts.join("\n");
+}
+/**
+* Extracts and validates a structured result from OpenCode response parts.
+*
+* Scans TextParts for the last ---RESULT_START--- / ---RESULT_END--- block,
+* parses the content, and validates it against the provided Valibot schema.
+*
+* @param parts - The response parts from OpenCode's session.prompt().
+* @param schema - The Valibot schema to validate against.
+* @param sessionId - The session ID (for error reporting).
+* @returns The validated, typed result.
+* @throws {SkillOutputError} If no result block is found or validation fails.
+*/
+function extractResult(parts, schema, sessionId) {
+	const allText = parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+	const resultBlock = extractLastResultBlock(allText);
+	if (resultBlock === null) {
+		console.error(`[flue] extractResult: no RESULT_START/RESULT_END block found (session: ${sessionId}, text length: ${allText.length} chars)`);
+		console.error(`[flue] extractResult: response tail (last 500 chars): ${allText.slice(-500)}`);
+		throw new SkillOutputError("No ---RESULT_START--- / ---RESULT_END--- block found in the assistant response.", {
+			sessionId,
+			rawOutput: allText
+		});
+	}
+	console.log(`[flue] extractResult: found result block (${resultBlock.length} chars, session: ${sessionId})`);
+	if (schema.type === "string") {
+		const parseResult = safeParse(schema, resultBlock);
+		if (!parseResult.success) {
+			console.error("[flue] extractResult: string validation failed", parseResult.issues);
+			throw new SkillOutputError("Result validation failed for string schema.", {
+				sessionId,
+				rawOutput: resultBlock,
+				validationErrors: parseResult.issues
+			});
+		}
+		console.log(`[flue] extractResult: validated string result (${resultBlock.length} chars)`);
+		return parseResult.output;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(resultBlock);
+	} catch (err) {
+		console.error(`[flue] extractResult: JSON parse failed for block: ${resultBlock.slice(0, 200)}`);
+		throw new SkillOutputError("Failed to parse result block as JSON.", {
+			sessionId,
+			rawOutput: resultBlock,
+			validationErrors: err
+		});
+	}
+	const parseResult = safeParse(schema, parsed);
+	if (!parseResult.success) {
+		console.error("[flue] extractResult: schema validation failed", parseResult.issues);
+		console.error("[flue] extractResult: parsed value was:", JSON.stringify(parsed));
+		throw new SkillOutputError("Result does not match the expected schema.", {
+			sessionId,
+			rawOutput: resultBlock,
+			validationErrors: parseResult.issues
+		});
+	}
+	console.log("[flue] extractResult: validated result:", JSON.stringify(parseResult.output));
+	return parseResult.output;
+}
+/**
+* Extracts the content of the last ---RESULT_START--- / ---RESULT_END--- block from text.
+* Returns null if no result block is found.
+*/
+function extractLastResultBlock(text) {
+	const matches = text.matchAll(/---RESULT_START---\s*\n([\s\S]*?)---RESULT_END---/g);
+	let lastMatch = null;
+	for (const match of matches) lastMatch = match[1]?.trim() ?? null;
+	return lastMatch;
+}
+/** How often to poll and log progress (ms). */
+const POLL_INTERVAL = 5e3;
+/** Max times we'll see 0 assistant messages before giving up. */
+const MAX_EMPTY_POLLS = 60;
+/** Max time to poll before timing out (ms) - 45 minutes. */
+const MAX_POLL_TIME = 2700 * 1e3;
+/**
+* Run a named skill via the OpenCode client and optionally extract a typed result.
+*/
+async function runSkill(client, workdir, name, options) {
+	const { args, result: schema, model, prompt: promptOverride } = options ?? {};
+	const prompt = promptOverride ?? buildSkillPrompt(name, args, schema);
+	console.log(`[flue] skill("${name}"): starting`);
+	console.log(`[flue] skill("${name}"): creating session`);
+	const session = await client.session.create({
+		body: { title: name },
+		query: { directory: workdir }
+	});
+	console.log(`[flue] skill("${name}"): session created`, {
+		hasData: !!session.data,
+		sessionId: session.data?.id,
+		error: session.error
+	});
+	if (!session.data) throw new Error(`Failed to create OpenCode session for skill "${name}".`);
+	const sessionId = session.data.id;
+	const promptStart = Date.now();
+	console.log(`[flue] skill("${name}"): sending prompt async`);
+	const asyncResult = await client.session.promptAsync({
+		path: { id: sessionId },
+		query: { directory: workdir },
+		body: {
+			...model ? { model } : {},
+			parts: [{
+				type: "text",
+				text: prompt
+			}]
+		}
+	});
+	console.log(`[flue] skill("${name}"): prompt sent`, {
+		hasError: !!asyncResult.error,
+		error: asyncResult.error,
+		data: asyncResult.data
+	});
+	if (asyncResult.error) throw new Error(`Failed to send prompt for skill "${name}" (session ${sessionId}): ${JSON.stringify(asyncResult.error)}`);
+	await confirmSessionStarted(client, sessionId, workdir, name);
+	console.log(`[flue] skill("${name}"): starting polling`);
+	const parts = await pollUntilIdle(client, sessionId, workdir, name, promptStart);
+	const promptElapsed = ((Date.now() - promptStart) / 1e3).toFixed(1);
+	console.log(`[flue] skill("${name}"): completed (${promptElapsed}s)`);
+	if (!schema) return;
+	return extractResult(parts, schema, sessionId);
+}
+/**
+* After promptAsync, confirm that OpenCode actually started processing the session.
+* Polls quickly (1s) to detect the session appearing as "busy" or a user message being recorded.
+* Fails fast (~15s) instead of letting the poll loop run for 5 minutes.
+*/
+async function confirmSessionStarted(client, sessionId, workdir, skillName) {
+	const maxAttempts = 15;
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		await sleep(1e3);
+		if (((await client.session.status({ query: { directory: workdir } })).data?.[sessionId])?.type === "busy") {
+			console.log(`[flue] skill("${skillName}"): session confirmed running`);
+			return;
+		}
+		const messages = (await client.session.messages({
+			path: { id: sessionId },
+			query: { directory: workdir }
+		})).data;
+		if (messages && messages.length > 0) {
+			console.log(`[flue] skill("${skillName}"): session confirmed (${messages.length} messages)`);
+			return;
+		}
+	}
+	throw new Error(`Skill "${skillName}" failed to start: session ${sessionId} has no messages after 15s.\nThe prompt was accepted but OpenCode never began processing it.\nThis usually means no model is configured. Pass --model to the flue CLI or set "model" in opencode.json.`);
+}
+async function pollUntilIdle(client, sessionId, workdir, skillName, startTime) {
+	let emptyPolls = 0;
+	let pollCount = 0;
+	for (;;) {
+		await sleep(POLL_INTERVAL);
+		pollCount++;
+		const elapsed = ((Date.now() - startTime) / 1e3).toFixed(0);
+		if (Date.now() - startTime > MAX_POLL_TIME) throw new Error(`Skill "${skillName}" timed out after ${elapsed}s. Session never went idle. This may indicate a stuck session or OpenCode bug.`);
+		const statusResult = await client.session.status({ query: { directory: workdir } });
+		const sessionStatus = statusResult.data?.[sessionId];
+		if (!sessionStatus || sessionStatus.type === "idle") {
+			const parts = await fetchAllAssistantParts(client, sessionId, workdir);
+			if (parts.length === 0) {
+				emptyPolls++;
+				if (emptyPolls % 12 === 0) {
+					console.log(`[flue] skill("${skillName}"): status result: ${JSON.stringify({
+						hasData: !!statusResult.data,
+						sessionIds: statusResult.data ? Object.keys(statusResult.data) : [],
+						error: statusResult.error
+					})}`);
+					console.log(`[flue] skill("${skillName}"): sessionStatus for ${sessionId}: ${JSON.stringify(sessionStatus)}`);
+				}
+				if (emptyPolls >= MAX_EMPTY_POLLS) {
+					const allMessages = await client.session.messages({
+						path: { id: sessionId },
+						query: { directory: workdir }
+					});
+					console.error(`[flue] skill("${skillName}"): TIMEOUT DIAGNOSTICS`, JSON.stringify({
+						sessionId,
+						statusData: statusResult.data,
+						messageCount: Array.isArray(allMessages.data) ? allMessages.data.length : 0,
+						messages: allMessages.data
+					}, null, 2));
+					throw new Error(`Skill "${skillName}" produced no output after ${elapsed}s and ${emptyPolls} empty polls. The agent may have failed to start — check model ID and API key.`);
+				}
+				continue;
+			}
+			return parts;
+		}
+		if (pollCount % 12 === 0) console.log(`[flue] skill("${skillName}"): running (${elapsed}s)`);
+	}
+}
+/**
+* Fetch ALL parts from every assistant message in the session.
+*/
+async function fetchAllAssistantParts(client, sessionId, workdir) {
+	const messagesResult = await client.session.messages({
+		path: { id: sessionId },
+		query: { directory: workdir }
+	});
+	if (!messagesResult.data) throw new Error(`Failed to fetch messages for session ${sessionId}.`);
+	const assistantMessages = messagesResult.data.filter((m) => m.info.role === "assistant");
+	const allParts = [];
+	for (const msg of assistantMessages) allParts.push(...msg.parts ?? []);
+	return allParts;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var Flue = class {
+	/** Working branch for commits. */
+	branch;
+	/** Workflow arguments passed by the runner. */
+	args;
+	/** Scoped secrets passed by the runner. */
+	secrets;
+	workdir;
+	model;
+	client;
+	constructor(options) {
+		this.branch = options.branch ?? "main";
+		this.args = options.args ?? {};
+		this.secrets = options.secrets ?? {};
+		this.workdir = options.workdir;
+		this.model = options.model;
+		this.client = createOpencodeClient({
+			baseUrl: options.opencodeUrl ?? "http://localhost:48765",
+			directory: options.workdir
+		});
+	}
+	async skill(name, options) {
+		const mergedOptions = {
+			...options,
+			args: this.args || options?.args ? {
+				...this.args,
+				...options?.args
+			} : void 0,
+			model: options?.model ?? this.model
+		};
+		return runSkill(this.client, this.workdir, name, mergedOptions);
+	}
+	async prompt(promptText, options) {
+		const mergedOptions = {
+			result: options?.result,
+			model: options?.model ?? this.model,
+			prompt: promptText
+		};
+		return runSkill(this.client, this.workdir, "__inline__", mergedOptions);
+	}
+	/** Execute a shell command with scoped environment variables. */
+	async shell(command, options) {
+		return runShell(command, {
+			...options,
+			cwd: options?.cwd ?? this.workdir
+		});
+	}
+	/** Close the OpenCode client connection. */
+	async close() {}
+};
+
+//#endregion
+export { Flue, transformEvent };