@ai-sdk/google 3.0.137 → 3.0.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "3.0.137",
+  "version": "3.0.139",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

package/src/convert-json-schema-to-openapi-schema.ts

@@ -109,8 +109,18 @@ function convertJSONSchemaDefinition(
       if (nonNullTypes.length === 0) {
         // Only null type
         result.type = 'null';
+      } else if (nonNullTypes.length === 1) {
+        // A single type stays a plain node so sibling keywords (items,
+        // format, ...) remain valid: Gemini rejects fields beside anyOf and
+        // items on a non-array node.
+        result.type = nonNullTypes[0];
+        if (hasNull) {
+          result.nullable = true;
+        }
       } else {
-        // One or more non-null types: always use anyOf
+        // Multiple non-null types: use anyOf. Type-specific keywords
+        // (items, format, ...) still land beside it, which Gemini rejects;
+        // splitting them per branch is not handled yet.
         result.anyOf = nonNullTypes.map(t => ({ type: t }));
         if (hasNull) {
           result.nullable = true;

package/src/google-json-accumulator.ts

@@ -51,8 +51,14 @@ export class GoogleJSONAccumulator {
     let delta = '';
 
     for (const arg of partialArgs) {
-      const rawPath = arg.jsonPath.replace(/^\$\./, '');
-      if (!rawPath) continue;
+      // Vertex terminates an array with a value-less `$.path[]` entry. For an
+      // empty array, that terminator is the only entry sent for the path.
+      const isArrayTerminator = arg.jsonPath.endsWith('[]');
+      const jsonPath = isArrayTerminator
+        ? arg.jsonPath.slice(0, -2)
+        : arg.jsonPath;
+      const rawPath = jsonPath.replace(/^\$\./, '');
+      if (!rawPath || rawPath === '$') continue;
 
       const segments = parsePath(rawPath);
 
@@ -72,7 +78,20 @@ export class GoogleJSONAccumulator {
       }
 
       const resolved = resolvePartialArgValue(arg);
-      if (resolved == null) continue;
+      if (resolved == null) {
+        // A value-less entry for a path without a value is an empty container
+        // (an empty container has no leaves to stream). Value-less entries for
+        // existing paths are string or array terminators and are ignored.
+        if (existingValue !== undefined || arg.willContinue === true) continue;
+
+        setNestedValue(
+          this.accumulatedArgs,
+          segments,
+          isArrayTerminator ? [] : {},
+        );
+        delta += this.emitContainer(segments, isArrayTerminator);
+        continue;
+      }
 
       setNestedValue(this.accumulatedArgs, segments, resolved.value);
       delta += this.emitNavigationTo(segments, arg, resolved.json);
@@ -141,6 +160,36 @@ export class GoogleJSONAccumulator {
     return fragment;
   }
 
+  /**
+   * Navigates to `targetSegments` and opens a container there. The container
+   * stays open so later entries for its children continue inside it; it is
+   * closed by subsequent navigation or by `finalize()`.
+   *
+   * Input: targetSegments=["nested","tags"], isArray=true
+   * Output: '{"nested":{"tags":['
+   */
+  private emitContainer(
+    targetSegments: PathSegment[],
+    isArray: boolean,
+  ): string {
+    let fragment = '';
+
+    if (this.stringOpen) {
+      fragment += '"';
+      this.stringOpen = false;
+    }
+
+    fragment += this.ensureRoot();
+
+    const commonDepth = this.findCommonStackDepth(targetSegments);
+
+    fragment += this.closeDownTo(commonDepth);
+    // openDownTo infers the innermost container type from the leaf segment type
+    fragment += this.openDownTo(targetSegments, isArray ? 0 : '');
+
+    return fragment;
+  }
+
   /**
    * Returns the stack depth to preserve when navigating to a new target
    * container path. Always >= 1 (the root is never popped).