@relaymessenger/pi 0.1.4-staging.3 → 0.1.4-staging.30

package/README.md

@@ -15,3 +15,25 @@ 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.
+
+## Selection
+
+End the final Pi answer with a `selection` JSON fence after the question.
+The RPC prompt preserves ordered rich parts, `selected_values`, and `reply_to`
+as data. FULL sync still fails closed rather than discarding skipped context.
+
+New human reply text is literal `• ` + each selected source label joined with
+`\n`, followed by `selection_response` metadata in source-option order. Dispatch
+with `selected_values` and the explicit source target, never label parsing.
+Exact legacy comma-joined text remains a server compatibility input. The person
+checks any number of options and submits them once; checking sends nothing, and
+a person answers a given selection once. iOS may draw a checkmark in place of
+each bullet and repeat the prompt's title, as presentation only.
+
+## Payment
+
+The agent ends the final Pi answer with a `payment` JSON fence holding the
+payment request's fields (`description`, `category`, and `amount` with
+`currency`, or `mode: "subscription"` with `price_id`). The plugin creates the
+request with its own Relay token, on the card's own idempotency key; the words
+go first and the payment card follows as its own Message.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import Relay from "@relaymessenger/sdk";
+import Relay, { type MessagePart, type PaymentRequestCreateParams } from "@relaymessenger/sdk";
 export interface PiChannelOptions {
     readonly agentToken: string;
     readonly baseURL?: string;
@@ -16,6 +16,23 @@ export interface PiProcess {
     readonly stdout: AsyncIterable<string>;
     readonly kill: () => void;
 }
+/**
+ * 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
+ * rules every other runtime carries.
+ */
+export declare const piPrompt: (message: string) => string;
+/**
+ * The messages an answer becomes: each link written alone on a line as its
+ * own message, text in chunks the API takes, and the buttons its fenced block
+ * asked for under the last words. A block pi wrote that cannot be read stays
+ * in the words, so nothing the person was told is lost.
+ */
+export declare const answerMessages: (answer: string) => {
+    parts: MessagePart[];
+    error?: string;
+    payment?: PaymentRequestCreateParams;
+}[];
 export declare class PiChannel {
     #private;
     constructor(options: PiChannelOptions);

package/dist/index.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
-import Relay, {} from "@relaymessenger/sdk";
+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";
 class ChildPiProcess {
     #child;
     constructor(command, args) { this.#child = spawn(command, [...args], { stdio: ["pipe", "pipe", "pipe"] }); this.#child.stderr.resume(); }
@@ -11,11 +11,48 @@ class ChildPiProcess {
 const textFromEvent = (event) => {
     if (event.event_type !== "message.received" || event.data.direction !== "inbound")
         return null;
-    return event.data.parts
-        .flatMap((part) => part.type === "text" || part.type === "link"
-        ? [part.value]
-        : part.type === "button_reply" ? [part.label] : [])
-        .join("\n").trim() || null;
+    const text = event.data.parts
+        .flatMap((part) => part.type === "text" || part.type === "link" ? [part.value] : [])
+        .join("\n").trim();
+    const context = selectionReplyContext(selectionReply(event.data.parts, event.data.reply_to), {
+        parts: event.data.parts, ...(event.data.reply_to ? { reply_to: event.data.reply_to } : {}),
+    });
+    if (!text && !context)
+        return null;
+    return [text, context].filter(Boolean).join("\n\n");
+};
+/**
+ * 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
+ * rules every other runtime carries.
+ */
+export const piPrompt = (message) => `${message}\n\nWrite your answer as your final message. Relay sends that answer to the chat for you, so do not send it yourself. Write chat text. Inline Markdown draws: bold, italic, strikethrough, code, links. Headings, lists and code fences show as written.\n\n${BUTTONS_BLOCK_INSTRUCTION} ${LINK_LINE_INSTRUCTION} ${BUTTONS_GUIDANCE} ${SELECTION_BLOCK_INSTRUCTION} ${SELECTION_GUIDANCE} ${PAYMENT_BLOCK_INSTRUCTION} ${PAYMENT_GUIDANCE}`;
+/**
+ * The messages an answer becomes: each link written alone on a line as its
+ * own message, text in chunks the API takes, and the buttons its fenced block
+ * asked for under the last words. A block pi wrote that cannot be read stays
+ * in the words, so nothing the person was told is lost.
+ */
+export const answerMessages = (answer) => {
+    const split = splitAnswer(answer);
+    const messages = [];
+    for (const [first, ...rest] of split.messages) {
+        if (first?.type !== "text" || first.value.length <= 10_000) {
+            messages.push({ parts: first ? [first, ...rest] : rest });
+            continue;
+        }
+        const chunks = first.value.match(/[\s\S]{1,10000}/gu) ?? [];
+        for (const [index, chunk] of chunks.entries()) {
+            messages.push({ parts: [{ type: "text", value: chunk }, ...(index === chunks.length - 1 ? rest : [])] });
+        }
+    }
+    if (split.error && messages[0])
+        messages[0].error = split.error;
+    // The payment request the block described: created with the card's own key
+    // and sent as the last Message.
+    if (split.payment)
+        messages.push({ parts: [], payment: split.payment });
+    return messages;
 };
 class ChatSession {
     process;
@@ -96,6 +133,10 @@ export class PiChannel {
     stop() { for (const session of this.#sessions.values())
         session.stop(); this.#sessions.clear(); }
     async #handle(event, signal) {
+        // Concurrent redelivery must await the original handoff, not ACK early.
+        const inflight = this.#inflight.get(event.event_id);
+        if (inflight)
+            return inflight;
         if (this.#seen.has(event.event_id))
             return;
         const message = textFromEvent(event);
@@ -126,7 +167,7 @@ export class PiChannel {
             this.#sessions.set(data.chat.id, session);
         }
         const timeout = this.#options.rpcTimeoutMs ?? 60_000;
-        await session.command("prompt", { message }, timeout, signal);
+        await session.command("prompt", { message: piPrompt(message) }, timeout, signal);
         if (!session.settled) {
             while (!session.settled)
                 await session.read(timeout, signal);
@@ -135,9 +176,25 @@ export class PiChannel {
         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}` } });
+        const messages = answerMessages(answer);
+        if (messages[0]?.error)
+            console.error(`Relay: the component block in pi's answer was left as text: ${messages[0].error}.`);
+        for (const [index, message] of messages.entries()) {
+            const key = `pi-${event.event_id}-${index}`;
+            let parts = message.parts;
+            if (message.payment) {
+                try {
+                    parts = [await createPaymentPart(this.#relay, message.payment, key)];
+                }
+                catch (error) {
+                    if (!(error instanceof RelayAPIError) || error.retryable)
+                        throw error;
+                    console.error(`Relay: the payment in pi's answer was not sent: ${error.message}`);
+                    continue;
+                }
+            }
+            await this.#relay.chats.messages.send(data.chat.id, { message: { parts, idempotency_key: key } });
+        }
     }
 }
 export const runPiChannel = (options, signal) => new PiChannel(options).run(signal);

package/dist/native.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relaymessenger/pi",
-  "version": "0.1.4-staging.3",
+  "version": "0.1.4-staging.30",
   "description": "Relay Messenger channel for Pi over Relay v1 WebSocket delivery.",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,11 +34,11 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@relaymessenger/sdk": "0.3.6-staging.3"
+    "@relaymessenger/sdk": "0.3.6-staging.30"
   },
   "devDependencies": {
-    "@mariozechner/pi-coding-agent": "0.73.1",
-    "@types/node": "26.0.0",
+    "@earendil-works/pi-coding-agent": "0.86.0",
+    "@types/node": "26.6.2",
     "typescript": "7.0.2",
     "vitest": "4.1.11"
   },