@tt-a1i/openpi 0.3.0 → 0.3.1

package/extensions/capabilities/index.ts

@@ -17,7 +17,10 @@ import {
   resetOpenPiToolSurface,
 } from "../shared/tool-surface.ts";
 
-const CapabilitySchema = Type.Enum(OPENPI_CAPABILITY_NAMES);
+const CapabilitySchema = Type.Unsafe<OpenPiCapability>({
+  type: "string",
+  enum: OPENPI_CAPABILITY_NAMES,
+});
 
 const OpenPiLoadToolsParameters = Type.Object({
   groups: Type.Optional(

package/extensions/subagents/index.ts

@@ -95,8 +95,7 @@ import {
   SUBAGENT_WAIT_PARAMETER_DESCRIPTIONS,
   SUBAGENT_WAIT_TOOL_DESCRIPTION,
 } from "./src/prompt.ts";
-import { createDeferredResultDelivery } from "./src/result-delivery.ts";
-import { resultDeliveryOptions } from "../background-terminals/src/result-delivery.ts";
+import { createSubagentResultDelivery } from "./src/result-delivery.ts";
 import {
   effectiveChildToolAllowlist,
   resolveStandaloneChildProjectTrust,
@@ -210,7 +209,7 @@ export function createSubagentResultDispatcher(
   pi: ExtensionAPI,
   outputFor: (snap: SubagentSnapshot) => string = truncatedOutput,
 ) {
-  return (snaps: readonly SubagentSnapshot[], wake: boolean) => {
+  return (snaps: readonly SubagentSnapshot[]) => {
     if (snaps.length === 0) return;
     const content = snaps
       .map((snap) =>
@@ -249,7 +248,7 @@ export function createSubagentResultDispatcher(
         display: false,
         details,
       },
-      resultDeliveryOptions(wake),
+      { deliverAs: "followUp", triggerTurn: true },
     );
   };
 }
@@ -322,8 +321,14 @@ export default function (pi: ExtensionAPI) {
   let requestWidgetRender: (() => void) | undefined;
   let navigationLayerRegistered = false;
   let dashboardOpen = false;
-  const resultDelivery = createDeferredResultDelivery<SubagentSnapshot>();
   const dispatchResults = createSubagentResultDispatcher(pi);
+  const resultDelivery = createSubagentResultDelivery<SubagentSnapshot>({
+    isIdle: () => sessionContext?.isIdle() === true,
+    // Every unconsumed fire-and-forget result must reach the parent. The
+    // delivery coordinator batches results that settled while it was busy.
+    deliver: dispatchResults,
+  });
+  pi.on("agent_settled", () => resultDelivery.parentSettled());
   const hideLifecycleTools = () =>
     patchOwnedTools(pi, "subagents", {
       disable: OPENPI_TOOL_SURFACE.subagents.deferred,
@@ -436,25 +441,6 @@ export default function (pi: ExtensionAPI) {
     navigationLayerRegistered = true;
   };
 
-  /**
-   * `wake` decides whether this costs the model a turn. A subagent that
-   * settled while the model sits idle is the result it is waiting on. A
-   * backlog that piled up while it worked is not: waking once per stale
-   * subagent forces a turn each, and the model can only answer "that one
-   * already finished". `nextTurn` still enters context with the user's next
-   * message, without demanding a reply.
-   */
-  const deliverResults = (
-    snaps: readonly SubagentSnapshot[],
-    wake: boolean,
-  ) => {
-    dispatchResults(snaps, wake);
-  };
-
-  const flushResults = (wake: boolean) => {
-    deliverResults(resultDelivery.drain(), wake);
-  };
-
   const deliverBtwResult = (snap: SubagentSnapshot) => {
     // appendEntry is a synchronous SessionManager operation and emits an
     // entry_appended event, so it is safe while the parent is streaming and
@@ -500,10 +486,10 @@ export default function (pi: ExtensionAPI) {
     // subagent_wait can consume it before agent_settled flushes follow-ups.
     // Defer a copy: the live snapshot keeps mutating if the subagent is
     // restarted before the deferred result flushes.
+    // The delivery coordinator closes both sides of the wake-up race: it
+    // flushes now if the parent is already idle, otherwise the parent's next
+    // agent_settled edge rechecks this same pending Map.
     resultDelivery.defer({ ...snap, meta: { ...snap.meta } });
-    // Settled while the model sits idle: it has nothing else in flight, so
-    // this is the result it is waiting on — wake it.
-    if (sessionContext?.isIdle()) flushResults(true);
   };
 
   pi.on("session_start", (_event, ctx) => {
@@ -530,10 +516,6 @@ export default function (pi: ExtensionAPI) {
     managerPromise?.then(updateStatus).catch(() => undefined);
   });
 
-  // These settled while the model was working on something else, so they go
-  // into context without forcing a turn per stale subagent.
-  pi.on("agent_settled", () => flushResults(false));
-
   pi.on("session_shutdown", async () => {
     if (navigationLayerRegistered) {
       removeEditorLayer(pi, "subagents");

package/extensions/subagents/src/result-delivery.ts

@@ -1,17 +1,62 @@
-export function createDeferredResultDelivery<T extends { id: string }>() {
+export interface SubagentResultDeliveryOptions<T> {
+  /** True only when the parent has no run or queued continuation in flight. */
+  readonly isIdle: () => boolean;
+  /** Deliver one drained batch and wake the parent. */
+  readonly deliver: (results: readonly T[]) => void;
+}
+
+/**
+ * One-shot result delivery for fire-and-forget subagents.
+ *
+ * The tool contract promises that a settled child re-invokes the parent. A
+ * child that settles while the parent is busy therefore remains retractable
+ * until the parent's `agent_settled` event, but it must never be downgraded to
+ * a `nextTurn` message that needs another user prompt. There are two symmetric
+ * wake-up edges so no ordering can lose the notification:
+ *
+ * 1. child settles after the parent became idle -> `defer` flushes now;
+ * 2. parent settles after the child -> `parentSettled` flushes the batch.
+ *
+ * The parent boundary wakes even if an earlier extension handler has already
+ * started another turn: Pi queues the follow-up into that active run.
+ *
+ * The Map is the one-shot gate: `subagent_wait` may consume a result before it
+ * is delivered, and whichever path drains first prevents duplicate delivery.
+ */
+export function createSubagentResultDelivery<T extends { id: string }>(
+  options: SubagentResultDeliveryOptions<T>,
+) {
   const pending = new Map<string, T>();
 
+  const flush = () => {
+    if (pending.size === 0) return;
+    const results = [...pending.values()];
+    pending.clear();
+    try {
+      options.deliver(results);
+    } catch (error) {
+      // A synchronous session teardown may reject append/send. Preserve the
+      // original batch ahead of anything deferred re-entrantly while delivery
+      // ran, so a later boundary can retry without loss or reordering.
+      const current = [...pending.values()];
+      pending.clear();
+      for (const result of results) pending.set(result.id, result);
+      for (const result of current) pending.set(result.id, result);
+      throw error;
+    }
+  };
+
   return {
     defer(result: T) {
       pending.set(result.id, result);
+      if (options.isIdle()) flush();
     },
     consume(ids: Iterable<string>) {
       for (const id of ids) pending.delete(id);
     },
-    drain() {
-      const results = [...pending.values()];
-      pending.clear();
-      return results;
+    /** Flush at the authoritative parent boundary. */
+    parentSettled() {
+      flush();
     },
     clear() {
       pending.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tt-a1i/openpi",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "OpenPI — a Pi-native multi-agent workbench with background execution, isolated subagents, replay-safe workflows, goals, tasks, and observable TUI",
   "license": "MIT",
   "author": "tt-a1i",