@pasko70/pibo 2.0.0 → 2.2.0

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;
+}

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

@@ -0,0 +1,108 @@
+import { OMP_ADAPTER_ID } from "./thread.js";
+import { OMP_ADAPTER_VERSION } from "./thread.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function inspectOmpHistory(input, runtimeInstanceId) {
+    const binding = input.binding;
+    return {
+        runtimeInstanceId,
+        adapterId: OMP_ADAPTER_ID,
+        bindingState: binding.state,
+        available: binding.state === "bound" && Boolean(binding.nativeSessionId),
+        ...(binding.locator ? { locator: binding.locator } : {}),
+        version: OMP_ADAPTER_VERSION,
+        diagnostics: [],
+    };
+}
+function messageEntryRole(message) {
+    if (isRecord(message)) {
+        if (typeof message.role === "string") {
+            const role = message.role;
+            if (role === "user" || role === "assistant" || role === "tool" || role === "system")
+                return role;
+        }
+    }
+    return "system";
+}
+function messageText(message) {
+    if (typeof message === "string")
+        return message;
+    if (!isRecord(message))
+        return "";
+    if (typeof message.text === "string")
+        return message.text;
+    if (typeof message.content === "string")
+        return message.content;
+    if (Array.isArray(message.content)) {
+        const parts = [];
+        for (const part of message.content) {
+            if (isRecord(part) && typeof part.text === "string")
+                parts.push(part.text);
+        }
+        return parts.join("\n");
+    }
+    return "";
+}
+function toHistoryEntry(message, sequence, binding) {
+    const role = messageEntryRole(message);
+    const content = messageText(message);
+    return {
+        id: `${binding.nativeSessionId ?? "omp"}-${sequence}`,
+        type: "message",
+        source: "native",
+        createdAt: isRecord(message) && typeof message.timestamp === "string"
+            ? message.timestamp
+            : new Date().toISOString(),
+        sequence,
+        role,
+        content: content || "[empty message]",
+    };
+}
+export async function readOmpHistory(client, input, runtimeInstanceId, binding) {
+    try {
+        const result = await client.request({
+            type: "get_messages_page",
+            ...(input.cursor ? { cursor: input.cursor } : {}),
+            ...(input.limit ? { limit: input.limit } : {}),
+        }, "get_messages_page");
+        const data = result["data"];
+        if (!isRecord(data) || !Array.isArray(data.messages)) {
+            return emptyPage(runtimeInstanceId);
+        }
+        const entries = [];
+        let sequence = 0;
+        for (const message of data.messages) {
+            entries.push(toHistoryEntry(message, sequence++, binding));
+        }
+        return {
+            runtimeInstanceId,
+            adapterId: OMP_ADAPTER_ID,
+            source: "native",
+            entries,
+            ...(typeof data.nextCursor === "string" ? { nextCursor: data.nextCursor } : {}),
+            hasMore: typeof data.nextCursor === "string" && data.nextCursor.length > 0,
+        };
+    }
+    catch {
+        return emptyPage(runtimeInstanceId);
+    }
+}
+function emptyPage(runtimeInstanceId) {
+    return {
+        runtimeInstanceId,
+        adapterId: OMP_ADAPTER_ID,
+        source: "native",
+        entries: [],
+        hasMore: false,
+    };
+}
+export function emptyOmpHistoryPage(runtimeInstanceId) {
+    return {
+        runtimeInstanceId,
+        adapterId: OMP_ADAPTER_ID,
+        source: "native",
+        entries: [],
+        hasMore: false,
+    };
+}

package/dist/agent-runtimes/omp/host-tools.js

@@ -0,0 +1,201 @@
+const DEFAULT_MAX_TOOL_CALL_TIMEOUT_MS = 5 * 60_000;
+// Test hook: lets unit tests exercise the abort-on-timeout path quickly.
+function maxToolCallTimeoutMs() {
+    if (typeof process !== "undefined" && process.env?.PIBO_OMP_TOOL_TIMEOUT_MS) {
+        const parsed = Number(process.env.PIBO_OMP_TOOL_TIMEOUT_MS);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    return DEFAULT_MAX_TOOL_CALL_TIMEOUT_MS;
+}
+const MAX_RESULT_BYTES = 8 * 1024 * 1024;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : JSON.stringify(value ?? "");
+}
+/** Resolve the input-schema JSON Schema from a Pibo tool definition. */
+function toolInputSchema(definition) {
+    if (isRecord(definition.inputSchema)) {
+        return definition.inputSchema;
+    }
+    if (isRecord(definition.parameters)) {
+        return definition.parameters;
+    }
+    return { type: "object", properties: {} };
+}
+/** Flatten a Pibo tool result's content parts into host-tool text content. */
+function flattenToolResult(result) {
+    const parts = [];
+    for (const item of result.content ?? []) {
+        if (item.type === "text") {
+            parts.push(item.text);
+        }
+        else if (item.type === "image") {
+            parts.push("[image content]");
+        }
+        else if ("text" in item) {
+            parts.push(String(item.text ?? ""));
+        }
+        else {
+            parts.push(JSON.stringify(item));
+        }
+    }
+    const content = parts.join("\n");
+    return result.isError ? { content, isError: true } : { content };
+}
+/**
+ * Bridges Pibo's portable tool session over OMP's host-tool RPC protocol.
+ *
+ * - `install` sends Pibo's tool definitions via `set_host_tools` so OMP mounts
+ *   them directly (matching by name).
+ * - `handleFrame` processes `host_tool_call` / `host_tool_cancel` frames from
+ *   OMP, executes the underlying Pibo tool (same contract the Pi direct
+ *   compiler uses), and replies with `host_tool_result`.
+ *
+ * OMP preserves its native tools and base prompt; Pibo adds only its own
+ * portable tools, and only Pibo-hosted tools are governed by Pibo.
+ */
+export class OmpHostToolBridge {
+    client;
+    portableTools;
+    executionContext;
+    emitWarning;
+    tools = new Map();
+    activeCalls = new Map();
+    dispossed = false;
+    constructor(client, portableTools, executionContext, emitWarning) {
+        this.client = client;
+        this.portableTools = portableTools;
+        this.executionContext = executionContext;
+        this.emitWarning = emitWarning;
+    }
+    get installedNames() {
+        return [...this.tools.keys()];
+    }
+    /** Send the current Pibo portable tool definitions to OMP via set_host_tools. */
+    async install() {
+        if (!this.portableTools || this.dispossed) {
+            await this.client.request({ type: "set_host_tools", tools: [] }, "set_host_tools");
+            return [];
+        }
+        const definitions = this.portableTools.createDefinitions();
+        this.tools.clear();
+        const wire = [];
+        for (const def of definitions) {
+            if (typeof def.name !== "string" || def.name.length === 0 || def.portable === false)
+                continue;
+            this.tools.set(def.name, def);
+            wire.push({
+                name: def.name,
+                description: typeof def.description === "string" ? def.description : "",
+                inputSchema: toolInputSchema(def),
+            });
+        }
+        const result = await this.client.request({ type: "set_host_tools", tools: wire }, "set_host_tools");
+        const data = result["data"];
+        const toolNames = isRecord(data) && Array.isArray(data.toolNames)
+            ? data.toolNames.filter((n) => typeof n === "string")
+            : [];
+        return toolNames;
+    }
+    /**
+     * Handle a host tool frame from OMP. Returns true when the frame was a host
+     * tool call/cancel (consumed); false otherwise.
+     */
+    handleFrame(frame) {
+        if (!isRecord(frame))
+            return false;
+        if (frame.type === "host_tool_call") {
+            void this.handleToolCall(frame);
+            return true;
+        }
+        if (frame.type === "host_tool_cancel") {
+            void this.handleToolCancel(frame);
+            return true;
+        }
+        return false;
+    }
+    async handleToolCall(frame) {
+        const toolName = typeof frame.toolName === "string" ? frame.toolName : "unknown";
+        const toolCallId = stringValue(frame.toolCallId);
+        const definition = this.tools.get(toolName);
+        if (!definition) {
+            await this.client
+                .sendSideChannel({ type: "host_tool_result", toolCallId, result: { content: `error: unknown host tool "${toolName}"`, isError: true } }, "host_tool_result")
+                .catch(() => { });
+            return;
+        }
+        const controller = new AbortController();
+        this.activeCalls.set(toolCallId, controller);
+        let timeoutHandle;
+        // Forward incremental Pibo tool progress as host_tool_update when the tool
+        // callback provides it.
+        const onUpdate = definition.portable === false ? undefined : (update) => {
+            void this.client
+                .sendSideChannel({ type: "host_tool_update", toolCallId, partialResult: update }, "host_tool_update")
+                .catch(() => { });
+        };
+        try {
+            const prepared = definition.prepareInput ? definition.prepareInput(frame.arguments) : frame.arguments;
+            const result = await Promise.race([
+                definition.execute(toolCallId, prepared, controller.signal, onUpdate, this.executionContext),
+                new Promise((_, reject) => {
+                    timeoutHandle = setTimeout(() => {
+                        // Abort the underlying Pibo tool so timeout doesn't leak a
+                        // still-running background execution.
+                        controller.abort();
+                        reject(new Error(`OMP host tool "${toolName}" timed out.`));
+                    }, maxToolCallTimeoutMs());
+                }),
+            ]);
+            clearTimeout(timeoutHandle);
+            const wire = this.sanitize(flattenToolResult(result));
+            await this.client.sendSideChannel({ type: "host_tool_result", toolCallId, result: wire }, "host_tool_result");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.emitWarning(`OMP host tool "${toolName}" failed: ${message}`);
+            try {
+                await this.client.sendSideChannel({ type: "host_tool_result", toolCallId, result: { content: `error: ${message}`, isError: true } }, "host_tool_result");
+            }
+            catch {
+                // best-effort; the client may already be closing
+            }
+        }
+        finally {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            this.activeCalls.delete(toolCallId);
+        }
+    }
+    async handleToolCancel(frame) {
+        const toolCallId = stringValue(frame.toolCallId);
+        const active = this.activeCalls.get(toolCallId);
+        if (active)
+            active.abort();
+        this.activeCalls.delete(toolCallId);
+    }
+    sanitize(result) {
+        const serialized = JSON.stringify(result.content ?? "");
+        if (Buffer.byteLength(serialized, "utf8") > MAX_RESULT_BYTES) {
+            return { content: "[result truncated by Pibo]", isError: result.isError };
+        }
+        return result;
+    }
+    /** Cancel all in-flight host tool calls (used on abort/dispose). */
+    async cancelAll() {
+        for (const controller of this.activeCalls.values())
+            controller.abort();
+        this.activeCalls.clear();
+    }
+    dispose() {
+        if (this.dispossed)
+            return;
+        this.dispossed = true;
+        for (const controller of this.activeCalls.values())
+            controller.abort();
+        this.activeCalls.clear();
+    }
+}

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

@@ -0,0 +1,86 @@
+/** OMP thinking levels (from ai/types.ts ThinkingLevel). */
+export const OMP_REASONING_VALUES = ["none", "low", "medium", "high"];
+export const OMP_MODEL_PROVIDER_ID = "omp";
+export const OMP_MODEL_OPTIONS_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        provider: { type: "string" },
+        modelId: { type: "string" },
+        thinkingLevel: { type: "string", enum: [...OMP_REASONING_VALUES] },
+    },
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function toAgentRuntimeModelCatalog(runtimeInstanceId, models) {
+    return {
+        runtimeInstanceId,
+        models: models.map(toAgentRuntimeModelInfo),
+    };
+}
+export function toAgentRuntimeModelInfo(model) {
+    return {
+        id: model.id,
+        provider: model.provider ?? OMP_MODEL_PROVIDER_ID,
+        displayName: model.name ?? model.id,
+        reasoningOptions: model.reasoning || model.thinking ? [...OMP_REASONING_VALUES] : undefined,
+        options: {
+            provider: model.provider ?? OMP_MODEL_PROVIDER_ID,
+            modelId: model.id,
+        },
+    };
+}
+export async function readOmpModelCatalog(client, runtimeInstanceId) {
+    try {
+        const result = await client.request({ type: "get_available_models" }, "get_available_models");
+        const data = result["data"];
+        if (data && typeof data === "object" && !Array.isArray(data) && "models" in data) {
+            const models = data.models;
+            if (Array.isArray(models)) {
+                const descriptors = [];
+                for (const item of models) {
+                    if (!isRecord(item))
+                        continue;
+                    if (typeof item.id !== "string" || item.id.length === 0)
+                        continue;
+                    descriptors.push({
+                        provider: typeof item.provider === "string" ? item.provider : undefined,
+                        id: item.id,
+                        name: typeof item.name === "string" ? item.name : undefined,
+                        reasoning: item.reasoning === true,
+                        thinking: item.thinking === true,
+                        contextWindow: typeof item.contextWindow === "number" ? item.contextWindow : undefined,
+                    });
+                }
+                return toAgentRuntimeModelCatalog(runtimeInstanceId, descriptors);
+            }
+        }
+    }
+    catch {
+        // Model discovery is best-effort in fixtures; empty catalog is acceptable.
+    }
+    return { runtimeInstanceId, models: [] };
+}
+export async function setOmpModel(client, provider, modelId) {
+    const result = await client.request({ type: "set_model", provider, modelId }, "set_model");
+    const data = result["data"];
+    if (isRecord(data) && typeof data.id === "string") {
+        return toAgentRuntimeModelInfo({
+            provider: typeof data.provider === "string" ? data.provider : provider,
+            id: data.id,
+            name: typeof data.name === "string" ? data.name : undefined,
+        });
+    }
+    return { id: modelId, provider };
+}
+export async function setOmpThinkingLevel(client, level) {
+    await client.request({ type: "set_thinking_level", level }, "set_thinking_level");
+}
+export function parseOmpReasoning(level) {
+    if (typeof level === "string" && level.length > 0) {
+        const normalized = OMP_REASONING_VALUES.includes(level) ? level : "medium";
+        return { value: normalized, availableValues: [...OMP_REASONING_VALUES], supported: true };
+    }
+    return { availableValues: [...OMP_REASONING_VALUES], supported: true };
+}