opencandle 0.11.1 → 0.12.0

package/dist/gui/server/invoke-tool.d.ts

@@ -0,0 +1,47 @@
+import type { AgentTool, AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { SessionManager } from "@earendil-works/pi-coding-agent";
+import type { TSchema } from "@sinclair/typebox";
+import { getAllTools } from "../../tools/index.js";
+import type { AskUserHandler } from "../../types/index.js";
+import type { LocalSessionCoordinator } from "./local-session-coordinator.js";
+export interface InvokeToolResult {
+    toolCallId: string;
+    result: AgentToolResult<unknown>;
+    isError: boolean;
+}
+interface ToolInvokeClient {
+    send(message: unknown): void;
+}
+export interface ToolInvokeController {
+    handleToolInvoke(toolName: string, args: Record<string, unknown>, sessionId?: string, options?: {
+        actionId?: string;
+        allowProxy?: boolean;
+        recordTranscript?: boolean;
+    }): Promise<InvokeToolResult>;
+    handleToolInvokeMessage(client: ToolInvokeClient, data: Record<string, unknown>): Promise<void>;
+}
+export interface ToolInvokeControllerOptions {
+    role: string;
+    getSessionManager: () => SessionManager;
+    broadcastState: () => void;
+    onMarketStateChanged?: () => void;
+    getTools?: typeof getAllTools;
+    invokeTool?: typeof invokeToolFromUi;
+    askUserHandler?: AskUserHandler;
+    askUserHandlerForSessionId?: (sessionId: string) => AskUserHandler;
+    resolveSessionManager?: (sessionId: string) => Promise<SessionManager | null>;
+    broadcastSessionSnapshot?: (sessionManager: SessionManager) => void;
+    broadcastSessions?: () => void;
+    localSessionCoordinator?: LocalSessionCoordinator;
+    localCoordinatorEndpoint?: string;
+    localCoordinatorSecret?: string;
+    syncWriterLockScope?: () => void;
+}
+export declare function createToolInvokeController({ role, getSessionManager, broadcastState, onMarketStateChanged, getTools, invokeTool, askUserHandler, askUserHandlerForSessionId, resolveSessionManager, broadcastSessionSnapshot, broadcastSessions, localSessionCoordinator, localCoordinatorEndpoint, localCoordinatorSecret, syncWriterLockScope, }: ToolInvokeControllerOptions): ToolInvokeController;
+export declare function canProxyToolInvokeToCoordinator(runSessionManager: SessionManager): boolean;
+export declare function invokeToolFromUi(sessionManager: SessionManager, tool: AgentTool<TSchema, unknown>, args: Record<string, unknown>, source?: "ui" | "background", options?: {
+    askUserHandler?: AskUserHandler;
+    recordTranscript?: boolean;
+    onTranscriptStarted?: () => void;
+}): Promise<InvokeToolResult>;
+export {};

package/dist/gui/server/invoke-tool.js

@@ -0,0 +1,373 @@
+import { Value } from "@sinclair/typebox/value";
+import { getDefaults } from "../../memory/tool-defaults.js";
+import { clearPendingSessionAction, hasAcceptedSessionAction, hasPendingSessionAction, recordAcceptedSessionAction, recordPendingSessionAction, } from "../../pi/session-action-dedupe.js";
+import { wrapWithDefaults } from "../../runtime/tool-defaults-wrapper.js";
+import { getAllTools } from "../../tools/index.js";
+import { buildToolInvokeAckMessage } from "./tool-invoke-ack.js";
+import { acquireWriterLock, readWriterLock, refreshWriterLock, releaseWriterLock, shouldBlockFailedCoordinatorAction, writerLockScopeForSession, } from "./writer-lock.js";
+export function createToolInvokeController({ role, getSessionManager, broadcastState, onMarketStateChanged, getTools = getAllTools, invokeTool = invokeToolFromUi, askUserHandler, askUserHandlerForSessionId, resolveSessionManager, broadcastSessionSnapshot, broadcastSessions, localSessionCoordinator, localCoordinatorEndpoint, localCoordinatorSecret, syncWriterLockScope, }) {
+    async function handleToolInvoke(toolName, args, sessionId = "", options = {}) {
+        const tool = getTools().find((candidate) => candidate.name === toolName);
+        if (!tool)
+            throw new Error(`Unknown tool: ${toolName}`);
+        const currentSessionManager = getSessionManager();
+        const runSessionManager = await resolveToolInvokeSessionManager(currentSessionManager, sessionId, 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, options.recordTranscript);
+            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;
+        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", {
+                coordinatorEndpoint: localCoordinatorEndpoint,
+                coordinatorSecret: localCoordinatorSecret,
+            });
+            if (lockResult.role !== "writer") {
+                throw new Error("OpenCandle is reconnecting to this session.");
+            }
+            acquiredLockScope = lockScope;
+            lockHeartbeat = setInterval(() => refreshWriterLock(lockScope), 5000);
+        }
+        try {
+            const runSessionId = safeSessionId(runSessionManager);
+            recordPendingSessionAction(runSessionManager, options.actionId ?? "");
+            let actionAccepted = false;
+            const recordAcceptedAction = () => {
+                if (actionAccepted)
+                    return;
+                recordAcceptedSessionAction(runSessionManager, options.actionId ?? "");
+                actionAccepted = true;
+            };
+            let result;
+            try {
+                result = await invokeTool(runSessionManager, tool, args, "ui", {
+                    askUserHandler: runSessionId && askUserHandlerForSessionId
+                        ? askUserHandlerForSessionId(runSessionId)
+                        : askUserHandler,
+                    onTranscriptStarted: recordAcceptedAction,
+                    recordTranscript: options.recordTranscript,
+                });
+            }
+            catch (error) {
+                if (!actionAccepted)
+                    clearPendingSessionAction(runSessionManager, options.actionId ?? "");
+                throw error;
+            }
+            recordAcceptedAction();
+            if (!result.isError && marketStateToolMapping(toolName, args) != null) {
+                onMarketStateChanged?.();
+            }
+            if (useCurrentSession) {
+                broadcastState();
+            }
+            else {
+                broadcastSessionSnapshot?.(runSessionManager);
+                broadcastSessions?.();
+            }
+            return result;
+        }
+        finally {
+            if (lockHeartbeat)
+                clearInterval(lockHeartbeat);
+            if (acquiredLockScope)
+                releaseWriterLock(acquiredLockScope);
+        }
+    }
+    async function handleToolInvokeMessage(client, data) {
+        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 {
+            if (!sessionId.trim())
+                throw new Error("sessionId is required");
+            if (!actionId.trim())
+                throw new Error("actionId is required");
+            const recordTranscript = data.recordTranscript === false ? false : undefined;
+            const invoke = () => handleToolInvoke(toolName, requestArgs(data.args), sessionId, {
+                actionId,
+                allowProxy,
+                recordTranscript,
+            });
+            const actionResult = localSessionCoordinator
+                ? await localSessionCoordinator.runSessionAction({
+                    sessionId,
+                    actionId,
+                    actionType: "tool.invoke",
+                    payload: {
+                        toolName,
+                        args: requestArgs(data.args),
+                        ...(recordTranscript === false ? { recordTranscript: false } : {}),
+                    },
+                    source: "browser",
+                }, invoke)
+                : await invoke().then((result) => ({ ok: true, duplicate: false, result }));
+            if (!actionResult.ok)
+                throw new Error(actionResult.message);
+            const result = actionResult.result;
+            if (requestId) {
+                client.send(buildToolInvokeAckMessage(requestId, toolName, result));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (requestId) {
+                client.send({
+                    type: "tool.invoke.result",
+                    requestId,
+                    ok: false,
+                    toolName,
+                    error: { message },
+                });
+                return;
+            }
+            throw error;
+        }
+    }
+    return { handleToolInvoke, handleToolInvokeMessage };
+}
+export function canProxyToolInvokeToCoordinator(runSessionManager) {
+    let lockScope;
+    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, toolName, args, actionId = "", recordTranscript = undefined) {
+    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;
+    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,
+                ...(recordTranscript === false ? { recordTranscript: false } : {}),
+            }),
+        });
+    }
+    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, target) {
+    if (current === target)
+        return true;
+    const currentFile = safeSessionFile(current);
+    const targetFile = safeSessionFile(target);
+    return Boolean(currentFile && targetFile && currentFile === targetFile);
+}
+function safeSessionFile(sessionManager) {
+    try {
+        return sessionManager.getSessionFile() ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+function safeSessionId(sessionManager) {
+    try {
+        return sessionManager.getSessionId();
+    }
+    catch {
+        return "";
+    }
+}
+async function resolveToolInvokeSessionManager(currentSessionManager, sessionId, resolveSessionManager) {
+    const targetSessionId = sessionId.trim();
+    if (!targetSessionId || targetSessionId === safeSessionId(currentSessionManager)) {
+        return currentSessionManager;
+    }
+    const resolved = await resolveSessionManager?.(targetSessionId);
+    if (!resolved)
+        throw new Error("Unknown saved session");
+    return resolved;
+}
+function requestArgs(value) {
+    return typeof value === "object" && value !== null ? value : {};
+}
+export async function invokeToolFromUi(sessionManager, tool, args, source = "ui", options = {}) {
+    if (!Value.Check(tool.parameters, args)) {
+        const errors = [...Value.Errors(tool.parameters, args)]
+            .map((error) => `${error.path || "/"} ${error.message}`)
+            .join("; ");
+        throw new Error(errors || "Invalid tool arguments");
+    }
+    const toolCallId = `${source}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const call = {
+        type: "toolCall",
+        id: toolCallId,
+        name: tool.name,
+        arguments: args,
+    };
+    const assistant = {
+        role: "assistant",
+        content: [call],
+        api: "openai-responses",
+        provider: "openai",
+        model: "ui-direct",
+        usage: emptyUsage(),
+        stopReason: "toolUse",
+        timestamp: Date.now(),
+    };
+    const recordTranscript = options.recordTranscript ?? true;
+    if (recordTranscript) {
+        sessionManager.appendMessage(assistant);
+        options.onTranscriptStarted?.();
+    }
+    const wrapped = wrapWithDefaults(tool, getDefaults(tool.name));
+    let result;
+    let isError = false;
+    try {
+        result = await wrapped.execute(toolCallId, args, undefined, undefined, {
+            askUserHandler: options.askUserHandler,
+            hasUI: false,
+        });
+    }
+    catch (error) {
+        isError = true;
+        result = {
+            content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+            details: null,
+        };
+    }
+    if (recordTranscript) {
+        sessionManager.appendMessage({
+            role: "toolResult",
+            toolCallId,
+            toolName: tool.name,
+            content: result.content,
+            details: {
+                source,
+                args,
+                value: result.details,
+                ...stateChangeDetails(tool.name, args, result.details, source),
+            },
+            isError,
+            timestamp: Date.now(),
+        });
+    }
+    return { toolCallId, result, isError };
+}
+function stateChangeDetails(toolName, args, value, source) {
+    const mapping = marketStateToolMapping(toolName, args);
+    if (mapping == null)
+        return {};
+    const valueRecord = asRecord(value);
+    return {
+        stateChange: {
+            source,
+            domain: mapping.domain,
+            action: typeof args.action === "string" ? args.action : "invoke",
+            targetType: mapping.targetType,
+            targetId: numericField(valueRecord, "id"),
+            targetIds: numericArrayField(valueRecord, "removedLotIds"),
+            instrumentId: numericField(valueRecord, "instrumentId"),
+            instrumentIds: numericArrayField(valueRecord, "instrumentIds"),
+            toolName,
+        },
+    };
+}
+function marketStateToolMapping(toolName, args) {
+    switch (toolName) {
+        case "manage_watchlist":
+            if (args.action === "create" || args.action === "rename") {
+                return { domain: "watchlist", targetType: "watchlist" };
+            }
+            return { domain: "watchlist", targetType: "watchlist_item" };
+        case "track_portfolio":
+            if (args.action === "create" || args.action === "rename") {
+                return { domain: "portfolio", targetType: "portfolio" };
+            }
+            return { domain: "portfolio", targetType: "portfolio_lot" };
+        case "manage_alerts":
+            return { domain: "alerts", targetType: "alert_rule" };
+        case "daily_watchlist_report":
+            return { domain: "reports", targetType: "report_run" };
+        default:
+            return null;
+    }
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function numericField(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" ? value : undefined;
+}
+function numericArrayField(record, key) {
+    const value = record?.[key];
+    if (!Array.isArray(value))
+        return undefined;
+    const numbers = value.filter((item) => typeof item === "number");
+    return numbers.length > 0 ? numbers : undefined;
+}
+function emptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}

package/dist/gui/server/live-chat-event-adapter.d.ts

@@ -0,0 +1,19 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import type { ChatEvent, MessageAttachmentChip } from "../shared/chat-events.js";
+export interface LiveChatEventAdapterOptions {
+    runId: string;
+    sessionId: string;
+    startSeq: number;
+    emit: (event: ChatEvent) => void;
+    /**
+     * The user's words as typed. Workflow transforms can replace the first user
+     * message with an expanded prompt; the live view renders this instead.
+     */
+    originalPrompt?: string;
+    originalAttachments?: MessageAttachmentChip[];
+}
+export interface LiveChatEventAdapter {
+    handle(event: AgentSessionEvent): void;
+    nextSeq(): number;
+}
+export declare function createLiveChatEventAdapter(options: LiveChatEventAdapterOptions): LiveChatEventAdapter;

package/dist/gui/server/live-chat-event-adapter.js

@@ -0,0 +1,206 @@
+export function createLiveChatEventAdapter(options) {
+    let seq = options.startSeq;
+    let userCount = 0;
+    let assistantCount = 0;
+    let currentAssistantMessageId;
+    let lastAssistantMessageId;
+    const completedMessageIds = new Set();
+    const emit = (event) => {
+        options.emit({ ...event, sessionId: options.sessionId, seq: seq++ });
+    };
+    const ensureAssistantMessage = () => {
+        if (currentAssistantMessageId)
+            return currentAssistantMessageId;
+        currentAssistantMessageId = `${options.runId}-assistant-${++assistantCount}`;
+        lastAssistantMessageId = currentAssistantMessageId;
+        emit({
+            type: "message.created",
+            runId: options.runId,
+            messageId: currentAssistantMessageId,
+            role: "assistant",
+        });
+        return currentAssistantMessageId;
+    };
+    const messageIdForTool = () => lastAssistantMessageId ?? ensureAssistantMessage();
+    const completeAssistantMessage = (message) => {
+        const messageId = ensureAssistantMessage();
+        if (completedMessageIds.has(messageId))
+            return;
+        completedMessageIds.add(messageId);
+        emit({
+            type: "message.completed",
+            runId: options.runId,
+            messageId,
+            content: contentToChatContent(message.content),
+        });
+        currentAssistantMessageId = undefined;
+    };
+    return {
+        handle(event) {
+            switch (event.type) {
+                case "message_start": {
+                    const message = event.message;
+                    if (message.role === "user") {
+                        const messageId = `${options.runId}-user-${++userCount}`;
+                        const text = userCount === 1 && options.originalPrompt
+                            ? options.originalPrompt
+                            : messageText(message.content);
+                        emit({ type: "message.created", runId: options.runId, messageId, role: "user" });
+                        emit({
+                            type: "message.completed",
+                            runId: options.runId,
+                            messageId,
+                            content: userMessageContent(message.content, text),
+                            ...(userCount === 1 &&
+                                options.originalAttachments &&
+                                options.originalAttachments.length > 0
+                                ? { attachments: options.originalAttachments }
+                                : {}),
+                        });
+                        return;
+                    }
+                    if (message.role === "assistant") {
+                        ensureAssistantMessage();
+                    }
+                    return;
+                }
+                case "message_update": {
+                    const update = event.assistantMessageEvent;
+                    if (update.type === "text_delta") {
+                        emit({
+                            type: "message.delta",
+                            runId: options.runId,
+                            messageId: ensureAssistantMessage(),
+                            text: update.delta,
+                        });
+                    }
+                    if (update.type === "thinking_delta") {
+                        emit({
+                            type: "thinking.delta",
+                            runId: options.runId,
+                            text: update.delta,
+                        });
+                    }
+                    if (update.type === "thinking_end") {
+                        emit({
+                            type: "thinking.completed",
+                            runId: options.runId,
+                            text: update.content,
+                        });
+                    }
+                    return;
+                }
+                case "message_end": {
+                    const message = event.message;
+                    if (message.role === "assistant")
+                        completeAssistantMessage(message);
+                    return;
+                }
+                case "tool_execution_start": {
+                    const messageId = messageIdForTool();
+                    emit({
+                        type: "tool.started",
+                        runId: options.runId,
+                        toolCallId: event.toolCallId,
+                        messageId,
+                        name: event.toolName,
+                        input: event.args,
+                    });
+                    return;
+                }
+                case "tool_execution_update":
+                    emit({
+                        type: "tool.delta",
+                        runId: options.runId,
+                        toolCallId: event.toolCallId,
+                        chunk: event.partialResult,
+                    });
+                    return;
+                case "tool_execution_end": {
+                    const output = toolOutput(event.result, event.isError);
+                    if (event.isError) {
+                        emit({
+                            type: "tool.failed",
+                            runId: options.runId,
+                            toolCallId: event.toolCallId,
+                            error: {
+                                message: messageText(output.content),
+                                details: output.details,
+                            },
+                        });
+                    }
+                    else {
+                        emit({
+                            type: "tool.completed",
+                            runId: options.runId,
+                            toolCallId: event.toolCallId,
+                            output,
+                        });
+                    }
+                    return;
+                }
+            }
+        },
+        nextSeq() {
+            return seq;
+        },
+    };
+}
+function contentToChatContent(content) {
+    return content.flatMap((part) => {
+        if (part.type === "text")
+            return [{ type: "text", text: part.text }];
+        if (part.type === "toolCall")
+            return [{ type: "tool", toolCallId: part.id }];
+        return [];
+    });
+}
+function messageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => typeof part === "object" && part !== null && "text" in part && typeof part.text === "string"
+        ? part.text
+        : "")
+        .join("");
+}
+function userMessageContent(content, text) {
+    const parts = [{ type: "text", text }];
+    if (!Array.isArray(content))
+        return parts;
+    for (const part of content) {
+        const record = asRecord(part);
+        if (record.type !== "image")
+            continue;
+        const alt = typeof record.alt === "string" ? record.alt : undefined;
+        if (typeof record.url === "string") {
+            parts.push({ type: "image", url: record.url, alt });
+            continue;
+        }
+        if (typeof record.data === "string" && typeof record.mimeType === "string") {
+            parts.push({
+                type: "image",
+                url: `data:${record.mimeType};base64,${record.data}`,
+                data: record.data,
+                mimeType: record.mimeType,
+                alt,
+            });
+        }
+    }
+    return parts;
+}
+function toolOutput(result, isError) {
+    const record = asRecord(result);
+    return {
+        content: Array.isArray(record.content) ? record.content : [],
+        details: record.details,
+        isError,
+    };
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}

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

@@ -0,0 +1,26 @@
+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;
+}
+export declare function createLocalSessionCoordinator(options?: LocalSessionCoordinatorOptions): LocalSessionCoordinator;