@sparkelf/dsh-plugin-document-attachments 0.1.0-rc.10

package/lib/types-gD1pbaLm.js

@@ -0,0 +1,404 @@
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { Buffer } from "node:buffer";
+import { AttachmentError, admitEncodedImages } from "@deepseek-ai/dsh-attachment";
+import { TypertRemoteFailure } from "@deepseek-ai/dsh-typert-protocol";
+//#region lib/types/error.js
+/** Document parser failures crossing provider and Host admission. @module @deepseek-ai/dsh-document-parser/error */
+/** Failure crossing the document-parser capability seam. */
+var DocumentParserError = class extends Error {
+	/** Stable machine-routing failure code. */
+	code;
+	/**
+	* @param message - user-safe failure description without original bytes or parser temporary paths.
+	* @param code - stable parser failure code.
+	* @param options - optional chained cause.
+	*/
+	constructor(message, code, options) {
+		super(message, options);
+		this.name = "DocumentParserError";
+		this.code = code;
+	}
+};
+//#endregion
+//#region lib/types/input.js
+/** Authenticated mixed prompt admission for parsed document attachments. */
+/** Exact privileged browser route owned by this capability. */
+const DOCUMENT_PROMPT_PATH = "/api/document.prompt";
+const DOCUMENT_EXTENSIONS = Object.freeze({
+	"application/pdf": ".pdf",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx"
+});
+const DOCUMENT_MEDIA_TYPES = new Set(Object.keys(DOCUMENT_EXTENSIONS));
+const IMAGE_MEDIA_TYPES = new Set([
+	"image/png",
+	"image/jpeg",
+	"image/webp",
+	"image/gif"
+]);
+var DocumentInputError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+		this.name = "DocumentInputError";
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredString(record, key) {
+	const value = record[key];
+	if (typeof value !== "string") throw new DocumentInputError("INVALID_REQUEST", `${key} must be a string`);
+	return value;
+}
+function parsePart(value) {
+	if (!isRecord(value)) throw new DocumentInputError("INVALID_REQUEST", "content entries must be objects");
+	const type = requiredString(value, "type");
+	if (type === "text") return {
+		type,
+		text: requiredString(value, "text")
+	};
+	if (type === "image") {
+		const mediaType = requiredString(value, "mediaType");
+		if (!IMAGE_MEDIA_TYPES.has(mediaType)) throw new DocumentInputError("INVALID_REQUEST", "image mediaType is unsupported");
+		const name = value.name;
+		if (name !== void 0 && typeof name !== "string") throw new DocumentInputError("INVALID_REQUEST", "image name must be a string");
+		return {
+			type,
+			mediaType,
+			data: requiredString(value, "data"),
+			...name === void 0 ? {} : { name }
+		};
+	}
+	if (type === "document") {
+		const mediaType = requiredString(value, "mediaType");
+		if (!DOCUMENT_MEDIA_TYPES.has(mediaType)) throw new DocumentInputError("INVALID_REQUEST", "document mediaType is unsupported");
+		return {
+			type,
+			mediaType,
+			data: requiredString(value, "data"),
+			name: requiredString(value, "name")
+		};
+	}
+	throw new DocumentInputError("INVALID_REQUEST", "content entry type is unsupported");
+}
+function parsePromptRequest(value) {
+	if (!isRecord(value)) throw new DocumentInputError("INVALID_REQUEST", "request body must be an object");
+	const mode = requiredString(value, "mode");
+	if (mode !== "steer" && mode !== "followup") throw new DocumentInputError("INVALID_REQUEST", "mode must be steer or followup");
+	if (!Array.isArray(value.content) || value.content.length === 0) throw new DocumentInputError("INVALID_REQUEST", "content must be a non-empty array");
+	const clientTimeZone = value.clientTimeZone;
+	if (clientTimeZone !== void 0 && typeof clientTimeZone !== "string") throw new DocumentInputError("INVALID_REQUEST", "clientTimeZone must be a string");
+	return {
+		sessionId: requiredString(value, "sessionId"),
+		requestId: requiredString(value, "requestId"),
+		mode,
+		content: value.content.map(parsePart),
+		...clientTimeZone === void 0 ? {} : { clientTimeZone }
+	};
+}
+function decodeCanonicalBase64(value) {
+	const decoded = Buffer.from(value, "base64");
+	if (value.length === 0 || decoded.toString("base64") !== value) throw new DocumentInputError("INVALID_DOCUMENT_BASE64", "Document upload is not canonical base64.");
+	return new Uint8Array(decoded);
+}
+function displayName(value) {
+	const clean = value.slice(Math.max(value.lastIndexOf("/"), value.lastIndexOf("\\")) + 1).replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, 255);
+	if (clean === "") throw new DocumentInputError("INVALID_DOCUMENT", "Document name is empty after normalization.");
+	return clean;
+}
+function hasDocumentSignature(data, mediaType) {
+	if (mediaType === "application/pdf") return data.byteLength >= 5 && data[0] === 37 && data[1] === 80 && data[2] === 68 && data[3] === 70 && data[4] === 45;
+	return data.byteLength >= 4 && data[0] === 80 && data[1] === 75 && (data[2] === 3 && data[3] === 4 || data[2] === 5 && data[3] === 6 || data[2] === 7 && data[3] === 8);
+}
+function decodeDocuments(parts, limits) {
+	if (parts.length > limits.maxDocumentsPerMessage) throw new DocumentInputError("TOO_MANY_DOCUMENTS", "Document batch exceeds the configured document-count limit.");
+	const decoded = [];
+	let totalBytes = 0;
+	for (const part of parts) {
+		if (!limits.mediaTypes.includes(part.mediaType)) throw new DocumentInputError("UNSUPPORTED_DOCUMENT_TYPE", `Document type ${part.mediaType} is not accepted by this deployment.`);
+		const name = displayName(part.name);
+		if (!name.toLowerCase().endsWith(DOCUMENT_EXTENSIONS[part.mediaType])) throw new DocumentInputError("DOCUMENT_TYPE_MISMATCH", "Document filename extension does not match the declared media type.");
+		const data = decodeCanonicalBase64(part.data);
+		if (data.byteLength > limits.maxDocumentBytes) throw new DocumentInputError("DOCUMENT_TOO_LARGE", "Document exceeds the configured byte limit.");
+		if (!hasDocumentSignature(data, part.mediaType)) throw new DocumentInputError("INVALID_DOCUMENT", "Document bytes do not match the required container signature.");
+		totalBytes += data.byteLength;
+		decoded.push({
+			data,
+			mediaType: part.mediaType,
+			name
+		});
+	}
+	if (totalBytes > limits.maxMessageDocumentBytes) throw new DocumentInputError("DOCUMENTS_TOO_LARGE", "Document batch exceeds the configured aggregate byte limit.");
+	return decoded;
+}
+function renderModelText(attachment, markdown) {
+	const text = new TextDecoder("utf-8", { fatal: true }).decode(markdown);
+	return new TextEncoder().encode(`[attached document: ${attachment.name} (${attachment.mediaType}); parsed contents follow]\n\n${text}\n\n[end attached document: ${attachment.name}]`);
+}
+async function prepareDocuments(store, parser, parts, signal) {
+	const decoded = decodeDocuments(parts, store.documentLimits);
+	const parsed = [];
+	let modelBytes = 0;
+	for (const document of decoded) {
+		signal.throwIfAborted();
+		const original = await store.saveFile(document);
+		const attachment = {
+			attachmentId: original.attachmentId,
+			mediaType: document.mediaType,
+			bytes: original.bytes,
+			name: original.name ?? document.name
+		};
+		const output = await parser.parse({
+			attachment,
+			data: document.data
+		}, signal);
+		const modelText = renderModelText(attachment, output.result.markdown);
+		modelBytes += modelText.byteLength;
+		parsed.push({
+			attachment,
+			result: output.result,
+			parser: output.parser,
+			modelText
+		});
+	}
+	if (modelBytes > parser.maxDirectMarkdownBytes) throw new DocumentParserError("Parsed document content exceeds the configured direct-context byte limit.", "DOCUMENT_PARSE_CONTEXT_TOO_LARGE");
+	const imageInputs = [];
+	for (const document of parsed) for (const image of document.result.images) imageInputs.push(image);
+	const imageRefs = await store.saveImages(imageInputs);
+	let imageOffset = 0;
+	const blocks = [];
+	for (const document of parsed) {
+		const images = imageRefs.slice(imageOffset, imageOffset + document.result.images.length);
+		imageOffset += images.length;
+		const markdown = await store.saveFile({
+			data: document.result.markdown,
+			mediaType: "text/markdown; charset=utf-8",
+			name: `${document.attachment.name}.md`
+		});
+		const modelText = await store.saveFile({
+			data: document.modelText,
+			mediaType: "text/plain; charset=utf-8",
+			name: `${document.attachment.name}.model.txt`
+		});
+		const contentList = await store.saveFile({
+			data: document.result.contentList,
+			mediaType: "application/json",
+			name: `${document.attachment.name}.content-list.json`
+		});
+		blocks.push({
+			type: "document",
+			attachment: document.attachment,
+			parsed: {
+				parser: document.parser,
+				markdown,
+				modelText,
+				contentList,
+				images: [...images]
+			}
+		});
+	}
+	return blocks;
+}
+async function preparePromptContent(attachments, store, parser, parts, signal) {
+	const images = parts.filter((part) => part.type === "image");
+	const documents = parts.filter((part) => part.type === "document");
+	const imageRefs = await admitEncodedImages(attachments, images);
+	const documentBlocks = await prepareDocuments(store, parser, documents, signal);
+	let imageIndex = 0;
+	let documentIndex = 0;
+	const content = [];
+	for (const part of parts) if (part.type === "text") content.push({
+		type: "text",
+		text: part.text
+	});
+	else if (part.type === "image") content.push({
+		type: "image",
+		attachment: imageRefs[imageIndex++]
+	});
+	else content.push(documentBlocks[documentIndex++]);
+	return content;
+}
+async function readBoundedJson(request, maxBytes) {
+	const declared = request.headers["content-length"];
+	if (declared !== void 0 && Number(declared) > maxBytes) throw new DocumentInputError("REQUEST_TOO_LARGE", "Document prompt request exceeds the configured byte limit.");
+	const chunks = [];
+	let bytes = 0;
+	for await (const chunk of request) {
+		const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		bytes += value.byteLength;
+		if (bytes > maxBytes) throw new DocumentInputError("REQUEST_TOO_LARGE", "Document prompt request exceeds the configured byte limit.");
+		chunks.push(value);
+	}
+	try {
+		return JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
+	} catch (error) {
+		console.error("document-attachments: request JSON parsing failed", error);
+		throw new DocumentInputError("INVALID_REQUEST", "Document prompt request is not valid JSON.", { cause: error });
+	}
+}
+function sendJson(response, status, value) {
+	response.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	response.end(JSON.stringify(value));
+}
+function sendFailure(response, error) {
+	console.error("document-attachments: prompt admission failed", error);
+	if (error instanceof DocumentInputError || error instanceof DocumentParserError || error instanceof AttachmentError) {
+		sendJson(response, 400, {
+			ok: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: {}
+			}
+		});
+		return;
+	}
+	if (error instanceof TypertRemoteFailure) {
+		sendJson(response, 409, {
+			ok: false,
+			error: error.failure
+		});
+		return;
+	}
+	sendJson(response, 500, {
+		ok: false,
+		error: {
+			code: "DOCUMENT_PROMPT_FAILED",
+			message: "Unable to submit the document prompt.",
+			details: {}
+		}
+	});
+}
+/**
+* Register the authenticated mixed prompt route for this capability.
+* @param ctx - Host context carrying WebServer, Connection, Attachment, and Session Controller services.
+* @param parser - provider-neutral parser runtime.
+* @param maxRequestBytes - exact encoded HTTP body limit.
+* @returns route disposer owned by the Document parser Service fiber.
+*/
+function registerDocumentPromptRoute(ctx, parser, maxRequestBytes) {
+	const attachments = ctx.attachments;
+	const store = attachments;
+	const sessions = ctx.sessionController;
+	return ctx.webServer.register({
+		kind: "exact",
+		path: DOCUMENT_PROMPT_PATH,
+		handler: async (request, response) => {
+			const rejection = ctx.connection.requestRejection(request);
+			if (rejection !== void 0) {
+				response.writeHead(rejection);
+				response.end();
+				return;
+			}
+			if (request.method !== "POST") {
+				response.writeHead(405, { allow: "POST" });
+				response.end();
+				return;
+			}
+			const abort = new AbortController();
+			const onAborted = () => {
+				abort.abort(/* @__PURE__ */ new Error("Document prompt request was aborted."));
+			};
+			request.once("aborted", onAborted);
+			try {
+				const body = parsePromptRequest(await readBoundedJson(request, maxRequestBytes));
+				sendJson(response, 200, {
+					ok: true,
+					value: await sessions.promptPrepared(body, body.content.some((part) => part.type === "image"), () => preparePromptContent(attachments, store, parser, body.content, abort.signal))
+				});
+			} catch (error) {
+				sendFailure(response, error);
+			} finally {
+				request.off("aborted", onAborted);
+			}
+		}
+	});
+}
+//#endregion
+//#region lib/types/index.js
+/** Optional external document-parser capability (`ctx.documentParser`). @module @sparkelf/dsh-plugin-document-attachments */
+/** Parser seam configuration; the direct-context budget is intentionally required. */
+const Config = z.object({
+	provider: z.string(),
+	maxDirectMarkdownBytes: z.number().step(1).min(1).required(),
+	maxRequestBytes: z.number().step(1).min(1).required()
+});
+/** Provider-neutral parser registry and direct-context policy owner. */
+var DocumentParserRuntime = class extends Service {
+	static inject = [
+		"attachments",
+		"connection",
+		"sessionController",
+		"webServer"
+	];
+	providers = /* @__PURE__ */ new Map();
+	providerId;
+	/** Maximum aggregate rendered-document bytes Host admission may attach in one submitted message. */
+	maxDirectMarkdownBytes;
+	constructor(ctx, config) {
+		super(ctx, "documentParser");
+		if (config.provider !== void 0 && config.provider.length === 0) throw new Error("document-parser: configured provider id must be non-empty");
+		this.providerId = config.provider;
+		this.maxDirectMarkdownBytes = config.maxDirectMarkdownBytes;
+		ctx.effect(() => registerDocumentPromptRoute(ctx, this, config.maxRequestBytes), "document-attachments: authenticated prompt route");
+	}
+	/**
+	* Register one parser provider until the owning Cordis fiber disposes.
+	* @param provider - provider implementation keyed by its non-empty id.
+	* @returns disposer that withdraws exactly this registration.
+	*/
+	registerProvider(provider) {
+		if (provider.id.length === 0) throw new Error("document-parser: provider id must be non-empty");
+		if (this.providers.has(provider.id)) throw new DocumentParserError(`a document parser provider with id "${provider.id}" is already registered`, "DOCUMENT_PARSER_DUPLICATE_PROVIDER");
+		const providers = this.providers;
+		const providerId = provider.id;
+		const dispose = this.ctx.effect(function* () {
+			providers.set(providerId, provider);
+			yield () => providers.delete(providerId);
+		}, "documentParser.registerProvider()");
+		return () => void dispose();
+	}
+	/**
+	* Report whether current registry state resolves the configured provider selection.
+	* This does not probe provider health or external endpoint availability.
+	* @returns true only when a parse call can select exactly one registered provider.
+	*/
+	isSelectionResolvable() {
+		if (this.providerId !== void 0) return this.providers.has(this.providerId);
+		return this.providers.size === 1;
+	}
+	/**
+	* Parse one already-persisted document through the deployment-selected provider.
+	* @param request - verified original bytes and their durable metadata.
+	* @param signal - optional cancellation forwarded to the provider.
+	* @returns provider id together with the complete transient parse bundle.
+	*/
+	async parse(request, signal) {
+		const provider = this.resolveProvider();
+		return {
+			parser: provider.id,
+			result: await provider.parse(request, signal)
+		};
+	}
+	resolveProvider() {
+		if (this.providerId !== void 0) {
+			const provider = this.providers.get(this.providerId);
+			if (provider === void 0) throw new DocumentParserError(`configured document parser provider "${this.providerId}" is not registered`, "DOCUMENT_PARSER_CONFIGURED_MISSING");
+			return provider;
+		}
+		const registered = [...this.providers.values()];
+		const [single] = registered;
+		if (single === void 0) throw new DocumentParserError("no document parser provider is registered", "DOCUMENT_PARSER_UNAVAILABLE");
+		if (registered.length > 1) throw new DocumentParserError(`multiple document parser providers are registered (${registered.map((provider) => provider.id).join(", ")}); configure one explicitly`, "DOCUMENT_PARSER_AMBIGUOUS");
+		return single;
+	}
+};
+//#endregion
+export { DocumentParserRuntime as n, DocumentParserError as r, Config as t };

package/package.json

@@ -0,0 +1,97 @@
+{
+  "dependencies": {
+    "@deepseek-ai/schemastery": ">=3.18.1",
+    "fflate": "^0.8.2"
+  },
+  "description": "Provider-neutral parser and MinerU provider for durable PDF and Office document attachments",
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-api-session-controller": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-attachment": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-connection": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-locale": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-attachment": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-chat": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-trajectory": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.1",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.2-alpha.1",
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0"
+  },
+  "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-attachment",
+        "@deepseek-ai/dsh-client-ui-chat",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-trajectory",
+        "@deepseek-ai/dsh-client-ui-renderer"
+      ],
+      "platform": "web"
+    }
+  },
+  "exports": {
+    ".": {
+      "default": "./lib/index.js",
+      "types": "./lib/types/index.d.ts"
+    },
+    "./client": {
+      "default": "./lib/client.js",
+      "types": "./lib/types/client/index.d.ts"
+    },
+    "./invariant": {
+      "default": "./lib/invariant.js",
+      "types": "./lib/types/invariant.d.ts"
+    },
+    "./mineru": {
+      "default": "./lib/mineru.js",
+      "types": "./lib/types/mineru.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/mineru.js",
+    "lib/types-*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "@sparkelf/dsh-plugin-document-attachments",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.1",
+    "@deepseek-ai/dsh-api-session-controller": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-attachment": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-connection": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-locale": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-attachment": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-chat": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-conversation": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-renderer": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-client-ui-trajectory": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-host-webserver": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-invariants": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-llm": ">=0.1.2-alpha.1",
+    "@deepseek-ai/dsh-typert-protocol": ">=0.1.2-alpha.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "packages/plus/document-attachments",
+    "type": "git",
+    "url": "git+https://github.com/SparkElf/deepseek-harness-plus.git"
+  },
+  "type": "module",
+  "types": "lib/types/index.d.ts",
+  "version": "0.1.0-rc.10"
+}