@pasko70/pibo 2.0.0 → 2.1.1

package/dist/agent-runtimes/omp/client.js

@@ -0,0 +1,460 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { OMP_RPC_CHUNK_PAYLOAD_BYTES, OMP_RPC_MAX_FRAME_BYTES, OMP_RPC_PROTOCOL_VERSION, } from "./protocol-types.js";
+const DEFAULT_STARTUP_TIMEOUT_MS = 15_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 180_000;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 2_000;
+const DEFAULT_MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+const DEFAULT_MAX_PENDING_REQUESTS = 128;
+const DEFAULT_MAX_STDERR_BYTES = 256 * 1024;
+export class OmpRpcClientError extends Error {
+    code;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.code = code;
+        this.name = "OmpRpcClientError";
+    }
+}
+export class OmpRpcResponseError extends Error {
+    command;
+    error;
+    errorCode;
+    constructor(command, error, errorCode, options = {}) {
+        super(`OMP RPC command "${command}" failed: ${error}`, options);
+        this.command = command;
+        this.error = error;
+        this.errorCode = errorCode;
+        this.name = "OmpRpcResponseError";
+    }
+}
+function deferred() {
+    const d = {};
+    d.promise = new Promise((resolve, reject) => {
+        d.resolve = resolve;
+        d.reject = reject;
+    });
+    return d;
+}
+function isOmpRpcSideChannel(frame) {
+    const type = frame.type;
+    return type === "host_tool_result"
+        || type === "host_tool_update"
+        || type === "host_uri_result"
+        || type === "extension_ui_response";
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parseReadyFrame(value) {
+    if (!isRecord(value) || value.type !== "ready") {
+        throw new OmpRpcClientError("protocol_error", "OMP child did not emit a ready frame on startup.");
+    }
+    return value;
+}
+export class OmpRpcClient {
+    options;
+    child;
+    stdoutBuffer = Buffer.alloc(0);
+    state = "starting";
+    protocolVersion = 1;
+    pending = new Map();
+    chunks = new Map();
+    frameListeners = new Set();
+    sideChannelListeners = new Set();
+    diagnosticListeners = new Set();
+    stderrBytes = 0;
+    startupTimeoutMs;
+    requestTimeoutMs;
+    shutdownTimeoutMs;
+    maxMessageBytes;
+    maxPendingRequests;
+    maxStderrBytes;
+    constructor(options = {}) {
+        this.options = options;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        this.shutdownTimeoutMs = options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
+        this.maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
+        this.maxPendingRequests = options.maxPendingRequests ?? DEFAULT_MAX_PENDING_REQUESTS;
+        this.maxStderrBytes = options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES;
+    }
+    get snapshot() {
+        return {
+            state: this.state,
+            ready: this.state === "ready",
+            pendingRequests: this.pending.size,
+            protocolVersion: this.protocolVersion,
+        };
+    }
+    get process() {
+        return this.child;
+    }
+    get connected() {
+        return this.state === "ready";
+    }
+    subscribeFrames(listener) {
+        this.frameListeners.add(listener);
+        return () => this.frameListeners.delete(listener);
+    }
+    subscribeSideChannels(listener) {
+        this.sideChannelListeners.add(listener);
+        return () => this.sideChannelListeners.delete(listener);
+    }
+    subscribeDiagnostics(listener) {
+        this.diagnosticListeners.add(listener);
+        return () => this.diagnosticListeners.delete(listener);
+    }
+    /**
+     * Redact likely credential material before surfacing a diagnostic, so OMP
+     * stderr (which may echo prompts or provider keys) cannot leak secrets.
+     */
+    static redactDiagnostic(message) {
+        return message
+            .replace(/\b(?:sk|rk|pk|ghp|github_pat)[-_][A-Za-z0-9._~+/-]{8,}\b/g, "[redacted]")
+            .replace(/\bBearer\s+\S+/gi, "Bearer [redacted]")
+            .replace(/\b(?:api[_-]?key|secret|token|password)\b(?=[:=]\s*)\s*[^\s,;]+/gi, "$1 [redacted]");
+    }
+    emitDiagnostic(message) {
+        for (const listener of this.diagnosticListeners)
+            listener(OmpRpcClient.redactDiagnostic(message));
+    }
+    /**
+     * Spawn the OMP child in `--mode rpc` and wait for the `ready` frame, then
+     * negotiate protocol v2 (confirms frame encoder upgrade for large frames).
+     */
+    async connect(command, options) {
+        if (this.state === "ready")
+            return;
+        const ready = deferred();
+        let child;
+        try {
+            child = spawn(command[0], command.slice(1), {
+                cwd: options.cwd,
+                env: options.env,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            this.state = "failed";
+            throw new OmpRpcClientError("spawn_failed", `Failed to spawn OMP child: ${String(error)}`, { cause: error });
+        }
+        this.child = child;
+        let startupTimer;
+        child.stderr.on("data", (chunk) => {
+            this.stderrBytes += chunk.length;
+            if (this.stderrBytes <= this.maxStderrBytes) {
+                this.emitDiagnostic(chunk.toString("utf8"));
+            }
+        });
+        child.once("error", (error) => {
+            const code = error.code === "ENOENT" ? "spawn_failed" : "process_exited";
+            this.state = "failed";
+            ready.reject(new OmpRpcClientError(code, `OMP child process error: ${error.message}`, { cause: error }));
+        });
+        child.once("close", (code, signal) => {
+            this.state = "closed";
+            this.rejectAll(new OmpRpcClientError("process_exited", `OMP child process exited (code=${String(code)}, signal=${String(signal)})`));
+            ready.reject(new OmpRpcClientError("process_exited", "OMP child process exited before becoming ready."));
+        });
+        child.stdout.on("data", (chunk) => this.onStdoutData(Buffer.from(chunk)));
+        // Wait for ready frame.
+        const unsubscribe = this.subscribeFrames((frame) => {
+            if (frame.type === "ready") {
+                unsubscribe();
+                ready.resolve(frame);
+            }
+        });
+        startupTimer = setTimeout(() => {
+            ready.reject(new OmpRpcClientError("timeout", "Timed out waiting for the OMP ready frame."));
+        }, this.startupTimeoutMs);
+        this.state = "initializing";
+        let startup;
+        try {
+            startup = await ready.promise;
+        }
+        catch (error) {
+            this.state = "failed";
+            this.closeProcess();
+            throw error;
+        }
+        finally {
+            if (startupTimer)
+                clearTimeout(startupTimer);
+        }
+        // Mark ready before negotiation so the client can send the handshake.
+        this.state = "ready";
+        this.protocolVersion = startup.protocolVersion;
+        try {
+            await this.request({ type: "negotiate_protocol", protocolVersion: OMP_RPC_PROTOCOL_VERSION }, "negotiate_protocol");
+            this.protocolVersion = OMP_RPC_PROTOCOL_VERSION;
+        }
+        catch (error) {
+            this.state = "failed";
+            this.closeProcess();
+            throw new OmpRpcClientError("protocol_error", `OMP protocol negotiation failed: ${String(error)}`, { cause: error });
+        }
+    }
+    onStdoutData(chunk) {
+        this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
+        let newlineIndex;
+        while ((newlineIndex = this.stdoutBuffer.indexOf(0x0a)) !== -1) {
+            const line = this.stdoutBuffer.subarray(0, newlineIndex).toString("utf8").trim();
+            this.stdoutBuffer = this.stdoutBuffer.subarray(newlineIndex + 1);
+            if (line.length === 0)
+                continue;
+            this.handleLine(line);
+        }
+    }
+    handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.emitDiagnostic(`OMP emitted a malformed JSON line on stdout (ignored).`);
+            return;
+        }
+        if (!isRecord(parsed)) {
+            this.emitDiagnostic(`OMP emitted a non-object JSON line on stdout (ignored).`);
+            return;
+        }
+        // Reassemble oversized chunked frames first.
+        if (parsed.type === "rpc_chunk") {
+            const reassembled = this.consumeChunk(parsed);
+            if (reassembled === undefined)
+                return; // waiting for more chunks
+            try {
+                parsed = JSON.parse(reassembled);
+            }
+            catch {
+                this.emitDiagnostic(`OMP chunk reassembly produced invalid JSON (ignored).`);
+                return;
+            }
+        }
+        const frame = parsed;
+        for (const listener of this.frameListeners)
+            listener(frame);
+        if (isOmpRpcSideChannel(frame)) {
+            const sideChannel = frame;
+            for (const listener of this.sideChannelListeners)
+                listener(sideChannel);
+        }
+        if (this.isResponse(frame)) {
+            this.resolveResponse(frame);
+        }
+    }
+    isSideChannel(frame) {
+        const type = frame.type;
+        return (type === "host_tool_result" ||
+            type === "host_tool_update" ||
+            type === "host_uri_result" ||
+            type === "extension_ui_response");
+    }
+    isResponse(frame) {
+        return frame.type === "response";
+    }
+    consumeChunk(frame) {
+        // Validate frame bounds first so an out-of-range index can never create a
+        // sparse array that Buffer.concat later turns into an uncaught TypeError.
+        if (!Number.isSafeInteger(frame.index) || frame.index < 0 || frame.index >= frame.count) {
+            this.chunks.delete(frame.chunkId);
+            this.emitDiagnostic(`OMP chunk frame has an invalid index ${frame.index} (dropped).`);
+            return undefined;
+        }
+        let decoded;
+        try {
+            decoded = Buffer.from(frame.data, "base64");
+            // Reject invalid base64 (empty/garbage) before it becomes a hole.
+            if (frame.data.length === 0 && frame.byteLength > 0) {
+                this.chunks.delete(frame.chunkId);
+                this.emitDiagnostic(`OMP chunk frame carries empty base64 payload (dropped).`);
+                return undefined;
+            }
+        }
+        catch {
+            this.chunks.delete(frame.chunkId);
+            this.emitDiagnostic(`OMP chunk frame base64 decode failed (dropped).`);
+            return undefined;
+        }
+        const existing = this.chunks.get(frame.chunkId);
+        if (existing) {
+            if (existing.count !== frame.count || existing.byteLength !== frame.byteLength) {
+                this.chunks.delete(frame.chunkId);
+                this.emitDiagnostic(`OMP chunk frame metadata mismatch (dropped).`);
+                return undefined;
+            }
+            // Must be the next in-order chunk; reject duplicates/holes/out-of-order.
+            if (frame.index !== existing.parts.length) {
+                this.chunks.delete(frame.chunkId);
+                this.emitDiagnostic(`OMP chunk frame arrived out of order (expected index ${existing.parts.length}, got ${frame.index}); dropped.`);
+                return undefined;
+            }
+            existing.parts.push(decoded);
+        }
+        else {
+            if (frame.index !== 0) {
+                this.emitDiagnostic(`OMP chunk frame sequence did not start at index 0 (dropped).`);
+                return undefined;
+            }
+            this.chunks.set(frame.chunkId, { count: frame.count, byteLength: frame.byteLength, parts: [decoded] });
+        }
+        const acc = this.chunks.get(frame.chunkId);
+        if (acc.parts.length < acc.count)
+            return undefined;
+        this.chunks.delete(frame.chunkId);
+        const full = Buffer.concat(acc.parts);
+        if (full.length !== acc.byteLength) {
+            this.emitDiagnostic(`OMP chunk reassembly length mismatch (dropped).`);
+            return undefined;
+        }
+        return full.toString("utf8");
+    }
+    resolveResponse(response) {
+        const id = response.id;
+        if (id === undefined) {
+            // Responses without an id that still carry command info are protocol
+            // telemetry; emit as diagnostic rather than dropping silently.
+            this.emitDiagnostic(`OMP response without an id (command=${response.command}).`);
+            return;
+        }
+        const entry = this.pending.get(id);
+        if (!entry)
+            return; // late/superseded response
+        this.pending.delete(id);
+        clearTimeout(entry.timer);
+        entry.resolve(response);
+    }
+    rejectAll(error) {
+        for (const [id, entry] of Array.from(this.pending.entries())) {
+            this.pending.delete(id);
+            clearTimeout(entry.timer);
+            entry.reject(error);
+        }
+    }
+    /**
+     * Send a command and await its correlated response. Always matches on `id`
+     * (never queue order) — OMP dispatches `bash` concurrently and side-channel
+     * frames overtake the serial queue.
+     */
+    async request(command, label) {
+        if (this.state !== "ready") {
+            throw new OmpRpcClientError("closed", `Cannot send OMP command "${label}": client is not ready.`);
+        }
+        if (this.pending.size >= this.maxPendingRequests) {
+            throw new OmpRpcClientError("pending_limit", "Too many pending OMP RPC requests.");
+        }
+        const id = (command.id ?? randomUUID());
+        const withId = { ...command, id };
+        let serialized;
+        try {
+            serialized = JSON.stringify(withId);
+        }
+        catch (error) {
+            throw new OmpRpcClientError("serialization_error", `Failed to serialize OMP command "${label}": ${String(error)}`);
+        }
+        if (Buffer.byteLength(serialized, "utf8") > this.maxMessageBytes) {
+            throw new OmpRpcClientError("message_too_large", `OMP command "${label}" exceeds the message size limit.`);
+        }
+        const response = deferred();
+        const timer = setTimeout(() => {
+            this.pending.delete(id);
+            response.reject(new OmpRpcClientError("timeout", `OMP command "${label}" timed out.`));
+        }, this.requestTimeoutMs);
+        this.pending.set(id, {
+            command: command.type,
+            resolve: response.resolve,
+            reject: response.reject,
+            timer,
+        });
+        try {
+            await this.writeLine(serialized);
+        }
+        catch (error) {
+            this.pending.delete(id);
+            clearTimeout(timer);
+            response.reject(error);
+        }
+        const result = await response.promise;
+        if (result["success"] === false) {
+            const err = result;
+            throw new OmpRpcResponseError(label, err.error ?? "unknown error", err.code);
+        }
+        return result;
+    }
+    async writeLine(line) {
+        return await new Promise((resolveWrite, rejectWrite) => {
+            if (!this.child || this.child.stdin.destroyed) {
+                rejectWrite(new OmpRpcClientError("write_failed", "OMP child stdin is closed."));
+                return;
+            }
+            this.child.stdin.write(`${line}\n`, (error) => {
+                if (error)
+                    rejectWrite(new OmpRpcClientError("write_failed", `Failed to write to OMP child: ${error.message}`, { cause: error }));
+                else
+                    resolveWrite();
+            });
+        });
+    }
+    get stderr() {
+        return []; // diagnostics already streamed via listeners; retained for symmetry
+    }
+    /**
+         * Send a fire-and-forget side-channel frame to OMP (host_tool_result,
+         * host_tool_update, host_uri_result, extension_ui_response). These overtake
+         * the serial command queue and do not receive a correlated `response`.
+         */
+    async sendSideChannel(frame, label) {
+        if (this.state !== "ready") {
+            throw new OmpRpcClientError("closed", `Cannot send OMP side-channel frame "${label}": client is not ready.`);
+        }
+        let serialized;
+        try {
+            serialized = JSON.stringify(frame);
+        }
+        catch (error) {
+            throw new OmpRpcClientError("serialization_error", `Failed to serialize OMP frame "${label}": ${String(error)}`);
+        }
+        if (Buffer.byteLength(serialized, "utf8") > this.maxMessageBytes) {
+            throw new OmpRpcClientError("message_too_large", `OMP frame "${label}" exceeds the message size limit.`);
+        }
+        await this.writeLine(serialized);
+    }
+    async close() {
+        if (this.state === "ready") {
+            this.state = "closing";
+        }
+        this.closeProcess();
+    }
+    closeProcess() {
+        if (this.child && !this.child.killed) {
+            try {
+                this.child.kill("SIGTERM");
+            }
+            catch {
+                // ignore
+            }
+            const child = this.child;
+            // Ensure the child is reaped even on platforms where SIGTERM is
+            // ignored (freeing any cwd lock for temp cleanup).
+            const timer = setTimeout(() => {
+                if (child && !child.killed) {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }, this.shutdownTimeoutMs);
+            timer.unref();
+        }
+        this.state = "closed";
+        this.rejectAll(new OmpRpcClientError("aborted", "OMP client closed."));
+    }
+    dispose() {
+        this.closeProcess();
+    }
+}
+/** Convenience for oversized-frames logic parity; retained as a documented limit. */
+export const OMP_MAX_CHUNK_PAYLOAD_BYTES = OMP_RPC_CHUNK_PAYLOAD_BYTES;
+export const OMP_DEFAULT_MAX_FRAME_BYTES = OMP_RPC_MAX_FRAME_BYTES;

package/dist/agent-runtimes/omp/config.js

@@ -0,0 +1,188 @@
+import { piboHomePath } from "../../core/pibo-home.js";
+const MAX_TIMEOUT_MS = 10 * 60 * 1_000;
+const MAX_AUTH_LOGIN_TIMEOUT_MS = 30 * 60 * 1_000;
+const ENVIRONMENT_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED_ENVIRONMENT_KEYS = new Set([
+    "PI_CODING_AGENT_DIR",
+    "PI_CONFIG_DIR",
+    "OMP_PROFILE",
+    "PI_PROFILE",
+    "HOME",
+    "USERPROFILE",
+    "XDG_CACHE_HOME",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_STATE_HOME",
+    "TMP",
+    "TEMP",
+    "TMPDIR",
+    "NODE_OPTIONS",
+    "LD_PRELOAD",
+    "BASH_ENV",
+    "ENV",
+    "PYTHONHOME",
+    "PYTHONPATH",
+    "RUBYOPT",
+    "PERL5OPT",
+    "JAVA_TOOL_OPTIONS",
+    "_JAVA_OPTIONS",
+]);
+export const DEFAULT_OMP_ENVIRONMENT_ALLOWLIST = [
+    "PATH",
+    "PATHEXT",
+    "SystemRoot",
+    "WINDIR",
+    "COMSPEC",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "TZ",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "NO_PROXY",
+    "ALL_PROXY",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+];
+/**
+ * Pibo does not know the real key names OMP's model catalog reads (it supports
+ * many providers and custom `models.yml` baseUrl/apiKey pairs). We allow an
+ * operator to add the specific provider keys (e.g. `OPENAI_API_KEY`,
+ * `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`, `DEEPSEEK_API_KEY`) plus any custom
+ * keys via the config `apiKeyEnv` allowlist. These names are validated at parse
+ * time so a typo fails fast.
+ */
+export const DEFAULT_OMP_API_KEY_ENVIRONMENT_KEYS = [
+    "OPENAI_API_KEY",
+    "ANTHROPIC_API_KEY",
+    "GEMINI_API_KEY",
+    "DEEPSEEK_API_KEY",
+    "OPENROUTER_API_KEY",
+    "GROQ_API_KEY",
+    "MISTRAL_API_KEY",
+    "COHERE_API_KEY",
+    "PERPLEXITY_API_KEY",
+    "XAI_API_KEY",
+    "OMP_DEFAULT_API_KEY",
+];
+export const OMP_RUNTIME_CONFIG_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        bunExecutable: { type: "string", minLength: 1, default: "bun" },
+        ompEntry: { type: "string", minLength: 1 },
+        homeRoot: { type: "string", minLength: 1 },
+        environmentAllowlist: {
+            type: "array",
+            items: { type: "string", pattern: ENVIRONMENT_KEY_PATTERN.source },
+            uniqueItems: true,
+        },
+        apiKeyEnvironment: {
+            type: "array",
+            items: { type: "string", pattern: ENVIRONMENT_KEY_PATTERN.source },
+            uniqueItems: true,
+        },
+        defaultProvider: { type: "string", minLength: 1 },
+        defaultModel: { type: "string", minLength: 1 },
+        diagnosticTimeoutMs: { type: "integer", minimum: 1, maximum: MAX_TIMEOUT_MS, default: 5_000 },
+        startupTimeoutMs: { type: "integer", minimum: 1, maximum: MAX_TIMEOUT_MS, default: 15_000 },
+        requestTimeoutMs: { type: "integer", minimum: 1, maximum: MAX_TIMEOUT_MS, default: 180_000 },
+        authLoginTimeoutMs: { type: "integer", minimum: 1, maximum: MAX_AUTH_LOGIN_TIMEOUT_MS, default: 15 * 60 * 1_000 },
+        shutdownTimeoutMs: { type: "integer", minimum: 1, maximum: MAX_TIMEOUT_MS, default: 2_000 },
+        killTimeoutMs: { type: "integer", minimum: 1, maximum: MAX_TIMEOUT_MS, default: 500 },
+    },
+};
+export function defaultOmpRuntimeConfig() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cfg = {};
+    return {
+        bunExecutable: "bun",
+        ompEntry: "", // operator must supply the OMP install path
+        homeRoot: piboHomePath("agent-runtimes", "omp"),
+        environmentAllowlist: [...DEFAULT_OMP_ENVIRONMENT_ALLOWLIST],
+        apiKeyEnvironment: [...DEFAULT_OMP_API_KEY_ENVIRONMENT_KEYS],
+        diagnosticTimeoutMs: 5_000,
+        startupTimeoutMs: 15_000,
+        requestTimeoutMs: 180_000,
+        authLoginTimeoutMs: 15 * 60 * 1_000,
+        shutdownTimeoutMs: 2_000,
+        killTimeoutMs: 500,
+    };
+}
+function timeout(value, fallback, label, maximum = MAX_TIMEOUT_MS) {
+    const selected = value ?? fallback;
+    if (!Number.isSafeInteger(selected) || Number(selected) <= 0 || Number(selected) > maximum) {
+        throw new Error(`${label} must be a positive integer no greater than ${maximum}`);
+    }
+    return Number(selected);
+}
+function stringAllowlist(value, fallback, label, reject) {
+    const selected = value ?? fallback;
+    if (!Array.isArray(selected))
+        throw new Error(`${label} must be an array of environment variable names`);
+    const result = [];
+    const seen = new Set();
+    for (const entry of selected) {
+        if (typeof entry !== "string" || !ENVIRONMENT_KEY_PATTERN.test(entry)) {
+            throw new Error(`${label} entries must be valid environment variable names`);
+        }
+        const canonical = entry.toUpperCase();
+        if (reject?.has(canonical) || canonical.startsWith("DYLD_")) {
+            throw new Error(`${label} may not include reserved key "${entry}"`);
+        }
+        if (seen.has(canonical))
+            throw new Error(`${label} contains duplicate key "${entry}"`);
+        seen.add(canonical);
+        result.push(entry);
+    }
+    return result;
+}
+function nonEmptyString(value, fallback, label) {
+    const selected = value ?? fallback;
+    if (typeof selected !== "string" || selected.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    return selected.trim();
+}
+/**
+ * Resolve the OMP CLI entry. An empty value means "not yet configured" (the
+ * operator supplies it via runtime-instance config); diagnose() surfaces that.
+ * A non-empty value MUST be an absolute path — resolving it against the session
+ * workspace would silently target the wrong executable.
+ */
+function absolutePathOrEmpty(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return "";
+    }
+    const candidate = value.trim();
+    if (!(candidate.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(candidate))) {
+        throw new Error(label + " must be an absolute path to the OMP CLI entry; got \"" + candidate + "\"");
+    }
+    return candidate;
+}
+export function parseOmpRuntimeConfig(value) {
+    const record = value ?? {};
+    const provider = optionalString(record.defaultProvider);
+    const model = optionalString(record.defaultModel);
+    const config = {
+        bunExecutable: nonEmptyString(record.bunExecutable, "bun", "bunExecutable"),
+        ompEntry: absolutePathOrEmpty(record.ompEntry, "ompEntry"),
+        homeRoot: nonEmptyString(record.homeRoot, piboHomePath("agent-runtimes", "omp"), "homeRoot"),
+        environmentAllowlist: stringAllowlist(record.environmentAllowlist, DEFAULT_OMP_ENVIRONMENT_ALLOWLIST, "environmentAllowlist", RESERVED_ENVIRONMENT_KEYS),
+        apiKeyEnvironment: stringAllowlist(record.apiKeyEnvironment, DEFAULT_OMP_API_KEY_ENVIRONMENT_KEYS, "apiKeyEnvironment", RESERVED_ENVIRONMENT_KEYS),
+        diagnosticTimeoutMs: timeout(record.diagnosticTimeoutMs, 5_000, "diagnosticTimeoutMs"),
+        startupTimeoutMs: timeout(record.startupTimeoutMs, 15_000, "startupTimeoutMs"),
+        requestTimeoutMs: timeout(record.requestTimeoutMs, 180_000, "requestTimeoutMs"),
+        authLoginTimeoutMs: timeout(record.authLoginTimeoutMs, 15 * 60 * 1_000, "authLoginTimeoutMs", MAX_AUTH_LOGIN_TIMEOUT_MS),
+        shutdownTimeoutMs: timeout(record.shutdownTimeoutMs, 2_000, "shutdownTimeoutMs"),
+        killTimeoutMs: timeout(record.killTimeoutMs, 500, "killTimeoutMs"),
+    };
+    if (provider !== undefined)
+        config.defaultProvider = provider;
+    if (model !== undefined)
+        config.defaultModel = model;
+    return config;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}