@pasko70/pibo 2.0.0 → 2.2.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/agent-runtimes/pi/adapter.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { rm } from "node:fs/promises";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { InitialSessionContext, } from "../../core/profiles.js";
 import { createPiboRuntime, } from "./runtime.js";
@@ -8,8 +9,9 @@ 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";
+import { importPortableHistoryIntoPi } from "./portable-history.js";
 const PI_ADAPTER_ID = "pi";
-const PI_PROTOCOL_VERSION = "0.80.6";
+export const PI_PROTOCOL_VERSION = "0.84.2";
 export const PI_AGENT_RUNTIME_CAPABILITIES = {
     lifecycle: {
         persistent: true,
@@ -48,6 +50,19 @@ export const PI_AGENT_RUNTIME_CAPABILITIES = {
     },
     skills: { support: "native" },
     context: { support: "native" },
+    contextDiscovery: {
+        supported: true,
+        configurable: true,
+        enabledByDefault: true,
+        strategy: "filesystem-ancestors",
+        knownFileNames: ["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"],
+    },
+    nativeSubagents: {
+        supported: false,
+        configurable: false,
+        enabledByDefault: false,
+    },
+    historyImport: true,
     auth: {
         status: true,
         methods: [
@@ -105,6 +120,7 @@ function cloneProfileForPiSession(input) {
         builtinTools: profile.builtinTools,
         builtinToolNames: profile.builtinToolNames,
         autoContextFiles: profile.autoContextFiles,
+        nativeSubagents: profile.nativeSubagents,
         toolPackages: profile.toolPackages,
     });
 }
@@ -562,6 +578,9 @@ class PiAgentRuntimeAdapter {
         };
     }
     async openSession(input) {
+        if (input.historyHandoff?.mode === "import" && input.binding?.state === "bound") {
+            throw new Error("Pi portable history import requires a new native session.");
+        }
         const compatibility = input.services?.compatibility;
         const runtime = await createPiboRuntime({
             cwd: input.workspace,
@@ -585,6 +604,18 @@ class PiAgentRuntimeAdapter {
             },
             contextGuardTuiQueueOrdering: compatibility?.contextGuardTuiQueueOrdering,
         });
+        if (input.historyHandoff?.mode === "import") {
+            try {
+                importPortableHistoryIntoPi(runtime.session.sessionManager, input.historyHandoff.history);
+            }
+            catch (error) {
+                const partialSessionFile = runtime.session.sessionFile;
+                await runtime.dispose().catch(() => { });
+                if (partialSessionFile)
+                    await rm(partialSessionFile, { force: true }).catch(() => { });
+                throw error;
+            }
+        }
         const binding = {
             ...(input.binding ? structuredClone(input.binding) : {}),
             piboSessionId: input.piboSession.id,

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

@@ -1,6 +1,6 @@
-import { AuthStorage } from "@earendil-works/pi-coding-agent";
 import { randomBytes, randomUUID } from "node:crypto";
 import { AgentRuntimeAuthError } from "../../agent-runtime/errors.js";
+import { deletePiCredential, getPiProviderAuthStatus, listPiCredentials, writePiCredential, } from "./credentials.js";
 const OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 const OPENAI_AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize";
 const OPENAI_ISSUER_URL = "https://auth.openai.com";
@@ -31,9 +31,6 @@ async function generatePKCE() {
     return { verifier, challenge };
 }
 const pendingLogins = new Map();
-function createAuthStorage() {
-    return AuthStorage.create();
-}
 function decodeJwt(token) {
     try {
         const parts = token.split(".");
@@ -201,8 +198,7 @@ export async function completeLogin(provider, code, state) {
         const deviceResult = await pollOpenAiDeviceAuthorization(pending);
         const tokenResult = await exchangeOpenAiAuthorizationCode(deviceResult.authorization_code, deviceResult.code_verifier, OPENAI_DEVICE_REDIRECT_URI);
         const accountId = getOpenAiAccountId(tokenResult.accessToken);
-        const authStorage = createAuthStorage();
-        authStorage.set(provider, {
+        await writePiCredential(provider, {
             type: "oauth",
             access: tokenResult.accessToken,
             refresh: tokenResult.refreshToken,
@@ -222,8 +218,7 @@ export async function completeLogin(provider, code, state) {
         }
         const tokenResult = await exchangeOpenAiAuthorizationCode(code, pending.verifier, OPENAI_REDIRECT_URI);
         const accountId = getOpenAiAccountId(tokenResult.accessToken);
-        const authStorage = createAuthStorage();
-        authStorage.set("openai-codex", {
+        await writePiCredential("openai-codex", {
             type: "oauth",
             access: tokenResult.accessToken,
             refresh: tokenResult.refreshToken,
@@ -234,26 +229,27 @@ export async function completeLogin(provider, code, state) {
     }
     throw new Error(`OAuth login complete not supported for provider "${provider}". Supported: openai-codex.`);
 }
-export function setApiKey(provider, apiKey) {
-    const authStorage = createAuthStorage();
-    authStorage.set(provider, { type: "api_key", key: apiKey });
+export async function setApiKey(provider, apiKey) {
+    await writePiCredential(provider, { type: "api_key", key: apiKey });
     return { success: true, provider };
 }
-export function getLoginStatus(provider) {
-    const authStorage = createAuthStorage();
-    if (provider) {
-        return [{ id: provider, provider, ...authStorage.getAuthStatus(provider) }];
-    }
-    return authStorage.list().map((p) => ({ id: p, provider: p, ...authStorage.getAuthStatus(p) }));
+export async function getLoginStatus(provider) {
+    const providerIds = provider
+        ? [provider]
+        : (await listPiCredentials()).map((credential) => credential.providerId);
+    return await Promise.all(providerIds.map(async (providerId) => ({
+        id: providerId,
+        provider: providerId,
+        ...(await getPiProviderAuthStatus(providerId)),
+    })));
 }
 export function cancelLogin(provider, state) {
     requirePendingLogin(state, provider);
     pendingLogins.delete(state);
     return { success: true, provider };
 }
-export function removeLogin(provider) {
-    const authStorage = createAuthStorage();
-    authStorage.logout(provider);
+export async function removeLogin(provider) {
+    await deletePiCredential(provider);
     return { success: true, provider };
 }
 const PI_AUTH_FLOW_TTL_MS = 10 * 60 * 1_000;
@@ -294,22 +290,31 @@ export class PiAgentRuntimeAuthController {
         try {
             this.cleanupExpired();
             const catalog = await this.loadCatalog();
+            const storedStatuses = await getLoginStatus();
             const providers = new Map(catalog.providers.map((provider) => [provider.id, {
                     id: provider.id,
                     displayName: provider.label,
+                    configured: provider.authConfigured,
                 }]));
-            for (const configured of getLoginStatus()) {
-                if (!providers.has(configured.id))
-                    providers.set(configured.id, { id: configured.id, displayName: configured.id });
+            for (const stored of storedStatuses) {
+                const existing = providers.get(stored.id);
+                if (existing) {
+                    existing.configured = stored.configured;
+                    continue;
+                }
+                providers.set(stored.id, {
+                    id: stored.id,
+                    displayName: stored.id,
+                    configured: stored.configured,
+                });
             }
             return [...providers.values()].map((provider) => {
-                const configured = getLoginStatus(provider.id)[0]?.configured ?? false;
                 const pending = [...this.pending.values()].find((entry) => entry.providerId === provider.id);
                 return {
                     id: provider.id,
                     displayName: provider.displayName,
-                    state: pending ? "pending" : configured ? "connected" : "disconnected",
-                    configured,
+                    state: pending ? "pending" : provider.configured ? "connected" : "disconnected",
+                    configured: provider.configured,
                     methods: [...piAuthMethodsForProvider(provider.id)],
                     ...(pending ? { pending: { ...pending.flow } } : {}),
                 };
@@ -328,7 +333,7 @@ export class PiAgentRuntimeAuthController {
             throw new Error(`Pi does not support ${input.method} authentication for provider "${input.providerId}".`);
         if (input.method === "api_key") {
             try {
-                setApiKey(input.providerId, input.apiKey);
+                await setApiKey(input.providerId, input.apiKey);
             }
             catch {
                 throw new AgentRuntimeAuthError("pi_auth_failed", "Pi API-key authentication failed safely.", true);
@@ -384,7 +389,7 @@ export class PiAgentRuntimeAuthController {
             const pending = this.requirePending(input.providerId, input.flowId);
             cancelLogin(pending.nativeProviderId, pending.nativeState);
             this.pending.delete(input.flowId);
-            const configured = getLoginStatus(input.providerId)[0]?.configured ?? false;
+            const configured = (await getLoginStatus(input.providerId))[0]?.configured ?? false;
             return {
                 providerId: input.providerId,
                 state: configured ? "connected" : "disconnected",
@@ -411,7 +416,7 @@ export class PiAgentRuntimeAuthController {
             this.pending.delete(flowId);
         }
         try {
-            removeLogin(input.providerId);
+            await removeLogin(input.providerId);
         }
         catch {
             throw new AgentRuntimeAuthError("pi_auth_failed", "Pi provider logout failed safely.", true);

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

@@ -0,0 +1,43 @@
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+let authStorageModulePromise;
+async function loadPiAuthStorageModule() {
+    authStorageModulePromise ??= import(new URL("./core/auth-storage.js", import.meta.resolve("@earendil-works/pi-coding-agent")).href);
+    return await authStorageModulePromise;
+}
+async function createPiCredentialStore() {
+    const { AuthStorage } = await loadPiAuthStorageModule();
+    return AuthStorage.create();
+}
+export async function readPiCredential(providerId) {
+    return await (await createPiCredentialStore()).read(providerId);
+}
+export async function writePiCredential(providerId, credential) {
+    const store = await createPiCredentialStore();
+    await store.modify(providerId, async () => credential);
+}
+export async function deletePiCredential(providerId) {
+    await (await createPiCredentialStore()).delete(providerId);
+}
+export async function listPiCredentials() {
+    return await (await createPiCredentialStore()).list();
+}
+export async function resolvePiProviderAuth(providerId) {
+    const credentials = await createPiCredentialStore();
+    const runtime = await ModelRuntime.create({ credentials, allowModelNetwork: false });
+    return await runtime.getAuth(providerId);
+}
+export async function getPiProviderAuthStatus(providerId) {
+    const credentials = await createPiCredentialStore();
+    const runtime = await ModelRuntime.create({ credentials, allowModelNetwork: false });
+    const status = runtime.getProviderAuthStatus(providerId);
+    if (status.configured)
+        return status;
+    const credential = (await credentials.list()).find((entry) => entry.providerId === providerId);
+    if (!credential)
+        return status;
+    return {
+        configured: true,
+        source: "stored",
+        label: credential.type === "oauth" ? "OAuth" : "API key",
+    };
+}

package/dist/agent-runtimes/pi/model-catalog.js

@@ -1,4 +1,4 @@
-import { createAgentSessionServices } from "@earendil-works/pi-coding-agent";
+import { ModelRegistry, createAgentSessionServices, } from "@earendil-works/pi-coding-agent";
 import { registerMiniMaxProvider } from "../../providers/minimax.js";
 import { registerGlmProvider } from "../../providers/glm.js";
 import { registerQwenTokenPlanProvider } from "../../providers/qwen-token-plan.js";
@@ -39,8 +39,12 @@ export function buildModelCatalogFromRegistry(registry) {
 export async function loadModelCatalogWithServices(createServices, cwd = process.cwd(), extensionHook) {
     try {
         const services = await createServices({ cwd });
-        extensionHook?.(services.modelRegistry);
-        return buildModelCatalogFromRegistry(services.modelRegistry);
+        const registry = services.modelRegistry
+            ?? (services.modelRuntime ? new ModelRegistry(services.modelRuntime) : undefined);
+        if (!registry)
+            throw new Error("Pi model services did not provide a model runtime.");
+        extensionHook?.(registry);
+        return buildModelCatalogFromRegistry(registry);
     }
     catch {
         return { providers: [] };