@google/genai 1.8.0 → 1.9.0

package/dist/node/node.d.ts

@@ -3510,11 +3510,38 @@ export { Image_2 as Image }
 
 /** Enum that specifies the language of the text in the prompt. */
 export declare enum ImagePromptLanguage {
+    /**
+     * Auto-detect the language.
+     */
     auto = "auto",
+    /**
+     * English
+     */
     en = "en",
+    /**
+     * Japanese
+     */
     ja = "ja",
+    /**
+     * Korean
+     */
     ko = "ko",
-    hi = "hi"
+    /**
+     * Hindi
+     */
+    hi = "hi",
+    /**
+     * Chinese
+     */
+    zh = "zh",
+    /**
+     * Portuguese
+     */
+    pt = "pt",
+    /**
+     * Spanish
+     */
+    es = "es"
 }
 
 /** Config for inlined request. */
@@ -3812,7 +3839,7 @@ export declare class Live {
      if (GOOGLE_GENAI_USE_VERTEXAI) {
      model = 'gemini-2.0-flash-live-preview-04-09';
      } else {
-     model = 'gemini-2.0-flash-live-001';
+     model = 'gemini-live-2.5-flash-preview';
      }
      const session = await ai.live.connect({
      model: model,
@@ -4778,6 +4805,14 @@ export declare class Models extends BaseModule {
      * ```
      */
     generateContent: (params: types.GenerateContentParameters) => Promise<types.GenerateContentResponse>;
+    /**
+     * This logic is needed for GenerateContentConfig only.
+     * Previously we made GenerateContentConfig.responseSchema field to accept
+     * unknown. Since v1.9.0, we switch to use backend JSON schema support.
+     * To maintain backward compatibility, we move the data that was treated as
+     * JSON schema from the responseSchema field to the responseJsonSchema field.
+     */
+    private maybeMoveToResponseJsonSchem;
     /**
      * Makes an API request to generate content with a given model and yields the
      * response in chunks.
@@ -5790,7 +5825,7 @@ export declare class Session {
      if (GOOGLE_GENAI_USE_VERTEXAI) {
      model = 'gemini-2.0-flash-live-preview-04-09';
      } else {
-     model = 'gemini-2.0-flash-live-001';
+     model = 'gemini-live-2.5-flash-preview';
      }
      const session = await ai.live.connect({
      model: model,
@@ -6085,14 +6120,20 @@ export declare class Tokens extends BaseModule {
      * @experimental
      *
      * @remarks
-     * Ephermeral auth tokens is only supported in the Gemini Developer API.
+     * Ephemeral auth tokens is only supported in the Gemini Developer API.
      * It can be used for the session connection to the Live constrained API.
+     * Support in v1alpha only.
      *
      * @param params - The parameters for the create request.
      * @return The created auth token.
      *
      * @example
      * ```ts
+     * const ai = new GoogleGenAI({
+     *     apiKey: token.name,
+     *     httpOptions: { apiVersion: 'v1alpha' }  // Support in v1alpha only.
+     * });
+     *
      * // Case 1: If LiveEphemeralParameters is unset, unlock LiveConnectConfig
      * // when using the token in Live API sessions. Each session connection can
      * // use a different configuration.

package/dist/web/index.mjs

@@ -1,5 +1,3 @@
-import { z } from 'zod';
-
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -791,11 +789,38 @@ var PersonGeneration;
 /** Enum that specifies the language of the text in the prompt. */
 var ImagePromptLanguage;
 (function (ImagePromptLanguage) {
+    /**
+     * Auto-detect the language.
+     */
     ImagePromptLanguage["auto"] = "auto";
+    /**
+     * English
+     */
     ImagePromptLanguage["en"] = "en";
+    /**
+     * Japanese
+     */
     ImagePromptLanguage["ja"] = "ja";
+    /**
+     * Korean
+     */
     ImagePromptLanguage["ko"] = "ko";
+    /**
+     * Hindi
+     */
     ImagePromptLanguage["hi"] = "hi";
+    /**
+     * Chinese
+     */
+    ImagePromptLanguage["zh"] = "zh";
+    /**
+     * Portuguese
+     */
+    ImagePromptLanguage["pt"] = "pt";
+    /**
+     * Spanish
+     */
+    ImagePromptLanguage["es"] = "es";
 })(ImagePromptLanguage || (ImagePromptLanguage = {}));
 /** Enum representing the mask mode of a mask reference image. */
 var MaskReferenceMode;
@@ -1896,133 +1921,12 @@ function tContents(origin) {
     }
     return result;
 }
-// The fields that are supported by JSONSchema. Must be kept in sync with the
-// JSONSchema interface above.
-const supportedJsonSchemaFields = new Set([
-    'type',
-    'format',
-    'title',
-    'description',
-    'default',
-    'items',
-    'minItems',
-    'maxItems',
-    'enum',
-    'properties',
-    'required',
-    'minProperties',
-    'maxProperties',
-    'minimum',
-    'maximum',
-    'minLength',
-    'maxLength',
-    'pattern',
-    'anyOf',
-    'propertyOrdering',
-]);
-const jsonSchemaTypeValidator = z.enum([
-    'string',
-    'number',
-    'integer',
-    'object',
-    'array',
-    'boolean',
-    'null',
-]);
-// Handles all types and arrays of all types.
-const schemaTypeUnion = z.union([
-    jsonSchemaTypeValidator,
-    z.array(jsonSchemaTypeValidator),
-]);
-/**
- * Creates a zod validator for JSONSchema.
- *
- * @param strictMode Whether to enable strict mode, default to true. When
- * strict mode is enabled, the zod validator will throw error if there
- * are unrecognized fields in the input data. If strict mode is
- * disabled, the zod validator will ignore the unrecognized fields, only
- * populate the fields that are listed in the JSONSchema. Regardless of
- * the mode the type mismatch will always result in an error, for example
- * items field should be a single JSONSchema, but for tuple type it would
- * be an array of JSONSchema, this will always result in an error.
- * @return The zod validator for JSONSchema.
- */
-function createJsonSchemaValidator(strictMode = true) {
-    const jsonSchemaValidator = z.lazy(() => {
-        // Define the base object shape *inside* the z.lazy callback
-        const baseShape = z.object({
-            // --- Type ---
-            type: schemaTypeUnion.optional(),
-            // --- Annotations ---
-            format: z.string().optional(),
-            title: z.string().optional(),
-            description: z.string().optional(),
-            default: z.unknown().optional(),
-            // --- Array Validations ---
-            items: jsonSchemaValidator.optional(),
-            minItems: z.coerce.string().optional(),
-            maxItems: z.coerce.string().optional(),
-            // --- Generic Validations ---
-            enum: z.array(z.unknown()).optional(),
-            // --- Object Validations ---
-            properties: z.record(z.string(), jsonSchemaValidator).optional(),
-            required: z.array(z.string()).optional(),
-            minProperties: z.coerce.string().optional(),
-            maxProperties: z.coerce.string().optional(),
-            propertyOrdering: z.array(z.string()).optional(),
-            // --- Numeric Validations ---
-            minimum: z.number().optional(),
-            maximum: z.number().optional(),
-            // --- String Validations ---
-            minLength: z.coerce.string().optional(),
-            maxLength: z.coerce.string().optional(),
-            pattern: z.string().optional(),
-            // --- Schema Composition ---
-            anyOf: z.array(jsonSchemaValidator).optional(),
-            // --- Additional Properties --- This field is not included in the
-            // JSONSchema, will not be communicated to the model, it is here purely
-            // for enabling the zod validation strict mode.
-            additionalProperties: z.boolean().optional(),
-        });
-        // Conditionally apply .strict() based on the flag
-        return strictMode ? baseShape.strict() : baseShape;
-    });
-    return jsonSchemaValidator;
-}
 /*
-Handle type field:
-The resulted type field in JSONSchema form zod_to_json_schema can be either
-an array consist of primitive types or a single primitive type.
-This is due to the optimization of zod_to_json_schema, when the types in the
-union are primitive types without any additional specifications,
-zod_to_json_schema will squash the types into an array instead of put them
-in anyOf fields. Otherwise, it will put the types in anyOf fields.
-See the following link for more details:
-https://github.com/zodjs/zod-to-json-schema/blob/main/src/index.ts#L101
-The logic here is trying to undo that optimization, flattening the array of
-types to anyOf fields.
-                                 type field
-                                      |
-                            ___________________________
-                           /                           \
-                          /                              \
-                         /                                \
-                       Array                              Type.*
-                /                  \                       |
-      Include null.              Not included null     type = Type.*.
-      [null, Type.*, Type.*]     multiple types.
-      [null, Type.*]             [Type.*, Type.*]
-            /                                \
-      remove null                             \
-      add nullable = true                      \
-       /                    \                   \
-    [Type.*]           [Type.*, Type.*]          \
- only one type left     multiple types left       \
- add type = Type.*.           \                  /
-                               \                /
-                         not populate the type field in final result
-                           and make the types into anyOf fields
-                          anyOf:[{type: 'Type.*'}, {type: 'Type.*'}];
+Transform the type field from an array of types to an array of anyOf fields.
+Example:
+  {type: ['STRING', 'NUMBER']}
+will be transformed to
+  {anyOf: [{type: 'STRING'}, {type: 'NUMBER'}]}
 */
 function flattenTypeArrayToAnyOf(typeList, resultingSchema) {
     if (typeList.includes('null')) {
@@ -2168,15 +2072,11 @@ function processJsonSchema(_jsonSchema) {
 // https://github.com/StefanTerdell/zod-to-json-schema/blob/70525efe555cd226691e093d171370a3b10921d1/src/zodToJsonSchema.ts#L7
 // typebox can return unknown, see details in
 // https://github.com/sinclairzx81/typebox/blob/5a5431439f7d5ca6b494d0d18fbfd7b1a356d67c/src/type/create/type.ts#L35
+// Note: proper json schemas with the $schema field set never arrive to this
+// transformer. Schemas with $schema are routed to the equivalent API json
+// schema field.
 function tSchema(schema) {
-    if (Object.keys(schema).includes('$schema')) {
-        delete schema['$schema'];
-        const validatedJsonSchema = createJsonSchemaValidator().parse(schema);
-        return processJsonSchema(validatedJsonSchema);
-    }
-    else {
-        return processJsonSchema(schema);
-    }
+    return processJsonSchema(schema);
 }
 function tSpeechConfig(speechConfig) {
     if (typeof speechConfig === 'object') {
@@ -2205,10 +2105,28 @@ function tTool(tool) {
     if (tool.functionDeclarations) {
         for (const functionDeclaration of tool.functionDeclarations) {
             if (functionDeclaration.parameters) {
-                functionDeclaration.parameters = tSchema(functionDeclaration.parameters);
+                if (!Object.keys(functionDeclaration.parameters).includes('$schema')) {
+                    functionDeclaration.parameters = processJsonSchema(functionDeclaration.parameters);
+                }
+                else {
+                    if (!functionDeclaration.parametersJsonSchema) {
+                        functionDeclaration.parametersJsonSchema =
+                            functionDeclaration.parameters;
+                        delete functionDeclaration.parameters;
+                    }
+                }
             }
             if (functionDeclaration.response) {
-                functionDeclaration.response = tSchema(functionDeclaration.response);
+                if (!Object.keys(functionDeclaration.response).includes('$schema')) {
+                    functionDeclaration.response = processJsonSchema(functionDeclaration.response);
+                }
+                else {
+                    if (!functionDeclaration.responseJsonSchema) {
+                        functionDeclaration.responseJsonSchema =
+                            functionDeclaration.response;
+                        delete functionDeclaration.response;
+                    }
+                }
             }
         }
     }
@@ -2413,7 +2331,7 @@ function mcpToGeminiTool(mcpTool, config = {}) {
     const functionDeclaration = {
         name: mcpToolSchema['name'],
         description: mcpToolSchema['description'],
-        parameters: processJsonSchema(filterToJsonSchema(mcpToolSchema['inputSchema'])),
+        parametersJsonSchema: mcpToolSchema['inputSchema'],
     };
     if (config.behavior) {
         functionDeclaration['behavior'] = config.behavior;
@@ -2445,53 +2363,6 @@ function mcpToolsToGeminiTool(mcpTools, config = {}) {
     }
     return { functionDeclarations: functionDeclarations };
 }
-// Filters the list schema field to only include fields that are supported by
-// JSONSchema.
-function filterListSchemaField(fieldValue) {
-    const listSchemaFieldValue = [];
-    for (const listFieldValue of fieldValue) {
-        listSchemaFieldValue.push(filterToJsonSchema(listFieldValue));
-    }
-    return listSchemaFieldValue;
-}
-// Filters the dict schema field to only include fields that are supported by
-// JSONSchema.
-function filterDictSchemaField(fieldValue) {
-    const dictSchemaFieldValue = {};
-    for (const [key, value] of Object.entries(fieldValue)) {
-        const valueRecord = value;
-        dictSchemaFieldValue[key] = filterToJsonSchema(valueRecord);
-    }
-    return dictSchemaFieldValue;
-}
-// Filters the schema to only include fields that are supported by JSONSchema.
-function filterToJsonSchema(schema) {
-    const schemaFieldNames = new Set(['items']); // 'additional_properties' to come
-    const listSchemaFieldNames = new Set(['anyOf']); // 'one_of', 'all_of', 'not' to come
-    const dictSchemaFieldNames = new Set(['properties']); // 'defs' to come
-    const filteredSchema = {};
-    for (const [fieldName, fieldValue] of Object.entries(schema)) {
-        if (schemaFieldNames.has(fieldName)) {
-            filteredSchema[fieldName] = filterToJsonSchema(fieldValue);
-        }
-        else if (listSchemaFieldNames.has(fieldName)) {
-            filteredSchema[fieldName] = filterListSchemaField(fieldValue);
-        }
-        else if (dictSchemaFieldNames.has(fieldName)) {
-            filteredSchema[fieldName] = filterDictSchemaField(fieldValue);
-        }
-        else if (fieldName === 'type') {
-            const typeValue = fieldValue.toUpperCase();
-            filteredSchema[fieldName] = Object.values(Type).includes(typeValue)
-                ? typeValue
-                : Type.TYPE_UNSPECIFIED;
-        }
-        else if (supportedJsonSchemaFields.has(fieldName)) {
-            filteredSchema[fieldName] = fieldValue;
-        }
-    }
-    return filteredSchema;
-}
 // Transforms a source input into a BatchJobSource object with validation.
 function tBatchJobSource(apiClient, src) {
     if (typeof src !== 'string' && !Array.isArray(src)) {
@@ -12827,7 +12698,7 @@ const CONTENT_TYPE_HEADER = 'Content-Type';
 const SERVER_TIMEOUT_HEADER = 'X-Server-Timeout';
 const USER_AGENT_HEADER = 'User-Agent';
 const GOOGLE_API_CLIENT_HEADER = 'x-goog-api-client';
-const SDK_VERSION = '1.8.0'; // x-release-please-version
+const SDK_VERSION = '1.9.0'; // x-release-please-version
 const LIBRARY_LABEL = `google-genai-sdk/${SDK_VERSION}`;
 const VERTEX_AI_API_DEFAULT_VERSION = 'v1beta1';
 const GOOGLE_AI_API_DEFAULT_VERSION = 'v1beta';
@@ -13058,7 +12929,14 @@ class ApiClient {
             const abortController = new AbortController();
             const signal = abortController.signal;
             if (httpOptions.timeout && (httpOptions === null || httpOptions === void 0 ? void 0 : httpOptions.timeout) > 0) {
-                setTimeout(() => abortController.abort(), httpOptions.timeout);
+                const timeoutHandle = setTimeout(() => abortController.abort(), httpOptions.timeout);
+                if (timeoutHandle &&
+                    typeof timeoutHandle.unref ===
+                        'function') {
+                    // call unref to prevent nodejs process from hanging, see
+                    // https://nodejs.org/api/timers.html#timeoutunref
+                    timeoutHandle.unref();
+                }
             }
             if (abortSignal) {
                 abortSignal.addEventListener('abort', () => {
@@ -13121,7 +12999,7 @@ class ApiClient {
                         }
                         break;
                     }
-                    const chunkString = decoder.decode(value);
+                    const chunkString = decoder.decode(value, { stream: true });
                     // Parse and throw an error if the chunk contains an error.
                     try {
                         const chunkJson = JSON.parse(chunkString);
@@ -13878,7 +13756,7 @@ class Live {
        if (GOOGLE_GENAI_USE_VERTEXAI) {
          model = 'gemini-2.0-flash-live-preview-04-09';
        } else {
-         model = 'gemini-2.0-flash-live-001';
+         model = 'gemini-live-2.5-flash-preview';
        }
        const session = await ai.live.connect({
          model: model,
@@ -13924,6 +13802,9 @@ class Live {
             let keyName = 'key';
             if (apiKey === null || apiKey === void 0 ? void 0 : apiKey.startsWith('auth_tokens/')) {
                 console.warn('Warning: Ephemeral token support is experimental and may change in future versions.');
+                if (apiVersion !== 'v1alpha') {
+                    console.warn("Warning: The SDK's ephemeral token support is in v1alpha only. Please use const ai = new GoogleGenAI({apiKey: token.name, httpOptions: { apiVersion: 'v1alpha' }}); before session connection.");
+                }
                 method = 'BidiGenerateContentConstrained';
                 keyName = 'access_token';
             }
@@ -14199,7 +14080,7 @@ class Session {
        if (GOOGLE_GENAI_USE_VERTEXAI) {
          model = 'gemini-2.0-flash-live-preview-04-09';
        } else {
-         model = 'gemini-2.0-flash-live-001';
+         model = 'gemini-live-2.5-flash-preview';
        }
        const session = await ai.live.connect({
          model: model,
@@ -14328,6 +14209,7 @@ class Models extends BaseModule {
         this.generateContent = async (params) => {
             var _a, _b, _c, _d, _e;
             const transformedParams = await this.processParamsForMcpUsage(params);
+            this.maybeMoveToResponseJsonSchem(params);
             if (!hasMcpClientTools(params) || shouldDisableAfc(params.config)) {
                 return await this.generateContentInternal(transformedParams);
             }
@@ -14414,6 +14296,7 @@ class Models extends BaseModule {
          * ```
          */
         this.generateContentStream = async (params) => {
+            this.maybeMoveToResponseJsonSchem(params);
             if (shouldDisableAfc(params.config)) {
                 const transformedParams = await this.processParamsForMcpUsage(params);
                 return await this.generateContentStreamInternal(transformedParams);
@@ -14565,6 +14448,24 @@ class Models extends BaseModule {
             return await this.upscaleImageInternal(apiParams);
         };
     }
+    /**
+     * This logic is needed for GenerateContentConfig only.
+     * Previously we made GenerateContentConfig.responseSchema field to accept
+     * unknown. Since v1.9.0, we switch to use backend JSON schema support.
+     * To maintain backward compatibility, we move the data that was treated as
+     * JSON schema from the responseSchema field to the responseJsonSchema field.
+     */
+    maybeMoveToResponseJsonSchem(params) {
+        if (params.config && params.config.responseSchema) {
+            if (!params.config.responseJsonSchema) {
+                if (Object.keys(params.config.responseSchema).includes('$schema')) {
+                    params.config.responseJsonSchema = params.config.responseSchema;
+                    delete params.config.responseSchema;
+                }
+            }
+        }
+        return;
+    }
     /**
      * Transforms the CallableTools in the parameters to be simply Tools, it
      * copies the params into a new object and replaces the tools, it does not
@@ -16625,14 +16526,20 @@ class Tokens extends BaseModule {
      * @experimental
      *
      * @remarks
-     * Ephermeral auth tokens is only supported in the Gemini Developer API.
+     * Ephemeral auth tokens is only supported in the Gemini Developer API.
      * It can be used for the session connection to the Live constrained API.
+     * Support in v1alpha only.
      *
      * @param params - The parameters for the create request.
      * @return The created auth token.
      *
      * @example
      * ```ts
+     * const ai = new GoogleGenAI({
+     *     apiKey: token.name,
+     *     httpOptions: { apiVersion: 'v1alpha' }  // Support in v1alpha only.
+     * });
+     *
      * // Case 1: If LiveEphemeralParameters is unset, unlock LiveConnectConfig
      * // when using the token in Live API sessions. Each session connection can
      * // use a different configuration.