opencandle 0.11.0 → 0.11.1

package/gui/server/http-routes.ts

@@ -3,6 +3,13 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { extname, join, resolve } from "node:path";
 import { type AgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
 import { buildDoctorReport } from "../../src/doctor/report.js";
+import { MarketStateService } from "../../src/market-state/service.js";
+import {
+  formatLatestReportSummary,
+  formatPortfolioSummary,
+  formatWatchlistSummary,
+} from "../../src/market-state/summaries.js";
+import { initDefaultDatabase } from "../../src/memory/sqlite.js";
 import { probeProviderStatus } from "../../src/onboarding/provider-status.js";
 import {
   clearPendingSessionAction,
@@ -13,7 +20,6 @@ import {
 } from "../../src/pi/session-action-dedupe.js";
 import type { ChatEvent } from "../shared/chat-events.js";
 import { sessionEntriesToChatEvents } from "./chat-event-adapter.js";
-import { chatRunSessionConflict } from "./chat-run-session.js";
 import type { ToolInvokeController } from "./invoke-tool.js";
 import { createLiveChatEventAdapter } from "./live-chat-event-adapter.js";
 import type {
@@ -21,7 +27,11 @@ import type {
   SessionActionEnvelope,
   SessionActionResult,
 } from "./local-session-coordinator.js";
-import { buildMarketStateSnapshot, searchInstrumentCandidates } from "./market-state-api.js";
+import {
+  buildMarketStateSnapshot,
+  getSavedMarketStateSymbols,
+  searchInstrumentCandidates,
+} from "./market-state-api.js";
 import { buildModelSetupState, type ModelSetupController } from "./model-setup.js";
 import { isTrustedPrivateApiRequest, privateApiCookieHeader } from "./private-api-access.js";
 import { projectDashboard } from "./projector.js";
@@ -32,6 +42,7 @@ import { waitForNewEntryId } from "./session-entry-wait.js";
 import { buildCatalog } from "./tool-metadata.js";
 import {
   acquireWriterLock,
+  isCoordinatorOwnerAlive,
   readWriterLock,
   refreshWriterLock,
   releaseWriterLock,
@@ -64,6 +75,28 @@ interface GuiHttpRouteOptions {
   localSessionCoordinator?: LocalSessionCoordinator;
 }
 
+export interface ChatRunImageInput {
+  data: string;
+  mimeType: string;
+}
+
+export type ChatRunAttachmentInput =
+  | { kind: "portfolio"; id?: string }
+  | { kind: "watchlist"; id: string }
+  | { kind: "report"; id: string };
+
+export interface ParsedChatRunBody {
+  prompt: string;
+  images: ChatRunImageInput[];
+  attachments: ChatRunAttachmentInput[];
+}
+
+type ChatRunParseResult = { ok: true; value: ParsedChatRunBody } | { ok: false; error: string };
+
+const CHAT_RUN_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/webp"]);
+const CHAT_RUN_MAX_IMAGE_COUNT = 4;
+const CHAT_RUN_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+
 export function createHttpRequestHandler(options: GuiHttpRouteOptions) {
   const activeRunSessionIds = new Set<string>();
 
@@ -234,28 +267,35 @@ export function createHttpRequestHandler(options: GuiHttpRouteOptions) {
 
     if (url.pathname === "/api/chat/run" && req.method === "POST") {
       if (!allowTrustedGuiRequest(req, res, "Chat run API", options)) return;
-      await handleSseChatRun(req, res, options, activeRunSessionIds);
+      writeJson(
+        res,
+        {
+          error: "Legacy active-session chat runs are no longer supported.",
+          code: "legacy_route_removed",
+        },
+        410,
+      );
       return;
     }
 
     if (url.pathname === "/api/local-coordinator/chat-run" && req.method === "POST") {
       if (!allowLocalCoordinatorRequest(req, res, options)) return;
       const body = asRecord(await readJsonBody(req));
-      const requestedSessionId = String(body.sessionId ?? "").trim();
-      const sessionManager = requestedSessionId
-        ? await resolveSessionManagerById(options, requestedSessionId)
-        : undefined;
-      if (requestedSessionId && !sessionManager) {
+      if (!requireSessionActionFields(res, body)) return;
+      const sessionManager = await resolveSessionManagerById(options, String(body.sessionId));
+      if (!sessionManager) {
         writeJson(res, { error: "Unknown saved session" }, 404);
         return;
       }
-      await handleSseChatRun(req, res, options, activeRunSessionIds, sessionManager, body);
+      // allowProxy: false — this endpoint is the proxy target; re-proxying loops.
+      await handleSseChatRun(req, res, options, activeRunSessionIds, sessionManager, body, false);
       return;
     }
 
     if (url.pathname === "/api/local-coordinator/tool-invoke" && req.method === "POST") {
       if (!allowLocalCoordinatorRequest(req, res, options)) return;
       const body = asRecord(await readJsonBody(req));
+      if (!requireSessionActionFields(res, body)) return;
       let ack: unknown;
       await options.toolInvokeController.handleToolInvokeMessage(
         { send: (message) => (ack = message) },
@@ -285,6 +325,7 @@ export function createHttpRequestHandler(options: GuiHttpRouteOptions) {
     if (url.pathname === "/api/local-coordinator/ask-user" && req.method === "POST") {
       if (!allowLocalCoordinatorRequest(req, res, options)) return;
       const body = asRecord(await readJsonBody(req));
+      if (!requireSessionActionFields(res, body)) return;
       const payload = asRecord(body.payload);
       try {
         const action = {
@@ -319,12 +360,16 @@ export function createHttpRequestHandler(options: GuiHttpRouteOptions) {
     const runSessionId = sessionIdFromRoute(url.pathname, "runs");
     if (runSessionId && req.method === "POST") {
       if (!allowTrustedGuiRequest(req, res, "Chat run API", options)) return;
+      const body = asRecord(await readJsonBody(req));
+      if (!requireSessionActionFields(res, { ...body, sessionId: runSessionId }, false)) return;
       const sessionManager = await resolveSessionManagerById(options, runSessionId);
       if (!sessionManager) {
         writeJson(res, { error: "Unknown saved session" }, 404);
         return;
       }
-      await handleSseChatRun(req, res, options, activeRunSessionIds, sessionManager);
+      // allowProxy: true — forward to a live coordinator owned by another
+      // process (0.11.0 authenticated local forwarding).
+      await handleSseChatRun(req, res, options, activeRunSessionIds, sessionManager, body, true);
       return;
     }
 
@@ -337,28 +382,26 @@ async function handleSseChatRun(
   res: ServerResponse,
   options: GuiHttpRouteOptions,
   activeRunSessionIds: Set<string>,
-  targetSessionManager?: SessionManager,
-  bodyOverride?: Record<string, unknown>,
+  targetSessionManager: SessionManager | undefined,
+  bodyOverride: Record<string, unknown> | undefined,
+  // Explicit because both remaining callers pass a body: the browser-facing
+  // runs route must forward to a live coordinator owned by another process,
+  // while the local-coordinator endpoint IS the proxy target and re-proxying
+  // there would loop.
+  allowProxy: boolean,
 ): Promise<void> {
   const body = bodyOverride ?? asRecord(await readJsonBody(req));
-  const prompt = String(asRecord(body).prompt ?? "").trim();
-  if (!prompt) {
-    writeJson(res, { error: "prompt is required" }, 400);
+  const parsed = parseChatRunBody(body);
+  if (!parsed.ok) {
+    writeJson(res, { error: parsed.error }, 400);
     return;
   }
-
   const currentSessionManager = options.getSessionManager();
   const bodyRecord = asRecord(body);
   const requestedSessionId = String(bodyRecord.sessionId ?? "").trim();
   const runSessionManager = targetSessionManager ?? currentSessionManager;
   const sessionId = runSessionManager.getSessionId();
-  if (!targetSessionManager) {
-    const sessionConflict = chatRunSessionConflict(requestedSessionId, sessionId);
-    if (sessionConflict) {
-      writeJson(res, sessionConflict, 409);
-      return;
-    }
-  } else if (requestedSessionId && requestedSessionId !== sessionId) {
+  if (requestedSessionId && requestedSessionId !== sessionId) {
     writeJson(
       res,
       { error: "Session route and request body disagree", code: "session_changed" },
@@ -367,9 +410,8 @@ async function handleSseChatRun(
     return;
   }
 
-  const proxyAllowed = bodyOverride === undefined;
   const actionId = String(bodyRecord.actionId ?? "").trim();
-  const shouldProxyChatRun = proxyAllowed && canProxyChatRunToCoordinator(runSessionManager);
+  const shouldProxyChatRun = allowProxy && canProxyChatRunToCoordinator(runSessionManager);
   if (shouldProxyChatRun) {
     if (await proxyChatRunToCoordinator(res, runSessionManager, bodyRecord)) {
       const useCurrentSession =
@@ -421,7 +463,7 @@ async function handleSseChatRun(
           currentSessionManager,
           runSessionManager,
           sessionId,
-          prompt,
+          parsedRun: parsed.value,
           actionId: action.actionId,
         });
         if (!admitted) throw new SessionActionNotAdmitted();
@@ -449,14 +491,14 @@ async function handleSseChatRun(
     currentSessionManager,
     runSessionManager,
     sessionId,
-    prompt,
+    parsedRun: parsed.value,
     actionId,
   });
 }
 
 export function canProxyChatRunToCoordinator(runSessionManager: SessionManager): boolean {
   const lock = readWriterLock(writerLockScopeForSession(runSessionManager));
-  return Boolean(lock?.coordinatorEndpoint && lock.coordinatorSecret && lock.pid !== process.pid);
+  return hasLiveCoordinatorLock(lock);
 }
 
 async function proxyChatRunToCoordinator(
@@ -465,7 +507,7 @@ async function proxyChatRunToCoordinator(
   body: Record<string, unknown>,
 ): Promise<boolean> {
   const lock = readWriterLock(writerLockScopeForSession(runSessionManager));
-  if (!lock?.coordinatorEndpoint || !lock.coordinatorSecret) return false;
+  if (!hasLiveCoordinatorLock(lock)) return false;
   const endpoint = new URL("/api/local-coordinator/chat-run", lock.coordinatorEndpoint);
   let response: Response;
   try {
@@ -490,6 +532,21 @@ async function proxyChatRunToCoordinator(
   return true;
 }
 
+function hasLiveCoordinatorLock(
+  lock: ReturnType<typeof readWriterLock>,
+  staleGraceMs = 15_000,
+): lock is NonNullable<ReturnType<typeof readWriterLock>> & {
+  coordinatorEndpoint: string;
+  coordinatorSecret: string;
+} {
+  if (!lock?.coordinatorEndpoint || !lock.coordinatorSecret || lock.pid === process.pid) {
+    return false;
+  }
+  const heartbeat = Date.parse(lock.lastHeartbeat);
+  const hasFreshHeartbeat = Number.isFinite(heartbeat) && Date.now() - heartbeat <= staleGraceMs;
+  return hasFreshHeartbeat && isCoordinatorOwnerAlive(lock.pid);
+}
+
 async function streamAcceptedSseChatRun({
   res,
   options,
@@ -498,7 +555,7 @@ async function streamAcceptedSseChatRun({
   currentSessionManager,
   runSessionManager,
   sessionId,
-  prompt,
+  parsedRun,
   actionId,
 }: {
   res: ServerResponse;
@@ -508,13 +565,37 @@ async function streamAcceptedSseChatRun({
   currentSessionManager: SessionManager;
   runSessionManager: SessionManager;
   sessionId: string;
-  prompt: string;
+  parsedRun: ParsedChatRunBody;
   actionId: string;
 }): Promise<boolean> {
+  const prompt = parsedRun.prompt;
   if (activeRunSessionIds.has(sessionId)) {
     writeJson(res, { error: "Session already has an active run", code: "session_busy" }, 409);
     return false;
   }
+  let dispatchedPrompt: string;
+  try {
+    dispatchedPrompt = await buildDispatchedPrompt(parsedRun);
+  } catch (error) {
+    writeJson(res, { error: error instanceof Error ? error.message : String(error) }, 400);
+    return false;
+  }
+  const promptImages = parsedRun.images.map((image) => ({
+    type: "image" as const,
+    data: image.data,
+    mimeType: image.mimeType,
+  }));
+  const attachmentLabels = parsedRun.attachments.map((attachment) => ({
+    kind: attachment.kind,
+    label: attachmentLabel(attachment),
+  }));
+  const inputAttachmentLabels = [
+    ...promptImages.map((image, index) => ({
+      kind: "image",
+      label: `${image.mimeType || "image"} #${index + 1}`,
+    })),
+    ...attachmentLabels,
+  ];
 
   const currentSessionFile = currentSessionManager.getSessionFile();
   const targetSessionFile = runSessionManager.getSessionFile();
@@ -579,22 +660,34 @@ async function streamAcceptedSseChatRun({
     startSeq: seq,
     emit: (event) => writeSse(res, event),
     originalPrompt: prompt,
+    originalAttachments: inputAttachmentLabels,
   });
   const observation = createPromptObservation();
+  let originalInputMarkerAppended = false;
+  const appendOriginalInputMarker = () => {
+    if (inputAttachmentLabels.length === 0 || originalInputMarkerAppended) return;
+    runSessionManager.appendCustomEntry("opencandle-user-input", {
+      original: prompt,
+      attachments: inputAttachmentLabels,
+    });
+    originalInputMarkerAppended = true;
+  };
   let actionAccepted = false;
   const recordAcceptedAction = () => {
     if (actionAccepted) return;
+    appendOriginalInputMarker();
     recordAcceptedSessionAction(runSessionManager, actionId);
     if (useCurrentSession) options.syncCurrentWriterLockScope?.();
     actionAccepted = true;
   };
+
   const unsubscribeLive = runSession.subscribe((event) => {
     liveAdapter.handle(event);
     observePromptEvent(observation, event);
     if (
       !prompt.startsWith("/") &&
       !actionAccepted &&
-      observation.userTexts.some((text) => text.trim() === prompt.trim())
+      observation.userTexts.some((text) => text.trim() === dispatchedPrompt.trim())
     ) {
       recordAcceptedAction();
     }
@@ -616,7 +709,13 @@ async function streamAcceptedSseChatRun({
       });
       await broadcastRunSessionSnapshot(options, runSessionManager, useCurrentSession);
     } else {
-      await promptAndSettle(runSession, prompt, beforeIds, observation);
+      await promptAndSettle(
+        runSession,
+        dispatchedPrompt,
+        beforeIds,
+        observation,
+        promptImages.length > 0 ? { images: promptImages } : undefined,
+      );
       recordAcceptedAction();
       await broadcastRunSessionSnapshot(options, runSessionManager, useCurrentSession);
     }
@@ -709,7 +808,7 @@ function buildSnapshotPayload(sessionManager: SessionManager): Record<string, un
   const entries = sessionManager.getEntries();
   return {
     sessionId,
-    state: projectDashboard(entries, sessionId),
+    state: projectDashboard(entries, sessionId, getSavedMarketStateSymbols()),
     entries,
     events: sessionEntriesToChatEvents(entries, {
       sessionId,
@@ -742,7 +841,7 @@ export async function buildSessionBootstrapPayload(
     sessions: await SessionManager.list(options.cwd, options.sessionDir),
     snapshot: {
       sessionId,
-      state: projectDashboard(entries, sessionId),
+      state: projectDashboard(entries, sessionId, getSavedMarketStateSymbols()),
       entries,
       events: sessionEntriesToChatEvents(entries, {
         sessionId,
@@ -796,20 +895,169 @@ export function buildChatRunActionEnvelope(
   body: Record<string, unknown>,
   sessionId: string,
 ): SessionActionEnvelope {
-  const actionId = String(body.actionId ?? "").trim() || `legacy-chat-${Date.now()}`;
+  const actionId = String(body.actionId ?? "").trim();
+  const parsed = parseChatRunBody(body);
+  const attachments = parsed.ok ? parsed.value.attachments : [];
+  const images = parsed.ok ? parsed.value.images : [];
   return {
     sessionId,
     actionId,
     actionType: "chat.prompt",
-    payload: { prompt: String(body.prompt ?? "") },
+    payload: {
+      prompt: String(body.prompt ?? ""),
+      ...(images.length > 0 ? { imageCount: images.length } : {}),
+      ...(attachments.length > 0
+        ? { attachments: attachments.map((attachment) => ({ kind: attachment.kind })) }
+        : {}),
+    },
     source: "browser",
   };
 }
 
+export function parseChatRunBody(body: unknown): ChatRunParseResult {
+  const record = asRecord(body);
+  const prompt = String(record.prompt ?? "").trim();
+  if (!prompt) return { ok: false, error: "prompt is required" };
+
+  const rawImages = record.images;
+  const images: ChatRunImageInput[] = [];
+  if (rawImages !== undefined) {
+    if (!Array.isArray(rawImages)) return { ok: false, error: "images must be an array" };
+    if (rawImages.length > CHAT_RUN_MAX_IMAGE_COUNT) {
+      return { ok: false, error: "Attach up to 4 images" };
+    }
+    for (const rawImage of rawImages) {
+      const image = asRecord(rawImage);
+      const mimeType = String(image.mimeType ?? "");
+      const data = String(image.data ?? "");
+      if (!CHAT_RUN_IMAGE_MIME_TYPES.has(mimeType)) {
+        return { ok: false, error: "Unsupported image mime type" };
+      }
+      if (data.length > Math.ceil(CHAT_RUN_MAX_IMAGE_BYTES / 3) * 4) {
+        return { ok: false, error: "Image attachment must be 5 MB or smaller" };
+      }
+      const decoded = decodeStrictBase64(data);
+      if (!decoded) {
+        return { ok: false, error: "Image attachment data must be valid base64" };
+      }
+      if (decoded.byteLength > CHAT_RUN_MAX_IMAGE_BYTES) {
+        return { ok: false, error: "Image attachment must be 5 MB or smaller" };
+      }
+      images.push({ data, mimeType });
+    }
+  }
+
+  const rawAttachments = record.attachments;
+  const attachments: ChatRunAttachmentInput[] = [];
+  if (rawAttachments !== undefined) {
+    if (!Array.isArray(rawAttachments)) {
+      return { ok: false, error: "attachments must be an array" };
+    }
+    for (const rawAttachment of rawAttachments) {
+      const attachment = asRecord(rawAttachment);
+      const kind = String(attachment.kind ?? "");
+      const id = typeof attachment.id === "string" ? attachment.id.trim() : "";
+      if (kind === "portfolio") {
+        attachments.push(id ? { kind, id } : { kind });
+      } else if (kind === "watchlist" || kind === "report") {
+        if (!id) return { ok: false, error: `${kind} attachment id is required` };
+        attachments.push({ kind, id });
+      } else {
+        return { ok: false, error: "Unsupported attachment kind" };
+      }
+    }
+  }
+
+  if (prompt.startsWith("/") && (images.length > 0 || attachments.length > 0)) {
+    return { ok: false, error: "Attachments are not supported for slash commands" };
+  }
+
+  return { ok: true, value: { prompt, images, attachments } };
+}
+
+function decodeStrictBase64(data: string): Buffer | null {
+  if (!data || data.trim() !== data) return null;
+  if (data.length % 4 !== 0) return null;
+  if (/[^A-Za-z0-9+/=]/.test(data)) return null;
+  const firstPadding = data.indexOf("=");
+  if (firstPadding !== -1) {
+    const padding = data.slice(firstPadding);
+    if (!/^={1,2}$/.test(padding)) return null;
+  }
+  const decoded = Buffer.from(data, "base64");
+  if (decoded.byteLength === 0) return null;
+  return decoded.toString("base64") === data ? decoded : null;
+}
+
+export async function buildDispatchedPrompt(parsed: ParsedChatRunBody): Promise<string> {
+  if (parsed.prompt.startsWith("/")) return parsed.prompt;
+  if (parsed.attachments.length === 0) return parsed.prompt;
+  const db = initDefaultDatabase();
+  try {
+    const service = new MarketStateService(db);
+    const blocks = parsed.attachments.map((attachment) => {
+      const lines = attachmentSummaryLines(service, attachment);
+      if (lines.length === 0) throw new Error(`${attachment.kind} attachment was empty`);
+      return `[Attached by user — ${attachment.kind}]\n${lines.join("\n")}`;
+    });
+    return [parsed.prompt, ...blocks].join("\n\n");
+  } finally {
+    db.close();
+  }
+}
+
+function attachmentSummaryLines(
+  service: MarketStateService,
+  attachment: ChatRunAttachmentInput,
+): string[] {
+  if (attachment.kind === "portfolio") {
+    const portfolioId = attachment.id ? Number(attachment.id) : undefined;
+    if (attachment.id && !Number.isFinite(portfolioId)) {
+      throw new Error("Unknown portfolio attachment");
+    }
+    return formatPortfolioSummary(service.listPortfolioLots(portfolioId));
+  }
+  if (attachment.kind === "watchlist") {
+    const watchlistId =
+      attachment.id === "default" ? service.getDefaultWatchlist().id : Number(attachment.id);
+    if (!Number.isFinite(watchlistId)) throw new Error("Unknown watchlist attachment");
+    return formatWatchlistSummary(service.listWatchlistItems(watchlistId));
+  }
+  const reports = service.listReportRuns();
+  const report =
+    attachment.id === "latest"
+      ? reports[0]
+      : reports.find((candidate) => candidate.id === Number(attachment.id));
+  if (!report) throw new Error("Unknown report attachment");
+  return formatLatestReportSummary(report);
+}
+
+function attachmentLabel(attachment: ChatRunAttachmentInput): string {
+  if (attachment.kind === "portfolio") return "Portfolio";
+  if (attachment.kind === "watchlist") return "Watchlist";
+  return "Latest report";
+}
+
 function hasClientActionId(body: Record<string, unknown>): boolean {
   return typeof body.actionId === "string" && body.actionId.trim().length > 0;
 }
 
+function requireSessionActionFields(
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  requireSessionId = true,
+): boolean {
+  if (requireSessionId && !String(body.sessionId ?? "").trim()) {
+    writeJson(res, { error: "sessionId is required" }, 400);
+    return false;
+  }
+  if (!String(body.actionId ?? "").trim()) {
+    writeJson(res, { error: "actionId is required" }, 400);
+    return false;
+  }
+  return true;
+}
+
 function shouldBlockFailedCoordinatorAction(
   runSessionManager: SessionManager,
   body: Record<string, unknown>,

package/gui/server/invoke-tool.ts

@@ -194,21 +194,22 @@ export function createToolInvokeController({
     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 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 }));
+      const actionResult = localSessionCoordinator
+        ? await localSessionCoordinator.runSessionAction(
+            {
+              sessionId,
+              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) {

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

@@ -1,6 +1,11 @@
 import type { AssistantMessage, Message } from "@earendil-works/pi-ai";
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
-import type { ChatEvent, MessageContent, ToolOutput } from "../shared/chat-events.js";
+import type {
+  ChatEvent,
+  MessageAttachmentChip,
+  MessageContent,
+  ToolOutput,
+} from "../shared/chat-events.js";
 
 export interface LiveChatEventAdapterOptions {
   runId: string;
@@ -12,6 +17,7 @@ export interface LiveChatEventAdapterOptions {
    * message with an expanded prompt; the live view renders this instead.
    */
   originalPrompt?: string;
+  originalAttachments?: MessageAttachmentChip[];
 }
 
 export interface LiveChatEventAdapter {
@@ -77,7 +83,12 @@ export function createLiveChatEventAdapter(
               type: "message.completed",
               runId: options.runId,
               messageId,
-              content: [{ type: "text", text }],
+              content: userMessageContent(message.content, text),
+              ...(userCount === 1 &&
+              options.originalAttachments &&
+              options.originalAttachments.length > 0
+                ? { attachments: options.originalAttachments }
+                : {}),
             });
             return;
           }
@@ -192,6 +203,30 @@ function messageText(content: unknown): string {
     .join("");
 }
 
+function userMessageContent(content: unknown, text: string): MessageContent[] {
+  const parts: MessageContent[] = [{ 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: unknown, isError: boolean): ToolOutput {
   const record = asRecord(result);
   return {