bunnyquery 1.3.5 → 1.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunnyquery",
-  "version": "1.3.5",
+  "version": "1.4.2",
   "description": "Embeddable BunnyQuery AI chat widget + its framework-agnostic chat engine",
   "main": "bunnyquery.js",
   "exports": {

package/src/engine/attachment_parsers.ts

@@ -0,0 +1,112 @@
+/**
+ * Client-side attachment-parser plugins.
+ *
+ * Some attachment formats can't be read by the model's web_fetch (binary) and
+ * have no server-side extractor either — e.g. legacy Hancom .hwp. A parser
+ * plugin runs IN THE BROWSER, turns the uploaded File into indexable text (or an
+ * HTML string), and the engine sends that content INLINE in the background
+ * indexing request — so the model indexes the parsed content directly, with no
+ * upload-side server extraction and no web_fetch for that file.
+ *
+ * Register a parser with `registerAttachmentParser()`, or via
+ * `configureChatEngine({ attachmentParsers: [...] })`. The BunnyQuery widget also
+ * exposes `BunnyQuery.registerAttachmentParser()` and an `attachmentParsers`
+ * init option. First matching parser wins.
+ */
+
+export interface AttachmentParser {
+	/** Human-readable label — used only in logs. */
+	name?: string;
+	/**
+	 * Return true if this parser handles the file. Receives the file name and
+	 * (when known) its MIME type. Keep it cheap — it runs for every upload.
+	 */
+	match: (file: { name: string; mime?: string }) => boolean;
+	/**
+	 * Parse the File into indexable plain text OR an HTML string (the model reads
+	 * either). Runs in the browser; may be async. Return a falsy/empty value to
+	 * skip (the file then falls back to web_fetch / server extraction).
+	 */
+	parse: (
+		file: File,
+	) => string | null | undefined | Promise<string | null | undefined>;
+}
+
+// Hard ceiling on inlined parsed content (characters), mirroring the worker's
+// server-side MAX_EXTRACTED_CHARS, so a huge document can't blow the model's
+// context window or the request size.
+export const MAX_PARSED_CONTENT_CHARS = 200_000;
+
+const _parsers: AttachmentParser[] = [];
+
+/** Register an attachment parser. Ignores duplicates (by reference) and invalid plugins. */
+export function registerAttachmentParser(parser: AttachmentParser): void {
+	if (
+		parser &&
+		typeof parser.match === 'function' &&
+		typeof parser.parse === 'function' &&
+		_parsers.indexOf(parser) === -1
+	) {
+		_parsers.push(parser);
+	}
+}
+
+/** Remove all registered parsers (mainly for tests / re-init). */
+export function clearAttachmentParsers(): void {
+	_parsers.length = 0;
+}
+
+/** Snapshot of the registered parsers. */
+export function getAttachmentParsers(): AttachmentParser[] {
+	return _parsers.slice();
+}
+
+/** First parser whose `match` returns true for the given file, if any. */
+export function findAttachmentParser(
+	name: string,
+	mime?: string,
+): AttachmentParser | undefined {
+	for (let i = 0; i < _parsers.length; i++) {
+		try {
+			if (_parsers[i].match({ name: name, mime: mime })) return _parsers[i];
+		} catch {
+			/* a throwing matcher must not break uploads */
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Run the matching parser (if any) and return capped, trimmed content — or null
+ * when there is no parser, the parser throws, or it yields nothing. Never throws:
+ * a parser failure degrades to null so the upload still completes (the file then
+ * resolves via its normal path).
+ */
+export async function parseAttachmentContent(
+	file: File,
+	name: string,
+	mime?: string,
+): Promise<string | null> {
+	const parser = findAttachmentParser(name, mime);
+	if (!parser) return null;
+
+	let raw: string | null | undefined;
+	try {
+		raw = await parser.parse(file);
+	} catch (err) {
+		console.error(
+			`[chat-engine] attachment parser ${parser.name || '(unnamed)'} failed for ${name}:`,
+			err,
+		);
+		return null;
+	}
+
+	let text = (raw == null ? '' : String(raw)).trim();
+	if (!text) return null;
+	if (text.length > MAX_PARSED_CONTENT_CHARS) {
+		text =
+			text.slice(0, MAX_PARSED_CONTENT_CHARS) +
+			`\n...[truncated for length; original ${text.length} characters]`;
+	}
+	return text;
+}

package/src/engine/config.ts

@@ -13,6 +13,8 @@
  * send cancel). So the request builders include `poll` only when it is set.
  */
 
+import { type AttachmentParser, registerAttachmentParser } from './attachment_parsers';
+
 export interface ChatEngineConfig {
     /** skapi.clientSecretRequest, bound to the consumer's skapi instance. */
     clientSecretRequest: (opts: any) => Promise<any>;
@@ -25,12 +27,21 @@ export interface ChatEngineConfig {
      * the `poll` key is omitted entirely (agent.vue). BunnyQuery sets `0`.
      */
     poll?: number;
+    /**
+     * Optional client-side attachment parsers (e.g. an .hwp parser). Each is
+     * registered at configure time; more can be added later via
+     * `registerAttachmentParser()`. See attachment_parsers.ts.
+     */
+    attachmentParsers?: AttachmentParser[];
 }
 
 let _config: ChatEngineConfig | null = null;
 
 export function configureChatEngine(config: ChatEngineConfig): void {
     _config = config;
+    if (config.attachmentParsers) {
+        for (const parser of config.attachmentParsers) registerAttachmentParser(parser);
+    }
 }
 
 export function chatEngineConfig(): ChatEngineConfig {

package/src/engine/index.ts

@@ -14,6 +14,7 @@ export {
 } from './config';
 
 export {
+	isServerExtractable,
 	isOfficeFile,
 	makeExtractPlaceholder,
 	composeUserMessage,
@@ -26,6 +27,18 @@ export {
 	type AttachmentFailureGroup,
 } from './attachments';
 
+// Client-side attachment-parser plugins (e.g. .hwp). Register your own parser to
+// turn an uploaded File into indexable text/HTML, sent inline for indexing.
+export {
+	registerAttachmentParser,
+	clearAttachmentParsers,
+	getAttachmentParsers,
+	findAttachmentParser,
+	parseAttachmentContent,
+	MAX_PARSED_CONTENT_CHARS,
+	type AttachmentParser,
+} from './attachment_parsers';
+
 export * from './prompts';
 
 // Pure helpers (Tier-1.5): error detection, token budgeting, link/path

package/src/engine/office.ts

@@ -21,30 +21,74 @@ export type ExtractDirective = {
 	mime?: string;
 };
 
-// Office formats whose text the model cannot read via web_fetch. OOXML
-// (.docx/.xlsx/.pptx) and Hancom .hwpx are extracted server-side; the other
-// (legacy/macro/binary) extensions are still flagged so the worker returns a
-// graceful note instead of the model fetching binary garbage.
+// Files whose text the worker extracts SERVER-SIDE and inlines for indexing,
+// instead of handing the agent a URL to fetch. Two groups:
+//   (1) BINARY document formats the model can't read at all (OOXML, Hancom
+//       HWP/HWPX, OpenDocument, EPUB) — the worker parses them.
+//   (2) TEXT/data/markup/code formats. These ARE readable via web_fetch, BUT
+//       some providers (OpenAI's Responses API) have no working file-fetch tool,
+//       so the agent can't retrieve the URL at all. Extracting them server-side
+//       (the worker just decodes the bytes) makes indexing provider-independent.
 const OFFICE_FILE_EXTENSIONS = new Set([
 	'doc', 'docx', 'docm',
 	'xls', 'xlsx', 'xlsm',
 	'ppt', 'pptx', 'pptm',
 	'hwp', 'hwpx',
+	'ods', 'odt', 'odp',
+	'epub',
 ]);
 
-export function isOfficeFile(name?: string, mime?: string): boolean {
+const TEXT_FILE_EXTENSIONS = new Set([
+	'csv', 'tsv', 'tab', 'txt', 'text', 'log', 'md', 'markdown', 'rst',
+	'json', 'ndjson', 'jsonl', 'geojson', 'xml', 'yaml', 'yml', 'toml',
+	'ini', 'conf', 'cfg', 'properties', 'env', 'rtf', 'html', 'htm',
+	'js', 'mjs', 'cjs', 'ts', 'tsx', 'jsx', 'py', 'rb', 'go', 'rs', 'java',
+	'kt', 'c', 'h', 'cpp', 'cc', 'hpp', 'cs', 'php', 'swift', 'sh', 'bash',
+	'zsh', 'sql', 'css', 'scss', 'less', 'vue', 'svelte', 'tex', 'srt', 'vtt',
+]);
+
+// MIME types that indicate decodable text even when the extension is unknown
+// (the worker has the same fallback, so any text/* file is extracted server-side).
+function isTextMime(m: string): boolean {
+	return (
+		m.startsWith('text/') ||
+		m.endsWith('+json') || m.endsWith('+xml') || m.endsWith('+yaml') ||
+		m === 'application/json' || m === 'application/ld+json' ||
+		m === 'application/xml' || m === 'application/yaml' || m === 'application/x-yaml' ||
+		m === 'application/javascript' || m === 'application/x-javascript' ||
+		m === 'application/x-sh' || m === 'application/x-ndjson' ||
+		m === 'application/csv' || m === 'application/rtf' ||
+		m === 'application/sql' || m === 'application/toml'
+	);
+}
+
+/**
+ * True when a file should be EXTRACTED SERVER-SIDE (text inlined for indexing)
+ * rather than handed to the agent as a URL to fetch — i.e. binary office
+ * documents AND all text/data/code files. Detection is extension-first (so a
+ * .csv reported as an Office MIME is still treated as text), with a text-MIME
+ * fallback for unlisted extensions.
+ */
+export function isServerExtractable(name?: string, mime?: string): boolean {
 	const ext = (name || '').split('.').pop()?.toLowerCase() || '';
 	if (OFFICE_FILE_EXTENSIONS.has(ext)) return true;
+	if (TEXT_FILE_EXTENSIONS.has(ext)) return true;
 	const m = (mime || '').toLowerCase();
+	if (isTextMime(m)) return true;
 	return (
 		m.includes('officedocument') ||
+		m.includes('opendocument') ||
 		m.includes('hwp') ||
+		m.includes('epub') ||
 		m === 'application/msword' ||
 		m === 'application/vnd.ms-excel' ||
 		m === 'application/vnd.ms-powerpoint'
 	);
 }
 
+/** @deprecated renamed to {@link isServerExtractable} (now also covers text files). */
+export const isOfficeFile = isServerExtractable;
+
 // Monotonic counter so placeholders are unique even for same-named files in one
 // request. Token shape must match the worker's _EXTRACT_PLACEHOLDER_RE:
 // {{SKAPI_FILE_CONTENT::<id>}}.
@@ -85,10 +129,10 @@ export function composeUserMessage(
 	let composedForLlm = composed;
 	let extractContent: ExtractDirective[] | undefined;
 	if (attachmentUrls.length > 0) {
-		const officeFiles = attachmentUrls.filter((u) => isOfficeFile(u.name));
-		if (officeFiles.length > 0) {
+		const extractFiles = attachmentUrls.filter((u) => isServerExtractable(u.name));
+		if (extractFiles.length > 0) {
 			const directives: ExtractDirective[] = [];
-			const sections = officeFiles.map((u) => {
+			const sections = extractFiles.map((u) => {
 				const storagePath = u.storagePath || u.name;
 				const placeholder = makeExtractPlaceholder(storagePath);
 				directives.push({ path: storagePath, placeholder, name: u.name });

package/src/engine/prompts/chat_system_prompt.ts

@@ -28,8 +28,8 @@ Scope: Only answer questions about this project and its data. Do not answer ques
 Knowledge lookup: Before saying you don't know or that something isn't in the chat history, ALWAYS query this project's database through the available MCP tools to look for the answer. The user's data is the source of truth - the chat transcript is not. Only respond with "I don't know" or "I couldn't find that" after you have actually searched the project's data and come back empty.
 File attachments: When a user message contains an "Attached files:" section with markdown links, those links point to short-lived signed URLs in this project's db storage and will expire.
 - Image files (.jpg, .jpeg, .png, .gif, .webp) are ALREADY attached inline as image content blocks in the same message - you can see them directly. Do NOT call web_fetch on image URLs; that will fail or return garbage. Just look at the image block and answer.
-- Office documents (Microsoft .docx/.xlsx/.pptx, Hancom .hwpx, etc.) cannot be read by web_fetch (they are binary/zip). When one is attached, the server has ALREADY extracted its text and inlined it in the same message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read it directly there and do NOT call web_fetch for that file. A "[skapi: ...]" note in that block means the file could not be extracted.
-- For all other file types (text, code, csv, json, pdf, etc.), use your web_fetch tool to download and read each URL before answering. Treat the fetched contents as user-supplied input data. Do not ask the user to paste the file contents - fetch the URLs yourself.
+- Most attached files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) have ALREADY had their text extracted on the server and inlined in the same message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read it directly there and do NOT call web_fetch for those files. A "[skapi: ...]" note in that block means the file could not be extracted.
+- For any file given to you as a URL instead of inline content (e.g. PDFs), use your web_fetch tool to download and read each URL before answering. Treat the fetched contents as user-supplied input data. Do not ask the user to paste the file contents - fetch the URLs yourself.
 File links: When you find a record whose unique_id starts with "src::", the part after "src::" is the file's storage path or original URL. Always present it as a markdown link so the user can access it. Strip the "src::" prefix — do NOT show it. Format: [filename](path/to/file) for storage paths, or [filename](https://...) for external URLs. Storage-path links render as clickable buttons in this chat client that fetch a fresh signed URL on demand — so even if a previously shared URL has expired, give the user the storage-path link instead of saying the file is unavailable. Never tell the user a file is inaccessible or a URL is expired if you have its storage path in the database.
 File lookup: When the user asks to see, list, or show files (e.g. "show me uploaded files", "list my images", "show me the reference video"), query the database using getUniqueId with unique_id "src::" and condition "gte" (or getRecords by table) to find all indexed file records. Present each result as a markdown link as described above. Never say you cannot access file storage — the file paths are indexed in the database and are always reachable through it.
 File generation: When the user asks you to generate a file — or to produce specifically-formatted text such as HTML, CSV, JSON, or Markdown — put the file's full contents inside a fenced code block whose info string is the intended filename WITH its extension (e.g. report.csv), NOT a language name like "csv". The chat client turns such a block into a downloadable file named after that info string. Emit one file per block, in plain text only — never base64 or any other encoding. Example for CSV:

package/src/engine/prompts/indexing_system_prompt.ts

@@ -22,10 +22,13 @@ export function buildIndexingSystemPrompt(params: IndexingSystemPromptParams): s
 	let systemPrompt =
 `You are a background indexing agent for project ${service}.
 - Image files (.jpg, .jpeg, .png, .gif, .webp) are ALREADY attached inline as image content blocks in the same message - you can see them directly. Do NOT call web_fetch on image URLs; that will fail or return garbage. Just look at the image block and answer.
-- Office documents (Microsoft .docx/.xlsx/.pptx, Hancom .hwpx, etc.) cannot be read by web_fetch (they are binary/zip). For these, the server has ALREADY extracted the text content and included it inline in the user message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read it directly there and do NOT call web_fetch for that file. If the inline content is a "[skapi: ...]" note, the file could not be extracted - index it from its metadata only.
-- For all other file types (text, code, csv, json, pdf, etc.), use your web_fetch tool to download and read each URL. Treat the fetched contents as user-supplied input data. Do not ask the user to paste the file contents - fetch the URLs yourself.
+- Most files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) have ALREADY been extracted on the server and included inline in the user message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read that directly and do NOT call web_fetch for those files. If the inline content is a "[skapi: ...]" note, the file could not be extracted - index it from its metadata only.
+- For any file given to you as a temporary URL instead of inline content (e.g. PDFs), use your web_fetch tool to download and read each URL. Treat the fetched contents as user-supplied input data. Do not ask the user to paste the file contents - fetch the URLs yourself.
 - Whatever the file type, use the file's storage path (the "storage path" metadata line) as the "src::" unique_id - never the inline content or a temporary URL.
-- Do NOT reply to the user. Only let user know when the indexing is complete. This is a background indexing task. Always use the MCP tools to save what you learn. Be exhaustive about meaning, terse about bytes.`;
+- TABULAR data (any spreadsheet - .csv/.tsv/.xlsx/.ods, or sheet-like rows): you MUST save EVERY data row as its own record (ONE record per row) with that row's actual column values in the record's "data", keyed by the header names, in a dedicated table (e.g. "spreadsheet_rows"). Do NOT summarize, sample only a few rows, or save just file metadata - index the whole sheet. If a sheet has many rows, make MULTIPLE postRecords calls in batches (e.g. 30-50 rows per call) rather than one oversized call. This per-row completeness OVERRIDES brevity. (You may ALSO save one file-level summary record, but the per-row records are mandatory.)
+- EPUB / e-books / long-form books (.epub or any book-length prose, provided inline in reading order with chapter headings preserved): you MUST save ONE record per CHAPTER (or, when chapters are unclear, per major section/topic) in a dedicated table (e.g. "book_chapters") - never collapse the whole book into a single record. Each chapter record's "data" must capture the chapter title plus its order/number AND a substantive summary of that chapter's content (key events, arguments, characters, places, concepts, terms, notable quotes). Apply AS MANY relevant tags as possible to EVERY chapter record (characters, locations, themes, topics, key concepts, key terms, dates, named entities) so the book is easy to SEARCH and cross-reference later - this is the whole point. ALSO save one book-level record (title, author, language, overall summary, chapter list / table of contents, genre/subjects) and link each chapter record to it via reference. This per-chapter completeness OVERRIDES brevity; human-readable summaries only, never raw/binary bytes.
+- This is a ONE-SHOT background indexing task: do ALL the MCP saving FIRST, never reply mid-task, and never ask the user questions or invite back-and-forth. Always use the MCP tools to save what you learn - be exhaustive about meaning (and, for tabular data, about every row). Never store raw or binary bytes (base64, blobs); describe them in human-readable text instead.
+- Only AFTER every save is done, send exactly ONE final message summarizing what you indexed - never just "Indexing complete", and never a raw/base64/binary value or a large pasted dump. Keep it to a few factual sentences or a short markdown bullet list covering: the file name, its content type, each table you wrote to with its record/row count and the key columns/fields or topics captured, and anything that could not be extracted. Follow this shape - Indexed <file name> (<content type>): saved <N> records to <table(s)> capturing <key columns/fields or topics>; could not extract: <gaps, or none>.`;
 
 	if (serviceDescription) {
 		systemPrompt += `

package/src/engine/prompts/indexing_user_message.ts

@@ -30,6 +30,12 @@ export type BuildIndexingUserMessageOptions = {
 	 * drops the temporary-URL line — there is nothing for the model to fetch).
 	 */
 	inlineContentPlaceholder?: string;
+	/**
+	 * Actual file content parsed CLIENT-SIDE by an attachment-parser plugin (e.g.
+	 * an .hwp parser). Embedded inline verbatim — no server extraction and no
+	 * web_fetch for this file. Takes precedence over `inlineContentPlaceholder`.
+	 */
+	inlineContent?: string;
 };
 
 export function buildIndexingUserMessage(
@@ -44,6 +50,20 @@ export function buildIndexingUserMessage(
 		(attachment.mime ? `- mime type: ${attachment.mime}\n` : '') +
 		(typeof attachment.size === 'number' ? `- size (bytes): ${attachment.size}\n` : '');
 
+	if (options?.inlineContent) {
+		// Parsed client-side (an attachment-parser plugin). The content is already
+		// inlined below — no server extraction, no URL to fetch.
+		return (
+			head +
+			`\nThe file's content was parsed by the client and is provided inline below. ` +
+			`Read it directly — do NOT fetch any URL for this file. ` +
+			`Use the storage path above (not this content) for the "src::" unique_id.\n\n` +
+			`----- BEGIN FILE CONTENT -----\n` +
+			`${options.inlineContent}\n` +
+			`----- END FILE CONTENT -----`
+		);
+	}
+
 	if (options?.inlineContentPlaceholder) {
 		// Office file: text was extracted on the server and is inlined below
 		// between the markers. Do NOT fetch any URL for this file.

package/src/engine/requests.ts

@@ -11,7 +11,7 @@
  *                                    only the BgTaskEntry TYPE lives here)
  */
 import { buildIndexingSystemPrompt, buildIndexingUserMessage } from './prompts';
-import { isOfficeFile, makeExtractPlaceholder, type ExtractDirective } from './office';
+import { isServerExtractable, makeExtractPlaceholder, type ExtractDirective } from './office';
 import { chatEngineConfig, pollOpt } from './config';
 
 export const ANTHROPIC_MESSAGES_API_URL = 'https://api.anthropic.com/v1/messages';
@@ -425,17 +425,25 @@ export type AttachmentSaveInfo = {
 		size?: number;
 		url: string;
 	};
+	/**
+	 * Content parsed CLIENT-SIDE by an attachment-parser plugin (e.g. an .hwp
+	 * parser). When set, it is inlined into the indexing message verbatim and
+	 * takes precedence over server-side office extraction / web_fetch.
+	 */
+	parsedContent?: string;
 };
 
-// Background "save into knowledge" call (not a chat turn). Office files get the
-// _skapi_extract directive + an inline-content placeholder instead of a URL.
+// Background "save into knowledge" call (not a chat turn). A client-parsed file
+// (parser plugin) is inlined directly; otherwise office files get the
+// _skapi_extract directive + a placeholder, and everything else gets a URL.
 export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
-	const { platform, service, owner, attachment } = info;
+	const { platform, service, owner, attachment, parsedContent } = info;
 
-	const office = isOfficeFile(attachment.name, attachment.mime);
-	const placeholder = office ? makeExtractPlaceholder(attachment.storagePath) : undefined;
+	// Client-parsed content wins over server-side extraction.
+	const serverExtract = !parsedContent && isServerExtractable(attachment.name, attachment.mime);
+	const placeholder = serverExtract ? makeExtractPlaceholder(attachment.storagePath) : undefined;
 	const extractContent: ExtractDirective[] | undefined =
-		office && placeholder
+		serverExtract && placeholder
 			? [{ path: attachment.storagePath, placeholder, name: attachment.name, mime: attachment.mime }]
 			: undefined;
 	const skapiExtract =
@@ -443,7 +451,11 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 
 	const userMessage = buildIndexingUserMessage(
 		attachment,
-		placeholder ? { inlineContentPlaceholder: placeholder } : undefined,
+		parsedContent
+			? { inlineContent: parsedContent }
+			: placeholder
+				? { inlineContentPlaceholder: placeholder }
+				: undefined,
 	);
 
 	const systemPrompt = buildIndexingSystemPrompt({

package/src/engine/session.ts

@@ -34,6 +34,7 @@ import { isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError, ge
 import { buildBoundedChatMessages } from './budget';
 import { createInlineLinkRegex } from './links';
 import { mapHistoryListToMessages, extractLastUserTextFromRequest } from './history';
+import { parseAttachmentContent } from './attachment_parsers';
 import type { ChatHost, ChatState, ChatMessage } from './host';
 
 function sleep(ms: number): Promise<void> {
@@ -881,6 +882,12 @@ export class ChatSession {
 					urls.push({ name: member.relPath, url: url, storagePath: member.storagePath });
 					if (att.kind !== 'folder') { att.uploadedUrl = url; att.storagePath = member.storagePath; }
 					var mime = member.file.type || self.host.getMimeType(member.file.name);
+					// Run a client-side attachment parser (e.g. .hwp) if one matches; its
+					// output is inlined into the indexing request (falls back to office
+					// extraction / web_fetch when no parser matches or it yields nothing).
+					return Promise.resolve(
+						parseAttachmentContent(member.file, member.file.name, mime || undefined),
+					).then(function (parsedContent: string | null) {
 					return notifyAgentSaveAttachment({
 						platform: id.platform as 'claude' | 'openai',
 						model: id.model,
@@ -893,6 +900,7 @@ export class ChatSession {
 							name: member.file.name, storagePath: member.storagePath,
 							mime: mime || undefined, size: member.file.size, url: url,
 						},
+						parsedContent: parsedContent || undefined,
 					}).then(function (ack: any) {
 						if (ack && typeof ack.id === 'string') {
 							self.bgTaskQueue.push({
@@ -916,6 +924,7 @@ export class ChatSession {
 							att.errorDetail = (e && (e.message || (e.body && e.body.message))) || (typeof e === 'string' ? e : '');
 						}
 					});
+					});
 				});
 			});
 		});