@cartanova/qgrid-ai-sdk 2.6.8 → 2.6.10

package/dist/index.js

@@ -1,3 +1,257 @@
+//#region src/envelope-stream-parser.ts
+const ESCAPE_MAP = {
+	"\"": "\"",
+	"\\": "\\",
+	"/": "/",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+const LITERAL_CHARS = /[0-9a-zA-Z+\-.eE]/;
+function createEnvelopeStreamParser(answerKind) {
+	let action = null;
+	let discard = false;
+	let pending = "";
+	let out = "";
+	const emit = (text) => {
+		if (discard || text === "") return;
+		if (action === "answer") out += text;
+		else pending += text;
+	};
+	const resolveAction = (value) => {
+		if (action !== null) return;
+		if (value === "answer") {
+			action = "answer";
+			out += pending;
+			pending = "";
+		} else {
+			action = "tool_call";
+			discard = true;
+			pending = "";
+		}
+	};
+	const stack = [];
+	let mode = "value";
+	let currentKey = null;
+	let inString = false;
+	let stringIsKey = false;
+	let escape = false;
+	let unicode = null;
+	let keyBuf = "";
+	let actionBuf = "";
+	let capture = "none";
+	let rawActive = false;
+	let rawDepth = 0;
+	let rawInString = false;
+	let rawEscape = false;
+	let rawIsLiteral = false;
+	const atEnvelopeLevel = () => stack.length === 2 && stack[0].openedAtKey === null && stack[1].openedAtKey === "result";
+	const deliverStringChar = (ch) => {
+		if (stringIsKey) keyBuf += ch;
+		else if (capture === "action") actionBuf += ch;
+		else if (capture === "answer-text") emit(ch);
+	};
+	const endString = () => {
+		inString = false;
+		if (stringIsKey) {
+			currentKey = keyBuf;
+			mode = "colon";
+			return;
+		}
+		if (capture === "action") resolveAction(actionBuf);
+		capture = "none";
+		mode = "afterValue";
+	};
+	const endRaw = (reprocessChar) => {
+		rawActive = false;
+		mode = "afterValue";
+		if (reprocessChar !== void 0) step(reprocessChar);
+	};
+	const rawStep = (c) => {
+		if (rawIsLiteral) {
+			if (LITERAL_CHARS.test(c)) return;
+			rawIsLiteral = false;
+			endRaw(c);
+			return;
+		}
+		emit(c);
+		if (rawInString) {
+			if (rawEscape) rawEscape = false;
+			else if (c === "\\") rawEscape = true;
+			else if (c === "\"") {
+				rawInString = false;
+				if (rawDepth === 0) endRaw();
+			}
+			return;
+		}
+		if (c === "\"") rawInString = true;
+		else if (c === "{" || c === "[") rawDepth++;
+		else if (c === "}" || c === "]") {
+			rawDepth--;
+			if (rawDepth === 0) endRaw();
+		}
+	};
+	const startValue = (c) => {
+		const watchedAction = atEnvelopeLevel() && currentKey === "action";
+		const watchedAnswer = atEnvelopeLevel() && currentKey === "answer";
+		if (watchedAnswer && answerKind === "json") {
+			rawActive = true;
+			rawDepth = 0;
+			rawInString = false;
+			rawEscape = false;
+			rawIsLiteral = false;
+			if (c === "{" || c === "[") {
+				rawDepth = 1;
+				emit(c);
+			} else if (c === "\"") {
+				rawInString = true;
+				emit(c);
+			} else rawIsLiteral = true;
+			return;
+		}
+		if (c === "\"") {
+			inString = true;
+			stringIsKey = false;
+			escape = false;
+			unicode = null;
+			if (watchedAction) {
+				capture = "action";
+				actionBuf = "";
+			} else if (watchedAnswer && answerKind === "text") capture = "answer-text";
+			else capture = "none";
+			return;
+		}
+		if (c === "{") {
+			stack.push({
+				type: "object",
+				openedAtKey: currentKey
+			});
+			currentKey = null;
+			mode = "key";
+			return;
+		}
+		if (c === "[") {
+			stack.push({
+				type: "array",
+				openedAtKey: currentKey
+			});
+			currentKey = null;
+			mode = "value";
+			return;
+		}
+		if (c === "]" && stack[stack.length - 1]?.type === "array") {
+			stack.pop();
+			mode = "afterValue";
+			return;
+		}
+		if (LITERAL_CHARS.test(c)) {
+			mode = "literal";
+			return;
+		}
+		discard = true;
+	};
+	const step = (c) => {
+		if (discard) return;
+		if (rawActive) {
+			rawStep(c);
+			return;
+		}
+		if (inString) {
+			if (unicode !== null) {
+				unicode += c;
+				if (unicode.length === 4) {
+					const code = Number.parseInt(unicode, 16);
+					unicode = null;
+					if (Number.isNaN(code)) {
+						discard = true;
+						return;
+					}
+					deliverStringChar(String.fromCharCode(code));
+				}
+				return;
+			}
+			if (escape) {
+				escape = false;
+				if (c === "u") {
+					unicode = "";
+					return;
+				}
+				const mapped = ESCAPE_MAP[c];
+				if (mapped === void 0) {
+					discard = true;
+					return;
+				}
+				deliverStringChar(mapped);
+				return;
+			}
+			if (c === "\\") {
+				escape = true;
+				return;
+			}
+			if (c === "\"") {
+				endString();
+				return;
+			}
+			deliverStringChar(c);
+			return;
+		}
+		if (mode === "literal") {
+			if (LITERAL_CHARS.test(c)) return;
+			mode = "afterValue";
+			step(c);
+			return;
+		}
+		if (c === " " || c === "	" || c === "\n" || c === "\r") return;
+		switch (mode) {
+			case "value":
+				startValue(c);
+				return;
+			case "key":
+				if (c === "\"") {
+					inString = true;
+					stringIsKey = true;
+					escape = false;
+					unicode = null;
+					keyBuf = "";
+				} else if (c === "}") {
+					stack.pop();
+					mode = "afterValue";
+				} else discard = true;
+				return;
+			case "colon":
+				if (c === ":") {
+					mode = "value";
+					stringIsKey = false;
+				} else discard = true;
+				return;
+			case "afterValue":
+				if (c === ",") {
+					const frame = stack[stack.length - 1];
+					if (!frame) {
+						discard = true;
+						return;
+					}
+					currentKey = null;
+					mode = frame.type === "object" ? "key" : "value";
+				} else if (c === "}" || c === "]") stack.pop();
+				else discard = true;
+				return;
+		}
+	};
+	return { push(chunk) {
+		if (discard) return "";
+		for (const c of chunk) {
+			step(c);
+			if (discard) break;
+		}
+		const emitted = out;
+		out = "";
+		return emitted;
+	} };
+}
+//#endregion
 //#region src/qgrid.constant.ts
 const QGRID_PROVIDER_NAME = "qgrid";
 const THREAD_COORD_TTL_MS = 10 * 6e4;
@@ -941,11 +1195,14 @@ function qgrid(modelId, config) {
 			const textId = `${TEXT_STREAM_ID_PREFIX}_${Math.random().toString(36).slice(2, 10)}`;
 			let textStarted = false;
 			let deltaTextEmitted = false;
+			const envelopeParser = hasTools ? createEnvelopeStreamParser(jsonSchema ? "json" : "text") : void 0;
 			return { stream: new ReadableStream({ async start(controller) {
 				try {
 					let streamCompleted = false;
 					for await (const event of parseSSE(streamRes.body)) if (event.type === "delta") {
-						if (!hasTools) {
+						const raw = event.data.text;
+						const text = envelopeParser ? envelopeParser.push(raw) : raw;
+						if (text !== "") {
 							if (!textStarted) {
 								controller.enqueue({
 									type: "text-start",
@@ -956,7 +1213,7 @@ function qgrid(modelId, config) {
 							controller.enqueue({
 								type: "text-delta",
 								id: textId,
-								delta: event.data.text
+								delta: text
 							});
 							deltaTextEmitted = true;
 						}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cartanova/qgrid-ai-sdk",
-  "version": "2.6.8",
+  "version": "2.6.10",
   "description": "AI SDK LanguageModelV3 provider for qgrid",
   "repository": {
     "type": "git",