ai 7.0.18 → 7.0.20

package/src/ui/convert-to-model-messages.ts

@@ -11,6 +11,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { createToolModelOutput } from '../prompt/create-tool-model-output';
 import { MessageConversionError } from '../prompt/message-conversion-error';
+import { getOwn } from '../util/get-own';
 import {
   getToolName,
   isCustomContentUIPart,
@@ -256,7 +257,7 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                           part.state === 'output-error'
                             ? part.errorText
                             : part.output,
-                        tool: options?.tools?.[toolName],
+                        tool: getOwn(options?.tools, toolName),
                         errorMode:
                           part.state === 'output-error' ? 'json' : 'none',
                       }),
@@ -375,7 +376,7 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                             toolPart.state === 'output-error'
                               ? toolPart.errorText
                               : toolPart.output,
-                          tool: options?.tools?.[toolName],
+                          tool: getOwn(options?.tools, toolName),
                           errorMode:
                             toolPart.state === 'output-error' ? 'text' : 'none',
                         }),

package/src/ui/process-ui-message-stream.ts

@@ -731,6 +731,9 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
                 approved: chunk.approved,
                 ...(chunk.reason != null ? { reason: chunk.reason } : {}),
                 ...(approval.isAutomatic === true ? { isAutomatic: true } : {}),
+                ...(approval.signature != null
+                  ? { signature: approval.signature }
+                  : {}),
               };
               if (chunk.providerExecuted != null) {
                 toolInvocation.providerExecuted = chunk.providerExecuted;

package/src/ui/validate-ui-messages.ts

@@ -9,6 +9,7 @@ import {
 import { z } from 'zod/v4';
 import { InvalidArgumentError } from '../error';
 import { jsonValueSchema } from '../types/json-value';
+import { getOwn } from '../util/get-own';
 import { providerMetadataSchema } from '../types/provider-metadata';
 import type {
   DataUIPart,
@@ -456,7 +457,7 @@ export async function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({
               InferUIMessageTools<UI_MESSAGE>
             >;
             const toolName = toolPart.type.slice(5);
-            const tool = tools[toolName];
+            const tool = getOwn(tools, toolName);
 
             if (
               !tool &&

package/src/util/canonical-hash.ts

@@ -0,0 +1,44 @@
+import { convertUint8ArrayToBase64 } from '@ai-sdk/provider-utils';
+
+const encoder = new TextEncoder();
+
+/**
+ * Deterministic JSON serialization: object keys are sorted so that two
+ * structurally-equal values always produce the same string regardless of key
+ * insertion order. Used as the input to content hashing.
+ */
+export function canonicalJSON(value: unknown): string {
+  if (value === null || value === undefined) {
+    return JSON.stringify(value);
+  }
+  if (typeof value !== 'object') {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJSON).join(',')}]`;
+  }
+  const keys = Object.keys(value as Record<string, unknown>).sort();
+  const entries = keys.map(
+    k =>
+      `${JSON.stringify(k)}:${canonicalJSON((value as Record<string, unknown>)[k])}`,
+  );
+  return `{${entries.join(',')}}`;
+}
+
+export function toBase64url(bytes: Uint8Array): string {
+  return convertUint8ArrayToBase64(bytes)
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}
+
+/**
+ * Canonical SHA-256 digest (base64url) of an arbitrary JSON-serializable value.
+ */
+export async function hashCanonical(value: unknown): Promise<string> {
+  const digest = await crypto.subtle.digest(
+    'SHA-256',
+    encoder.encode(canonicalJSON(value)),
+  );
+  return toBase64url(new Uint8Array(digest));
+}

package/src/util/get-own.ts

@@ -0,0 +1,18 @@
+/**
+ * Reads a property by an untrusted key, ignoring inherited prototype members.
+ *
+ * Tool sets, tool contexts, and similar lookup objects are indexed by names
+ * that can come from model output or client-supplied message history. Plain
+ * bracket access (`obj[name]`) resolves names such as `constructor`,
+ * `toString`, or `__proto__` to values on `Object.prototype`, which would slip
+ * past the `== null` / `!value` guards that treat an unknown name as "not
+ * present". This helper returns `undefined` unless `key` is an own property.
+ */
+export function getOwn<T extends object>(
+  obj: T | undefined | null,
+  key: string,
+): T[keyof T] | undefined {
+  return obj != null && Object.hasOwn(obj, key)
+    ? obj[key as keyof T]
+    : undefined;
+}

package/src/util/write-to-server-response.ts

@@ -1,5 +1,9 @@
 import type { ServerResponse } from 'node:http';
 
+type FlushableServerResponse = ServerResponse & {
+  flush?: () => void;
+};
+
 /**
  * Writes the content of a stream to a server response.
  */
@@ -32,6 +36,11 @@ export function writeToServerResponse({
 
         // Respect backpressure: if write() returns false, wait for 'drain' event
         const canContinue = response.write(value);
+        const flush = (response as FlushableServerResponse).flush;
+        if (typeof flush === 'function') {
+          flush.call(response);
+        }
+
         if (!canContinue) {
           await new Promise<void>(resolve => {
             response.once('drain', resolve);