सोच के हस्ताक्षर

सूझ-बूझ वाले मॉडल के सिग्नेचर, मॉडल की इंटरनल थॉट प्रोसेस के एन्क्रिप्टेड वर्शन होते हैं. इनका इस्तेमाल, कई चरणों वाले इंटरैक्शन में तर्क देने के कॉन्टेक्स्ट को बनाए रखने के लिए किया जाता है. Gemini 3 और 2.5 सीरीज़ जैसे सूझ-बूझ वाले मॉडल का इस्तेमाल करने पर, एपीआई, रिस्पॉन्स के कॉन्टेंट वाले हिस्सों (जैसे, text या functionCall वाले हिस्से) में thoughtSignature फ़ील्ड दिखा सकता है.

आम तौर पर, अगर आपको मॉडल के रिस्पॉन्स में सूझ-बूझ वाला मॉडल का सिग्नेचर मिलता है, तो बातचीत के इतिहास को अगले चरण में भेजते समय, आपको उसे ठीक उसी तरह वापस भेजना चाहिए जैसे वह मिला था. Gemini 3 मॉडल का इस्तेमाल करते समय, फ़ंक्शन कॉल करने के दौरान, आपको सूझ-बूझ वाले मॉडल के सिग्नेचर वापस भेजने होंगे. ऐसा न करने पर, आपको पुष्टि से जुड़ी गड़बड़ी मिलेगी (4xx स्टेटस कोड). इसमें Gemini 3 Flash के लिए, minimal थिंकिंग लेवल सेटिंग का इस्तेमाल करना भी शामिल है.

यह कैसे काम करता है

नीचे दी गई इमेज में, Gemini API में फ़ंक्शन कॉल करने के संदर्भ में "टर्न" और "स्टेप" का मतलब दिखाया गया है. "टर्न" का मतलब है, उपयोगकर्ता और मॉडल के बीच बातचीत का एक पूरा चरण. "स्टेप" का मतलब है, मॉडल की ओर से की जाने वाली कोई कार्रवाई या ऑपरेशन. अक्सर, यह किसी टर्न को पूरा करने के लिए, बड़ी प्रोसेस का हिस्सा होता है.

फ़ंक्शन कॉल करने के टर्न और चरणों का डायग्राम

इस दस्तावेज़ में, Gemini 3 मॉडल के लिए फ़ंक्शन कॉल करने की सुविधा को मैनेज करने के बारे में बताया गया है. 2.5 मॉडल के साथ काम करने में होने वाली गड़बड़ियों के बारे में जानने के लिए, मॉडल के व्यवहार वाला सेक्शन देखें.

Gemini 3, फ़ंक्शन कॉल वाले मॉडल के सभी रिस्पॉन्स (एपीआई से मिलने वाले रिस्पॉन्स) के लिए, सूझ-बूझ वाले मॉडल के सिग्नेचर दिखाता है. सूझ-बूझ वाले मॉडल के सिग्नेचर इन मामलों में दिखते हैं:

नीचे दी गई टेबल में, कई चरणों वाले फ़ंक्शन कॉल के बारे में बताया गया है. इसमें टर्न और स्टेप की परिभाषाओं को, ऊपर बताए गए सिग्नेचर के कॉन्सेप्ट के साथ जोड़ा गया है:

टर्न

स्टेप

उपयोगकर्ता का अनुरोध

मॉडल का रिस्पॉन्स

FunctionResponse

1

1

request1 = user_prompt FC1 + signature FR1

1

2

request2 = request1 + (FC1 + signature) + FR1 FC2 + signature FR2

1

3

request3 = request2 + (FC2 + signature) + FR2 text_output

(no FCs)

कोई नहीं

फ़ंक्शन कॉल वाले हिस्सों में सिग्नेचर

जब Gemini कोई functionCall जनरेट करता है, तो वह अगले टर्न में टूल के आउटपुट को सही तरीके से प्रोसेस करने के लिए, thought_signature पर निर्भर करता है.

  • व्यवहार:
    • एक फ़ंक्शन कॉल: functionCall वाले हिस्से में, thought_signature शामिल होगा.
    • एक साथ कई फ़ंक्शन कॉल: अगर मॉडल, रिस्पॉन्स में एक साथ कई फ़ंक्शन कॉल जनरेट करता है , तो thought_signature सिर्फ़ पहलेवाले हिस्से से अटैच होता है functionCall. एक ही रिस्पॉन्स में, इसके बाद के functionCall वाले हिस्सों में सिग्नेचर नहीं होगा.
  • ज़रूरी शर्तें: बातचीत के इतिहास को वापस भेजते समय, आपको इस सिग्नेचर को ठीक उसी हिस्से में वापस भेजना होगा जिसमें यह मिला था.
  • पुष्टि: मौजूदा टर्न में किए गए सभी फ़ंक्शन कॉल के लिए, सख्त पुष्टि लागू की जाती है . (सिर्फ़ मौजूदा टर्न की पुष्टि ज़रूरी है. हम पिछले टर्न की पुष्टि नहीं करते)
    • एपीआई, इतिहास में पीछे जाकर (सबसे नए से सबसे पुराने) उपयोगकर्ता का वह सबसे नया मैसेज ढूंढता है जिसमें स्टैंडर्ड कॉन्टेंट (जैसे, text) शामिल हो. यह मौजूदा टर्न की शुरुआत होती है. यह functionResponse be होगा.
    • उपयोगकर्ता के उस मैसेज के बाद होने वाले, मॉडल के सभी functionCall टर्न को, टर्न का हिस्सा माना जाता है.
    • मौजूदा टर्न के हर स्टेप में, पहले functionCall वाले हिस्से में उसका thought_signature शामिल होना चाहिए.
    • अगर मौजूदा टर्न के किसी भी स्टेप में, पहले functionCall वाले हिस्से के लिए thought_signature शामिल नहीं किया जाता है, तो अनुरोध 400 गड़बड़ी के साथ पूरा नहीं होगा.
  • अगर सही सिग्नेचर वापस नहीं भेजे जाते हैं, तो आपको इस तरह की गड़बड़ी दिखेगी
    • Gemini 3 मॉडल: सिग्नेचर शामिल न करने पर, 400 गड़बड़ी दिखेगी. यह गड़बड़ी इस फ़ॉर्मैट में दिखेगी:
      • <index of contents array> कॉन्टेंट ब्लॉक में मौजूद, फ़ंक्शन कॉल <Function Call> में thought_signature शामिल नहीं है. उदाहरण के लिए, फ़ंक्शन कॉल FC1 कॉन्टेंट ब्लॉक में मौजूद 1. में thought_signature शामिल नहीं है.

क्रम से फ़ंक्शन कॉल करने का उदाहरण

इस सेक्शन में, एक से ज़्यादा फ़ंक्शन कॉल का उदाहरण दिखाया गया है. इसमें उपयोगकर्ता, कोई मुश्किल सवाल पूछता है जिसके लिए कई टास्क पूरे करने पड़ते हैं.

आइए, कई टर्न वाले फ़ंक्शन कॉल का एक उदाहरण देखते हैं. इसमें उपयोगकर्ता, कोई मुश्किल सवाल पूछता है जिसके लिए कई टास्क पूरे करने पड़ते हैं: "Check flight status for AA100 and book a taxi if delayed".

टर्न

स्टेप

उपयोगकर्ता का अनुरोध

मॉडल का रिस्पॉन्स

FunctionResponse

1

1

request1="Check flight status for AA100 and book a taxi 2 hours before if delayed." FC1 ("check_flight") + signature FR1

1

2

request2 = request1 + FC1 ("check_flight") + signature + FR1 FC2("book_taxi") + signature FR2

1

3

request3 = request2 + FC2 ("book_taxi") + signature + FR2 text_output

(no FCs)

None

नीचे दिए गए कोड में, ऊपर दी गई टेबल में मौजूद क्रम दिखाया गया है.

टर्न 1, स्टेप 1 (उपयोगकर्ता का अनुरोध)

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "check_flight",
          "description": "Gets the current status of a flight",
          "parameters": {
            "type": "object",
            "properties": {
              "flight": {
                "type": "string",
                "description": "The flight number to check"
              }
            },
            "required": [
              "flight"
            ]
          }
        },
        {
          "name": "book_taxi",
          "description": "Book a taxi",
          "parameters": {
            "type": "object",
            "properties": {
              "time": {
                "type": "string",
                "description": "time to book the taxi"
              }
            },
            "required": [
              "time"
            ]
          }
        }
      ]
    }
  ]
}

टर्न 1, स्टेप 1 (मॉडल का रिस्पॉन्स)

{
"content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<Signature A>"
          }
        ]
  }
}

टर्न 1, स्टेप 2 (उपयोगकर्ता का रिस्पॉन्स - टूल के आउटपुट भेजना) इस उपयोगकर्ता के टर्न में सिर्फ़ functionResponse (कोई नया टेक्स्ट नहीं) शामिल है. इसलिए, हम अब भी टर्न 1 में हैं. हमें <Signature_A> को बनाए रखना होगा.

{
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    },
    {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<Signature A>" //Required and Validated
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "check_flight",
              "response": {
                "status": "delayed",
                "departure_time": "12 PM"
                }
              }
            }
        ]
}

टर्न 1, स्टेप 2 (मॉडल) मॉडल अब पिछले टूल के आउटपुट के आधार पर टैक्सी बुक करने का फ़ैसला लेता है.

{
      "content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "book_taxi",
              "args": {
                "time": "10 AM"
              }
            },
            "thoughtSignature": "<Signature B>"
          }
        ]
      }
}

टर्न 1, स्टेप 3 (उपयोगकर्ता - टूल का आउटपुट भेजना) टैक्सी बुकिंग की पुष्टि भेजने के लिए, हमें इस लूप में सभी फ़ंक्शन कॉल के लिए सिग्नेचर (<Signature A> + <Signature B>) शामिल करने होंगे.

{
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    },
    {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<Signature A>" //Required and Validated
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "check_flight",
              "response": {
                "status": "delayed",
                "departure_time": "12 PM"
              }
              }
            }
        ]
      },
      {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "book_taxi",
              "args": {
                "time": "10 AM"
              }
            },
            "thoughtSignature": "<Signature B>" //Required and Validated
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "book_taxi",
              "response": {
                "booking_status": "success"
              }
              }
            }
        ]
    }
}

एक साथ कई फ़ंक्शन कॉल करने का उदाहरण

आइए, एक साथ कई फ़ंक्शन कॉल करने का एक उदाहरण देखते हैं. इसमें उपयोगकर्ता "Check weather in Paris and London" सवाल पूछता है, ताकि यह देखा जा सके कि मॉडल कहां पुष्टि करता है.

टर्न

स्टेप

उपयोगकर्ता का अनुरोध

मॉडल का रिस्पॉन्स

FunctionResponse

1

1

request1="Check the weather in Paris and London"

FC1 ("Paris") + signature

FC2 ("London")

FR1

1

2

request 2 = request1 + FC1 ("Paris") + signature + FC2 ("London")

text_output

(no FCs)

कोई नहीं

नीचे दिए गए कोड में, ऊपर दी गई टेबल में मौजूद क्रम दिखाया गया है.

टर्न 1, स्टेप 1 (उपयोगकर्ता का अनुरोध)

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check the weather in Paris and London."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "get_current_temperature",
          "description": "Gets the current temperature for a given location.",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city name, e.g. San Francisco"
              }
            },
            "required": [
              "location"
            ]
          }
        }
      ]
    }
  ]
}

टर्न 1, स्टेप 1 (मॉडल का रिस्पॉन्स)

{
  "content": {
    "parts": [
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "location": "Paris"
          }
        },
        "thoughtSignature": "<Signature_A>"// INCLUDED on First FC
      },
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "location": "London"
          }// NO signature on subsequent parallel FCs
        }
      }
    ]
  }
}

टर्न 1, स्टेप 2 (उपयोगकर्ता का रिस्पॉन्स - टूल के आउटपुट भेजना) हमें पहले हिस्से में <Signature_A> को ठीक उसी तरह बनाए रखना होगा जैसे वह मिला था.

[
  {
    "role": "user",
    "parts": [
      {
        "text": "Check the weather in Paris and London."
      }
    ]
  },
  {
    "role": "model",
    "parts": [
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "city": "Paris"
          }
        },
        "thought_signature": "<Signature_A>" // MUST BE INCLUDED
      },
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "city": "London"
          }
        }
      } // NO SIGNATURE FIELD
    ]
  },
  {
    "role": "user",
    "parts": [
      {
        "functionResponse": {
          "name": "get_current_temperature",
          "response": {
            "temp": "15C"
          }
        }
      },
      {
        "functionResponse": {
          "name": "get_current_temperature",
          "response": {
            "temp": "12C"
          }
        }
      }
    ]
  }
]

functionCall वाले हिस्सों के अलावा अन्य हिस्सों में सिग्नेचर

Gemini, फ़ंक्शन कॉल वाले हिस्सों के अलावा अन्य हिस्सों में भी, रिस्पॉन्स के आखिरी हिस्से में thought_signatures दिखा सकता है.

  • व्यवहार: मॉडल के आखिरी कॉन्टेंट वाले हिस्से (text, inlineData…) में, thought_signature शामिल हो सकता है.
  • सुझाव: इन सिग्नेचर को वापस भेजने का सुझाव दिया जाता है. इससे यह पक्का किया जा सकता है कि मॉडल, उच्च क्वालिटी वाले तर्क बनाए रखे. खास तौर पर, मुश्किल निर्देशों का पालन करने या एजेंटिक वर्कफ़्लो को सिम्युलेट करने के लिए.
  • पुष्टि: एपीआई, पुष्टि को सख्ती से लागू नहीं करता. अगर इन्हें शामिल नहीं किया जाता है, तो आपको कोई गड़बड़ी नहीं मिलेगी. हालांकि, परफ़ॉर्मेंस कम हो सकती है.

टेक्स्ट/कॉन्टेक्स्ट में तर्क (पुष्टि नहीं की जाती)

टर्न 1, स्टेप 1 (मॉडल का रिस्पॉन्स)

{
  "role": "model",
  "parts": [
    {
      "text": "I need to calculate the risk. Let me think step-by-step...",
      "thought_signature": "<Signature_C>" // OPTIONAL (Recommended)
    }
  ]
}

टर्न 2, स्टेप 1 (उपयोगकर्ता)

[
  { "role": "user", "parts": [{ "text": "What is the risk?" }] },
  {
    "role": "model", 
    "parts": [
      {
        "text": "I need to calculate the risk. Let me think step-by-step...",
        // If you omit <Signature_C> here, no error will occur.
      }
    ]
  },
  { "role": "user", "parts": [{ "text": "Summarize it." }] }
]

OpenAI के साथ काम करने के लिए सिग्नेचर

यहां दिए गए उदाहरण में, OpenAI के साथ काम करने की सुविधा का इस्तेमाल करके, चैट पूरा करने वाले एपीआई के लिए, सूझ-बूझ वाले मॉडल के सिग्नेचर को मैनेज करने का तरीका दिखाया गया है.

क्रम से फ़ंक्शन कॉल करने का उदाहरण

यह एक से ज़्यादा फ़ंक्शन कॉल करने का उदाहरण है. इसमें उपयोगकर्ता, कोई मुश्किल सवाल पूछता है जिसके लिए कई टास्क पूरे करने पड़ते हैं.

आइए, कई टर्न वाले फ़ंक्शन कॉल का एक उदाहरण देखते हैं. इसमें उपयोगकर्ता, Check flight status for AA100 and book a taxi if delayed सवाल पूछता है. इससे आपको पता चलेगा कि जब उपयोगकर्ता, कोई मुश्किल सवाल पूछता है जिसके लिए कई टास्क पूरे करने पड़ते हैं, तो क्या होता है.

टर्न

स्टेप

उपयोगकर्ता का अनुरोध

मॉडल का रिस्पॉन्स

FunctionResponse

1

1

request1 = "Check flight status for AA100 and book a taxi 2 hours before if delayed." FC1 ("check_flight") + signature FR1

1

2

request2 = request1 + FC1 ("check_flight") + signature + FR1 FC2("book_taxi") + signature FR2

1

3

request3 = request2 + FC2 ("book_taxi") + signature + FR2 text_output

(no FCs)

None

नीचे दिए गए कोड में, दिए गए क्रम के बारे में बताया गया है.

टर्न 1, स्टेप 1 (उपयोगकर्ता का अनुरोध)

{
  "model": "google/gemini-3.1-pro-preview",
  "messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "check_flight",
        "description": "Gets the current status of a flight",
        "parameters": {
          "type": "object",
          "properties": {
            "flight": {
              "type": "string",
              "description": "The flight number to check."
            }
          },
          "required": [
            "flight"
          ]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "book_taxi",
        "description": "Book a taxi",
        "parameters": {
          "type": "object",
          "properties": {
            "time": {
              "type": "string",
              "description": "time to book the taxi"
            }
          },
          "required": [
            "time"
          ]
        }
      }
    }
  ]
}

टर्न 1, स्टेप 1 (मॉडल का रिस्पॉन्स)

{
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<Signature A>"
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1",
            "type": "function"
          }
        ]
    }

टर्न 1, स्टेप 2 (उपयोगकर्ता का रिस्पॉन्स - टूल के आउटपुट भेजना)

इस उपयोगकर्ता के टर्न में सिर्फ़ functionResponse (कोई नया टेक्स्ट नहीं) शामिल है. इसलिए, हम अब भी टर्न 1 में हैं. हमें <Signature_A> को बनाए रखना होगा.

"messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<Signature A>" //Required and Validated
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "check_flight",
      "tool_call_id": "function-call-1",
      "content": "{\"status\":\"delayed\",\"departure_time\":\"12 PM\"}"                 
    }
  ]

टर्न 1, स्टेप 2 (मॉडल)

मॉडल अब पिछले टूल के आउटपुट के आधार पर टैक्सी बुक करने का फ़ैसला लेता है.

{
"role": "model",
"tool_calls": [
{
"extra_content": {
"google": {
"thought_signature": "<Signature B>"
}
            },
            "function": {
              "arguments": "{\"time\":\"10 AM\"}",
              "name": "book_taxi"
            },
            "id": "function-call-2",
            "type": "function"
          }
       ]
}

टर्न 1, स्टेप 3 (उपयोगकर्ता - टूल का आउटपुट भेजना)

टैक्सी बुकिंग की पुष्टि भेजने के लिए, हमें इस लूप में सभी फ़ंक्शन कॉल के लिए सिग्नेचर (<Signature A> + <Signature B>) शामिल करने होंगे.

"messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<Signature A>" //Required and Validated
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1d6a1a61-6f4f-4029-80ce-61586bd86da5",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "check_flight",
      "tool_call_id": "function-call-1d6a1a61-6f4f-4029-80ce-61586bd86da5",
      "content": "{\"status\":\"delayed\",\"departure_time\":\"12 PM\"}"                 
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<Signature B>" //Required and Validated
              }
            },
            "function": {
              "arguments": "{\"time\":\"10 AM\"}",
              "name": "book_taxi"
            },
            "id": "function-call-65b325ba-9b40-4003-9535-8c7137b35634",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "book_taxi",
      "tool_call_id": "function-call-65b325ba-9b40-4003-9535-8c7137b35634",
      "content": "{\"booking_status\":\"success\"}"
    }
  ]

एक साथ कई फ़ंक्शन कॉल करने का उदाहरण

आइए, एक साथ कई फ़ंक्शन कॉल करने का एक उदाहरण देखते हैं. इसमें उपयोगकर्ता "Check weather in Paris and London" सवाल पूछता है. इससे आपको पता चलेगा कि मॉडल कहां पुष्टि करता है.

टर्न

स्टेप

उपयोगकर्ता का अनुरोध

मॉडल का रिस्पॉन्स

FunctionResponse

1

1

request1="Check the weather in Paris and London" FC1 ("Paris") + signature

FC2 ("London")

FR1

1

2

request 2 = request1 + FC1 ("Paris") + signature + FC2 ("London") text_output

(no FCs)

None

यहां दिए गए क्रम के बारे में बताने वाला कोड दिया गया है.

टर्न 1, स्टेप 1 (उपयोगकर्ता का अनुरोध)

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check the weather in Paris and London."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "get_current_temperature",
          "description": "Gets the current temperature for a given location.",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city name, e.g. San Francisco"
              }
            },
            "required": [
              "location"
            ]
          }
        }
      ]
    }
  ]
}

टर्न 1, स्टेप 1 (मॉडल का रिस्पॉन्स)

{
"role": "assistant",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<Signature A>" //Signature returned
              }
            },
            "function": {
              "arguments": "{\"location\":\"Paris\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
            "type": "function"
          },
          {
            "function": {
              "arguments": "{\"location\":\"London\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
            "type": "function" // No signature on Parallel FC
          }
        ]
}

टर्न 1, स्टेप 2 (उपयोगकर्ता का रिस्पॉन्स - टूल के आउटपुट भेजना)

आपको पहले हिस्से में <Signature_A> को ठीक उसी तरह बनाए रखना होगा जैसे वह मिला था.

"messages": [
    {
      "role": "user",
      "content": "Check the weather in Paris and London."
    },
    {
      "role": "assistant",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<Signature A>" //Required
              }
            },
            "function": {
              "arguments": "{\"location\":\"Paris\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
            "type": "function"
          },
          {
            "function": { //No Signature
              "arguments": "{\"location\":\"London\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
            "type": "function"
          }
        ]
    },
    {
      "role":"tool",
      "name": "get_current_temperature",
      "tool_call_id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
      "content": "{\"temp\":\"15C\"}"
    },    
    {
      "role":"tool",
      "name": "get_current_temperature",
      "tool_call_id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
      "content": "{\"temp\":\"12C\"}"
    }
  ]

अक्सर पूछे जाने वाले सवाल

  1. मौजूदा टर्न और स्टेप में, फ़ंक्शन कॉल वाले हिस्से के साथ, किसी दूसरे मॉडल से Gemini 3 में इतिहास कैसे ट्रांसफ़र किया जा सकता है? मुझे फ़ंक्शन कॉल वाले ऐसे हिस्से देने हैं जो एपीआई से जनरेट नहीं किए गए थे. इसलिए, उनसे जुड़ा कोई सूझ-बूझ वाला मॉडल का सिग्नेचर नहीं है?

    अनुरोध में, पसंद के मुताबिक फ़ंक्शन कॉल ब्लॉक शामिल करने का सुझाव नहीं दिया जाता. हालांकि, ऐसे मामले जहां इसे टाला नहीं जा सकता. जैसे, मॉडल को फ़ंक्शन कॉल और रिस्पॉन्स के बारे में जानकारी देना. यह जानकारी, क्लाइंट ने तय तरीके से दी है या किसी दूसरे मॉडल से ट्रेस ट्रांसफ़र करना. इस ट्रेस में, सूझ-बूझ वाले मॉडल के सिग्नेचर शामिल नहीं हैं. ऐसे में, पुष्टि की प्रोसेस को स्किप करने के लिए, सूझ-बूझ वाले मॉडल के सिग्नेचर वाले फ़ील्ड में, "context_engineering_is_the_way_to_go" या "skip_thought_signature_validator" में से कोई एक डमी सिग्नेचर सेट किया जा सकता है.

  2. मैं एक साथ कई फ़ंक्शन कॉल और रिस्पॉन्स वापस भेज रहा हूं. हालांकि, एपीआई 400 गड़बड़ी दिखा रहा है. ऐसा क्यों हो रहा है?

    जब एपीआई, एक साथ कई फ़ंक्शन कॉल "FC1 + signature, FC2" दिखाता है, तो उपयोगकर्ता के रिस्पॉन्स के तौर पर "FC1+ signature, FC2, FR1, FR2" की उम्मीद की जाती है. अगर आपने इन्हें "FC1 + signature, FR1, FC2, FR2" के तौर पर इंटरलीव किया है, तो एपीआई 400 गड़बड़ी दिखाएगा.

  3. स्ट्रीमिंग के दौरान, अगर मॉडल कोई फ़ंक्शन कॉल वापस नहीं भेज रहा है, तो मुझे सूझ-बूझ वाला मॉडल का सिग्नेचर नहीं मिल रहा है

    स्ट्रीमिंग अनुरोध के साथ, मॉडल के ऐसे रिस्पॉन्स के दौरान जिसमें कोई एफसी शामिल नहीं है, मॉडल, खाली टेक्स्ट कॉन्टेंट वाले हिस्से में सूझ-बूझ वाला मॉडल का सिग्नेचर दिखा सकता है. सलाह दी जाती है कि मॉडल से finish_reason मिलने तक, पूरे अनुरोध को पार्स करें.

अलग-अलग मॉडल के लिए सूझ-बूझ वाले मॉडल के सिग्नेचर

Gemini 3 मॉडल और Gemini 2.5 मॉडल फ़ंक्शन कॉल में सूझ-बूझ वाले मॉडल के सिग्नेचर के साथ अलग-अलग तरीके से काम करते हैं:

  • अगर किसी रिस्पॉन्स में फ़ंक्शन कॉल शामिल हैं, तो
    • Gemini 3 में, फ़ंक्शन कॉल वाले पहले हिस्से में हमेशा सिग्नेचर होगा. उस हिस्से को वापस भेजना ज़रूरी है.
    • Gemini 2.5 में, पहले हिस्से में सिग्नेचर होगा (टाइप के बावजूद). उस हिस्से को वापस भेजना ज़रूरी नहीं है.
  • अगर किसी रिस्पॉन्स में फ़ंक्शन कॉल शामिल नहीं हैं, तो
    • अगर मॉडल कोई सूझ-बूझ वाला मॉडल जनरेट करता है, तो Gemini 3 में, आखिरी हिस्से में सिग्नेचर होगा.
    • Gemini 2.5 में, किसी भी हिस्से में सिग्नेचर नहीं होगा.

तुलना से जुड़ी ज़्यादा जानकारी के लिए, सूझ-बूझ वाला मॉडल पेज देखें. Gemini 3 इमेज मॉडल के लिए, इमेज जनरेट करने के गाइड का सूझ-बूझ वाली प्रोसेस सेक्शन देखें.