veryfront 0.1.196 → 0.1.198

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.196",
+    "version": "0.1.198",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "exclude": [

package/esm/src/chat/ag-ui.d.ts

@@ -18,12 +18,18 @@ export type AgUiDecodedChunk = {
     events: AgUiDecodedEvent[];
     remainder: string;
 };
+export type AgUiDecoderValidationMode = "permissive" | "strict";
 export type AgUiChatEventDecoderState = {
     remainder: string;
     lastEventId: number;
     toolCalls: Map<string, ToolCallState>;
     reasoningFallbackIndex: number;
     activeFallbackReasoningPartId: string | null;
+    validationMode: AgUiDecoderValidationMode;
+    onInvalidJson: ((details: {
+        eventName: string | null;
+        dataLength: number;
+    }) => void) | null;
 };
 export declare const AgUiRunFinishedMetadataSchema: z.ZodObject<{
     provider: z.ZodOptional<z.ZodString>;
@@ -299,6 +305,11 @@ export type AgUiWireEvent = z.infer<typeof AgUiWireEventSchema>;
 export declare function parseSseEvent(raw: string): ParsedSseEvent;
 export declare function createAgUiChatEventDecoderState(input?: {
     lastEventId?: number;
+    validationMode?: AgUiDecoderValidationMode;
+    onInvalidJson?: (details: {
+        eventName: string | null;
+        dataLength: number;
+    }) => void;
 }): AgUiChatEventDecoderState;
 export declare function decodeAgUiSseChunk(state: AgUiChatEventDecoderState, chunk: string): AgUiDecodedChunk;
 export declare function flushAgUiSseChunk(state: AgUiChatEventDecoderState): AgUiDecodedChunk;

package/esm/src/chat/ag-ui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ag-ui.d.ts","sourceRoot":"","sources":["../../../src/src/chat/ag-ui.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAoB,eAAe,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,eAAe,EAAE,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACtC,sBAAsB,EAAE,MAAM,CAAC;IAC/B,6BAA6B,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9C,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;iBAUxC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;iBAQrC,CAAC;AAiBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA+BpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;EAmBlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAgJ9B,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AA8WhE,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CA+BzD;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,GAAE;IACL,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GACL,yBAAyB,CAQ3B;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,yBAAyB,EAChC,KAAK,EAAE,MAAM,GACZ,gBAAgB,CAoClB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,yBAAyB,GAAG,gBAAgB,CAWpF"}
+{"version":3,"file":"ag-ui.d.ts","sourceRoot":"","sources":["../../../src/src/chat/ag-ui.ts"],"names":[],"mappings":"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"}

package/esm/src/chat/ag-ui.js

@@ -361,7 +361,7 @@ function isCommentOnlySseFrame(raw) {
         .split("\n")
         .every((line) => line.trim().length === 0 || line.trimStart().startsWith(":"));
 }
-function parseAgUiWireEvent(frame) {
+function parseAgUiWireEvent(frame, input) {
     if (frame.data === "[DONE]" || !frame.event || !frame.data) {
         return null;
     }
@@ -374,6 +374,10 @@ function parseAgUiWireEvent(frame) {
         payload = JSON.parse(frame.data);
     }
     catch {
+        input.onInvalidJson?.({
+            eventName: frame.event,
+            dataLength: frame.data.length,
+        });
         return null;
     }
     if (!isRecord(payload)) {
@@ -383,6 +387,9 @@ function parseAgUiWireEvent(frame) {
         eventName: eventName.data,
         payload,
     });
+    if (!parsed.success && input.validationMode === "strict") {
+        throw new Error(`Malformed AG-UI event payload for ${eventName.data}`);
+    }
     return parsed.success ? parsed.data : null;
 }
 function mapWireEventToChatEvents(state, wireEvent) {
@@ -563,6 +570,8 @@ export function createAgUiChatEventDecoderState(input = {}) {
         toolCalls: new Map(),
         reasoningFallbackIndex: 0,
         activeFallbackReasoningPartId: null,
+        validationMode: input.validationMode ?? "permissive",
+        onInvalidJson: input.onInvalidJson ?? null,
     };
 }
 export function decodeAgUiSseChunk(state, chunk) {
@@ -581,7 +590,10 @@ export function decodeAgUiSseChunk(state, chunk) {
             }
             state.lastEventId = frame.id;
         }
-        const wireEvent = parseAgUiWireEvent(frame);
+        const wireEvent = parseAgUiWireEvent(frame, {
+            validationMode: state.validationMode,
+            onInvalidJson: state.onInvalidJson,
+        });
         if (!wireEvent) {
             continue;
         }

package/esm/src/provider/runtime-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-loader.d.ts","sourceRoot":"","sources":["../../../src/src/provider/runtime-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAkhDD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkDd;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,MAAM,GACd,YAAY,CA4Dd;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkDd;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CA0ClB;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CAgDlB"}
+{"version":3,"file":"runtime-loader.d.ts","sourceRoot":"","sources":["../../../src/src/provider/runtime-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AA0oDD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkDd;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,MAAM,GACd,YAAY,CA4Dd;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkDd;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CA0ClB;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CAgDlB"}

package/esm/src/provider/runtime-loader.js

@@ -440,6 +440,7 @@ async function* streamAnthropicCompatibleParts(stream) {
     const decoder = new TextDecoder();
     let buffer = "";
     const toolCalls = new Map();
+    const reasoningBlocks = new Map();
     let finishReason = null;
     let usage;
     for await (const chunk of stream) {
@@ -466,6 +467,22 @@ async function* streamAnthropicCompatibleParts(stream) {
                     yield { type: "text-delta", delta: contentBlock.text };
                     continue;
                 }
+                if (blockType === "thinking") {
+                    const reasoningId = `thinking-${index}`;
+                    reasoningBlocks.set(index, { id: reasoningId });
+                    yield {
+                        type: "reasoning-start",
+                        id: reasoningId,
+                    };
+                    if (typeof contentBlock?.thinking === "string" && contentBlock.thinking.length > 0) {
+                        yield {
+                            type: "reasoning-delta",
+                            id: reasoningId,
+                            delta: contentBlock.thinking,
+                        };
+                    }
+                    continue;
+                }
                 if ((blockType === "tool_use" || blockType === "server_tool_use") &&
                     typeof contentBlock?.id === "string" &&
                     typeof contentBlock?.name === "string") {
@@ -527,6 +544,19 @@ async function* streamAnthropicCompatibleParts(stream) {
                     yield { type: "text-delta", delta: delta.text };
                     continue;
                 }
+                if (deltaType === "thinking_delta" && typeof delta?.thinking === "string" &&
+                    delta.thinking.length > 0) {
+                    const current = reasoningBlocks.get(index);
+                    if (!current) {
+                        continue;
+                    }
+                    yield {
+                        type: "reasoning-delta",
+                        id: current.id,
+                        delta: delta.thinking,
+                    };
+                    continue;
+                }
                 if (deltaType === "input_json_delta" && typeof delta?.partial_json === "string") {
                     const current = toolCalls.get(index);
                     if (!current) {
@@ -543,6 +573,15 @@ async function* streamAnthropicCompatibleParts(stream) {
             }
             if (eventType === "content_block_stop") {
                 const index = typeof record?.index === "number" ? record.index : 0;
+                const reasoning = reasoningBlocks.get(index);
+                if (reasoning) {
+                    yield {
+                        type: "reasoning-end",
+                        id: reasoning.id,
+                    };
+                    reasoningBlocks.delete(index);
+                    continue;
+                }
                 const current = toolCalls.get(index);
                 if (!current) {
                     continue;
@@ -871,6 +910,8 @@ async function* streamGoogleCompatibleParts(stream) {
     const decoder = new TextDecoder();
     let buffer = "";
     const seenToolCalls = new Set();
+    let reasoningId = null;
+    let reasoningIndex = 0;
     let finishReason = null;
     let usage;
     for await (const chunk of stream) {
@@ -888,6 +929,29 @@ async function* streamGoogleCompatibleParts(stream) {
                 finishReason = normalizedFinishReason;
             }
             for (const [index, part] of extractGoogleCandidateParts(event).entries()) {
+                const isThought = part.thought === true;
+                if (isThought && typeof part.text === "string" && part.text.length > 0) {
+                    if (!reasoningId) {
+                        reasoningId = `reasoning-${reasoningIndex++}`;
+                        yield {
+                            type: "reasoning-start",
+                            id: reasoningId,
+                        };
+                    }
+                    yield {
+                        type: "reasoning-delta",
+                        id: reasoningId,
+                        delta: part.text,
+                    };
+                    continue;
+                }
+                if (reasoningId) {
+                    yield {
+                        type: "reasoning-end",
+                        id: reasoningId,
+                    };
+                    reasoningId = null;
+                }
                 if (typeof part.text === "string" && part.text.length > 0) {
                     yield { type: "text-delta", delta: part.text };
                     continue;
@@ -930,6 +994,12 @@ async function* streamGoogleCompatibleParts(stream) {
             usage = extractGoogleUsage(event) ?? usage;
         }
     }
+    if (reasoningId) {
+        yield {
+            type: "reasoning-end",
+            id: reasoningId,
+        };
+    }
     yield {
         type: "finish",
         finishReason,
@@ -971,6 +1041,8 @@ async function* streamOpenAICompatibleParts(stream) {
     const decoder = new TextDecoder();
     let buffer = "";
     const toolCalls = new Map();
+    let reasoningId = null;
+    let reasoningIndex = 0;
     let finishReason = null;
     let usage;
     for await (const chunk of stream) {
@@ -983,56 +1055,81 @@ async function* streamOpenAICompatibleParts(stream) {
             }
             const record = readRecord(event);
             usage = extractOpenAIUsage(record) ?? usage;
-            const choices = Array.isArray(record?.choices) ? record.choices : [];
-            for (const choiceValue of choices) {
-                const choice = readRecord(choiceValue);
-                if (!choice) {
-                    continue;
+            const choice = extractFirstChoice(record);
+            if (!choice) {
+                continue;
+            }
+            const delta = readRecord(choice.delta);
+            if (typeof delta?.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+                if (!reasoningId) {
+                    reasoningId = `reasoning-${reasoningIndex++}`;
+                    yield {
+                        type: "reasoning-start",
+                        id: reasoningId,
+                    };
                 }
-                const delta = readRecord(choice.delta);
-                const textDelta = extractOpenAIContentText(delta?.content);
-                if (textDelta.length > 0) {
-                    yield { type: "text-delta", delta: textDelta };
+                yield {
+                    type: "reasoning-delta",
+                    id: reasoningId,
+                    delta: delta.reasoning_content,
+                };
+            }
+            const textDelta = extractOpenAIContentText(delta?.content);
+            if (textDelta.length > 0) {
+                if (reasoningId) {
+                    yield {
+                        type: "reasoning-end",
+                        id: reasoningId,
+                    };
+                    reasoningId = null;
                 }
-                const rawToolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
-                for (const rawToolCall of rawToolCalls) {
-                    const toolCallRecord = readRecord(rawToolCall);
-                    const index = typeof toolCallRecord?.index === "number" ? toolCallRecord.index : 0;
-                    const current = toolCalls.get(index) ?? {
-                        id: typeof toolCallRecord?.id === "string" ? toolCallRecord.id : `tool-${index}`,
-                        name: "",
-                        arguments: "",
-                        started: false,
+                yield { type: "text-delta", delta: textDelta };
+            }
+            const rawToolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
+            for (const rawToolCall of rawToolCalls) {
+                if (reasoningId) {
+                    yield {
+                        type: "reasoning-end",
+                        id: reasoningId,
                     };
-                    if (typeof toolCallRecord?.id === "string") {
-                        current.id = toolCallRecord.id;
-                    }
-                    const fn = readRecord(toolCallRecord?.function);
-                    if (typeof fn?.name === "string") {
-                        current.name = fn.name;
-                    }
-                    if (!current.started && current.name.length > 0) {
-                        current.started = true;
-                        yield {
-                            type: "tool-input-start",
-                            id: current.id,
-                            toolName: current.name,
-                        };
-                    }
-                    if (typeof fn?.arguments === "string" && fn.arguments.length > 0) {
-                        current.arguments += fn.arguments;
-                        yield {
-                            type: "tool-input-delta",
-                            id: current.id,
-                            delta: fn.arguments,
-                        };
-                    }
-                    toolCalls.set(index, current);
+                    reasoningId = null;
                 }
-                const normalizedFinishReason = normalizeOpenAIFinishReason(choice.finish_reason);
-                if (normalizedFinishReason) {
-                    finishReason = normalizedFinishReason;
+                const toolCallRecord = readRecord(rawToolCall);
+                const index = typeof toolCallRecord?.index === "number" ? toolCallRecord.index : 0;
+                const current = toolCalls.get(index) ?? {
+                    id: typeof toolCallRecord?.id === "string" ? toolCallRecord.id : `tool-${index}`,
+                    name: "",
+                    arguments: "",
+                    started: false,
+                };
+                if (typeof toolCallRecord?.id === "string") {
+                    current.id = toolCallRecord.id;
+                }
+                const fn = readRecord(toolCallRecord?.function);
+                if (typeof fn?.name === "string") {
+                    current.name = fn.name;
+                }
+                if (!current.started && current.name.length > 0) {
+                    current.started = true;
+                    yield {
+                        type: "tool-input-start",
+                        id: current.id,
+                        toolName: current.name,
+                    };
+                }
+                if (typeof fn?.arguments === "string" && fn.arguments.length > 0) {
+                    current.arguments += fn.arguments;
+                    yield {
+                        type: "tool-input-delta",
+                        id: current.id,
+                        delta: fn.arguments,
+                    };
                 }
+                toolCalls.set(index, current);
+            }
+            const normalizedFinishReason = normalizeOpenAIFinishReason(choice.finish_reason);
+            if (normalizedFinishReason) {
+                finishReason = normalizedFinishReason;
             }
         }
     }
@@ -1046,6 +1143,12 @@ async function* streamOpenAICompatibleParts(stream) {
             usage = extractOpenAIUsage(record) ?? usage;
         }
     }
+    if (reasoningId) {
+        yield {
+            type: "reasoning-end",
+            id: reasoningId,
+        };
+    }
     if (finishReason &&
         typeof finishReason === "object" &&
         finishReason.unified === "tool-calls") {

package/esm/src/utils/version-constant.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.196";
+export declare const VERSION = "0.1.198";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.196";
+export const VERSION = "0.1.198";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.196",
+  "version": "0.1.198",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.196",
+  "version": "0.1.198",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

package/src/src/chat/ag-ui.ts

@@ -37,12 +37,16 @@ export type AgUiDecodedChunk = {
   remainder: string;
 };
 
+export type AgUiDecoderValidationMode = "permissive" | "strict";
+
 export type AgUiChatEventDecoderState = {
   remainder: string;
   lastEventId: number;
   toolCalls: Map<string, ToolCallState>;
   reasoningFallbackIndex: number;
   activeFallbackReasoningPartId: string | null;
+  validationMode: AgUiDecoderValidationMode;
+  onInvalidJson: ((details: { eventName: string | null; dataLength: number }) => void) | null;
 };
 
 export const AgUiRunFinishedMetadataSchema = z.object({
@@ -449,7 +453,13 @@ function isCommentOnlySseFrame(raw: string): boolean {
     .every((line) => line.trim().length === 0 || line.trimStart().startsWith(":"));
 }
 
-function parseAgUiWireEvent(frame: ParsedSseEvent): AgUiWireEvent | null {
+function parseAgUiWireEvent(
+  frame: ParsedSseEvent,
+  input: {
+    validationMode: AgUiDecoderValidationMode;
+    onInvalidJson: ((details: { eventName: string | null; dataLength: number }) => void) | null;
+  },
+): AgUiWireEvent | null {
   if (frame.data === "[DONE]" || !frame.event || !frame.data) {
     return null;
   }
@@ -463,6 +473,10 @@ function parseAgUiWireEvent(frame: ParsedSseEvent): AgUiWireEvent | null {
   try {
     payload = JSON.parse(frame.data);
   } catch {
+    input.onInvalidJson?.({
+      eventName: frame.event,
+      dataLength: frame.data.length,
+    });
     return null;
   }
 
@@ -475,6 +489,10 @@ function parseAgUiWireEvent(frame: ParsedSseEvent): AgUiWireEvent | null {
     payload,
   });
 
+  if (!parsed.success && input.validationMode === "strict") {
+    throw new Error(`Malformed AG-UI event payload for ${eventName.data}`);
+  }
+
   return parsed.success ? parsed.data : null;
 }
 
@@ -687,6 +705,8 @@ export function parseSseEvent(raw: string): ParsedSseEvent {
 export function createAgUiChatEventDecoderState(
   input: {
     lastEventId?: number;
+    validationMode?: AgUiDecoderValidationMode;
+    onInvalidJson?: (details: { eventName: string | null; dataLength: number }) => void;
   } = {},
 ): AgUiChatEventDecoderState {
   return {
@@ -695,6 +715,8 @@ export function createAgUiChatEventDecoderState(
     toolCalls: new Map<string, ToolCallState>(),
     reasoningFallbackIndex: 0,
     activeFallbackReasoningPartId: null,
+    validationMode: input.validationMode ?? "permissive",
+    onInvalidJson: input.onInvalidJson ?? null,
   };
 }
 
@@ -721,7 +743,10 @@ export function decodeAgUiSseChunk(
       state.lastEventId = frame.id;
     }
 
-    const wireEvent = parseAgUiWireEvent(frame);
+    const wireEvent = parseAgUiWireEvent(frame, {
+      validationMode: state.validationMode,
+      onInvalidJson: state.onInvalidJson,
+    });
     if (!wireEvent) {
       continue;
     }

package/src/src/provider/runtime-loader.ts

@@ -156,6 +156,9 @@ type AnthropicStreamToolCallState = {
   input: string;
   providerExecuted?: boolean;
 };
+type AnthropicStreamReasoningState = {
+  id: string;
+};
 type GoogleCompatibleContent = {
   role: "user" | "model";
   parts: Array<Record<string, unknown>>;
@@ -780,6 +783,7 @@ async function* streamAnthropicCompatibleParts(
   const decoder = new TextDecoder();
   let buffer = "";
   const toolCalls = new Map<number, AnthropicStreamToolCallState>();
+  const reasoningBlocks = new Map<number, AnthropicStreamReasoningState>();
   let finishReason: string | { unified: string; raw: string } | null = null;
   let usage: { inputTokens?: number; outputTokens?: number; totalTokens?: number } | undefined;
 
@@ -815,6 +819,24 @@ async function* streamAnthropicCompatibleParts(
           continue;
         }
 
+        if (blockType === "thinking") {
+          const reasoningId = `thinking-${index}`;
+          reasoningBlocks.set(index, { id: reasoningId });
+          yield {
+            type: "reasoning-start",
+            id: reasoningId,
+          };
+
+          if (typeof contentBlock?.thinking === "string" && contentBlock.thinking.length > 0) {
+            yield {
+              type: "reasoning-delta",
+              id: reasoningId,
+              delta: contentBlock.thinking,
+            };
+          }
+          continue;
+        }
+
         if (
           (blockType === "tool_use" || blockType === "server_tool_use") &&
           typeof contentBlock?.id === "string" &&
@@ -892,6 +914,23 @@ async function* streamAnthropicCompatibleParts(
           continue;
         }
 
+        if (
+          deltaType === "thinking_delta" && typeof delta?.thinking === "string" &&
+          delta.thinking.length > 0
+        ) {
+          const current = reasoningBlocks.get(index);
+          if (!current) {
+            continue;
+          }
+
+          yield {
+            type: "reasoning-delta",
+            id: current.id,
+            delta: delta.thinking,
+          };
+          continue;
+        }
+
         if (deltaType === "input_json_delta" && typeof delta?.partial_json === "string") {
           const current = toolCalls.get(index);
           if (!current) {
@@ -911,6 +950,16 @@ async function* streamAnthropicCompatibleParts(
 
       if (eventType === "content_block_stop") {
         const index = typeof record?.index === "number" ? record.index : 0;
+        const reasoning = reasoningBlocks.get(index);
+        if (reasoning) {
+          yield {
+            type: "reasoning-end",
+            id: reasoning.id,
+          };
+          reasoningBlocks.delete(index);
+          continue;
+        }
+
         const current = toolCalls.get(index);
         if (!current) {
           continue;
@@ -1334,6 +1383,8 @@ async function* streamGoogleCompatibleParts(
   const decoder = new TextDecoder();
   let buffer = "";
   const seenToolCalls = new Set<string>();
+  let reasoningId: string | null = null;
+  let reasoningIndex = 0;
   let finishReason: string | { unified: string; raw: string } | null = null;
   let usage: { inputTokens?: number; outputTokens?: number; totalTokens?: number } | undefined;
 
@@ -1355,6 +1406,32 @@ async function* streamGoogleCompatibleParts(
       }
 
       for (const [index, part] of extractGoogleCandidateParts(event).entries()) {
+        const isThought = part.thought === true;
+        if (isThought && typeof part.text === "string" && part.text.length > 0) {
+          if (!reasoningId) {
+            reasoningId = `reasoning-${reasoningIndex++}`;
+            yield {
+              type: "reasoning-start",
+              id: reasoningId,
+            };
+          }
+
+          yield {
+            type: "reasoning-delta",
+            id: reasoningId,
+            delta: part.text,
+          };
+          continue;
+        }
+
+        if (reasoningId) {
+          yield {
+            type: "reasoning-end",
+            id: reasoningId,
+          };
+          reasoningId = null;
+        }
+
         if (typeof part.text === "string" && part.text.length > 0) {
           yield { type: "text-delta", delta: part.text };
           continue;
@@ -1402,6 +1479,13 @@ async function* streamGoogleCompatibleParts(
     }
   }
 
+  if (reasoningId) {
+    yield {
+      type: "reasoning-end",
+      id: reasoningId,
+    };
+  }
+
   yield {
     type: "finish",
     finishReason,
@@ -1462,6 +1546,8 @@ async function* streamOpenAICompatibleParts(
   const decoder = new TextDecoder();
   let buffer = "";
   const toolCalls = new Map<number, OpenAIStreamToolCallState>();
+  let reasoningId: string | null = null;
+  let reasoningIndex = 0;
   let finishReason: string | { unified: string; raw: string } | null = null;
   let usage: { inputTokens?: number; outputTokens?: number; totalTokens?: number } | undefined;
 
@@ -1477,65 +1563,92 @@ async function* streamOpenAICompatibleParts(
 
       const record = readRecord(event);
       usage = extractOpenAIUsage(record) ?? usage;
-      const choices = Array.isArray(record?.choices) ? record.choices : [];
+      const choice = extractFirstChoice(record);
+      if (!choice) {
+        continue;
+      }
 
-      for (const choiceValue of choices) {
-        const choice = readRecord(choiceValue);
-        if (!choice) {
-          continue;
+      const delta = readRecord(choice.delta);
+      if (typeof delta?.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+        if (!reasoningId) {
+          reasoningId = `reasoning-${reasoningIndex++}`;
+          yield {
+            type: "reasoning-start",
+            id: reasoningId,
+          };
         }
 
-        const delta = readRecord(choice.delta);
-        const textDelta = extractOpenAIContentText(delta?.content);
-        if (textDelta.length > 0) {
-          yield { type: "text-delta", delta: textDelta };
-        }
+        yield {
+          type: "reasoning-delta",
+          id: reasoningId,
+          delta: delta.reasoning_content,
+        };
+      }
 
-        const rawToolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
-        for (const rawToolCall of rawToolCalls) {
-          const toolCallRecord = readRecord(rawToolCall);
-          const index = typeof toolCallRecord?.index === "number" ? toolCallRecord.index : 0;
-          const current = toolCalls.get(index) ?? {
-            id: typeof toolCallRecord?.id === "string" ? toolCallRecord.id : `tool-${index}`,
-            name: "",
-            arguments: "",
-            started: false,
+      const textDelta = extractOpenAIContentText(delta?.content);
+      if (textDelta.length > 0) {
+        if (reasoningId) {
+          yield {
+            type: "reasoning-end",
+            id: reasoningId,
           };
+          reasoningId = null;
+        }
+        yield { type: "text-delta", delta: textDelta };
+      }
 
-          if (typeof toolCallRecord?.id === "string") {
-            current.id = toolCallRecord.id;
-          }
+      const rawToolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
+      for (const rawToolCall of rawToolCalls) {
+        if (reasoningId) {
+          yield {
+            type: "reasoning-end",
+            id: reasoningId,
+          };
+          reasoningId = null;
+        }
 
-          const fn = readRecord(toolCallRecord?.function);
-          if (typeof fn?.name === "string") {
-            current.name = fn.name;
-          }
+        const toolCallRecord = readRecord(rawToolCall);
+        const index = typeof toolCallRecord?.index === "number" ? toolCallRecord.index : 0;
+        const current = toolCalls.get(index) ?? {
+          id: typeof toolCallRecord?.id === "string" ? toolCallRecord.id : `tool-${index}`,
+          name: "",
+          arguments: "",
+          started: false,
+        };
 
-          if (!current.started && current.name.length > 0) {
-            current.started = true;
-            yield {
-              type: "tool-input-start",
-              id: current.id,
-              toolName: current.name,
-            };
-          }
+        if (typeof toolCallRecord?.id === "string") {
+          current.id = toolCallRecord.id;
+        }
 
-          if (typeof fn?.arguments === "string" && fn.arguments.length > 0) {
-            current.arguments += fn.arguments;
-            yield {
-              type: "tool-input-delta",
-              id: current.id,
-              delta: fn.arguments,
-            };
-          }
+        const fn = readRecord(toolCallRecord?.function);
+        if (typeof fn?.name === "string") {
+          current.name = fn.name;
+        }
 
-          toolCalls.set(index, current);
+        if (!current.started && current.name.length > 0) {
+          current.started = true;
+          yield {
+            type: "tool-input-start",
+            id: current.id,
+            toolName: current.name,
+          };
         }
 
-        const normalizedFinishReason = normalizeOpenAIFinishReason(choice.finish_reason);
-        if (normalizedFinishReason) {
-          finishReason = normalizedFinishReason;
+        if (typeof fn?.arguments === "string" && fn.arguments.length > 0) {
+          current.arguments += fn.arguments;
+          yield {
+            type: "tool-input-delta",
+            id: current.id,
+            delta: fn.arguments,
+          };
         }
+
+        toolCalls.set(index, current);
+      }
+
+      const normalizedFinishReason = normalizeOpenAIFinishReason(choice.finish_reason);
+      if (normalizedFinishReason) {
+        finishReason = normalizedFinishReason;
       }
     }
   }
@@ -1552,6 +1665,13 @@ async function* streamOpenAICompatibleParts(
     }
   }
 
+  if (reasoningId) {
+    yield {
+      type: "reasoning-end",
+      id: reasoningId,
+    };
+  }
+
   if (
     finishReason &&
     typeof finishReason === "object" &&

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.196";
+export const VERSION = "0.1.198";