@relaymessenger/pi 0.1.0-staging.0 → 0.1.0

package/README.md

@@ -6,3 +6,12 @@ each inbound Message through Pi RPC mode, and sends one final text reply.
 `relay connect pi` configures and runs this path for you. For a direct
 integration, pass `agentToken`, optionally `baseURL` and `piCommand`, then use
 `runPiChannel()`.
+
+To load the native Pi extension in an existing Pi installation:
+
+```bash
+pi install npm:@relaymessenger/pi
+```
+
+Set `RELAY_AGENT_TOKEN` before using `/relay-connect`. Set
+`RELAY_BASE_URL` when the Agent belongs to a non-default API environment.

package/dist/index.d.ts

@@ -4,7 +4,8 @@ export interface PiChannelOptions {
     readonly baseURL?: string;
     readonly piCommand?: string;
     readonly piArgs?: readonly string[];
-    readonly spawnPi?: (command: string, args: readonly string[]) => PiProcess;
+    readonly rpcTimeoutMs?: number;
+    readonly spawnPi?: (command: string, args: readonly string[], chatId: string) => PiProcess;
     readonly relay?: Relay;
 }
 export interface PiProcess {
@@ -19,5 +20,6 @@ export declare class PiChannel {
     #private;
     constructor(options: PiChannelOptions);
     run(signal?: AbortSignal): Promise<void>;
+    stop(): void;
 }
 export declare const runPiChannel: (options: PiChannelOptions, signal?: AbortSignal) => Promise<void>;

package/dist/index.js

@@ -3,10 +3,7 @@ import { createInterface } from "node:readline";
 import Relay, {} from "@relaymessenger/sdk";
 class ChildPiProcess {
     #child;
-    constructor(command, args) {
-        this.#child = spawn(command, [...args], { stdio: ["pipe", "pipe", "pipe"] });
-        this.#child.stderr.resume();
-    }
+    constructor(command, args) { this.#child = spawn(command, [...args], { stdio: ["pipe", "pipe", "pipe"] }); this.#child.stderr.resume(); }
     get stdin() { return this.#child.stdin; }
     get stdout() { return createInterface({ input: this.#child.stdout }); }
     kill = () => { this.#child.kill(); };
@@ -16,77 +13,127 @@ const textFromEvent = (event) => {
         return null;
     return event.data.parts.filter((part) => part.type === "text" || part.type === "link").map((part) => part.value).join("\n").trim() || null;
 };
+class ChatSession {
+    process;
+    lines;
+    settled = false;
+    nextId = 0;
+    constructor(process) { this.process = process; this.lines = process.stdout[Symbol.asyncIterator](); }
+    async read(timeoutMs, signal) {
+        if (signal?.aborted)
+            throw new Error("Pi RPC request aborted");
+        let timer;
+        let onAbort;
+        try {
+            const result = await Promise.race([
+                this.lines.next(),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error("Pi RPC request timed out")), timeoutMs);
+                    onAbort = () => reject(new Error("Pi RPC request aborted"));
+                    signal?.addEventListener("abort", onAbort, { once: true });
+                }),
+            ]);
+            if (result.done)
+                throw new Error("Pi RPC process exited");
+            const record = JSON.parse(result.value);
+            if (record.type === "agent_settled")
+                this.settled = true;
+            return record;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            if (onAbort)
+                signal?.removeEventListener("abort", onAbort);
+        }
+    }
+    async command(type, data, timeoutMs, signal) {
+        const id = String(++this.nextId);
+        this.process.stdin.write(`${JSON.stringify({ id, type, ...data })}\n`);
+        for (;;) {
+            const record = await this.read(timeoutMs, signal);
+            if (record.type === "response" && record.id === id) {
+                if (record.success === false)
+                    throw new Error(record.error ?? `Pi RPC ${type} failed`);
+                return record;
+            }
+        }
+    }
+    stop() { this.process.stdin.end(); this.process.kill(); }
+}
 export class PiChannel {
     #relay;
     #options;
     #spawnPi;
+    #sessions = new Map();
+    #turns = new Map();
+    #seen = new Set();
+    #inflight = new Map();
+    #abortListener;
     constructor(options) {
         if (!options.agentToken.trim())
             throw new Error("Relay Agent Token is required");
         this.#options = options;
-        this.#relay = options.relay ?? new Relay({
-            apiKey: options.agentToken,
-            ...(options.baseURL ? { baseURL: options.baseURL } : {}),
-        });
+        this.#relay = options.relay ?? new Relay({ apiKey: options.agentToken, ...(options.baseURL ? { baseURL: options.baseURL } : {}) });
         this.#spawnPi = options.spawnPi ?? ((command, args) => new ChildPiProcess(command, args));
     }
     async run(signal) {
-        await this.#relay.websocket.run({
-            ...(signal ? { signal } : {}),
-            onEvent: async (event) => { await this.#handle(event); },
-            onFullSync: async () => { },
-        });
+        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"); } });
+        }
+        finally {
+            this.stop();
+            if (signal)
+                signal.removeEventListener("abort", this.#abortListener);
+        }
     }
-    async #handle(event) {
+    stop() { for (const session of this.#sessions.values())
+        session.stop(); this.#sessions.clear(); }
+    async #handle(event, signal) {
+        if (this.#seen.has(event.event_id))
+            return;
         const message = textFromEvent(event);
         if (!message)
             return;
-        const pi = this.#spawnPi(this.#options.piCommand ?? "pi", ["--mode", "rpc", ...(this.#options.piArgs ?? [])]);
+        const data = event.data;
+        this.#seen.add(event.event_id);
+        const prior = this.#turns.get(data.chat.id) ?? Promise.resolve();
+        const turn = prior.then(() => this.#runTurn(event, message, signal));
+        this.#turns.set(data.chat.id, turn.catch(() => undefined));
+        this.#inflight.set(event.event_id, turn);
         try {
-            const lines = pi.stdout[Symbol.asyncIterator]();
-            let id = 0;
-            const readResponse = async (requestId, command) => {
-                for (;;) {
-                    const item = await lines.next();
-                    if (item.done)
-                        throw new Error("Pi RPC process exited before responding");
-                    const record = JSON.parse(item.value);
-                    if (record.type === "response" && record.id === requestId) {
-                        if (record.success === false)
-                            throw new Error(record.error ?? `Pi RPC ${command} failed`);
-                        return record;
-                    }
-                }
-            };
-            const promptId = String(++id);
-            pi.stdin.write(JSON.stringify({ id: promptId, type: "prompt", message }) + "\n");
-            await readResponse(promptId, "prompt");
-            let settled = false;
-            while (!settled) {
-                const item = await lines.next();
-                if (item.done)
-                    throw new Error("Pi RPC process exited before settling");
-                const record = JSON.parse(item.value);
-                settled = record.type === "agent_settled";
-            }
-            const textId = String(++id);
-            pi.stdin.write(JSON.stringify({ id: textId, type: "get_last_assistant_text" }) + "\n");
-            const response = await readResponse(textId, "get_last_assistant_text");
-            const answer = response.data?.text?.trim();
-            if (!answer)
-                throw new Error("Pi returned no final text answer");
-            const data = event.data;
-            await this.#relay.chats.messages.send(data.chat.id, {
-                message: {
-                    parts: [{ type: "text", value: answer }],
-                    idempotency_key: `pi-${event.event_id}`,
-                },
-            });
+            await turn;
+        }
+        catch (error) {
+            this.#seen.delete(event.event_id);
+            throw error;
         }
         finally {
-            pi.stdin.end();
-            pi.kill();
+            this.#inflight.delete(event.event_id);
+        }
+    }
+    async #runTurn(event, message, signal) {
+        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));
+            this.#sessions.set(data.chat.id, session);
+        }
+        const timeout = this.#options.rpcTimeoutMs ?? 60_000;
+        await session.command("prompt", { message }, timeout, signal);
+        if (!session.settled) {
+            while (!session.settled)
+                await session.read(timeout, signal);
         }
+        const response = await session.command("get_last_assistant_text", {}, timeout, signal);
+        const answer = response.data?.text?.trim();
+        if (!answer)
+            throw new Error("Pi returned no final text answer");
+        const chunks = answer.match(/[\s\S]{1,10000}/gu) ?? [];
+        for (const [index, chunk] of chunks.entries())
+            await this.#relay.chats.messages.send(data.chat.id, { message: { parts: [{ type: "text", value: chunk }], idempotency_key: `pi-${event.event_id}-${index}` } });
     }
 }
 export const runPiChannel = (options, signal) => new PiChannel(options).run(signal);

package/dist/native.d.ts

@@ -0,0 +1,7 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+/**
+ * Pi-native entry point. It deliberately exposes only lifecycle-safe commands;
+ * Relay ingress remains owned by runPiChannel so the CLI and extension share
+ * the same authenticated routing implementation.
+ */
+export default function relayPiExtension(pi: ExtensionAPI): void;

package/dist/native.js

@@ -0,0 +1,44 @@
+import { runPiChannel } from "./index.js";
+let controller;
+let running;
+/**
+ * Pi-native entry point. It deliberately exposes only lifecycle-safe commands;
+ * Relay ingress remains owned by runPiChannel so the CLI and extension share
+ * the same authenticated routing implementation.
+ */
+export default function relayPiExtension(pi) {
+    pi.registerCommand("relay-connect", {
+        description: "Start the Relay channel using the configured Agent Token",
+        handler: async (_args, ctx) => {
+            if (running) {
+                ctx.ui.notify("Relay Pi channel is already running.", "info");
+                return;
+            }
+            const agentToken = process.env.RELAY_AGENT_TOKEN?.trim();
+            if (!agentToken) {
+                ctx.ui.notify("RELAY_AGENT_TOKEN is not configured.", "error");
+                return;
+            }
+            controller = new AbortController();
+            running = runPiChannel({
+                agentToken,
+                ...(process.env.RELAY_BASE_URL?.trim()
+                    ? { baseURL: process.env.RELAY_BASE_URL.trim() }
+                    : {}),
+            }, controller.signal).catch((error) => {
+                ctx.ui.notify(`Relay Pi channel stopped: ${error instanceof Error ? error.message : String(error)}`, "error");
+            }).finally(() => {
+                running = undefined;
+                controller = undefined;
+            });
+            ctx.ui.notify("Relay Pi channel started.", "info");
+        },
+    });
+    pi.registerCommand("relay-disconnect", {
+        description: "Stop the Relay channel started by the Relay CLI",
+        handler: async (_args, ctx) => {
+            controller?.abort();
+            ctx.ui.notify("Relay Pi channel stopping.", "info");
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relaymessenger/pi",
-  "version": "0.1.0-staging.0",
+  "version": "0.1.0",
   "description": "Relay Messenger channel for Pi over Relay v1 WebSocket delivery.",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,21 +15,50 @@
   },
   "license": "MIT",
   "packageManager": "npm@12.0.2",
-  "engines": { "node": ">=22.22.3" },
-  "files": ["dist/", "README.md", "LICENSE"],
+  "engines": {
+    "node": ">=22.22.3"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./dist/native.js"
+    ]
+  },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "check": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run"
   },
-  "dependencies": { "@relaymessenger/sdk": "0.3.3-staging.7" },
+  "dependencies": {
+    "@relaymessenger/sdk": "0.3.3"
+  },
   "devDependencies": {
+    "@mariozechner/pi-coding-agent": "0.73.1",
     "@types/node": "26.0.0",
     "typescript": "7.0.2",
     "vitest": "4.1.10"
   },
-  "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/", "tag": "staging", "provenance": true },
-  "repository": { "type": "git", "url": "git+https://github.com/RelayMessenger/Relay-SDK.git", "directory": "packages/pi" },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "tag": "staging",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RelayMessenger/Relay-SDK.git",
+    "directory": "packages/pi"
+  },
   "homepage": "https://github.com/RelayMessenger/Relay-SDK/tree/main/packages/pi#readme",
-  "keywords": ["relay", "pi", "channel", "messaging"]
+  "keywords": [
+    "relay",
+    "pi",
+    "pi-package",
+    "channel",
+    "messaging"
+  ]
 }