@hachej/boring-agent 0.1.93 → 0.1.94

package/dist/{chunk-CJ2BW2W2.js → chunk-EOMY2HDT.js}

@@ -42,6 +42,7 @@ var AGENT_EFFECT_METHODS = {
 };
 function withAgentEffectAdmission(service, admit) {
   return {
+    ...service.ensurePiSessionBound ? { ensurePiSessionBound: (ctx, sessionId) => service.ensurePiSessionBound(ctx, sessionId) } : {},
     ...service.listSessions ? { listSessions: (ctx, options) => service.listSessions(ctx, options) } : {},
     async createSession(ctx, init) {
       await admit(ctx);

package/dist/{chunk-4TKUT7IL.js → chunk-N4AATPH7.js}

@@ -11,7 +11,7 @@ import {
   AgentEffectAdmissionError,
   createAgentRuntimeBridge,
   isObservedSynchronousServiceError
-} from "./chunk-CJ2BW2W2.js";
+} from "./chunk-EOMY2HDT.js";
 import {
   AgentDefinitionValidationError,
   AgentDeploymentValidationError,
@@ -4605,6 +4605,18 @@ var HarnessPiChatService = class {
     const seq = envelope?.chunk?.seq;
     return typeof seq === "number" && Number.isInteger(seq) && seq >= 0 ? seq : tailIndex + 1;
   }
+  /**
+   * Validate the persisted session identity and instantiate its lazily-created
+   * Pi adapter under the same full cache key. This is intentionally a narrow
+   * trusted-host seam rather than another browser route.
+   */
+  async ensurePiSessionBound(ctx, sessionId) {
+    this.lifecycle.assertOpen();
+    await this.assertCanAccessSession(ctx, sessionId);
+    const adapter = await this.getAdapter(ctx, sessionId, "", { authorize: false });
+    await this.ensureChannel(ctx, sessionId, adapter);
+    this.lifecycle.assertOpen();
+  }
   async assertCanAccessSession(ctx, sessionId) {
     try {
       await this.sessionStore.load(toSessionCtx(ctx), sessionId);
@@ -7311,7 +7323,16 @@ var EmbeddedAgentGateway = class {
         });
         this.runtime.activity.set(claim.workspaceScopeId, ref, "running");
         return { ...receipt, disposition: "prompt" };
-      }, true);
+      }, {
+        duplicateReceipt: true,
+        guard: async () => await this.promptAdmission(
+          scope,
+          claim,
+          ref,
+          command.requestId,
+          command.requireIdle === true
+        )
+      });
     }
     return await this.sessionEffect(ref, claim, "session.followup", command.requestId, command, async () => {
       const receipt = await service.followUp(context(claim, command.requestId), ref.sessionId, {
@@ -7321,7 +7342,7 @@ var EmbeddedAgentGateway = class {
         clientSeq: command.clientSeq
       });
       return { ...receipt, disposition: "followup" };
-    }, true);
+    }, { duplicateReceipt: true });
   }
   async renameSession(input) {
     const claim = await this.verify(input.scope);
@@ -7395,16 +7416,18 @@ var EmbeddedAgentGateway = class {
     if (!summary) throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND, "session was not found");
     return summary;
   }
-  sessionEffect(ref, claim, operation, requestId, payload, action, duplicateReceipt = false, legacyAlias = false) {
+  sessionEffect(ref, claim, operation, requestId, payload, action, options = {}) {
     return this.effect(
       claim,
       operation,
       sessionTarget(ref),
       requestId,
       payload,
-      () => this.withWriter(claim.workspaceScopeId, ref, action),
-      duplicateReceipt,
-      legacyAlias
+      action,
+      {
+        ...options,
+        serialize: (effect) => this.withWriter(claim.workspaceScopeId, ref, effect)
+      }
     );
   }
   /** Internal legacy-alias seam; never exposed through the public Gateway contract. */
@@ -7419,8 +7442,7 @@ var EmbeddedAgentGateway = class {
         input.requestId,
         input.payload,
         input.action,
-        false,
-        true
+        { legacyAlias: true }
       );
     }
     if (input.target.kind !== "session") throw new TypeError(`${input.operation} requires a session target`);
@@ -7431,12 +7453,20 @@ var EmbeddedAgentGateway = class {
       input.requestId,
       input.payload,
       input.action,
-      false,
-      true
+      {
+        legacyAlias: true,
+        guard: input.retryableGuard
+      }
     );
   }
-  async effect(claim, operation, target, requestId, payload, action, duplicateReceipt = false, legacyAlias = false) {
+  async effect(claim, operation, target, requestId, payload, action, options = {}) {
     this.assertOpen();
+    const {
+      duplicateReceipt = false,
+      legacyAlias = false,
+      serialize,
+      guard
+    } = options;
     const key = {
       workspaceScopeId: claim.workspaceScopeId,
       authSubjectId: claim.authSubjectId,
@@ -7452,8 +7482,9 @@ var EmbeddedAgentGateway = class {
     const id = requestKeyString(key);
     const existing = this.effects.get(id);
     if (existing) return this.replayReceipt(await existing, duplicateReceipt);
-    const running = this.runtime.trackEffect((async () => {
+    const execute = async () => {
       const current = await this.runtime.ledger.read(key);
+      let admissionReceipt;
       if (current?.state === "pending-admission") {
         const admission = await this.runtime.effectAdmission.admit({ key, digest: digest2, scope: claim, operation, target });
         if (admission.type === "retryable") throw gatewayError(admission.error);
@@ -7461,71 +7492,87 @@ var EmbeddedAgentGateway = class {
           await this.runtime.ledger.reject(key, { kind: "gateway", error: admission.error });
           throw gatewayError(admission.error);
         }
-        await this.runtime.ledger.acceptAdmission(key, admission.admissionReceipt);
-      }
-      await this.runtime.ledger.beginEffect(key);
-      let actionResult;
-      try {
-        actionResult = action();
-      } catch (error) {
-        if (legacyAlias) {
-          if (error instanceof AgentEffectAdmissionError) {
+        admissionReceipt = admission.admissionReceipt;
+      }
+      const runEffect = async () => {
+        const locked = await this.runtime.ledger.read(key);
+        if (locked?.state === "pending-admission") {
+          if (admissionReceipt === void 0) {
+            throw new AgentGatewayError(
+              AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
+              "request admission receipt was unavailable"
+            );
+          }
+          const retryableGuardError = await guard?.();
+          if (retryableGuardError) throw gatewayError(retryableGuardError);
+          await this.runtime.ledger.acceptAdmission(key, admissionReceipt);
+        }
+        await this.runtime.ledger.beginEffect(key);
+        let actionResult;
+        try {
+          actionResult = action();
+        } catch (error) {
+          if (legacyAlias) {
+            if (error instanceof AgentEffectAdmissionError) {
+              const details = projectJson(error.details);
+              const failure2 = {
+                kind: "legacy-admission",
+                code: error.code,
+                statusCode: 500,
+                message: error.message,
+                ...details === void 0 ? {} : { details }
+              };
+              await this.runtime.ledger.reject(key, failure2);
+              throw this.failure(failure2, true);
+            }
+            const failure = legacyServiceFailure(error);
+            await this.runtime.ledger.reject(key, failure);
+            throw this.failure(failure, true);
+          }
+          const unknown = new AgentGatewayError(
+            AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
+            "effect outcome could not be safely replayed"
+          );
+          await this.runtime.ledger.markOutcomeUnknown(key, unknown.toJSON()).catch(() => {
+          });
+          throw error;
+        }
+        try {
+          const receipt = await actionResult;
+          this.runtime.assertOpen();
+          await this.runtime.ledger.complete(key, receipt);
+          return receipt;
+        } catch (error) {
+          if (legacyAlias && error instanceof AgentEffectAdmissionError) {
             const details = projectJson(error.details);
-            const failure2 = {
+            const failure = {
               kind: "legacy-admission",
               code: error.code,
               statusCode: 500,
               message: error.message,
               ...details === void 0 ? {} : { details }
             };
-            await this.runtime.ledger.reject(key, failure2);
-            throw this.failure(failure2, true);
+            await this.runtime.ledger.reject(key, failure);
+            throw this.failure(failure, true);
           }
-          const failure = legacyServiceFailure(error);
-          await this.runtime.ledger.reject(key, failure);
-          throw this.failure(failure, true);
-        }
-        const unknown = new AgentGatewayError(
-          AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
-          "effect outcome could not be safely replayed"
-        );
-        await this.runtime.ledger.markOutcomeUnknown(key, unknown.toJSON()).catch(() => {
-        });
-        throw error;
-      }
-      try {
-        const receipt = await actionResult;
-        this.runtime.assertOpen();
-        await this.runtime.ledger.complete(key, receipt);
-        return receipt;
-      } catch (error) {
-        if (legacyAlias && error instanceof AgentEffectAdmissionError) {
-          const details = projectJson(error.details);
-          const failure = {
-            kind: "legacy-admission",
-            code: error.code,
-            statusCode: 500,
-            message: error.message,
-            ...details === void 0 ? {} : { details }
-          };
-          await this.runtime.ledger.reject(key, failure);
-          throw this.failure(failure, true);
-        }
-        if (legacyAlias && (isObservedSynchronousServiceError(error) || isKnownLegacyServiceFailure(error))) {
-          const failure = legacyServiceFailure(error);
-          await this.runtime.ledger.reject(key, failure);
-          throw this.failure(failure, true);
+          if (legacyAlias && (isObservedSynchronousServiceError(error) || isKnownLegacyServiceFailure(error))) {
+            const failure = legacyServiceFailure(error);
+            await this.runtime.ledger.reject(key, failure);
+            throw this.failure(failure, true);
+          }
+          const unknown = new AgentGatewayError(
+            AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
+            "effect outcome could not be safely replayed"
+          );
+          await this.runtime.ledger.markOutcomeUnknown(key, unknown.toJSON()).catch(() => {
+          });
+          if (legacyAlias) throw unknown;
+          throw error;
         }
-        const unknown = new AgentGatewayError(
-          AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
-          "effect outcome could not be safely replayed"
-        );
-        await this.runtime.ledger.markOutcomeUnknown(key, unknown.toJSON()).catch(() => {
-        });
-        if (legacyAlias) throw unknown;
-        throw error;
-      }
-    })(), key);
+      };
+      return serialize ? serialize(runEffect) : runEffect();
+    };
+    const running = this.runtime.trackEffect(execute(), key);
     this.effects.set(id, running);
     try {
       return await running;
@@ -7558,6 +7605,20 @@ var EmbeddedAgentGateway = class {
       "effect admission was rejected"
     );
   }
+  async promptAdmission(scope, claim, ref, requestId, requireIdle) {
+    const binding = await this.bindingForSession(scope, claim, ref);
+    const snapshot = await binding.composition.service.readState(
+      context(claim, requestId, binding.scope.identity),
+      ref.sessionId
+    );
+    const admissible = requireIdle ? snapshot.status === "idle" : snapshot.status === "idle" || snapshot.status === "error";
+    if (admissible) return void 0;
+    return new AgentGatewayError(
+      AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE,
+      requireIdle ? "session is not idle" : "prompt is invalid in current state",
+      { status: snapshot.status }
+    ).toJSON();
+  }
   async withWriter(workspaceScopeId, ref, action) {
     const key = sessionKey(workspaceScopeId, ref);
     const previous = this.writerTails.get(key) ?? Promise.resolve();
@@ -8167,6 +8228,7 @@ var PromptBodySchema = z4.object({
   clientNonce: NonEmptyString.max(128),
   content: NonEmptyString.max(1e6),
   displayContent: NonEmptyString.max(1e6).optional(),
+  requireIdle: z4.literal(true).optional(),
   model: ChatModelSelectionSchema.optional(),
   thinkingLevel: z4.enum(["off", "low", "medium", "high"]).optional(),
   attachments: z4.array(ChatAttachmentPayloadSchema).max(20).optional()
@@ -8486,7 +8548,8 @@ function createLegacyPiChatCompatibilityService(input) {
     target: options.target,
     requestId: options.requestId,
     payload: jsonProjection(options.payload),
-    action: options.action
+    action: options.action,
+    ...options.retryableGuard ? { retryableGuard: options.retryableGuard } : {}
   });
   return {
     ...input.service.listSessions ? { listSessions: (ctx, options) => input.service.listSessions(ctx, options) } : {},
@@ -8517,6 +8580,17 @@ function createLegacyPiChatCompatibilityService(input) {
       target: sessionTarget2(input.agentTypeId, sessionId),
       requestId: requestIdForPayload(ctx, payload.clientNonce),
       payload,
+      ...payload.requireIdle ? {
+        retryableGuard: async () => {
+          const snapshot = await input.service.readState(ctx, sessionId);
+          if (snapshot.status === "idle") return void 0;
+          return new AgentGatewayError(
+            AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE,
+            "session is not idle",
+            { status: snapshot.status }
+          ).toJSON();
+        }
+      } : {},
       action: () => input.service.prompt(ctx, sessionId, payload)
     }),
     followUp: (ctx, sessionId, payload) => effect({
@@ -9732,7 +9806,7 @@ async function dispatchGatewayInput(binding, input) {
     scope: binding.scope,
     agentTypeId: binding.agentTypeId,
     requestId,
-    title: contentToText(input.content ?? input.message).slice(0, 80) || void 0
+    title: input.title?.trim() || contentToText(input.content ?? input.message).slice(0, 80) || void 0
   });
   const connection = await binding.gateway.connectSession({
     scope: binding.scope,
@@ -10897,6 +10971,75 @@ async function mountOrderedAgentHostLegacyRoutes(input) {
   );
 }
 
+// src/server/trustedPiSessionBinding.ts
+async function bindTrustedPiSession(input) {
+  const sessionContext = trustedPiSessionContext(input.ctx, input.request, input.requested);
+  await input.withServices(async ({ binding }) => {
+    if (!binding.ensurePiSessionBound) {
+      throw createWorkspaceAgentDispatcherError(
+        ErrorCode.enum.INTERNAL_ERROR,
+        "Pi session binding is unavailable",
+        500
+      );
+    }
+    return await binding.ensurePiSessionBound(sessionContext, input.sessionId);
+  });
+  return {
+    visibleUserMessageTarget: {
+      async isIdle() {
+        return await input.withServices(async ({ binding }) => {
+          const snapshot = await binding.readState(sessionContext, input.sessionId);
+          return snapshot.status === "idle";
+        });
+      },
+      async sendIfIdle(sendInput) {
+        const requestId = sendInput.requestId.trim();
+        if (!requestId) throw new TypeError("requestId must be a non-empty string");
+        try {
+          const receipt = await input.withServices(async ({ prompt }) => await prompt.prompt(
+            sessionContext,
+            input.sessionId,
+            {
+              message: sendInput.message,
+              displayMessage: sendInput.displayMessage ?? sendInput.message,
+              clientNonce: requestId,
+              requireIdle: true
+            }
+          ));
+          return {
+            status: "accepted",
+            cursor: receipt.cursor,
+            ...receipt.duplicate ? { duplicate: true } : {}
+          };
+        } catch (error) {
+          if (error instanceof AgentGatewayError && error.code === AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE) {
+            return { status: "busy" };
+          }
+          if (isGoneSessionError(error)) return { status: "gone" };
+          throw error;
+        }
+      }
+    }
+  };
+}
+function isGoneSessionError(error) {
+  const code = error?.code;
+  return code === AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND || code === AgentGatewayErrorCode.AGENT_SCOPE_DENIED || code === AgentGatewayErrorCode.AGENT_SESSION_RUNTIME_SCOPE_MISMATCH || code === ErrorCode.enum.SESSION_NOT_FOUND || code === ErrorCode.enum.UNAUTHORIZED;
+}
+function trustedPiSessionContext(ctx, request, requested) {
+  if (requested?.workspaceId && requested.workspaceId !== ctx.workspaceId) {
+    throw createWorkspaceAgentDispatcherError(ErrorCode.enum.UNAUTHORIZED, "Pi session workspace context mismatch", 401);
+  }
+  if (requested?.userId && requested.userId !== ctx.userId) {
+    throw createWorkspaceAgentDispatcherError(ErrorCode.enum.UNAUTHORIZED, "Pi session user context mismatch", 401);
+  }
+  return {
+    workspaceId: requested?.workspaceId ?? ctx.workspaceId,
+    authSubject: requested?.userId ?? ctx.userId,
+    requestId: request?.id ?? `trusted:${ctx.workspaceId}:${ctx.userId}`
+  };
+}
+
 // src/server/agentHostLegacyRouteRuntime.ts
 var DEFAULT_WORKSPACE_ID6 = "default";
 var STANDARD_AGENT_TOOL_NAMES = ["bash", "read", "write", "edit", "find", "grep", "ls"];
@@ -11391,6 +11534,11 @@ async function mountAgentHostLegacyRouteRuntime(app, opts, mountInput, scopePoli
       tools,
       readyTracker,
       piChatService: composition.service,
+      trustedPiChatService: agentHost.createPiChatService({
+        service: composition.service,
+        scope: authorizedScope,
+        agentTypeId: defaultAgentTypeId
+      }),
       authorizedScope,
       hostScope
     };
@@ -11526,6 +11674,7 @@ async function mountAgentHostLegacyRouteRuntime(app, opts, mountInput, scopePoli
           throw error;
         }
         return {
+          binding,
           dispatcher: createBoundWorkspaceAgentDispatcher({
             gateway: agentHost.gateway,
             scope: binding.authorizedScope,
@@ -11538,6 +11687,25 @@ async function mountAgentHostLegacyRouteRuntime(app, opts, mountInput, scopePoli
       binding = await getOrCreateRuntimeBinding(boundCtx.workspaceId, void 0, { trustedCtx: boundCtx });
     }
   }
+  async function ensureTrustedPiSessionBound(initialBinding, boundCtx, boundSessionId, request, requestedSessionCtx) {
+    return await bindTrustedPiSession({
+      ctx: boundCtx,
+      request,
+      sessionId: boundSessionId,
+      requested: requestedSessionCtx,
+      withServices: async (effect) => {
+        const operation = await acquireDispatcherOperation(initialBinding, boundCtx, request);
+        try {
+          return await effect({
+            binding: operation.binding.piChatService,
+            prompt: operation.binding.trustedPiChatService
+          });
+        } finally {
+          operation.release();
+        }
+      }
+    });
+  }
   function createLeasedWorkspaceAgentDispatcher(initialBinding, boundCtx, request) {
     return {
       async dispatch(input) {
@@ -11616,14 +11784,28 @@ async function mountAgentHostLegacyRouteRuntime(app, opts, mountInput, scopePoli
         }
         return {
           dispatcher: createLeasedWorkspaceAgentDispatcher(staticBinding, boundCtx, options?.request),
-          workspace: staticBinding.runtimeBundle.workspace
+          workspace: staticBinding.runtimeBundle.workspace,
+          bindPiSession: async (boundSessionId, requestedSessionCtx) => await ensureTrustedPiSessionBound(
+            staticBinding,
+            boundCtx,
+            boundSessionId,
+            options?.request,
+            requestedSessionCtx
+          )
         };
       }
       const binding = await getOrCreateRuntimeBinding(boundCtx.workspaceId, options?.request, { trustedCtx: boundCtx });
       bindingLifecycle.assertAdmission(boundCtx.workspaceId, options?.request);
       return {
         dispatcher: createLeasedWorkspaceAgentDispatcher(binding, boundCtx, options?.request),
-        workspace: binding.runtimeBundle.workspace
+        workspace: binding.runtimeBundle.workspace,
+        bindPiSession: async (boundSessionId, requestedSessionCtx) => await ensureTrustedPiSessionBound(
+          binding,
+          boundCtx,
+          boundSessionId,
+          options?.request,
+          requestedSessionCtx
+        )
       };
     }
   });

package/dist/core/index.d.ts

@@ -1,8 +1,8 @@
 import { A as AgentHarness, a as AgentReadiness, b as Agent } from '../harness-Cc48o6uS.js';
 export { c as AGENT_NOT_IMPLEMENTED_UNTIL_T1, d as AgentActor, e as AgentCoreHarness, f as AgentCoreHarnessFactory, g as AgentCorePromptInput, h as AgentCoreSessionAdapter, i as AgentCoreSessionSnapshot, j as AgentEvent, k as AgentMessageContent, l as AgentMessagePart, m as AgentNotImplementedError, n as AgentReadinessStatus, o as AgentResolveInputResponse, p as AgentSendInput, q as AgentStartReceipt, r as AgentStreamOptions } from '../harness-Cc48o6uS.js';
 import { S as SessionStore } from '../piChatEvent-BsMp3MSo.js';
-import { A as AgentCoreSessionService, a as AgentEffectAdmission } from '../piChatSessionService-BrPqKrpY.js';
-export { b as AGENT_EFFECT_METHODS, c as AgentEffectAdmissionError, P as PiChatEventStreamResult, d as PiChatEventStreamSubscription, e as PiChatEventSubscriber, f as PiChatReplayRangeError, g as PiChatSessionService, h as PiSessionCreateInit, i as PiSessionRequestContext, w as withAgentEffectAdmission } from '../piChatSessionService-BrPqKrpY.js';
+import { A as AgentCoreSessionService, a as AgentEffectAdmission } from '../piChatSessionService-C0KbcGw9.js';
+export { b as AGENT_EFFECT_METHODS, c as AgentEffectAdmissionError, P as PiChatEventStreamResult, d as PiChatEventStreamSubscription, e as PiChatEventSubscriber, f as PiChatReplayRangeError, g as PiChatSessionService, h as PiSessionCreateInit, i as PiSessionRequestContext, w as withAgentEffectAdmission } from '../piChatSessionService-C0KbcGw9.js';
 import '@mariozechner/pi-coding-agent';
 import 'zod';
 

package/dist/core/index.js

@@ -3,7 +3,7 @@ import {
   AgentEffectAdmissionError,
   createAgent,
   withAgentEffectAdmission
-} from "../chunk-CJ2BW2W2.js";
+} from "../chunk-EOMY2HDT.js";
 import {
   AGENT_NOT_IMPLEMENTED_UNTIL_T1,
   AgentNotImplementedError

package/dist/{errors-C38f6pol.d.ts → errors-G6T6S7PQ.d.ts}

@@ -101,6 +101,8 @@ interface AgentPromptCommand {
     readonly clientNonce: string;
     readonly content: string;
     readonly displayContent?: string;
+    /** Require an actually idle Pi session; busy is a retryable admission result. */
+    readonly requireIdle?: true;
     readonly model?: ChatModelSelection;
     readonly thinkingLevel?: ThinkingLevel;
     readonly attachments?: readonly ChatAttachmentPayload[];

package/dist/front/index.d.ts

@@ -1,7 +1,7 @@
+import { T as ToolUiMetadata, B as BoringChatPart, a as BoringChatMessage, P as PiChatStatus, Q as QueuedUserMessage, C as ChatError, b as PiChatEvent, c as PromptPayload, d as PromptReceipt, F as FollowUpPayload, e as FollowUpReceipt, f as QueueClearPayload, g as QueueClearReceipt, I as InterruptPayload, h as CommandReceipt, i as StopPayload, j as StopReceipt, k as SessionSummary } from '../piChatEvent-BsMp3MSo.js';
 import * as react from 'react';
 import { ComponentProps, HTMLAttributes, FormEvent, ReactNode, ComponentType } from 'react';
 import { FileUIPart, ChatStatus, UIMessage } from 'ai';
-import { T as ToolUiMetadata, B as BoringChatPart, a as BoringChatMessage, P as PiChatStatus, Q as QueuedUserMessage, C as ChatError, b as PiChatEvent, c as PromptPayload, d as PromptReceipt, F as FollowUpPayload, e as FollowUpReceipt, f as QueueClearPayload, g as QueueClearReceipt, I as InterruptPayload, h as CommandReceipt, i as StopPayload, j as StopReceipt, k as SessionSummary } from '../piChatEvent-BsMp3MSo.js';
 import { InputGroupAddon, InputGroupButton, InputGroupTextarea, Button, Collapsible, CollapsibleContent, CollapsibleTrigger } from '@hachej/boring-ui-kit';
 import { Streamdown } from 'streamdown';
 import { StickToBottom } from 'use-stick-to-bottom';
@@ -176,6 +176,11 @@ interface SlashCommand {
     source?: 'local' | 'extension' | 'prompt' | 'skill';
     /** Originating plugin/package name (when known), shown as a tag. */
     sourcePlugin?: string;
+    /**
+     * Narrow browser-local escape hatch for independent controls that must remain
+     * usable while Pi is running. The predicate must admit only exact safe subcommands.
+     */
+    allowWhileBusy?: (args: string) => boolean;
     handler: SlashCommandHandler;
 }
 interface SlashCommandContext {
@@ -210,7 +215,7 @@ declare function createCommandRegistry(initial?: SlashCommand[]): CommandRegistr
 
 declare const builtinCommands: SlashCommand[];
 
-type ToolState = 'input-streaming' | 'input-available' | 'approval-requested' | 'approval-responded' | 'output-available' | 'output-error' | 'output-denied' | 'aborted';
+type ToolState$1 = 'input-streaming' | 'input-available' | 'approval-requested' | 'approval-responded' | 'output-available' | 'output-error' | 'output-denied' | 'aborted';
 
 type BoringToolCallPart = Extract<BoringChatPart, {
     type: 'tool-call';
@@ -220,25 +225,25 @@ interface ToolRendererResolution {
     source: 'rendererId' | 'toolName' | 'fallback';
     requestedRendererId?: string;
 }
-interface ToolPart {
+interface ToolPart$1 {
     /** Neutral render-model type. Legacy `tool-<name>` values are accepted at the renderer boundary. */
     type: 'tool-call' | `tool-${string}` | 'dynamic-tool';
     toolName: string;
     /** Stable tool call id; for Pi-native BoringChatPart this is BoringChatPart.id. */
     toolCallId: string;
-    state: ToolState;
+    state: ToolState$1;
     input?: unknown;
     output?: unknown;
     errorText?: string;
     ui?: ToolUiMetadata;
     rendererResolution?: ToolRendererResolution;
 }
-type ToolRenderablePart = ToolPart | BoringToolCallPart | unknown;
-type ToolRenderer = (part: ToolPart) => ReactNode;
+type ToolRenderablePart = ToolPart$1 | BoringToolCallPart | unknown;
+type ToolRenderer = (part: ToolPart$1) => ReactNode;
 type ToolRendererOverrides = Partial<Record<string, ToolRenderer>>;
 declare const defaultToolRenderers: Record<string, ToolRenderer>;
 declare function mergeToolRenderers(overrides?: ToolRendererOverrides): Record<string, ToolRenderer>;
-declare function resolveToolRenderer(toolNameOrPart: string | ToolPart, overrides?: ToolRendererOverrides): ToolRenderer;
+declare function resolveToolRenderer(toolNameOrPart: string | ToolPart$1, overrides?: ToolRendererOverrides): ToolRenderer;
 
 type ChatPanelRuntimeDependenciesWarmupStatus = {
     state: 'preparing' | 'ready' | 'failed';
@@ -770,6 +775,37 @@ interface AgentCommandOptions {
 }
 declare function getAgentCommands(options?: AgentCommandOptions): AgentCommandContribution[];
 
+type ComposerDraftUpdate = (currentDraft: string) => string;
+interface ComposerActionContributionProps {
+    updateDraft(update: ComposerDraftUpdate, options?: {
+        focus?: boolean;
+    }): void;
+}
+interface ComposerContribution {
+    id: string;
+    Top?: ComponentType;
+    Action?: ComponentType<ComposerActionContributionProps>;
+    commands?: readonly SlashCommand[];
+}
+declare function ComposerContributionProvider({ contribution, children, }: {
+    contribution: ComposerContribution;
+    children: ReactNode;
+}): react.JSX.Element;
+
+interface ChatMessageContributionProps {
+    message: BoringChatMessage;
+}
+interface ChatMessageContribution {
+    id: string;
+    /** Pure, hook-free claim predicate. */
+    matches(message: BoringChatMessage): boolean;
+    Component: ComponentType<ChatMessageContributionProps>;
+}
+declare function ChatMessageContributionProvider({ contribution, children, }: {
+    contribution: ChatMessageContribution;
+    children: ReactNode;
+}): react.JSX.Element;
+
 declare function mergeShadcnToolRenderers(overrides?: ToolRendererOverrides): Record<string, ToolRenderer>;
 
 type GroupedToolEntry = {
@@ -832,6 +868,30 @@ type CodeBlockProps = HTMLAttributes<HTMLDivElement> & {
 };
 declare const CodeBlock: ({ code, language, showLineNumbers, className, children, ...props }: CodeBlockProps) => react.JSX.Element;
 
+type ToolProps = ComponentProps<typeof Collapsible>;
+declare const Tool: ({ className, ...props }: ToolProps) => react.JSX.Element;
+type ToolState = "input-streaming" | "input-available" | "approval-requested" | "approval-responded" | "output-available" | "output-denied" | "output-error" | "aborted";
+type ToolPart = {
+    type: `tool-${string}` | "dynamic-tool" | "tool-call";
+    state: ToolState;
+    toolName?: string;
+    input?: unknown;
+    output?: unknown;
+    errorText?: string;
+};
+type ToolHeaderProps = {
+    title?: ReactNode;
+    className?: string;
+    icon?: ReactNode;
+    type: ToolPart["type"];
+    state: ToolState;
+    toolName?: string;
+    statusLabel?: string;
+};
+declare const ToolHeader: ({ className, title, type, state, icon, toolName, statusLabel, ...props }: ToolHeaderProps) => react.JSX.Element;
+type ToolContentProps = ComponentProps<typeof CollapsibleContent>;
+declare const ToolContent: ({ className, ...props }: ToolContentProps) => react.JSX.Element;
+
 declare function cn(...inputs: ClassValue[]): string;
 
-export { type AgentCommandContribution, type AgentCommandOptions, type AgentPluginReloadResult, ArtifactOpenProvider, type AvailableModel, ChatEmptyState, type ChatEmptyStateProps, PiChatPanel as ChatPanel, type PiChatPanelProps as ChatPanelProps, type ChatSuggestion, CodeBlock, type CommandRegistry, type ComposerBlocker, type ComposerBlockerAction, Conversation, ConversationContent, ConversationScrollButton, DebugDrawer, type GroupedToolEntry, Message, MessageAction, MessageActions, MessageContent, MessageResponse, ModelPickerMenu, ModelSelect, ModelSelectTrigger, type ModelSelection, type OpenArtifactHandler, type ParsedCommand, PiChatPanel, type PiChatPanelProps, SessionBrowser as PiSessionBrowser, type PiSessionCreateInit, SessionList as PiSessionList, type PiSessionSearchItem, type PiSessionSearchOptions, type PiSessionSearchSortMode, PromptInput, PromptInputFooter, PromptInputSubmit, PromptInputTextarea, Reasoning, ReasoningContent, ReasoningTrigger, type SessionListProps, type SlashCommand, type SlashCommandContext, type ThinkingLevel, ThinkingSelect, ToolCallGroup, type ToolPart, type ToolRenderer, type ToolRendererOverrides, type UploadFileOptions, type UploadFileResult, type UsePiSessionsOptions, type UsePiSessionsResult, activeSessionStorageKey, builtinCommands, clearActiveSessionId, cn, createCommandRegistry, defaultChatSuggestions, defaultToolRenderers, getAgentCommands, matchPiSessionSearch, mergeShadcnToolRenderers, mergeToolRenderers, parsePiSessionSearchQuery, parseSlashCommand, readActiveSessionId, resolveToolRenderer, searchPiSessions, uploadFile, useOpenArtifact, usePiSessions, writeActiveSessionId };
+export { type AgentCommandContribution, type AgentCommandOptions, type AgentPluginReloadResult, ArtifactOpenProvider, type AvailableModel, BoringChatMessage, ChatEmptyState, type ChatEmptyStateProps, type ChatMessageContribution, type ChatMessageContributionProps, ChatMessageContributionProvider, PiChatPanel as ChatPanel, type PiChatPanelProps as ChatPanelProps, type ChatSuggestion, CodeBlock, type CommandRegistry, type ComposerActionContributionProps, type ComposerBlocker, type ComposerBlockerAction, type ComposerContribution, ComposerContributionProvider, type ComposerDraftUpdate, Conversation, ConversationContent, ConversationScrollButton, DebugDrawer, type GroupedToolEntry, Message, MessageAction, MessageActions, MessageContent, MessageResponse, ModelPickerMenu, ModelSelect, ModelSelectTrigger, type ModelSelection, type OpenArtifactHandler, type ParsedCommand, PiChatPanel, type PiChatPanelProps, SessionBrowser as PiSessionBrowser, type PiSessionCreateInit, SessionList as PiSessionList, type PiSessionSearchItem, type PiSessionSearchOptions, type PiSessionSearchSortMode, PromptInput, PromptInputFooter, PromptInputSubmit, PromptInputTextarea, Reasoning, ReasoningContent, ReasoningTrigger, type SessionListProps, type SlashCommand, type SlashCommandContext, type ThinkingLevel, ThinkingSelect, Tool, ToolCallGroup, ToolContent, ToolHeader, type ToolPart$1 as ToolPart, type ToolRenderer, type ToolRendererOverrides, type UploadFileOptions, type UploadFileResult, type UsePiSessionsOptions, type UsePiSessionsResult, activeSessionStorageKey, builtinCommands, clearActiveSessionId, cn, createCommandRegistry, defaultChatSuggestions, defaultToolRenderers, getAgentCommands, matchPiSessionSearch, mergeShadcnToolRenderers, mergeToolRenderers, parsePiSessionSearchQuery, parseSlashCommand, readActiveSessionId, resolveToolRenderer, searchPiSessions, uploadFile, useOpenArtifact, usePiSessions, writeActiveSessionId };