pi-sessions 0.8.0 → 0.9.0

package/extensions/session-messaging/pi/incoming-message-presenter.ts

@@ -0,0 +1,32 @@
+import type { ExpandableContentPresentation } from "../../shared/rendering/expandable-content-layout.ts";
+import type { RenderTheme } from "../../shared/rendering/theme.ts";
+import type { IncomingMessageViewModel } from "./incoming-message-view-model.ts";
+
+export function buildIncomingMessagePresentation(
+  model: IncomingMessageViewModel,
+  theme: RenderTheme,
+): ExpandableContentPresentation {
+  const source = model.sourceSessionName
+    ? `${model.sourceSessionName} (${model.sourceSessionId})`
+    : model.sourceSessionId;
+  const metadata = [
+    model.relation,
+    model.requestResponse ? "response requested" : undefined,
+  ].filter((item): item is string => Boolean(item));
+  const metadataHint = metadata.length > 0 ? ` (${metadata.join(", ")})` : "";
+
+  return {
+    header: `${theme.fg("toolTitle", theme.bold("incoming_message"))} ${theme.fg(
+      "muted",
+      `from ${source}${metadataHint}`,
+    )}`,
+    ...(model.body
+      ? {
+          body: {
+            text: theme.fg("toolOutput", model.body.replaceAll("\t", "  ")),
+            collapsedRows: 3,
+          },
+        }
+      : {}),
+  };
+}

package/extensions/session-messaging/pi/incoming-message-view-model.ts

@@ -0,0 +1,20 @@
+import { normalizeOptionalText } from "../../shared/text.ts";
+import type { ReceivedMessageEntry } from "./message-contracts.ts";
+
+export interface IncomingMessageViewModel {
+  sourceSessionId: string;
+  sourceSessionName?: string | undefined;
+  relation?: string | undefined;
+  requestResponse: boolean;
+  body: string;
+}
+
+export function buildIncomingMessageView(received: ReceivedMessageEntry): IncomingMessageViewModel {
+  return {
+    sourceSessionId: received.source.sessionId,
+    sourceSessionName: normalizeOptionalText(received.source.sessionName),
+    relation: received.relation,
+    requestResponse: received.requestResponse === true,
+    body: received.body,
+  };
+}

package/extensions/session-messaging/pi/incoming-runtime.ts

@@ -1,12 +1,11 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isSessionStarting, SESSION_STARTING_MESSAGE } from "../../session-handoff/metadata.ts";
 import { safeParseTypeBoxValue } from "../../shared/typebox.ts";
 import { RECEIVED_MESSAGE_ENTRY_SCHEMA, type ReceivedMessageEntry } from "./message-contracts.ts";
 
 export const MESSAGE_RECEIVED_CUSTOM_TYPE = "pi-sessions.message_received";
 export const SESSION_MESSAGE_CUSTOM_TYPE = "pi-sessions.session_message";
 
-type DeliveryResult = { delivered: true } | { delivered: false; error: string };
-
 interface IncomingMessageActions {
   appendEntry(customType: string, data: unknown): void;
   sendMessage(
@@ -29,28 +28,30 @@ export class IncomingSessionMessageRuntime {
       appendEntry: pi.appendEntry.bind(pi),
       sendMessage: pi.sendMessage.bind(pi),
     };
+  }
 
-    pi.on("session_start", (_event, ctx) => {
-      this.context = ctx;
-    });
-    pi.on("session_shutdown", () => {
-      this.context = undefined;
-    });
+  bindContext(ctx: ExtensionContext): void {
+    this.context = ctx;
   }
 
-  deliver(received: ReceivedMessageEntry): DeliveryResult {
-    const ctx = this.context;
-    if (!ctx) {
-      return { delivered: false, error: "Target session is not ready." };
-    }
+  clearContext(): void {
+    this.context = undefined;
+  }
 
-    try {
-      this.actions.appendEntry(MESSAGE_RECEIVED_CUSTOM_TYPE, received);
-      this.inject(ctx, received);
-      return { delivered: true };
-    } catch (error) {
-      return { delivered: false, error: formatError(error) };
+  deliver(received: ReceivedMessageEntry): void {
+    const ctx = this.requireContext();
+    // A starting session is broker-reachable but has not consumed its handoff
+    // kickoff. Injecting here would land the message before the kickoff and
+    // break the first-message invariant, so refuse delivery until it kicks off.
+    if (isSessionStarting(ctx.sessionManager.getBranch())) {
+      throw new Error(SESSION_STARTING_MESSAGE);
     }
+    this.actions.appendEntry(MESSAGE_RECEIVED_CUSTOM_TYPE, received);
+    this.inject(ctx, received);
+  }
+
+  cancel(): void {
+    this.requireContext().abort();
   }
 
   replayPending(ctx: ExtensionContext): void {
@@ -84,6 +85,13 @@ export class IncomingSessionMessageRuntime {
     }
   }
 
+  private requireContext(): ExtensionContext {
+    if (!this.context) {
+      throw new Error("Target session is not ready.");
+    }
+    return this.context;
+  }
+
   private inject(ctx: ExtensionContext, received: ReceivedMessageEntry): void {
     const deliveryOptions = ctx.isIdle()
       ? { triggerTurn: true as const }
@@ -108,7 +116,3 @@ function formatIncomingMessageForModel(received: ReceivedMessageEntry): string {
   const responseLine = received.requestResponse ? "\n\nResponse requested." : "";
   return `Incoming message from session${titlePart} (session: ${received.source.sessionId}${relationPart}):\n\n${received.body}${responseLine}`;
 }
-
-function formatError(error: unknown): string {
-  return error instanceof Error && error.message.trim() ? error.message : String(error);
-}

package/extensions/session-messaging/pi/message-contracts.ts

@@ -19,6 +19,35 @@ export const SEND_MESSAGE_PARAMS = Type.Object({
   ),
 });
 
+export const SEND_MESSAGE_TOOL_DETAILS_SCHEMA = Type.Object({
+  delivered: Type.Literal(true),
+  messageId: Type.String(),
+  target: RECEIVED_MESSAGE_ENDPOINT_SCHEMA,
+  relation: Type.Optional(Type.String()),
+});
+
+export const CANCEL_SESSION_PARAMS = Type.Object({
+  session: Type.String({ description: "Bare UUID for the live session to cancel." }),
+});
+
+export const CANCEL_SESSION_TOOL_DETAILS_SCHEMA = Type.Union([
+  Type.Object({
+    kind: Type.Literal("transport"),
+    delivered: Type.Literal(true),
+    cancelId: Type.String(),
+    target: RECEIVED_MESSAGE_ENDPOINT_SCHEMA,
+    relation: Type.Optional(Type.String()),
+  }),
+  Type.Object({
+    kind: Type.Literal("managed"),
+    accepted: Type.Literal(true),
+    target: RECEIVED_MESSAGE_ENDPOINT_SCHEMA,
+    state: Type.String(),
+    cancelId: Type.Optional(Type.String()),
+    relation: Type.Optional(Type.String()),
+  }),
+]);
+
 export const RECEIVED_MESSAGE_ENTRY_SCHEMA = Type.Object({
   messageId: Type.String(),
   source: RECEIVED_MESSAGE_ENDPOINT_SCHEMA,
@@ -32,5 +61,8 @@ export const RECEIVED_MESSAGE_ENTRY_SCHEMA = Type.Object({
 });
 
 export type SendMessageParams = Static<typeof SEND_MESSAGE_PARAMS>;
+export type SendMessageToolDetails = Static<typeof SEND_MESSAGE_TOOL_DETAILS_SCHEMA>;
+export type CancelSessionParams = Static<typeof CANCEL_SESSION_PARAMS>;
+export type CancelSessionToolDetails = Static<typeof CANCEL_SESSION_TOOL_DETAILS_SCHEMA>;
 export type ReceivedMessageEndpoint = Static<typeof RECEIVED_MESSAGE_ENDPOINT_SCHEMA>;
 export type ReceivedMessageEntry = Static<typeof RECEIVED_MESSAGE_ENTRY_SCHEMA>;

package/extensions/session-messaging/pi/renderer.ts

@@ -1,16 +1,23 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { MessageRenderer } from "@earendil-works/pi-coding-agent";
+import { Box } from "@earendil-works/pi-tui";
+import { ExpandableContentLayout } from "../../shared/rendering/expandable-content-layout.ts";
 import { safeParseTypeBoxValue } from "../../shared/typebox.ts";
-import { SESSION_MESSAGE_CUSTOM_TYPE } from "./incoming-runtime.ts";
+import { buildIncomingMessagePresentation } from "./incoming-message-presenter.ts";
+import { buildIncomingMessageView } from "./incoming-message-view-model.ts";
 import { RECEIVED_MESSAGE_ENTRY_SCHEMA } from "./message-contracts.ts";
-import { createReceivedSessionMessageComponent } from "./message-view.ts";
 
-export function registerSessionMessagingRenderer(pi: ExtensionAPI): void {
-  pi.registerMessageRenderer(SESSION_MESSAGE_CUSTOM_TYPE, (message, options, theme) => {
-    const details = safeParseTypeBoxValue(RECEIVED_MESSAGE_ENTRY_SCHEMA, message.details);
-    if (!details) {
-      return undefined;
-    }
+export const renderIncomingSessionMessage: MessageRenderer = (message, options, theme) => {
+  const details = safeParseTypeBoxValue(RECEIVED_MESSAGE_ENTRY_SCHEMA, message.details);
+  if (!details) {
+    return undefined;
+  }
 
-    return createReceivedSessionMessageComponent(details, options.expanded, theme);
-  });
-}
+  const layout = new ExpandableContentLayout(theme);
+  layout.update(
+    buildIncomingMessagePresentation(buildIncomingMessageView(details), theme),
+    options.expanded,
+  );
+  const box = new Box(1, 1, (text) => theme.bg("toolSuccessBg", text));
+  box.addChild(layout);
+  return box;
+};

package/extensions/session-messaging/pi/send-message-presenter.ts

@@ -0,0 +1,39 @@
+import type { ExpandableContentPresentation } from "../../shared/rendering/expandable-content-layout.ts";
+import type { RenderTheme } from "../../shared/rendering/theme.ts";
+import type { SendMessageViewModel } from "./send-message-view-model.ts";
+
+export function buildSendMessagePresentation(
+  model: SendMessageViewModel,
+  theme: RenderTheme,
+): ExpandableContentPresentation {
+  const target =
+    model.status === "delivered"
+      ? (model.targetSessionName ?? model.targetSessionId)
+      : (model.targetSessionId ?? "[target pending]");
+  const metadata = [
+    model.relation,
+    model.requestResponse ? "response requested" : undefined,
+  ].filter((item): item is string => Boolean(item));
+  const metadataHint = metadata.length > 0 ? ` (${metadata.join(", ")})` : "";
+  const action = model.status === "delivered" ? "delivered to" : "to";
+
+  return {
+    header: `${theme.fg("toolTitle", theme.bold("session_send_message"))} ${theme.fg(
+      "muted",
+      `${action} ${target}${metadataHint}`,
+    )}`,
+    ...(model.status === "delivered"
+      ? {
+          expandedMetadata: [`${theme.bold("session")} ${model.targetSessionId}`],
+        }
+      : {}),
+    ...(model.body
+      ? {
+          body: {
+            text: theme.fg("toolOutput", model.body.replaceAll("\t", "  ")),
+            collapsedRows: 3,
+          },
+        }
+      : {}),
+  };
+}

package/extensions/session-messaging/pi/send-message-view-model.ts

@@ -0,0 +1,54 @@
+import { normalizeOptionalText } from "../../shared/text.ts";
+import type { SendMessageToolDetails } from "./message-contracts.ts";
+
+export interface SendMessageRenderArgs {
+  session?: string | undefined;
+  message?: string | undefined;
+  requestResponse?: boolean | undefined;
+}
+
+export interface SendingMessageViewModel {
+  status: "sending";
+  targetSessionId?: string | undefined;
+  relation?: string | undefined;
+  requestResponse: boolean;
+  body: string;
+}
+
+export interface DeliveredMessageViewModel {
+  status: "delivered";
+  targetSessionId: string;
+  targetSessionName?: string | undefined;
+  relation?: string | undefined;
+  requestResponse: boolean;
+  body: string;
+}
+
+export type SendMessageViewModel = SendingMessageViewModel | DeliveredMessageViewModel;
+
+export function buildSendingMessageView(
+  args: SendMessageRenderArgs | undefined,
+  relation: string | undefined,
+): SendingMessageViewModel {
+  return {
+    status: "sending",
+    targetSessionId: normalizeOptionalText(args?.session),
+    relation,
+    requestResponse: args?.requestResponse === true,
+    body: args?.message ?? "",
+  };
+}
+
+export function buildDeliveredMessageView(
+  args: SendMessageRenderArgs | undefined,
+  details: SendMessageToolDetails,
+): DeliveredMessageViewModel {
+  return {
+    status: "delivered",
+    targetSessionId: details.target.sessionId,
+    targetSessionName: normalizeOptionalText(details.target.sessionName),
+    relation: details.relation,
+    requestResponse: args?.requestResponse === true,
+    body: args?.message?.trim() ?? "",
+  };
+}