@selesai/code 0.9.11 → 0.9.12

package/dist/extensions/pi-intercom/broker/client.ts

@@ -4,13 +4,15 @@ import { randomUUID } from "crypto";
 import { writeMessage, createMessageReader } from "./framing.ts";
 import { getBrokerConnectTarget, type BrokerConnectTarget } from "./paths.ts";
 import { isMessage, isMessageControl, isMessageReceipt, isSessionInfo } from "./protocol.ts";
-import { EXTENSION_BUS_FEATURE } from "../types.ts";
+import { getIntercomScopeId } from "../config.ts";
+import { EXACT_SEND_FEATURE, EXTENSION_BUS_FEATURE, type DeliveryDetails } from "../types.ts";
 import type {
   Attachment,
   BrokerMessage,
   ClientMessage,
   Message,
   MessageControl,
+  MessageProvenance,
   MessageReceipt,
   SessionInfo,
   SessionRegistration,
@@ -24,9 +26,10 @@ interface SendOptions {
   messageId?: string;
   supersedes?: string;
   retryOf?: string;
+  provenance?: MessageProvenance;
 }
 
-interface SendResult {
+export interface SendResult extends DeliveryDetails {
   id: string;
   delivered: boolean;
   reason?: string;
@@ -280,10 +283,12 @@ export class IntercomClient extends EventEmitter {
       this.once("_registered", onRegistered);
       
       try {
+        const scopeId = getIntercomScopeId();
         writeMessage(socket, {
           type: "register",
           session,
           ...(sessionId ? { sessionId } : {}),
+          ...(scopeId ? { scopeId } : {}),
           ...(typeof target === "string" ? {} : { stateId: target.stateId }),
         });
       } catch (error) {
@@ -366,8 +371,8 @@ export class IntercomClient extends EventEmitter {
       }
 
       case "delivered": {
-        const { messageId } = brokerMessage;
-        if (typeof messageId !== "string") {
+        const { messageId, delivery, retryable, outcomeKnown } = brokerMessage;
+        if (typeof messageId !== "string" || (delivery !== undefined && delivery !== "socket_delivered" && delivery !== "queued") || (retryable !== undefined && typeof retryable !== "boolean") || (outcomeKnown !== undefined && typeof outcomeKnown !== "boolean")) {
           throw new Error("Invalid delivered message");
         }
 
@@ -378,13 +383,13 @@ export class IntercomClient extends EventEmitter {
         }
 
         this.pendingSends.delete(messageId);
-        pending.resolve({ id: messageId, delivered: true });
+        pending.resolve({ id: messageId, delivered: true, delivery: delivery as "socket_delivered" | "queued" | undefined ?? "socket_delivered", retryable: retryable as boolean | undefined ?? false, outcomeKnown: outcomeKnown as boolean | undefined ?? true, ...(typeof brokerMessage.code === "string" ? { code: brokerMessage.code } : {}) });
         break;
       }
 
       case "delivery_failed": {
-        const { messageId, reason } = brokerMessage;
-        if (typeof messageId !== "string" || typeof reason !== "string") {
+        const { messageId, reason, delivery, retryable, outcomeKnown } = brokerMessage;
+        if (typeof messageId !== "string" || typeof reason !== "string" || (delivery !== undefined && delivery !== "failed" && delivery !== "unknown") || (retryable !== undefined && typeof retryable !== "boolean") || (outcomeKnown !== undefined && typeof outcomeKnown !== "boolean")) {
           throw new Error("Invalid delivery_failed message");
         }
 
@@ -395,7 +400,7 @@ export class IntercomClient extends EventEmitter {
         }
 
         this.pendingSends.delete(messageId);
-        pending.resolve({ id: messageId, delivered: false, reason });
+        pending.resolve({ id: messageId, delivered: false, reason, delivery: delivery as "failed" | "unknown" | undefined ?? "failed", retryable: retryable as boolean | undefined ?? false, outcomeKnown: outcomeKnown as boolean | undefined ?? true, ...(typeof brokerMessage.code === "string" ? { code: brokerMessage.code } : {}) });
         break;
       }
 
@@ -613,12 +618,12 @@ export class IntercomClient extends EventEmitter {
     });
   }
 
-  send(to: string, options: SendOptions): Promise<SendResult> {
+  async send(to: string, options: SendOptions): Promise<SendResult> {
     let socket: net.Socket;
     try {
       socket = this.requireActiveSocket();
     } catch (error) {
-      return Promise.reject(toError(error));
+      throw toError(error);
     }
     
     const messageId = options.messageId ?? randomUUID();
@@ -630,13 +635,14 @@ export class IntercomClient extends EventEmitter {
       retryOf: options.retryOf,
       replyTo: options.replyTo,
       expectsReply: options.expectsReply,
+      provenance: options.provenance,
       content: {
         text: options.text,
         attachments: options.attachments,
       },
     };
 
-    return new Promise((resolve, reject) => {
+    const sendOnce = (targetId?: string, targetEpoch?: string): Promise<SendResult> => new Promise((resolve, reject) => {
       const wrappedResolve = (result: SendResult) => {
         clearTimeout(timeout);
         resolve(result);
@@ -654,13 +660,34 @@ export class IntercomClient extends EventEmitter {
       this.pendingSends.set(messageId, { resolve: wrappedResolve, reject: wrappedReject });
 
       try {
-        writeMessage(socket, { type: "send", to, message });
+        writeMessage(socket, { type: "send", to, message, ...(targetId && targetEpoch ? { targetId, targetEpoch } : {}) });
       } catch (error) {
         clearTimeout(timeout);
         this.pendingSends.delete(messageId);
         reject(toError(error));
       }
     });
+
+    if (!this.supportsFeature(EXACT_SEND_FEATURE) || options.replyTo) {
+      return sendOnce();
+    }
+
+    const resolveTarget = async (): Promise<{ id: string; epoch: string } | null> => {
+      const sessions = await this.listSessions();
+      const byId = sessions.find((session) => session.id === to);
+      const byName = byId ? [] : sessions.filter((session) => session.name?.toLowerCase() === to.toLowerCase());
+      const byPrefix = byId || byName.length > 0 ? [] : sessions.filter((session) => session.id.startsWith(to));
+      const matches = byId ? [byId] : byName.length > 0 ? byName : byPrefix;
+      const target = matches.length === 1 ? matches[0]! : null;
+      return target?.endpointEpoch ? { id: target.id, epoch: target.endpointEpoch } : null;
+    };
+
+    const target = await resolveTarget();
+    if (!target) return sendOnce();
+    const result = await sendOnce(target.id, target.epoch);
+    if (result.code !== "E_TARGET_REBOUND") return result;
+    const reboundTarget = await resolveTarget();
+    return reboundTarget ? sendOnce(reboundTarget.id, reboundTarget.epoch) : result;
   }
 
   cancelMessage(messageId: string): Promise<SendResult> {

package/dist/extensions/pi-intercom/broker/extension.test.ts

@@ -7,8 +7,8 @@ import path from "node:path";
 import test from "node:test";
 import type { BrokerMessage, SessionRegistration } from "../types.ts";
 import { IntercomClient } from "./client.ts";
-import { ExtensionStateManager } from "./extension-state.ts";
 import { getTsxCliPath } from "./spawn.ts";
+import { ExtensionStateManager } from "./extension-state.ts";
 
 const repoDir = process.cwd();
 
@@ -60,13 +60,29 @@ async function startBroker(agentDir: string): Promise<ChildProcessWithoutNullStr
     });
     broker.once("exit", (code, signal) => {
       clearTimeout(timeout);
-      reject(new Error(`Broker exited before startup (${code ?? signal})`));
+      reject(new Error(`Broker exited before startup (${code ?? signal}): ${broker.stderr.read()?.toString() ?? ""}`));
     });
   });
   await ready;
   return broker;
 }
 
+async function withIntercomScope<T>(scopeId: string | undefined, fn: () => T | Promise<T>): Promise<T> {
+  const previous = process.env.PI_INTERCOM_SCOPE_ID;
+  if (scopeId === undefined) delete process.env.PI_INTERCOM_SCOPE_ID;
+  else process.env.PI_INTERCOM_SCOPE_ID = scopeId;
+  try {
+    return await fn();
+  } finally {
+    if (previous === undefined) delete process.env.PI_INTERCOM_SCOPE_ID;
+    else process.env.PI_INTERCOM_SCOPE_ID = previous;
+  }
+}
+
+async function connectScoped(client: IntercomClient, scopeId: string | undefined, session: SessionRegistration, sessionId: string): Promise<void> {
+  await withIntercomScope(scopeId, () => client.connect(session, sessionId));
+}
+
 async function stopBroker(broker: ChildProcessWithoutNullStreams): Promise<void> {
   if (broker.exitCode !== null) return;
   broker.kill("SIGTERM");
@@ -74,7 +90,7 @@ async function stopBroker(broker: ChildProcessWithoutNullStreams): Promise<void>
 }
 
 test("extension bus negotiates, routes, elects an owner, and persists state", { concurrency: false, timeout: 30_000 }, async () => {
-  const agentDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-extension-"));
+  const agentDir = mkdtempSync(path.join(tmpdir(), "ic-unit-"));
   const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
   process.env.SELESAI_CODING_AGENT_DIR = agentDir;
   const broker = await startBroker(agentDir);
@@ -332,6 +348,89 @@ test("extension bus negotiates, routes, elects an owner, and persists state", {
   }
 });
 
+test("extension bus owners, publish, and state are scoped", { concurrency: false, timeout: 30_000 }, async () => {
+  const agentDir = mkdtempSync(path.join(tmpdir(), "ic-scope-"));
+  const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+  process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+  const broker = await startBroker(agentDir);
+  const clients: IntercomClient[] = [];
+
+  try {
+    const alphaOwner = new IntercomClient();
+    const alphaPeer = new IntercomClient();
+    const betaOwner = new IntercomClient();
+    const betaPeer = new IntercomClient();
+    clients.push(alphaOwner, alphaPeer, betaOwner, betaPeer);
+
+    const alphaOwnerMessages: BrokerMessage[] = [];
+    const alphaPeerMessages: BrokerMessage[] = [];
+    const betaOwnerMessages: BrokerMessage[] = [];
+    const betaPeerMessages: BrokerMessage[] = [];
+    alphaOwner.onBrokerMessage((message) => alphaOwnerMessages.push(message));
+    alphaPeer.onBrokerMessage((message) => alphaPeerMessages.push(message));
+    betaOwner.onBrokerMessage((message) => betaOwnerMessages.push(message));
+    betaPeer.onBrokerMessage((message) => betaPeerMessages.push(message));
+    for (const client of clients) client.on("error", () => {});
+
+    const now = Date.now();
+    await connectScoped(alphaOwner, "alpha", registration("alpha-owner", now, true), "scoped-owner-id");
+    await connectScoped(betaOwner, "beta", registration("beta-owner", now, true), "scoped-owner-id");
+    await connectScoped(alphaPeer, "alpha", registration("alpha-peer", now + 1, false), "alpha-peer-id");
+    await connectScoped(betaPeer, "beta", registration("beta-peer", now + 1, false), "beta-peer-id");
+
+    const alphaOwnerEvent = await waitFor(alphaOwnerMessages, (message) => message.type === "extension_owner" && message.ownerId === "scoped-owner-id");
+    const betaOwnerEvent = await waitFor(betaOwnerMessages, (message) => message.type === "extension_owner" && message.ownerId === "scoped-owner-id");
+    assert.equal(alphaOwnerEvent.type, "extension_owner");
+    assert.equal(betaOwnerEvent.type, "extension_owner");
+    assert.notEqual(alphaOwnerEvent.ownerEpoch, betaOwnerEvent.ownerEpoch);
+
+    alphaOwner.sendExtensionMessage({
+      type: "extension_publish",
+      namespace: "test/v1",
+      audience: "capable",
+      payload: { scope: "alpha" },
+    });
+    const alphaPublish = await waitFor(alphaPeerMessages, (message) => message.type === "extension_message"
+      && (message.payload as { scope?: string }).scope === "alpha");
+    assert.equal(alphaPublish.type, "extension_message");
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    assert.equal(betaPeerMessages.some((message) => message.type === "extension_message"
+      && (message.payload as { scope?: string }).scope === "alpha"), false);
+
+    alphaOwner.sendExtensionMessage({
+      type: "extension_state_commit",
+      namespace: "test/v1",
+      ownerEpoch: alphaOwnerEvent.ownerEpoch!,
+      expectedRevision: 0,
+      payload: { scope: "alpha-state" },
+    });
+    const alphaState = await waitFor(alphaPeerMessages, (message) => message.type === "extension_state"
+      && (message.payload as { scope?: string }).scope === "alpha-state");
+    assert.equal(alphaState.type, "extension_state");
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    assert.equal(betaPeerMessages.some((message) => message.type === "extension_state"
+      && (message.payload as { scope?: string }).scope === "alpha-state"), false);
+
+    betaOwner.sendExtensionMessage({
+      type: "extension_state_commit",
+      namespace: "test/v1",
+      ownerEpoch: betaOwnerEvent.ownerEpoch!,
+      expectedRevision: 0,
+      payload: { scope: "beta-state" },
+    });
+    const betaCommitted = await waitFor(betaOwnerMessages, (message) => message.type === "extension_state_result"
+      && message.committed === true);
+    assert.equal(betaCommitted.type, "extension_state_result");
+    assert.equal(betaCommitted.revision, 1);
+  } finally {
+    await Promise.all(clients.map((client) => client.disconnect().catch(() => undefined)));
+    await stopBroker(broker);
+    rmSync(agentDir, { recursive: true, force: true });
+    if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+    else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+  }
+});
+
 test("extension state compare-and-swap rejects stale and invalid revisions", () => {
   const runtimeDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-state-cas-"));
   try {

package/dist/extensions/pi-intercom/broker/paths.test.ts

@@ -3,7 +3,6 @@ import assert from "node:assert/strict";
 import { chmodSync, mkdtempSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { getAgentDir } from "@selesai/code";
 import {
   ensureIntercomRuntimeDir,
   getAgentDirPath,
@@ -20,7 +19,8 @@ import {
 } from "./paths.ts";
 
 test("getAgentDirPath defaults to Selesai's configured agent directory", () => {
-  assert.equal(getAgentDirPath({}), getAgentDir());
+  const expected = getAgentDirPath();
+  assert.equal(getAgentDirPath({}), expected);
 });
 
 test("getAgentDirPath honors SELESAI_CODING_AGENT_DIR", () => {

package/dist/extensions/pi-intercom/broker/protocol.ts

@@ -2,6 +2,7 @@ import type {
   Attachment,
   Message,
   MessageControl,
+  MessageProvenance,
   MessageReceipt,
   MessageReceiptStatus,
   SessionInfo,
@@ -69,6 +70,16 @@ function isAttachment(value: unknown): value is Attachment {
   return value.language === undefined || typeof value.language === "string";
 }
 
+function isMessageProvenance(value: unknown): value is MessageProvenance {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "extension_outbox"
+    && typeof value.extensionId === "string"
+    && typeof value.extensionName === "string"
+    && typeof value.requestId === "string";
+}
+
 export function isMessage(value: unknown): value is Message {
   if (!isRecord(value)) {
     return false;
@@ -100,6 +111,10 @@ export function isMessage(value: unknown): value is Message {
     return false;
   }
 
+  if (value.provenance !== undefined && !isMessageProvenance(value.provenance)) {
+    return false;
+  }
+
   if (!isRecord(value.content) || typeof value.content.text !== "string") {
     return false;
   }
@@ -124,6 +139,10 @@ export function isSessionInfo(value: unknown): value is SessionInfo {
     return false;
   }
 
+  if (value.endpointEpoch !== undefined && typeof value.endpointEpoch !== "string") {
+    return false;
+  }
+
   if (value.name !== undefined && typeof value.name !== "string") {
     return false;
   }
@@ -146,6 +165,10 @@ export function isSessionInfo(value: unknown): value is SessionInfo {
     }
   }
 
+  if (value.tmuxPane !== undefined && typeof value.tmuxPane !== "string") {
+    return false;
+  }
+
   return value.trustedLocal === undefined || typeof value.trustedLocal === "boolean";
 }
 
@@ -177,6 +200,9 @@ export function isSessionRegistration(value: unknown): value is SessionRegistrat
   if (value.extensions !== undefined && !Array.isArray(value.extensions)) {
     return false;
   }
+  if (value.tmuxPane !== undefined && typeof value.tmuxPane !== "string") {
+    return false;
+  }
 
   return value.status === undefined || typeof value.status === "string";
 }

package/dist/extensions/pi-intercom/broker/spawn.test.ts

@@ -105,7 +105,7 @@ test("getBrokerLaunchSpec uses wscript launcher on Windows without writing files
   }
 });
 
-test("getBrokerLaunchSpec falls back to PATH node for a standalone Pi executable on Windows", () => {
+test("getBrokerLaunchSpec falls back to PATH node for a standalone Selesai executable on Windows", () => {
   const intercomDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-"));
 
   try {
@@ -149,7 +149,7 @@ test("getBrokerLaunchSpec uses node + resolved tsx for the default non-Windows l
   assert.equal(spec.captureStartupStderr, true);
 });
 
-test("getBrokerLaunchSpec falls back to PATH node for a standalone Pi executable on non-Windows", () => {
+test("getBrokerLaunchSpec falls back to PATH node for a standalone Selesai executable on non-Windows", () => {
   const spec = getBrokerLaunchSpec(
     "/repo/broker.ts",
     "npx",
@@ -213,7 +213,10 @@ test("spawnBrokerIfNeeded includes stderr from default broker startup failures",
   try {
     mkdirSync(brokerDir, { recursive: true });
     mkdirSync(path.dirname(fakeTsxCli), { recursive: true });
+    mkdirSync(path.join(extensionDir, "node_modules", "@selesai", "code"), { recursive: true });
     writeFileSync(path.join(extensionDir, "package.json"), JSON.stringify({ type: "module" }));
+    writeFileSync(path.join(extensionDir, "node_modules", "@selesai", "code", "package.json"), JSON.stringify({ type: "module" }));
+    writeFileSync(path.join(extensionDir, "node_modules", "@selesai", "code", "index.js"), "export const getAgentDir = () => process.env.SELESAI_CODING_AGENT_DIR;\n");
     writeFileSync(fakeTsxCli, "process.stderr.write('fake tsx failed\\n'); process.exit(1);\n");
 
     const sourceDir = path.dirname(fileURLToPath(import.meta.url));
@@ -221,24 +224,6 @@ test("spawnBrokerIfNeeded includes stderr from default broker startup failures",
       cpSync(path.join(sourceDir, fileName), path.join(brokerDir, fileName));
     }
 
-    // Our fork's paths.ts routes through getAgentDir() from @selesai/code, so
-    // the temp copy needs a resolvable shim for the fork's config-dir lookup.
-    const codeShimDir = path.join(extensionDir, "node_modules", "@selesai", "code");
-    mkdirSync(codeShimDir, { recursive: true });
-    writeFileSync(
-      path.join(codeShimDir, "package.json"),
-      JSON.stringify({ name: "@selesai/code", type: "module", exports: { ".": "./index.mjs" } }),
-    );
-    writeFileSync(
-      path.join(codeShimDir, "index.mjs"),
-      `import { homedir } from "node:os";
-import { join } from "node:path";
-export function getAgentDir() {
-  return process.env.SELESAI_CODING_AGENT_DIR ?? join(homedir(), ".selesai", "agent");
-}
-`,
-    );
-
     process.env.SELESAI_CODING_AGENT_DIR = path.join(root, "agent");
     const moduleUrl = `${pathToFileURL(path.join(brokerDir, "spawn.ts")).href}?case=${Date.now()}`;
     const imported = await import(moduleUrl) as typeof import("./spawn.ts");

package/dist/extensions/pi-intercom/config.test.ts

@@ -60,6 +60,30 @@ test("loadConfig accepts inboundTrigger replies policy", async () => {
   }
 });
 
+test("loadConfig defaults intercom tool visibility to always", async () => {
+  const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
+  try {
+    await withAgentDir(root, () => {
+      assert.equal(loadConfig().toolVisibility, "always");
+    });
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("loadConfig accepts lazy intercom tool visibility", async () => {
+  const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
+  try {
+    mkdirSync(join(root, "intercom"), { recursive: true });
+    writeFileSync(join(root, "intercom", "config.json"), JSON.stringify({ toolVisibility: "after-first-use" }));
+    await withAgentDir(root, () => {
+      assert.equal(loadConfig().toolVisibility, "after-first-use");
+    });
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("loadConfig accepts a restart-stable intercom id", async () => {
   const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
   try {
@@ -73,6 +97,23 @@ test("loadConfig accepts a restart-stable intercom id", async () => {
   }
 });
 
+test("loadConfig rejects invalid toolVisibility values", async () => {
+  const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
+  try {
+    mkdirSync(join(root, "intercom"), { recursive: true });
+    writeFileSync(join(root, "intercom", "config.json"), JSON.stringify({ toolVisibility: "lazy" }));
+
+    await withAgentDir(root, () => {
+      assert.throws(
+        () => loadConfig(),
+        /Failed to load intercom config.*"toolVisibility" must be "always" or "after-first-use"/,
+      );
+    });
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("loadConfig rejects invalid inboundTrigger values", async () => {
   const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
   try {

package/dist/extensions/pi-intercom/config.ts

@@ -3,6 +3,7 @@ import { join } from "path";
 import { getIntercomDirPath } from "./broker/paths.ts";
 
 const DEFAULT_ASK_TIMEOUT_MS = 10 * 60 * 1000;
+const INTERCOM_SCOPE_ID_ENV = "PI_INTERCOM_SCOPE_ID";
 
 export function getAskTimeoutMs(): number {
   const raw = process.env.PI_INTERCOM_ASK_TIMEOUT_MS;
@@ -17,7 +18,13 @@ export function getAskTimeoutMs(): number {
   return value;
 }
 
+export function getIntercomScopeId(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const scopeId = env[INTERCOM_SCOPE_ID_ENV]?.trim();
+  return scopeId ? scopeId : undefined;
+}
+
 export type InboundTriggerPolicy = "always" | "replies" | "never";
+export type IntercomToolVisibility = "always" | "after-first-use";
 
 export interface IntercomConfig {
   /** Broker command used to spawn the broker process (e.g. "npx" or "bun") */
@@ -32,6 +39,9 @@ export interface IntercomConfig {
   /** Controls whether inbound broker messages may automatically trigger a model turn */
   inboundTrigger: InboundTriggerPolicy;
 
+  /** Controls when the intercom tool enters the active model tool set */
+  toolVisibility: IntercomToolVisibility;
+
   /** Optional custom status suffix shown after automatic lifecycle status */
   status?: string;
 
@@ -54,6 +64,7 @@ const defaults: IntercomConfig = {
   brokerArgs: ["--no-install", "tsx"],
   confirmSend: false,
   inboundTrigger: "always",
+  toolVisibility: "always",
   enabled: true,
   replyHint: true,
 };
@@ -124,6 +135,16 @@ export function loadConfig(): IntercomConfig {
       config.inboundTrigger = parsedConfig.inboundTrigger;
     }
 
+    if (Object.hasOwn(parsedConfig, "toolVisibility")) {
+      if (
+        parsedConfig.toolVisibility !== "always"
+        && parsedConfig.toolVisibility !== "after-first-use"
+      ) {
+        throw new Error(`"toolVisibility" must be "always" or "after-first-use"`);
+      }
+      config.toolVisibility = parsedConfig.toolVisibility;
+    }
+
     if (Object.hasOwn(parsedConfig, "replyHint")) {
       if (typeof parsedConfig.replyHint !== "boolean") {
         throw new Error(`"replyHint" must be a boolean`);

package/dist/extensions/pi-intercom/extension-api.ts

@@ -2,6 +2,46 @@ import type { SessionInfo } from "./types.ts";
 
 export const INTERCOM_EXTENSION_REGISTER_EVENT = "intercom:extension-register";
 export const INTERCOM_EXTENSION_REGISTRY_READY_EVENT = "intercom:extension-registry-ready";
+export const INTERCOM_OUTBOX_REQUEST_EVENT = "intercom:outbox-request";
+export const INTERCOM_OUTBOX_RESULT_EVENT = "intercom:outbox-result";
+
+export type IntercomOutboxResultStatus = "sent" | "rejected" | "blocked" | "failed";
+
+export type IntercomOutboxResultCode =
+  | "user_cancelled"
+  | "confirmation_unavailable"
+  | "session_unavailable"
+  | "session_ended"
+  | "invalid_request"
+  | "duplicate_request"
+  | "target_not_found"
+  | "target_ambiguous"
+  | "self_target"
+  | "delivery_failed";
+
+export interface IntercomOutboxRequestV1 {
+  version: 1;
+  requestId: string;
+  extensionId: string;
+  extensionName: string;
+  to: string;
+  message: string;
+}
+
+export type IntercomOutboxRequest = IntercomOutboxRequestV1;
+
+export interface IntercomOutboxResultV1 {
+  version: 1;
+  requestId: string;
+  status: IntercomOutboxResultStatus;
+  code?: IntercomOutboxResultCode;
+  extensionId?: string;
+  extensionName?: string;
+  messageId?: string;
+  detail?: string;
+}
+
+export type IntercomOutboxResult = IntercomOutboxResultV1;
 
 export interface IntercomExtensionOwner {
   sessionId: string;