@nordbyte/nordrelay 0.8.0 → 0.8.2

package/dist/{relay-external-activity-monitor.js → runtime/relay-external-activity-monitor.js}

@@ -1,7 +1,8 @@
-import {} from "./agent.js";
-import { getExternalSnapshotForSession } from "./agent-activity.js";
-import { friendlyErrorText } from "./error-messages.js";
-import {} from "./web-state.js";
+import {} from "../agents/shared/agent.js";
+import { getExternalSnapshotForSession } from "../agents/shared/agent-activity.js";
+import { renderExternalMirrorEvent, renderExternalMirrorStatus, trimLine, } from "../channels/shared/bot-rendering.js";
+import { friendlyErrorText } from "../core/error-messages.js";
+import {} from "../web/web-state.js";
 const CLI_ACTIVITY_ACTOR = {
     channel: "cli",
     label: "CLI",
@@ -16,6 +17,9 @@ export class RelayExternalActivityMonitor {
     snapshot() {
         return this.mirror ? { ...this.mirror } : null;
     }
+    reset() {
+        this.mirror = null;
+    }
     task() {
         if (!this.mirror) {
             return null;
@@ -81,7 +85,7 @@ export class RelayExternalActivityMonitor {
                 startedAt: snapshot.activity.startedAt?.toISOString() ?? null,
             };
             if (snapshot.activity.active) {
-                this.startExternalTurn(snapshot, info);
+                await this.startExternalTurn(snapshot, info);
             }
             return;
         }
@@ -91,36 +95,51 @@ export class RelayExternalActivityMonitor {
                 mirror.turnId = snapshot.activity.turnId;
                 mirror.startedAt = snapshot.activity.startedAt?.toISOString() ?? null;
                 mirror.latestAgentLine = undefined;
-                this.startExternalTurn(snapshot, info);
+                mirror.latestStatusAt = undefined;
+                mirror.latestMirroredEventLine = undefined;
+                await this.startExternalTurn(snapshot, info);
+            }
+            const mirrorMode = this.options.mirrorMode();
+            const newEvents = snapshot.events.filter((event) => event.lineNumber > mirror.lastLine);
+            this.broadcastExternalEvents(snapshot, newEvents, info, mirrorMode === "full");
+            if (mirrorMode === "full") {
+                await this.appendExternalEventMessages(snapshot, newEvents, mirror);
             }
-            this.broadcastExternalEvents(snapshot, snapshot.events.filter((event) => event.lineNumber > mirror.lastLine), info);
             mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
             mirror.latestStatus = externalStatusLine(snapshot, this.options.queueLength());
-            this.options.broadcastStatus(mirror.latestStatus, "info");
+            if (mirrorMode === "status" || mirrorMode === "full") {
+                await this.updateExternalStatusMessage(snapshot, mirror);
+            }
+            if (mirrorMode !== "off") {
+                this.options.broadcastStatus(mirror.latestStatus, "info");
+            }
             return;
         }
         const terminalEvent = [...snapshot.events].reverse().find((event) => event.kind === "task" && event.status && event.status !== "started");
         if (terminalEvent && terminalEvent.lineNumber > mirror.lastLine) {
+            const mirrorMode = this.options.mirrorMode();
             const finalAgent = snapshot.events.filter((event) => event.kind === "agent" && event.text).at(-1);
             const finalText = finalAgent?.text ?? snapshot.latestAgentMessage;
             const finalLine = finalAgent?.lineNumber ?? snapshot.lineCount;
-            if (finalText && finalLine !== mirror.latestAgentLine) {
-                this.options.chatStore.append({
+            if ((mirrorMode === "final" || mirrorMode === "full") && finalText && finalLine !== mirror.latestAgentLine) {
+                this.options.chatStore.appendWithResult({
                     threadId: snapshot.threadId,
                     role: "agent",
                     text: finalText,
                     source: "cli",
                     turnId: terminalEvent.turnId ?? undefined,
+                    key: externalMessageKey("final", snapshot, terminalEvent.lineNumber),
                 });
-                this.options.broadcast({ type: "text_delta", id: terminalEvent.turnId ?? "cli", delta: finalText });
                 mirror.latestAgentLine = finalLine;
             }
             const externalStartedAt = mirror.startedAt ? new Date(mirror.startedAt) : snapshot.activity.startedAt;
-            this.options.broadcast({
-                type: "turn_complete",
-                id: terminalEvent.turnId ?? "cli",
-                at: terminalEvent.timestamp?.toISOString() ?? new Date().toISOString(),
-            });
+            if (mirrorMode !== "off") {
+                this.options.broadcast({
+                    type: "turn_complete",
+                    id: terminalEvent.turnId ?? "cli",
+                    at: terminalEvent.timestamp?.toISOString() ?? new Date().toISOString(),
+                });
+            }
             this.options.appendActivity({
                 source: "cli",
                 status: terminalEvent.status === "aborted" ? "aborted" : terminalEvent.status === "failed" ? "failed" : "completed",
@@ -137,29 +156,35 @@ export class RelayExternalActivityMonitor {
                 await this.options.persistWorkspaceArtifactsForTurn(info.workspace, terminalEvent.turnId, externalStartedAt);
             }
             mirror.latestStatus = `${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`;
-            this.options.broadcastStatus(`${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`, terminalEvent.status === "failed" ? "error" : terminalEvent.status === "aborted" ? "warn" : "info");
-            this.options.broadcast({ type: "chat_history", messages: await this.options.chatHistory() });
+            if (mirrorMode === "status" || mirrorMode === "full") {
+                await this.updateExternalStatusMessage(snapshot, mirror, mirror.latestStatus);
+            }
+            if (mirrorMode !== "off") {
+                this.options.broadcastStatus(`${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`, terminalEvent.status === "failed" ? "error" : terminalEvent.status === "aborted" ? "warn" : "info");
+                await this.broadcastChatHistory();
+            }
             await this.options.drainQueue();
         }
         mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
     }
-    startExternalTurn(snapshot, info) {
+    async startExternalTurn(snapshot, info) {
         const prompt = snapshot.latestUserMessage ?? `${snapshot.agentLabel} CLI task`;
-        this.options.chatStore.append({
-            threadId: snapshot.threadId,
-            role: "user",
-            text: prompt,
-            source: "cli",
-            turnId: snapshot.activity.turnId ?? undefined,
-            timestamp: snapshot.activity.startedAt?.toISOString(),
-        });
-        this.options.broadcast({
-            type: "turn_start",
-            id: snapshot.activity.turnId ?? "cli",
-            prompt,
-            at: snapshot.activity.startedAt?.toISOString() ?? new Date().toISOString(),
-            source: "cli",
-        });
+        const mode = this.options.mirrorMode();
+        if (mode === "final" || mode === "full") {
+            this.options.chatStore.appendWithResult({
+                threadId: snapshot.threadId,
+                role: "system",
+                text: `Working on ${trimLine(prompt, 500)}`,
+                source: "cli",
+                turnId: snapshot.activity.turnId ?? undefined,
+                timestamp: snapshot.activity.startedAt?.toISOString(),
+                key: externalMessageKey("working", snapshot),
+            });
+            await this.broadcastChatHistory();
+        }
+        if ((mode === "status" || mode === "full") && this.mirror) {
+            await this.updateExternalStatusMessage(snapshot, this.mirror);
+        }
         this.options.appendActivity({
             source: "cli",
             status: "running",
@@ -172,15 +197,17 @@ export class RelayExternalActivityMonitor {
             detail: `${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
         });
     }
-    broadcastExternalEvents(snapshot, events, info) {
+    broadcastExternalEvents(snapshot, events, info, broadcastTools) {
         for (const event of events) {
             if (event.kind === "tool" && event.status === "started") {
-                this.options.broadcast({
-                    type: "tool_start",
-                    id: snapshot.activity.turnId ?? "cli",
-                    toolCallId: `cli-${event.lineNumber}`,
-                    toolName: event.toolName ?? "tool",
-                });
+                if (broadcastTools) {
+                    this.options.broadcast({
+                        type: "tool_start",
+                        id: snapshot.activity.turnId ?? "cli",
+                        toolCallId: `cli-${event.lineNumber}`,
+                        toolName: event.toolName ?? "tool",
+                    });
+                }
                 this.options.appendActivity({
                     source: "cli",
                     status: "running",
@@ -193,12 +220,14 @@ export class RelayExternalActivityMonitor {
                 });
             }
             if (event.kind === "tool" && event.status === "finished") {
-                this.options.broadcast({
-                    type: "tool_end",
-                    id: snapshot.activity.turnId ?? "cli",
-                    toolCallId: `cli-${event.lineNumber}`,
-                    isError: false,
-                });
+                if (broadcastTools) {
+                    this.options.broadcast({
+                        type: "tool_end",
+                        id: snapshot.activity.turnId ?? "cli",
+                        toolCallId: `cli-${event.lineNumber}`,
+                        isError: false,
+                    });
+                }
                 this.options.appendActivity({
                     source: "cli",
                     status: "completed",
@@ -211,12 +240,14 @@ export class RelayExternalActivityMonitor {
                 });
             }
             if (event.kind === "tool" && event.status === "failed") {
-                this.options.broadcast({
-                    type: "tool_end",
-                    id: snapshot.activity.turnId ?? "cli",
-                    toolCallId: `cli-${event.lineNumber}`,
-                    isError: true,
-                });
+                if (broadcastTools) {
+                    this.options.broadcast({
+                        type: "tool_end",
+                        id: snapshot.activity.turnId ?? "cli",
+                        toolCallId: `cli-${event.lineNumber}`,
+                        isError: true,
+                    });
+                }
                 this.options.appendActivity({
                     source: "cli",
                     status: "failed",
@@ -230,6 +261,62 @@ export class RelayExternalActivityMonitor {
             }
         }
     }
+    async appendExternalEventMessages(snapshot, events, mirror) {
+        let changed = false;
+        for (const event of events) {
+            if (event.lineNumber <= (mirror.latestMirroredEventLine ?? mirror.lastLine)) {
+                continue;
+            }
+            const rendered = renderExternalMirrorEvent(event);
+            if (!rendered) {
+                continue;
+            }
+            const stored = this.options.chatStore.appendWithResult({
+                threadId: snapshot.threadId,
+                role: event.kind === "tool" ? "tool" : "system",
+                text: rendered.plain,
+                source: "cli",
+                turnId: event.turnId ?? snapshot.activity.turnId ?? undefined,
+                timestamp: event.timestamp?.toISOString(),
+                key: externalMessageKey("event", snapshot, event.lineNumber),
+            });
+            changed = changed || stored.inserted;
+            mirror.latestMirroredEventLine = event.lineNumber;
+        }
+        if (changed) {
+            await this.broadcastChatHistory();
+        }
+    }
+    async updateExternalStatusMessage(snapshot, mirror, text) {
+        const now = Date.now();
+        const minInterval = this.options.mirrorMinUpdateMs();
+        if (!text && mirror.latestStatusAt && now - mirror.latestStatusAt < minInterval) {
+            return;
+        }
+        this.options.chatStore.upsertByKey({
+            threadId: snapshot.threadId,
+            role: "system",
+            text: text ?? renderExternalMirrorStatus(snapshot, this.options.queueLength()).plain,
+            source: "cli",
+            turnId: snapshot.activity.turnId ?? undefined,
+            key: externalMessageKey("status", snapshot),
+        });
+        mirror.latestStatusAt = now;
+        await this.broadcastChatHistory();
+    }
+    async broadcastChatHistory() {
+        this.options.broadcast({ type: "chat_history", messages: await this.options.chatHistory() });
+    }
+}
+function externalMessageKey(kind, snapshot, lineNumber) {
+    return [
+        "external",
+        kind,
+        snapshot.agentId,
+        snapshot.threadId,
+        snapshot.activity.turnId ?? "turn",
+        lineNumber ?? "",
+    ].join(":");
 }
 function externalStatusLine(snapshot, queueLength) {
     const elapsed = snapshot.activity.startedAt

package/dist/runtime/relay-runtime-active-sessions.js

@@ -0,0 +1,387 @@
+import { randomUUID } from "node:crypto";
+import { ensureOutDir } from "../artifacts/artifacts.js";
+import { buildFileInstructions, outboxPath, stageFile, } from "../artifacts/attachments.js";
+import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, isAgentId, } from "../agents/shared/agent.js";
+import { getExternalSnapshotForSession } from "../agents/shared/agent-activity.js";
+import { listAgentAdapterDescriptors } from "../agents/shared/agent-adapter.js";
+import { AgentUpdateManager } from "../agents/shared/agent-updates.js";
+import { createAgentSessionService, enabledAgents } from "../agents/shared/agent-factory.js";
+import { AuditLogStore } from "../access/audit-log.js";
+import { BotPreferencesStore } from "../state/bot-preferences.js";
+import { ChannelCommandService } from "../channels/shared/channel-command-service.js";
+import { ChannelTurnService } from "../channels/shared/channel-turn-service.js";
+import { activeSessionSourceForContextKey, ChannelMirrorRegistry } from "../channels/shared/channel-mirror-registry.js";
+import { listThreads as listCodexThreads } from "../agents/codex/codex-state.js";
+import { friendlyErrorText } from "../core/error-messages.js";
+import { clearLogFile, getAgentUpdateLogPath, getConnectorHealth, getConnectorLogPath, getPackageVersion, getUpdateLogPath, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate } from "../support/operations.js";
+import { PromptStore, toPromptEnvelope } from "../state/prompt-store.js";
+import { UnifiedJobStore } from "../state/job-store.js";
+import { buildRuntimeMetrics } from "./metrics.js";
+import { RelayArtifactService } from "./relay-artifact-service.js";
+import { RelayAuthService } from "./relay-auth-service.js";
+import { RelayExternalActivityMonitor } from "./relay-external-activity-monitor.js";
+import { RelayQueueService } from "./relay-queue-service.js";
+import { RuntimeSnapshotCache } from "./runtime-cache.js";
+import { activeSessionPriority, activityToUnifiedJob, agentUpdateStatusToUnified, dedupeJobs, hostLoginCommand, hostLogoutCommand, isPromptTerminalActivity, normalizeMimeType, promptActivityToUnifiedJob, shouldRefreshActiveSessions, taskToUnifiedJob, uploadFileDtos, } from "./relay-runtime-helpers.js";
+import { RelayDashboardService } from "./relay-dashboard-service.js";
+import { capabilitiesOf } from "../channels/shared/bot-rendering.js";
+import { renderSessionInfoPlain, renderSessionUsageRows } from "../channels/shared/session-format.js";
+import { SessionLockStore } from "../access/session-locks.js";
+import { SessionRegistry } from "../state/session-registry.js";
+import { createSupportBundle } from "../support/support-bundle.js";
+import { transcribeAudio } from "../artifacts/voice.js";
+import { WebActivityStore, WebChatStore, } from "../web/web-state.js";
+import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "../core/workspace-policy.js";
+export const WEB_CONTEXT_KEY = "web:dashboard";
+const ACTIVE_CODEX_DISCOVERY_LIMIT = 200;
+const ACTIVE_ACTIVITY_TTL_MS = 6 * 60 * 60 * 1000;
+const MAX_WEB_SESSION_PAGE_SIZE = 50;
+const MAX_CHAT_HISTORY = 250;
+export async function relayRuntimeActiveSessions(runtime) {
+    const sessions = new Map();
+    const knownContexts = runtime.listKnownContextMetadata();
+    const preferences = new BotPreferencesStore(runtime.config.workspace, runtime.config.stateBackend);
+    const addActiveSession = (session) => {
+        const key = runtime.activeSessionKey(session);
+        const existing = sessions.get(key);
+        sessions.set(key, runtime.preferredActiveSession(existing, session));
+    };
+    if (runtime.currentProgress?.status === "running") {
+        addActiveSession({
+            ...runtime.currentProgress,
+            contextKey: runtime.contextKey,
+            sourceContextKey: runtime.contextKey,
+            source: "web",
+            status: "running",
+            queueLength: runtime.queueService.length(),
+            queuePaused: runtime.queueService.isPaused(),
+        });
+    }
+    for (const active of runtime.discoverRunningConnectorSessions()) {
+        addActiveSession(active);
+    }
+    for (const active of runtime.discoverActiveCodexSessions(knownContexts, preferences)) {
+        addActiveSession(active);
+    }
+    for (const meta of knownContexts) {
+        if (meta.contextKey === runtime.contextKey && runtime.currentProgress?.status === "running") {
+            continue;
+        }
+        const active = runtime.externalActiveSession(meta, knownContexts, preferences);
+        if (active) {
+            addActiveSession(active);
+        }
+    }
+    return {
+        sessions: [...sessions.values()].sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt)),
+        updatedAt: new Date().toISOString(),
+    };
+}
+export async function relayRuntimeGetSession(runtime, deferThreadStart) {
+    return runtime.registry.getOrCreate(runtime.contextKey, { deferThreadStart });
+}
+export function relayRuntimeListKnownContextMetadata(runtime) {
+    const contexts = new Map();
+    const add = (meta) => {
+        if (meta?.contextKey) {
+            contexts.set(meta.contextKey, meta);
+        }
+    };
+    for (const meta of runtime.registry.listContexts()) {
+        add(meta);
+    }
+    const sharedRegistry = new SessionRegistry(runtime.config);
+    try {
+        for (const meta of sharedRegistry.listContexts()) {
+            add(meta);
+        }
+    }
+    finally {
+        sharedRegistry.disposeAll();
+    }
+    const current = runtime.registry.get(runtime.contextKey)?.getInfo();
+    if (current) {
+        add({
+            contextKey: runtime.contextKey,
+            agentId: current.agentId,
+            threadId: current.threadId,
+            workspace: current.workspace,
+            model: current.model,
+            reasoningEffort: current.reasoningEffort,
+            launchProfileId: current.nextLaunchProfileId ?? current.launchProfileId,
+            sessionPath: current.sessionPath,
+            updatedAt: Date.now(),
+        });
+    }
+    return [...contexts.values()];
+}
+export function relayRuntimeDiscoverRunningConnectorSessions(runtime) {
+    const active = [];
+    const terminal = new Set();
+    const now = Date.now();
+    for (const event of runtime.activityStore.list({ limit: 500 })) {
+        if (!event.threadId || !event.agentId || !event.contextKey) {
+            continue;
+        }
+        const key = `${event.source}:${event.contextKey}:${event.agentId}:${event.threadId}`;
+        if (isPromptTerminalActivity(event)) {
+            terminal.add(key);
+            continue;
+        }
+        if (event.type !== "prompt_started" || event.status !== "running" || event.source === "cli") {
+            continue;
+        }
+        if (terminal.has(key)) {
+            continue;
+        }
+        const startedMs = Date.parse(event.timestamp);
+        if (!Number.isFinite(startedMs) || now - startedMs > ACTIVE_ACTIVITY_TTL_MS) {
+            continue;
+        }
+        active.push({
+            id: `${event.contextKey}:${event.id}`,
+            contextKey: event.contextKey,
+            sourceContextKey: event.contextKey,
+            source: event.source,
+            status: "running",
+            agentId: event.agentId,
+            agentLabel: event.agentId ? agentLabel(event.agentId) : undefined,
+            threadId: event.threadId,
+            workspace: event.workspace,
+            prompt: event.prompt,
+            startedAt: event.timestamp,
+            updatedAt: event.timestamp,
+            durationMs: Math.max(0, now - startedMs),
+            queueLength: runtime.promptStore.list(event.contextKey).length,
+            queuePaused: runtime.promptStore.isPaused(event.contextKey),
+            detail: event.actor?.label ? `Started by ${event.actor.label}` : undefined,
+        });
+    }
+    return active;
+}
+export function relayRuntimeDiscoverActiveCodexSessions(runtime, knownContexts, preferences) {
+    if (!runtime.config.codexEnabled || !enabledAgents(runtime.config).includes("codex")) {
+        return [];
+    }
+    const capabilities = runtime.capabilitiesForAgent("codex");
+    if (!capabilities.externalActivity) {
+        return [];
+    }
+    const active = [];
+    const nowMs = Date.now();
+    const staleAfterMs = runtime.config.codexExternalBusyStaleMs;
+    for (const thread of listCodexThreads(ACTIVE_CODEX_DISCOVERY_LIMIT)) {
+        if (staleAfterMs > 0 && nowMs - thread.updatedAt.getTime() > staleAfterMs) {
+            continue;
+        }
+        const meta = {
+            contextKey: `cli:codex:${thread.id}`,
+            agentId: "codex",
+            threadId: thread.id,
+            workspace: thread.cwd,
+            model: thread.model ?? undefined,
+            reasoningEffort: thread.reasoningEffort ?? undefined,
+            updatedAt: thread.updatedAt.getTime(),
+        };
+        const session = runtime.externalActiveSession(meta, knownContexts, preferences);
+        if (session) {
+            active.push(session);
+        }
+    }
+    return active;
+}
+export function relayRuntimeExternalActiveSession(runtime, meta, knownContexts, preferences) {
+    if (!meta.threadId) {
+        return null;
+    }
+    const agentId = isAgentId(meta.agentId) ? meta.agentId : runtime.config.defaultAgent;
+    if (!enabledAgents(runtime.config).includes(agentId)) {
+        return null;
+    }
+    const capabilities = runtime.capabilitiesForAgent(agentId);
+    if (!capabilities.externalActivity) {
+        return null;
+    }
+    if (agentId === "codex" &&
+        meta.updatedAt &&
+        runtime.config.codexExternalBusyStaleMs > 0 &&
+        Date.now() - meta.updatedAt > runtime.config.codexExternalBusyStaleMs) {
+        return null;
+    }
+    const snapshot = getExternalSnapshotForSession(runtime.sessionStubForMetadata(meta, agentId, capabilities), runtime.config, {
+        maxEvents: 8,
+    });
+    if (!snapshot?.activity.active) {
+        return null;
+    }
+    const startedAt = snapshot.activity.startedAt?.toISOString() ?? new Date().toISOString();
+    const updatedAt = snapshot.activity.updatedAt?.toISOString() ?? new Date().toISOString();
+    const startedMs = Date.parse(startedAt);
+    const sourceContextKey = `cli:${snapshot.agentId}:${snapshot.threadId}`;
+    const mirrorChannels = runtime.mirrorRegistry.activeMirrorsForThread(snapshot.agentId, snapshot.threadId, knownContexts, preferences);
+    const queueLength = runtime.mirrorRegistry.queueLengthForExternalSource(sourceContextKey, mirrorChannels);
+    const mirrorDetail = mirrorChannels.length > 0
+        ? `Mirroring: ${mirrorChannels.map((mirror) => `${mirror.source} ${mirror.mode}`).join(", ")}`
+        : "Mirroring: none";
+    return {
+        id: `${sourceContextKey}:${snapshot.activity.turnId ?? snapshot.threadId}`,
+        contextKey: sourceContextKey,
+        sourceContextKey,
+        source: "cli",
+        status: "external",
+        agentId: snapshot.agentId,
+        agentLabel: snapshot.agentLabel,
+        threadId: snapshot.threadId,
+        workspace: meta.workspace,
+        prompt: snapshot.latestUserMessage ?? undefined,
+        currentTool: snapshot.latestToolName ?? undefined,
+        lastTool: snapshot.latestToolName ?? undefined,
+        startedAt,
+        updatedAt,
+        durationMs: Number.isFinite(startedMs) ? Math.max(0, Date.now() - startedMs) : 0,
+        queueLength,
+        queuePaused: runtime.mirrorRegistry.queuePausedForExternalSource(sourceContextKey, mirrorChannels),
+        mirrorChannels,
+        detail: `${mirrorDetail} | ${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
+    };
+}
+export function relayRuntimeSessionStubForMetadata(runtime, meta, agentId, capabilities) {
+    const info = {
+        agentId,
+        agentLabel: agentLabel(agentId),
+        threadId: meta.threadId,
+        workspace: meta.workspace,
+        model: meta.model,
+        reasoningEffort: meta.reasoningEffort,
+        launchProfileId: meta.launchProfileId ?? runtime.config.defaultLaunchProfileId,
+        launchProfileLabel: meta.launchProfileId ?? runtime.config.defaultLaunchProfileId,
+        launchProfileBehavior: "-",
+        sandboxMode: "-",
+        approvalPolicy: "-",
+        fastMode: false,
+        unsafeLaunch: false,
+        sessionPath: meta.sessionPath,
+        capabilities,
+    };
+    return {
+        getInfo: () => info,
+        getActiveThreadId: () => meta.threadId,
+    };
+}
+export function relayRuntimeCapabilitiesForAgent(runtime, agentId) {
+    return listAgentAdapterDescriptors().find((descriptor) => descriptor.id === agentId)?.capabilities ?? CODEX_AGENT_CAPABILITIES;
+}
+export function relayRuntimeActiveSessionKey(runtime, session) {
+    return session.threadId ? `${session.agentId ?? "unknown"}:${session.threadId}` : session.id;
+}
+export function relayRuntimePreferredActiveSession(runtime, existing, candidate) {
+    if (!existing) {
+        return candidate;
+    }
+    const existingPriority = activeSessionPriority(existing);
+    const candidatePriority = activeSessionPriority(candidate);
+    if (candidatePriority !== existingPriority) {
+        return candidatePriority > existingPriority ? candidate : existing;
+    }
+    return Date.parse(candidate.updatedAt) >= Date.parse(existing.updatedAt) ? candidate : existing;
+}
+export function relayRuntimeRecordActivity(runtime, input) {
+    return runtime.appendActivity(input);
+}
+export function relayRuntimeAppendActivity(runtime, input) {
+    const event = runtime.activityStore.append(runtime.enrichActivityInput(input));
+    runtime.broadcast({ type: "activity_update", events: runtime.activity({ limit: 50 }) });
+    return event;
+}
+export function relayRuntimeEnrichActivityInput(runtime, input) {
+    return runtime.enrichActivityFields(input);
+}
+export function relayRuntimeEnrichActivityEvent(runtime, event, info) {
+    return runtime.enrichActivityFields(event, info);
+}
+export function relayRuntimeEnrichActivityFields(runtime, event, info) {
+    if (!info) {
+        return !event.threadId && !event.workspace ? { ...event, workspace: runtime.config.workspace } : event;
+    }
+    if (event.threadId && info.threadId && event.threadId === info.threadId) {
+        return { ...event, workspace: event.workspace ?? info.workspace, agentId: event.agentId ?? info.agentId };
+    }
+    if (!event.threadId && !event.workspace) {
+        return { ...event, workspace: runtime.config.workspace };
+    }
+    return event;
+}
+export function relayRuntimeAppendAudit(runtime, input) {
+    return runtime.auditStore.append({ ...input, channelId: "web" });
+}
+export function relayRuntimeUpdateCurrentProgress(runtime, patch = {}) {
+    if (!runtime.currentProgress) {
+        return;
+    }
+    if ("currentTool" in patch) {
+        runtime.currentProgress.currentTool = patch.currentTool;
+        const { currentTool: _currentTool, ...rest } = patch;
+        Object.assign(runtime.currentProgress, rest);
+    }
+    else {
+        Object.assign(runtime.currentProgress, patch);
+    }
+    runtime.currentProgress.durationMs = Date.now() - runtime.currentTurnStartedAt;
+    runtime.currentProgress.updatedAt = new Date().toISOString();
+}
+export function relayRuntimeAddCurrentTool(runtime, toolName) {
+    if (!runtime.currentProgress) {
+        return;
+    }
+    const existing = runtime.currentProgress.tools.find((tool) => tool.name === toolName);
+    if (existing) {
+        existing.count += 1;
+    }
+    else {
+        runtime.currentProgress.tools.push({ name: toolName, count: 1 });
+    }
+    runtime.updateCurrentProgress({ currentTool: toolName, lastTool: toolName });
+}
+export function relayRuntimeBroadcastQueue(runtime) {
+    runtime.broadcast({ type: "queue_update", queue: runtime.queue(), paused: runtime.queuePaused() });
+}
+export function relayRuntimeBroadcastStatus(runtime, message, level = "info") {
+    runtime.broadcast({ type: "status", message, level, at: new Date().toISOString() });
+}
+export function relayRuntimeBroadcast(runtime, event) {
+    for (const subscriber of runtime.subscribers) {
+        try {
+            subscriber(event);
+        }
+        catch {
+            runtime.subscribers.delete(subscriber);
+        }
+    }
+    if (shouldRefreshActiveSessions(event)) {
+        runtime.scheduleActiveSessionsBroadcast();
+    }
+}
+export function relayRuntimeScheduleActiveSessionsBroadcast(runtime) {
+    if (runtime.activeSessionsBroadcastTimer) {
+        return;
+    }
+    const delayMs = Math.max(0, 1_000 - (Date.now() - runtime.activeSessionsLastBroadcastAt));
+    runtime.activeSessionsBroadcastTimer = setTimeout(() => {
+        runtime.activeSessionsBroadcastTimer = null;
+        runtime.activeSessionsLastBroadcastAt = Date.now();
+        void runtime.activeSessions()
+            .then((active) => runtime.broadcast({ type: "active_sessions_update", active }))
+            .catch(() => { });
+    }, delayMs);
+    runtime.activeSessionsBroadcastTimer.unref?.();
+}
+export function relayRuntimePublicInfo(runtime, session) {
+    const info = session.getInfo();
+    const agentId = info.agentId ?? "codex";
+    return {
+        ...info,
+        agentId,
+        agentLabel: info.agentLabel ?? agentLabel(agentId),
+        capabilities: info.capabilities ?? CODEX_AGENT_CAPABILITIES,
+    };
+}