npm - @xopcai/xopc - Versions diffs - 0.0.158 → 0.0.159 - Mend

@xopcai/xopc 0.0.158 → 0.0.159

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (105) hide show

package/dist/gateway/static/root/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png?v=20260713-1" />
     <link rel="manifest" href="/site.webmanifest?v=20260713-1" />
     <title>xopc</title>
-    <script type="module" crossorigin src="/assets/index-EXa_i6BT.js"></script>
+    <script type="module" crossorigin src="/assets/index-BuqGh2SW.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-aKtaBQYM.js">
     <link rel="modulepreload" crossorigin href="/assets/preload-helper-zJ_50EbN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BOUWij0V.js">
@@ -32,7 +32,7 @@
     <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-cxQ94qMm.js">
     <link rel="modulepreload" crossorigin href="/assets/activity-store-C-57rvkX.js">
     <link rel="modulepreload" crossorigin href="/assets/theme-store-C8ohIHhw.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-gpwk8Nro.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BgZhEOkN.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/package.js CHANGED Viewed

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.0.158";
+var version = "0.0.159";
 //#endregion
 export { version };

package/dist/src/agent/embedded/session-tool-result-guard.js CHANGED Viewed

@@ -173,6 +173,20 @@ function sanitizeToolResultDetailsForPersistence(details) {
 		out.sessions = src.sessions.slice(0, MAX_PERSISTED_DETAIL_SESSION_COUNT).map(sanitizePersistedSessionDetail);
 		if (src.sessions.length > MAX_PERSISTED_DETAIL_SESSION_COUNT) out.sessionsTruncated = src.sessions.length - MAX_PERSISTED_DETAIL_SESSION_COUNT;
 	}
+	if (Array.isArray(src.media)) out.media = src.media.slice(0, 12).map((item) => {
+		if (!item || typeof item !== "object") return item;
+		const media = item;
+		return Object.fromEntries([
+			"id",
+			"bucket",
+			"type",
+			"mimeType",
+			"name",
+			"size",
+			"uri",
+			"path"
+		].filter((key) => media[key] !== void 0).map((key) => [key, media[key]]));
+	});
 	return enforcePersistedDetailsByteCap(out, src, originalSize);
 }
 function capToolResultDetails(msg) {

package/dist/src/agent/image/generation/openai-compatible-image-provider.js CHANGED Viewed

@@ -1,11 +1,11 @@
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
+import { imageAssetFromBase64, imageFileExtensionForMimeType } from "./image-assets.js";
 import { pickTimeoutMsOrFallback } from "../../../media-shared/http/deadline.js";
 import { privateNetworkPolicyToSsrfGuardOptions } from "../../../media-shared/http/private-network.js";
 import { resolveProviderHttpRequestConfig } from "../../../media-shared/http/resolve-provider-http-request-config.js";
 import { postJsonRequest, postMultipartRequest } from "../../../media-shared/http/provider-http.js";
 import "../../../media-shared/http/index.js";
-import { imageAssetFromBase64, imageFileExtensionForMimeType } from "./image-assets.js";
 //#region src/agent/image/generation/openai-compatible-image-provider.ts
 init_logger();
 const log = createLogger("ImageGen:OpenAICompat");

package/dist/src/agent/service/process-direct-streaming.js CHANGED Viewed

@@ -102,7 +102,7 @@ function pushAssistantReceipt(queue, text, runId, metadata) {
 		message
 	});
 	queue.push({
-		type: "message_update",
+		type: "assistant_snapshot",
 		runId,
 		message
 	});

package/dist/src/agent/tools/image-generate-tool.js CHANGED Viewed

@@ -1,7 +1,8 @@
 import { getAgentDefaultImageGenerationModelConfig, init_schema } from "../../config/schema.js";
+import { imageAssetFromDataUrl, imageFileExtensionForMimeType, mimeTypeFromFileName, parseImageDataUrl, sniffImageMimeType } from "../image/generation/image-assets.js";
+import { persistToolMedia } from "./tool-media.js";
 import { applyImageGenerationModelConfigDefaults } from "../image/image-helpers.js";
 import { isFailoverError } from "../failover-error.js";
-import { imageAssetFromDataUrl, imageFileExtensionForMimeType, mimeTypeFromFileName, parseImageDataUrl, sniffImageMimeType } from "../image/generation/image-assets.js";
 import { getImageGenerationProvider } from "../image/generation/provider-registry.js";
 import { generateImage, listImageGenerationProvidersSummary } from "../image/generation/runtime.js";
 import path from "node:path";
@@ -174,7 +175,7 @@ function createImageGenerateTool(options) {
 	return {
 		name: "image_generate",
 		label: "Image Generation",
-		description: "Generate images with the configured image-generation model (default OpenAI). Use action=\"list\" to see providers. Saves files under workspace/media/generated/.",
+		description: "Generate and attach images with the configured image-generation model. Use action=\"list\" to see providers. Also saves files under workspace/media/generated/. Do not call send_media for generated images.",
 		parameters: ImageGenerateToolSchema,
 		async execute(_toolCallId, args) {
 			const params = args;
@@ -254,7 +255,12 @@ function createImageGenerateTool(options) {
 					...filename ? { filenameHint: filename } : {}
 				});
 				const workspaceRelativePaths = paths.map((p) => path.relative(options.workspace, p).split(path.sep).join("/"));
-				const lines = [`Generated ${paths.length} image(s) with ${result.provider}/${result.model}.`, ...paths.map((p) => `Saved: ${p}`)];
+				const media = await Promise.all(result.images.map((image, index) => persistToolMedia({
+					buffer: image.buffer,
+					filePath: paths[index],
+					mediaType: "photo"
+				})));
+				const lines = [`Generated and attached ${paths.length} image(s) with ${result.provider}/${result.model}.`, ...paths.map((p) => `Saved: ${p}`)];
 				for (const note of buildNormalizationNotes(result.normalization, result.ignoredOverrides)) lines.push(note);
 				return {
 					content: [{
@@ -266,6 +272,7 @@ function createImageGenerateTool(options) {
 						model: result.model,
 						paths,
 						workspaceRelativePaths,
+						media,
 						attempts: result.attempts,
 						...result.normalization ? { normalization: result.normalization } : {},
 						...result.ignoredOverrides.length > 0 ? { ignoredOverrides: result.ignoredOverrides } : {},

package/dist/src/agent/tools/send-media.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { checkFileSafety } from "../prompt/safety.js";
 import { resolvePathUnderWorkspace } from "./tool-paths.js";
+import { persistToolMedia } from "./tool-media.js";
 import { basename } from "node:path";
 import { readFile } from "fs/promises";
 import { Type } from "@sinclair/typebox";
@@ -14,61 +15,6 @@ const SendMediaSchema = Type.Object({
 	}, { description: "Type of media to send (auto-detected if not specified)" })),
 	caption: Type.Optional(Type.String({ description: "Caption for the media" }))
 });
-function detectMediaType(filePath) {
-	const ext = filePath.split(".").pop()?.toLowerCase();
-	const imageExts = [
-		"jpg",
-		"jpeg",
-		"png",
-		"gif",
-		"webp",
-		"bmp"
-	];
-	const videoExts = [
-		"mp4",
-		"mov",
-		"avi",
-		"webm",
-		"mkv"
-	];
-	const audioExts = [
-		"mp3",
-		"wav",
-		"ogg",
-		"m4a",
-		"flac"
-	];
-	if (imageExts.includes(ext || "")) return "photo";
-	if (videoExts.includes(ext || "")) return "video";
-	if (audioExts.includes(ext || "")) return "audio";
-	return "document";
-}
-function detectMimeType(filePath) {
-	return {
-		jpg: "image/jpeg",
-		jpeg: "image/jpeg",
-		png: "image/png",
-		gif: "image/gif",
-		webp: "image/webp",
-		bmp: "image/bmp",
-		svg: "image/svg+xml",
-		mp4: "video/mp4",
-		mov: "video/quicktime",
-		avi: "video/x-msvideo",
-		webm: "video/webm",
-		mp3: "audio/mpeg",
-		wav: "audio/wav",
-		ogg: "audio/ogg",
-		m4a: "audio/mp4",
-		flac: "audio/flac",
-		pdf: "application/pdf",
-		doc: "application/msword",
-		docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-		txt: "text/plain",
-		zip: "application/zip",
-		rar: "application/x-rar-compressed"
-	}[filePath.split(".").pop()?.toLowerCase() || ""] || "application/octet-stream";
-}
 function createSendMediaTool(workspace, bus, getContext) {
 	return {
 		name: "send_media",
@@ -95,26 +41,30 @@ function createSendMediaTool(workspace, bus, getContext) {
 				details: {}
 			};
 			try {
-				const base64 = (await readFile(resolved)).toString("base64");
-				const mimeType = detectMimeType(resolved);
-				const mediaType = p.mediaType || detectMediaType(resolved);
-				const dataUrl = `data:${mimeType};base64,${base64}`;
-				const msg = {
-					channel: ctx.channel,
-					chat_id: ctx.chatId,
-					content: p.caption || "",
-					mediaUrl: dataUrl,
-					mediaType
-				};
-				await bus.publishOutbound(msg);
+				const fileBuffer = await readFile(resolved);
+				const media = await persistToolMedia({
+					buffer: fileBuffer,
+					filePath: resolved,
+					...p.mediaType ? { mediaType: p.mediaType } : {}
+				});
+				if (ctx.channel !== "webchat") {
+					const msg = {
+						channel: ctx.channel,
+						chat_id: ctx.chatId,
+						content: p.caption || "",
+						mediaUrl: `data:${media.mimeType};base64,${fileBuffer.toString("base64")}`,
+						mediaType: media.type
+					};
+					await bus.publishOutbound(msg);
+				}
 				return {
 					content: [{
 						type: "text",
-						text: `✅ Media sent: ${basename(resolved)} (${mediaType})`
+						text: `Media attached: ${basename(resolved)} (${media.type})`
 					}],
 					details: {
-						filePath: resolved,
-						mediaType
+						media: [media],
+						...p.caption ? { caption: p.caption } : {}
 					}
 				};
 			} catch (error) {

package/dist/src/agent/tools/tool-media.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import type { MediaRef } from '../../media/types.js';
+export type ToolMediaType = 'photo' | 'video' | 'audio' | 'document';
+export declare function detectToolMediaMimeType(buffer: Buffer, filePath: string): string;
+export declare function mediaTypeFromMimeType(mimeType: string): ToolMediaType;
+export declare function persistToolMedia(params: {
+    buffer: Buffer;
+    filePath: string;
+    mediaType?: ToolMediaType;
+}): Promise<MediaRef>;

package/dist/src/agent/tools/tool-media.js ADDED Viewed

@@ -0,0 +1,58 @@
+import { sniffImageMimeType } from "../image/generation/image-assets.js";
+import { mimeTypeFromMediaPath, saveMediaBuffer } from "../../media/store.js";
+import { basename } from "node:path";
+//#region src/agent/tools/tool-media.ts
+const MAX_TOOL_MEDIA_BYTES = 50 * 1024 * 1024;
+function hasImageMagic(buffer) {
+	if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]))) return true;
+	if (buffer.length >= 3 && buffer.subarray(0, 3).equals(Buffer.from([
+		255,
+		216,
+		255
+	]))) return true;
+	if (buffer.length >= 4 && buffer.subarray(0, 4).toString("ascii") === "GIF8") return true;
+	return buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP";
+}
+function detectToolMediaMimeType(buffer, filePath) {
+	if (hasImageMagic(buffer)) return sniffImageMimeType(buffer).mimeType;
+	if (buffer.length >= 5 && buffer.subarray(0, 5).toString("ascii") === "%PDF-") return "application/pdf";
+	return mimeTypeFromMediaPath(filePath);
+}
+function mediaTypeFromMimeType(mimeType) {
+	if (mimeType === "image/svg+xml") return "document";
+	if (mimeType.startsWith("image/")) return "photo";
+	if (mimeType.startsWith("video/")) return "video";
+	if (mimeType.startsWith("audio/")) return "audio";
+	return "document";
+}
+async function persistToolMedia(params) {
+	const name = basename(params.filePath);
+	const mimeType = detectToolMediaMimeType(params.buffer, params.filePath);
+	const saved = await saveMediaBuffer(params.buffer, {
+		bucket: "outbound",
+		contentType: mimeType,
+		originalFilename: name,
+		maxBytes: MAX_TOOL_MEDIA_BYTES
+	});
+	return {
+		id: saved.id,
+		bucket: saved.bucket,
+		type: params.mediaType ?? mediaTypeFromMimeType(mimeType),
+		mimeType: saved.contentType,
+		name,
+		size: saved.size,
+		uri: saved.uri,
+		path: saved.path
+	};
+}
+//#endregion
+export { detectToolMediaMimeType, mediaTypeFromMimeType, persistToolMedia };

package/dist/src/config/agent-profile.js CHANGED Viewed

@@ -1,6 +1,6 @@
+import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import "../agent-manifest/index.js";
-import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { init_session_key, parseSessionKey } from "../routing/session-key.js";
 import { agentExists, getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 //#region src/config/agent-profile.ts

package/dist/src/gateway/agent-run-relay.d.ts CHANGED Viewed

@@ -7,7 +7,9 @@ export type RelayEvent = {
     type: string;
 } & Record<string, unknown>;
 export declare class AgentRunRelay {
+    private readonly maxEvents;
     private runs;
+    constructor(maxEvents?: number);
     ensureRun(runId: string, sessionKey: string): void;
     getSessionKey(runId: string): string | undefined;
     hasRun(runId: string): boolean;

package/dist/src/gateway/agent-run-relay.js CHANGED Viewed

@@ -5,8 +5,84 @@ init_logger();
 const log = createLogger("Gateway:AgentRunRelay");
 const COMPLETE_TTL_MS = 5 * 6e4;
 const MAX_EVENTS = 8e3;
+const COMPACT_TO_RATIO = .75;
+const MAX_MERGED_DELTA_CHARS = 16 * 1024;
+const REPLAY_DELTA_TYPES = new Set([
+	"assistant_delta",
+	"thinking_delta",
+	"command_output_delta",
+	"review_delta"
+]);
+function eventSeq(event) {
+	return typeof event.seq === "number" ? event.seq : void 0;
+}
+function findEventAtOrAfter(events, seq) {
+	let low = 0;
+	let high = events.length;
+	while (low < high) {
+		const middle = low + Math.floor((high - low) / 2);
+		if ((eventSeq(events[middle]) ?? Number.MAX_SAFE_INTEGER) < seq) low = middle + 1;
+		else high = middle;
+	}
+	return events[low];
+}
+function recordValue(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function sameDeltaStream(left, right) {
+	if (left.type !== right.type || !REPLAY_DELTA_TYPES.has(left.type)) return false;
+	const leftPayload = recordValue(left.payload);
+	const rightPayload = recordValue(right.payload);
+	if (!leftPayload || !rightPayload) return false;
+	return [
+		"messageId",
+		"toolCallId",
+		"reviewId",
+		"stream"
+	].every((key) => leftPayload[key] === rightPayload[key]);
+}
+function mergeReplayDelta(events, event) {
+	const previous = events.at(-1);
+	if (!previous || !sameDeltaStream(previous, event)) return false;
+	const previousPayload = recordValue(previous.payload);
+	const payload = recordValue(event.payload);
+	const previousDelta = previousPayload?.delta;
+	const delta = payload?.delta;
+	if (typeof previousDelta !== "string" || typeof delta !== "string") return false;
+	if (previousDelta.length + delta.length > MAX_MERGED_DELTA_CHARS) return false;
+	events[events.length - 1] = {
+		...previous,
+		payload: {
+			...previousPayload,
+			delta: previousDelta + delta
+		}
+	};
+	return true;
+}
+function compactEvents(events, targetSize) {
+	let remaining = Math.max(0, events.length - targetSize);
+	const retained = [];
+	const removedByType = {};
+	for (const event of events) {
+		if (remaining > 0 && REPLAY_DELTA_TYPES.has(event.type)) {
+			remaining -= 1;
+			removedByType[event.type] = (removedByType[event.type] ?? 0) + 1;
+			continue;
+		}
+		retained.push(event);
+	}
+	if (remaining > 0) for (const event of retained.splice(0, remaining)) removedByType[event.type] = (removedByType[event.type] ?? 0) + 1;
+	return {
+		events: retained,
+		removedByType
+	};
+}
 var AgentRunRelay = class {
 	runs = /* @__PURE__ */ new Map();
+	constructor(maxEvents = MAX_EVENTS) {
+		this.maxEvents = maxEvents;
+		if (!Number.isInteger(maxEvents) || maxEvents < 2) throw new Error("AgentRunRelay maxEvents must be an integer greater than 1");
+	}
 	ensureRun(runId, sessionKey) {
 		if (this.runs.has(runId)) return;
 		this.runs.set(runId, {
@@ -14,7 +90,9 @@ var AgentRunRelay = class {
 			events: [],
 			nextSeq: 1,
 			done: false,
-			waiters: []
+			waiters: [],
+			subscriberCount: 0,
+			compactionWarned: false
 		});
 	}
 	getSessionKey(runId) {
@@ -31,12 +109,22 @@ var AgentRunRelay = class {
 			runId,
 			seq: state.nextSeq++
 		};
-		if (state.events.length >= MAX_EVENTS) log.warn({
-			runId,
-			max: MAX_EVENTS,
-			droppedType: relayed.type
-		}, "Relay buffer full; dropping event (resume may miss tool_end/tokens)");
-		else state.events.push(relayed);
+		const merged = state.subscriberCount === 0 && mergeReplayDelta(state.events, relayed);
+		if (!merged && state.events.length >= this.maxEvents) {
+			const targetSize = Math.max(1, Math.floor(this.maxEvents * COMPACT_TO_RATIO));
+			const compacted = compactEvents(state.events, targetSize);
+			state.events = compacted.events;
+			if (!state.compactionWarned) {
+				state.compactionWarned = true;
+				log.warn({
+					runId,
+					max: this.maxEvents,
+					retained: state.events.length,
+					removedByType: compacted.removedByType
+				}, "Relay replay buffer compacted; old delta events are no longer resumable");
+			}
+		}
+		if (!merged) state.events.push(relayed);
 		const waiters = state.waiters.splice(0);
 		for (const w of waiters) w();
 		return relayed;
@@ -55,13 +143,25 @@ var AgentRunRelay = class {
 	async *subscribe(runId) {
 		const state = this.runs.get(runId);
 		if (!state) throw new Error("UNKNOWN_RUN");
-		let cursor = 0;
-		while (true) {
-			while (cursor < state.events.length) yield state.events[cursor++];
-			if (state.done) break;
-			await new Promise((resolve) => {
-				state.waiters.push(resolve);
-			});
+		state.subscriberCount += 1;
+		try {
+			let nextSeq = eventSeq(state.events[0]) ?? state.nextSeq;
+			while (true) {
+				const earliestSeq = eventSeq(state.events[0]);
+				if (earliestSeq !== void 0 && nextSeq < earliestSeq) nextSeq = earliestSeq;
+				const available = findEventAtOrAfter(state.events, nextSeq);
+				if (available) {
+					nextSeq = (eventSeq(available) ?? nextSeq) + 1;
+					yield available;
+					continue;
+				}
+				if (state.done) break;
+				await new Promise((resolve) => {
+					state.waiters.push(resolve);
+				});
+			}
+		} finally {
+			state.subscriberCount -= 1;
 		}
 	}
 };

package/dist/src/gateway/agents-admin.js CHANGED Viewed

@@ -1,5 +1,5 @@
-import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
+import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
 import { WORKSPACE_FILES, init_paths, resolveUserProfilePath } from "../config/paths.js";
 import { AGENT_PROFILE_MARKDOWN_SYSTEM_FILES, REQUIRED_AGENT_PROFILE_MARKDOWN_FILE_SET } from "../agent/context/workspace.js";

package/dist/src/gateway/chat-stream/mapper.d.ts CHANGED Viewed

@@ -14,7 +14,6 @@ export declare class ChatStreamMapper {
     private assistantIndex;
     private currentAssistantMessageId;
     private lastAssistantMessageId;
-    private currentAssistantText;
     private currentAssistantReviewEmitted;
     private toolCallToMessageId;
     private turnDiffs;
@@ -30,6 +29,7 @@ export declare class ChatStreamMapper {
     error(message: string, code?: string): ChatStreamEvent[];
     private mapMessageStart;
     private mapMessageUpdate;
+    private mapAssistantSnapshot;
     private mapMessageEnd;
     private mapToolStart;
     private mapToolUpdate;

package/dist/src/gateway/chat-stream/mapper.js CHANGED Viewed

@@ -4,7 +4,6 @@ var ChatStreamMapper = class {
 	assistantIndex = 0;
 	currentAssistantMessageId;
 	lastAssistantMessageId;
-	currentAssistantText = "";
 	currentAssistantReviewEmitted = false;
 	toolCallToMessageId = /* @__PURE__ */ new Map();
 	turnDiffs = [];
@@ -23,6 +22,7 @@ var ChatStreamMapper = class {
 			case "agent_end": return [];
 			case "message_start": return this.mapMessageStart(event.message);
 			case "message_update": return this.mapMessageUpdate(event);
+			case "assistant_snapshot": return this.mapAssistantSnapshot(event.message);
 			case "message_end": return this.mapMessageEnd(event.message);
 			case "tool_execution_start": return this.mapToolStart(event);
 			case "tool_execution_update": return this.mapToolUpdate(event);
@@ -44,7 +44,7 @@ var ChatStreamMapper = class {
 				status: event.status === "error" ? "error" : "complete",
 				...typeof event.message === "string" && event.message ? { message: event.message } : {}
 			})];
-			case "user_message": return [this.make("user_message", { message: userMessageFromLegacyEvent(event) })];
+			case "user_message": return [this.make("user_message", { message: userMessageFromEvent(event) })];
 			case "user_transcript": return [this.make("user_transcript", {
 				text: String(event.text ?? ""),
 				media: event.media
@@ -147,7 +147,6 @@ var ChatStreamMapper = class {
 		if (raw?.role !== "assistant") return [];
 		const messageId = this.nextAssistantMessageId();
 		this.currentAssistantMessageId = messageId;
-		this.currentAssistantText = "";
 		this.currentAssistantReviewEmitted = false;
 		return [this.make("assistant_message_start", { messageId })];
 	}
@@ -155,39 +154,42 @@ var ChatStreamMapper = class {
 		const message = event.message;
 		if (message?.role !== "assistant") return [];
 		const messageId = this.ensureAssistantMessageId();
+		const events = [];
 		const review = extractReview(message);
 		if (review && !this.currentAssistantReviewEmitted) {
 			this.currentAssistantReviewEmitted = true;
-			return [this.make("review", {
+			events.push(this.make("review", {
 				messageId,
 				review
-			})];
+			}));
 		}
 		const delta = event.assistantMessageEvent;
-		if (delta?.type === "text_delta" && typeof delta.delta === "string" && delta.delta) {
-			const text = extractTextFromMessage(message);
-			const suffixFromMessage = appendSuffix(this.currentAssistantText, text);
-			const suffix = text ? suffixFromMessage : appendSuffix(this.currentAssistantText, delta.delta);
-			if (!suffix) {
-				if (text) this.currentAssistantText = text;
-				return [];
-			}
-			this.currentAssistantText = text || `${this.currentAssistantText}${suffix}`;
-			return [this.make("assistant_delta", {
+		if (delta?.type === "text_delta" && typeof delta.delta === "string" && delta.delta) events.push(this.make("assistant_delta", {
+			messageId,
+			delta: delta.delta
+		}));
+		if (delta?.type === "thinking_delta" && typeof delta.delta === "string" && delta.delta) events.push(this.make("thinking_delta", {
+			messageId,
+			delta: delta.delta
+		}));
+		return events;
+	}
+	mapAssistantSnapshot(raw) {
+		const message = raw;
+		if (message?.role !== "assistant") return [];
+		const messageId = this.ensureAssistantMessageId();
+		const review = extractReview(message);
+		if (review && !this.currentAssistantReviewEmitted) {
+			this.currentAssistantReviewEmitted = true;
+			return [this.make("review", {
 				messageId,
-				delta: suffix
+				review
 			})];
 		}
-		if (delta?.type === "thinking_delta" && typeof delta.delta === "string" && delta.delta) return [this.make("thinking_delta", {
-			messageId,
-			delta: delta.delta
-		})];
 		const text = extractTextFromMessage(message);
-		const suffix = appendSuffix(this.currentAssistantText, text);
-		this.currentAssistantText = text || this.currentAssistantText;
-		return suffix ? [this.make("assistant_delta", {
+		return text ? [this.make("assistant_delta", {
 			messageId,
-			delta: suffix
+			delta: text
 		})] : [];
 	}
 	mapMessageEnd(raw) {
@@ -203,13 +205,6 @@ var ChatStreamMapper = class {
 				review
 			}));
 		}
-		const text = extractTextFromMessage(message);
-		const suffix = appendSuffix(this.currentAssistantText, text);
-		if (suffix) events.push(this.make("assistant_delta", {
-			messageId,
-			delta: suffix
-		}));
-		this.currentAssistantText = text || this.currentAssistantText;
 		events.push(this.make("thinking_end", { messageId }));
 		if (this.turnDiffs.length > 0) {
 			events.push(this.make("turn_diff", {
@@ -230,7 +225,6 @@ var ChatStreamMapper = class {
 		}));
 		this.lastAssistantMessageId = messageId;
 		this.currentAssistantMessageId = void 0;
-		this.currentAssistantText = "";
 		this.currentAssistantReviewEmitted = false;
 		return events;
 	}
@@ -368,7 +362,7 @@ var ChatStreamMapper = class {
 		}
 	}
 };
-function userMessageFromLegacyEvent(event) {
+function userMessageFromEvent(event) {
 	return {
 		role: "user",
 		content: event.content ?? [],
@@ -400,15 +394,6 @@ function extractText(value) {
 		return rec.type === "text" && typeof rec.text === "string" ? rec.text : "";
 	}).join("") || void 0;
 }
-function appendSuffix(base, next) {
-	if (!next) return "";
-	if (!base) return next;
-	if (next === base || base.endsWith(next)) return "";
-	if (next.startsWith(base)) return next.slice(base.length);
-	const max = Math.min(base.length, next.length, 512);
-	for (let overlap = max; overlap > 0; overlap--) if (base.slice(-overlap) === next.slice(0, overlap)) return next.slice(overlap);
-	return next;
-}
 function extractUsage(message) {
 	const usage = message.usage;
 	if (!usage || typeof usage !== "object") return void 0;

package/dist/src/gateway/chat-stream/thinking-delta-coalescer.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { ChatStreamEvent } from './protocol.js';
+type CoalescerOptions = {
+    windowMs?: number;
+    maxChars?: number;
+};
+export declare function coalesceThinkingDeltas(source: AsyncIterable<ChatStreamEvent>, options?: CoalescerOptions): AsyncGenerator<ChatStreamEvent>;
+export {};