@depup/ai-sdk__google 4.0.69-depup.0 → 4.0.72-depup.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @ai-sdk/google
 
+## 4.0.72
+
+### Patch Changes
+
+- 4a994ad: feat(google): realtime session options for Gemini 3.8 Live
+
+  Add `thinkingConfig` (`thinkingLevel`, `thinkingBudget`, `includeThoughts`) and
+  `defaultToolBehavior` to `GoogleRealtimeModelOptions`. `thinkingConfig` is merged
+  into the Live `setup.generationConfig`. Background-reasoning Live models such as
+  `gemini-3.8-live-extended-thinking` require exactly one of `thinkingLevel` or
+  `thinkingBudget`, so the provider sends `thinkingLevel: 'low'` on those models
+  when neither is set. `defaultToolBehavior` stamps `behavior` on every function
+  declaration in the setup.
+
+  Forward the Live `interactionStatus` and `waitingForInput` server messages as
+  custom events so applications can tell when a background-reasoning model is idle,
+  since `turnComplete` alone no longer means that.
+
+## 4.0.71
+
+### Patch Changes
+
+- Updated dependencies [5c0054d]
+- Updated dependencies [39535af]
+  - @ai-sdk/provider@4.0.15
+  - @ai-sdk/provider-utils@5.0.41
+
+## 4.0.70
+
+### Patch Changes
+
+- 2a32459: fix(google): preserve JSON Schema instead of converting to OpenAPI schema
+- d93e295: fix(google): keep a realtime `functionResponse.response` an object
+
+  Gemini types that field as a `google.protobuf.Struct`, which accepts an object and
+  nothing else. `onToolCall` returns `unknown` and `addToolOutput` takes `unknown`, so a
+  string, number, array or `null` tool result reached the wire unwrapped, Gemini closed
+  the socket with `1007`, and the close code was dropped on the way back so the
+  application saw a plain disconnect. A non-object result is now wrapped under the
+  `output` key the field's own docstring prescribes; an object is passed through
+  unchanged, as before.
+
+  An `output` that is not valid JSON no longer becomes `{}`. That branch told the model
+  the tool had returned an empty object, with nothing thrown and the socket still up, so
+  the answer was wrong with nothing to notice. The text is kept instead.
+
 ## 4.0.69
 
 ### Patch Changes

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/ai-sdk__google
 
 | Field | Value |
 |-------|-------|
-| Original | [@ai-sdk/google](https://www.npmjs.com/package/@ai-sdk/google) @ 4.0.69 |
-| Processed | 2026-09-12 |
+| Original | [@ai-sdk/google](https://www.npmjs.com/package/@ai-sdk/google) @ 4.0.72 |
+| Processed | 2026-09-16 |
 | Smoke test | failed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-09-12T08:09:52.486Z",
+  "timestamp": "2026-09-16T00:30:55.501Z",
   "totalUpdated": 0
 }

package/dist/index.d.ts

@@ -762,6 +762,41 @@ type GoogleRealtimeModelOptions = {
          */
         echoTargetLanguage?: boolean;
     };
+    /**
+     * Gemini Live thinking configuration.
+     *
+     * Supported by Live models with background reasoning (e.g.
+     * `gemini-3.8-live-extended-thinking`), which can process multi-step
+     * reasoning and function calls while streaming audio responses. Not
+     * supported by latency-optimized models (e.g. `gemini-3.8-live`).
+     */
+    thinkingConfig?: {
+        /**
+         * Thinking effort level. Background-reasoning Live models require exactly
+         * one of `thinkingLevel` or `thinkingBudget`; when neither is set, the
+         * provider sends `thinkingLevel: 'low'` on those models.
+         */
+        thinkingLevel?: 'low' | 'medium' | 'high';
+        /**
+         * Token budget for background thinking. Mutually exclusive with
+         * `thinkingLevel`; setting it suppresses the default level.
+         */
+        thinkingBudget?: number;
+        /**
+         * Whether thought summaries should be included in the response.
+         */
+        includeThoughts?: boolean;
+    };
+    /**
+     * Default `behavior` stamped onto every function declaration in the
+     * session setup.
+     *
+     * Gemini 3.8 Live models default to `NON_BLOCKING` (asynchronous) function
+     * calling. Set to `BLOCKING` for synchronous calls on models that support it
+     * (e.g. `gemini-3.8-live`); background-reasoning models accept only
+     * `NON_BLOCKING`.
+     */
+    defaultToolBehavior?: 'BLOCKING' | 'NON_BLOCKING';
 };
 
 interface GoogleTranscriptionModelConfig {

package/dist/index.js

@@ -7,7 +7,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "4.0.69" : "0.0.0-test";
+var VERSION = true ? "4.0.72" : "0.0.0-test";
 
 // src/google-embedding-model.ts
 import {
@@ -255,7 +255,7 @@ var googleGenerativeAISingleEmbeddingResponseSchema = lazySchema3(
 import {
   InvalidArgumentError,
   InvalidResponseDataError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders3,
@@ -329,289 +329,9 @@ function convertGoogleUsage(usage) {
   };
 }
 
-// src/convert-json-schema-to-openapi-schema.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-var recursiveReferenceFunctionalityPrefix = "recursive JSON Schema reference:";
-function isRecursiveJSONSchemaReferenceError(error) {
-  return UnsupportedFunctionalityError.isInstance(error) && error.functionality.startsWith(recursiveReferenceFunctionalityPrefix);
-}
-function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
-  const rootSchema = typeof jsonSchema === "object" ? jsonSchema : void 0;
-  return convertJSONSchemaDefinition(jsonSchema, isRoot, {
-    definitions: rootSchema == null ? void 0 : rootSchema.definitions,
-    dollarDefinitions: rootSchema == null ? void 0 : rootSchema.$defs,
-    resolvingReferences: /* @__PURE__ */ new Set()
-  });
-}
-function convertJSONSchemaDefinition(jsonSchema, isRoot, referenceContext) {
-  if (jsonSchema == null) {
-    return void 0;
-  }
-  if (typeof jsonSchema === "boolean") {
-    return { type: "boolean", properties: {} };
-  }
-  if (jsonSchema.$ref != null) {
-    return convertJSONSchemaReference({
-      jsonSchema,
-      reference: jsonSchema.$ref,
-      isRoot,
-      referenceContext
-    });
-  }
-  if (isEmptyObjectSchema(jsonSchema)) {
-    if (isRoot) {
-      return void 0;
-    }
-    if (jsonSchema.description) {
-      return { type: "object", description: jsonSchema.description };
-    }
-    return { type: "object" };
-  }
-  const {
-    type,
-    description,
-    required,
-    properties,
-    items,
-    allOf,
-    anyOf,
-    oneOf,
-    format,
-    const: constValue,
-    minLength,
-    minItems,
-    maxItems,
-    enum: enumValues
-  } = jsonSchema;
-  const result = {};
-  if (description) result.description = description;
-  if (required) result.required = required;
-  if (format) result.format = format;
-  if (type) {
-    if (Array.isArray(type)) {
-      const hasNull = type.includes("null");
-      const nonNullTypes = type.filter((t) => t !== "null");
-      if (nonNullTypes.length === 0) {
-        result.type = "null";
-      } else {
-        result.anyOf = nonNullTypes.map((t) => ({ type: t }));
-        if (hasNull) {
-          result.nullable = true;
-        }
-      }
-    } else {
-      result.type = type;
-    }
-  }
-  const values = enumValues != null ? enumValues : constValue !== void 0 ? [constValue] : void 0;
-  if (values !== void 0) {
-    addEnumToSchema({ values, type, result });
-  }
-  if (properties != null) {
-    result.properties = Object.entries(properties).reduce(
-      (acc, [key, value]) => {
-        acc[key] = convertJSONSchemaDefinition(value, false, referenceContext);
-        return acc;
-      },
-      {}
-    );
-  }
-  if (items) {
-    result.items = Array.isArray(items) ? items.map(
-      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
-    ) : convertJSONSchemaDefinition(items, false, referenceContext);
-  }
-  if (allOf) {
-    result.allOf = allOf.map(
-      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
-    );
-  }
-  if (anyOf) {
-    if (anyOf.some(
-      (schema) => typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null"
-    )) {
-      const nonNullSchemas = anyOf.filter(
-        (schema) => !(typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null")
-      );
-      if (nonNullSchemas.length === 1) {
-        const converted = convertJSONSchemaDefinition(
-          nonNullSchemas[0],
-          false,
-          referenceContext
-        );
-        if (typeof converted === "object") {
-          result.nullable = true;
-          Object.assign(result, converted);
-        }
-      } else {
-        result.anyOf = nonNullSchemas.map(
-          (item) => convertJSONSchemaDefinition(item, false, referenceContext)
-        );
-        result.nullable = true;
-      }
-    } else {
-      result.anyOf = anyOf.map(
-        (item) => convertJSONSchemaDefinition(item, false, referenceContext)
-      );
-    }
-  }
-  if (oneOf) {
-    result.oneOf = oneOf.map(
-      (item) => convertJSONSchemaDefinition(item, false, referenceContext)
-    );
-  }
-  if (minLength !== void 0) {
-    result.minLength = minLength;
-  }
-  if (minItems !== void 0) {
-    result.minItems = minItems;
-  }
-  if (maxItems !== void 0) {
-    result.maxItems = maxItems;
-  }
-  return result;
-}
-function convertJSONSchemaReference({
-  jsonSchema,
-  reference,
-  isRoot,
-  referenceContext
-}) {
-  const { definition, referenceKey } = getReferencedDefinition(
-    reference,
-    referenceContext
-  );
-  if (referenceContext.resolvingReferences.has(referenceKey)) {
-    throw new UnsupportedFunctionalityError({
-      functionality: `${recursiveReferenceFunctionalityPrefix} ${reference}`,
-      message: "Google schema conversion does not support recursive JSON Schema references."
-    });
-  }
-  const resolvingReferences = new Set(referenceContext.resolvingReferences);
-  resolvingReferences.add(referenceKey);
-  const { $ref: _reference, ...siblingSchema } = jsonSchema;
-  const resolvedSchema = typeof definition === "boolean" ? definition ? siblingSchema : false : { ...definition, ...siblingSchema };
-  return convertJSONSchemaDefinition(resolvedSchema, isRoot, {
-    ...referenceContext,
-    resolvingReferences
-  });
-}
-function getReferencedDefinition(reference, referenceContext) {
-  const definitionSources = [
-    {
-      prefix: "#/$defs/",
-      definitions: referenceContext.dollarDefinitions
-    },
-    {
-      prefix: "#/definitions/",
-      definitions: referenceContext.definitions
-    }
-  ];
-  const source = definitionSources.find(
-    ({ prefix }) => reference.startsWith(prefix)
-  );
-  const encodedDefinitionName = source ? reference.slice(source.prefix.length) : void 0;
-  if (source == null || encodedDefinitionName == null || encodedDefinitionName.length === 0 || encodedDefinitionName.includes("/")) {
-    throwUnsupportedReference(reference);
-  }
-  let decodedDefinitionName;
-  try {
-    decodedDefinitionName = decodeURIComponent(encodedDefinitionName);
-  } catch (e) {
-    throwUnsupportedReference(reference);
-  }
-  if (decodedDefinitionName.includes("/") || /~(?![01])/u.test(decodedDefinitionName) || source.definitions == null) {
-    throwUnsupportedReference(reference);
-  }
-  const definitionName = decodedDefinitionName.replace(
-    /~[01]/g,
-    (match) => match === "~1" ? "/" : "~"
-  );
-  if (!Object.prototype.hasOwnProperty.call(source.definitions, definitionName)) {
-    throwUnsupportedReference(reference);
-  }
-  return {
-    definition: source.definitions[definitionName],
-    referenceKey: `${source.prefix}${definitionName}`
-  };
-}
-function throwUnsupportedReference(reference) {
-  throw new UnsupportedFunctionalityError({
-    functionality: `JSON Schema reference: ${reference}`,
-    message: "Google schema conversion only supports references to direct children of root-level $defs or definitions."
-  });
-}
-function addEnumToSchema({
-  values,
-  type,
-  result
-}) {
-  const nullable = Array.isArray(type) && type.includes("null") || type === void 0 && values.includes(null);
-  const enumValues = nullable ? values.filter((value) => value !== null) : values;
-  if (values.length > 0 && values.every((value) => value === null)) {
-    const typeAllowsNull = type === void 0 || type === "null" || Array.isArray(type) && type.includes("null");
-    if (typeAllowsNull) {
-      result.type = "null";
-      if (Array.isArray(type)) {
-        delete result.anyOf;
-      }
-      return;
-    }
-  }
-  const enumType = getEnumType({ values: enumValues, type });
-  if (enumType === void 0) {
-    throw new UnsupportedFunctionalityError({
-      functionality: "JSON Schema enum with mixed or unsupported values",
-      message: "Google does not support this JSON Schema enum. Enum values must share one supported primitive type and match the schema type."
-    });
-  }
-  result.type = enumType;
-  if (Array.isArray(type)) {
-    delete result.anyOf;
-  }
-  if (nullable) {
-    result.nullable = true;
-  }
-  if (enumType === "string") {
-    result.enum = enumValues;
-  } else {
-    result.format = "enum";
-    result.enum = enumValues.map(String);
-  }
-}
-function getEnumType({
-  values,
-  type
-}) {
-  if (values.length === 0) {
-    return void 0;
-  }
-  const typeAllows = (enumType) => type === void 0 || type === enumType || Array.isArray(type) && type.includes(enumType);
-  if (typeAllows("string") && values.every((value) => typeof value === "string")) {
-    return "string";
-  }
-  if ((typeAllows("number") || typeAllows("integer")) && values.every((value) => typeof value === "number" && Number.isFinite(value))) {
-    if (typeAllows("number")) {
-      return "number";
-    }
-    if (values.every((value) => Number.isInteger(value))) {
-      return "integer";
-    }
-  }
-  if (typeAllows("boolean") && values.every((value) => typeof value === "boolean")) {
-    return "boolean";
-  }
-  return void 0;
-}
-function isEmptyObjectSchema(jsonSchema) {
-  return jsonSchema != null && typeof jsonSchema === "object" && jsonSchema.type === "object" && (jsonSchema.properties == null || Object.keys(jsonSchema.properties).length === 0) && !jsonSchema.additionalProperties;
-}
-
 // src/convert-to-google-messages.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+  UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
 import {
   convertToBase64,
@@ -768,7 +488,7 @@ function convertToGoogleMessages(prompt, options) {
     switch (role) {
       case "system": {
         if (!systemMessagesAllowed) {
-          throw new UnsupportedFunctionalityError2({
+          throw new UnsupportedFunctionalityError({
             functionality: "system messages are only supported at the beginning of the conversation"
           });
         }
@@ -797,7 +517,7 @@ function convertToGoogleMessages(prompt, options) {
                 }
                 case "reference": {
                   if (isVertexLike) {
-                    throw new UnsupportedFunctionalityError2({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "file parts with provider references"
                     });
                   }
@@ -865,7 +585,7 @@ function convertToGoogleMessages(prompt, options) {
               case "reasoning-file": {
                 switch (part.data.type) {
                   case "url": {
-                    throw new UnsupportedFunctionalityError2({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "File data URLs in assistant messages are not supported"
                     });
                   }
@@ -885,13 +605,13 @@ function convertToGoogleMessages(prompt, options) {
               case "file": {
                 switch (part.data.type) {
                   case "url": {
-                    throw new UnsupportedFunctionalityError2({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "File data URLs in assistant messages are not supported"
                     });
                   }
                   case "reference": {
                     if (isVertexLike) {
-                      throw new UnsupportedFunctionalityError2({
+                      throw new UnsupportedFunctionalityError({
                         functionality: "file parts with provider references"
                       });
                     }
@@ -1154,6 +874,44 @@ async function downloadToolResultOutput(output, {
   };
 }
 
+// src/sanitize-response-json-schema.ts
+function sanitizeResponseJsonSchema(schema) {
+  const {
+    const: constValue,
+    properties,
+    items,
+    additionalProperties,
+    anyOf,
+    oneOf,
+    ...result
+  } = schema;
+  return {
+    ...result,
+    ...constValue !== void 0 ? { enum: [constValue] } : {},
+    ...properties != null ? { properties: sanitizeDefinitions(properties) } : {},
+    ...items != null ? {
+      items: Array.isArray(items) ? items.map(sanitizeDefinition) : sanitizeDefinition(items)
+    } : {},
+    ...additionalProperties != null ? {
+      additionalProperties: typeof additionalProperties === "boolean" ? additionalProperties : sanitizeDefinition(additionalProperties)
+    } : {},
+    ...anyOf != null ? { anyOf: anyOf.map(sanitizeDefinition) } : {},
+    ...oneOf != null ? { oneOf: oneOf.map(sanitizeDefinition) } : {},
+    ...result.$defs != null ? { $defs: sanitizeDefinitions(result.$defs) } : {}
+  };
+}
+function sanitizeDefinitions(definitions) {
+  return Object.fromEntries(
+    Object.entries(definitions).map(([name, definition]) => [
+      name,
+      sanitizeDefinition(definition)
+    ])
+  );
+}
+function sanitizeDefinition(definition) {
+  return typeof definition === "boolean" ? definition : sanitizeResponseJsonSchema(definition);
+}
+
 // src/google-language-model-options.ts
 import {
   lazySchema as lazySchema4,
@@ -1368,7 +1126,7 @@ function getGoogleModelCapabilities(modelId) {
 
 // src/google-prepare-tools.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 function prepareTools({
   tools,
@@ -1598,7 +1356,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError3({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -1606,24 +1364,11 @@ function prepareTools({
 }
 function prepareFunctionDeclaration(tool) {
   var _a;
-  const declaration = {
+  return {
     name: tool.name,
-    description: (_a = tool.description) != null ? _a : ""
+    description: (_a = tool.description) != null ? _a : "",
+    parametersJsonSchema: tool.inputSchema
   };
-  try {
-    return {
-      ...declaration,
-      parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema)
-    };
-  } catch (error) {
-    if (!isRecursiveJSONSchemaReferenceError(error)) {
-      throw error;
-    }
-    return {
-      ...declaration,
-      parametersJsonSchema: tool.inputSchema
-    };
-  }
 }
 
 // src/google-json-accumulator.ts
@@ -2109,10 +1854,10 @@ var GoogleLanguageModel = class _GoogleLanguageModel {
           seed,
           // response format:
           responseMimeType: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? "application/json" : void 0,
-          responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
-          // so this is needed as an escape hatch:
+          responseJsonSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google does not support all JSON Schema features in
+          // responseJsonSchema, so this is needed as an escape hatch:
           // TODO convert into provider option
-          ((_c = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _c : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
+          ((_c = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _c : true) ? sanitizeResponseJsonSchema(responseFormat.schema) : void 0,
           ...(googleOptions == null ? void 0 : googleOptions.audioTimestamp) && {
             audioTimestamp: googleOptions.audioTimestamp
           },
@@ -3214,7 +2959,7 @@ function assertSupportedBatchRequests(requests) {
   for (const request of requests) {
     const requestType = request.type;
     if (requestType !== "text" && requestType !== "image") {
-      throw new UnsupportedFunctionalityError4({
+      throw new UnsupportedFunctionalityError3({
         functionality: `batch request type: ${requestType}`,
         message: `The Google Batch API does not support batch requests with type "${requestType}".`
       });
@@ -3703,12 +3448,12 @@ var GoogleBatch = class {
     const { prompt, n, size, aspectRatio, seed, files, mask, providerOptions } = request.options;
     const warnings = [];
     if (mask != null) {
-      throw new UnsupportedFunctionalityError4({
+      throw new UnsupportedFunctionalityError3({
         functionality: "mask-based image editing in Google batches"
       });
     }
     if (n > 1) {
-      throw new UnsupportedFunctionalityError4({
+      throw new UnsupportedFunctionalityError3({
         functionality: "multiple images per Google batch request"
       });
     }
@@ -8312,6 +8057,20 @@ var GoogleRealtimeEventMapper = class {
         raw
       });
     }
+    if (serverContent.interactionStatus != null) {
+      events.push({
+        type: "custom",
+        rawType: "interactionStatus",
+        raw
+      });
+    }
+    if (serverContent.waitingForInput) {
+      events.push({
+        type: "custom",
+        rawType: "waitingForInput",
+        raw
+      });
+    }
     if (serverContent.turnComplete) {
       if (this.hasAudio) {
         events.push({
@@ -8400,9 +8159,16 @@ var GoogleRealtimeEventMapper = class {
     return null;
   }
 };
+function toFunctionResponseStruct(value) {
+  const isStruct = typeof value === "object" && value !== null && !Array.isArray(value);
+  return isStruct ? value : { output: value };
+}
 async function serializeFunctionCallOutput(item) {
   const parseResult = await safeParseJSON({ text: item.output });
-  const response = parseResult.success ? parseResult.value : {};
+  const response = parseResult.success ? toFunctionResponseStruct(parseResult.value) : (
+    // Preserve non-JSON output in the required object wrapper.
+    { output: item.output }
+  );
   return {
     toolResponse: {
       functionResponses: [
@@ -8415,10 +8181,18 @@ async function serializeFunctionCallOutput(item) {
     }
   };
 }
+function isThinkingLiveModel(modelId) {
+  var _a, _b;
+  const modelName = (_b = (_a = modelId.split("/").at(-1)) == null ? void 0 : _a.toLowerCase()) != null ? _b : "";
+  return /^gemini-\d+\.\d+-live\b.*thinking/.test(modelName);
+}
 function buildGoogleSessionConfig(config, modelId) {
+  var _a, _b;
   const setup = {
     model: getModelPath(modelId)
   };
+  const { google: google2, ...restProviderOptions } = (_a = config == null ? void 0 : config.providerOptions) != null ? _a : {};
+  const googleOptions = isRecord(google2) ? google2 : void 0;
   const generationConfig = {};
   if ((config == null ? void 0 : config.outputModalities) != null) {
     generationConfig.responseModalities = config.outputModalities.map(
@@ -8448,7 +8222,8 @@ function buildGoogleSessionConfig(config, modelId) {
         functionDeclarations: config.tools.map((tool) => ({
           name: tool.name,
           description: tool.description,
-          parameters: convertJSONSchemaToOpenAPISchema(tool.parameters)
+          parametersJsonSchema: tool.parameters,
+          ...(googleOptions == null ? void 0 : googleOptions.defaultToolBehavior) != null ? { behavior: googleOptions.defaultToolBehavior } : {}
         }))
       }
     ];
@@ -8459,12 +8234,17 @@ function buildGoogleSessionConfig(config, modelId) {
   if ((config == null ? void 0 : config.outputAudioTranscription) != null) {
     setup.outputAudioTranscription = {};
   }
+  const thinkingConfig = (_b = googleOptions == null ? void 0 : googleOptions.thinkingConfig) != null ? _b : isThinkingLiveModel(modelId) ? { thinkingLevel: "low" } : void 0;
+  const applyThinkingConfig = () => {
+    if (thinkingConfig == null) return;
+    const target = isRecord(setup.generationConfig) ? setup.generationConfig : generationConfig;
+    setup.generationConfig = { ...target, thinkingConfig };
+  };
   if ((config == null ? void 0 : config.providerOptions) == null) {
+    applyThinkingConfig();
     return setup;
   }
-  const { google: google2, ...providerOptions } = config.providerOptions;
-  Object.assign(setup, providerOptions);
-  const googleOptions = isRecord(google2) ? google2 : void 0;
+  Object.assign(setup, restProviderOptions);
   if ((googleOptions == null ? void 0 : googleOptions.translationConfig) != null) {
     const target = isRecord(setup.generationConfig) ? setup.generationConfig : generationConfig;
     setup.generationConfig = {
@@ -8472,6 +8252,7 @@ function buildGoogleSessionConfig(config, modelId) {
       translationConfig: googleOptions.translationConfig
     };
   }
+  applyThinkingConfig();
   return setup;
 }