@pasko70/pibo 2.0.0 → 2.1.1

package/dist/agent-runtimes/omp/protocol-types.js

@@ -0,0 +1,17 @@
+/**
+ * OMP RPC protocol wire types (read-only mirror of the OMP `--mode rpc`
+ * JSON-lines-over-stdio protocol from `@oh-my-pi/pi-coding-agent`).
+ *
+ * These are Pibo-owned, structurally-typed representations of the wire frames
+ * OMP emits/receives. They intentionally do NOT import from `@oh-my-pi/*`
+ * (which is Bun-only and cannot be imported under Node). Field names and shapes
+ * mirror OMP's `packages/coding-agent/src/modes/rpc/rpc-types.ts` and the
+ * session/agent event unions so the Pibo OMP adapter can speak the protocol
+ * without depending on the Bun runtime.
+ */
+export const OMP_RPC_PROTOCOL_NAME = "omp-rpc";
+export const OMP_RPC_PROTOCOL_VERSION = 2;
+export const OMP_RPC_SUPPORTED_PROTOCOL_VERSIONS = [1, 2];
+export const OMP_RPC_MAX_FRAME_BYTES = 1024 * 1024;
+export const OMP_RPC_MAX_REASSEMBLED_BYTES = 64 * 1024 * 1024;
+export const OMP_RPC_CHUNK_PAYLOAD_BYTES = 256 * 1024;

package/dist/agent-runtimes/omp/resource-delivery.js

@@ -0,0 +1,162 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+const MAX_CONTEXT_CONTRIBUTIONS = 128;
+const MAX_CONTEXT_BYTES = 1024 * 1024;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function boundedString(value, label) {
+    return typeof value === "string" ? value.slice(0, 4096) : label;
+}
+/** Longest common ancestor (dir) of a set of absolute file/dir paths. */
+function commonParent(paths) {
+    if (paths.length === 0)
+        return undefined;
+    const segs = paths.map((p) => resolve(p).split(/[\\/]/));
+    let i = 0;
+    while (segs[0][i] !== undefined && segs.every((s) => s[i] === segs[0][i]))
+        i++;
+    return segs[0].slice(0, i).join("/");
+}
+/**
+ * Materializes Pibo-selected skills into the isolated OMP agent dir
+ * (`PI_CODING_AGENT_DIR`) and writes the OMP `config.yml` including
+ * `skills.customDirectories` (pointing at the directory the resource-service
+ * populated with `<skillName>/SKILL.md` entries OMP actually discovers) plus
+ * provider/model defaults. Project context is copied under the isolating
+ * context dir for diagnostics only and reported `unsupported` — OMP loads its
+ * own project context via AGENTS.md discovery and Pibo has no injection seam.
+ * The real project's `.omp/skills`, `AGENTS.md` are untouched — OMP keeps
+ * discovering them natively.
+ *
+ * Called BEFORE spawning OMP: OMP reads config.yml at startup, and
+ * `skills.customDirectories` dirs are scanned for `<skill>/SKILL.md` subdirs on
+ * every session start. The resource-service materializes shared content before
+ * `openSession` returns, so `getSkillPaths("materialized")` are already valid.
+ */
+export class OmpResourceDelivery {
+    config;
+    paths;
+    resources;
+    constructor(config, paths, resources) {
+        this.config = config;
+        this.paths = paths;
+        this.resources = resources;
+    }
+    get configYamlPath() {
+        return this.paths.config;
+    }
+    /**
+     * Skill directories OMP should scan, derived from the materialized paths.
+     * `copyAgentRuntimeSkillDirectory` yields `<skillsRoot>/<skillName>/SKILL.md`;
+     * OMP's `scanSkillsFromDir` scans a dir containing `<skill>/SKILL.md`
+     * subdirs, which is the common parent of every materialized SKILL.md.
+     */
+    get customSkillDirectories() {
+        if (!this.resources)
+            return [];
+        const materialized = this.resources.getSkillPaths("materialized");
+        if (materialized.length === 0)
+            return [];
+        const dirs = materialized.map((p) => dirname(resolve(p)));
+        const shared = commonParent(dirs);
+        return shared ? [shared] : dirs;
+    }
+    /**
+     * Materialize selected skills/context and write the OMP config. MUST be
+     * called BEFORE spawning the OMP process (OMP reads config.yml at startup).
+     * Returns a delivery report per contribution.
+     */
+    async prepare() {
+        const reports = [];
+        const diagnostics = [];
+        // Context contributions are surfaced for debug traceability only. OMP
+        // does not read a `projectContextFiles` config key or any Pibo-injected
+        // file — project context arrives via its own AGENTS.md/rules discovery in
+        // the session cwd (the user's workspace, which we must not mutate). We
+        // write copies under the isolated context dir for diagnostics, but report
+        // them unsupported so callers never mistake them for engine-delivered.
+        const contributions = this.resources?.getContextContributions() ?? [];
+        const totalBytes = contributions.reduce((sum, c) => sum + (c.byteSize ?? c.content?.length ?? 0), 0);
+        if (contributions.length > MAX_CONTEXT_CONTRIBUTIONS || totalBytes > MAX_CONTEXT_BYTES) {
+            diagnostics.push({
+                severity: "warning",
+                code: "orp_context_exceeds_limit",
+                message: "Pibo context contributions exceed the OMP materialization limit; excess is omitted.",
+            });
+        }
+        await mkdir(this.paths.context, { recursive: true });
+        for (const contribution of contributions.slice(0, MAX_CONTEXT_CONTRIBUTIONS)) {
+            const safeName = (contribution.label || `contribution-${reports.length}`)
+                .replace(/[^A-Za-z0-9._-]+/g, "-")
+                .replace(/^-+|-+$/g, "")
+                .slice(0, 64) || "contribution.md";
+            const target = join(this.paths.context, `${reports.length}-${safeName}.md`);
+            try {
+                await writeFile(target, contribution.content ?? "", "utf8");
+                reports.push({
+                    contributionId: contribution.id,
+                    status: "unsupported",
+                    mode: "omp-native-agents-md-discovery",
+                    fidelity: "none",
+                    target,
+                    diagnostic: "OMP loads project context via its own AGENTS.md discovery; Pibo context is copied here for diagnostics only and not consumed by OMP.",
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                diagnostics.push({
+                    severity: "error",
+                    code: "orp_context_materialization_failed",
+                    message: `Failed to materialize context contribution "${contribution.id}": ${message}`,
+                    contributionId: contribution.id,
+                });
+                reports.push({
+                    contributionId: contribution.id,
+                    status: "failed",
+                    mode: "materialized",
+                    fidelity: "none",
+                    diagnostic: message,
+                });
+            }
+        }
+        // Skills: point OMP at directories populated with <skillName>/SKILL.md.
+        const customDirectories = this.customSkillDirectories;
+        await this.writeConfig({ customDirectories });
+        return { reports, diagnostics };
+    }
+    async writeConfig(opts) {
+        const lines = [];
+        lines.push("setupVersion: 1");
+        if (this.config.defaultProvider && this.config.defaultModel) {
+            lines.push(`modelRoles:`);
+            lines.push(`  default: ${this.config.defaultProvider}/${this.config.defaultModel}:max`);
+        }
+        if (opts.customDirectories.length > 0) {
+            lines.push(`skills:`);
+            lines.push(`  customDirectories:`);
+            for (const dir of opts.customDirectories) {
+                lines.push(`    - ${JSON.stringify(dir)}`);
+            }
+        }
+        await mkdir(dirname(this.paths.config), { recursive: true });
+        await writeFile(this.paths.config, `${lines.join("\n")}\n`, "utf8");
+    }
+    async readConfig() {
+        try {
+            return await readFile(this.paths.config, "utf8");
+        }
+        catch {
+            return "";
+        }
+    }
+}
+export function contextContributionToString(c) {
+    return c.content ?? "";
+}
+export function isRecordValue(value) {
+    return isRecord(value);
+}
+export function boundedContextValue(value, label) {
+    return boundedString(value, label);
+}

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

@@ -0,0 +1,141 @@
+import { OMP_RPC_PROTOCOL_NAME, OMP_RPC_PROTOCOL_VERSION } from "./protocol-types.js";
+export const OMP_ADAPTER_ID = "orp";
+export const OMP_ADAPTER_VERSION = "1.0.0";
+/**
+ * OMP session-file lifecycle controller. OMP owns its session files (JSONL
+ * session transcripts) under the isolated `PI_CODING_AGENT_DIR` sessions dir.
+ * Pibo records only an opaque binding locator pointing at OMP's native session
+ * id/file, so resume/re-attach target the native session through `switch_session`.
+ */
+export class OmpThreadController {
+    client;
+    cwd;
+    snapshot;
+    forkCandidatesCache = [];
+    constructor(client, cwd, initial) {
+        this.client = client;
+        this.cwd = cwd;
+        this.snapshot = { sessionId: initial.sessionId, messageCount: 0, cwd };
+    }
+    get current() {
+        return this.snapshot;
+    }
+    getSessionSnapshot(runtimeInstanceId) {
+        return {
+            adapterId: OMP_ADAPTER_ID,
+            runtimeInstanceId,
+            nativeSessionId: this.snapshot.sessionId,
+            locator: {
+                kind: "adapter-resolved",
+                value: this.snapshot.sessionFile ?? this.snapshot.sessionId,
+            },
+            cwd: this.cwd,
+            name: this.snapshot.sessionName,
+            metadata: {
+                protocol: OMP_RPC_PROTOCOL_NAME,
+                protocolVersion: OMP_RPC_PROTOCOL_VERSION,
+            },
+        };
+    }
+    async refresh() {
+        const state = await this.client.request({ type: "get_state" }, "get_state");
+        const data = state["data"];
+        if (data && typeof data === "object" && !Array.isArray(data)) {
+            const record = data;
+            this.snapshot = {
+                sessionId: typeof record.sessionId === "string" ? record.sessionId : this.snapshot.sessionId,
+                sessionName: typeof record.sessionName === "string" ? record.sessionName : undefined,
+                sessionFile: typeof record.sessionFile === "string" ? record.sessionFile : undefined,
+                messageCount: typeof record.messageCount === "number" ? record.messageCount : 0,
+                cwd: this.cwd,
+            };
+        }
+    }
+    async listSessions(runtimeInstanceId) {
+        await this.refresh();
+        const snapshot = this.getSessionSnapshot(runtimeInstanceId);
+        return [{ ...snapshot, messageCount: this.snapshot.messageCount, name: this.snapshot.sessionName }];
+    }
+    /** Fetch branch candidates from OMP and cache them for the sync SPI. */
+    async loadForkCandidates(runtimeInstanceId) {
+        try {
+            const result = await this.client.request({ type: "get_branch_messages" }, "get_branch_messages");
+            const data = result["data"];
+            if (data && typeof data === "object" && !Array.isArray(data) && "messages" in data) {
+                const messages = data.messages;
+                if (Array.isArray(messages)) {
+                    const candidates = [];
+                    for (const entry of messages) {
+                        if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+                            const rec = entry;
+                            if (typeof rec.entryId === "string") {
+                                candidates.push({
+                                    entryId: rec.entryId,
+                                    text: typeof rec.text === "string" ? rec.text : "",
+                                });
+                            }
+                        }
+                    }
+                    this.forkCandidatesCache = candidates;
+                    return candidates;
+                }
+            }
+        }
+        catch {
+            // Branch candidates are optional; fall through to empty.
+        }
+        this.forkCandidatesCache = [];
+        return [];
+    }
+    /** Sync accessor for the SPI (get_available_commands via a warm-up load). */
+    cachedForkCandidates() {
+        return this.forkCandidatesCache;
+    }
+    async forkSession(runtimeInstanceId, entryId) {
+        const previous = structuredClone(this.getSessionSnapshot(runtimeInstanceId));
+        const result = await this.client.request({ type: "branch", entryId }, "branch");
+        const data = result["data"];
+        const cancelled = Boolean(data && typeof data === "object" && !Array.isArray(data) && data.cancelled === true);
+        await this.refresh();
+        const current = this.getSessionSnapshot(runtimeInstanceId);
+        return { previous, current, cancelled };
+    }
+    async switchSession(runtimeInstanceId, sessionPath) {
+        const previous = structuredClone(this.getSessionSnapshot(runtimeInstanceId));
+        const result = await this.client.request({ type: "switch_session", sessionPath }, "switch_session");
+        const data = result["data"];
+        const cancelled = Boolean(data && typeof data === "object" && !Array.isArray(data) && data.cancelled === true);
+        await this.refresh();
+        const current = this.getSessionSnapshot(runtimeInstanceId);
+        return { previous, current, cancelled };
+    }
+}
+export async function readOmpAvailableCommands(client) {
+    try {
+        const result = await client.request({ type: "get_available_commands" }, "get_available_commands");
+        const data = result["data"];
+        if (data && typeof data === "object" && !Array.isArray(data) && "commands" in data) {
+            const commands = data.commands;
+            if (Array.isArray(commands)) {
+                return commands
+                    .filter((c) => Boolean(c) && typeof c === "object")
+                    .filter(isOmpCommand)
+                    .map((c) => ({
+                    name: c.name,
+                    description: c.description,
+                    source: String(c.source ?? "unknown"),
+                    aliases: c.aliases,
+                    inputHint: c.input?.hint,
+                    subcommands: c.subcommands,
+                }));
+            }
+        }
+    }
+    catch {
+        // available_commands is best-effort; return empty if unavailable.
+    }
+    return [];
+}
+function isOmpCommand(c) {
+    return typeof c.name === "string" && c.name.length > 0;
+}

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

@@ -0,0 +1,325 @@
+/** Hard cap on how long a streaming turn may run before we resolve it. */
+const DEFAULT_TURN_STREAM_TIMEOUT_MS = 10 * 60 * 1_000;
+// Test hook: allows the deadline to be set tiny (e.g. 250ms) so unit tests can
+// exercise the timeout path without waiting ten minutes.
+function turnStreamTimeoutMs() {
+    if (typeof process !== "undefined" && process.env?.PIBO_OMP_TURN_TIMEOUT_MS) {
+        const parsed = Number(process.env.PIBO_OMP_TURN_TIMEOUT_MS);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    return DEFAULT_TURN_STREAM_TIMEOUT_MS;
+}
+function deferred() {
+    const d = {};
+    d.promise = new Promise((resolve, reject) => {
+        d.resolve = resolve;
+        d.reject = reject;
+    });
+    return d;
+}
+export class OmpRpcClientProtocolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OmpRpcClientProtocolError";
+    }
+}
+function isOmpRpcAgentEvent(frame) {
+    return frame.type === "agent_start"
+        || frame.type === "agent_end"
+        || frame.type === "turn_start"
+        || frame.type === "turn_end"
+        || frame.type === "message_start"
+        || frame.type === "message_end"
+        || frame.type === "auto_compaction_start"
+        || frame.type === "auto_compaction_end"
+        || frame.type === "auto_retry_start"
+        || frame.type === "auto_retry_end"
+        || frame.type === "retry_fallback_applied"
+        || frame.type === "retry_fallback_succeeded"
+        || frame.type === "model_changed"
+        || frame.type === "ttsr_triggered"
+        || frame.type === "todo_reminder"
+        || frame.type === "todo_auto_clear"
+        || frame.type === "irc_message"
+        || frame.type === "notice"
+        || frame.type === "thinking_level_changed"
+        || frame.type === "goal_updated";
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function assistantEventText(event) {
+    if (event.type === "text_delta")
+        return { text: event.delta };
+    if (event.type === "text_end")
+        return { text: event.content };
+    if (event.type === "thinking_delta")
+        return { thinking: event.delta };
+    if (event.type === "thinking_end")
+        return { thinking: event.content };
+    return undefined;
+}
+function toolCallFromEvent(event) {
+    if (event.type !== "toolcall_end")
+        return undefined;
+    const toolCall = event.toolCall;
+    if (!toolCall)
+        return undefined;
+    return { id: toolCall.id, name: toolCall.name, args: toolCall.arguments };
+}
+export class OmpRpcTurnController {
+    client;
+    emit;
+    pending;
+    disposed = false;
+    unsubscribeFrames;
+    constructor(client, emit) {
+        this.client = client;
+        this.emit = emit;
+        this.unsubscribeFrames = client.subscribeFrames((frame) => {
+            if (this.disposed)
+                return;
+            try {
+                this.handleFrame(frame);
+            }
+            catch (error) {
+                this.handleProtocolFailure(error);
+            }
+        });
+        this.client.subscribeDiagnostics((message) => {
+            if (this.pending && message)
+                this.emitWarning(message);
+        });
+    }
+    get streaming() {
+        return this.pending !== undefined;
+    }
+    emitWarning(message) {
+        this.emit({ type: "warning", message });
+    }
+    handleProtocolFailure(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.emit({ type: "error", message });
+        if (this.pending && !this.pending.interrupted) {
+            this.pending.turnSettled.reject(new OmpRpcClientProtocolError(`OMP RPC protocol failure while streaming a turn: ${message}`));
+        }
+    }
+    /**
+     * Start a prompt turn. Strategy per MUST-FIX #4:
+     * - Send `prompt`, wait for the correlated `response`.
+     * - If the response reports agentInvoked:false (a local-only slash command or
+     *   skill that never invokes the model), resolve the turn IMMEDIATELY —
+     *   there is no agent_start/agent_end stream.
+     * - If agentInvoked:true, await the terminal agent_end with isTerminal:true.
+     */
+    async prompt(text) {
+        this.assertActive();
+        if (this.pending)
+            throw new Error("An OMP turn is already in progress.");
+        // Set pending BEFORE sending so frames emitted in the same stdout chunk
+        // (or before the response resolves) are attributed to this turn.
+        const turn = {
+            agentInvoked: true,
+            responseSettled: deferred(),
+            turnSettled: deferred(),
+            interrupted: false,
+        };
+        this.pending = turn;
+        try {
+            await this.executePrompt(turn, text);
+        }
+        catch (error) {
+            if (this.pending === turn)
+                this.pending = undefined;
+            throw error;
+        }
+    }
+    async executePrompt(turn, text) {
+        let response;
+        try {
+            response = await this.client.request({ type: "prompt", message: text }, "prompt");
+        }
+        finally {
+            turn.responseSettled.resolve();
+        }
+        const data = response["data"];
+        const invoked = !isRecord(data) || !("agentInvoked" in data) || data.agentInvoked !== false;
+        turn.agentInvoked = invoked;
+        if (!invoked) {
+            // Local-only slash/skill command: no agent stream will come (MUST-FIX #4).
+            if (this.pending === turn)
+                this.pending = undefined;
+            turn.turnSettled.resolve();
+            return;
+        }
+        // A running agent turn normally ends with a terminal agent_end. Guard
+        // against OMP never emitting it: resolve after a hard deadline so
+        // prompt() cannot hang forever.
+        const deadline = setTimeout(() => {
+            if (this.pending === turn)
+                this.pending = undefined;
+            turn.turnSettled.resolve();
+        }, turnStreamTimeoutMs());
+        try {
+            await turn.turnSettled.promise;
+        }
+        finally {
+            clearTimeout(deadline);
+            if (this.pending === turn)
+                this.pending = undefined;
+        }
+    }
+    async steer(text) {
+        this.assertActive();
+        await this.client.request({ type: "steer", message: text }, "steer");
+    }
+    async interrupt() {
+        this.assertActive();
+        if (this.pending)
+            this.pending.interrupted = true;
+        try {
+            await this.client.request({ type: "abort" }, "abort");
+        }
+        catch (error) {
+            if (this.pending && !this.pending.interrupted)
+                throw error;
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        this.unsubscribeFrames();
+        if (this.pending) {
+            this.pending.turnSettled.reject(new Error("OMP turn disposed."));
+            this.pending = undefined;
+        }
+    }
+    assertActive() {
+        if (this.disposed)
+            throw new Error("OMP turn controller is disposed.");
+    }
+    handleFrame(frame) {
+        if (this.pending === undefined)
+            return;
+        if (frame.type === "agent_end") {
+            if (frame.isTerminal !== false) {
+                const turn = this.pending;
+                this.pending = undefined;
+                turn.turnSettled.resolve();
+                turn.responseSettled.resolve();
+            }
+            return;
+        }
+        if (frame.type === "message_update") {
+            const event = frame.assistantMessageEvent;
+            if (!event)
+                return;
+            if (event.type === "text_delta" || event.type === "text_end") {
+                this.emit({ type: "assistant_delta", text: event.type === "text_end" ? event.content : event.delta, contentIndex: event.contentIndex });
+            }
+            else if (event.type === "thinking_delta" || event.type === "thinking_end") {
+                this.emit({ type: "reasoning_delta", text: event.type === "thinking_end" ? event.content : event.delta, contentIndex: event.contentIndex });
+            }
+            else if (event.type === "thinking_start") {
+                this.emit({ type: "reasoning_started", contentIndex: event.contentIndex });
+            }
+            else if (event.type === "toolcall_end") {
+                this.emit({
+                    type: "tool_call",
+                    toolCallId: event.toolCall.id,
+                    toolName: event.toolCall.name,
+                    args: event.toolCall.arguments,
+                    argsComplete: true,
+                });
+            }
+            else if (event.type === "done") {
+                // message done; terminal is signalled by agent_end
+            }
+            return;
+        }
+        if (frame.type === "tool_execution_start") {
+            this.emit({
+                type: "tool_execution_started",
+                toolCallId: frame.toolCallId,
+                toolName: frame.toolName,
+                args: frame.args,
+            });
+            return;
+        }
+        if (frame.type === "tool_execution_update") {
+            this.emit({
+                type: "tool_execution_updated",
+                toolCallId: frame.toolCallId,
+                toolName: frame.toolName,
+                args: frame.args,
+                partialResult: frame.partialResult,
+            });
+            return;
+        }
+        if (frame.type === "tool_execution_end") {
+            this.emit({
+                type: "tool_execution_finished",
+                toolCallId: frame.toolCallId,
+                toolName: frame.toolName,
+                result: frame.result,
+                isError: frame.isError === true,
+            });
+            return;
+        }
+        this.handleSessionEvent(frame);
+    }
+    handleSessionEvent(frame) {
+        if (!isOmpRpcAgentEvent(frame))
+            return;
+        switch (frame.type) {
+            case "turn_start":
+                this.emit({ type: "turn_started" });
+                break;
+            case "turn_end":
+                this.emit({ type: "turn_completed", status: "completed" });
+                break;
+            case "auto_compaction_start":
+                this.emit({ type: "compaction_start", reason: frame.reason });
+                break;
+            case "auto_compaction_end":
+                this.emit({
+                    type: "compaction_end",
+                    reason: frame.action,
+                    aborted: frame.aborted,
+                    errorMessage: frame.errorMessage,
+                    result: frame.result,
+                });
+                break;
+            case "notice":
+                if (frame.level === "error") {
+                    this.emit({ type: "error", message: frame.message });
+                }
+                else {
+                    this.emit({ type: "warning", message: frame.message });
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    /** Normalize an OMP AgentMessage usage into Pibo usage, if present. */
+    static usageFromMessage(message) {
+        if (!isRecord(message))
+            return undefined;
+        const usage = message.usage;
+        if (!isRecord(usage))
+            return undefined;
+        const record = usage;
+        const input = typeof record.inputTokens === "number" ? record.inputTokens : 0;
+        const output = typeof record.outputTokens === "number" ? record.outputTokens : 0;
+        const total = typeof record.totalTokens === "number" ? record.totalTokens : input + output;
+        return {
+            inputTokens: input,
+            outputTokens: output,
+            cacheReadTokens: typeof record.cachedInputTokens === "number" ? record.cachedInputTokens : 0,
+            cacheWriteTokens: 0,
+            reasoningTokens: typeof record.reasoningTokens === "number" ? record.reasoningTokens : 0,
+            totalTokens: total,
+        };
+    }
+}

package/dist/index.js

@@ -1,4 +1,4 @@
-export { createDefaultPiboProfile, createDefaultPiboPluginRegistry, createDefaultPiboPlugins, createGatewayProducerPiboPluginRegistry, createGatewayProducerPiboProfile, CODEX_NATIVE_PROFILE_NAME, CODEX_NATIVE_RUNTIME_INSTANCE_ID, piboCodexNativePlugin, piboCorePlugin, piboGatewayProducerPlugin, } from "./plugins/builtin.js";
+export { createDefaultPiboProfile, createDefaultPiboPluginRegistry, createDefaultPiboPlugins, createGatewayProducerPiboPluginRegistry, createGatewayProducerPiboProfile, CODEX_NATIVE_PROFILE_NAME, CODEX_NATIVE_RUNTIME_INSTANCE_ID, piboCodexNativePlugin, OMP_PROFILE_NAME, OMP_RUNTIME_INSTANCE_ID, piboOmpPlugin, piboCorePlugin, piboGatewayProducerPlugin, } from "./plugins/builtin.js";
 export { createPiboBetterAuthPlugin } from "./plugins/better-auth.js";
 export { createPiboChatWebPlugin } from "./plugins/chat-web.js";
 export { createPiboContextFilesPlugin } from "./plugins/context-files.js";

package/dist/plugins/builtin.js

@@ -12,10 +12,12 @@ import { piboCodexCompatPlugin } from "./codex-compat.js";
 import { piboCodexNativePlugin } from "./codex-native.js";
 import { addPiboNativeToolingContext, registerPiboNativeTooling } from "./native-tooling.js";
 import { piboWebAnnotationsPlugin } from "./web-annotations.js";
+import { piboOmpPlugin } from "./omp.js";
 import { definePiboPlugin, PiboPluginRegistry } from "./registry.js";
 import { PI_AGENT_RUNTIME_DRIVER } from "../agent-runtimes/pi/adapter.js";
 export { createDefaultPiboProfile, DEFAULT_PIBO_PROFILE_NAME } from "../core/default-profile.js";
 export { CODEX_NATIVE_PROFILE_NAME, CODEX_NATIVE_RUNTIME_INSTANCE_ID, piboCodexNativePlugin, } from "./codex-native.js";
+export { OMP_PROFILE_NAME, OMP_RUNTIME_INSTANCE_ID, piboOmpPlugin, } from "./omp.js";
 const GATEWAY_PROFILE_TOOLS = ["pibo_gateway_send"];
 const PIBO_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 function builtinSkillPath(name) {
@@ -587,11 +589,11 @@ export const piboGatewayProducerPlugin = definePiboPlugin({
     },
 });
 export function createDefaultPiboPlugins() {
-    return [piboCorePlugin, piboCodexNativePlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin];
+    return [piboCorePlugin, piboCodexNativePlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin, piboOmpPlugin];
 }
 export function createGatewayProducerPiboPluginRegistry() {
     return PiboPluginRegistry.create({
-        plugins: [piboCorePlugin, piboCodexNativePlugin, piboGatewayProducerPlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin],
+        plugins: [piboCorePlugin, piboCodexNativePlugin, piboGatewayProducerPlugin, piboCodexCompatPlugin, piboWebAnnotationsPlugin, piboOmpPlugin],
     });
 }
 export function createDefaultPiboPluginRegistry() {