@tylerl0706/ahpx 0.2.0

package/dist/chunk-B6RV43UP.js

@@ -0,0 +1,2384 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/protocol/actions.ts
+var ActionType = /* @__PURE__ */ ((ActionType2) => {
+  ActionType2["RootAgentsChanged"] = "root/agentsChanged";
+  ActionType2["RootActiveSessionsChanged"] = "root/activeSessionsChanged";
+  ActionType2["SessionReady"] = "session/ready";
+  ActionType2["SessionCreationFailed"] = "session/creationFailed";
+  ActionType2["SessionTurnStarted"] = "session/turnStarted";
+  ActionType2["SessionDelta"] = "session/delta";
+  ActionType2["SessionResponsePart"] = "session/responsePart";
+  ActionType2["SessionToolCallStart"] = "session/toolCallStart";
+  ActionType2["SessionToolCallDelta"] = "session/toolCallDelta";
+  ActionType2["SessionToolCallReady"] = "session/toolCallReady";
+  ActionType2["SessionToolCallConfirmed"] = "session/toolCallConfirmed";
+  ActionType2["SessionToolCallComplete"] = "session/toolCallComplete";
+  ActionType2["SessionToolCallResultConfirmed"] = "session/toolCallResultConfirmed";
+  ActionType2["SessionTurnComplete"] = "session/turnComplete";
+  ActionType2["SessionTurnCancelled"] = "session/turnCancelled";
+  ActionType2["SessionError"] = "session/error";
+  ActionType2["SessionTitleChanged"] = "session/titleChanged";
+  ActionType2["SessionUsage"] = "session/usage";
+  ActionType2["SessionReasoning"] = "session/reasoning";
+  ActionType2["SessionModelChanged"] = "session/modelChanged";
+  ActionType2["SessionServerToolsChanged"] = "session/serverToolsChanged";
+  ActionType2["SessionActiveClientChanged"] = "session/activeClientChanged";
+  ActionType2["SessionActiveClientToolsChanged"] = "session/activeClientToolsChanged";
+  ActionType2["SessionPendingMessageSet"] = "session/pendingMessageSet";
+  ActionType2["SessionPendingMessageRemoved"] = "session/pendingMessageRemoved";
+  ActionType2["SessionQueuedMessagesReordered"] = "session/queuedMessagesReordered";
+  ActionType2["SessionCustomizationsChanged"] = "session/customizationsChanged";
+  ActionType2["SessionCustomizationToggled"] = "session/customizationToggled";
+  ActionType2["SessionTruncated"] = "session/truncated";
+  return ActionType2;
+})(ActionType || {});
+
+// src/client/protocol.ts
+import { EventEmitter } from "events";
+var RpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "RpcError";
+  }
+};
+var RpcTimeoutError = class extends Error {
+  constructor(method, timeoutMs) {
+    super(`Request '${method}' timed out after ${timeoutMs}ms`);
+    this.method = method;
+    this.timeoutMs = timeoutMs;
+    this.name = "RpcTimeoutError";
+  }
+};
+var ProtocolLayer = class extends EventEmitter {
+  constructor(transport, options = {}) {
+    super();
+    this.transport = transport;
+    this.requestTimeout = options.requestTimeout ?? 3e4;
+    this.transport.on("message", (data) => this.handleMessage(data));
+  }
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  requestTimeout;
+  /**
+   * Send a typed JSON-RPC request and await the response.
+   */
+  async request(method, params, timeoutMs) {
+    const id = this.nextId++;
+    const timeout = timeoutMs ?? this.requestTimeout;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new RpcTimeoutError(method, timeout));
+      }, timeout);
+      this.pending.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      this.transport.send({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      });
+    });
+  }
+  /**
+   * Send a JSON-RPC notification (no response expected).
+   */
+  notify(method, params) {
+    this.transport.send({
+      jsonrpc: "2.0",
+      method,
+      params
+    });
+  }
+  /**
+   * Cancel all pending requests (e.g. on disconnect).
+   */
+  cancelAll(reason) {
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(reason));
+      this.pending.delete(id);
+    }
+  }
+  handleMessage(data) {
+    if (!data || typeof data !== "object") return;
+    const msg = data;
+    if ("id" in msg && typeof msg.id === "number") {
+      const pending = this.pending.get(msg.id);
+      if (!pending) return;
+      this.pending.delete(msg.id);
+      clearTimeout(pending.timer);
+      if ("error" in msg) {
+        const errPayload = msg.error;
+        pending.reject(new RpcError(errPayload.code, errPayload.message, errPayload.data));
+      } else if ("result" in msg) {
+        pending.resolve(msg.result);
+      }
+      return;
+    }
+    if ("method" in msg && typeof msg.method === "string") {
+      if (msg.method === "action") {
+        this.emit("action", msg.params);
+      } else if (msg.method === "notification") {
+        const params = msg.params;
+        this.emit("notification", params.notification);
+      }
+    }
+  }
+};
+
+// src/protocol/state.ts
+var PendingMessageKind = /* @__PURE__ */ ((PendingMessageKind2) => {
+  PendingMessageKind2["Steering"] = "steering";
+  PendingMessageKind2["Queued"] = "queued";
+  return PendingMessageKind2;
+})(PendingMessageKind || {});
+var SessionLifecycle = /* @__PURE__ */ ((SessionLifecycle2) => {
+  SessionLifecycle2["Creating"] = "creating";
+  SessionLifecycle2["Ready"] = "ready";
+  SessionLifecycle2["CreationFailed"] = "creationFailed";
+  return SessionLifecycle2;
+})(SessionLifecycle || {});
+var SessionStatus = /* @__PURE__ */ ((SessionStatus2) => {
+  SessionStatus2["Idle"] = "idle";
+  SessionStatus2["InProgress"] = "in-progress";
+  SessionStatus2["Error"] = "error";
+  return SessionStatus2;
+})(SessionStatus || {});
+var ResponsePartKind = /* @__PURE__ */ ((ResponsePartKind2) => {
+  ResponsePartKind2["Markdown"] = "markdown";
+  ResponsePartKind2["ContentRef"] = "contentRef";
+  ResponsePartKind2["ToolCall"] = "toolCall";
+  ResponsePartKind2["Reasoning"] = "reasoning";
+  return ResponsePartKind2;
+})(ResponsePartKind || {});
+var ToolCallStatus = /* @__PURE__ */ ((ToolCallStatus2) => {
+  ToolCallStatus2["Streaming"] = "streaming";
+  ToolCallStatus2["PendingConfirmation"] = "pending-confirmation";
+  ToolCallStatus2["Running"] = "running";
+  ToolCallStatus2["PendingResultConfirmation"] = "pending-result-confirmation";
+  ToolCallStatus2["Completed"] = "completed";
+  ToolCallStatus2["Cancelled"] = "cancelled";
+  return ToolCallStatus2;
+})(ToolCallStatus || {});
+
+// src/client/session-handle.ts
+import { randomUUID } from "crypto";
+import { EventEmitter as EventEmitter2 } from "events";
+var SessionHandle = class extends EventEmitter2 {
+  constructor(client, uri, provider, model) {
+    super();
+    this.client = client;
+    this.uri = uri;
+    this.provider = provider;
+    this.model = model;
+    this._onAction = (envelope) => {
+      const action = envelope.action;
+      if (!("session" in action) || action.session !== this.uri) {
+        return;
+      }
+      this.emit("action", envelope);
+      if (action.type === "session/turnComplete" /* SessionTurnComplete */) {
+        const session = this.state;
+        if (session && session.turns.length > 0) {
+          this.emit("turnComplete", session.turns[session.turns.length - 1]);
+        }
+      } else if (action.type === "session/error" /* SessionError */) {
+        const a = action;
+        this.emit("error", new Error(a.error.message));
+      }
+    };
+    this._onDisconnect = (_code, reason) => {
+      this.emit("error", new Error(`Connection lost: ${reason}`));
+    };
+    this.client.on("action", this._onAction);
+    this.client.on("disconnected", this._onDisconnect);
+  }
+  uri;
+  provider;
+  model;
+  _disposed = false;
+  _activeTurnId;
+  _onAction;
+  _onDisconnect;
+  // ── State accessors ────────────────────────────────────────────────────
+  /** Current session state from the state mirror. */
+  get state() {
+    return this.client.state.getSession(this.uri);
+  }
+  /** Whether the session is ready for prompts. */
+  get isReady() {
+    return this.state?.lifecycle === "ready" /* Ready */;
+  }
+  /** The currently active turn, if any. */
+  get activeTurn() {
+    return this.state?.activeTurn;
+  }
+  /** Whether this handle has been disposed. */
+  get disposed() {
+    return this._disposed;
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────────
+  /**
+   * Wait for the session to reach the "ready" lifecycle state.
+   *
+   * Resolves immediately if already ready. Rejects on creation failure
+   * or timeout.
+   */
+  async waitForReady(timeout = 3e4) {
+    this.ensureNotDisposed();
+    if (this.isReady) return;
+    const current = this.state;
+    if (current?.lifecycle === "creationFailed" /* CreationFailed */) {
+      throw new Error(`Session creation failed: ${current.creationError?.message ?? "Unknown error"}`);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Timed out waiting for session to be ready (${timeout}ms)`));
+      }, timeout);
+      const onAction = (envelope) => {
+        const action = envelope.action;
+        if (action.type === "session/ready" /* SessionReady */) {
+          cleanup();
+          resolve();
+        } else if (action.type === "session/creationFailed" /* SessionCreationFailed */) {
+          cleanup();
+          const session = this.state;
+          reject(new Error(`Session creation failed: ${session?.creationError?.message ?? "Unknown error"}`));
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.removeListener("action", onAction);
+      };
+      this.on("action", onAction);
+    });
+  }
+  /**
+   * Dispose this session handle and clean up server-side resources.
+   */
+  async dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this.client.removeListener("action", this._onAction);
+    this.client.removeListener("disconnected", this._onDisconnect);
+    if (this.client.connected) {
+      try {
+        await this.client.disposeSession(this.uri);
+      } catch {
+      }
+    }
+    this.emit("disposed");
+    this.removeAllListeners();
+  }
+  // ── Turns ──────────────────────────────────────────────────────────────
+  /**
+   * Send a prompt and wait for the turn to complete.
+   *
+   * Returns a `TurnResult` when the turn finishes (complete, error, or cancelled).
+   * Tool call confirmations and permissions are NOT handled automatically —
+   * library consumers should listen to `handle.on('action', ...)` and use
+   * `handle.dispatchAction()` for tool/permission responses.
+   */
+  async sendPrompt(text, options) {
+    this.ensureNotDisposed();
+    if (!this.isReady) {
+      throw new Error("Session is not ready");
+    }
+    if (this._activeTurnId) {
+      throw new Error("A turn is already active");
+    }
+    const turnId = randomUUID();
+    this._activeTurnId = turnId;
+    let responseText = "";
+    let toolCallCount = 0;
+    let usage;
+    return new Promise((resolve) => {
+      let timer;
+      const onAction = (envelope) => {
+        const action = envelope.action;
+        if ("turnId" in action && action.turnId !== turnId) {
+          return;
+        }
+        switch (action.type) {
+          case "session/delta" /* SessionDelta */: {
+            const a = action;
+            responseText += a.content;
+            break;
+          }
+          case "session/toolCallStart" /* SessionToolCallStart */:
+            toolCallCount++;
+            break;
+          case "session/usage" /* SessionUsage */: {
+            const a = action;
+            usage = a.usage;
+            break;
+          }
+          case "session/turnComplete" /* SessionTurnComplete */: {
+            finish("complete");
+            break;
+          }
+          case "session/error" /* SessionError */: {
+            const a = action;
+            finish("error", a.error.message);
+            break;
+          }
+          case "session/turnCancelled" /* SessionTurnCancelled */: {
+            finish("cancelled");
+            break;
+          }
+        }
+      };
+      const finish = (state, error) => {
+        cleanup();
+        resolve({
+          turnId,
+          responseText,
+          toolCalls: toolCallCount,
+          usage: usage ? {
+            inputTokens: usage.inputTokens ?? 0,
+            outputTokens: usage.outputTokens ?? 0,
+            model: usage.model
+          } : void 0,
+          state,
+          error
+        });
+      };
+      const cleanup = () => {
+        if (timer !== void 0) clearTimeout(timer);
+        this.removeListener("action", onAction);
+        this._activeTurnId = void 0;
+      };
+      if (options?.timeout) {
+        timer = setTimeout(() => {
+          this.cancelTurn().catch(() => {
+          });
+          cleanup();
+          resolve({
+            turnId,
+            responseText,
+            toolCalls: toolCallCount,
+            state: "error",
+            error: `Turn timed out after ${options.timeout}ms`
+          });
+        }, options.timeout);
+      }
+      this.on("action", onAction);
+      this.client.dispatchAction({
+        type: "session/turnStarted" /* SessionTurnStarted */,
+        session: this.uri,
+        turnId,
+        userMessage: {
+          text,
+          ...options?.attachments && options.attachments.length > 0 ? { attachments: options.attachments } : {}
+        }
+      });
+    });
+  }
+  /**
+   * Cancel the currently active turn.
+   */
+  async cancelTurn() {
+    this.ensureNotDisposed();
+    if (!this._activeTurnId) return;
+    this.client.dispatchAction({
+      type: "session/turnCancelled" /* SessionTurnCancelled */,
+      session: this.uri,
+      turnId: this._activeTurnId
+    });
+  }
+  // ── Action dispatch ────────────────────────────────────────────────────
+  /**
+   * Dispatch a client action for this session.
+   *
+   * Automatically injects the session URI into the action. Use this for
+   * tool call confirmations, permission responses, model changes, etc.
+   */
+  dispatchAction(action) {
+    this.ensureNotDisposed();
+    this.client.dispatchAction({
+      ...action,
+      session: this.uri
+    });
+  }
+  ensureNotDisposed() {
+    if (this._disposed) {
+      throw new Error("SessionHandle has been disposed");
+    }
+  }
+};
+
+// src/protocol/action-origin.generated.ts
+var IS_CLIENT_DISPATCHABLE = {
+  ["root/agentsChanged" /* RootAgentsChanged */]: false,
+  ["root/activeSessionsChanged" /* RootActiveSessionsChanged */]: false,
+  ["session/ready" /* SessionReady */]: false,
+  ["session/creationFailed" /* SessionCreationFailed */]: false,
+  ["session/turnStarted" /* SessionTurnStarted */]: true,
+  ["session/delta" /* SessionDelta */]: false,
+  ["session/responsePart" /* SessionResponsePart */]: false,
+  ["session/toolCallStart" /* SessionToolCallStart */]: false,
+  ["session/toolCallDelta" /* SessionToolCallDelta */]: false,
+  ["session/toolCallReady" /* SessionToolCallReady */]: false,
+  ["session/toolCallConfirmed" /* SessionToolCallConfirmed */]: true,
+  ["session/toolCallComplete" /* SessionToolCallComplete */]: true,
+  ["session/toolCallResultConfirmed" /* SessionToolCallResultConfirmed */]: true,
+  ["session/turnComplete" /* SessionTurnComplete */]: false,
+  ["session/turnCancelled" /* SessionTurnCancelled */]: true,
+  ["session/error" /* SessionError */]: false,
+  ["session/titleChanged" /* SessionTitleChanged */]: true,
+  ["session/usage" /* SessionUsage */]: false,
+  ["session/reasoning" /* SessionReasoning */]: false,
+  ["session/modelChanged" /* SessionModelChanged */]: true,
+  ["session/serverToolsChanged" /* SessionServerToolsChanged */]: false,
+  ["session/activeClientChanged" /* SessionActiveClientChanged */]: true,
+  ["session/activeClientToolsChanged" /* SessionActiveClientToolsChanged */]: true,
+  ["session/pendingMessageSet" /* SessionPendingMessageSet */]: true,
+  ["session/pendingMessageRemoved" /* SessionPendingMessageRemoved */]: true,
+  ["session/queuedMessagesReordered" /* SessionQueuedMessagesReordered */]: true,
+  ["session/customizationsChanged" /* SessionCustomizationsChanged */]: false,
+  ["session/customizationToggled" /* SessionCustomizationToggled */]: true,
+  ["session/truncated" /* SessionTruncated */]: true
+};
+
+// src/protocol/reducers.ts
+function softAssertNever(value, log7) {
+  const msg = `Unhandled action type: ${JSON.stringify(value)}`;
+  (log7 ?? console.warn)(msg);
+}
+function tcBase(tc) {
+  return {
+    toolCallId: tc.toolCallId,
+    toolName: tc.toolName,
+    displayName: tc.displayName,
+    toolClientId: tc.toolClientId,
+    _meta: tc._meta
+  };
+}
+function endTurn(state, turnId, turnState, summaryStatus, error) {
+  if (!state.activeTurn || state.activeTurn.id !== turnId) {
+    return state;
+  }
+  const active = state.activeTurn;
+  const responseParts = active.responseParts.map((part) => {
+    if (part.kind !== "toolCall" /* ToolCall */) {
+      return part;
+    }
+    const tc = part.toolCall;
+    if (tc.status === "completed" /* Completed */ || tc.status === "cancelled" /* Cancelled */) {
+      return part;
+    }
+    return {
+      kind: "toolCall" /* ToolCall */,
+      toolCall: {
+        status: "cancelled" /* Cancelled */,
+        ...tcBase(tc),
+        invocationMessage: tc.status === "streaming" /* Streaming */ ? tc.invocationMessage ?? "" : tc.invocationMessage,
+        toolInput: tc.status === "streaming" /* Streaming */ ? void 0 : tc.toolInput,
+        reason: "skipped" /* Skipped */
+      }
+    };
+  });
+  const turn = {
+    id: active.id,
+    userMessage: active.userMessage,
+    responseParts,
+    usage: active.usage,
+    state: turnState,
+    error
+  };
+  return {
+    ...state,
+    turns: [...state.turns, turn],
+    activeTurn: void 0,
+    summary: { ...state.summary, status: summaryStatus, modifiedAt: Date.now() }
+  };
+}
+function updateToolCallInParts(state, turnId, toolCallId, updater) {
+  const activeTurn = state.activeTurn;
+  if (!activeTurn || activeTurn.id !== turnId) {
+    return state;
+  }
+  let found = false;
+  const responseParts = activeTurn.responseParts.map((part) => {
+    if (part.kind === "toolCall" /* ToolCall */ && part.toolCall.toolCallId === toolCallId) {
+      const updated = updater(part.toolCall);
+      if (updated === part.toolCall) {
+        return part;
+      }
+      found = true;
+      return { ...part, toolCall: updated };
+    }
+    return part;
+  });
+  if (!found) {
+    return state;
+  }
+  return {
+    ...state,
+    activeTurn: { ...activeTurn, responseParts }
+  };
+}
+function updateResponsePart(state, turnId, partId, updater) {
+  const activeTurn = state.activeTurn;
+  if (!activeTurn || activeTurn.id !== turnId) {
+    return state;
+  }
+  let found = false;
+  const responseParts = activeTurn.responseParts.map((part) => {
+    if (!found) {
+      const id = part.kind === "toolCall" /* ToolCall */ ? part.toolCall.toolCallId : "id" in part ? part.id : void 0;
+      if (id === partId) {
+        found = true;
+        return updater(part);
+      }
+    }
+    return part;
+  });
+  if (!found) {
+    return state;
+  }
+  return {
+    ...state,
+    activeTurn: { ...activeTurn, responseParts }
+  };
+}
+function rootReducer(state, action, log7) {
+  switch (action.type) {
+    case "root/agentsChanged" /* RootAgentsChanged */:
+      return { ...state, agents: action.agents };
+    case "root/activeSessionsChanged" /* RootActiveSessionsChanged */:
+      return { ...state, activeSessions: action.activeSessions };
+    default:
+      softAssertNever(action, log7);
+      return state;
+  }
+}
+function sessionReducer(state, action, log7) {
+  switch (action.type) {
+    // ── Lifecycle ──────────────────────────────────────────────────────────
+    case "session/ready" /* SessionReady */:
+      return {
+        ...state,
+        lifecycle: "ready" /* Ready */,
+        summary: { ...state.summary, status: "idle" /* Idle */ }
+      };
+    case "session/creationFailed" /* SessionCreationFailed */:
+      return {
+        ...state,
+        lifecycle: "creationFailed" /* CreationFailed */,
+        creationError: action.error
+      };
+    // ── Turn Lifecycle ────────────────────────────────────────────────────
+    case "session/turnStarted" /* SessionTurnStarted */: {
+      let next = {
+        ...state,
+        summary: { ...state.summary, status: "in-progress" /* InProgress */, modifiedAt: Date.now() },
+        activeTurn: {
+          id: action.turnId,
+          userMessage: action.userMessage,
+          responseParts: [],
+          usage: void 0
+        }
+      };
+      if (action.queuedMessageId) {
+        if (next.steeringMessage?.id === action.queuedMessageId) {
+          next = { ...next, steeringMessage: void 0 };
+        }
+        if (next.queuedMessages) {
+          const filtered = next.queuedMessages.filter((m) => m.id !== action.queuedMessageId);
+          next = { ...next, queuedMessages: filtered.length > 0 ? filtered : void 0 };
+        }
+      }
+      return next;
+    }
+    case "session/delta" /* SessionDelta */:
+      return updateResponsePart(state, action.turnId, action.partId, (part) => {
+        if (part.kind === "markdown" /* Markdown */) {
+          return { ...part, content: part.content + action.content };
+        }
+        return part;
+      });
+    case "session/responsePart" /* SessionResponsePart */:
+      if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
+        return state;
+      }
+      return {
+        ...state,
+        activeTurn: {
+          ...state.activeTurn,
+          responseParts: [...state.activeTurn.responseParts, action.part]
+        }
+      };
+    case "session/turnComplete" /* SessionTurnComplete */:
+      return endTurn(state, action.turnId, "complete" /* Complete */, "idle" /* Idle */);
+    case "session/turnCancelled" /* SessionTurnCancelled */:
+      return endTurn(state, action.turnId, "cancelled" /* Cancelled */, "idle" /* Idle */);
+    case "session/error" /* SessionError */:
+      return endTurn(state, action.turnId, "error" /* Error */, "error" /* Error */, action.error);
+    // ── Tool Call State Machine ───────────────────────────────────────────
+    case "session/toolCallStart" /* SessionToolCallStart */:
+      if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
+        return state;
+      }
+      return {
+        ...state,
+        activeTurn: {
+          ...state.activeTurn,
+          responseParts: [
+            ...state.activeTurn.responseParts,
+            {
+              kind: "toolCall" /* ToolCall */,
+              toolCall: {
+                toolCallId: action.toolCallId,
+                toolName: action.toolName,
+                displayName: action.displayName,
+                toolClientId: action.toolClientId,
+                _meta: action._meta,
+                status: "streaming" /* Streaming */
+              }
+            }
+          ]
+        }
+      };
+    case "session/toolCallDelta" /* SessionToolCallDelta */:
+      return updateToolCallInParts(state, action.turnId, action.toolCallId, (tc) => {
+        if (tc.status !== "streaming" /* Streaming */) {
+          return tc;
+        }
+        return {
+          ...tc,
+          partialInput: (tc.partialInput ?? "") + action.content,
+          invocationMessage: action.invocationMessage ?? tc.invocationMessage
+        };
+      });
+    case "session/toolCallReady" /* SessionToolCallReady */:
+      return updateToolCallInParts(state, action.turnId, action.toolCallId, (tc) => {
+        if (tc.status !== "streaming" /* Streaming */ && tc.status !== "running" /* Running */) {
+          return tc;
+        }
+        const base = tcBase(tc);
+        if (action.confirmed) {
+          return {
+            status: "running" /* Running */,
+            ...base,
+            invocationMessage: action.invocationMessage,
+            toolInput: action.toolInput,
+            confirmed: action.confirmed
+          };
+        }
+        return {
+          status: "pending-confirmation" /* PendingConfirmation */,
+          ...base,
+          invocationMessage: action.invocationMessage,
+          toolInput: action.toolInput,
+          confirmationTitle: action.confirmationTitle
+        };
+      });
+    case "session/toolCallConfirmed" /* SessionToolCallConfirmed */:
+      return updateToolCallInParts(state, action.turnId, action.toolCallId, (tc) => {
+        if (tc.status !== "pending-confirmation" /* PendingConfirmation */) {
+          return tc;
+        }
+        const base = tcBase(tc);
+        if (action.approved) {
+          return {
+            status: "running" /* Running */,
+            ...base,
+            invocationMessage: tc.invocationMessage,
+            toolInput: tc.toolInput,
+            confirmed: action.confirmed
+          };
+        }
+        return {
+          status: "cancelled" /* Cancelled */,
+          ...base,
+          invocationMessage: tc.invocationMessage,
+          toolInput: tc.toolInput,
+          reason: action.reason,
+          reasonMessage: action.reasonMessage,
+          userSuggestion: action.userSuggestion
+        };
+      });
+    case "session/toolCallComplete" /* SessionToolCallComplete */:
+      return updateToolCallInParts(state, action.turnId, action.toolCallId, (tc) => {
+        if (tc.status !== "running" /* Running */ && tc.status !== "pending-confirmation" /* PendingConfirmation */) {
+          return tc;
+        }
+        const base = tcBase(tc);
+        const confirmed = tc.status === "running" /* Running */ ? tc.confirmed : "not-needed" /* NotNeeded */;
+        if (action.requiresResultConfirmation) {
+          return {
+            status: "pending-result-confirmation" /* PendingResultConfirmation */,
+            ...base,
+            invocationMessage: tc.invocationMessage,
+            toolInput: tc.toolInput,
+            confirmed,
+            ...action.result
+          };
+        }
+        return {
+          status: "completed" /* Completed */,
+          ...base,
+          invocationMessage: tc.invocationMessage,
+          toolInput: tc.toolInput,
+          confirmed,
+          ...action.result
+        };
+      });
+    case "session/toolCallResultConfirmed" /* SessionToolCallResultConfirmed */:
+      return updateToolCallInParts(state, action.turnId, action.toolCallId, (tc) => {
+        if (tc.status !== "pending-result-confirmation" /* PendingResultConfirmation */) {
+          return tc;
+        }
+        const base = tcBase(tc);
+        if (action.approved) {
+          return {
+            status: "completed" /* Completed */,
+            ...base,
+            invocationMessage: tc.invocationMessage,
+            toolInput: tc.toolInput,
+            confirmed: tc.confirmed,
+            success: tc.success,
+            pastTenseMessage: tc.pastTenseMessage,
+            content: tc.content,
+            structuredContent: tc.structuredContent,
+            error: tc.error
+          };
+        }
+        return {
+          status: "cancelled" /* Cancelled */,
+          ...base,
+          invocationMessage: tc.invocationMessage,
+          toolInput: tc.toolInput,
+          reason: "result-denied" /* ResultDenied */
+        };
+      });
+    // ── Metadata ──────────────────────────────────────────────────────────
+    case "session/titleChanged" /* SessionTitleChanged */:
+      return {
+        ...state,
+        summary: { ...state.summary, title: action.title, modifiedAt: Date.now() }
+      };
+    case "session/usage" /* SessionUsage */:
+      if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
+        return state;
+      }
+      return {
+        ...state,
+        activeTurn: { ...state.activeTurn, usage: action.usage }
+      };
+    case "session/reasoning" /* SessionReasoning */:
+      return updateResponsePart(state, action.turnId, action.partId, (part) => {
+        if (part.kind === "reasoning" /* Reasoning */) {
+          return { ...part, content: part.content + action.content };
+        }
+        return part;
+      });
+    case "session/modelChanged" /* SessionModelChanged */:
+      return {
+        ...state,
+        summary: { ...state.summary, model: action.model, modifiedAt: Date.now() }
+      };
+    case "session/serverToolsChanged" /* SessionServerToolsChanged */:
+      return { ...state, serverTools: action.tools };
+    case "session/activeClientChanged" /* SessionActiveClientChanged */:
+      return {
+        ...state,
+        activeClient: action.activeClient ?? void 0
+      };
+    case "session/activeClientToolsChanged" /* SessionActiveClientToolsChanged */:
+      if (!state.activeClient) {
+        return state;
+      }
+      return {
+        ...state,
+        activeClient: { ...state.activeClient, tools: action.tools }
+      };
+    // ── Customizations ──────────────────────────────────────────────────
+    case "session/customizationsChanged" /* SessionCustomizationsChanged */:
+      return { ...state, customizations: action.customizations };
+    case "session/customizationToggled" /* SessionCustomizationToggled */: {
+      const list = state.customizations;
+      if (!list) {
+        return state;
+      }
+      const idx = list.findIndex((c) => c.customization.uri === action.uri);
+      if (idx < 0) {
+        return state;
+      }
+      const updated = [...list];
+      updated[idx] = { ...list[idx], enabled: action.enabled };
+      return { ...state, customizations: updated };
+    }
+    // ── Truncation ────────────────────────────────────────────────────────
+    case "session/truncated" /* SessionTruncated */: {
+      let turns;
+      if (action.turnId === void 0) {
+        turns = [];
+      } else {
+        const idx = state.turns.findIndex((t) => t.id === action.turnId);
+        if (idx < 0) {
+          return state;
+        }
+        turns = state.turns.slice(0, idx + 1);
+      }
+      return {
+        ...state,
+        turns,
+        activeTurn: void 0,
+        summary: { ...state.summary, status: "idle" /* Idle */, modifiedAt: Date.now() }
+      };
+    }
+    // ── Pending Messages ──────────────────────────────────────────────────
+    case "session/pendingMessageSet" /* SessionPendingMessageSet */: {
+      const entry = { id: action.id, userMessage: action.userMessage };
+      if (action.kind === "steering" /* Steering */) {
+        return { ...state, steeringMessage: entry };
+      }
+      const existing = state.queuedMessages ?? [];
+      const idx = existing.findIndex((m) => m.id === action.id);
+      if (idx >= 0) {
+        const updated = [...existing];
+        updated[idx] = entry;
+        return { ...state, queuedMessages: updated };
+      }
+      return { ...state, queuedMessages: [...existing, entry] };
+    }
+    case "session/pendingMessageRemoved" /* SessionPendingMessageRemoved */: {
+      if (action.kind === "steering" /* Steering */) {
+        if (!state.steeringMessage || state.steeringMessage.id !== action.id) {
+          return state;
+        }
+        return { ...state, steeringMessage: void 0 };
+      }
+      const existing = state.queuedMessages;
+      if (!existing) {
+        return state;
+      }
+      const filtered = existing.filter((m) => m.id !== action.id);
+      return filtered.length === existing.length ? state : { ...state, queuedMessages: filtered.length > 0 ? filtered : void 0 };
+    }
+    case "session/queuedMessagesReordered" /* SessionQueuedMessagesReordered */: {
+      const existing = state.queuedMessages;
+      if (!existing) {
+        return state;
+      }
+      const byId = new Map(existing.map((m) => [m.id, m]));
+      const ordered = /* @__PURE__ */ new Set();
+      const reordered = action.order.filter((id) => {
+        if (byId.has(id) && !ordered.has(id)) {
+          ordered.add(id);
+          return true;
+        }
+        return false;
+      }).map((id) => byId.get(id));
+      for (const m of existing) {
+        if (!ordered.has(m.id)) {
+          reordered.push(m);
+        }
+      }
+      return { ...state, queuedMessages: reordered };
+    }
+    default:
+      softAssertNever(action, log7);
+      return state;
+  }
+}
+
+// src/client/state.ts
+var ROOT_ACTION_TYPES = /* @__PURE__ */ new Set(["root/agentsChanged" /* RootAgentsChanged */, "root/activeSessionsChanged" /* RootActiveSessionsChanged */]);
+var StateMirror = class {
+  rootState = { agents: [] };
+  sessions = /* @__PURE__ */ new Map();
+  serverSeq = 0;
+  /** Current root state (agents, active session count). */
+  get root() {
+    return this.rootState;
+  }
+  /** Current server sequence number. */
+  get seq() {
+    return this.serverSeq;
+  }
+  /** Get a session state by URI. */
+  getSession(uri) {
+    return this.sessions.get(uri);
+  }
+  /** All tracked session URIs. */
+  get sessionUris() {
+    return [...this.sessions.keys()];
+  }
+  /**
+   * Load a snapshot (from initialize, reconnect, or subscribe).
+   */
+  applySnapshot(snapshot) {
+    if (snapshot.fromSeq > this.serverSeq) {
+      this.serverSeq = snapshot.fromSeq;
+    }
+    if ("agents" in snapshot.state) {
+      this.rootState = snapshot.state;
+    } else if ("summary" in snapshot.state) {
+      const sessionState = snapshot.state;
+      this.sessions.set(snapshot.resource, sessionState);
+    }
+  }
+  /**
+   * Apply an incoming action envelope from the server.
+   */
+  applyAction(envelope) {
+    this.serverSeq = envelope.serverSeq;
+    const action = envelope.action;
+    if (ROOT_ACTION_TYPES.has(action.type)) {
+      this.rootState = rootReducer(this.rootState, action);
+    } else {
+      const sessionAction = action;
+      const sessionUri = sessionAction.session;
+      if (sessionUri) {
+        const current = this.sessions.get(sessionUri);
+        if (current) {
+          this.sessions.set(sessionUri, sessionReducer(current, sessionAction));
+        }
+      }
+    }
+  }
+  /**
+   * Remove a session from tracking (e.g. after dispose or unsubscribe).
+   */
+  removeSession(uri) {
+    this.sessions.delete(uri);
+  }
+};
+
+// src/client/transport.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import WebSocket from "ws";
+var Transport = class extends EventEmitter3 {
+  ws;
+  _connected = false;
+  get connected() {
+    return this._connected;
+  }
+  /**
+   * Open a WebSocket connection to the given URL.
+   */
+  async connect(url, options = {}) {
+    const { connectTimeout = 1e4, headers } = options;
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url, { headers });
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          ws.close();
+          reject(new Error(`Connection to ${url} timed out after ${connectTimeout}ms`));
+        }
+      }, connectTimeout);
+      ws.on("open", () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this.ws = ws;
+        this._connected = true;
+        this.attachListeners(ws);
+        this.emit("open");
+        resolve();
+      });
+      ws.on("error", (err) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          const code = err.code;
+          const detail = err.message || code || "unknown error";
+          reject(new Error(`Connection to ${url} failed: ${detail}`));
+        }
+      });
+    });
+  }
+  /**
+   * Send a JSON-serializable value over the WebSocket.
+   */
+  send(data) {
+    if (!this.ws || !this._connected) {
+      throw new Error("Transport is not connected");
+    }
+    this.ws.send(JSON.stringify(data));
+  }
+  /**
+   * Gracefully close the connection.
+   */
+  close() {
+    if (this.ws) {
+      this._connected = false;
+      this.ws.close();
+      this.ws = void 0;
+    }
+  }
+  attachListeners(ws) {
+    ws.on("message", (raw) => {
+      try {
+        const data = JSON.parse(raw.toString());
+        this.emit("message", data);
+      } catch {
+        this.emit("error", new Error(`Failed to parse message: ${raw.toString().slice(0, 200)}`));
+      }
+    });
+    ws.on("close", (code, reason) => {
+      this._connected = false;
+      this.ws = void 0;
+      this.emit("close", code, reason.toString());
+    });
+    ws.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+};
+
+// src/client/active-client.ts
+var ActiveClientManager = class {
+  constructor(client, clientId) {
+    this.client = client;
+    this.clientId = clientId;
+  }
+  /** Sessions where this client is the active client. */
+  activeSessions = /* @__PURE__ */ new Set();
+  /**
+   * Claim active client status for a session.
+   * Dispatches `session/activeClientChanged` with this client's info.
+   */
+  async claimActiveClient(sessionUri, displayName, tools = []) {
+    const activeClient = {
+      clientId: this.clientId,
+      displayName,
+      tools
+    };
+    this.client.dispatchAction({
+      type: "session/activeClientChanged" /* SessionActiveClientChanged */,
+      session: sessionUri,
+      activeClient
+    });
+    this.activeSessions.add(sessionUri);
+  }
+  /**
+   * Release active client status for a session.
+   * Dispatches `session/activeClientChanged` with `null`.
+   */
+  async releaseActiveClient(sessionUri) {
+    this.client.dispatchAction({
+      type: "session/activeClientChanged" /* SessionActiveClientChanged */,
+      session: sessionUri,
+      activeClient: null
+    });
+    this.activeSessions.delete(sessionUri);
+  }
+  /**
+   * Check if this client is the active client for a session.
+   * Uses the local state mirror for the check.
+   */
+  isActiveClient(sessionUri) {
+    const session = this.client.state.getSession(sessionUri);
+    return session?.activeClient?.clientId === this.clientId;
+  }
+  /**
+   * Register (or update) the tools this client provides to a session.
+   * Dispatches `session/activeClientToolsChanged`.
+   * Only valid when this client is the active client.
+   */
+  async registerTools(sessionUri, tools) {
+    this.client.dispatchAction({
+      type: "session/activeClientToolsChanged" /* SessionActiveClientToolsChanged */,
+      session: sessionUri,
+      tools
+    });
+  }
+  /**
+   * Handle a tool call directed at this client.
+   * Dispatches `session/toolCallComplete` with the result.
+   */
+  completeToolCall(sessionUri, turnId, toolCallId, result) {
+    this.client.dispatchAction({
+      type: "session/toolCallComplete" /* SessionToolCallComplete */,
+      session: sessionUri,
+      turnId,
+      toolCallId,
+      result: {
+        success: result.success,
+        pastTenseMessage: result.pastTenseMessage,
+        content: result.content?.map(
+          (c) => ({
+            type: "text" /* Text */,
+            text: c.text
+          })
+        )
+      }
+    });
+  }
+  /**
+   * Get the set of sessions where this client is active.
+   */
+  get sessions() {
+    return this.activeSessions;
+  }
+};
+
+// src/client/reconnect.ts
+import pc from "picocolors";
+var ReconnectManager = class {
+  constructor(serverUrl, clientId, options = {}) {
+    this.serverUrl = serverUrl;
+    this.clientId = clientId;
+    this.maxRetries = options.maxRetries ?? 5;
+    this.backoffMs = options.backoffMs ?? 1e3;
+    this.maxBackoffMs = options.maxBackoffMs ?? 3e4;
+    this.statusOut = options.statusOut ?? process.stderr;
+  }
+  maxRetries;
+  backoffMs;
+  maxBackoffMs;
+  statusOut;
+  aborted = false;
+  /**
+   * Attempt to reconnect to the AHP server.
+   *
+   * @param client - The AhpClient to reconnect
+   * @param lastSeenServerSeq - Last server sequence number received
+   * @param subscriptions - URIs the client was subscribed to
+   * @returns The reconnect outcome (replay, snapshot, or failed)
+   */
+  async reconnect(client, _lastSeenServerSeq, subscriptions) {
+    this.aborted = false;
+    let attempt = 0;
+    let backoff = this.backoffMs;
+    while (attempt < this.maxRetries && !this.aborted) {
+      attempt++;
+      this.statusOut.write(pc.yellow(`Connection lost. Reconnecting (${attempt}/${this.maxRetries})...
+`));
+      try {
+        await this.sleep(backoff);
+        if (this.aborted) break;
+        await client.connect(this.serverUrl);
+        for (const uri of subscriptions) {
+          await client.subscribe(uri);
+        }
+        this.statusOut.write(pc.green("Reconnected successfully.\n"));
+        return "snapshot";
+      } catch {
+        backoff = Math.min(backoff * 2, this.maxBackoffMs);
+        const jitter = backoff * 0.25 * (Math.random() * 2 - 1);
+        backoff = Math.max(this.backoffMs, backoff + jitter);
+      }
+    }
+    this.statusOut.write(pc.red(`Failed to reconnect after ${this.maxRetries} attempts.
+`));
+    return "failed";
+  }
+  /**
+   * Abort any in-progress reconnection attempt.
+   */
+  abort() {
+    this.aborted = true;
+  }
+  /**
+   * Sleep for a given number of milliseconds. Can be aborted.
+   */
+  sleep(ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(resolve, ms);
+      const check = setInterval(() => {
+        if (this.aborted) {
+          clearTimeout(timer);
+          clearInterval(check);
+          resolve();
+        }
+      }, 100);
+      setTimeout(() => clearInterval(check), ms + 10);
+    });
+  }
+};
+
+// src/client/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { EventEmitter as EventEmitter4 } from "events";
+
+// src/protocol/version/registry.ts
+var PROTOCOL_VERSION = 1;
+var ACTION_INTRODUCED_IN = {
+  ["root/agentsChanged" /* RootAgentsChanged */]: 1,
+  ["root/activeSessionsChanged" /* RootActiveSessionsChanged */]: 1,
+  ["session/ready" /* SessionReady */]: 1,
+  ["session/creationFailed" /* SessionCreationFailed */]: 1,
+  ["session/turnStarted" /* SessionTurnStarted */]: 1,
+  ["session/delta" /* SessionDelta */]: 1,
+  ["session/responsePart" /* SessionResponsePart */]: 1,
+  ["session/toolCallStart" /* SessionToolCallStart */]: 1,
+  ["session/toolCallDelta" /* SessionToolCallDelta */]: 1,
+  ["session/toolCallReady" /* SessionToolCallReady */]: 1,
+  ["session/toolCallConfirmed" /* SessionToolCallConfirmed */]: 1,
+  ["session/toolCallComplete" /* SessionToolCallComplete */]: 1,
+  ["session/toolCallResultConfirmed" /* SessionToolCallResultConfirmed */]: 1,
+  ["session/turnComplete" /* SessionTurnComplete */]: 1,
+  ["session/turnCancelled" /* SessionTurnCancelled */]: 1,
+  ["session/error" /* SessionError */]: 1,
+  ["session/titleChanged" /* SessionTitleChanged */]: 1,
+  ["session/usage" /* SessionUsage */]: 1,
+  ["session/reasoning" /* SessionReasoning */]: 1,
+  ["session/modelChanged" /* SessionModelChanged */]: 1,
+  ["session/serverToolsChanged" /* SessionServerToolsChanged */]: 1,
+  ["session/activeClientChanged" /* SessionActiveClientChanged */]: 1,
+  ["session/activeClientToolsChanged" /* SessionActiveClientToolsChanged */]: 1,
+  ["session/pendingMessageSet" /* SessionPendingMessageSet */]: 1,
+  ["session/pendingMessageRemoved" /* SessionPendingMessageRemoved */]: 1,
+  ["session/queuedMessagesReordered" /* SessionQueuedMessagesReordered */]: 1,
+  ["session/customizationsChanged" /* SessionCustomizationsChanged */]: 1,
+  ["session/customizationToggled" /* SessionCustomizationToggled */]: 1,
+  ["session/truncated" /* SessionTruncated */]: 1
+};
+var NOTIFICATION_INTRODUCED_IN = {
+  ["notify/sessionAdded" /* SessionAdded */]: 1,
+  ["notify/sessionRemoved" /* SessionRemoved */]: 1,
+  ["notify/authRequired" /* AuthRequired */]: 1
+};
+
+// src/client/index.ts
+var AhpClient = class extends EventEmitter4 {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this._clientId = options.clientId ?? randomUUID2();
+  }
+  transport;
+  protocol;
+  _state = new StateMirror();
+  _sessions = /* @__PURE__ */ new Map();
+  _clientId;
+  _clientSeq = 0;
+  _connected = false;
+  /** Whether the client is currently connected. */
+  get connected() {
+    return this._connected;
+  }
+  /** The local state mirror. */
+  get state() {
+    return this._state;
+  }
+  /** The client identifier. */
+  get clientId() {
+    return this._clientId;
+  }
+  /** All active session handles. */
+  get sessions() {
+    return this._sessions;
+  }
+  /**
+   * Connect to an AHP server and perform the initialization handshake.
+   */
+  async connect(url) {
+    const transport = new Transport();
+    const protocol = new ProtocolLayer(transport, this.options);
+    protocol.on("action", (envelope) => {
+      this._state.applyAction(envelope);
+      this.emit("action", envelope);
+    });
+    protocol.on("notification", (notification) => {
+      this.emit("notification", notification);
+    });
+    transport.on("close", (code, reason) => {
+      this._connected = false;
+      protocol.cancelAll("Connection closed");
+      this.emit("disconnected", code, reason);
+    });
+    transport.on("error", (err) => {
+      this.emit("error", err);
+    });
+    await transport.connect(url, this.options);
+    this.transport = transport;
+    this.protocol = protocol;
+    const result = await protocol.request("initialize", {
+      protocolVersion: PROTOCOL_VERSION,
+      clientId: this._clientId,
+      initialSubscriptions: this.options.initialSubscriptions ?? ["agenthost:/root"]
+    });
+    for (const snapshot of result.snapshots) {
+      this._state.applySnapshot(snapshot);
+    }
+    this._connected = true;
+    this.emit("connected", result);
+    return result;
+  }
+  /**
+   * Gracefully disconnect from the server.
+   */
+  async disconnect() {
+    const handles = [...this._sessions.values()];
+    for (const handle of handles) {
+      try {
+        await handle.dispose();
+      } catch {
+      }
+    }
+    this._sessions.clear();
+    if (this.protocol) {
+      this.protocol.cancelAll("Client disconnecting");
+    }
+    if (this.transport) {
+      this.transport.close();
+      this.transport = void 0;
+      this.protocol = void 0;
+    }
+    this._connected = false;
+  }
+  // ── Session management ────────────────────────────────────────────────
+  /**
+   * Create a session and return a handle for interacting with it.
+   *
+   * Creates the session on the server, subscribes to its state, and
+   * (by default) waits for it to reach the "ready" lifecycle state.
+   */
+  async openSession(options = {}) {
+    this.ensureConnected();
+    const {
+      provider: requestedProvider,
+      model,
+      workingDirectory,
+      waitForReady = true,
+      readyTimeout = 3e4
+    } = options;
+    const provider = requestedProvider ?? (this._state.root.agents.length > 0 ? this._state.root.agents[0].provider : void 0);
+    if (!provider) {
+      throw new Error("No agent provider available. Specify one in options or ensure the server has agents.");
+    }
+    const sessionId = randomUUID2();
+    const sessionUri = `${provider}:/${sessionId}`;
+    await this.createSession(sessionUri, provider, model, workingDirectory);
+    await this.subscribe(sessionUri);
+    const handle = new SessionHandle(this, sessionUri, provider, model);
+    this._sessions.set(sessionUri, handle);
+    handle.on("disposed", () => {
+      this._sessions.delete(sessionUri);
+    });
+    if (waitForReady) {
+      try {
+        await handle.waitForReady(readyTimeout);
+      } catch (err) {
+        await handle.dispose().catch(() => {
+        });
+        throw err;
+      }
+    }
+    return handle;
+  }
+  // ── Commands ──────────────────────────────────────────────────────────
+  /**
+   * Create a new session with the specified agent provider.
+   */
+  async createSession(sessionUri, provider, model, workingDirectory) {
+    this.ensureConnected();
+    return this.protocol.request("createSession", {
+      session: sessionUri,
+      provider,
+      model,
+      workingDirectory
+    });
+  }
+  /**
+   * Dispose a session and clean up server-side resources.
+   */
+  async disposeSession(sessionUri) {
+    this.ensureConnected();
+    const result = await this.protocol.request("disposeSession", {
+      session: sessionUri
+    });
+    this._state.removeSession(sessionUri);
+    this._sessions.delete(sessionUri);
+    return result;
+  }
+  /**
+   * List all sessions on the server.
+   */
+  async listSessions() {
+    this.ensureConnected();
+    return this.protocol.request("listSessions", {});
+  }
+  /**
+   * Subscribe to a state resource URI.
+   */
+  async subscribe(resourceUri) {
+    this.ensureConnected();
+    const result = await this.protocol.request("subscribe", {
+      resource: resourceUri
+    });
+    this._state.applySnapshot(result.snapshot);
+    return result;
+  }
+  /**
+   * Unsubscribe from a state resource URI.
+   */
+  unsubscribe(resourceUri) {
+    this.ensureConnected();
+    this.protocol.notify("unsubscribe", { resource: resourceUri });
+  }
+  /**
+   * Fetch historical turns for a session.
+   */
+  async fetchTurns(sessionUri, before, limit) {
+    this.ensureConnected();
+    return this.protocol.request("fetchTurns", {
+      session: sessionUri,
+      before,
+      limit
+    });
+  }
+  /**
+   * Read content by URI (files, tool outputs, etc.).
+   */
+  async resourceRead(uri, encoding) {
+    this.ensureConnected();
+    return this.protocol.request("resourceRead", { uri, ...encoding ? { encoding } : {} });
+  }
+  /**
+   * Write content to a file on the server's filesystem.
+   */
+  async resourceWrite(params) {
+    this.ensureConnected();
+    return this.protocol.request("resourceWrite", params);
+  }
+  /**
+   * List directory entries on the server's filesystem.
+   */
+  async resourceList(uri) {
+    this.ensureConnected();
+    return this.protocol.request("resourceList", { uri });
+  }
+  /**
+   * Copy a resource from one URI to another.
+   */
+  async resourceCopy(params) {
+    this.ensureConnected();
+    return this.protocol.request("resourceCopy", params);
+  }
+  /**
+   * Delete a resource at a URI.
+   */
+  async resourceDelete(params) {
+    this.ensureConnected();
+    return this.protocol.request("resourceDelete", params);
+  }
+  /**
+   * Move (rename) a resource from one URI to another.
+   */
+  async resourceMove(params) {
+    this.ensureConnected();
+    return this.protocol.request("resourceMove", params);
+  }
+  /**
+   * Dispatch a client-originated action to the server.
+   */
+  dispatchAction(action) {
+    this.ensureConnected();
+    this._clientSeq++;
+    this.protocol.notify("dispatchAction", {
+      clientSeq: this._clientSeq,
+      action
+    });
+  }
+  /**
+   * Push an authentication token for a protected resource.
+   */
+  async authenticate(resource, token) {
+    this.ensureConnected();
+    await this.protocol.request("authenticate", { resource, token });
+  }
+  ensureConnected() {
+    if (!this._connected || !this.protocol) {
+      throw new Error("Client is not connected");
+    }
+  }
+};
+
+// src/logger.ts
+import pc2 from "picocolors";
+var verbose = false;
+function setVerbose(enabled) {
+  verbose = enabled;
+}
+function timestamp() {
+  const now = /* @__PURE__ */ new Date();
+  return [
+    String(now.getHours()).padStart(2, "0"),
+    String(now.getMinutes()).padStart(2, "0"),
+    String(now.getSeconds()).padStart(2, "0")
+  ].join(":");
+}
+function formatData(data) {
+  if (!data) return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (value !== void 0) {
+      parts.push(`${key}=${typeof value === "string" ? value : JSON.stringify(value)}`);
+    }
+  }
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+function createLogger(component) {
+  const prefix = () => `[${timestamp()} ${component}]`;
+  return {
+    debug(message, data) {
+      if (!verbose) return;
+      process.stderr.write(pc2.dim(`${prefix()} ${message}${formatData(data)}
+`));
+    },
+    info(message, data) {
+      process.stderr.write(`${prefix()} ${message}${formatData(data)}
+`);
+    },
+    warn(message, data) {
+      process.stderr.write(pc2.yellow(`${prefix()} ${message}${formatData(data)}
+`));
+    },
+    error(message, data) {
+      process.stderr.write(pc2.red(`${prefix()} ${message}${formatData(data)}
+`));
+    }
+  };
+}
+
+// src/events/forwarding-formatter.ts
+var log = createLogger("forwarding-formatter");
+var ForwardingFormatter = class {
+  inner;
+  forwarders;
+  tags;
+  /** Session URI to attach to forwarded events. Can be set after construction. */
+  sessionUri;
+  constructor(options) {
+    this.inner = options.inner;
+    this.forwarders = options.forwarders;
+    this.sessionUri = options.sessionUri;
+    this.tags = options.tags;
+  }
+  onDelta(text) {
+    this.inner.onDelta(text);
+    this.emit("delta", { content: text });
+  }
+  onReasoning(text) {
+    this.inner.onReasoning(text);
+    this.emit("reasoning", { content: text });
+  }
+  onToolCallStart(id, name) {
+    this.inner.onToolCallStart(id, name);
+    this.emit("tool_call_start", { toolCallId: id, name });
+  }
+  onToolCallDelta(id, paramsDelta) {
+    this.inner.onToolCallDelta(id, paramsDelta);
+    this.emit("tool_call_delta", { toolCallId: id, content: paramsDelta });
+  }
+  onToolCallReady(id, call) {
+    this.inner.onToolCallReady(id, call);
+    this.emit("tool_call_ready", {
+      toolCallId: id,
+      toolName: call.toolName,
+      displayName: call.displayName,
+      invocationMessage: call.invocationMessage,
+      ...call.toolInput !== void 0 ? { toolInput: call.toolInput } : {}
+    });
+  }
+  onToolCallComplete(id, result) {
+    this.inner.onToolCallComplete(id, result);
+    this.emit("tool_call_complete", { toolCallId: id, result });
+  }
+  onToolCallCancelled(id, reason) {
+    this.inner.onToolCallCancelled(id, reason);
+    this.emit("tool_call_cancelled", { toolCallId: id, reason });
+  }
+  onUsage(usage) {
+    this.inner.onUsage(usage);
+    this.emit("usage", { usage });
+  }
+  onTurnComplete(responseText) {
+    this.inner.onTurnComplete(responseText);
+    this.emit("turn_complete", { responseText });
+  }
+  onTurnError(error) {
+    this.inner.onTurnError(error);
+    this.emit("turn_error", { error });
+  }
+  onTurnCancelled() {
+    this.inner.onTurnCancelled();
+    this.emit("turn_cancelled", {});
+  }
+  onTitleChanged(title) {
+    this.inner.onTitleChanged(title);
+    this.emit("title_changed", { title });
+  }
+  /**
+   * Close all forwarders, flushing any buffered events.
+   *
+   * Call this when the session/turn is done to ensure all events
+   * have been delivered.
+   */
+  async close() {
+    await Promise.allSettled(this.forwarders.map((f) => f.close()));
+  }
+  // ── Internal ──────────────────────────────────────────────────────────
+  emit(type, data) {
+    const event = {
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...this.tags && Object.keys(this.tags).length > 0 ? { tags: this.tags } : {},
+      data,
+      ...this.sessionUri ? { sessionUri: this.sessionUri } : {}
+    };
+    for (const forwarder of this.forwarders) {
+      forwarder.forward(event).catch((err) => {
+        log.info("forward-error", { type, error: err instanceof Error ? err.message : String(err) });
+      });
+    }
+  }
+};
+
+// src/events/webhook-forwarder.ts
+var log2 = createLogger("webhook-forwarder");
+var WebhookForwarder = class {
+  url;
+  headers;
+  batchSize;
+  batchIntervalMs;
+  retries;
+  filter;
+  batch = [];
+  flushTimer;
+  closed = false;
+  flushPromise = Promise.resolve();
+  constructor(options) {
+    this.url = options.url;
+    this.headers = options.headers ?? {};
+    this.batchSize = options.batchSize ?? 10;
+    this.batchIntervalMs = options.batchIntervalMs ?? 1e3;
+    this.retries = options.retries ?? 3;
+    this.filter = options.filter && options.filter.length > 0 ? new Set(options.filter) : void 0;
+  }
+  async forward(event) {
+    if (this.closed) return;
+    if (this.filter && !this.filter.has(event.type)) return;
+    this.batch.push(event);
+    if (this.batch.length >= this.batchSize) {
+      this.clearFlushTimer();
+      this.flushPromise = this.flushPromise.then(() => this.flush());
+    } else if (this.flushTimer === void 0) {
+      this.startFlushTimer();
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.clearFlushTimer();
+    await this.flushPromise;
+    await this.flush();
+  }
+  // ── Internal ──────────────────────────────────────────────────────────
+  startFlushTimer() {
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      this.flushPromise = this.flushPromise.then(() => this.flush());
+    }, this.batchIntervalMs);
+  }
+  clearFlushTimer() {
+    if (this.flushTimer !== void 0) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+  }
+  async flush() {
+    if (this.batch.length === 0) return;
+    const events = this.batch;
+    this.batch = [];
+    await this.sendWithRetry(events);
+  }
+  async sendWithRetry(events) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        await this.send(events);
+        return;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < this.retries) {
+          const delay = Math.min(1e3 * 2 ** attempt, 1e4);
+          log2.info("retry", { attempt: attempt + 1, delay, error: lastError.message });
+          await sleep(delay);
+        }
+      }
+    }
+    log2.info("send-failed", {
+      url: this.url,
+      events: events.length,
+      error: lastError?.message ?? "Unknown error"
+    });
+  }
+  async send(events) {
+    const body = events.map((e) => JSON.stringify(e)).join("\n");
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-ndjson",
+        ...this.headers
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/events/ws-forwarder.ts
+import WebSocket2 from "ws";
+var log3 = createLogger("ws-forwarder");
+var BACKPRESSURE_THRESHOLD = 1024 * 1024;
+var MAX_BUFFER_SIZE = 1e4;
+var WebSocketForwarder = class {
+  url;
+  headers;
+  reconnect;
+  filter;
+  ws;
+  buffer = [];
+  closed = false;
+  reconnecting = false;
+  reconnectTimer;
+  reconnectAttempt = 0;
+  connectPromise;
+  constructor(options) {
+    this.url = options.url;
+    this.headers = options.headers ?? {};
+    this.reconnect = options.reconnect ?? true;
+    this.filter = options.filter && options.filter.length > 0 ? new Set(options.filter) : void 0;
+    this.connectPromise = this.connect();
+  }
+  async forward(event) {
+    if (this.closed) return;
+    if (this.filter && !this.filter.has(event.type)) return;
+    if (this.connectPromise) {
+      try {
+        await this.connectPromise;
+      } catch {
+      }
+    }
+    if (this.isConnected()) {
+      this.sendOrBuffer(event);
+    } else {
+      this.addToBuffer(event);
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.reconnectTimer !== void 0) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+    if (this.connectPromise) {
+      try {
+        await this.connectPromise;
+      } catch {
+      }
+    }
+    if (this.isConnected()) {
+      this.drainBuffer();
+    }
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      if (this.ws.readyState === WebSocket2.OPEN || this.ws.readyState === WebSocket2.CONNECTING) {
+        this.ws.close(1e3, "Forwarder closed");
+      }
+      this.ws = void 0;
+    }
+    this.buffer = [];
+  }
+  // ── Internal ──────────────────────────────────────────────────────────
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket2(this.url, { headers: this.headers });
+      } catch (err) {
+        this.connectPromise = void 0;
+        reject(err);
+        return;
+      }
+      this.ws.on("open", () => {
+        log3.info("connected", { url: this.url });
+        this.reconnectAttempt = 0;
+        this.reconnecting = false;
+        this.connectPromise = void 0;
+        this.drainBuffer();
+        resolve();
+      });
+      this.ws.on("close", (code, reason) => {
+        log3.info("disconnected", { url: this.url, code, reason: reason.toString() });
+        if (!this.closed && this.reconnect) {
+          this.scheduleReconnect();
+        }
+      });
+      this.ws.on("error", (err) => {
+        log3.info("error", { url: this.url, error: err.message });
+        if (this.connectPromise) {
+          this.connectPromise = void 0;
+          reject(err);
+        }
+      });
+    });
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnecting) return;
+    this.reconnecting = true;
+    const delay = Math.min(1e3 * 2 ** this.reconnectAttempt, 3e4);
+    this.reconnectAttempt++;
+    log3.info("reconnecting", { attempt: this.reconnectAttempt, delay });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      if (!this.closed) {
+        this.connectPromise = this.connect().catch(() => {
+        });
+      }
+    }, delay);
+  }
+  isConnected() {
+    return this.ws?.readyState === WebSocket2.OPEN;
+  }
+  sendOrBuffer(event) {
+    if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) {
+      this.addToBuffer(event);
+      return;
+    }
+    if (this.ws.bufferedAmount > BACKPRESSURE_THRESHOLD) {
+      log3.info("backpressure", { bufferedAmount: this.ws.bufferedAmount });
+      this.addToBuffer(event);
+      return;
+    }
+    try {
+      this.ws.send(JSON.stringify(event));
+    } catch {
+      this.addToBuffer(event);
+    }
+  }
+  addToBuffer(event) {
+    if (this.buffer.length >= MAX_BUFFER_SIZE) {
+      this.buffer.shift();
+    }
+    this.buffer.push(event);
+  }
+  drainBuffer() {
+    while (this.buffer.length > 0 && this.isConnected()) {
+      const event = this.buffer.shift();
+      try {
+        this.ws.send(JSON.stringify(event));
+      } catch {
+        this.buffer.unshift(event);
+        break;
+      }
+    }
+  }
+};
+
+// src/fleet/health.ts
+var HealthChecker = class {
+  _defaultTimeout;
+  constructor(options) {
+    this._defaultTimeout = options?.timeout ?? 1e4;
+  }
+  /** Check a single server's health. */
+  async check(url, name, options) {
+    const start = performance.now();
+    const client = new AhpClient({
+      connectTimeout: options?.timeout ?? this._defaultTimeout
+    });
+    try {
+      const result = await client.connect(url);
+      if (options?.token) {
+        await client.authenticate(url, options.token);
+      }
+      const latencyMs = performance.now() - start;
+      const root = client.state.root;
+      return {
+        name,
+        url,
+        status: "healthy",
+        latencyMs,
+        protocolVersion: result.protocolVersion,
+        agents: root.agents.map((a) => ({
+          provider: a.provider,
+          models: a.models.map((m) => m.id)
+        })),
+        activeSessions: root.activeSessions ?? 0,
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (err) {
+      const latencyMs = performance.now() - start;
+      return {
+        name,
+        url,
+        status: "unreachable",
+        latencyMs,
+        agents: [],
+        activeSessions: 0,
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: err instanceof Error ? err.message : String(err)
+      };
+    } finally {
+      try {
+        await client.disconnect();
+      } catch {
+      }
+    }
+  }
+  /** Check all servers concurrently. */
+  async checkAll(connections) {
+    return Promise.all(connections.map((c) => this.check(c.url, c.name, c.token ? { token: c.token } : void 0)));
+  }
+};
+
+// src/session/store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+var log4 = createLogger("session-store");
+var MAX_LOCAL_TURNS = 100;
+var PREVIEW_MAX_LEN = 200;
+function truncatePreview(str, maxLen = PREVIEW_MAX_LEN) {
+  if (str.length <= maxLen) return str;
+  return `${str.slice(0, maxLen - 1)}\u2026`;
+}
+function buildTurnSummary(result) {
+  return {
+    turnId: result.turnId,
+    userMessage: truncatePreview(result.userMessage),
+    responsePreview: truncatePreview(result.responseText || "(no response)"),
+    toolCallCount: result.toolCalls,
+    tokenUsage: result.usage ? { input: result.usage.inputTokens, output: result.usage.outputTokens, model: result.usage.model } : void 0,
+    state: result.state,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var SessionStore = class {
+  sessionsDir;
+  constructor(configDir) {
+    const dir = configDir ?? path.join(os.homedir(), ".ahpx");
+    this.sessionsDir = path.join(dir, "sessions");
+  }
+  /** Ensure the sessions directory exists. */
+  async ensureDir() {
+    await fs.mkdir(this.sessionsDir, { recursive: true, mode: 448 });
+  }
+  /** Path to a session record file. Validates ID to prevent path traversal. */
+  filePath(id) {
+    this.validateId(id);
+    return path.join(this.sessionsDir, `${id}.json`);
+  }
+  /** Validate that a session ID is safe for use in file paths (no traversal). */
+  validateId(id) {
+    if (!id || id.includes("/") || id.includes("\\") || id.includes("..") || id.includes("\0")) {
+      throw new Error(`Invalid session ID: "${id}". IDs must not contain path separators or traversal sequences.`);
+    }
+  }
+  /**
+   * Save a session record to disk. Creates a new file or overwrites an existing one.
+   * Uses atomic writes (temp file + rename).
+   */
+  async save(record) {
+    this.validateId(record.id);
+    await this.ensureDir();
+    const tmp = path.join(this.sessionsDir, `.${record.id}.${randomUUID3()}.tmp`);
+    await fs.writeFile(tmp, `${JSON.stringify(record, null, "	")}
+`, { mode: 384, encoding: "utf-8" });
+    await fs.rename(tmp, this.filePath(record.id));
+  }
+  /** Get a session record by ID, or undefined if not found. */
+  async get(id) {
+    try {
+      const raw = await fs.readFile(this.filePath(id), "utf-8");
+      return JSON.parse(raw);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return void 0;
+      }
+      throw err;
+    }
+  }
+  /**
+   * List session records, optionally filtered.
+   * Returns records sorted by createdAt descending (newest first).
+   */
+  async list(filter) {
+    await this.ensureDir();
+    let entries;
+    try {
+      entries = await fs.readdir(this.sessionsDir);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const records = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      try {
+        const raw = await fs.readFile(path.join(this.sessionsDir, entry), "utf-8");
+        const record = JSON.parse(raw);
+        if (filter?.status && record.status !== filter.status) continue;
+        if (filter?.serverName && record.serverName !== filter.serverName) continue;
+        if (filter?.workingDirectory && record.workingDirectory !== filter.workingDirectory) continue;
+        if (filter?.name && record.name !== filter.name) continue;
+        records.push(record);
+      } catch (err) {
+        log4.warn("skipping corrupt session file", { file: entry, error: String(err) });
+      }
+    }
+    records.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return records;
+  }
+  /**
+   * Update specific fields on an existing session record.
+   * Returns the updated record, or undefined if not found.
+   */
+  async update(id, updates) {
+    const existing = await this.get(id);
+    if (!existing) return void 0;
+    const updated = { ...existing, ...updates };
+    await this.save(updated);
+    return updated;
+  }
+  /**
+   * Soft-close a session: set status='closed' and record the timestamp.
+   * The record is preserved for history.
+   * Returns the updated record, or undefined if not found.
+   */
+  async close(id) {
+    return this.update(id, {
+      status: "closed",
+      closedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Append a turn summary to a session record's local history.
+   * Caps the history at MAX_LOCAL_TURNS entries (oldest removed first).
+   * Returns the updated record, or undefined if not found.
+   */
+  async appendTurn(id, turn) {
+    const record = await this.get(id);
+    if (!record) return void 0;
+    const turns = record.turns ? [...record.turns] : [];
+    turns.push(turn);
+    while (turns.length > MAX_LOCAL_TURNS) {
+      turns.shift();
+    }
+    return this.update(id, { turns });
+  }
+  /**
+   * Find a session by scope: matching serverName, workingDirectory, and optional name.
+   * Only returns active sessions.
+   */
+  async getByScope(options) {
+    const records = await this.list({
+      status: "active",
+      serverName: options.serverName,
+      workingDirectory: options.workingDirectory,
+      ...options.name ? { name: options.name } : {}
+    });
+    if (options.name) {
+      return records.find((r) => r.name === options.name);
+    }
+    return records[0];
+  }
+};
+
+// src/auth/handler.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import * as fs2 from "fs/promises";
+import * as os2 from "os";
+import * as path2 from "path";
+var log5 = createLogger("auth");
+function authFilePath(configDir) {
+  const dir = configDir ?? path2.join(os2.homedir(), ".ahpx");
+  return path2.join(dir, "auth.json");
+}
+var AuthHandler = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.configDir = options.configDir ?? path2.join(os2.homedir(), ".ahpx");
+    this.explicitToken = options.token;
+    this.interactive = options.interactive ?? !!process.stdin.isTTY;
+  }
+  configDir;
+  explicitToken;
+  interactive;
+  /**
+   * Handle an authRequired notification — find a token and authenticate.
+   * Returns true if authentication succeeded, false otherwise.
+   */
+  async handleAuthRequired(resource) {
+    const resourceUri = resource.resource;
+    if (this.explicitToken) {
+      return this.tryAuthenticate(resourceUri, this.explicitToken);
+    }
+    const envToken = process.env.AHPX_TOKEN;
+    if (envToken) {
+      return this.tryAuthenticate(resourceUri, envToken);
+    }
+    const stored = await this.loadToken(resourceUri);
+    if (stored) {
+      const success = await this.tryAuthenticate(resourceUri, stored);
+      if (success) return true;
+    }
+    if (this.interactive) {
+      const token = await this.promptForToken(resource);
+      if (token) {
+        const success = await this.tryAuthenticate(resourceUri, token);
+        if (success) {
+          await this.storeToken(resourceUri, token);
+        }
+        return success;
+      }
+    }
+    return false;
+  }
+  /**
+   * Store a token for a resource in ~/.ahpx/auth.json.
+   * File is created with 0600 permissions.
+   */
+  async storeToken(resourceUri, token) {
+    const filePath = authFilePath(this.configDir);
+    await fs2.mkdir(path2.dirname(filePath), { recursive: true, mode: 448 });
+    let store = {};
+    try {
+      const raw = await fs2.readFile(filePath, "utf-8");
+      store = JSON.parse(raw);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        log5.warn("corrupt auth file, starting fresh", { error: String(err) });
+      }
+    }
+    store[resourceUri] = {
+      token,
+      storedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const tmp = `${filePath}.${randomUUID4()}.tmp`;
+    await fs2.writeFile(tmp, `${JSON.stringify(store, null, "	")}
+`, { mode: 384 });
+    await fs2.rename(tmp, filePath);
+    try {
+      await fs2.chmod(filePath, 384);
+    } catch {
+    }
+  }
+  /**
+   * Load a stored token for a resource.
+   */
+  async loadToken(resourceUri) {
+    try {
+      const raw = await fs2.readFile(authFilePath(this.configDir), "utf-8");
+      const store = JSON.parse(raw);
+      return store[resourceUri]?.token;
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        log5.warn("skipping corrupt auth file", { error: String(err) });
+      }
+      return void 0;
+    }
+  }
+  /**
+   * Try to authenticate with the server.
+   */
+  async tryAuthenticate(resource, token) {
+    try {
+      await this.client.authenticate(resource, token);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Prompt the user for a token interactively.
+   */
+  promptForToken(resource) {
+    const name = resource.resource_name ?? resource.resource;
+    return new Promise((resolve) => {
+      const readline = __require("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr
+      });
+      rl.question(`Token for ${name}: `, (answer) => {
+        rl.close();
+        const token = answer.trim();
+        resolve(token || void 0);
+      });
+      rl.on("close", () => resolve(void 0));
+    });
+  }
+};
+
+// src/session/persistence.ts
+var log6 = createLogger("persistence");
+var SESSION_NOT_FOUND = -32001;
+var SessionPersistence = class {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Resume a locally-stored session on a connected server.
+   *
+   * Subscribes to the session URI and verifies it is still alive. Returns
+   * a ResumeOutcome indicating whether the session was found.
+   */
+  async resume(record, client) {
+    try {
+      await client.subscribe(record.sessionUri);
+      log6.info("session resumed", { sessionUri: record.sessionUri });
+      return { status: "resumed" };
+    } catch (err) {
+      if (err instanceof RpcError && err.code === SESSION_NOT_FOUND) {
+        log6.info("session not found on server", { sessionUri: record.sessionUri });
+        return { status: "not_found" };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      log6.info("resume failed", { sessionUri: record.sessionUri, error: message });
+      return { status: "error", message };
+    }
+  }
+  /**
+   * Save a turn summary to the local session record after a prompt completes.
+   */
+  async saveTurn(recordId, result) {
+    const summary = buildTurnSummary(result);
+    return this.store.appendTurn(recordId, summary);
+  }
+  /**
+   * Sync local session records for a server with the server's actual state.
+   *
+   * Compares locally-active records against the server's session list to
+   * find sessions that were added remotely, disposed remotely, or updated.
+   */
+  async sync(client, serverName) {
+    const result = { added: [], removed: [], updated: [] };
+    const serverSessions = await client.listSessions();
+    const serverUris = new Set(serverSessions.items.map((s) => s.resource));
+    const serverMap = new Map(serverSessions.items.map((s) => [s.resource, s]));
+    const localRecords = await this.store.list({ status: "active", serverName });
+    const localUris = new Set(localRecords.map((r) => r.sessionUri));
+    for (const uri of serverUris) {
+      if (!localUris.has(uri)) {
+        result.added.push(uri);
+      }
+    }
+    for (const record of localRecords) {
+      if (!serverUris.has(record.sessionUri)) {
+        result.removed.push(record.id);
+        await this.store.close(record.id);
+        log6.info("closed stale local record", { id: record.id, sessionUri: record.sessionUri });
+      }
+    }
+    for (const record of localRecords) {
+      const serverSession = serverMap.get(record.sessionUri);
+      if (!serverSession) continue;
+      let changed = false;
+      const updates = {};
+      if (serverSession.title && serverSession.title !== record.title) {
+        updates.title = serverSession.title;
+        changed = true;
+      }
+      if (changed) {
+        await this.store.update(record.id, updates);
+        result.updated.push(record.id);
+      }
+    }
+    return result;
+  }
+};
+
+// src/uri.ts
+function hasScheme(input) {
+  return /^[a-zA-Z][a-zA-Z0-9+.-]+:/.test(input);
+}
+function ensureFileUri(pathOrUri) {
+  if (!pathOrUri) return pathOrUri;
+  if (hasScheme(pathOrUri)) return pathOrUri;
+  const normalized = pathOrUri.replace(/\\/g, "/");
+  if (/^[a-zA-Z]:\//.test(normalized) || /^[a-zA-Z]:$/.test(normalized)) {
+    return `file:///${encodeFilePathComponents(normalized)}`;
+  }
+  if (normalized.startsWith("/")) {
+    return `file://${encodeFilePathComponents(normalized)}`;
+  }
+  return pathOrUri;
+}
+function fileUriToDisplayPath(uri) {
+  if (!uri.startsWith("file:///")) return uri;
+  try {
+    const parsed = new URL(uri);
+    const pathname = decodeURIComponent(parsed.pathname);
+    if (/^\/[a-zA-Z]:/.test(pathname)) {
+      return pathname.slice(1);
+    }
+    return pathname;
+  } catch {
+    const pathname = decodeURIComponent(uri.slice("file://".length));
+    if (/^\/[a-zA-Z]:/.test(pathname)) {
+      return pathname.slice(1);
+    }
+    return pathname;
+  }
+}
+function encodeFilePathComponents(filePath) {
+  return filePath.split("/").map((component) => {
+    if (!component) return component;
+    if (/^[a-zA-Z]:$/.test(component)) return component;
+    return encodeURIComponent(component);
+  }).join("/");
+}
+
+export {
+  ActionType,
+  RpcError,
+  RpcTimeoutError,
+  ProtocolLayer,
+  PendingMessageKind,
+  SessionLifecycle,
+  SessionStatus,
+  ResponsePartKind,
+  ToolCallStatus,
+  SessionHandle,
+  StateMirror,
+  Transport,
+  ActiveClientManager,
+  ReconnectManager,
+  AhpClient,
+  setVerbose,
+  createLogger,
+  ForwardingFormatter,
+  WebhookForwarder,
+  WebSocketForwarder,
+  HealthChecker,
+  truncatePreview,
+  buildTurnSummary,
+  SessionStore,
+  AuthHandler,
+  SessionPersistence,
+  ensureFileUri,
+  fileUriToDisplayPath
+};