chat_template.jinja · gemma-4-12B-it

1

{#

2

Template: Google Gemma 4 Canonical Chat Template

3

Author: Google Gemma Engineering Team

4

Published: 2026-07-09

5

Context: Fixed tool-calling loops, turn closures, and thinking content-ordering.

6

#}

7

{%- macro format_parameters(properties, required, filter_keys=false) -%}

8

{%- set standard_keys = ['description', 'type', 'properties', 'required', 'nullable'] -%}

9

{%- set ns = namespace(found_first=false) -%}

10

{%- for key, value in properties | dictsort -%}

11

{%- set add_comma = false -%}

12

{%- if not filter_keys or key not in standard_keys -%}

13

{%- if ns.found_first %},{% endif -%}

14

{%- set ns.found_first = true -%}

15

{{ key }}:{

16

{%- if value['description'] -%}

17

description:<|"|>{{ value['description'] }}<|"|>

18

{%- set add_comma = true -%}

19

{%- endif -%}

20

{%- if value['type'] | upper == 'STRING' -%}

21

{%- if value['enum'] -%}

22

{%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}

23

enum:{{ format_argument(value['enum']) }}

24

{%- endif -%}

25

{%- elif value['type'] | upper == 'ARRAY' -%}

26

{%- if value['items'] is mapping and value['items'] -%}

27

{%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}

28

items:{

29

{%- set ns_items = namespace(found_first=false) -%}

30

{%- for item_key, item_value in value['items'] | dictsort -%}

31

{%- if item_value is not none -%}

32

{%- if ns_items.found_first %},{% endif -%}

33

{%- set ns_items.found_first = true -%}

34

{%- if item_key == 'properties' -%}

35

properties:{

36

{%- if item_value is mapping -%}

37

{{- format_parameters(item_value, value['items']['required'] | default([])) -}}

38

{%- endif -%}

39

}

40

{%- elif item_key == 'required' -%}

41

required:[

42

{%- for req_item in item_value -%}

43

<|"|>{{- req_item -}}<|"|>

44

{%- if not loop.last %},{% endif -%}

45

{%- endfor -%}

46

]

47

{%- elif item_key == 'type' -%}

48

{%- if item_value is string -%}

49

type:{{ format_argument(item_value | upper) }}

50

{%- else -%}

51

type:{{ format_argument(item_value | map('upper') | list) }}

52

{%- endif -%}

53

{%- else -%}

54

{{ item_key }}:{{ format_argument(item_value) }}

55

{%- endif -%}

56

{%- endif -%}

57

{%- endfor -%}

58

}

59

{%- endif -%}

60

{%- endif -%}

61

{%- if value['nullable'] %}

62

{%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}

63

nullable:true

64

{%- endif -%}

65

{%- if value['type'] | upper == 'OBJECT' -%}

66

{%- if value['properties'] is defined and value['properties'] is mapping -%}

67

{%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}

68

properties:{

69

{{- format_parameters(value['properties'], value['required'] | default([])) -}}

70

}

71

{%- elif value is mapping -%}

72

{%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}

73

properties:{

74

{{- format_parameters(value, value['required'] | default([]), filter_keys=true) -}}

75

}

76

{%- endif -%}

77

{%- if value['required'] -%}

78

{%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}

79

required:[

80

{%- for item in value['required'] | default([]) -%}

81

<|"|>{{- item -}}<|"|>

82

{%- if not loop.last %},{% endif -%}

83

{%- endfor -%}

84

]

85

{%- endif -%}

86

{%- endif -%}

87

{%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}

88

type:<|"|>{{ value['type'] | upper }}<|"|>}

89

{%- endif -%}

90

{%- endfor -%}

91

{%- endmacro -%}

92

{%- macro format_function_declaration(tool_data) -%}

93

declaration:{{- tool_data['function']['name'] -}}{description:<|"|>{{- tool_data['function']['description'] -}}<|"|>

94

{%- set params = tool_data['function']['parameters'] -%}

95

{%- if params -%}

96

,parameters:{

97

{%- if params['properties'] -%}

98

properties:{ {{- format_parameters(params['properties'], params['required']) -}} },

99

{%- endif -%}

100

{%- if params['required'] -%}

101

required:[

102

{%- for item in params['required'] -%}

103

<|"|>{{- item -}}<|"|>

104

{{- ',' if not loop.last -}}

105

{%- endfor -%}

106

],

107

{%- endif -%}

108

{%- if params['type'] -%}

109

type:<|"|>{{- params['type'] | upper -}}<|"|>}

110

{%- endif -%}

111

{%- endif -%}

112

{%- if 'response' in tool_data['function'] -%}

113

{%- set response_declaration = tool_data['function']['response'] -%}

114

,response:{

115

{%- if response_declaration['description'] -%}

116

description:<|"|>{{- response_declaration['description'] -}}<|"|>,

117

{%- endif -%}

118

{%- if response_declaration['type'] | upper == 'OBJECT' -%}

119

type:<|"|>{{- response_declaration['type'] | upper -}}<|"|>}

120

{%- endif -%}

121

{%- endif -%}

122

}

123

{%- endmacro -%}

124

{%- macro format_argument(argument, escape_keys=True) -%}

125

{%- if argument is none -%}

126

{{- 'null' -}}

127

{%- elif argument is string -%}

128

{{- '<|"|>' + argument + '<|"|>' -}}

129

{%- elif argument is boolean -%}

130

{{- 'true' if argument else 'false' -}}

131

{%- elif argument is mapping -%}

132

{{- '{' -}}

133

{%- set ns = namespace(found_first=false) -%}

134

{%- for key, value in argument | dictsort -%}

135

{%- if ns.found_first %},{% endif -%}

136

{%- set ns.found_first = true -%}

137

{%- if escape_keys -%}

138

{{- '<|"|>' + key + '<|"|>' -}}

139

{%- else -%}

140

{{- key -}}

141

{%- endif -%}

142

:{{- format_argument(value, escape_keys=escape_keys) -}}

143

{%- endfor -%}

144

{{- '}' -}}

145

{%- elif argument is sequence -%}

146

{{- '[' -}}

147

{%- for item in argument -%}

148

{{- format_argument(item, escape_keys=escape_keys) -}}

149

{%- if not loop.last %},{% endif -%}

150

{%- endfor -%}

151

{{- ']' -}}

152

{%- else -%}

153

{{- argument -}}

154

{%- endif -%}

155

{%- endmacro -%}

156

{%- macro strip_thinking(text) -%}

157

{%- set ns = namespace(result='') -%}

158

{%- for part in text.split('<channel|>') -%}

159

{%- if '<|channel>' in part -%}

160

{%- set ns.result = ns.result + part.split('<|channel>')[0] -%}

161

{%- else -%}

162

{%- set ns.result = ns.result + part -%}

163

{%- endif -%}

164

{%- endfor -%}

165

{{- ns.result | trim -}}

166

{%- endmacro -%}

167

168

{%- macro format_tool_response_block(tool_name, response) -%}

169

{{- '<|tool_response>' -}}

170

{%- if response is mapping -%}

171

{{- 'response:' + tool_name + '{' -}}

172

{%- for key, value in response | dictsort -%}

173

{{- key -}}:{{- format_argument(value, escape_keys=False) -}}

174

{%- if not loop.last %},{% endif -%}

175

{%- endfor -%}

176

{{- '}' -}}

177

{%- else -%}

178

{{- 'response:' + tool_name + '{value:' + format_argument(response, escape_keys=False) + '}' -}}

179

{%- endif -%}

180

{{- '<tool_response|>' -}}

181

{%- endmacro -%}

182

183

{#- ===== SETUP ===== -#}

184

{%- set ns = namespace(prev_message_type=None, prev_non_tool_role=None) -%}

185

{%- set loop_messages = messages -%}

186

{%- set enable_thinking = enable_thinking | default(false) -%}

187

{%- set preserve_thinking = preserve_thinking | default(false) -%}

188

{{- bos_token -}}

189

{#- Handle System/Tool Definitions Block -#}

190

{%- if enable_thinking or tools or (messages and messages[0]['role'] in ['system', 'developer']) -%}

191

{{- '<|turn>system\n' -}}

192

{#- Inject Thinking token at the very top of the FIRST system turn -#}

193

{%- if enable_thinking -%}

194

{{- '<|think|>\n' -}}

195

{%- set ns.prev_message_type = 'think' -%}

196

{%- endif -%}

197

{%- if messages and messages[0]['role'] in ['system', 'developer'] -%}

198

{%- if messages[0]['content'] is string -%}

199

{{- messages[0]['content'] | trim -}}

200

{%- elif messages[0]['content'] is sequence -%}

201

{%- for item in messages[0]['content'] -%}

202

{{- item['text'] | trim + ' '-}}

203

{%- endfor -%}

204

{%- endif -%}

205

{%- set loop_messages = messages[1:] -%}

206

{%- endif -%}

207

{%- if tools -%}

208

{%- for tool in tools %}

209

{{- '<|tool>' -}}

210

{{- format_function_declaration(tool) | trim -}}

211

{{- '<tool|>' -}}

212

{%- endfor %}

213

{%- set ns.prev_message_type = 'tool' -%}

214

{%- endif -%}

215

{{- '<turn|>\n' -}}

216

{%- endif %}

217

218

{#- Pre-scan: find last user message index for reasoning guard -#}

219

{%- set ns_turn = namespace(last_user_idx=-1) -%}

220

{%- for i in range(loop_messages | length) -%}

221

{%- if loop_messages[i]['role'] == 'user' -%}

222

{%- set ns_turn.last_user_idx = i -%}

223

{%- endif -%}

224

{%- endfor -%}

225

226

{#- Loop through messages -#}

227

{%- for message in loop_messages -%}

228

{%- if message['role'] != 'tool' -%}

229

{%- set ns.prev_message_type = None -%}

230

{%- set role = 'model' if message['role'] == 'assistant' else message['role'] -%}

231

{#- Detect continuation using tracked state — O(1) instead of O(n) backward scan -#}

232

{%- set continue_same_model_turn = (role == 'model' and ns.prev_non_tool_role == 'assistant') -%}

233

{%- if not continue_same_model_turn -%}

234

{{- '<|turn>' + role + '\n' }}

235

236

{%- endif -%}

237

238

{#- Render reasoning/reasoning_content as thinking channel -#}

239

{%- set thinking_text = message.get('reasoning') or message.get('reasoning_content') -%}

240

    {%- set thinking_gate = (loop.index0 > ns_turn.last_user_idx) or (preserve_thinking and message.get('tool_calls')) -%}

241

{%- if thinking_text and thinking_gate -%}

242

{{- '<|channel>thought\n' + thinking_text + '\n<channel|>' -}}

243

{%- endif -%}

244

245

{%- if message.get('tool_calls') -%}

246

{%- for tool_call in message.get('tool_calls') -%}

247

{%- set function = tool_call['function'] -%}

248

{{- '<|tool_call>call:' + function['name'] + '{' -}}

249

{%- if function['arguments'] is mapping -%}

250

{%- set ns_args = namespace(found_first=false) -%}

251

{%- for key, value in function['arguments'] | dictsort -%}

252

{%- if ns_args.found_first %},{% endif -%}

253

{%- set ns_args.found_first = true -%}

254

{{- key -}}:{{- format_argument(value, escape_keys=False) -}}

255

{%- endfor -%}

256

{%- elif function['arguments'] is none -%}

257

{%- else -%}

258

{{- raise_exception(

259

"chat_template: tool_calls[].function.arguments must be a "

260

"JSON object (mapping), not a string. Deserialize arguments "

261

"before passing to the template."

262

) -}}

263

{%- endif -%}

264

{{- '}<tool_call|>' -}}

265

{%- endfor -%}

266

{%- set ns.prev_message_type = 'tool_call' -%}

267

{%- endif -%}

268

269

{%- set ns_tr_out = namespace(flag=false) -%}

270

{%- if message.get('tool_responses') -%}

271

{#- Legacy: tool_responses embedded on the assistant message (Google/Gemma native) -#}

272

{%- for tool_response in message.get('tool_responses') -%}

273

                    {{- format_tool_response_block(tool_response['name'] | default('unknown', true), tool_response['response']) -}}

274

{%- set ns_tr_out.flag = true -%}

275

{%- set ns.prev_message_type = 'tool_response' -%}

276

{%- endfor -%}

277

{%- elif message.get('tool_calls') -%}

278

{#- OpenAI Chat Completions: forward-scan consecutive role:tool messages -#}

279

{%- set ns_tool_scan = namespace(stopped=false) -%}

280

{%- for k in range(loop.index0 + 1, loop_messages | length) -%}

281

{%- if ns_tool_scan.stopped -%}

282

{%- elif loop_messages[k]['role'] != 'tool' -%}

283

{%- set ns_tool_scan.stopped = true -%}

284

{%- else -%}

285

{%- set follow = loop_messages[k] -%}

286

{#- Resolve tool_call_id to function name -#}

287

{%- set ns_tname = namespace(name=follow.get('name') or 'unknown') -%}

288

{%- for tc in message.get('tool_calls') -%}

289

{%- if tc.get('id') == follow.get('tool_call_id') -%}

290

{%- set ns_tname.name = tc['function']['name'] -%}

291

{%- endif -%}

292

{%- endfor -%}

293

{#- Handle content as string or content-parts array -#}

294

{%- set tool_body = follow.get('content') -%}

295

{%- if tool_body is string -%}

296

{{- format_tool_response_block(ns_tname.name, tool_body) -}}

297

{%- elif tool_body is sequence and tool_body is not string -%}

298

{%- set ns_txt = namespace(s='') -%}

299

{%- for part in tool_body -%}

300

{%- if part.get('type') == 'text' -%}

301

{%- set ns_txt.s = ns_txt.s + (part.get('text') | default('')) -%}

302

{%- endif -%}

303

{%- endfor -%}

304

{{- format_tool_response_block(ns_tname.name, ns_txt.s) -}}

305

{%- for part in tool_body -%}

306

{%- if part.get('type') in ['image', 'image_url'] -%}

307

{{- '<|image|>' -}}

308

{%- elif part.get('type') in ['audio', 'input_audio'] -%}

309

{{- '<|audio|>' -}}

310

{%- elif part.get('type') == 'video' -%}

311

{{- '<|video|>' -}}

312

{%- endif -%}

313

{%- endfor -%}

314

{%- else -%}

315

{{- format_tool_response_block(ns_tname.name, tool_body) -}}

316

{%- endif -%}

317

{%- set ns_tr_out.flag = true -%}

318

{%- set ns.prev_message_type = 'tool_response' -%}

319

{%- endif -%}

320

{%- endfor -%}

321

{%- endif -%}

322

323

{%- set captured_content -%}

324

{%- if message.get('content') is string -%}

325

{%- if role == 'model' -%}

326

{{- strip_thinking(message['content']) -}}

327

{%- else -%}

328

{{- message['content'] | trim -}}

329

{%- endif -%}

330

{%- elif message.get('content') is sequence -%}

331

{%- for item in message['content'] -%}

332

{%- if item.get('type') == 'text' -%}

333

{%- if role == 'model' -%}

334

{{- strip_thinking(item['text']) -}}

335

{%- else -%}

336

{{- item['text'] | trim -}}

337

{%- endif -%}

338

{%- elif item.get('type') in ['image', 'image_url'] -%}

339

{{- '<|image|>' -}}

340

{%- elif item.get('type') in ['audio', 'input_audio'] -%}

341

{{- '<|audio|>' -}}

342

{%- elif item.get('type') == 'video' -%}

343

{{- '<|video|>' -}}

344

{%- endif -%}

345

{%- endfor -%}

346

{%- endif -%}

347

{%- endset -%}

348

349

{{- captured_content -}}

350

{%- set has_content = captured_content | trim | length > 0 -%}

351

352

{#- Forward-scan: find next non-tool message role for continuation detection -#}

353

{%- set next_nt = namespace(role=None, found=false) -%}

354

{%- for j in range(loop.index0 + 1, loop_messages | length) -%}

355

{%- if not next_nt.found -%}

356

{%- if loop_messages[j]['role'] != 'tool' -%}

357

{%- set next_nt.role = loop_messages[j]['role'] -%}

358

{%- set next_nt.found = true -%}

359

{%- endif -%}

360

{%- endif -%}

361

{%- endfor -%}

362

363

{%- set continues_into_next = (

364

role == 'model'

365

and next_nt.role == 'assistant'

366

and (not message.get('tool_calls') or ns_tr_out.flag)

367

) -%}

368

369

{%- if ns.prev_message_type == 'tool_call' and not ns_tr_out.flag -%}

370

{{- '<|tool_response>' -}}

371

{%- elif continues_into_next -%}

372

{%- elif not (ns_tr_out.flag and not has_content and not next_nt.found) -%}

373

{{- '<turn|>\n' -}}

374

{%- endif -%}

375

376

{#- Track previous non-tool role for next iteration (avoids O(n) backward scan) -#}

377

{%- set ns.prev_non_tool_role = message['role'] -%}

378

{%- endif -%}

379

{%- endfor -%}

380

381

{%- if add_generation_prompt -%}

382

{%- if ns.prev_message_type != 'tool_response' and ns.prev_message_type != 'tool_call' -%}

383

{{- '<|turn>model\n' -}}

384

{%- if not enable_thinking -%}

385

{{- '<|channel>thought\n<channel|>' -}}

386

{%- endif -%}

387

{%- elif ns.prev_message_type == 'tool_response' and enable_thinking -%}

388

{{- '<|channel>thought\n' -}}

389

{%- endif -%}

390

{%- endif -%}

391