@relaymessenger/pi 0.1.4-staging.39 → 0.1.4-staging.40

package/dist/index.d.ts

@@ -1,4 +1,31 @@
-import Relay, { type MessagePart, type PaymentRequestCreateParams } from "@relaymessenger/sdk";
+import Relay, { type MessagePart, type PaymentRequestCreateParams, type RelayWebhookEvent } from "@relaymessenger/sdk";
+/**
+ * A dialog one of the person's own Pi extensions opened with `ctx.ui.select`
+ * or `ctx.ui.confirm`, the way Pi asks before a tool runs: Pi has "No
+ * permission popups" and leaves confirmation flows to extensions (Pi README;
+ * examples/extensions/permission-gate.ts). In RPC mode each one arrives as an
+ * `extension_ui_request` and waits for an `extension_ui_response` (Pi
+ * docs/rpc.md, "Extension UI Protocol").
+ */
+export interface PiDialog {
+    readonly method: "select" | "confirm";
+    readonly title: string;
+    readonly message?: string;
+    /** What the person picks from: the select's options, or Yes and No for a confirm. */
+    readonly options: readonly string[];
+    /** Pi's own wait: "the agent-side will auto-resolve with a default value when the timeout expires". */
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+/** Who answers Pi's dialogs, and reads the taps that answer them. */
+export interface PiApprovals {
+    /** The option picked, or undefined for no answer. */
+    dialog(request: PiDialog): Promise<string | undefined>;
+    /** Whether this event answered a dialog, so it starts no turn. */
+    take(event: RelayWebhookEvent): Promise<boolean>;
+}
+/** A confirm's two options. */
+export declare const CONFIRM_OPTIONS: readonly ["Yes", "No"];
 export interface PiChannelOptions {
     readonly agentToken: string;
     readonly baseURL?: string;
@@ -7,6 +34,12 @@ export interface PiChannelOptions {
     readonly rpcTimeoutMs?: number;
     readonly spawnPi?: (command: string, args: readonly string[], chatId: string) => PiProcess;
     readonly relay?: Relay;
+    /**
+     * Answers the person's own extensions' dialogs. Without it, a dialog is
+     * dismissed at once (`cancelled: true`), so the extension gets its own
+     * "no answer" and the turn goes on.
+     */
+    readonly approvals?: PiApprovals;
 }
 export interface PiProcess {
     readonly stdin: {
@@ -16,6 +49,25 @@ export interface PiProcess {
     readonly stdout: AsyncIterable<string>;
     readonly kill: () => void;
 }
+interface RpcRecord {
+    readonly type?: string;
+    readonly id?: string;
+    readonly success?: boolean;
+    readonly data?: {
+        text?: string | null;
+    };
+    readonly error?: string;
+    /** `extension_ui_request` fields (Pi docs/rpc.md). */
+    readonly method?: string;
+    readonly title?: string;
+    readonly message?: string;
+    readonly options?: unknown;
+    readonly timeout?: unknown;
+}
+/** The `extension_ui_response` to one dialog request, from the option picked. */
+export declare const dialogResponse: (record: Pick<RpcRecord, "id" | "method">, picked: string | undefined) => Record<string, unknown>;
+/** A dialog request as `PiDialog`, or undefined for a method a card cannot answer (input, editor, fire-and-forget). */
+export declare const piDialog: (record: RpcRecord) => Omit<PiDialog, "signal"> | undefined;
 /**
  * The prompt pi is given for one message: the words, then how to answer.
  * This process sends pi's final text for it, and the same buttons and link
@@ -40,3 +92,4 @@ export declare class PiChannel {
     stop(): void;
 }
 export declare const runPiChannel: (options: PiChannelOptions, signal?: AbortSignal) => Promise<void>;
+export {};

package/dist/index.js

@@ -1,6 +1,31 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import Relay, { BUTTONS_BLOCK_INSTRUCTION, BUTTONS_GUIDANCE, PAYMENT_BLOCK_INSTRUCTION, PAYMENT_GUIDANCE, selectionReply, selectionReplyContext, SELECTION_GUIDANCE, SELECTION_BLOCK_INSTRUCTION, LINK_LINE_INSTRUCTION, answerMessages as splitAnswer, createPaymentPart, RelayAPIError, } from "@relaymessenger/sdk";
+/** A confirm's two options. */
+export const CONFIRM_OPTIONS = ["Yes", "No"];
+/** The `extension_ui_response` to one dialog request, from the option picked. */
+export const dialogResponse = (record, picked) => {
+    if (picked === undefined)
+        return { type: "extension_ui_response", id: record.id, cancelled: true };
+    if (record.method === "confirm")
+        return { type: "extension_ui_response", id: record.id, confirmed: picked === CONFIRM_OPTIONS[0] };
+    return { type: "extension_ui_response", id: record.id, value: picked };
+};
+/** A dialog request as `PiDialog`, or undefined for a method a card cannot answer (input, editor, fire-and-forget). */
+export const piDialog = (record) => {
+    if (record.type !== "extension_ui_request" || typeof record.id !== "string")
+        return undefined;
+    const timeoutMs = typeof record.timeout === "number" && record.timeout > 0 ? record.timeout : undefined;
+    const base = { title: typeof record.title === "string" ? record.title : "", ...(typeof record.message === "string" ? { message: record.message } : {}), ...(timeoutMs !== undefined ? { timeoutMs } : {}) };
+    if (record.method === "confirm")
+        return { method: "confirm", options: CONFIRM_OPTIONS, ...base };
+    if (record.method === "select" && Array.isArray(record.options) && record.options.every((option) => typeof option === "string") && record.options.length) {
+        return { method: "select", options: record.options, ...base };
+    }
+    return undefined;
+};
+/** The dialog methods that wait for an answer (Pi docs/rpc.md). */
+const DIALOG_METHODS = new Set(["select", "confirm", "input", "editor"]);
 class ChildPiProcess {
     #child;
     constructor(command, args) { this.#child = spawn(command, [...args], { stdio: ["pipe", "pipe", "pipe"] }); this.#child.stderr.resume(); }
@@ -59,7 +84,34 @@ class ChatSession {
     lines;
     settled = false;
     nextId = 0;
-    constructor(process) { this.process = process; this.lines = process.stdout[Symbol.asyncIterator](); }
+    /** Dialogs waiting on a person; Pi is silent meanwhile, which is not a stall. */
+    dialogs = 0;
+    #approvals;
+    #stop = new AbortController();
+    constructor(process, approvals) {
+        this.process = process;
+        this.lines = process.stdout[Symbol.asyncIterator]();
+        this.#approvals = approvals;
+    }
+    /** Answers one dialog without holding up the reading of Pi's output. */
+    #answer(record) {
+        const dialog = piDialog(record);
+        const reply = (picked) => {
+            try {
+                this.process.stdin.write(`${JSON.stringify(dialogResponse(record, picked))}\n`);
+            }
+            catch { /* Pi is gone. */ }
+        };
+        if (!dialog || !this.#approvals) {
+            reply(undefined);
+            return;
+        }
+        this.dialogs += 1;
+        void this.#approvals.dialog({ ...dialog, signal: this.#stop.signal })
+            .catch(() => undefined)
+            .then((picked) => { reply(picked); })
+            .finally(() => { this.dialogs -= 1; });
+    }
     async read(timeoutMs, signal) {
         if (signal?.aborted)
             throw new Error("Pi RPC request aborted");
@@ -69,7 +121,14 @@ class ChatSession {
             const result = await Promise.race([
                 this.lines.next(),
                 new Promise((_, reject) => {
-                    timer = setTimeout(() => reject(new Error("Pi RPC request timed out")), timeoutMs);
+                    const expire = () => {
+                        if (this.dialogs > 0) {
+                            timer = setTimeout(expire, timeoutMs);
+                            return;
+                        }
+                        reject(new Error("Pi RPC request timed out"));
+                    };
+                    timer = setTimeout(expire, timeoutMs);
                     onAbort = () => reject(new Error("Pi RPC request aborted"));
                     signal?.addEventListener("abort", onAbort, { once: true });
                 }),
@@ -79,6 +138,8 @@ class ChatSession {
             const record = JSON.parse(result.value);
             if (record.type === "agent_settled")
                 this.settled = true;
+            if (record.type === "extension_ui_request" && DIALOG_METHODS.has(String(record.method)))
+                this.#answer(record);
             return record;
         }
         finally {
@@ -100,7 +161,7 @@ class ChatSession {
             }
         }
     }
-    stop() { this.process.stdin.end(); this.process.kill(); }
+    stop() { this.#stop.abort(); this.process.stdin.end(); this.process.kill(); }
 }
 export class PiChannel {
     #relay;
@@ -122,7 +183,8 @@ export class PiChannel {
         this.#abortListener = () => this.stop();
         signal?.addEventListener("abort", this.#abortListener, { once: true });
         try {
-            await this.#relay.websocket.run({ ...(signal ? { signal } : {}), onEvent: async (event) => this.#handle(event, signal), onFullSync: async () => { throw new Error("Pi channel cannot acknowledge FULL sync without a durable Relay inbox"); } });
+            await this.#relay.websocket.run({ ...(signal ? { signal } : {}), onEvent: async (event) => { if (await this.#options.approvals?.take(event))
+                    return; await this.#handle(event, signal); }, onFullSync: async () => { throw new Error("Pi channel cannot acknowledge FULL sync without a durable Relay inbox"); } });
         }
         finally {
             this.stop();
@@ -163,7 +225,7 @@ export class PiChannel {
         const data = event.data;
         let session = this.#sessions.get(data.chat.id);
         if (!session) {
-            session = new ChatSession(this.#spawnPi(this.#options.piCommand ?? "pi", ["--mode", "rpc", ...(this.#options.piArgs ?? [])], data.chat.id));
+            session = new ChatSession(this.#spawnPi(this.#options.piCommand ?? "pi", ["--mode", "rpc", ...(this.#options.piArgs ?? [])], data.chat.id), this.#options.approvals);
             this.#sessions.set(data.chat.id, session);
         }
         const timeout = this.#options.rpcTimeoutMs ?? 60_000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relaymessenger/pi",
-  "version": "0.1.4-staging.39",
+  "version": "0.1.4-staging.40",
   "description": "Relay Messenger channel for Pi over Relay v1 WebSocket delivery.",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,7 +34,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@relaymessenger/sdk": "0.3.6-staging.43"
+    "@relaymessenger/sdk": "0.3.6-staging.44"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "0.86.0",