ompchamber 0.3.0

package/src/shared/lib/chat/omp/agent-events.ts

@@ -0,0 +1,347 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Folds one live agent event frame into chamber state. Transport-agnostic: the
+ * WebSocket and SSE clients both hand every decoded frame to `foldAgentEvent`,
+ * so both transports produce byte-identical timeline behavior.
+ *
+ * Split out of useOmpAgentStream so the hook owns only connection lifecycle
+ * (open, reconnect, teardown) and each file stays under the repo's per-file
+ * size ceiling.
+ */
+
+import type { Dispatch, RefObject, SetStateAction } from 'preact/compat';
+import type { ChatMessageData, IncomingExtensionUiRequest, OmpAgentCallbacks, OmpAgentEvent, OmpAgentState, ToolCallData } from '@/shared/types';
+import { extractTextFromContent, toChatMessage, toolResultText } from '@/shared/lib/omp/session/mapper';
+import { normalizeThinkingLevel } from '@/shared/lib/models/thinking-levels';
+import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
+import { describeAssistantPhase, describeToolActivity } from '@/shared/lib/chat/timeline/tool-verbs';
+import { FILE_MUTATION_EVENT, isFileMutatingTool } from '@/shared/lib/chat/omp/file-mutations';
+
+/** Tool output accumulated between a `toolCall` block and its result frame. */
+export interface ToolResultRecord {
+  output: string;
+  isError?: boolean;
+  details?: Record<string, any>;
+}
+
+/** Per-entry cap on stored tool output; the tail of a build log is what matters. */
+const MAX_TOOL_OUTPUT_CHARS = 200_000;
+/** Max tool results retained per session; oldest entries are dropped first. */
+const MAX_TRACKED_TOOL_RESULTS = 200;
+
+/** Truncate tool output to the cap, keeping the tail and marking the cut. */
+function capToolOutput(output: string): string {
+  if (output.length <= MAX_TOOL_OUTPUT_CHARS) return output;
+  return `…[truncated]\n${output.slice(-MAX_TOOL_OUTPUT_CHARS)}`;
+}
+
+/** Write a tool result into the map, enforcing both caps. */
+function storeToolResult(
+  map: Map<string, ToolResultRecord>,
+  callId: string,
+  record: ToolResultRecord,
+): void {
+  map.set(callId, { ...record, output: capToolOutput(record.output) });
+  while (map.size > MAX_TRACKED_TOOL_RESULTS) {
+    const oldest = map.keys().next().value;
+    if (oldest === undefined) break;
+    map.delete(oldest);
+  }
+}
+
+export interface OmpAgentFoldDeps {
+  sessionId: string;
+  setState: Dispatch<SetStateAction<OmpAgentState>>;
+  callbacksRef: RefObject<OmpAgentCallbacks>;
+  toolResultsRef: RefObject<Map<string, ToolResultRecord>>;
+  lastToolMessageRef: RefObject<ChatMessageData>;
+  interruptPendingRef: RefObject<boolean>;
+  /** Last activity phrase published to the indicator; guards per-token frames
+   *  from re-setting identical state. */
+  activityRef: RefObject<string>;
+  /** Thinking level in effect for the live run (last `thinking_level_changed`
+   *  frame); stamped onto assistant turns as they stream. */
+  currentThinkingLevelRef: RefObject<string | undefined>;
+  /** toolCallIds of in-flight file-mutating calls, cleared on `agent_start`. */
+  fileMutatingCallsRef: RefObject<Set<string>>;
+}
+
+/** Publish a new indicator phrase, skipping repeats (thinking/text deltas
+ *  arrive per token and would otherwise re-set state on every frame). */
+function setActivity(verb: string | undefined, deps: OmpAgentFoldDeps): void {
+  if (!verb || verb === deps.activityRef.current) return;
+  deps.activityRef.current = verb;
+  deps.callbacksRef.current?.onActivity?.(verb);
+}
+
+/** Re-emit the last tool-carrying assistant message with its results paired. */
+function pairToolOutputs(
+  msg: ChatMessageData,
+  toolResultsRef: RefObject<Map<string, ToolResultRecord>>,
+): ChatMessageData {
+  if (!msg.toolCalls?.length) return msg;
+  const toolCalls = msg.toolCalls.map(tc => {
+    const res = toolResultsRef.current?.get(tc.id);
+    return res
+      ? {
+          ...tc,
+          output: res.output,
+          details: tc.details || res.details || undefined,
+          status: (res.isError ? 'error' : 'success') as ToolCallData['status'],
+        }
+      : tc;
+  });
+  return { ...msg, toolCalls };
+}
+
+/** Record a toolResult frame's output against its tool call id. */
+function recordToolResult(
+  raw: Record<string, unknown>,
+  deps: OmpAgentFoldDeps,
+): void {
+  const callId = typeof raw.toolCallId === 'string' ? raw.toolCallId : undefined;
+  if (!callId) return;
+  deps.toolResultsRef.current?.set(callId, {
+    output: extractTextFromContent(raw.content),
+    details: (raw.details && typeof raw.details === 'object' ? raw.details : undefined) as ToolResultRecord['details'],
+  });
+}
+
+/** Re-emit the last tool-carrying message when `callId` belongs to it. */
+function refreshToolMessage(callId: string | undefined, deps: OmpAgentFoldDeps): void {
+  if (!callId) return;
+  const last = deps.lastToolMessageRef.current;
+  if (!last?.toolCalls?.some(tc => tc.id === callId)) return;
+  deps.callbacksRef.current?.onMessageUpdate?.(pairToolOutputs(last, deps.toolResultsRef));
+}
+
+/** Flush assistant turns that stopped abnormally and were never streamed as
+ *  `message_end`. A user abort is the one terminal path where omp emits no
+ *  `message_end` at all — the synthetic aborted turn rides only in
+ *  `agent_end.messages`. omp slices out whatever it already streamed, so any
+ *  message found here is not a duplicate. Without this the failure stays
+ *  invisible until the session JSONL is reloaded. */
+function materializeTerminalMessages(
+  data: OmpAgentEvent,
+  deps: OmpAgentFoldDeps,
+  callbacks: OmpAgentCallbacks | undefined,
+): { errorMessage?: string } {
+  if (data.isTerminal === false) return {};
+  const messages = data.messages;
+  if (!Array.isArray(messages)) return {};
+  let errorMessage: string | undefined;
+  for (const entry of messages) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+    const raw = entry as Record<string, unknown>;
+    if (raw.role !== 'assistant') continue;
+    if (raw.stopReason !== 'aborted' && raw.stopReason !== 'error') continue;
+    const converted = toChatMessage(raw, false);
+    if (!converted) continue;
+    const paired = pairToolOutputs(converted, deps.toolResultsRef);
+    if (paired.toolCalls?.length) deps.lastToolMessageRef.current = paired;
+    callbacks?.onMessageEnd?.(paired);
+    if (typeof raw.errorMessage === 'string') errorMessage = raw.errorMessage;
+  }
+  return { errorMessage };
+}
+
+export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): void {
+  const callbacks = deps.callbacksRef.current;
+  switch (data.type) {
+    case 'agent_start':
+      deps.setState((prev) => ({ ...prev, isGenerating: true, error: null }));
+      deps.toolResultsRef.current?.clear();
+      deps.fileMutatingCallsRef.current?.clear();
+      deps.lastToolMessageRef.current = null;
+      deps.interruptPendingRef.current = false;
+      // A fresh run restarts level tracking; the first turn relies on the
+      // session-level value until omp emits thinking_level_changed (or not).
+      deps.currentThinkingLevelRef.current = undefined;
+      setActivity(PHASE_VERBS.thinking, deps);
+      callbacks?.onAgentStart?.();
+      break;
+
+    case 'message_start':
+    case 'message_update': {
+      const msg = data.message as Record<string, unknown> | undefined;
+      if (!msg) break;
+      if (msg.role === 'toolResult') {
+        recordToolResult(msg, deps);
+        setActivity(PHASE_VERBS.thinking, deps);
+        break;
+      }
+      // Assistant phases (thinking / prose / tool-call assembly) name the
+      // action directly — a tool that never starts still shows its phrase.
+      setActivity(describeAssistantPhase(data.assistantMessageEvent), deps);
+      // Steering (abort_and_prompt) and follow-up deliveries create no
+      // optimistic bubble — the user turn only exists on the stream. Convert
+      // it here so the bubble renders live instead of after a JSONL reload.
+      // The callbacks append user rows (never overwrite the streaming AI
+      // placeholder) and dedup by omp message id.
+      const converted = toChatMessage(msg);
+      if (converted) {
+        if (converted.role !== 'user' && deps.currentThinkingLevelRef.current) {
+          converted.thinkingLevel = deps.currentThinkingLevelRef.current;
+        }
+        callbacks?.onMessageUpdate?.(converted);
+      }
+      break;
+    }
+
+    case 'message_end': {
+      const completed = data.message as Record<string, unknown> | undefined;
+      if (!completed) break;
+      if (completed.role === 'toolResult') {
+        recordToolResult(completed, deps);
+        break;
+      }
+      if (completed.role === 'custom') break;
+      if (completed.role === 'user') {
+        const delivered = extractTextFromContent(completed.content);
+        if (delivered) callbacks?.onQueuedMessageDelivered?.(delivered);
+        break;
+      }
+      const converted = toChatMessage(completed, false);
+      if (!converted) break;
+      if (converted.role !== 'user' && deps.currentThinkingLevelRef.current) {
+        converted.thinkingLevel = deps.currentThinkingLevelRef.current;
+      }
+      const paired = pairToolOutputs(converted, deps.toolResultsRef);
+      if (paired.toolCalls?.length) deps.lastToolMessageRef.current = paired;
+      callbacks?.onMessageEnd?.(paired);
+      break;
+    }
+
+    case 'tool_execution_start': {
+      const callId = typeof data.toolCallId === 'string' ? data.toolCallId : undefined;
+      setActivity(describeToolActivity({
+        name: typeof data.toolName === 'string' ? data.toolName : undefined,
+        args: data.args,
+        intent: typeof data.intent === 'string' ? data.intent : undefined,
+      }), deps);
+      if (callId) deps.toolResultsRef.current?.set(callId, { output: '' });
+      // Remember whether this call can change workspace files; the end frame
+      // then signals the data panels to re-read (see file-mutations.ts).
+      if (callId && isFileMutatingTool({ toolName: data.toolName, args: data.args })) {
+        deps.fileMutatingCallsRef.current?.add(callId);
+      }
+      const last = deps.lastToolMessageRef.current;
+      if (last?.toolCalls?.some(tc => tc.id === callId)) {
+        deps.lastToolMessageRef.current = {
+          ...last,
+          toolCalls: last.toolCalls.map(tc => ({ ...tc, status: 'running' as ToolCallData['status'] })),
+        };
+        callbacks?.onMessageUpdate?.(deps.lastToolMessageRef.current);
+      }
+      break;
+    }
+
+    case 'tool_execution_update': {
+      const callId = typeof data.toolCallId === 'string' ? data.toolCallId : undefined;
+      const partial = toolResultText(data.partialResult);
+      if (!callId || !partial) break;
+      const prev = deps.toolResultsRef.current?.get(callId)?.output ?? '';
+      const map = deps.toolResultsRef.current;
+      if (map) storeToolResult(map, callId, { output: prev + partial });
+      refreshToolMessage(callId, deps);
+      break;
+    }
+
+    case 'tool_execution_end': {
+      const callId = typeof data.toolCallId === 'string' ? data.toolCallId : undefined;
+      if (!callId) break;
+      setActivity(PHASE_VERBS.thinking, deps);
+      const map = deps.toolResultsRef.current;
+      if (map) storeToolResult(map, callId, {
+        output: toolResultText(data.result),
+        isError: data.isError === true,
+        details: (data.details && typeof data.details === 'object' ? data.details : undefined) as ToolResultRecord['details'],
+      });
+      refreshToolMessage(callId, deps);
+      // A file-mutating tool just finished — tell the data-bearing right panels
+      // (files / git / context) to re-read now, not on their next poll tick.
+      // Guarded: the fold also runs headless under `bun test` (no window).
+      if (typeof window !== 'undefined' && deps.fileMutatingCallsRef.current?.delete(callId)) {
+        window.dispatchEvent(new CustomEvent(FILE_MUTATION_EVENT, {
+          detail: { sessionId: deps.sessionId },
+        }));
+      }
+      break;
+    }
+
+    case 'agent_end': {
+      deps.setState((prev) => ({ ...prev, isGenerating: false }));
+      deps.activityRef.current = '';
+      const terminal = materializeTerminalMessages(data, deps, callbacks ?? undefined);
+      if (deps.interruptPendingRef.current) {
+        deps.interruptPendingRef.current = false;
+        break;
+      }
+      callbacks?.onAgentEnd?.({
+        errorMessage: terminal.errorMessage
+          ?? (typeof data.errorMessage === 'string' ? data.errorMessage : undefined),
+        message: typeof data.message === 'string' ? data.message : undefined,
+      });
+      break;
+    }
+
+    case 'prompt_error': {
+      const errorMessage = typeof data.errorMessage === 'string' ? data.errorMessage : 'Prompt failed';
+      deps.setState((prev) => ({ ...prev, isGenerating: false, error: errorMessage }));
+      deps.interruptPendingRef.current = false;
+      deps.activityRef.current = '';
+      callbacks?.onPromptError?.(errorMessage);
+      break;
+    }
+
+    case 'notice': {
+      callbacks?.onNotice?.(
+        typeof data.level === 'string' ? data.level : 'info',
+        typeof data.message === 'string' ? data.message : '',
+      );
+      break;
+    }
+
+    case 'extension_ui_request': {
+      callbacks?.onExtensionUiRequest?.(data as unknown as IncomingExtensionUiRequest);
+      break;
+    }
+
+    case 'subagent_lifecycle':
+    case 'subagent_progress':
+    case 'subagent_event': {
+      // Forward live subagent frames to feature listeners as scoped window
+      // events (same pattern as the other omp:* signals).
+      const payload = data.payload;
+      if (payload === undefined || payload === null || typeof payload !== 'object') break;
+      window.dispatchEvent(new CustomEvent(data.type, {
+        detail: { sessionId: deps.sessionId, payload },
+      }));
+      break;
+    }
+
+    case 'model_changed':
+      callbacks?.onModelChanged?.();
+      break;
+
+    // The live `thinking_level_changed` frame carries the new session level
+    // (e.g. { thinkingLevel: "high", configured, resolved }); null → "off".
+    // Record it so subsequent assistant turns are stamped with the level that
+    // actually served them — mirrors the JSONL `thinking_level_change` walk.
+    case 'thinking_level_changed':
+      deps.currentThinkingLevelRef.current = normalizeThinkingLevel(data.thinkingLevel);
+      break;
+
+    // No chamber-side effect: config/command inventory frames and the
+    // transport's own `connected` greeting.
+    case 'config_update':
+    case 'available_commands_update':
+    case 'connected':
+    default:
+      break;
+  }
+}

package/src/shared/lib/chat/omp/file-mutations.ts

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * File-mutation signal: the chat event fold marks file-mutating tool calls
+ * (edit / write / ast_edit / bash and their aliases) and, when one finishes,
+ * the callbacks dispatch `omp:files-mutated`. Panels whose data lives on disk
+ * (file explorer, git panel, context panel) listen through
+ * `useFileMutationRefresh` and re-read out-of-band instead of waiting for
+ * their next poll tick. Terminal, browser, and search panels stay untouched —
+ * their data does not ride the AI response.
+ */
+
+import { isRecord } from '@/shared/lib/util/guards';
+import { TOOL_ALIASES, asString } from '@/shared/lib/chat/timeline/tool-phrases';
+
+/** Window event the fold dispatches after a file-mutating tool completes. */
+export const FILE_MUTATION_EVENT = 'omp:files-mutated';
+
+/** Canonical omp tool names whose completion can change files on disk. */
+const FILE_MUTATING_BY_TOOL: Record<string, true> = {
+  edit: true,
+  write: true,
+  ast_edit: true,
+  bash: true,
+};
+
+/**
+ * True when a `tool_execution_*` frame's tool can change workspace files.
+ * `write` to an `xd://<device>` target mutates in-chamber state (AST proposals,
+ * issue reports), never workspace files, so it does not count.
+ */
+export function isFileMutatingTool(frame: { toolName?: unknown; args?: unknown }): boolean {
+  const raw = typeof frame.toolName === 'string' ? frame.toolName.toLowerCase() : '';
+  const name = TOOL_ALIASES[raw] ?? raw;
+  if (!FILE_MUTATING_BY_TOOL[name]) return false;
+  const args = isRecord(frame.args) ? frame.args : {};
+  const target = asString(args.path) ?? asString(args.target);
+  return !(name === 'write' && typeof target === 'string' && target.startsWith('xd://'));
+}

package/src/shared/lib/chat/omp/socket.ts

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * WebSocket client for the live agent event stream — the default transport.
+ *
+ * One duplex socket per session replaces the SSE response stream: frames arrive
+ * as bare JSON messages (no `data:` framing or chunk reassembly), the server
+ * keeps the link warm with protocol pings instead of comment heartbeats, and a
+ * dropped socket is re-dialed with capped backoff instead of relying on the
+ * browser's EventSource retry loop.
+ *
+ * A socket that closes before it ever opened is terminal: the handshake was
+ * refused (409 — the chamber does not manage the session yet), and retrying
+ * would spin against a session that is not there. Same reasoning as the SSE
+ * route's observer-only contract.
+ */
+
+import type { OmpAgentEvent } from '@/shared/types';
+import type { AgentStreamConnection, AgentStreamHandlers } from '@/shared/lib/chat/omp/transport';
+import { agentSocketUrl } from '@/shared/lib/chat/omp/transport';
+
+const RECONNECT_BASE_MS = 500;
+const RECONNECT_MAX_MS = 8_000;
+/** Consecutive re-dials that never opened before the stream is given up on. */
+const MAX_FAILED_DIALS = 4;
+
+export function connectAgentSocket(sessionId: string, handlers: AgentStreamHandlers): AgentStreamConnection {
+  let socket: WebSocket | null = null;
+  let retryTimer: ReturnType<typeof setTimeout> | null = null;
+  let failures = 0;
+  let established = false;
+  let released = false;
+
+  const dial = () => {
+    const ws = new WebSocket(agentSocketUrl(sessionId));
+    socket = ws;
+
+    ws.onopen = () => {
+      if (released) return;
+      failures = 0;
+      established = true;
+      handlers.onOpen();
+    };
+
+    ws.onmessage = (event) => {
+      if (released) return;
+      let data: OmpAgentEvent;
+      try {
+        data = JSON.parse(String(event.data)) as OmpAgentEvent;
+      } catch {
+        return;
+      }
+      handlers.onFrame(data);
+    };
+
+    ws.onclose = () => {
+      socket = null;
+      if (released) return;
+      handlers.onClose();
+      // First dial refused, or the re-dials keep failing: stop, don't spin.
+      if (!established) return;
+      failures += 1;
+      if (failures > MAX_FAILED_DIALS) return;
+      const delay = Math.min(RECONNECT_BASE_MS * 2 ** (failures - 1), RECONNECT_MAX_MS);
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        if (!released) dial();
+      }, delay);
+    };
+  };
+
+  dial();
+
+  return {
+    close: () => {
+      released = true;
+      if (retryTimer !== null) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+      const ws = socket;
+      socket = null;
+      if (ws) {
+        ws.onopen = null;
+        ws.onmessage = null;
+        ws.onclose = null;
+        ws.onerror = null;
+        ws.close();
+      }
+    },
+  };
+}

package/src/shared/lib/chat/omp/sse.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Server-Sent Events client for the live agent event stream — the fallback
+ * transport, kept for environments where the WebSocket upgrade is blocked
+ * (HTTP-only proxies, some corporate networks).
+ *
+ * EventSource reconnects on transient drops by itself, so only a fatal close
+ * (the server closed the stream) is reported upward.
+ */
+
+import type { OmpAgentEvent } from '@/shared/types';
+import type { AgentStreamConnection, AgentStreamHandlers } from '@/shared/lib/chat/omp/transport';
+import { agentEventsUrl } from '@/shared/lib/chat/omp/transport';
+
+export function connectAgentEvents(sessionId: string, handlers: AgentStreamHandlers): AgentStreamConnection {
+  const source = new EventSource(agentEventsUrl(sessionId));
+  let released = false;
+
+  source.onopen = () => {
+    if (released) return;
+    handlers.onOpen();
+  };
+
+  source.onmessage = (event) => {
+    if (released) return;
+    let data: OmpAgentEvent;
+    try {
+      data = JSON.parse(event.data) as OmpAgentEvent;
+    } catch {
+      return;
+    }
+    handlers.onFrame(data);
+  };
+
+  source.onerror = () => {
+    if (released) return;
+    if (source.readyState === EventSource.CLOSED) handlers.onClose();
+  };
+
+  return {
+    close: () => {
+      released = true;
+      source.onopen = null;
+      source.onmessage = null;
+      source.onerror = null;
+      source.close();
+    },
+  };
+}

package/src/shared/lib/chat/omp/status.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Live connection status of the agent event stream.
+ *
+ * The socket lives deep inside the chat timeline while its indicator sits in
+ * the top navbar — a sibling subtree — so the status travels the same way as
+ * the other chamber-wide signals (`omp:theme-changed` and the shared
+ * session-status store): a window CustomEvent. The latest value is also kept
+ * here so a consumer that mounts mid-flight (layout toggle, session switch)
+ * paints the current state instead of waiting for the next transition.
+ */
+
+import type { StreamTransport } from '@/shared/types';
+import { readStreamTransport } from '@/shared/lib/chat/omp/transport';
+
+export const AGENT_STREAM_STATUS_EVENT = 'omp:stream-status';
+
+export interface AgentStreamStatus {
+  /** Transport in force for the live stream. */
+  transport: StreamTransport;
+  /** Transport is attached and frames may arrive. */
+  connected: boolean;
+}
+
+let latest: AgentStreamStatus = {
+  transport: readStreamTransport(),
+  connected: false,
+};
+
+/** Last published status — the seed for consumers mounting mid-flight. */
+export function readAgentStreamStatus(): AgentStreamStatus {
+  return latest;
+}
+
+/** Publish a status transition to every listener (no-op when unchanged). */
+export function publishAgentStreamStatus(next: AgentStreamStatus): void {
+  if (next.transport === latest.transport && next.connected === latest.connected) return;
+  latest = next;
+  if (typeof window === 'undefined') return;
+  window.dispatchEvent(new CustomEvent<AgentStreamStatus>(AGENT_STREAM_STATUS_EVENT, { detail: next }));
+}

package/src/shared/lib/chat/omp/transport.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Transport contract for the live agent event stream, shared by the WebSocket
+ * socket (default) and the Server-Sent Events fallback. Both dial
+ * `/api/agent/:sessionId/*`, emit the same JSON frames, and differ only in how
+ * the bytes travel — so `useOmpAgentStream` picks one and folds frames
+ * identically.
+ */
+
+import type { OmpAgentEvent, StreamTransport } from '@/shared/types';
+import { readChamberSetting } from '@/shared/lib/settings/client';
+
+export interface AgentStreamHandlers {
+  /** Transport is attached; frames may arrive. */
+  onOpen: () => void;
+  /** One decoded event frame. */
+  onFrame: (data: OmpAgentEvent) => void;
+  /** Transport is gone for good (no further frames without a re-dial). */
+  onClose: () => void;
+}
+
+export interface AgentStreamConnection {
+  /** Permanently release the transport; no callbacks fire afterwards. */
+  close: () => void;
+}
+
+export const DEFAULT_STREAM_TRANSPORT: StreamTransport = 'websocket';
+
+/** WebSocket endpoint for a session's agent event stream. */
+export function agentSocketUrl(sessionId: string): string {
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  return `${protocol}//${window.location.host}/api/agent/${encodeURIComponent(sessionId)}/ws`;
+}
+
+/** SSE endpoint for a session's agent event stream. */
+export function agentEventsUrl(sessionId: string): string {
+  return `/api/agent/${encodeURIComponent(sessionId)}/events`;
+}
+
+/**
+ * Resolve the configured stream transport from the chamber settings snapshot.
+ */
+export function readStreamTransport(appSettings?: Record<string, any>): StreamTransport {
+  const configured = readChamberSetting<unknown>('streamTransport', appSettings);
+  return configured === 'sse' || configured === 'websocket' ? configured : DEFAULT_STREAM_TRANSPORT;
+}

package/src/shared/lib/chat/order.ts

@@ -0,0 +1,40 @@
+import type { ChatMessageData } from '@/shared/types';
+
+/**
+ * Normalizes system notice positions in a chat timeline.
+ *
+ * In OMP / AI agent execution flows, a system notice (such as multi-step reasoning,
+ * ultrathink notice, or background job status) often arrives right before or
+ * during turn transition. If a notice precedes a user message, it chronologically
+ * belongs to the upcoming turn (responding to that user message).
+ *
+ * This function repositions any notice message that is immediately followed by a
+ * `user` message so that it is rendered AFTER that user message (and immediately
+ * before the next AI response).
+ */
+export function normalizeNoticePositions(messages: ChatMessageData[]): ChatMessageData[] {
+  if (!messages || messages.length <= 1) return messages;
+
+  const result: ChatMessageData[] = [...messages];
+  let changed = true;
+
+  // Bubble notices past any user messages that appear after them
+  while (changed) {
+    changed = false;
+    for (let i = 0; i < result.length - 1; i++) {
+      const curr = result[i];
+      const next = result[i + 1];
+
+      // If current is a notice message (role !== 'user' and has notice)
+      // and next is a user message, swap them so the user message comes first
+      // and the notice is rendered right before the subsequent AI response.
+      if (Boolean(curr.notice) && next.role === 'user') {
+        result[i] = next;
+        result[i + 1] = curr;
+        changed = true;
+      }
+    }
+  }
+
+  return result;
+}