@pasko70/pibo 1.16.6 → 2.0.0

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

@@ -0,0 +1,653 @@
+import { randomUUID } from "node:crypto";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { InitialSessionContext, } from "../../core/profiles.js";
+import { createPiboRuntime, } from "./runtime.js";
+import { PiboPluginRegistry } from "../../plugins/registry.js";
+import { unsupportedAgentRuntimeCapability, } from "../../agent-runtime/capabilities.js";
+import { RoutedSession as PiRoutedSession } from "./routed-session.js";
+import { loadModelCatalog as loadPiModelCatalog, piAgentRuntimeModelCatalog, } from "./model-catalog.js";
+import { inspectPiAgentRuntimeHistory, readPiAgentRuntimeHistory, } from "./history.js";
+import { PiAgentRuntimeAuthController } from "./auth.js";
+const PI_ADAPTER_ID = "pi";
+const PI_PROTOCOL_VERSION = "0.80.6";
+export const PI_AGENT_RUNTIME_CAPABILITIES = {
+    lifecycle: {
+        persistent: true,
+        lazyBinding: false,
+        resume: true,
+        attach: true,
+        listNativeSessions: true,
+        fork: true,
+        clone: true,
+        tree: true,
+    },
+    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: true,
+    },
+    tools: {
+        piboManaged: { support: "direct" },
+        nativeToolInspection: { support: "native" },
+        nativeToolYielding: { support: "native" },
+    },
+    mcp: {
+        externalServers: { support: "materialized", modes: ["isolated-pibo-mcp-config"] },
+        statusInspection: true,
+    },
+    skills: { support: "native" },
+    context: { support: "native" },
+    auth: {
+        status: true,
+        methods: [
+            { id: "device_code", completion: "explicit" },
+            { id: "browser_oauth", completion: "explicit" },
+            { id: "api_key", completion: "immediate" },
+        ],
+        cancel: true,
+        logout: true,
+        credentialScope: "adapter-shared",
+    },
+    models: {
+        catalog: true,
+        switchInSession: true,
+    },
+    reasoning: {
+        supported: true,
+        values: ["off", "minimal", "low", "medium", "high", "xhigh", "max"],
+    },
+    approvals: {
+        supported: false,
+        structuredUserInput: false,
+    },
+    maintenance: {
+        compaction: true,
+        contextUsage: true,
+        history: true,
+        health: true,
+    },
+};
+function cloneProfileForPiSession(input) {
+    const profile = input.profile;
+    const nativeSessionId = input.binding?.nativeSessionId ?? input.piboSession.piSessionId;
+    return new InitialSessionContext({
+        profileName: profile.profileName,
+        runtimeInstanceId: profile.runtimeInstanceId,
+        runtimeOptions: profile.runtimeOptions,
+        sessionId: nativeSessionId,
+        parentSessionId: profile.parentSessionId,
+        model: profile.model,
+        mainModel: profile.mainModel,
+        subagentModel: profile.subagentModel,
+        thinkingLevel: profile.thinkingLevel,
+        mainThinkingLevel: profile.mainThinkingLevel,
+        subagentThinkingLevel: profile.subagentThinkingLevel,
+        fast: profile.fast,
+        mainFast: profile.mainFast,
+        subagentFast: profile.subagentFast,
+        skills: profile.skills,
+        tools: profile.tools,
+        subagents: profile.subagents,
+        mcpServers: profile.mcpServers,
+        piPackages: profile.piPackages,
+        contextFiles: profile.contextFiles,
+        builtinTools: profile.builtinTools,
+        builtinToolNames: profile.builtinToolNames,
+        autoContextFiles: profile.autoContextFiles,
+        toolPackages: profile.toolPackages,
+    });
+}
+function nativeSnapshotFromPi(runtimeInstanceId, snapshot) {
+    return {
+        adapterId: PI_ADAPTER_ID,
+        runtimeInstanceId,
+        nativeSessionId: snapshot.piSessionId,
+        locator: snapshot.sessionFile ? { kind: "local-file", value: snapshot.sessionFile } : undefined,
+        leafId: snapshot.leafId,
+        cwd: snapshot.cwd,
+        name: snapshot.sessionName,
+        parentLocator: snapshot.parentSessionFile
+            ? { kind: "local-file", value: snapshot.parentSessionFile }
+            : undefined,
+    };
+}
+function nativeOperationFromPi(runtimeInstanceId, result) {
+    return {
+        previous: nativeSnapshotFromPi(runtimeInstanceId, result.previous),
+        current: nativeSnapshotFromPi(runtimeInstanceId, result.current),
+        cancelled: result.cancelled,
+        selectedText: result.selectedText,
+        editorText: result.editorText,
+        summaryEntryId: result.summaryEntryId,
+    };
+}
+function nativeSessionInfoFromPi(runtimeInstanceId, info) {
+    return {
+        adapterId: PI_ADAPTER_ID,
+        runtimeInstanceId,
+        nativeSessionId: info.id,
+        locator: { kind: "local-file", value: info.path },
+        cwd: info.cwd,
+        name: info.name,
+        parentLocator: info.parentSessionPath
+            ? { kind: "local-file", value: info.parentSessionPath }
+            : undefined,
+        createdAt: info.created,
+        updatedAt: info.modified,
+        messageCount: info.messageCount,
+        firstMessage: info.firstMessage,
+    };
+}
+function semanticEventFromPibo(event) {
+    switch (event.type) {
+        case "message_started":
+            return { type: "turn_started", turnId: event.eventId };
+        case "message_finished":
+            return { type: "turn_completed", turnId: event.eventId, status: "completed" };
+        case "assistant_delta":
+            return { type: "assistant_delta", text: event.text, contentIndex: event.contentIndex };
+        case "assistant_message":
+            return { type: "assistant_message", text: event.text, contentIndex: event.contentIndex };
+        case "thinking_started":
+            return { type: "reasoning_started", contentIndex: event.contentIndex };
+        case "thinking_delta":
+            return { type: "reasoning_delta", text: event.text, contentIndex: event.contentIndex };
+        case "thinking_finished":
+            return { type: "reasoning_finished", text: event.text, contentIndex: event.contentIndex };
+        case "tool_call":
+            return {
+                type: "tool_call",
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                args: event.args,
+                argsComplete: event.argsComplete,
+            };
+        case "tool_execution_started":
+            return { ...event, type: "tool_execution_started" };
+        case "tool_execution_updated":
+            return { ...event, type: "tool_execution_updated" };
+        case "tool_execution_finished":
+            return { ...event, type: "tool_execution_finished" };
+        case "assistant_usage":
+            return {
+                type: "usage",
+                usage: {
+                    inputTokens: event.inputTokens,
+                    outputTokens: event.outputTokens,
+                    cacheReadTokens: event.cacheReadTokens,
+                    cacheWriteTokens: event.cacheWriteTokens,
+                    totalTokens: event.totalTokens,
+                },
+            };
+        case "compaction_start":
+            return { type: "compaction_start", reason: event.reason };
+        case "compaction_end":
+            return {
+                type: "compaction_end",
+                reason: event.reason,
+                result: event.result,
+                aborted: event.aborted,
+                errorMessage: event.errorMessage,
+            };
+        case "session_error":
+            return { type: "error", message: event.error, details: event.errorDetails };
+        case "pi_event":
+            return { type: "native_event", event: event.event };
+        default:
+            return undefined;
+    }
+}
+class PiAgentRuntimeSession {
+    runtimeInstanceId;
+    piboSessionId;
+    runtime;
+    binding;
+    adapterId = PI_ADAPTER_ID;
+    cwd;
+    capabilities = PI_AGENT_RUNTIME_CAPABILITIES;
+    compatibility = { productRawEventType: "pi_event" };
+    controls;
+    listeners = new Set();
+    routed;
+    compatibilityHandle;
+    pendingPrompt;
+    engineProcessing = false;
+    bindingNativeSessionId;
+    nativePresenceExpected;
+    disposed = false;
+    constructor(runtimeInstanceId, piboSessionId, runtime, binding, initialFastMode) {
+        this.runtimeInstanceId = runtimeInstanceId;
+        this.piboSessionId = piboSessionId;
+        this.runtime = runtime;
+        this.binding = binding;
+        this.cwd = runtime.cwd;
+        this.bindingNativeSessionId = runtime.session.sessionId;
+        this.nativePresenceExpected = runtime.session.sessionManager.buildSessionContext().messages.length > 0;
+        this.routed = new PiRoutedSession(piboSessionId, runtime, (event) => this.handlePiboEvent(event), PiboPluginRegistry.create(), true, undefined, initialFastMode, undefined, undefined, (state) => this.handleEngineState(state));
+        this.controls = this.createControls();
+        this.compatibilityHandle = this.createCompatibilityHandle();
+    }
+    getBinding() {
+        const persistent = this.binding.metadata?.persistent !== false;
+        if (this.bindingNativeSessionId !== this.runtime.session.sessionId) {
+            this.bindingNativeSessionId = this.runtime.session.sessionId;
+            this.nativePresenceExpected = this.runtime.session.sessionManager.buildSessionContext().messages.length > 0;
+        }
+        return {
+            ...structuredClone(this.binding),
+            nativeSessionId: this.runtime.session.sessionId,
+            state: "bound",
+            locator: this.runtime.session.sessionFile
+                ? { kind: "local-file", value: this.runtime.session.sessionFile }
+                : undefined,
+            metadata: {
+                ...(this.binding.metadata ?? {}),
+                nativePresenceExpected: persistent && this.nativePresenceExpected,
+            },
+        };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async prompt(input) {
+        this.assertActive();
+        if (this.pendingPrompt)
+            throw new Error(`Pi runtime session "${this.piboSessionId}" already has an active prompt.`);
+        const id = randomUUID();
+        await new Promise((resolve, reject) => {
+            this.pendingPrompt = { id, terminal: false, resolve, reject };
+            try {
+                this.routed.enqueueMessage({
+                    type: "message",
+                    piboSessionId: this.piboSessionId,
+                    id,
+                    text: input.text,
+                    source: input.source === "interactive" ? "user" : "service",
+                    capabilityScope: input.capabilityScope === "run-reminder" ? "run-reminder" : undefined,
+                });
+            }
+            catch (error) {
+                this.pendingPrompt = undefined;
+                reject(error);
+            }
+        });
+    }
+    async steer(input) {
+        this.assertActive();
+        await this.routed.steerMessage({
+            type: "message",
+            piboSessionId: this.piboSessionId,
+            id: randomUUID(),
+            text: input.text,
+            delivery: "steer",
+            source: input.source === "interactive" ? "user" : "service",
+        });
+    }
+    async abort() {
+        const pending = this.pendingPrompt;
+        if (pending) {
+            const cancelled = await this.routed.cancelMessage(pending.id);
+            if (!cancelled)
+                await this.runtime.session.abort();
+            pending.terminal = true;
+            this.settlePromptIfReady();
+            return;
+        }
+        await this.runtime.session.abort();
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        await this.routed.dispose();
+        const pending = this.pendingPrompt;
+        this.pendingPrompt = undefined;
+        pending?.resolve();
+        this.listeners.clear();
+    }
+    getStatus() {
+        const status = this.routed.getStatus();
+        return {
+            streaming: status.streaming,
+            enabledTools: status.enabledTools,
+            cwd: status.cwd,
+            activeModel: this.routed.getActiveModel(),
+            reasoning: {
+                value: status.thinkingLevel,
+                availableValues: this.runtime.session.getAvailableThinkingLevels(),
+                supported: this.runtime.session.supportsThinking(),
+            },
+            fastMode: this.routed.getFastMode(),
+            retry: status.retry ? structuredClone(status.retry) : undefined,
+            warnings: status.warnings,
+            errors: status.errors,
+        };
+    }
+    async getStatusSnapshot() {
+        const status = await this.routed.getStatusSnapshot();
+        return {
+            ...this.getStatus(),
+            activeModel: status.activeModel,
+            contextUsage: status.contextUsage,
+            providerUsage: status.providerUsage,
+        };
+    }
+    getNativeCompatibilityHandle() {
+        return this.compatibilityHandle;
+    }
+    handlePiboEvent(event) {
+        if (event.type === "message_started")
+            this.nativePresenceExpected = true;
+        const eventId = "eventId" in event ? event.eventId : undefined;
+        const pending = this.pendingPrompt;
+        if (pending && eventId === pending.id) {
+            if (event.type === "message_finished" || event.type === "session_error")
+                pending.terminal = true;
+        }
+        const semantic = semanticEventFromPibo(event);
+        if (semantic)
+            this.emit(semantic);
+        if (event.type === "session_error") {
+            this.emit({
+                type: "turn_failed",
+                turnId: event.eventId,
+                message: event.error,
+                details: event.errorDetails,
+            });
+        }
+        this.settlePromptIfReady();
+    }
+    handleEngineState(state) {
+        this.engineProcessing = state.processing;
+        this.settlePromptIfReady();
+    }
+    settlePromptIfReady() {
+        const pending = this.pendingPrompt;
+        if (!pending || !pending.terminal || this.engineProcessing)
+            return;
+        this.pendingPrompt = undefined;
+        pending.resolve();
+    }
+    createControls() {
+        return {
+            getCurrentSession: () => nativeSnapshotFromPi(this.runtimeInstanceId, this.routed.getCurrentSession()),
+            listSessions: async () => (await this.routed.listSessions()).map((info) => nativeSessionInfoFromPi(this.runtimeInstanceId, info)),
+            getForkCandidates: () => this.routed.getForkCandidates(),
+            forkSession: async (entryId) => nativeOperationFromPi(this.runtimeInstanceId, await this.routed.forkSession(entryId)),
+            cloneSession: async () => nativeOperationFromPi(this.runtimeInstanceId, await this.routed.cloneSession()),
+            getSessionTree: () => {
+                const result = this.routed.getSessionTree();
+                return {
+                    current: nativeSnapshotFromPi(this.runtimeInstanceId, result.current),
+                    tree: result.tree,
+                };
+            },
+            navigateSessionTree: async (params) => nativeOperationFromPi(this.runtimeInstanceId, await this.routed.navigateSessionTree({
+                entryId: String(params.entryId ?? ""),
+                summarize: typeof params.summarize === "boolean" ? params.summarize : undefined,
+                customInstructions: typeof params.customInstructions === "string" ? params.customInstructions : undefined,
+                replaceInstructions: typeof params.replaceInstructions === "boolean" ? params.replaceInstructions : undefined,
+                label: typeof params.label === "string" ? params.label : undefined,
+            })),
+            switchSession: async (params) => nativeOperationFromPi(this.runtimeInstanceId, await this.routed.switchSession({
+                sessionFile: String(params.sessionFile ?? ""),
+                cwdOverride: typeof params.cwdOverride === "string" ? params.cwdOverride : undefined,
+            })),
+            getReasoning: () => ({
+                value: this.runtime.session.thinkingLevel,
+                availableValues: this.runtime.session.getAvailableThinkingLevels(),
+                supported: this.runtime.session.supportsThinking(),
+            }),
+            setReasoning: (value) => {
+                const result = this.routed.setThinkingLevel(value);
+                return { value: result.level, availableValues: result.availableLevels, supported: result.supported };
+            },
+            cycleReasoning: () => {
+                const result = this.routed.cycleThinkingLevel();
+                return { value: result.level, availableValues: result.availableLevels, supported: result.supported };
+            },
+            getFastMode: () => this.routed.getFastMode(),
+            setFastMode: (enabled) => this.routed.setFastMode(enabled),
+            setModel: async (model) => await this.routed.setModel(model),
+            compact: async (customInstructions) => await this.routed.compact(customInstructions),
+        };
+    }
+    createCompatibilityHandle() {
+        return new Proxy(this.runtime, {
+            get: (target, property, receiver) => {
+                if (property === "dispose")
+                    return () => this.dispose();
+                const value = Reflect.get(target, property, receiver);
+                return typeof value === "function" ? value.bind(target) : value;
+            },
+        });
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    assertActive() {
+        if (this.disposed)
+            throw new Error(`Pi runtime session "${this.piboSessionId}" is disposed.`);
+    }
+}
+class PiAgentRuntimeAdapter {
+    instanceId;
+    enabled;
+    descriptor = PI_AGENT_RUNTIME_DRIVER.descriptor;
+    config;
+    displayName;
+    modelCatalogCache;
+    authController;
+    constructor(instanceId, config, displayName, enabled) {
+        this.instanceId = instanceId;
+        this.enabled = enabled;
+        this.config = structuredClone(config);
+        this.displayName = displayName ?? this.descriptor.displayName;
+        this.authController = new PiAgentRuntimeAuthController(() => this.loadModelCatalog(), () => {
+            this.modelCatalogCache = undefined;
+        });
+    }
+    async diagnose() {
+        return [{
+                severity: "info",
+                code: "pi_runtime_available",
+                message: `Pi Coding Agent SDK ${PI_PROTOCOL_VERSION} is available in-process.`,
+            }];
+    }
+    async listModels() {
+        return piAgentRuntimeModelCatalog(this.instanceId, await this.loadModelCatalog());
+    }
+    async getAuthStatus() {
+        return await this.authController.getStatus();
+    }
+    async startAuth(input) {
+        return await this.authController.start(input);
+    }
+    async completeAuth(input) {
+        return await this.authController.complete(input);
+    }
+    async cancelAuth(input) {
+        return await this.authController.cancel(input);
+    }
+    async logoutAuth(input) {
+        return await this.authController.logout(input);
+    }
+    async disposeAuth() {
+        await this.authController.dispose();
+    }
+    async inspectHistory(input) {
+        return await inspectPiAgentRuntimeHistory(this.instanceId, input);
+    }
+    async readHistory(input) {
+        return await readPiAgentRuntimeHistory(this.instanceId, input);
+    }
+    validateProfile(input) {
+        const diagnostics = [];
+        if (input.profile.runtimeInstanceId !== this.instanceId) {
+            diagnostics.push({
+                severity: "error",
+                code: "runtime_instance_mismatch",
+                message: `Profile "${input.profile.profileName}" selects runtime instance "${input.profile.runtimeInstanceId}", not "${this.instanceId}".`,
+            });
+        }
+        if (Object.keys(input.profile.runtimeOptions).length > 0) {
+            diagnostics.push({
+                severity: "error",
+                code: "pi_runtime_options_unsupported",
+                message: "The Pi runtime does not accept adapter-specific profile options.",
+                path: "runtimeOptions",
+            });
+        }
+        const profileProvidesBash = input.profile.toolPackages.runControl === true
+            || (input.profile.builtinTools !== "disabled" && input.profile.builtinToolNames.includes("bash"));
+        if (input.profile.mcpServers.length > 0 && !profileProvidesBash) {
+            diagnostics.push({
+                severity: "error",
+                code: "pi_mcp_bash_required",
+                message: "Pi delivers selected external MCP servers through the session-scoped Pibo MCP CLI configuration, which requires the Bash tool.",
+                path: "mcpServers",
+            });
+        }
+        return diagnostics;
+    }
+    async resolveBinding(input) {
+        const binding = structuredClone(input.binding);
+        if (binding.state !== "bound" || binding.metadata?.persistent === false)
+            return binding;
+        if (!binding.nativeSessionId) {
+            return {
+                ...binding,
+                state: "error",
+                metadata: {
+                    ...(binding.metadata ?? {}),
+                    diagnosticCode: "pi_binding_native_id_missing",
+                    diagnosticMessage: "The persisted Pi binding is bound but has no native session id.",
+                },
+            };
+        }
+        const existing = (await SessionManager.list(input.workspace)).find((session) => session.id === binding.nativeSessionId);
+        if (existing) {
+            return {
+                ...binding,
+                locator: { kind: "local-file", value: existing.path },
+                metadata: {
+                    ...(binding.metadata ?? {}),
+                    nativePresenceExpected: existing.messageCount > 0,
+                },
+            };
+        }
+        if (binding.metadata?.nativePresenceExpected === false)
+            return binding;
+        return {
+            ...binding,
+            state: "missing",
+            metadata: {
+                ...(binding.metadata ?? {}),
+                diagnosticCode: "pi_session_missing",
+                diagnosticMessage: `Pi session "${binding.nativeSessionId}" was not found for workspace "${input.workspace}".`,
+            },
+        };
+    }
+    async openSession(input) {
+        const compatibility = input.services?.compatibility;
+        const runtime = await createPiboRuntime({
+            cwd: input.workspace,
+            persistSession: compatibility?.persistSession,
+            profile: cloneProfileForPiSession(input),
+            thinkingLevel: compatibility?.thinkingLevel,
+            retryDefaults: compatibility?.retryDefaults,
+            extensionFactories: compatibility?.extensionFactories,
+            subagentRunner: input.services?.subagentRunner,
+            runToolController: input.services?.runToolController,
+            runtimeToolController: input.services?.codeRuntimeToolController,
+            portableTools: input.services?.portableTools,
+            resources: input.services?.resources,
+            modelDefaults: compatibility?.modelDefaults,
+            activeModel: input.activeModel,
+            sessionContext: {
+                piboSessionId: input.productContext.piboSessionId,
+                piboRoomId: input.productContext.piboRoomId,
+                timezone: input.productContext.timezone,
+                getActiveMessage: input.productContext.getActiveMessage,
+            },
+            contextGuardTuiQueueOrdering: compatibility?.contextGuardTuiQueueOrdering,
+        });
+        const binding = {
+            ...(input.binding ? structuredClone(input.binding) : {}),
+            piboSessionId: input.piboSession.id,
+            runtimeInstanceId: this.instanceId,
+            adapterId: this.descriptor.id,
+            nativeSessionId: runtime.session.sessionId,
+            state: "bound",
+            protocol: "pi-sdk",
+            protocolVersion: PI_PROTOCOL_VERSION,
+            locator: runtime.session.sessionFile
+                ? { kind: "local-file", value: runtime.session.sessionFile }
+                : undefined,
+            metadata: {
+                ...(input.binding?.metadata ?? {}),
+                persistent: compatibility?.persistSession !== false,
+                nativePresenceExpected: compatibility?.persistSession !== false
+                    && runtime.session.sessionManager.buildSessionContext().messages.length > 0,
+            },
+        };
+        return new PiAgentRuntimeSession(this.instanceId, input.piboSession.id, runtime, binding, compatibility?.initialFastMode ?? false);
+    }
+    loadModelCatalog() {
+        const now = Date.now();
+        if (this.modelCatalogCache && this.modelCatalogCache.expiresAt > now)
+            return this.modelCatalogCache.value;
+        const value = loadPiModelCatalog(process.cwd());
+        this.modelCatalogCache = { expiresAt: now + 5_000, value };
+        value.catch(() => {
+            if (this.modelCatalogCache?.value === value)
+                this.modelCatalogCache = undefined;
+        });
+        return value;
+    }
+}
+export const PI_AGENT_RUNTIME_DRIVER = {
+    descriptor: {
+        id: PI_ADAPTER_ID,
+        displayName: "Pi Coding Agent",
+        transport: "embedded",
+        configSchema: {
+            type: "object",
+            additionalProperties: false,
+        },
+        capabilities: PI_AGENT_RUNTIME_CAPABILITIES,
+        protocol: {
+            name: "pi-sdk",
+            supportedRange: PI_PROTOCOL_VERSION,
+        },
+        supportsMultipleInstances: true,
+    },
+    defaultConfig: () => ({}),
+    parseConfig(value) {
+        if (Object.keys(value).length > 0)
+            throw new Error("Pi runtime config does not accept instance fields yet.");
+        return {};
+    },
+    create(input) {
+        return new PiAgentRuntimeAdapter(input.instanceId, input.config, input.displayName, input.enabled);
+    },
+};
+export function getPiAgentRuntimeCompatibilityHandle(session) {
+    if (session.adapterId !== PI_ADAPTER_ID)
+        return undefined;
+    return session.getNativeCompatibilityHandle?.();
+}
+export const PI_NATIVE_TOOL_YIELDING_LIMITATION = unsupportedAgentRuntimeCapability("Only Pi direct tools can be wrapped natively. External harness-native tools require an explicit host-tool capability.");