सूझ-बूझ वाले मॉडल के सिग्नेचर, मॉडल की इंटरनल थॉट प्रोसेस के एन्क्रिप्टेड वर्शन होते हैं. इनका इस्तेमाल, कई चरणों वाले इंटरैक्शन में, तर्क देने के कॉन्टेक्स्ट को बनाए रखने के लिए किया जाता है.
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
|
कोई नहीं |
फ़ंक्शन कॉल वाले हिस्सों में सिग्नेचर
जब Gemini, functionCall जनरेट करता है, तो वह अगले राउंड में टूल के आउटपुट को सही तरीके से प्रोसेस करने के लिए, thought_signature पर निर्भर करता है.
- व्यवहार:
- एक फ़ंक्शन कॉल:
functionCallवाले हिस्से में,thought_signatureशामिल होगा. - एक साथ कई फ़ंक्शन कॉल: अगर मॉडल, रिस्पॉन्स में एक साथ कई फ़ंक्शन कॉल जनरेट करता है
, तो
thought_signatureसिर्फ़ पहलेवाले हिस्से से अटैच होता हैfunctionCall. एक ही रिस्पॉन्स में, इसके बाद केfunctionCallवाले हिस्सों में सिग्नेचर नहीं होगा.
- एक फ़ंक्शन कॉल:
- ज़रूरी शर्तें: बातचीत का इतिहास वापस भेजते समय, आपको इस सिग्नेचर को ठीक उसी हिस्से में वापस भेजना होगा जिसमें यह मिला था.
- पुष्टि: मौजूदा राउंड में किए गए सभी फ़ंक्शन कॉल के लिए, सख्त पुष्टि लागू की जाती है . (सिर्फ़ मौजूदा राउंड की पुष्टि ज़रूरी है. हम पिछले राउंड की पुष्टि नहीं करते)
- एपीआई, इतिहास में पीछे जाता है (सबसे नए से सबसे पुराने तक), ताकि उपयोगकर्ता का वह सबसे नया मैसेज ढूंढा जा सके जिसमें स्टैंडर्ड कॉन्टेंट (जैसे,
text) शामिल हो. यह मौजूदा राउंड की शुरुआत होगी. यहfunctionResponsebe होगा. - उपयोगकर्ता के उस मैसेज के बाद होने वाले मॉडल के
functionCallवाले सभी राउंड, उस राउंड का हिस्सा माने जाते हैं. - मौजूदा राउंड के हर चरण में, पहले
functionCallवाले हिस्से में उसकाthought_signatureशामिल होना चाहिए. - अगर मौजूदा राउंड के किसी भी चरण में, पहले
functionCallवाले हिस्से के लिएthought_signatureशामिल नहीं किया जाता है, तो अनुरोध 400 गड़बड़ी के साथ पूरा नहीं होगा.
- एपीआई, इतिहास में पीछे जाता है (सबसे नए से सबसे पुराने तक), ताकि उपयोगकर्ता का वह सबसे नया मैसेज ढूंढा जा सके जिसमें स्टैंडर्ड कॉन्टेंट (जैसे,
- अगर सही सिग्नेचर वापस नहीं भेजे जाते हैं, तो आपको गड़बड़ी का मैसेज इस तरह दिखेगा
- Gemini 3 मॉडल: सिग्नेचर शामिल न करने पर, 400 गड़बड़ी मिलेगी. मैसेज इस फ़ॉर्म में होगा:
<index of contents array>कॉन्टेंट ब्लॉक में, फ़ंक्शन कॉल<Function Call>मेंthought_signatureमौजूद नहीं है. उदाहरण के लिए, फ़ंक्शन कॉलFC1कॉन्टेंट ब्लॉक में,1.मेंthought_signatureमौजूद नहीं है.
- Gemini 3 मॉडल: सिग्नेचर शामिल न करने पर, 400 गड़बड़ी मिलेगी. मैसेज इस फ़ॉर्म में होगा:
क्रम से फ़ंक्शन कॉल करने का उदाहरण
इस सेक्शन में, एक से ज़्यादा फ़ंक्शन कॉल का उदाहरण दिखाया गया है. इसमें उपयोगकर्ता, एक मुश्किल सवाल पूछता है जिसके लिए कई टास्क पूरे करने पड़ते हैं.
आइए, कई राउंड वाले फ़ंक्शन कॉल का एक उदाहरण देखते हैं. इसमें उपयोगकर्ता, एक मुश्किल सवाल पूछता है जिसके लिए कई टास्क पूरे करने पड़ते हैं: "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
|
None |
नीचे दिए गए कोड में, ऊपर दी गई टेबल में मौजूद क्रम दिखाया गया है.
पहला राउंड, पहला चरण (उपयोगकर्ता का अनुरोध)
{
"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"
]
}
}
]
}
]
}
पहला राउंड, पहला चरण (मॉडल का रिस्पॉन्स)
{
"content": {
"role": "model",
"parts": [
{
"functionCall": {
"name": "check_flight",
"args": {
"flight": "AA100"
}
},
"thoughtSignature": "<Signature A>"
}
]
}
}
पहला राउंड, दूसरा चरण (उपयोगकर्ता का रिस्पॉन्स - टूल के आउटपुट भेजना) इस राउंड में, उपयोगकर्ता के रिस्पॉन्स में सिर्फ़ functionResponse शामिल है. इसमें कोई नया टेक्स्ट नहीं है. इसलिए, हम अब भी पहले राउंड में हैं. हमें
<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"
}
}
}
]
}
पहला राउंड, दूसरा चरण (मॉडल) मॉडल अब टूल के पिछले आउटपुट के आधार पर टैक्सी बुक करने का फ़ैसला लेता है.
{
"content": {
"role": "model",
"parts": [
{
"functionCall": {
"name": "book_taxi",
"args": {
"time": "10 AM"
}
},
"thoughtSignature": "<Signature B>"
}
]
}
}
पहला राउंड, तीसरा चरण (उपयोगकर्ता - टूल का आउटपुट भेजना) टैक्सी बुकिंग
की पुष्टि भेजने के लिए, हमें इस लूप में सभी फ़ंक्शन कॉल के लिए सिग्नेचर शामिल करने होंगे
(<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) |
None |
नीचे दिए गए कोड में, ऊपर दी गई टेबल में मौजूद क्रम दिखाया गया है.
पहला राउंड, पहला चरण (उपयोगकर्ता का अनुरोध)
{
"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"
]
}
}
]
}
]
}
पहला राउंड, पहला चरण (मॉडल का रिस्पॉन्स)
{
"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
}
}
]
}
}
पहला राउंड, दूसरा चरण (उपयोगकर्ता का रिस्पॉन्स - टूल के आउटपुट भेजना) हमें पहले हिस्से में,
<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शामिल हो सकता है. - सुझाव: इन सिग्नेचर को वापस भेजने का सुझाव दिया जाता है. इससे यह पक्का किया जा सकेगा कि मॉडल, उच्च क्वालिटी वाले गहराई से विश्लेषण बनाए रखे. खास तौर पर, मुश्किल निर्देशों का पालन करने या एजेंटिक वर्कफ़्लो को सिम्युलेट करने के लिए.
- पुष्टि: एपीआई, पुष्टि को सख्ती से लागू नहीं करता. अगर इन्हें शामिल नहीं किया जाता है, तो आपको ब्लॉक करने वाली गड़बड़ी नहीं मिलेगी. हालांकि, परफ़ॉर्मेंस कम हो सकती है.
टेक्स्ट/कॉन्टेक्स्ट में तर्क (पुष्टि नहीं की जाती)
पहला राउंड, पहला चरण (मॉडल का रिस्पॉन्स)
{
"role": "model",
"parts": [
{
"text": "I need to calculate the risk. Let me think step-by-step...",
"thought_signature": "<Signature_C>" // OPTIONAL (Recommended)
}
]
}
दूसरा राउंड, पहला चरण (उपयोगकर्ता)
[
{ "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 के साथ काम करने के लिए सिग्नेचर
क्रम से फ़ंक्शन कॉल करने का उदाहरण
यह एक से ज़्यादा फ़ंक्शन कॉल करने का उदाहरण है. इसमें उपयोगकर्ता, एक मुश्किल सवाल पूछता है जिसके लिए कई टास्क पूरे करने पड़ते हैं.
आइए, कई राउंड वाले फ़ंक्शन कॉल का एक उदाहरण देखते हैं. इसमें उपयोगकर्ता,
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
|
None |
नीचे दिए गए कोड में, दिए गए क्रम के बारे में बताया गया है.
पहला राउंड, पहला चरण (उपयोगकर्ता का अनुरोध)
{
"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"
]
}
}
}
]
}
पहला राउंड, पहला चरण (मॉडल का रिस्पॉन्स)
{
"role": "model",
"tool_calls": [
{
"extra_content": {
"google": {
"thought_signature": "<Signature A>"
}
},
"function": {
"arguments": "{\"flight\":\"AA100\"}",
"name": "check_flight"
},
"id": "function-call-1",
"type": "function"
}
]
}
पहला राउंड, दूसरा चरण (उपयोगकर्ता का रिस्पॉन्स - टूल के आउटपुट भेजना)
इस राउंड में, उपयोगकर्ता के रिस्पॉन्स में सिर्फ़ functionResponse शामिल है. इसमें कोई नया टेक्स्ट नहीं है. इसलिए, हम अब भी पहले राउंड में हैं. हमें <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\"}"
}
]
पहला राउंड, दूसरा चरण (मॉडल)
मॉडल अब टूल के पिछले आउटपुट के आधार पर टैक्सी बुक करने का फ़ैसला लेता है.
{
"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"
}
]
}
पहला राउंड, तीसरा चरण (उपयोगकर्ता - टूल का आउटपुट भेजना)
टैक्सी बुकिंग की पुष्टि भेजने के लिए, हमें इस लूप में सभी
फ़ंक्शन कॉल के लिए सिग्नेचर शामिल करने होंगे (<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
|
FR1 |
1 |
2 |
request 2 = request1 + FC1 ("Paris") + signature + FC2 ("London") |
text_output
|
None |
दिए गए क्रम के बारे में जानने के लिए, यहां कोड दिया गया है.
पहला राउंड, पहला चरण (उपयोगकर्ता का अनुरोध)
{
"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"
]
}
}
]
}
]
}
पहला राउंड, पहला चरण (मॉडल का रिस्पॉन्स)
{
"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
}
]
}
पहला राउंड, दूसरा चरण (उपयोगकर्ता का रिस्पॉन्स - टूल के आउटपुट भेजना)
आपको पहले हिस्से में, <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\"}"
}
]
अक्सर पूछे जाने वाले सवाल
मौजूदा राउंड और चरण में, फ़ंक्शन कॉल वाले हिस्से के साथ, किसी दूसरे मॉडल से Gemini 3 में इतिहास कैसे ट्रांसफ़र किया जा सकता है? मुझे फ़ंक्शन कॉल वाले ऐसे हिस्से देने हैं जो एपीआई से जनरेट नहीं किए गए थे. इसलिए, उनसे जुड़ा कोई सूझ-बूझ वाला मॉडल का सिग्नेचर नहीं है?
अनुरोध में, पसंद के मुताबिक फ़ंक्शन कॉल ब्लॉक शामिल करने का सुझाव नहीं दिया जाता. हालांकि, ऐसे मामले जहां इसे टाला नहीं जा सकता. जैसे, मॉडल को फ़ंक्शन कॉल और रिस्पॉन्स के बारे में जानकारी देना. ये रिस्पॉन्स, क्लाइंट की ओर से तय तरीके से जनरेट किए गए थे या किसी दूसरे मॉडल से ट्रेस ट्रांसफ़र करना. इसमें सूझ-बूझ वाले मॉडल के सिग्नेचर शामिल नहीं हैं. ऐसे में, पुष्टि की प्रोसेस को स्किप करने के लिए, सूझ-बूझ वाले मॉडल के सिग्नेचर वाले फ़ील्ड में,
"context_engineering_is_the_way_to_go"या"skip_thought_signature_validator"में से कोई एक डमी सिग्नेचर सेट किया जा सकता है.मैं एक साथ कई फ़ंक्शन कॉल और रिस्पॉन्स वापस भेज रहा/रही हूं और एपीआई, 400 गड़बड़ी दिखा रहा है. ऐसा क्यों हो रहा है?
जब एपीआई, एक साथ कई फ़ंक्शन कॉल "FC1 + signature, FC2" दिखाता है, तो उपयोगकर्ता के रिस्पॉन्स में "FC1+ signature, FC2, FR1, FR2" होना चाहिए. अगर आपने इन्हें "FC1 + signature, FR1, FC2, FR2" के तौर पर इंटरलीव किया है, तो एपीआई, 400 गड़बड़ी दिखाएगा.
स्ट्रीमिंग के दौरान, अगर मॉडल कोई फ़ंक्शन कॉल नहीं दिखा रहा है, तो मुझे सूझ-बूझ वाला मॉडल का सिग्नेचर नहीं मिल रहा है
स्ट्रीमिंग अनुरोध के साथ, मॉडल के ऐसे रिस्पॉन्स के दौरान जिसमें कोई एफसी शामिल नहीं है, मॉडल, खाली टेक्स्ट कॉन्टेंट वाले हिस्से में, सूझ-बूझ वाला मॉडल का सिग्नेचर दिखा सकता है. हमारा सुझाव है कि मॉडल से
finish_reasonमिलने तक, पूरे अनुरोध को पार्स करें.
अलग-अलग मॉडल के लिए सूझ-बूझ वाले मॉडल के सिग्नेचर
Gemini 3 मॉडल और Gemini 2.5 मॉडल फ़ंक्शन कॉल में सूझ-बूझ वाले मॉडल के सिग्नेचर के साथ अलग-अलग तरीके से काम करते हैं:
- अगर किसी रिस्पॉन्स में फ़ंक्शन कॉल शामिल हैं, तो
- Gemini 3 में, फ़ंक्शन कॉल वाले पहले हिस्से में हमेशा सिग्नेचर होगा. उस हिस्से को वापस भेजना ज़रूरी है.
- Gemini 2.5 में, पहले हिस्से में सिग्नेचर होगा (टाइप के बावजूद). उस हिस्से को वापस भेजना ज़रूरी नहीं है.
- अगर किसी रिस्पॉन्स में फ़ंक्शन कॉल शामिल नहीं हैं, तो
- अगर मॉडल कोई सूझ-बूझ वाला जवाब जनरेट करता है, तो Gemini 3 में, आखिरी हिस्से में सिग्नेचर होगा.
- Gemini 2.5 में, किसी भी हिस्से में सिग्नेचर नहीं होगा.
तुलना से जुड़ी ज़्यादा जानकारी के लिए, सूझ-बूझ वाला मॉडल पेज देखें. Gemini 3 इमेज मॉडल के लिए, इमेज जनरेट करने के गाइड में, सूझ-बूझ वाली प्रोसेस वाला सेक्शन देखें.