@pasko70/pibo 2.0.0 → 2.1.1

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

@@ -0,0 +1,581 @@
+import { randomUUID } from "node:crypto";
+import { unsupportedAgentRuntimeCapability, } from "../../agent-runtime/capabilities.js";
+import { AgentRuntimeAuthError, AgentRuntimeBindingMissingError, AgentRuntimeUnavailableError, } from "../../agent-runtime/errors.js";
+import { OmpAuthController, OMP_AUTH_METHODS, unknownOmpStatusForAdapter } from "./auth.js";
+import { OmpRpcClient, OmpRpcResponseError } from "./client.js";
+import { defaultOmpRuntimeConfig, OMP_RUNTIME_CONFIG_SCHEMA, parseOmpRuntimeConfig } from "./config.js";
+import { OmpHostToolBridge } from "./host-tools.js";
+import { emptyOmpHistoryPage, inspectOmpHistory, readOmpHistory } from "./history.js";
+import { OMP_MODEL_OPTIONS_SCHEMA, OMP_MODEL_PROVIDER_ID, OMP_REASONING_VALUES, parseOmpReasoning, readOmpModelCatalog, setOmpModel, } from "./models.js";
+import { buildOmpProcessEnvironment, diagnoseOmpRuntime, disposeOmpSessionPaths, prepareOmpSessionPaths, resolveOmpCommand, } from "./process.js";
+import { OmpResourceDelivery } from "./resource-delivery.js";
+import { OMP_ADAPTER_ID, OMP_ADAPTER_VERSION, OmpThreadController, readOmpAvailableCommands } from "./thread.js";
+import { OmpRpcTurnController } from "./turn.js";
+export { OMP_ADAPTER_ID } from "./thread.js";
+export const OMP_RUNTIME_PROTOCOL_NAME = "omp-rpc";
+export const OMP_RUNTIME_SUPPORTED_RANGE = "2";
+function ompCapabilities() {
+    return {
+        lifecycle: {
+            persistent: true,
+            lazyBinding: false,
+            resume: true,
+            attach: true,
+            listNativeSessions: true,
+            fork: true,
+            clone: false,
+            tree: false,
+        },
+        input: {
+            text: true,
+            images: true,
+            audio: false,
+            steering: true,
+            structuredOutput: false,
+        },
+        output: {
+            assistantDeltas: true,
+            reasoning: true,
+            toolEvents: true,
+            usage: true,
+            plans: false,
+            diffs: false,
+            rawNativeEvents: false,
+        },
+        tools: {
+            piboManaged: { support: "direct" },
+            nativeToolInspection: {
+                support: "degraded",
+                mode: "observed-runtime-items",
+                reason: "OMP exposes its native tool inventory via get_state.dumpTools and runtime tool_execution items; a complete pre-turn inventory is only partially exposed through RPC.",
+            },
+            nativeToolYielding: unsupportedAgentRuntimeCapability("OMP native tools remain harness-owned and are not wrapped as Pibo yielded tools."),
+        },
+        mcp: {
+            externalServers: { support: "unsupported", reason: "OMP manages its own MCP; external MCP delivery is not wired in the initial OMP adapter." },
+            statusInspection: false,
+        },
+        skills: { support: "materialized", modes: ["omp-custom-directories"] },
+        context: {
+            support: "unsupported",
+            reason: "OMP loads project context via its own AGENTS.md/rules discovery in the session cwd; Pibo has no injection seam and does not mutate the user's workspace.",
+        },
+        auth: {
+            status: true,
+            methods: OMP_AUTH_METHODS,
+            cancel: true,
+            logout: true,
+            credentialScope: "runtime-instance",
+        },
+        models: {
+            catalog: true,
+            switchInSession: true,
+            optionsSchema: OMP_MODEL_OPTIONS_SCHEMA,
+        },
+        reasoning: {
+            supported: true,
+            values: [...OMP_REASONING_VALUES],
+        },
+        approvals: {
+            supported: false,
+            structuredUserInput: false,
+        },
+        maintenance: {
+            compaction: true,
+            contextUsage: true,
+            history: true,
+            health: true,
+        },
+    };
+}
+export const OMP_RUNTIME_CAPABILITIES = ompCapabilities();
+function validateOpenBinding(input, runtimeInstanceId) {
+    const binding = input.binding
+        ? structuredClone(input.binding)
+        : {
+            piboSessionId: input.piboSession.id,
+            runtimeInstanceId,
+            adapterId: OMP_ADAPTER_ID,
+            state: "unbound",
+        };
+    if (binding.piboSessionId !== input.piboSession.id) {
+        throw new AgentRuntimeUnavailableError(runtimeInstanceId, "The OMP binding belongs to a different Pibo Session.");
+    }
+    if (binding.runtimeInstanceId !== runtimeInstanceId || binding.adapterId !== OMP_ADAPTER_ID) {
+        throw new AgentRuntimeUnavailableError(runtimeInstanceId, "The OMP binding does not match the configured runtime instance.");
+    }
+    if (binding.state === "missing") {
+        throw new AgentRuntimeBindingMissingError(binding.piboSessionId, runtimeInstanceId, binding.nativeSessionId);
+    }
+    if (binding.state === "error") {
+        throw new AgentRuntimeUnavailableError(runtimeInstanceId, "The persisted OMP binding is in an error state.");
+    }
+    return binding;
+}
+function bindingForOmp(piboSessionId, runtimeInstanceId, previous) {
+    return {
+        ...(previous ? structuredClone(previous) : {}),
+        piboSessionId,
+        runtimeInstanceId,
+        adapterId: OMP_ADAPTER_ID,
+        protocol: OMP_RUNTIME_PROTOCOL_NAME,
+        protocolVersion: OMP_RUNTIME_SUPPORTED_RANGE,
+        adapterVersion: OMP_ADAPTER_VERSION,
+        locator: { kind: "adapter-resolved" },
+        state: "bound",
+    };
+}
+export class OmpSession {
+    runtimeInstanceId;
+    bundle;
+    config;
+    emitWarning;
+    adapter;
+    adapterId = OMP_ADAPTER_ID;
+    cwd;
+    capabilities;
+    controls;
+    listeners = new Set();
+    binding;
+    disposed = false;
+    operationInFlight = false;
+    client;
+    paths;
+    turn;
+    thread;
+    hostTools;
+    resourceDelivery;
+    constructor(runtimeInstanceId, bundle, config, emitWarning, adapter) {
+        this.runtimeInstanceId = runtimeInstanceId;
+        this.bundle = bundle;
+        this.config = config;
+        this.emitWarning = emitWarning;
+        this.adapter = adapter;
+        this.client = bundle.client;
+        this.paths = bundle.paths;
+        this.thread = bundle.threads;
+        this.resourceDelivery = bundle.resourceDelivery;
+        this.cwd = bundle.threads.current.cwd;
+        this.binding = bindingForOmp("", runtimeInstanceId, undefined);
+        this.capabilities = ompCapabilities();
+        this.turn = new OmpRpcTurnController(this.client, (event) => this.emit(event));
+        this.hostTools = new OmpHostToolBridge(this.client, undefined, this.toolExecutionContext(), (m) => this.emitWarning(m));
+        this.controls = {
+            getCurrentSession: () => this.thread.getSessionSnapshot(this.runtimeInstanceId),
+            listSessions: () => this.thread.listSessions(this.runtimeInstanceId),
+            getForkCandidates: () => this.forkCandidates(),
+            forkSession: async (entryId) => await this.runIdleOperation(async () => {
+                const previous = this.thread.getSessionSnapshot(this.runtimeInstanceId);
+                const result = await this.thread.forkSession(this.runtimeInstanceId, entryId);
+                this.updateBinding();
+                return { previous, current: result.current, cancelled: result.cancelled };
+            }),
+            getReasoning: () => parseOmpReasoning(undefined),
+            setReasoning: (value) => {
+                this.assertIdle();
+                const info = parseOmpReasoning(value);
+                // Send the real OMP thinking-level change (best-effort; contract is sync).
+                const level = info.value ?? "medium";
+                void this.client.request({ type: "set_thinking_level", level }, "set_thinking_level").catch((error) => {
+                    this.emitWarning("OMP set_thinking_level failed: " + (error instanceof Error ? error.message : String(error)));
+                });
+                return info;
+            },
+            setFastMode: (enabled) => {
+                this.assertIdle();
+                void this.client.request({ type: "set_fast_mode", enabled }, "set_fast_mode").catch((error) => {
+                    this.emitWarning("OMP set_fast_mode failed: " + (error instanceof Error ? error.message : String(error)));
+                });
+                return { mode: enabled ? "fast" : "normal", supported: true, changed: true };
+            },
+            getFastMode: () => ({ mode: "normal", supported: true }),
+            setModel: async (model) => await this.runIdleOperation(async () => {
+                const provider = model.provider ?? this.config.defaultProvider ?? "";
+                const modelId = model.id ?? this.config.defaultModel ?? "";
+                if (!provider || !modelId) {
+                    throw new Error("OMP model switch requires a provider and model id.");
+                }
+                await setOmpModel(this.client, provider, modelId);
+                return { provider, id: modelId };
+            }),
+            compact: async (customInstructions) => {
+                this.assertIdle();
+                return await this.client.request({ type: "compact", ...(customInstructions ? { customInstructions } : {}) }, "compact");
+            },
+        };
+    }
+    toolExecutionContext() {
+        return {
+            cwd: this.cwd,
+            runtimeInstanceId: this.runtimeInstanceId,
+            adapterId: OMP_ADAPTER_ID,
+        };
+    }
+    forkCandidates() {
+        return this.thread.cachedForkCandidates();
+    }
+    async setOmpModel(provider, modelId) {
+        const info = await setOmpModel(this.client, provider, modelId);
+        return info;
+    }
+    updateBinding() {
+        const snapshot = this.thread.getSessionSnapshot(this.runtimeInstanceId);
+        if (snapshot.nativeSessionId) {
+            this.binding = bindingForOmp(this.binding.piboSessionId, this.runtimeInstanceId, this.binding);
+            this.binding = {
+                ...this.binding,
+                nativeSessionId: snapshot.nativeSessionId,
+                locator: snapshot.locator,
+                metadata: {
+                    ...(this.binding.metadata ?? {}),
+                    nativePresenceExpected: true,
+                    ...(snapshot.name ? { sessionName: snapshot.name } : {}),
+                },
+            };
+        }
+    }
+    setPiboSessionId(sessionId) {
+        this.binding = { ...this.binding, piboSessionId: sessionId };
+    }
+    /** Apply the resolved native session id from OMP state. */
+    bindNativeSessionId(sessionId) {
+        this.binding = {
+            ...this.binding,
+            nativeSessionId: sessionId,
+            state: "bound",
+            locator: { kind: "adapter-resolved", value: sessionId },
+        };
+    }
+    /**
+     * Persist the on-disk OMP transcript path so a later `openSession` can pass
+     * it to `switch_session` (which expects the .jsonl file path, NOT the
+     * nativeSessionId UUID) to resume the same transcript.
+     */
+    bindNativeSessionFile(sessionFile) {
+        if (!sessionFile)
+            return;
+        this.binding = {
+            ...this.binding,
+            metadata: { ...(this.binding.metadata ?? {}), nativeSessionFile: sessionFile },
+        };
+    }
+    /** Wire a real host-tool bridge backed by the Pibo portable tool session. */
+    attachHostToolBridge(bridge) {
+        this.hostTools = bridge;
+    }
+    /** Adapter-level reads route history/models/auth through the live client. */
+    getClient() {
+        return this.client;
+    }
+    getBinding() {
+        this.updateBinding();
+        return structuredClone(this.binding);
+    }
+    subscribe(listener) {
+        this.assertActive();
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    async prompt(input) {
+        this.assertActive();
+        this.operationInFlight = true;
+        try {
+            await this.turn.prompt(input.text);
+            this.updateBinding();
+        }
+        finally {
+            this.operationInFlight = false;
+        }
+    }
+    async steer(input) {
+        this.assertActive();
+        await this.turn.steer(input.text);
+    }
+    async abort() {
+        this.assertActive();
+        await this.turn.interrupt();
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.turn.dispose();
+        await this.hostTools.cancelAll();
+        this.hostTools.dispose();
+        this.client.dispose();
+        await disposeOmpSessionPaths(this.paths);
+        // Notify the owning adapter so adapter-level reads stop routing to us.
+        this.adapter?.detachLiveSession(this);
+    }
+    getStatus() {
+        const hostInstalled = this.hostTools?.installedNames ?? [];
+        // Report the tools Pibo actually mounted (host-tool bridge). OMP's own
+        // native tools (bash/edit/…) remain engine-owned and are intentionally
+        // not exported here — we do not claim an inventory we do not observe.
+        return {
+            streaming: this.turn.streaming,
+            enabledTools: hostInstalled,
+            cwd: this.cwd,
+            reasoning: {
+                supported: true,
+                availableValues: [...OMP_REASONING_VALUES],
+            },
+        };
+    }
+    assertIdle() {
+        this.assertActive();
+        if (this.operationInFlight)
+            throw new Error("OMP session is busy with another operation.");
+    }
+    assertActive() {
+        if (this.disposed)
+            throw new Error("OMP session is disposed.");
+    }
+    async runIdleOperation(operation) {
+        this.assertIdle();
+        this.operationInFlight = true;
+        try {
+            return await operation();
+        }
+        finally {
+            this.operationInFlight = false;
+        }
+    }
+}
+export class OmpAgentRuntimeAdapter {
+    instanceId;
+    descriptor;
+    config;
+    displayName;
+    enabled;
+    parsed;
+    /** Handle to the currently-open session so history/auth/models route to it. */
+    live;
+    constructor(input, driver) {
+        this.instanceId = input.instanceId;
+        this.descriptor = driver.descriptor;
+        this.config = structuredClone(input.config);
+        this.displayName = input.displayName;
+        this.enabled = input.enabled;
+        this.parsed = parseOmpRuntimeConfig(input.config);
+    }
+    async diagnose() {
+        return await diagnoseOmpRuntime(this.parsed, this.instanceId);
+    }
+    validateProfile(input) {
+        // Truthful capability validation is delegated to the profile resolver;
+        // unsupported selections are rejected by the registry.
+        return [];
+    }
+    async openSession(input) {
+        const binding = validateOpenBinding(input, this.instanceId);
+        if (binding.state === "bound" && !binding.nativeSessionId) {
+            throw new AgentRuntimeUnavailableError(this.instanceId, "The persisted OMP binding has no native session id.");
+        }
+        const paths = await prepareOmpSessionPaths({
+            config: this.parsed,
+            runtimeInstanceId: this.instanceId,
+            piboSessionId: input.piboSession.id,
+            sessionGeneration: randomUUID(),
+        });
+        // Materialize BEFORE spawn (MUST-FIX #3): OMP reads config.yml at startup.
+        const resourceDelivery = new OmpResourceDelivery(this.parsed, paths, input.services?.resources);
+        await resourceDelivery.prepare();
+        const environment = buildOmpProcessEnvironment({
+            paths,
+            config: this.parsed,
+            baseEnvironment: process.env,
+        });
+        const command = resolveOmpCommand(this.parsed, paths);
+        const client = new OmpRpcClient({
+            startupTimeoutMs: this.parsed.startupTimeoutMs,
+            requestTimeoutMs: this.parsed.requestTimeoutMs,
+        });
+        try {
+            await client.connect(command, { cwd: input.workspace, env: environment });
+        }
+        catch (error) {
+            await client.dispose();
+            await disposeOmpSessionPaths(paths);
+            if (error instanceof OmpRpcResponseError)
+                throw error;
+            throw new AgentRuntimeUnavailableError(this.instanceId, `Failed to start OMP: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Determine native session id (+ transcript file path for later resume).
+        let nativeSessionId = binding.nativeSessionId;
+        let nativeSessionFile;
+        try {
+            const state = await client.request({ type: "get_state" }, "get_state");
+            const data = state["data"];
+            if (data && typeof data === "object" && !Array.isArray(data)) {
+                const record = data;
+                if (typeof record.sessionId === "string")
+                    nativeSessionId = record.sessionId;
+                if (typeof record.sessionFile === "string")
+                    nativeSessionFile = record.sessionFile;
+            }
+        }
+        catch {
+            // state is best-effort; binding stays as resolved
+        }
+        const initial = {
+            sessionId: nativeSessionId ?? binding.nativeSessionId ?? randomUUID(),
+            cwd: input.workspace,
+        };
+        // Build the session and thread controllers with a client that supports
+        // host-tool frames.
+        const threads = new OmpThreadController(client, input.workspace, { sessionId: initial.sessionId });
+        const bundle = { client, paths, threads, resourceDelivery };
+        const session = new OmpSession(this.instanceId, bundle, this.parsed, (m) => {
+            // Warning surfaced via session events is delivered by the turn controller.
+        }, this);
+        session.setPiboSessionId(input.piboSession.id);
+        // Wire host tools after session construction so the executor is available.
+        const portableTools = input.services?.portableTools;
+        // Rebuild the session's hostTools with the real portable session (the
+        // constructor used a placeholder). We recreate the bridge to avoid keeping
+        // a hidden reference.
+        const hb = new OmpHostToolBridge(client, portableTools, {
+            cwd: input.workspace,
+            runtimeInstanceId: this.instanceId,
+            adapterId: OMP_ADAPTER_ID,
+        }, (m) => session["emitWarning"]?.(m));
+        client.subscribeFrames((frame) => {
+            if (frame && typeof frame === "object" && frame.type === "host_tool_call") {
+                void hb.handleFrame(frame);
+            }
+        });
+        try {
+            await hb.install();
+            await threads.refresh();
+            // Resume/F4: if this Pibo Session was previously bound to an OMP
+            // native session, switch the new child into that persisted transcript
+            // so history/context carry over instead of starting a fresh session.
+            if (binding.state === "bound" && binding.nativeSessionId) {
+                // switch_session takes the .jsonl transcript PATH, not the session
+                // id UUID. Prefer the persisted transcript file (F4); fall back to
+                // the id only when no file was recorded.
+                const resumePath = (binding.metadata && typeof binding.metadata.nativeSessionFile === "string"
+                    ? binding.metadata.nativeSessionFile
+                    : undefined) ?? binding.nativeSessionId;
+                try {
+                    await client.request({ type: "switch_session", sessionPath: resumePath }, "switch_session");
+                    await threads.refresh();
+                    // OMP regenerates the session id on switch but restores the
+                    // transcript FILE. Re-read state so we persist the RESUMED
+                    // transcript path (not the fresh pre-switch session's file).
+                    const resumed = await client.request({ type: "get_state" }, "get_state");
+                    const resumedData = resumed["data"];
+                    if (resumedData && typeof resumedData === "object" && !Array.isArray(resumedData)) {
+                        const rr = resumedData;
+                        if (typeof rr.sessionFile === "string")
+                            nativeSessionFile = rr.sessionFile;
+                    }
+                }
+                catch (resumeError) {
+                    // Keep the fresh session; a failed switch is not fatal.
+                    // (bindNativeSessionId below still sets the binding.)
+                }
+            }
+            // Prime fork candidates (get_branch_messages) for the sync SPI.
+            void threads.loadForkCandidates(this.instanceId);
+        }
+        catch (error) {
+            await client.dispose();
+            await disposeOmpSessionPaths(paths);
+            throw error;
+        }
+        session.attachHostToolBridge(hb);
+        session.bindNativeSessionId(threads.current.sessionId);
+        session.bindNativeSessionFile(nativeSessionFile);
+        this.attachLiveSession(session);
+        return session;
+    }
+    /** Record the live session so adapter-level reads can route to it. */
+    attachLiveSession(session) {
+        this.live = session;
+    }
+    detachLiveSession(session) {
+        if (this.live === session)
+            this.live = undefined;
+    }
+    async listModels() {
+        if (this.live) {
+            try {
+                return await readOmpModelCatalog(this.live.getClient(), this.instanceId);
+            }
+            catch {
+                // fall through to empty on transient engine error
+            }
+        }
+        return { runtimeInstanceId: this.instanceId, models: [] };
+    }
+    async getAuthStatus() {
+        if (this.live) {
+            try {
+                const controller = new OmpAuthController(this.live.getClient());
+                return await controller.getStatus();
+            }
+            catch {
+                // fall through to unknown on transient engine error
+            }
+        }
+        return [unknownOmpStatusForAdapter()];
+    }
+    async startAuth(input) {
+        throw new AgentRuntimeAuthError("orp_auth_unavailable", "OMP auth requires an open session.");
+    }
+    async cancelAuth(input) {
+        return { providerId: input.providerId, configured: false, state: "disconnected", message: "Login canceled." };
+    }
+    async logoutAuth(input) {
+        return { providerId: input.providerId, configured: false, state: "disconnected" };
+    }
+    async inspectHistory(input) {
+        return inspectOmpHistory(input, this.instanceId);
+    }
+    async readHistory(input) {
+        if (this.live) {
+            return await readOmpHistory(this.live.getClient(), input, this.instanceId, input.binding);
+        }
+        return emptyOmpHistoryPage(this.instanceId);
+    }
+    async resolveBinding() {
+        return {
+            piboSessionId: "",
+            runtimeInstanceId: this.instanceId,
+            adapterId: OMP_ADAPTER_ID,
+            state: "unbound",
+        };
+    }
+}
+export const OMP_AGENT_RUNTIME_DRIVER = {
+    descriptor: {
+        id: OMP_ADAPTER_ID,
+        displayName: "Oh My Pi",
+        transport: "stdio-rpc",
+        configSchema: OMP_RUNTIME_CONFIG_SCHEMA,
+        capabilities: ompCapabilities(),
+        protocol: { name: OMP_RUNTIME_PROTOCOL_NAME, supportedRange: OMP_RUNTIME_SUPPORTED_RANGE },
+        supportsMultipleInstances: true,
+    },
+    defaultConfig() {
+        return defaultOmpRuntimeConfig();
+    },
+    parseConfig(value) {
+        return parseOmpRuntimeConfig(value);
+    },
+    create(input) {
+        return new OmpAgentRuntimeAdapter({ instanceId: input.instanceId, displayName: input.displayName ?? "Oh My Pi", enabled: input.enabled, config: input.config }, { descriptor: OMP_AGENT_RUNTIME_DRIVER.descriptor });
+    },
+};
+void OMP_MODEL_PROVIDER_ID;
+void OmpAuthController;
+void OmpRpcResponseError;
+void readOmpAvailableCommands;
+void inspectOmpHistory;
+void OMP_RUNTIME_CAPABILITIES;

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

@@ -0,0 +1,109 @@
+import { AgentRuntimeAuthError } from "../../agent-runtime/errors.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export const OMP_AUTH_METHODS = [
+    { id: "api_key", completion: "immediate" },
+];
+/**
+ * OMP auth status/surface.
+ *
+ * V1 truthfulness: OMP's RPC exposes `get_login_providers`/`login`. We declare
+ * `api_key` (immediate, env / models.yml configured keys) as the supported
+ * method. OAuth / device-code browser-step methods are surfaced only when the
+ * `open_url` extension_ui_request bridge is wired; until then they are not
+ * advertised.
+ */
+export class OmpAuthController {
+    client;
+    flowCounter = 0;
+    constructor(client) {
+        this.client = client;
+    }
+    async getStatus() {
+        try {
+            const result = await this.client.request({ type: "get_login_providers" }, "get_login_providers");
+            const data = result["data"];
+            if (!isRecord(data) || !Array.isArray(data.providers)) {
+                return [unknownOmpStatus()];
+            }
+            const statuses = [];
+            for (const provider of data.providers) {
+                if (!isRecord(provider) || typeof provider.id !== "string")
+                    continue;
+                const authenticated = provider.authenticated === true;
+                const available = provider.available === true;
+                statuses.push({
+                    id: provider.id,
+                    displayName: typeof provider.name === "string" ? provider.name : provider.id,
+                    state: ompAuthState(authenticated, available),
+                    configured: authenticated,
+                    methods: OMP_AUTH_METHODS,
+                    details: { accountType: authenticated ? "unknown" : "api_key" },
+                });
+            }
+            return statuses.length > 0 ? statuses : [unknownOmpStatus()];
+        }
+        catch {
+            return [unknownOmpStatus()];
+        }
+    }
+    async start(input) {
+        if (input.method === "api_key") {
+            // API-key auth is configured via provider config (env / models.yml);
+            // report as connected when a provider is selected.
+            return {
+                providerId: input.providerId,
+                state: "connected",
+                configured: true,
+                details: { accountType: "api_key" },
+            };
+        }
+        // OAuth/device-code: the browser step is surfaced via an open_url
+        // extension_ui_request only when the bridge is wired. Until then, report
+        // as unsupported rather than inventing support (truthful capability).
+        throw new AgentRuntimeAuthError("orp_auth_unsupported", `OMP OAuth/device-code authentication (${input.method}) is not wired in the OMP adapter; use an API key.`);
+    }
+    async complete(input) {
+        throw new AgentRuntimeAuthError("orp_auth_unsupported", "OMP API-key auth completes via provider configuration, not an RPC completion step.");
+    }
+    async cancel(input) {
+        return { providerId: input.providerId, state: "disconnected", configured: false, message: "Login canceled." };
+    }
+    async logout(input) {
+        // OMP persists credentials in its own store; Pibo reports the action
+        // without deleting user-global OMP state.
+        return { providerId: input.providerId, state: "disconnected", configured: false };
+    }
+    async dispose() {
+        // no owned resources
+    }
+}
+function ompAuthState(authenticated, available) {
+    if (authenticated)
+        return "connected";
+    if (!available)
+        return "unsupported";
+    return "disconnected";
+}
+function unknownOmpStatus() {
+    return {
+        id: "orp",
+        displayName: "OMP providers",
+        state: "unsupported",
+        configured: false,
+        methods: OMP_AUTH_METHODS,
+        details: { accountType: "api_key" },
+    };
+}
+/** Product-safe fallback status when the engine is unavailable. */
+export function unknownOmpStatusForAdapter() {
+    return {
+        id: "orp",
+        displayName: "OMP providers",
+        state: "unsupported",
+        configured: false,
+        methods: OMP_AUTH_METHODS,
+        details: { accountType: "api_key" },
+    };
+}