@plannotator/pi-extension 0.28.43 → 0.28.44

package/generated/ai/endpoints.ts

@@ -148,6 +148,13 @@ export interface AIEndpointDeps {
    * `authorizeSessionBridgeRequest` (loopback Host) before the token check.
    */
   pullBridge?: { handle(req: Request): Promise<Response> | null };
+  /**
+   * A dropped `/api/ai/query` stream leaves the question running: the answer
+   * keeps draining and the provider decides what to do with it. The Inbox's
+   * Ask AI saves it, so a reload or a sleeping phone stops nothing. Default off:
+   * a disconnect aborts. `/api/ai/abort` aborts either way.
+   */
+  keepRunningOnDisconnect?: boolean;
 }
 
 /** Error code for a bridge request refused by `authorizeSessionBridgeRequest`. */
@@ -266,6 +273,7 @@ export function createAIEndpoints(deps: AIEndpointDeps) {
     beforeProviderSession,
     authorizeSessionBridgeRequest,
     pullBridge,
+    keepRunningOnDisconnect = false,
   } = deps;
 
   // Streams whose question /api/ai/abort already handled. The browser drops a
@@ -465,31 +473,31 @@ export function createAIEndpoints(deps: AIEndpointDeps) {
         markers!.delete(marker);
         if (markers!.size === 0 && liveStreams.get(sessionId) === markers) liveStreams.delete(sessionId);
       };
+      // Set only with `keepRunningOnDisconnect`: the question drains into nothing.
+      let draining = false;
       const stream = new ReadableStream({
         async start(controller) {
+          const send = (text: string) => {
+            if (!draining) controller.enqueue(encoder.encode(text));
+          };
           try {
             const messages = Object.keys(queryOptions).length > 0
               ? entry.session.query(effectivePrompt, queryOptions)
               : entry.session.query(effectivePrompt);
             for await (const message of messages) {
-              const data = JSON.stringify(message);
-              controller.enqueue(
-                encoder.encode(`data: ${data}\n\n`)
-              );
+              send(`data: ${JSON.stringify(message)}\n\n`);
             }
-            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            send("data: [DONE]\n\n");
           } catch (err) {
             const errorMsg: AIMessage = {
               type: "error",
               error: err instanceof Error ? err.message : String(err),
               code: "stream_error",
             };
-            controller.enqueue(
-              encoder.encode(`data: ${JSON.stringify(errorMsg)}\n\n`)
-            );
+            send(`data: ${JSON.stringify(errorMsg)}\n\n`);
           } finally {
             forget();
-            controller.close();
+            if (!draining) controller.close();
           }
         },
         cancel() {
@@ -497,8 +505,9 @@ export function createAIEndpoints(deps: AIEndpointDeps) {
           // close, navigation). Stop the in-flight turn so it doesn't keep
           // running on the now long-lived provider process. Not when an abort
           // request already handled this question (see liveStreams).
+          draining = keepRunningOnDisconnect;
           forget();
-          if (marker.handled) return;
+          if (marker.handled || draining) return;
           entry.session.abort();
         },
       });

package/generated/ai/session-bridge-pull.ts

@@ -114,11 +114,15 @@ export interface PullSessionBridgeOptions extends PullSessionBridgeConfig {
 	interruptTimeoutMs?: number;
 	/** Default 15s: after a cancel, how long to wait for the host to confirm before freeing the slot. */
 	cancelGraceMs?: number;
+	/** Default 1,000,000: the most characters one request may carry. A `done` repeats the whole answer. */
+	maxBodyChars?: number;
 	now?: () => number;
 }
 
 export interface PullSessionBridge {
 	readonly bridge: SessionBridge;
+	/** The host has polled, so `status()` is what it reported, not a new bridge's `ready`. */
+	readonly connected: boolean;
 	/** Handle a request to one of the two bridge paths. `null` for any other path. */
 	handle(req: Request): Promise<Response> | null;
 	/** Server shutdown: answer open polls with `closing`, fail anything still waiting. */
@@ -211,11 +215,14 @@ export function createPullSessionBridge(options: PullSessionBridgeOptions): Pull
 	const resendAfterMs = options.resendAfterMs ?? 5_000;
 	const interruptTimeoutMs = options.interruptTimeoutMs ?? 15_000;
 	const cancelGraceMs = options.cancelGraceMs ?? 15_000;
+	const maxBodyChars = options.maxBodyChars ?? MAX_EVENT_BODY_BYTES;
 	const createdAt = now();
 	const modes = { ...options.modes };
 
 	let hostStatus: SessionBridgeStatus = "ready";
 	let connected = false;
+	/** A poll came: an event alone reports no status, however late it is. */
+	let polled = false;
 	let lastSeen = createdAt;
 	let openPoll: OpenPoll | null = null;
 	let active: ActiveAsk | null = null;
@@ -404,7 +411,7 @@ export function createPullSessionBridge(options: PullSessionBridgeOptions): Pull
 
 	const readJson = async (req: Request): Promise<unknown> => {
 		const text = await req.text();
-		if (text.length > MAX_EVENT_BODY_BYTES) throw new Error("Request body too large.");
+		if (text.length > maxBodyChars) throw new Error("Request body too large.");
 		return text ? JSON.parse(text) : {};
 	};
 
@@ -425,6 +432,7 @@ export function createPullSessionBridge(options: PullSessionBridgeOptions): Pull
 			return json({ error: "Invalid JSON body." }, 400);
 		}
 		noteContact();
+		polled = true;
 		if (isRecord(body)) {
 			applyStatus(body.status);
 			if (isRecord(body.modes)) {
@@ -543,6 +551,9 @@ export function createPullSessionBridge(options: PullSessionBridgeOptions): Pull
 
 	return {
 		bridge,
+		get connected() {
+			return polled;
+		},
 		handle(req) {
 			const path = new URL(req.url).pathname;
 			if (path !== SESSION_BRIDGE_POLL_PATH && path !== SESSION_BRIDGE_EVENT_PATH) return null;

package/generated/config.ts

@@ -360,6 +360,11 @@ export interface PlannotatorConfig {
    * out): on wherever the tool is on.
    */
   inboxReminder?: boolean | Partial<Record<InboxToolHost, boolean>>;
+  /**
+   * The Plannotator Inbox's debug log (`inbox/debug.log` in the data dir), as
+   * `PLANNOTATOR_INBOX_DEBUG=1`. Config-only, read when the Inbox starts.
+   */
+  inboxDebug?: boolean;
   /**
    * The Plannotator Inbox's browser notifications, set from the Inbox page
    * (its one-time ask and its Settings), kept here rather than in the page's
@@ -1488,6 +1493,17 @@ export function resolveInboxPhones(
   return coerceConfigBoolean(config.inboxPhones, false);
 }
 
+/**
+ * Whether the Plannotator Inbox offers Ask AI: an environment switch, off by
+ * default, until the owner has used it. Off, the ask routes answer 404, no
+ * question can wait and no agent connects for one. Same words as
+ * PLANNOTATOR_INBOX_PHONES; anything else counts as off.
+ */
+export function resolveInboxAskAi(env: NodeJS.ProcessEnv = process.env): boolean {
+  const v = env.PLANNOTATOR_INBOX_ASK_AI?.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "on";
+}
+
 /**
  * The experimental features this build knows: the name PLANNOTATOR_EXPERIMENTAL
  * lists (kebab case) and the key it is saved under in config.json

package/generated/inbox/connection.ts

@@ -361,7 +361,7 @@ export const INBOX_TOOL_LEAD =
  * OpenCode 2 as a user message, and all three carry the wake's first line.
  */
 export const INBOX_TOOL_WAKE_NOTE =
-  "A reply arrives in this session by itself once it is idle, headed `Plannotator Inbox: <subject> (<reply id>)`: end your turn or keep working; do not call wait_for_reply. To answer it, send_message with reply_to set to that reply id, never one from memory."
+  "A reply arrives in this session by itself once it is idle, headed `Plannotator Inbox: <title> (<reply id>)`: end your turn or keep working; do not call wait_for_reply. To answer it, send_message with reply_to set to that reply id, never one from memory."
 
 /**
  * Fixed text, the description's last line: where everything the tool's short
@@ -774,7 +774,12 @@ export interface InboxReplyCommand {
   thread_id: string
   /** The agent message a reply answers; null for a message. */
   reply_to: string | null
-  /** The thread's subject. */
+  /**
+   * The title a wake shows, as the Inbox decided it (`InboxStore.agentTitle`):
+   * on a plain reply the thread's short name, or null when it has none, which
+   * every connection words `a reply`; on everything else the thread's
+   * subject. An older Inbox always sends the subject here.
+   */
   subject: string | null
   /** The reply or message, markdown, verbatim. */
   body: string
@@ -982,6 +987,36 @@ function wakeName(value: unknown): string {
  */
 export const INBOX_SEND_NOW_POLL_FIELD = 'send_now'
 
+/**
+ * The poll field (`true`) by which a connection says it can answer Ask AI
+ * live. An older connection never sends it, so a question never waits for it.
+ */
+export const INBOX_ASK_POLL_FIELD = 'ask'
+
+/**
+ * Set (`true`) on every poll answer while a question waits for this session
+ * and its Ask AI client has not connected, and a held poll ends at once. The
+ * connection then runs the client against `inboxAskBridgeBase(session)`, with
+ * the Inbox's token, until the Inbox says `closing`. It is a state, not an
+ * event: a poll answer that does not read it loses nothing.
+ */
+export const INBOX_ASK_WAITS_FIELD = 'ask_waits'
+
+export const INBOX_ASK_BRIDGE_PREFIX = '/api/inbox/ask/'
+
+/** Where a session's Ask AI client talks to the Inbox: the pull bridge's two paths go after it. */
+export function inboxAskBridgeBase(session: string): string {
+  return `${INBOX_ASK_BRIDGE_PREFIX}${encodeURIComponent(session)}`
+}
+
+export function parseInboxAskWaits(text: string): boolean {
+  try {
+    return (JSON.parse(text) as Record<string, unknown>)[INBOX_ASK_WAITS_FIELD] === true
+  } catch {
+    return false
+  }
+}
+
 /**
  * The turn a connection submits when a reply it put into a running turn
  * arrived as that turn ended, so the model never read it: the reply is in
@@ -1141,8 +1176,9 @@ export function inboxWakeClosingLine(threadId: unknown, toolName: string = INBOX
 }
 
 /**
- * The turn a reply or a message becomes: `Plannotator Inbox: <subject> (<id>)`,
- * the fixed instruction line for its type (a reply, a New message, or a
+ * The turn a reply or a message becomes: `Plannotator Inbox: <title> (<id>)`
+ * (the title is the command's `subject`, or `a reply` / `a message` without
+ * one), the fixed instruction line for its type (a reply, a New message, or a
  * thread the person started; on a redirected reply, the line
  * saying so under it), then the words verbatim, then the closing line
  * (`inboxWakeClosingLine`, naming `toolName`, the tool as the host

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plannotator/pi-extension",
-  "version": "0.28.43",
+  "version": "0.28.44",
   "type": "module",
   "description": "Plannotator Pi extension - interactive plan review with annotations, annotate agent messages, and review code/PRs",
   "author": "backnotprop",