opencandle 0.9.0 → 0.11.0

package/gui/server/invoke-tool.ts

@@ -4,14 +4,24 @@ import type { SessionManager } from "@earendil-works/pi-coding-agent";
 import type { TSchema } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import { getDefaults } from "../../src/memory/tool-defaults.js";
+import {
+  clearPendingSessionAction,
+  hasAcceptedSessionAction,
+  hasPendingSessionAction,
+  recordAcceptedSessionAction,
+  recordPendingSessionAction,
+} from "../../src/pi/session-action-dedupe.js";
 import { wrapWithDefaults } from "../../src/runtime/tool-defaults-wrapper.js";
 import { getAllTools } from "../../src/tools/index.js";
 import type { AskUserHandler } from "../../src/types/index.js";
+import type { LocalSessionCoordinator } from "./local-session-coordinator.js";
 import { buildToolInvokeAckMessage } from "./tool-invoke-ack.js";
 import {
   acquireWriterLock,
+  readWriterLock,
   refreshWriterLock,
   releaseWriterLock,
+  shouldBlockFailedCoordinatorAction,
   writerLockScopeForSession,
 } from "./writer-lock.js";
 
@@ -30,6 +40,7 @@ export interface ToolInvokeController {
     toolName: string,
     args: Record<string, unknown>,
     sessionId?: string,
+    options?: { actionId?: string; allowProxy?: boolean },
   ): Promise<InvokeToolResult>;
   handleToolInvokeMessage(client: ToolInvokeClient, data: Record<string, unknown>): Promise<void>;
 }
@@ -46,6 +57,10 @@ export interface ToolInvokeControllerOptions {
   resolveSessionManager?: (sessionId: string) => Promise<SessionManager | null>;
   broadcastSessionSnapshot?: (sessionManager: SessionManager) => void;
   broadcastSessions?: () => void;
+  localSessionCoordinator?: LocalSessionCoordinator;
+  localCoordinatorEndpoint?: string;
+  localCoordinatorSecret?: string;
+  syncWriterLockScope?: () => void;
 }
 
 export function createToolInvokeController({
@@ -60,13 +75,17 @@ export function createToolInvokeController({
   resolveSessionManager,
   broadcastSessionSnapshot,
   broadcastSessions,
+  localSessionCoordinator,
+  localCoordinatorEndpoint,
+  localCoordinatorSecret,
+  syncWriterLockScope,
 }: ToolInvokeControllerOptions): ToolInvokeController {
   async function handleToolInvoke(
     toolName: string,
     args: Record<string, unknown>,
     sessionId = "",
+    options: { actionId?: string; allowProxy?: boolean } = {},
   ): Promise<InvokeToolResult> {
-    if (role !== "writer") throw new Error("Read-only follower mode");
     const tool = getTools().find((candidate) => candidate.name === toolName);
     if (!tool) throw new Error(`Unknown tool: ${toolName}`);
 
@@ -77,15 +96,50 @@ export function createToolInvokeController({
       resolveSessionManager,
     );
     const useCurrentSession = sameSessionStorage(currentSessionManager, runSessionManager);
+    const allowProxy = options.allowProxy !== false;
+    const shouldProxyToolInvoke =
+      allowProxy &&
+      (role !== "writer" || !useCurrentSession) &&
+      canProxyToolInvokeToCoordinator(runSessionManager);
+    if (shouldProxyToolInvoke) {
+      const proxied = await proxyToolInvokeToCoordinator(
+        runSessionManager,
+        toolName,
+        args,
+        options.actionId,
+      );
+      if (proxied) return proxied;
+      if (options.actionId && hasAcceptedSessionAction(runSessionManager, options.actionId)) {
+        throw new Error("OpenCandle already accepted this action in the active session.");
+      }
+      if (options.actionId && hasPendingSessionAction(runSessionManager, options.actionId)) {
+        throw new Error("OpenCandle is reconnecting to this session.");
+      }
+      if (options.actionId && shouldBlockFailedCoordinatorAction(runSessionManager)) {
+        throw new Error("OpenCandle is reconnecting to this session.");
+      }
+    }
+    if (options.actionId && hasAcceptedSessionAction(runSessionManager, options.actionId)) {
+      throw new Error("OpenCandle already accepted this action in the active session.");
+    }
+    if (options.actionId && hasPendingSessionAction(runSessionManager, options.actionId)) {
+      throw new Error("OpenCandle is reconnecting to this session.");
+    }
     let acquiredLockScope = "";
     let lockHeartbeat: ReturnType<typeof setInterval> | undefined;
-    if (!useCurrentSession) {
+    const needsWriterLock = !useCurrentSession || role !== "writer";
+    // The writer fast path must fail closed like chat runs when this process
+    // lost its lock scope migration, or it can double-write to a session
+    // another process now owns.
+    if (!needsWriterLock) syncWriterLockScope?.();
+    if (needsWriterLock) {
       const lockScope = writerLockScopeForSession(runSessionManager);
-      const lockResult = await acquireWriterLock(lockScope, "gui");
+      const lockResult = await acquireWriterLock(lockScope, "gui", {
+        coordinatorEndpoint: localCoordinatorEndpoint,
+        coordinatorSecret: localCoordinatorSecret,
+      });
       if (lockResult.role !== "writer") {
-        throw new Error(
-          `Session is currently being written by ${lockResult.lock.processKind} (pid ${lockResult.lock.pid}).`,
-        );
+        throw new Error("OpenCandle is reconnecting to this session.");
       }
       acquiredLockScope = lockScope;
       lockHeartbeat = setInterval(() => refreshWriterLock(lockScope), 5000);
@@ -93,12 +147,27 @@ export function createToolInvokeController({
 
     try {
       const runSessionId = safeSessionId(runSessionManager);
-      const result = await invokeTool(runSessionManager, tool, args, "ui", {
-        askUserHandler:
-          runSessionId && askUserHandlerForSessionId
-            ? askUserHandlerForSessionId(runSessionId)
-            : askUserHandler,
-      });
+      recordPendingSessionAction(runSessionManager, options.actionId ?? "");
+      let actionAccepted = false;
+      const recordAcceptedAction = () => {
+        if (actionAccepted) return;
+        recordAcceptedSessionAction(runSessionManager, options.actionId ?? "");
+        actionAccepted = true;
+      };
+      let result: InvokeToolResult;
+      try {
+        result = await invokeTool(runSessionManager, tool, args, "ui", {
+          askUserHandler:
+            runSessionId && askUserHandlerForSessionId
+              ? askUserHandlerForSessionId(runSessionId)
+              : askUserHandler,
+          onTranscriptStarted: recordAcceptedAction,
+        });
+      } catch (error) {
+        if (!actionAccepted) clearPendingSessionAction(runSessionManager, options.actionId ?? "");
+        throw error;
+      }
+      recordAcceptedAction();
       if (!result.isError && marketStateToolMapping(toolName) != null) {
         onMarketStateChanged?.();
       }
@@ -120,10 +189,28 @@ export function createToolInvokeController({
     data: Record<string, unknown>,
   ): Promise<void> {
     const requestId = typeof data.requestId === "string" ? data.requestId : "";
+    const actionId = typeof data.actionId === "string" ? data.actionId : "";
     const toolName = String(data.toolName ?? "");
     const sessionId = typeof data.sessionId === "string" ? data.sessionId : "";
+    const allowProxy = data.allowProxy !== false;
     try {
-      const result = await handleToolInvoke(toolName, requestArgs(data.args), sessionId);
+      const invoke = () =>
+        handleToolInvoke(toolName, requestArgs(data.args), sessionId, { actionId, allowProxy });
+      const actionResult =
+        localSessionCoordinator && actionId
+          ? await localSessionCoordinator.runSessionAction(
+              {
+                sessionId: sessionId || safeSessionId(getSessionManager()),
+                actionId,
+                actionType: "tool.invoke",
+                payload: { toolName, args: requestArgs(data.args) },
+                source: "browser",
+              },
+              invoke,
+            )
+          : await invoke().then((result) => ({ ok: true as const, duplicate: false, result }));
+      if (!actionResult.ok) throw new Error(actionResult.message);
+      const result = actionResult.result;
       if (requestId) {
         client.send(buildToolInvokeAckMessage(requestId, toolName, result));
       }
@@ -146,6 +233,64 @@ export function createToolInvokeController({
   return { handleToolInvoke, handleToolInvokeMessage };
 }
 
+export function canProxyToolInvokeToCoordinator(runSessionManager: SessionManager): boolean {
+  let lockScope: string;
+  try {
+    lockScope = writerLockScopeForSession(runSessionManager);
+  } catch {
+    return false;
+  }
+  const lock = readWriterLock(lockScope);
+  return Boolean(
+    lock?.processKind === "gui" &&
+      lock.coordinatorEndpoint &&
+      lock.coordinatorSecret &&
+      lock.pid !== process.pid,
+  );
+}
+
+async function proxyToolInvokeToCoordinator(
+  runSessionManager: SessionManager,
+  toolName: string,
+  args: Record<string, unknown>,
+  actionId = "",
+): Promise<InvokeToolResult | null> {
+  const lock = readWriterLock(writerLockScopeForSession(runSessionManager));
+  if (!lock?.coordinatorEndpoint || !lock.coordinatorSecret) return null;
+  const endpoint = new URL("/api/local-coordinator/tool-invoke", lock.coordinatorEndpoint);
+  let response: Response;
+  try {
+    response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-opencandle-coordinator-secret": lock.coordinatorSecret,
+      },
+      body: JSON.stringify({
+        sessionId: safeSessionId(runSessionManager),
+        actionId,
+        toolName,
+        args,
+      }),
+    });
+  } catch {
+    return null;
+  }
+  const body = asRecord(await response.json());
+  const ackResult = asRecord(body.result);
+  if (!response.ok || !ackResult.toolCallId) {
+    throw new Error(String(body.error ?? "OpenCandle is reconnecting to this session."));
+  }
+  return {
+    toolCallId: String(ackResult.toolCallId),
+    result: {
+      content: Array.isArray(ackResult.content) ? ackResult.content : [],
+      details: ackResult.details,
+    },
+    isError: Boolean(ackResult.isError),
+  };
+}
+
 function sameSessionStorage(current: SessionManager, target: SessionManager): boolean {
   if (current === target) return true;
   const currentFile = safeSessionFile(current);
@@ -192,7 +337,11 @@ export async function invokeToolFromUi(
   tool: AgentTool<TSchema, unknown>,
   args: Record<string, unknown>,
   source: "ui" | "background" = "ui",
-  options: { askUserHandler?: AskUserHandler; recordTranscript?: boolean } = {},
+  options: {
+    askUserHandler?: AskUserHandler;
+    recordTranscript?: boolean;
+    onTranscriptStarted?: () => void;
+  } = {},
 ): Promise<InvokeToolResult> {
   if (!Value.Check(tool.parameters, args)) {
     const errors = [...Value.Errors(tool.parameters, args)]
@@ -222,6 +371,7 @@ export async function invokeToolFromUi(
   const recordTranscript = options.recordTranscript ?? true;
   if (recordTranscript) {
     sessionManager.appendMessage(assistant);
+    options.onTranscriptStarted?.();
   }
 
   const wrapped = wrapWithDefaults(tool, getDefaults(tool.name));
@@ -299,8 +449,6 @@ function marketStateToolMapping(toolName: string): { domain: string; targetType:
       return { domain: "watchlist", targetType: "watchlist_item" };
     case "track_portfolio":
       return { domain: "portfolio", targetType: "portfolio_lot" };
-    case "track_prediction":
-      return { domain: "predictions", targetType: "prediction" };
     case "manage_alerts":
       return { domain: "alerts", targetType: "alert_rule" };
     case "daily_watchlist_report":

package/gui/server/local-session-coordinator.ts

@@ -0,0 +1,97 @@
+export type SessionActionType =
+  | "chat.prompt"
+  | "tool.invoke"
+  | "ask_user.answer"
+  | "ask_user.cancel"
+  | "run.cancel";
+
+export type SessionActionSource = "gui" | "tui" | "browser";
+
+export interface SessionActionEnvelope {
+  sessionId: string;
+  actionId: string;
+  actionType: SessionActionType;
+  payload: Record<string, unknown>;
+  source: SessionActionSource;
+}
+
+export type SessionActionResult<T = unknown> =
+  | { ok: true; duplicate: boolean; result: T }
+  | { ok: false; code: "session_busy"; message: string };
+
+export interface LocalSessionCoordinator {
+  runSessionAction<T>(
+    action: SessionActionEnvelope,
+    handler: (action: SessionActionEnvelope) => Promise<T>,
+  ): Promise<SessionActionResult<T>>;
+}
+
+export interface LocalSessionCoordinatorOptions {
+  dedupeRetentionMs?: number;
+  now?: () => number;
+}
+
+interface AcceptedAction {
+  expiresAt: number;
+  result: unknown;
+}
+
+const DEFAULT_DEDUPE_RETENTION_MS = 10 * 60 * 1000;
+const BUSY_MESSAGE = "OpenCandle is still working in this session. Try again when it finishes.";
+
+export function createLocalSessionCoordinator(
+  options: LocalSessionCoordinatorOptions = {},
+): LocalSessionCoordinator {
+  const now = options.now ?? Date.now;
+  const dedupeRetentionMs = options.dedupeRetentionMs ?? DEFAULT_DEDUPE_RETENTION_MS;
+  const acceptedActions = new Map<string, AcceptedAction>();
+  const activeActions = new Map<string, Promise<unknown>>();
+  const activeRunSessions = new Set<string>();
+
+  async function runSessionAction<T>(
+    action: SessionActionEnvelope,
+    handler: (action: SessionActionEnvelope) => Promise<T>,
+  ): Promise<SessionActionResult<T>> {
+    pruneExpiredActions();
+    const actionKey = `${action.sessionId}:${action.actionId}`;
+    const accepted = acceptedActions.get(actionKey);
+    if (accepted) return { ok: true, duplicate: true, result: accepted.result as T };
+    const active = activeActions.get(actionKey);
+    if (active) return { ok: true, duplicate: true, result: (await active) as T };
+
+    if (isRunAdmissionAction(action) && activeRunSessions.has(action.sessionId)) {
+      return { ok: false, code: "session_busy", message: BUSY_MESSAGE };
+    }
+
+    if (isRunAdmissionAction(action)) activeRunSessions.add(action.sessionId);
+    const runAction = (async () => {
+      const result = await handler(action);
+      acceptedActions.set(actionKey, {
+        expiresAt: now() + dedupeRetentionMs,
+        result,
+      });
+      return result;
+    })();
+    activeActions.set(actionKey, runAction);
+    try {
+      const result = await runAction;
+      return { ok: true, duplicate: false, result };
+    } finally {
+      activeActions.delete(actionKey);
+      if (isRunAdmissionAction(action)) activeRunSessions.delete(action.sessionId);
+    }
+  }
+
+  function pruneExpiredActions(): void {
+    const currentTime = now();
+    for (const [actionKey, accepted] of acceptedActions) {
+      if (accepted.expiresAt <= currentTime) acceptedActions.delete(actionKey);
+    }
+  }
+
+  return { runSessionAction };
+}
+
+function isRunAdmissionAction(action: SessionActionEnvelope): boolean {
+  return action.actionType === "chat.prompt" || action.actionType === "tool.invoke";
+}

package/gui/server/market-state-api.ts

@@ -9,7 +9,6 @@ export interface MarketStateSnapshot {
   instruments: Array<NonNullable<ReturnType<MarketStateService["getInstrument"]>>>;
   watchlist: ReturnType<MarketStateService["listWatchlistItems"]>;
   portfolio: ReturnType<MarketStateService["listPortfolioLots"]>;
-  predictions: ReturnType<MarketStateService["listPredictions"]>;
   alerts: ReturnType<MarketStateService["listAlertRules"]>;
   alertEvents: ReturnType<MarketStateService["listAlertEvents"]>;
   alertCheckRuns: ReturnType<MarketStateService["listAlertCheckRuns"]>;
@@ -51,17 +50,6 @@ export interface MarketStateQuoteSnapshot {
     stale?: boolean;
     reason?: string;
   }>;
-  predictionQuotes: Array<{
-    predictionId: number;
-    instrumentId: number;
-    symbol: string;
-    status: "ok" | "unavailable";
-    currentPrice?: number;
-    changePercent?: number;
-    fetchedAt?: string;
-    stale?: boolean;
-    reason?: string;
-  }>;
   portfolioSummary: {
     baseCurrency: string;
     totalValue: number;
@@ -86,7 +74,6 @@ export function buildMarketStateSnapshot(db?: Database.Database): MarketStateSna
         .filter((instrument) => instrument != null),
       watchlist: service.listWatchlistItems(),
       portfolio: service.listPortfolioLots(),
-      predictions: service.listPredictions(),
       alerts,
       alertEvents: service.listAlertEvents(),
       alertCheckRuns: service.listAlertCheckRuns(),
@@ -109,13 +96,8 @@ export async function buildMarketStateQuoteSnapshot(
   try {
     const watchlist = service.listWatchlistItems();
     const portfolio = service.listPortfolioLots();
-    const predictions = service.listPredictions();
     const symbols = [
-      ...new Set([
-        ...watchlist.map((item) => item.symbol),
-        ...portfolio.map((lot) => lot.symbol),
-        ...predictions.map((prediction) => prediction.symbol),
-      ]),
+      ...new Set([...watchlist.map((item) => item.symbol), ...portfolio.map((lot) => lot.symbol)]),
     ];
     const quoteMap = new Map<string, Awaited<ReturnType<typeof fetchQuoteSnapshot>>>();
     for (const symbol of symbols) {
@@ -224,34 +206,10 @@ export async function buildMarketStateQuoteSnapshot(
         currency: quote.currency,
         reason: quote.reason ?? "quote unavailable",
       }));
-    const predictionQuotes = predictions.map((prediction) => {
-      const quote = quoteMap.get(prediction.symbol);
-      if (quote == null || quote.status === "unavailable") {
-        return {
-          predictionId: prediction.id,
-          instrumentId: prediction.instrumentId,
-          symbol: prediction.symbol,
-          status: "unavailable" as const,
-          reason: quote?.reason ?? "quote unavailable",
-        };
-      }
-      return {
-        predictionId: prediction.id,
-        instrumentId: prediction.instrumentId,
-        symbol: prediction.symbol,
-        status: "ok" as const,
-        currentPrice: quote.price,
-        changePercent: quote.changePercent,
-        fetchedAt: quote.fetchedAt,
-        stale: quote.stale,
-      };
-    });
-
     return {
       generatedAt,
       watchlistQuotes,
       portfolioQuotes: portfolioQuotesWithAllocation,
-      predictionQuotes,
       portfolioSummary: {
         baseCurrency,
         totalValue,

package/gui/server/server.ts

@@ -25,6 +25,7 @@ import {
 import { createInitialGuiSessionManager } from "./gui-session-manager.js";
 import { createHttpRequestHandler, resolveSessionManagerById } from "./http-routes.js";
 import { createToolInvokeController } from "./invoke-tool.js";
+import { createLocalSessionCoordinator } from "./local-session-coordinator.js";
 import { buildMarketStateQuoteSnapshot } from "./market-state-api.js";
 import { createModelSetupController } from "./model-setup.js";
 import { isTrustedPrivateApiRequest } from "./private-api-access.js";
@@ -33,6 +34,7 @@ import { createSessionActionsController } from "./session-actions.js";
 import { createGracefulShutdown } from "./shutdown.js";
 import {
   acquireWriterLock,
+  migrateWriterLockScope,
   refreshWriterLock,
   releaseWriterLock,
   writerLockScopeForSession,
@@ -49,6 +51,8 @@ const automationHeartbeatMs = normalizeAutomationHeartbeatMs(
 );
 const allowRemotePrivateApi = process.env.OPENCANDLE_GUI_ALLOW_REMOTE_PRIVATE_API === "1";
 const privateApiSessionToken = randomBytes(32).toString("base64url");
+const localCoordinatorSecret = randomBytes(32).toString("base64url");
+const localCoordinatorEndpoint = `http://${coordinatorEndpointHost(host)}:${port}`;
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const webDist = resolve(__dirname, "../web/dist");
 
@@ -60,8 +64,12 @@ const initialSessionManager = createInitialGuiSessionManager(cwd);
 let sessionManager = initialSessionManager;
 const sessionDir = sessionManager.getSessionDir();
 const initialWriterLockScope = writerLockScopeForSession(sessionManager);
-const lockResult = await acquireWriterLock(initialWriterLockScope, "gui");
+const lockResult = await acquireWriterLock(initialWriterLockScope, "gui", {
+  coordinatorEndpoint: localCoordinatorEndpoint,
+  coordinatorSecret: localCoordinatorSecret,
+});
 let activeWriterLockScope = initialWriterLockScope;
+let currentWriterLockLost = false;
 let wsHub: WsHub;
 let quotePoller: BackgroundQuotePoller;
 const askUserBridge = createAskUserBridge({
@@ -91,8 +99,28 @@ const runtime = await createAgentSessionRuntime(
   { cwd, agentDir, sessionManager },
 );
 let session = runtime.session;
-const heartbeat = setInterval(() => refreshWriterLock(activeWriterLockScope), 5000);
+function syncCurrentWriterLockScope(): void {
+  if (currentWriterLockLost) throw new Error("OpenCandle is reconnecting to this session.");
+  if (lockResult.role !== "writer") return;
+  const nextScope = writerLockScopeForSession(sessionManager);
+  if (nextScope === activeWriterLockScope) return;
+  if (migrateWriterLockScope(activeWriterLockScope, nextScope)) {
+    activeWriterLockScope = nextScope;
+  } else {
+    currentWriterLockLost = true;
+    throw new Error("OpenCandle is reconnecting to this session.");
+  }
+}
+const heartbeat = setInterval(() => {
+  try {
+    syncCurrentWriterLockScope();
+    refreshWriterLock(activeWriterLockScope);
+  } catch {
+    clearInterval(heartbeat);
+  }
+}, 5000);
 const backgroundQuoteRefreshes = new BackgroundQuoteRefreshes();
+const localSessionCoordinator = createLocalSessionCoordinator();
 const quoteSnapshotStore = new QuoteSnapshotStore(() => buildMarketStateQuoteSnapshot());
 quotePoller = createBackgroundQuotePoller({
   getClientCount: () => wsHub.getClientCount(),
@@ -121,6 +149,10 @@ const toolInvokeController = createToolInvokeController({
   onMarketStateChanged: () => quoteSnapshotStore.invalidate(),
   askUserHandler: askUserBridge.ask,
   askUserHandlerForSessionId: (sessionId) => askUserBridge.askForSession(sessionId),
+  localCoordinatorEndpoint,
+  localCoordinatorSecret,
+  localSessionCoordinator,
+  syncWriterLockScope: syncCurrentWriterLockScope,
   resolveSessionManager: (sessionId) =>
     resolveSessionManagerById(
       { cwd, sessionDir, getSessionManager: () => sessionManager },
@@ -139,6 +171,7 @@ const sessionActionsController = createSessionActionsController({
   sendBoot: (client) => wsHub.sendBoot(client),
   broadcastState: () => wsHub.broadcastState(),
   broadcastSessions: () => wsHub.broadcastSessions(),
+  localSessionCoordinator,
 });
 wsHub = createWsHub({
   role: lockResult.role,
@@ -163,11 +196,12 @@ let unsubscribeSession = wsHub.subscribeToSessionEvents();
 runtime.setRebindSession(async (nextSession) => {
   const nextWriterLockScope = writerLockScopeForSession(nextSession.sessionManager);
   if (lockResult.role === "writer" && nextWriterLockScope !== activeWriterLockScope) {
-    const nextLockResult = await acquireWriterLock(nextWriterLockScope, "gui");
+    const nextLockResult = await acquireWriterLock(nextWriterLockScope, "gui", {
+      coordinatorEndpoint: localCoordinatorEndpoint,
+      coordinatorSecret: localCoordinatorSecret,
+    });
     if (nextLockResult.role !== "writer") {
-      throw new Error(
-        `Session is currently being written by ${nextLockResult.lock.processKind} (pid ${nextLockResult.lock.pid}).`,
-      );
+      throw new Error("OpenCandle is reconnecting to this session.");
     }
     releaseWriterLock(activeWriterLockScope);
     activeWriterLockScope = nextWriterLockScope;
@@ -187,7 +221,10 @@ const httpRequestHandler = createHttpRequestHandler({
   agentDir,
   sessionDir,
   privateApiSessionToken,
+  localCoordinatorEndpoint,
+  localCoordinatorSecret,
   allowRemotePrivateApi,
+  syncCurrentWriterLockScope,
   getSession: () => session,
   getSessionManager: () => sessionManager,
   createSessionForManager: async (targetSessionManager) =>
@@ -203,7 +240,9 @@ const httpRequestHandler = createHttpRequestHandler({
   wsHub,
   modelSetupController,
   sessionActionsController,
+  toolInvokeController,
   quoteSnapshotStore,
+  localSessionCoordinator,
 });
 
 const server = createServer((req, res) => {
@@ -240,5 +279,11 @@ const shutdown = createGracefulShutdown({
   exit: (code) => process.exit(code),
 });
 
+function coordinatorEndpointHost(bindHost: string): string {
+  if (bindHost === "0.0.0.0") return "127.0.0.1";
+  if (bindHost === "::") return "[::1]";
+  return bindHost.includes(":") && !bindHost.startsWith("[") ? `[${bindHost}]` : bindHost;
+}
+
 process.once("SIGINT", shutdown);
 process.once("SIGTERM", shutdown);