jwadow commited on
Commit
d30c8bc
·
1 Parent(s): 1723fcf

fix: preserve tool_calls when merging assistant messages; add DEBUG_MODE with errors/all modes

Browse files
.env.example CHANGED
@@ -65,8 +65,15 @@ KIRO_CREDS_FILE="~/.aws/sso/cache/kiro-auth-token.json"
65
  # DEBUG (for development only)
66
  # ===========================================
67
 
68
- # Enable debug logging of requests/responses to files
69
- # DEBUG_LAST_REQUEST=true
 
 
 
70
 
71
  # Directory for debug log files
72
  # DEBUG_DIR="debug_logs"
 
 
 
 
 
65
  # DEBUG (for development only)
66
  # ===========================================
67
 
68
+ # Debug logging mode:
69
+ # - off: disabled (default)
70
+ # - errors: save logs only for failed requests (4xx, 5xx) - recommended for troubleshooting
71
+ # - all: save logs for every request (overwrites on each request)
72
+ # DEBUG_MODE=off
73
 
74
  # Directory for debug log files
75
  # DEBUG_DIR="debug_logs"
76
+
77
+ # Legacy option (WILL BE REMOVED in future releases, use DEBUG_MODE instead)
78
+ # DEBUG_LAST_REQUEST=true is equivalent to DEBUG_MODE=all
79
+ # DEBUG_LAST_REQUEST=true
kiro_gateway/config.py CHANGED
@@ -238,18 +238,60 @@ FIRST_TOKEN_MAX_RETRIES: int = int(os.getenv("FIRST_TOKEN_MAX_RETRIES", "3"))
238
  # Debug Settings
239
  # ==================================================================================================
240
 
241
- # If True, the last request will be logged in detail to DEBUG_DIR
242
- # Enable via .env: DEBUG_LAST_REQUEST=true
243
- DEBUG_LAST_REQUEST: bool = os.getenv("DEBUG_LAST_REQUEST", "false").lower() in ("true", "1", "yes")
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
244
 
245
  # Directory for debug log files
246
  DEBUG_DIR: str = os.getenv("DEBUG_DIR", "debug_logs")
247
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
248
  # ==================================================================================================
249
  # Версия приложения
250
  # ==================================================================================================
251
 
252
- APP_VERSION: str = "1.0.3"
253
  APP_TITLE: str = "Kiro API Gateway"
254
  APP_DESCRIPTION: str = "OpenAI-compatible interface for Kiro API (AWS CodeWhisperer). Made by @jwadow"
255
 
 
238
  # Debug Settings
239
  # ==================================================================================================
240
 
241
+ # Legacy option (deprecated, will be removed in future releases)
242
+ # Use DEBUG_MODE instead
243
+ _DEBUG_LAST_REQUEST_RAW: str = os.getenv("DEBUG_LAST_REQUEST", "").lower()
244
+ DEBUG_LAST_REQUEST: bool = _DEBUG_LAST_REQUEST_RAW in ("true", "1", "yes")
245
+
246
+ # Debug logging mode:
247
+ # - off: disabled (default)
248
+ # - errors: save logs only for failed requests (4xx, 5xx)
249
+ # - all: save logs for every request (overwrites on each request)
250
+ _DEBUG_MODE_RAW: str = os.getenv("DEBUG_MODE", "").lower()
251
+
252
+ # Priority logic:
253
+ # 1. If DEBUG_MODE is explicitly set → use it
254
+ # 2. If DEBUG_MODE is not set but DEBUG_LAST_REQUEST=true → mode "all" (backward compatibility)
255
+ # 3. Otherwise → mode "off"
256
+ if _DEBUG_MODE_RAW in ("off", "errors", "all"):
257
+ DEBUG_MODE: str = _DEBUG_MODE_RAW
258
+ elif DEBUG_LAST_REQUEST:
259
+ DEBUG_MODE: str = "all"
260
+ else:
261
+ DEBUG_MODE: str = "off"
262
 
263
  # Directory for debug log files
264
  DEBUG_DIR: str = os.getenv("DEBUG_DIR", "debug_logs")
265
 
266
+
267
+ def _warn_deprecated_debug_setting():
268
+ """
269
+ Выводит предупреждение если используется deprecated DEBUG_LAST_REQUEST.
270
+ Вызывается при старте приложения.
271
+ """
272
+ if _DEBUG_LAST_REQUEST_RAW and not _DEBUG_MODE_RAW:
273
+ import sys
274
+ # ANSI escape codes: желтый текст
275
+ YELLOW = "\033[93m"
276
+ RESET = "\033[0m"
277
+
278
+ warning_text = f"""
279
+ {YELLOW}⚠️ DEPRECATED: DEBUG_LAST_REQUEST will be removed in future releases.
280
+ Please use DEBUG_MODE instead:
281
+ - DEBUG_MODE=off (disabled, default)
282
+ - DEBUG_MODE=errors (save logs only for failed requests)
283
+ - DEBUG_MODE=all (save logs for every request)
284
+
285
+ DEBUG_LAST_REQUEST=true is equivalent to DEBUG_MODE=all
286
+ See .env.example for more details.{RESET}
287
+ """
288
+ print(warning_text, file=sys.stderr)
289
+
290
  # ==================================================================================================
291
  # Версия приложения
292
  # ==================================================================================================
293
 
294
+ APP_VERSION: str = "1.0.4"
295
  APP_TITLE: str = "Kiro API Gateway"
296
  APP_DESCRIPTION: str = "OpenAI-compatible interface for Kiro API (AWS CodeWhisperer). Made by @jwadow"
297
 
kiro_gateway/converters.py CHANGED
@@ -163,6 +163,16 @@ def merge_adjacent_messages(messages: List[ChatMessage]) -> List[ChatMessage]:
163
  last_text = extract_text_content(last.content)
164
  current_text = extract_text_content(msg.content)
165
  last.content = f"{last_text}\n{current_text}"
 
 
 
 
 
 
 
 
 
 
166
  logger.debug(f"Merged adjacent messages with role {msg.role}")
167
  else:
168
  merged.append(msg)
 
163
  last_text = extract_text_content(last.content)
164
  current_text = extract_text_content(msg.content)
165
  last.content = f"{last_text}\n{current_text}"
166
+
167
+ # Объединяем tool_calls для assistant сообщений
168
+ # Критично: без этого теряются tool_calls из второго и последующих сообщений,
169
+ # что приводит к ошибке 400 от Kiro API (toolResult без соответствующего toolUse)
170
+ if msg.role == "assistant" and msg.tool_calls:
171
+ if last.tool_calls is None:
172
+ last.tool_calls = []
173
+ last.tool_calls = list(last.tool_calls) + list(msg.tool_calls)
174
+ logger.debug(f"Merged tool_calls: added {len(msg.tool_calls)} tool calls, total now: {len(last.tool_calls)}")
175
+
176
  logger.debug(f"Merged adjacent messages with role {msg.role}")
177
  else:
178
  merged.append(msg)
kiro_gateway/debug_logger.py CHANGED
@@ -17,23 +17,34 @@
17
  # along with this program. If not, see <https://www.gnu.org/licenses/>.
18
 
19
  """
20
- Модуль для отладочного логирования последнего запроса.
21
 
22
- Сохраняет данные запроса и потоки ответов в файлы для последующего анализа.
23
- Активен только когда DEBUG_LAST_REQUEST=true в окружении.
 
 
 
 
 
24
  """
25
 
26
  import json
27
  import shutil
28
  from pathlib import Path
 
29
  from loguru import logger
30
 
31
- from kiro_gateway.config import DEBUG_LAST_REQUEST, DEBUG_DIR
32
 
33
 
34
  class DebugLogger:
35
  """
36
- Синглтон для управления отладочными логами последнего запроса.
 
 
 
 
 
37
  """
38
  _instance = None
39
 
@@ -48,86 +59,258 @@ class DebugLogger:
48
  return
49
  self.debug_dir = Path(DEBUG_DIR)
50
  self._initialized = True
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
51
 
52
  def prepare_new_request(self):
53
  """
54
- Очищает папку с логами и создает её заново для нового запроса.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
55
  """
56
- if not DEBUG_LAST_REQUEST:
57
  return
58
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
59
  try:
60
- if self.debug_dir.exists():
61
- shutil.rmtree(self.debug_dir)
62
  self.debug_dir.mkdir(parents=True, exist_ok=True)
63
- logger.debug(f"[DebugLogger] Directory {self.debug_dir} cleared for new request.")
 
 
 
 
 
 
 
 
 
64
  except Exception as e:
65
- logger.error(f"[DebugLogger] Error preparing directory: {e}")
66
 
67
- def log_request_body(self, body: bytes):
68
  """
69
- Сохраняет тело запроса (от клиента, OpenAI формат) в JSON файл.
 
 
 
 
 
 
 
70
  """
71
- if not DEBUG_LAST_REQUEST:
72
  return
73
-
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
74
  try:
75
  file_path = self.debug_dir / "request_body.json"
76
- # Пытаемся сохранить как красивый JSON
77
  try:
78
  json_obj = json.loads(body)
79
  with open(file_path, "w", encoding="utf-8") as f:
80
  json.dump(json_obj, f, indent=2, ensure_ascii=False)
81
  except json.JSONDecodeError:
82
- # Если не JSON, пишем как есть (байты -> строка, если получится)
83
  with open(file_path, "wb") as f:
84
  f.write(body)
85
  except Exception as e:
86
  logger.error(f"[DebugLogger] Error writing request_body: {e}")
87
-
88
- def log_kiro_request_body(self, body: bytes):
89
- """
90
- Сохраняет модифицированное тело запроса (к Kiro API) в JSON файл.
91
- """
92
- if not DEBUG_LAST_REQUEST:
93
- return
94
-
95
  try:
96
  file_path = self.debug_dir / "kiro_request_body.json"
97
- # Пытаемся сохранить как красивый JSON
98
  try:
99
  json_obj = json.loads(body)
100
  with open(file_path, "w", encoding="utf-8") as f:
101
  json.dump(json_obj, f, indent=2, ensure_ascii=False)
102
  except json.JSONDecodeError:
103
- # Если не JSON, пишем как есть (байты -> строка, если получится)
104
  with open(file_path, "wb") as f:
105
  f.write(body)
106
  except Exception as e:
107
  logger.error(f"[DebugLogger] Error writing kiro_request_body: {e}")
108
-
109
- def log_raw_chunk(self, chunk: bytes):
110
- """
111
- Дописывает сырой чанк ответа (от провайдера) в файл.
112
- """
113
- if not DEBUG_LAST_REQUEST:
114
- return
115
-
116
  try:
117
  file_path = self.debug_dir / "response_stream_raw.txt"
118
  with open(file_path, "ab") as f:
119
  f.write(chunk)
120
  except Exception:
121
- # Не логируем ошибку на каждый чанк, чтобы не спамить
122
  pass
123
-
124
- def log_modified_chunk(self, chunk: bytes):
125
- """
126
- Дописывает модифицированный чанк (клиенту) в файл.
127
- """
128
- if not DEBUG_LAST_REQUEST:
129
- return
130
-
131
  try:
132
  file_path = self.debug_dir / "response_stream_modified.txt"
133
  with open(file_path, "ab") as f:
 
17
  # along with this program. If not, see <https://www.gnu.org/licenses/>.
18
 
19
  """
20
+ Модуль для отладочного логирования запросов.
21
 
22
+ Поддерживает три режима (DEBUG_MODE):
23
+ - off: логирование отключено
24
+ - errors: логи сохраняются только при ошибках (4xx, 5xx)
25
+ - all: логи перезаписываются на каждый запрос
26
+
27
+ В режиме "errors" данные буферизуются в памяти и сбрасываются в файлы
28
+ только при вызове flush_on_error().
29
  """
30
 
31
  import json
32
  import shutil
33
  from pathlib import Path
34
+ from typing import Optional
35
  from loguru import logger
36
 
37
+ from kiro_gateway.config import DEBUG_MODE, DEBUG_DIR
38
 
39
 
40
  class DebugLogger:
41
  """
42
+ Синглтон для управления отладочными логами запросов.
43
+
44
+ Режимы работы:
45
+ - off: ничего не делает
46
+ - errors: буферизует данные, сбрасывает в файлы только при ошибках
47
+ - all: пишет данные сразу в файлы (как раньше)
48
  """
49
  _instance = None
50
 
 
59
  return
60
  self.debug_dir = Path(DEBUG_DIR)
61
  self._initialized = True
62
+
63
+ # Буферы для режима "errors"
64
+ self._request_body_buffer: Optional[bytes] = None
65
+ self._kiro_request_body_buffer: Optional[bytes] = None
66
+ self._raw_chunks_buffer: bytearray = bytearray()
67
+ self._modified_chunks_buffer: bytearray = bytearray()
68
+
69
+ def _is_enabled(self) -> bool:
70
+ """Проверяет, включено ли логирование."""
71
+ return DEBUG_MODE in ("errors", "all")
72
+
73
+ def _is_immediate_write(self) -> bool:
74
+ """Проверяет, нужно ли писать сразу в файлы (режим all)."""
75
+ return DEBUG_MODE == "all"
76
+
77
+ def _clear_buffers(self):
78
+ """Очищает все буферы."""
79
+ self._request_body_buffer = None
80
+ self._kiro_request_body_buffer = None
81
+ self._raw_chunks_buffer.clear()
82
+ self._modified_chunks_buffer.clear()
83
 
84
  def prepare_new_request(self):
85
  """
86
+ Подготавливает логгер для нового запроса.
87
+
88
+ В режиме "all": очищает папку с логами.
89
+ В режиме "errors": очищает буферы.
90
+ """
91
+ if not self._is_enabled():
92
+ return
93
+
94
+ # Очищаем буферы в любом случае
95
+ self._clear_buffers()
96
+
97
+ if self._is_immediate_write():
98
+ # Режим "all" - очищаем папку и создаём заново
99
+ try:
100
+ if self.debug_dir.exists():
101
+ shutil.rmtree(self.debug_dir)
102
+ self.debug_dir.mkdir(parents=True, exist_ok=True)
103
+ logger.debug(f"[DebugLogger] Directory {self.debug_dir} cleared for new request.")
104
+ except Exception as e:
105
+ logger.error(f"[DebugLogger] Error preparing directory: {e}")
106
+
107
+ def log_request_body(self, body: bytes):
108
+ """
109
+ Сохраняет тело запроса (от клиента, OpenAI формат).
110
+
111
+ В режиме "all": пишет сразу в файл.
112
+ В режиме "errors": буферизует.
113
  """
114
+ if not self._is_enabled():
115
  return
116
 
117
+ if self._is_immediate_write():
118
+ self._write_request_body_to_file(body)
119
+ else:
120
+ # Режим "errors" - буферизуем
121
+ self._request_body_buffer = body
122
+
123
+ def log_kiro_request_body(self, body: bytes):
124
+ """
125
+ Сохраняет модифицированное тело запроса (к Kiro API).
126
+
127
+ В режиме "all": пишет сразу в файл.
128
+ В режиме "errors": буферизует.
129
+ """
130
+ if not self._is_enabled():
131
+ return
132
+
133
+ if self._is_immediate_write():
134
+ self._write_kiro_request_body_to_file(body)
135
+ else:
136
+ # Режим "errors" - буферизуем
137
+ self._kiro_request_body_buffer = body
138
+
139
+ def log_raw_chunk(self, chunk: bytes):
140
+ """
141
+ Дописывает сырой чанк ответа (от провайдера).
142
+
143
+ В режиме "all": пишет сразу в файл.
144
+ В режиме "errors": буферизует.
145
+ """
146
+ if not self._is_enabled():
147
+ return
148
+
149
+ if self._is_immediate_write():
150
+ self._append_raw_chunk_to_file(chunk)
151
+ else:
152
+ # Режим "errors" - буферизуем
153
+ self._raw_chunks_buffer.extend(chunk)
154
+
155
+ def log_modified_chunk(self, chunk: bytes):
156
+ """
157
+ Дописывает модифицированный чанк (клиенту).
158
+
159
+ В режиме "all": пишет сразу в файл.
160
+ В режиме "errors": буферизует.
161
+ """
162
+ if not self._is_enabled():
163
+ return
164
+
165
+ if self._is_immediate_write():
166
+ self._append_modified_chunk_to_file(chunk)
167
+ else:
168
+ # Режим "errors" - буферизуем
169
+ self._modified_chunks_buffer.extend(chunk)
170
+
171
+ def log_error_info(self, status_code: int, error_message: str = ""):
172
+ """
173
+ Записывает информацию об ошибке в файл.
174
+
175
+ Работает в обоих режимах (errors и all).
176
+ В режиме "all" записывает сразу в файл.
177
+ В режиме "errors" вызывается из flush_on_error().
178
+
179
+ Args:
180
+ status_code: HTTP статус код ошибки
181
+ error_message: Сообщение об ошибке (опционально)
182
+ """
183
+ if not self._is_enabled():
184
+ return
185
+
186
  try:
187
+ # Убеждаемся что директория существует
 
188
  self.debug_dir.mkdir(parents=True, exist_ok=True)
189
+
190
+ error_info = {
191
+ "status_code": status_code,
192
+ "error_message": error_message
193
+ }
194
+ error_file = self.debug_dir / "error_info.json"
195
+ with open(error_file, "w", encoding="utf-8") as f:
196
+ json.dump(error_info, f, indent=2, ensure_ascii=False)
197
+
198
+ logger.debug(f"[DebugLogger] Error info saved (status={status_code})")
199
  except Exception as e:
200
+ logger.error(f"[DebugLogger] Error writing error_info: {e}")
201
 
202
+ def flush_on_error(self, status_code: int, error_message: str = ""):
203
  """
204
+ Сбрасывает буферы в файлы при ошибке.
205
+
206
+ В режиме "errors": сбрасывает буферы и сохраняет error_info.
207
+ В режиме "all": только сохраняет error_info (данные уже записаны).
208
+
209
+ Args:
210
+ status_code: HTTP статус код ошибки
211
+ error_message: Сообщение об ошибке (опционально)
212
  """
213
+ if not self._is_enabled():
214
  return
215
+
216
+ # В режиме "all" данные уже записаны, только добавляем error_info
217
+ if self._is_immediate_write():
218
+ self.log_error_info(status_code, error_message)
219
+ return
220
+
221
+ # Проверяем, есть ли что сбрасывать
222
+ if not any([
223
+ self._request_body_buffer,
224
+ self._kiro_request_body_buffer,
225
+ self._raw_chunks_buffer,
226
+ self._modified_chunks_buffer
227
+ ]):
228
+ return
229
+
230
+ try:
231
+ # Создаём директорию если не существует
232
+ if self.debug_dir.exists():
233
+ shutil.rmtree(self.debug_dir)
234
+ self.debug_dir.mkdir(parents=True, exist_ok=True)
235
+
236
+ # Сбрасываем буферы в файлы
237
+ if self._request_body_buffer:
238
+ self._write_request_body_to_file(self._request_body_buffer)
239
+
240
+ if self._kiro_request_body_buffer:
241
+ self._write_kiro_request_body_to_file(self._kiro_request_body_buffer)
242
+
243
+ if self._raw_chunks_buffer:
244
+ file_path = self.debug_dir / "response_stream_raw.txt"
245
+ with open(file_path, "wb") as f:
246
+ f.write(self._raw_chunks_buffer)
247
+
248
+ if self._modified_chunks_buffer:
249
+ file_path = self.debug_dir / "response_stream_modified.txt"
250
+ with open(file_path, "wb") as f:
251
+ f.write(self._modified_chunks_buffer)
252
+
253
+ # Сохраняем информацию об ошибке
254
+ self.log_error_info(status_code, error_message)
255
+
256
+ logger.info(f"[DebugLogger] Error logs flushed to {self.debug_dir} (status={status_code})")
257
+
258
+ except Exception as e:
259
+ logger.error(f"[DebugLogger] Error flushing buffers: {e}")
260
+ finally:
261
+ # Очищаем буферы после сброса
262
+ self._clear_buffers()
263
+
264
+ def discard_buffers(self):
265
+ """
266
+ Очищает буферы без записи в файлы.
267
+
268
+ Вызывается когда запрос завершился успешно в режиме "errors".
269
+ """
270
+ if DEBUG_MODE == "errors":
271
+ self._clear_buffers()
272
+
273
+ # ==================== Приватные методы записи в файлы ====================
274
+
275
+ def _write_request_body_to_file(self, body: bytes):
276
+ """Записывает тело запроса в файл."""
277
  try:
278
  file_path = self.debug_dir / "request_body.json"
 
279
  try:
280
  json_obj = json.loads(body)
281
  with open(file_path, "w", encoding="utf-8") as f:
282
  json.dump(json_obj, f, indent=2, ensure_ascii=False)
283
  except json.JSONDecodeError:
 
284
  with open(file_path, "wb") as f:
285
  f.write(body)
286
  except Exception as e:
287
  logger.error(f"[DebugLogger] Error writing request_body: {e}")
288
+
289
+ def _write_kiro_request_body_to_file(self, body: bytes):
290
+ """Записывает тело запроса к Kiro в файл."""
 
 
 
 
 
291
  try:
292
  file_path = self.debug_dir / "kiro_request_body.json"
 
293
  try:
294
  json_obj = json.loads(body)
295
  with open(file_path, "w", encoding="utf-8") as f:
296
  json.dump(json_obj, f, indent=2, ensure_ascii=False)
297
  except json.JSONDecodeError:
 
298
  with open(file_path, "wb") as f:
299
  f.write(body)
300
  except Exception as e:
301
  logger.error(f"[DebugLogger] Error writing kiro_request_body: {e}")
302
+
303
+ def _append_raw_chunk_to_file(self, chunk: bytes):
304
+ """Дописывает сырой чанк в файл."""
 
 
 
 
 
305
  try:
306
  file_path = self.debug_dir / "response_stream_raw.txt"
307
  with open(file_path, "ab") as f:
308
  f.write(chunk)
309
  except Exception:
 
310
  pass
311
+
312
+ def _append_modified_chunk_to_file(self, chunk: bytes):
313
+ """Дописывает модифицированный чанк в файл."""
 
 
 
 
 
314
  try:
315
  file_path = self.debug_dir / "response_stream_modified.txt"
316
  with open(file_path, "ab") as f:
kiro_gateway/routes.py CHANGED
@@ -269,6 +269,10 @@ async def chat_completions(request: Request, request_data: ChatCompletionRequest
269
  except (json.JSONDecodeError, KeyError):
270
  pass
271
 
 
 
 
 
272
  # Возвращаем ошибку в формате OpenAI API
273
  return JSONResponse(
274
  status_code=response.status_code,
@@ -286,6 +290,10 @@ async def chat_completions(request: Request, request_data: ChatCompletionRequest
286
  messages_for_tokenizer = [msg.model_dump() for msg in request_data.messages]
287
  tools_for_tokenizer = [tool.model_dump() for tool in request_data.tools] if request_data.tools else None
288
 
 
 
 
 
289
  if request_data.stream:
290
  # Streaming режим
291
  async def stream_wrapper():
@@ -321,10 +329,16 @@ async def chat_completions(request: Request, request_data: ChatCompletionRequest
321
  await http_client.close()
322
  return JSONResponse(content=openai_response)
323
 
324
- except HTTPException:
325
  await http_client.close()
 
 
 
326
  raise
327
  except Exception as e:
328
  await http_client.close()
329
  logger.error(f"Internal error: {e}", exc_info=True)
 
 
 
330
  raise HTTPException(status_code=500, detail=f"Internal Server Error: {str(e)}")
 
269
  except (json.JSONDecodeError, KeyError):
270
  pass
271
 
272
+ # Сбрасываем debug логи при ошибке (режим "errors")
273
+ if debug_logger:
274
+ debug_logger.flush_on_error(response.status_code, error_message)
275
+
276
  # Возвращаем ошибку в формате OpenAI API
277
  return JSONResponse(
278
  status_code=response.status_code,
 
290
  messages_for_tokenizer = [msg.model_dump() for msg in request_data.messages]
291
  tools_for_tokenizer = [tool.model_dump() for tool in request_data.tools] if request_data.tools else None
292
 
293
+ # Успешный запрос - очищаем буферы debug логов (режим "errors")
294
+ if debug_logger:
295
+ debug_logger.discard_buffers()
296
+
297
  if request_data.stream:
298
  # Streaming режим
299
  async def stream_wrapper():
 
329
  await http_client.close()
330
  return JSONResponse(content=openai_response)
331
 
332
+ except HTTPException as e:
333
  await http_client.close()
334
+ # Сбрасываем debug логи при HTTP ошибке (режим "errors")
335
+ if debug_logger:
336
+ debug_logger.flush_on_error(e.status_code, str(e.detail))
337
  raise
338
  except Exception as e:
339
  await http_client.close()
340
  logger.error(f"Internal error: {e}", exc_info=True)
341
+ # Сбрасываем debug логи при внутренней ошибке (режим "errors")
342
+ if debug_logger:
343
+ debug_logger.flush_on_error(500, str(e))
344
  raise HTTPException(status_code=500, detail=f"Internal Server Error: {str(e)}")
main.py CHANGED
@@ -45,6 +45,7 @@ from kiro_gateway.config import (
45
  KIRO_CREDS_FILE,
46
  PROXY_API_KEY,
47
  LOG_LEVEL,
 
48
  )
49
  from kiro_gateway.auth import KiroAuthManager
50
  from kiro_gateway.cache import ModelInfoCache
@@ -149,6 +150,9 @@ def validate_configuration() -> None:
149
  # Run configuration validation on import
150
  validate_configuration()
151
 
 
 
 
152
 
153
  # --- Lifespan Manager ---
154
  @asynccontextmanager
 
45
  KIRO_CREDS_FILE,
46
  PROXY_API_KEY,
47
  LOG_LEVEL,
48
+ _warn_deprecated_debug_setting,
49
  )
50
  from kiro_gateway.auth import KiroAuthManager
51
  from kiro_gateway.cache import ModelInfoCache
 
150
  # Run configuration validation on import
151
  validate_configuration()
152
 
153
+ # Warn about deprecated DEBUG_LAST_REQUEST if used
154
+ _warn_deprecated_debug_setting()
155
+
156
 
157
  # --- Lifespan Manager ---
158
  @asynccontextmanager
tests/README.md CHANGED
@@ -76,6 +76,7 @@ tests/
76
  │ ├── test_cache.py # Тесты ModelInfoCache
77
  │ ├── test_config.py # Тесты конфигурации (LOG_LEVEL и др.)
78
  │ ├── test_converters.py # Тесты конвертеров OpenAI <-> Kiro
 
79
  │ ├── test_parsers.py # Тесты AwsEventStreamParser
80
  │ ├── test_streaming.py # Тесты streaming функций
81
  │ ├── test_tokenizer.py # Тесты токенизатора (tiktoken)
@@ -385,6 +386,106 @@ Unit-тесты для **модуля конфигурации** (загрузк
385
 
386
  ---
387
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
388
  ### `tests/unit/test_converters.py`
389
 
390
  Unit-тесты для конвертеров **OpenAI <-> Kiro**. **50 тестов.**
@@ -438,6 +539,26 @@ Unit-тесты для конвертеров **OpenAI <-> Kiro**. **50 тест
438
  - **Что он делает**: Проверяет объединение list contents
439
  - **Цель**: Убедиться, что списки объединяются корректно
440
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
441
  #### `TestBuildKiroHistory`
442
 
443
  - **`test_builds_user_message()`**: Проверяет построение user сообщения
 
76
  │ ├── test_cache.py # Тесты ModelInfoCache
77
  │ ├── test_config.py # Тесты конфигурации (LOG_LEVEL и др.)
78
  │ ├── test_converters.py # Тесты конвертеров OpenAI <-> Kiro
79
+ │ ├── test_debug_logger.py # Тесты DebugLogger (режимы off/errors/all)
80
  │ ├── test_parsers.py # Тесты AwsEventStreamParser
81
  │ ├── test_streaming.py # Тесты streaming функций
82
  │ ├── test_tokenizer.py # Тесты токенизатора (tiktoken)
 
386
 
387
  ---
388
 
389
+ ### `tests/unit/test_debug_logger.py`
390
+
391
+ Unit-тесты для **DebugLogger** (отладочное логирование запросов). **20 тестов.**
392
+
393
+ #### `TestDebugLoggerModeOff`
394
+
395
+ Тесты для режима DEBUG_MODE=off.
396
+
397
+ - **`test_prepare_new_request_does_nothing()`**:
398
+ - **Что он делает**: Проверяет, что prepare_new_request ничего не делает в режиме off
399
+ - **Цель**: Убедиться, что в режиме off директория не создаётся
400
+
401
+ - **`test_log_request_body_does_nothing()`**:
402
+ - **Что он делает**: Проверяет, что log_request_body ничего не делает в режиме off
403
+ - **Цель**: Убедиться, что данные не записываются
404
+
405
+ #### `TestDebugLoggerModeAll`
406
+
407
+ Тесты для режима DEBUG_MODE=all.
408
+
409
+ - **`test_prepare_new_request_clears_directory()`**:
410
+ - **Что он делает**: Проверяет, что prepare_new_request очищает директорию в режиме all
411
+ - **Цель**: Убедиться, что старые логи удаляются
412
+
413
+ - **`test_log_request_body_writes_immediately()`**:
414
+ - **Что он делает**: Проверяет, что log_request_body пишет сразу в файл в режиме all
415
+ - **Цель**: Убедиться, что данные записываются немедленно
416
+
417
+ - **`test_log_kiro_request_body_writes_immediately()`**:
418
+ - **Что он делает**: Проверяет, что log_kiro_request_body пишет сразу в файл в режиме all
419
+ - **Цель**: Убедиться, что Kiro payload записывается немедленно
420
+
421
+ - **`test_log_raw_chunk_appends_to_file()`**:
422
+ - **Что он делает**: Проверяет, что log_raw_chunk дописывает в файл в режиме all
423
+ - **Цель**: Убедиться, что чанки накапливаются
424
+
425
+ #### `TestDebugLoggerModeErrors`
426
+
427
+ Тесты для режима DEBUG_MODE=errors.
428
+
429
+ - **`test_log_request_body_buffers_data()`**:
430
+ - **Что он делает**: Проверяет, что log_request_body буферизует данные в режиме errors
431
+ - **Цель**: Убедиться, что данные не записываются сразу
432
+
433
+ - **`test_flush_on_error_writes_buffers()`**:
434
+ - **Что он делает**: Проверяет, что flush_on_error записывает буферы в файлы
435
+ - **Цель**: Убедиться, что при ошибке данные сохраняются
436
+
437
+ - **`test_flush_on_error_clears_buffers()`**:
438
+ - **Что он делает**: Проверяет, что flush_on_error очищает буферы после записи
439
+ - **Цель**: Убедиться, что буферы не накапливаются между запросами
440
+
441
+ - **`test_discard_buffers_clears_without_writing()`**:
442
+ - **Что он делает**: Проверяет, что discard_buffers очищает буферы без записи
443
+ - **Цель**: Убедиться, что успешные запросы не оставляют логов
444
+
445
+ - **`test_flush_on_error_writes_error_info_in_mode_all()`**:
446
+ - **Что он делает**: Проверяет, что flush_on_error записывает error_info.json в режиме all
447
+ - **Цель**: Убедиться, что информация об ошибке сохраняется в обоих режимах
448
+
449
+ #### `TestDebugLoggerLogErrorInfo`
450
+
451
+ Тесты для метода log_error_info().
452
+
453
+ - **`test_log_error_info_writes_in_mode_all()`**:
454
+ - **Что он делает**: Проверяет, что log_error_info записывает файл в режиме all
455
+ - **Цель**: Убедиться, что error_info.json создаётся при ошибках
456
+
457
+ - **`test_log_error_info_writes_in_mode_errors()`**:
458
+ - **Что он делает**: Проверяет, что log_error_info записывает файл в режиме errors
459
+ - **Цель**: Убедиться, что метод работает в обоих режимах
460
+
461
+ - **`test_log_error_info_does_nothing_in_mode_off()`**:
462
+ - **Что он делает**: Проверяет, что log_error_info ничего не делает в режиме off
463
+ - **Цель**: Убедиться, что в режиме off файлы не создаются
464
+
465
+ #### `TestDebugLoggerHelperMethods`
466
+
467
+ Тесты для вспомогательных методов DebugLogger.
468
+
469
+ - **`test_is_enabled_returns_true_for_errors()`**: Проверяет _is_enabled() для режима errors
470
+ - **`test_is_enabled_returns_true_for_all()`**: Проверяет _is_enabled() для режима all
471
+ - **`test_is_enabled_returns_false_for_off()`**: Проверяет _is_enabled() для режима off
472
+ - **`test_is_immediate_write_returns_true_for_all()`**: Проверяет _is_immediate_write() для режима all
473
+ - **`test_is_immediate_write_returns_false_for_errors()`**: Проверяет _is_immediate_write() для режима errors
474
+
475
+ #### `TestDebugLoggerJsonHandling`
476
+
477
+ Тесты для обработки JSON в DebugLogger.
478
+
479
+ - **`test_log_request_body_formats_json_pretty()`**:
480
+ - **Что он делает**: Проверяет, что JSON форматируется красиво
481
+ - **Цель**: Убедиться, что JSON читаем в файле
482
+
483
+ - **`test_log_request_body_handles_invalid_json()`**:
484
+ - **Что он делает**: Проверяет обработку невалидного JSON
485
+ - **Цель**: Убедиться, что невалидный JSON записывается как есть
486
+
487
+ ---
488
+
489
  ### `tests/unit/test_converters.py`
490
 
491
  Unit-тесты для конвертеров **OpenAI <-> Kiro**. **50 тестов.**
 
539
  - **Что он делает**: Проверяет объединение list contents
540
  - **Цель**: Убедиться, что списки объединяются корректно
541
 
542
+ - **`test_merges_adjacent_assistant_tool_calls()`**:
543
+ - **Что он делает**: Проверяет объединение tool_calls при merge соседних assistant сообщений
544
+ - **Цель**: Убедиться, что tool_calls из всех assistant сообщений сохраняются при объединении
545
+
546
+ - **`test_merges_three_adjacent_assistant_tool_calls()`**:
547
+ - **Что он делает**: Проверяет объединение tool_calls из трёх assistant сообщений
548
+ - **Цель**: Убедиться, что все tool_calls сохраняются при объединении более двух сообщений
549
+
550
+ - **`test_merges_assistant_with_and_without_tool_calls()`**:
551
+ - **Что он делает**: Проверяет объединение assistant с tool_calls и без
552
+ - **Цель**: Убедиться, что tool_calls корректно инициализируются при объединении
553
+
554
+ #### `TestBuildKiroPayloadToolCallsIntegration`
555
+
556
+ Интеграционные тесты для полного flow tool_calls от OpenAI до Kiro формата.
557
+
558
+ - **`test_multiple_assistant_tool_calls_with_results()`**:
559
+ - **Что он делает**: Проверяет полный сценарий с несколькими assistant tool_calls и их результатами
560
+ - **Цель**: Убедиться, что все toolUses и toolResults корректно связываются в Kiro payload
561
+
562
  #### `TestBuildKiroHistory`
563
 
564
  - **`test_builds_user_message()`**: Проверяет построение user сообщения
tests/unit/test_converters.py CHANGED
@@ -382,6 +382,121 @@ class TestMergeAdjacentMessages:
382
  assert len(result) == 1
383
  assert isinstance(result[0].content, list)
384
  assert len(result[0].content) == 2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
385
 
386
 
387
  class TestBuildKiroHistory:
@@ -916,6 +1031,101 @@ class TestBuildUserInputContext:
916
  assert result == {}
917
 
918
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
919
  class TestBuildKiroPayload:
920
  """Тесты функции build_kiro_payload."""
921
 
 
382
  assert len(result) == 1
383
  assert isinstance(result[0].content, list)
384
  assert len(result[0].content) == 2
385
+
386
+ def test_merges_adjacent_assistant_tool_calls(self):
387
+ """
388
+ Что он делает: Проверяет объединение tool_calls при merge соседних assistant сообщений.
389
+ Цель: Убедиться, что tool_calls из всех assistant сообщений сохраняются при объединении.
390
+
391
+ Это критический тест для бага, когда Codex CLI отправляет несколько assistant
392
+ сообщений подряд, каждое со своим tool_call. Без этого фикса второй tool_call
393
+ терялся, что приводило к ошибке 400 от Kiro API (toolResult без toolUse).
394
+ """
395
+ print("Настройка: Два assistant сообщения с разными tool_calls...")
396
+ messages = [
397
+ ChatMessage(
398
+ role="assistant",
399
+ content=None,
400
+ tool_calls=[{
401
+ "id": "tooluse_first",
402
+ "type": "function",
403
+ "function": {
404
+ "name": "shell",
405
+ "arguments": '{"command": ["ls", "-la"]}'
406
+ }
407
+ }]
408
+ ),
409
+ ChatMessage(
410
+ role="assistant",
411
+ content=None,
412
+ tool_calls=[{
413
+ "id": "tooluse_second",
414
+ "type": "function",
415
+ "function": {
416
+ "name": "shell",
417
+ "arguments": '{"command": ["pwd"]}'
418
+ }
419
+ }]
420
+ )
421
+ ]
422
+
423
+ print("Действие: Объединение сообщений...")
424
+ result = merge_adjacent_messages(messages)
425
+
426
+ print(f"Результат: {result}")
427
+ print(f"Сравниваем длину: Ожидалось 1, Получено {len(result)}")
428
+ assert len(result) == 1
429
+ assert result[0].role == "assistant"
430
+
431
+ print("Проверяем, что оба tool_calls сохранены...")
432
+ assert result[0].tool_calls is not None
433
+ print(f"Сравниваем количество tool_calls: Ожидалось 2, Получено {len(result[0].tool_calls)}")
434
+ assert len(result[0].tool_calls) == 2
435
+
436
+ tool_ids = [tc["id"] for tc in result[0].tool_calls]
437
+ print(f"Tool IDs: {tool_ids}")
438
+ assert "tooluse_first" in tool_ids
439
+ assert "tooluse_second" in tool_ids
440
+
441
+ def test_merges_three_adjacent_assistant_tool_calls(self):
442
+ """
443
+ Что он делает: Проверяет объединение tool_calls из трёх assistant сообщений.
444
+ Цель: Убедиться, что все tool_calls сохраняются при объединении более двух сообщений.
445
+ """
446
+ print("Настройка: Три assistant сообщения с tool_calls...")
447
+ messages = [
448
+ ChatMessage(
449
+ role="assistant",
450
+ content="",
451
+ tool_calls=[{"id": "call_1", "type": "function", "function": {"name": "tool1", "arguments": "{}"}}]
452
+ ),
453
+ ChatMessage(
454
+ role="assistant",
455
+ content="",
456
+ tool_calls=[{"id": "call_2", "type": "function", "function": {"name": "tool2", "arguments": "{}"}}]
457
+ ),
458
+ ChatMessage(
459
+ role="assistant",
460
+ content="",
461
+ tool_calls=[{"id": "call_3", "type": "function", "function": {"name": "tool3", "arguments": "{}"}}]
462
+ )
463
+ ]
464
+
465
+ print("Действие: Объединение сообщений...")
466
+ result = merge_adjacent_messages(messages)
467
+
468
+ print(f"Результат: {result}")
469
+ assert len(result) == 1
470
+ assert len(result[0].tool_calls) == 3
471
+
472
+ tool_ids = [tc["id"] for tc in result[0].tool_calls]
473
+ print(f"Сравниваем tool IDs: Ожидалось ['call_1', 'call_2', 'call_3'], Получено {tool_ids}")
474
+ assert tool_ids == ["call_1", "call_2", "call_3"]
475
+
476
+ def test_merges_assistant_with_and_without_tool_calls(self):
477
+ """
478
+ Что он делает: Проверяет объединение assistant с tool_calls и без.
479
+ Цель: Убедиться, что tool_calls корректно инициализируются при объединении.
480
+ """
481
+ print("Настройка: Assistant без tool_calls + assistant с tool_calls...")
482
+ messages = [
483
+ ChatMessage(role="assistant", content="Thinking...", tool_calls=None),
484
+ ChatMessage(
485
+ role="assistant",
486
+ content="",
487
+ tool_calls=[{"id": "call_1", "type": "function", "function": {"name": "tool1", "arguments": "{}"}}]
488
+ )
489
+ ]
490
+
491
+ print("Действие: Объединение сообщений...")
492
+ result = merge_adjacent_messages(messages)
493
+
494
+ print(f"Результат: {result}")
495
+ assert len(result) == 1
496
+ assert result[0].tool_calls is not None
497
+ print(f"Сравниваем количество tool_calls: Ожидалось 1, Получено {len(result[0].tool_calls)}")
498
+ assert len(result[0].tool_calls) == 1
499
+ assert result[0].tool_calls[0]["id"] == "call_1"
500
 
501
 
502
  class TestBuildKiroHistory:
 
1031
  assert result == {}
1032
 
1033
 
1034
+ class TestBuildKiroPayloadToolCallsIntegration:
1035
+ """
1036
+ Интеграционные тесты для build_kiro_payload с tool_calls.
1037
+ Проверяет полный flow от OpenAI формата до Kiro формата.
1038
+ """
1039
+
1040
+ def test_multiple_assistant_tool_calls_with_results(self):
1041
+ """
1042
+ Что он делает: Проверяет полный сценарий с несколькими assistant tool_calls и их результатами.
1043
+ Цель: Убедиться, что все toolUses и toolResults корректно связываются в Kiro payload.
1044
+
1045
+ Это интеграционный тест для бага Codex CLI, где несколько assistant сообщений
1046
+ с tool_calls отправлялись подряд, а затем tool results. Без фикса второй toolUse
1047
+ терялся, что приводило к ошибке 400 от Kiro API.
1048
+ """
1049
+ print("Настройка: Полный сценарий с двумя tool_calls и их результатами...")
1050
+ request = ChatCompletionRequest(
1051
+ model="claude-sonnet-4-5",
1052
+ messages=[
1053
+ ChatMessage(role="user", content="Run two commands"),
1054
+ # Первый assistant с tool_call
1055
+ ChatMessage(
1056
+ role="assistant",
1057
+ content=None,
1058
+ tool_calls=[{
1059
+ "id": "tooluse_first",
1060
+ "type": "function",
1061
+ "function": {
1062
+ "name": "shell",
1063
+ "arguments": '{"command": ["ls"]}'
1064
+ }
1065
+ }]
1066
+ ),
1067
+ # Второй assistant с tool_call (подряд!)
1068
+ ChatMessage(
1069
+ role="assistant",
1070
+ content=None,
1071
+ tool_calls=[{
1072
+ "id": "tooluse_second",
1073
+ "type": "function",
1074
+ "function": {
1075
+ "name": "shell",
1076
+ "arguments": '{"command": ["pwd"]}'
1077
+ }
1078
+ }]
1079
+ ),
1080
+ # Результаты обоих tool_calls
1081
+ ChatMessage(role="tool", content="file1.txt\nfile2.txt", tool_call_id="tooluse_first"),
1082
+ ChatMessage(role="tool", content="/home/user", tool_call_id="tooluse_second")
1083
+ ]
1084
+ )
1085
+
1086
+ print("Действие: Построение Kiro payload...")
1087
+ result = build_kiro_payload(request, "conv-123", "arn:aws:test")
1088
+
1089
+ print(f"Результат: {result}")
1090
+
1091
+ # Проверяем историю
1092
+ history = result["conversationState"].get("history", [])
1093
+ print(f"История: {history}")
1094
+
1095
+ # Должен быть userInputMessage и assistantResponseMessage в истории
1096
+ assert len(history) >= 2, f"Ожидалось минимум 2 элемента в истории, получено {len(history)}"
1097
+
1098
+ # Находим assistantResponseMessage
1099
+ assistant_msgs = [h for h in history if "assistantResponseMessage" in h]
1100
+ print(f"Assistant сообщения в истории: {assistant_msgs}")
1101
+ assert len(assistant_msgs) >= 1, "Должен быть хотя бы один assistantResponseMessage"
1102
+
1103
+ # Проверяем, что в assistantResponseMessage есть оба toolUses
1104
+ assistant_msg = assistant_msgs[0]["assistantResponseMessage"]
1105
+ tool_uses = assistant_msg.get("toolUses", [])
1106
+ print(f"ToolUses в assistant: {tool_uses}")
1107
+ print(f"Сравниваем количество toolUses: Ожидалось 2, Получено {len(tool_uses)}")
1108
+ assert len(tool_uses) == 2, f"Должно быть 2 toolUses, получено {len(tool_uses)}"
1109
+
1110
+ tool_use_ids = [tu["toolUseId"] for tu in tool_uses]
1111
+ print(f"ToolUse IDs: {tool_use_ids}")
1112
+ assert "tooluse_first" in tool_use_ids
1113
+ assert "tooluse_second" in tool_use_ids
1114
+
1115
+ # Проверяем currentMessage содержит toolResults
1116
+ current_msg = result["conversationState"]["currentMessage"]["userInputMessage"]
1117
+ context = current_msg.get("userInputMessageContext", {})
1118
+ tool_results = context.get("toolResults", [])
1119
+ print(f"ToolResults в currentMessage: {tool_results}")
1120
+ print(f"Сравниваем количество toolResults: Ожидалось 2, Получено {len(tool_results)}")
1121
+ assert len(tool_results) == 2, f"Должно быть 2 toolResults, получено {len(tool_results)}"
1122
+
1123
+ tool_result_ids = [tr["toolUseId"] for tr in tool_results]
1124
+ print(f"ToolResult IDs: {tool_result_ids}")
1125
+ assert "tooluse_first" in tool_result_ids
1126
+ assert "tooluse_second" in tool_result_ids
1127
+
1128
+
1129
  class TestBuildKiroPayload:
1130
  """Тесты функции build_kiro_payload."""
1131
 
tests/unit/test_debug_logger.py ADDED
@@ -0,0 +1,512 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+
3
+ """
4
+ Unit-тесты для DebugLogger.
5
+ Проверяет логику буферизации и записи debug логов в разных режимах.
6
+ """
7
+
8
+ import json
9
+ import pytest
10
+ from pathlib import Path
11
+ from unittest.mock import patch, MagicMock
12
+
13
+
14
+ class TestDebugLoggerModeOff:
15
+ """Тесты для режима DEBUG_MODE=off."""
16
+
17
+ def test_prepare_new_request_does_nothing(self, tmp_path):
18
+ """
19
+ Что он делает: Проверяет, что prepare_new_request ничего не делает в режиме off.
20
+ Цель: Убедиться, что в режиме off директория не создаётся.
21
+ """
22
+ print("Настройка: Режим off...")
23
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'off'):
24
+ with patch('kiro_gateway.debug_logger.DEBUG_DIR', str(tmp_path / "debug_logs")):
25
+ # Пересоздаём экземпляр с новыми настройками
26
+ from kiro_gateway.debug_logger import DebugLogger
27
+ logger = DebugLogger.__new__(DebugLogger)
28
+ logger._initialized = False
29
+ logger.__init__()
30
+ logger.debug_dir = tmp_path / "debug_logs"
31
+
32
+ print("Действие: Вызов prepare_new_request...")
33
+ logger.prepare_new_request()
34
+
35
+ print(f"Проверяем, что директория не создана...")
36
+ assert not (tmp_path / "debug_logs").exists()
37
+
38
+ def test_log_request_body_does_nothing(self, tmp_path):
39
+ """
40
+ Что он делает: Проверяет, что log_request_body ничего не делает в режиме off.
41
+ Цель: Убедиться, что данные не записываются.
42
+ """
43
+ print("Настройка: Режим off...")
44
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'off'):
45
+ from kiro_gateway.debug_logger import DebugLogger
46
+ logger = DebugLogger.__new__(DebugLogger)
47
+ logger._initialized = False
48
+ logger.__init__()
49
+ logger.debug_dir = tmp_path / "debug_logs"
50
+
51
+ print("Действие: Вызов log_request_body...")
52
+ logger.log_request_body(b'{"test": "data"}')
53
+
54
+ print(f"Проверяем, что файл не создан...")
55
+ assert not (tmp_path / "debug_logs" / "request_body.json").exists()
56
+
57
+
58
+ class TestDebugLoggerModeAll:
59
+ """Тесты для режима DEBUG_MODE=all."""
60
+
61
+ def test_prepare_new_request_clears_directory(self, tmp_path):
62
+ """
63
+ Что он делает: Проверяет, что prepare_new_request очищает директорию в режиме all.
64
+ Цель: Убедиться, что старые логи удаляются.
65
+ """
66
+ print("Настройка: Режим all, создаём старый файл...")
67
+ debug_dir = tmp_path / "debug_logs"
68
+ debug_dir.mkdir()
69
+ old_file = debug_dir / "old_file.txt"
70
+ old_file.write_text("old content")
71
+
72
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
73
+ from kiro_gateway.debug_logger import DebugLogger
74
+ logger = DebugLogger.__new__(DebugLogger)
75
+ logger._initialized = False
76
+ logger.__init__()
77
+ logger.debug_dir = debug_dir
78
+
79
+ print("Действие: Вызов prepare_new_request...")
80
+ logger.prepare_new_request()
81
+
82
+ print(f"Проверяем, что старый файл удалён...")
83
+ assert not old_file.exists()
84
+ print(f"Проверяем, что директория существует...")
85
+ assert debug_dir.exists()
86
+
87
+ def test_log_request_body_writes_immediately(self, tmp_path):
88
+ """
89
+ Что он делает: Проверяет, что log_request_body пишет сразу в файл в режиме all.
90
+ Цель: Убедиться, что данные записываются немедленно.
91
+ """
92
+ print("Настройка: Режим all...")
93
+ debug_dir = tmp_path / "debug_logs"
94
+ debug_dir.mkdir()
95
+
96
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
97
+ from kiro_gateway.debug_logger import DebugLogger
98
+ logger = DebugLogger.__new__(DebugLogger)
99
+ logger._initialized = False
100
+ logger.__init__()
101
+ logger.debug_dir = debug_dir
102
+
103
+ print("Действие: Вызов log_request_body...")
104
+ test_data = b'{"model": "test", "messages": []}'
105
+ logger.log_request_body(test_data)
106
+
107
+ print(f"Проверяем, что файл создан...")
108
+ file_path = debug_dir / "request_body.json"
109
+ assert file_path.exists()
110
+
111
+ print(f"Проверяем содержимое файла...")
112
+ content = json.loads(file_path.read_text())
113
+ assert content["model"] == "test"
114
+
115
+ def test_log_kiro_request_body_writes_immediately(self, tmp_path):
116
+ """
117
+ Что он делает: Проверяет, что log_kiro_request_body пишет сразу в файл в режиме all.
118
+ Цель: Убедиться, что Kiro payload записывается немедленно.
119
+ """
120
+ print("Настройка: Режим all...")
121
+ debug_dir = tmp_path / "debug_logs"
122
+ debug_dir.mkdir()
123
+
124
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
125
+ from kiro_gateway.debug_logger import DebugLogger
126
+ logger = DebugLogger.__new__(DebugLogger)
127
+ logger._initialized = False
128
+ logger.__init__()
129
+ logger.debug_dir = debug_dir
130
+
131
+ print("Действие: Вызов log_kiro_request_body...")
132
+ test_data = b'{"conversationState": {}}'
133
+ logger.log_kiro_request_body(test_data)
134
+
135
+ print(f"Проверяем, что файл создан...")
136
+ file_path = debug_dir / "kiro_request_body.json"
137
+ assert file_path.exists()
138
+
139
+ def test_log_raw_chunk_appends_to_file(self, tmp_path):
140
+ """
141
+ Что он делает: Проверяет, что log_raw_chunk дописывает в файл в режиме all.
142
+ Цель: Убедиться, что чанки накапливаются.
143
+ """
144
+ print("Настройка: Режим all...")
145
+ debug_dir = tmp_path / "debug_logs"
146
+ debug_dir.mkdir()
147
+
148
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
149
+ from kiro_gateway.debug_logger import DebugLogger
150
+ logger = DebugLogger.__new__(DebugLogger)
151
+ logger._initialized = False
152
+ logger.__init__()
153
+ logger.debug_dir = debug_dir
154
+
155
+ print("Действие: Вызов log_raw_chunk дважды...")
156
+ logger.log_raw_chunk(b'chunk1')
157
+ logger.log_raw_chunk(b'chunk2')
158
+
159
+ print(f"Проверяем содержимое файла...")
160
+ file_path = debug_dir / "response_stream_raw.txt"
161
+ content = file_path.read_bytes()
162
+ assert content == b'chunk1chunk2'
163
+
164
+
165
+ class TestDebugLoggerModeErrors:
166
+ """Тесты для режима DEBUG_MODE=errors."""
167
+
168
+ def test_log_request_body_buffers_data(self, tmp_path):
169
+ """
170
+ Что он делает: Проверяет, что log_request_body буферизует данные в режиме errors.
171
+ Цель: Убедиться, что данные не записываются сразу.
172
+ """
173
+ print("Настройка: Режим errors...")
174
+ debug_dir = tmp_path / "debug_logs"
175
+
176
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'errors'):
177
+ from kiro_gateway.debug_logger import DebugLogger
178
+ logger = DebugLogger.__new__(DebugLogger)
179
+ logger._initialized = False
180
+ logger.__init__()
181
+ logger.debug_dir = debug_dir
182
+
183
+ print("Действие: Вызов log_request_body...")
184
+ test_data = b'{"test": "buffered"}'
185
+ logger.log_request_body(test_data)
186
+
187
+ print(f"Проверяем, что файл НЕ создан...")
188
+ assert not debug_dir.exists()
189
+
190
+ print(f"Проверяем, что данные в буфере...")
191
+ assert logger._request_body_buffer == test_data
192
+
193
+ def test_flush_on_error_writes_buffers(self, tmp_path):
194
+ """
195
+ Что он делает: Проверяет, что flush_on_error записывает буферы в файлы.
196
+ Цель: Убедиться, что при ошибке данные сохраняются.
197
+ """
198
+ print("Настройка: Режим errors, заполняем буферы...")
199
+ debug_dir = tmp_path / "debug_logs"
200
+
201
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'errors'):
202
+ from kiro_gateway.debug_logger import DebugLogger
203
+ logger = DebugLogger.__new__(DebugLogger)
204
+ logger._initialized = False
205
+ logger.__init__()
206
+ logger.debug_dir = debug_dir
207
+
208
+ # Заполняем буферы
209
+ logger.log_request_body(b'{"request": "body"}')
210
+ logger.log_kiro_request_body(b'{"kiro": "request"}')
211
+ logger.log_raw_chunk(b'raw_chunk')
212
+ logger.log_modified_chunk(b'modified_chunk')
213
+
214
+ print("Действие: Вызов flush_on_error...")
215
+ logger.flush_on_error(400, "Bad Request")
216
+
217
+ print(f"Проверяем, что все файлы созданы...")
218
+ assert (debug_dir / "request_body.json").exists()
219
+ assert (debug_dir / "kiro_request_body.json").exists()
220
+ assert (debug_dir / "response_stream_raw.txt").exists()
221
+ assert (debug_dir / "response_stream_modified.txt").exists()
222
+ assert (debug_dir / "error_info.json").exists()
223
+
224
+ print(f"Проверяем error_info.json...")
225
+ error_info = json.loads((debug_dir / "error_info.json").read_text())
226
+ assert error_info["status_code"] == 400
227
+ assert error_info["error_message"] == "Bad Request"
228
+
229
+ def test_flush_on_error_clears_buffers(self, tmp_path):
230
+ """
231
+ Что он делает: Проверяет, что flush_on_error очищает буферы после записи.
232
+ Цель: Убедиться, что буферы не накапливаются между запросами.
233
+ """
234
+ print("Настройка: Режим errors...")
235
+ debug_dir = tmp_path / "debug_logs"
236
+
237
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'errors'):
238
+ from kiro_gateway.debug_logger import DebugLogger
239
+ logger = DebugLogger.__new__(DebugLogger)
240
+ logger._initialized = False
241
+ logger.__init__()
242
+ logger.debug_dir = debug_dir
243
+
244
+ logger.log_request_body(b'{"test": "data"}')
245
+
246
+ print("Действие: Вызов flush_on_error...")
247
+ logger.flush_on_error(500, "Error")
248
+
249
+ print(f"Проверяем, что буферы очищены...")
250
+ assert logger._request_body_buffer is None
251
+ assert logger._kiro_request_body_buffer is None
252
+ assert len(logger._raw_chunks_buffer) == 0
253
+ assert len(logger._modified_chunks_buffer) == 0
254
+
255
+ def test_discard_buffers_clears_without_writing(self, tmp_path):
256
+ """
257
+ Что он делает: Проверяет, что discard_buffers очищает буферы без записи.
258
+ Цель: Убедиться, что успешные запросы не оставляют логов.
259
+ """
260
+ print("Настройка: Режим errors, заполняем буферы...")
261
+ debug_dir = tmp_path / "debug_logs"
262
+
263
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'errors'):
264
+ from kiro_gateway.debug_logger import DebugLogger
265
+ logger = DebugLogger.__new__(DebugLogger)
266
+ logger._initialized = False
267
+ logger.__init__()
268
+ logger.debug_dir = debug_dir
269
+
270
+ logger.log_request_body(b'{"test": "data"}')
271
+ logger.log_raw_chunk(b'chunk')
272
+
273
+ print("Действие: Вызов discard_buffers...")
274
+ logger.discard_buffers()
275
+
276
+ print(f"Проверяем, что директория НЕ создана...")
277
+ assert not debug_dir.exists()
278
+
279
+ print(f"Проверяем, что буферы очищены...")
280
+ assert logger._request_body_buffer is None
281
+ assert len(logger._raw_chunks_buffer) == 0
282
+
283
+ def test_flush_on_error_writes_error_info_in_mode_all(self, tmp_path):
284
+ """
285
+ Что он делает: Проверяет, что flush_on_error записывает error_info.json в режиме all.
286
+ Цель: Убедиться, что информация об ошибке сохраняется в обоих режимах.
287
+ """
288
+ print("Настройка: Режим all...")
289
+ debug_dir = tmp_path / "debug_logs"
290
+
291
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
292
+ from kiro_gateway.debug_logger import DebugLogger
293
+ logger = DebugLogger.__new__(DebugLogger)
294
+ logger._initialized = False
295
+ logger.__init__()
296
+ logger.debug_dir = debug_dir
297
+
298
+ print("Действие: Вызов flush_on_error...")
299
+ logger.flush_on_error(400, "Bad Request")
300
+
301
+ print(f"Проверяем, что error_info.json создан...")
302
+ assert (debug_dir / "error_info.json").exists()
303
+
304
+ print(f"Проверяем содержимое error_info.json...")
305
+ error_info = json.loads((debug_dir / "error_info.json").read_text())
306
+ assert error_info["status_code"] == 400
307
+ assert error_info["error_message"] == "Bad Request"
308
+
309
+
310
+ class TestDebugLoggerLogErrorInfo:
311
+ """Тесты для метода log_error_info()."""
312
+
313
+ def test_log_error_info_writes_in_mode_all(self, tmp_path):
314
+ """
315
+ Что он делает: Проверяет, что log_error_info записывает файл в режиме all.
316
+ Цель: Убедиться, что error_info.json создаётся при ошибках.
317
+ """
318
+ print("Настройка: Режим all...")
319
+ debug_dir = tmp_path / "debug_logs"
320
+
321
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
322
+ from kiro_gateway.debug_logger import DebugLogger
323
+ logger = DebugLogger.__new__(DebugLogger)
324
+ logger._initialized = False
325
+ logger.__init__()
326
+ logger.debug_dir = debug_dir
327
+
328
+ print("Действие: Вызов log_error_info...")
329
+ logger.log_error_info(500, "Internal Server Error")
330
+
331
+ print(f"Проверяем, что error_info.json создан...")
332
+ error_file = debug_dir / "error_info.json"
333
+ assert error_file.exists()
334
+
335
+ print(f"Проверяем содержимое...")
336
+ error_info = json.loads(error_file.read_text())
337
+ assert error_info["status_code"] == 500
338
+ assert error_info["error_message"] == "Internal Server Error"
339
+
340
+ def test_log_error_info_writes_in_mode_errors(self, tmp_path):
341
+ """
342
+ Что он делает: Проверяет, что log_error_info записывает файл в режиме errors.
343
+ Цель: Убедиться, что метод работает в обоих режимах.
344
+ """
345
+ print("Настройка: Режим errors...")
346
+ debug_dir = tmp_path / "debug_logs"
347
+
348
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'errors'):
349
+ from kiro_gateway.debug_logger import DebugLogger
350
+ logger = DebugLogger.__new__(DebugLogger)
351
+ logger._initialized = False
352
+ logger.__init__()
353
+ logger.debug_dir = debug_dir
354
+
355
+ print("Действие: Вызов log_error_info...")
356
+ logger.log_error_info(404, "Not Found")
357
+
358
+ print(f"Проверяем, что error_info.json создан...")
359
+ error_file = debug_dir / "error_info.json"
360
+ assert error_file.exists()
361
+
362
+ def test_log_error_info_does_nothing_in_mode_off(self, tmp_path):
363
+ """
364
+ Что он делает: Проверяет, что log_error_info ничего не делает в режиме off.
365
+ Цель: Убедиться, что в режиме off файлы не создаются.
366
+ """
367
+ print("Настройка: Режим off...")
368
+ debug_dir = tmp_path / "debug_logs"
369
+
370
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'off'):
371
+ from kiro_gateway.debug_logger import DebugLogger
372
+ logger = DebugLogger.__new__(DebugLogger)
373
+ logger._initialized = False
374
+ logger.__init__()
375
+ logger.debug_dir = debug_dir
376
+
377
+ print("Действие: Вызов log_error_info...")
378
+ logger.log_error_info(500, "Error")
379
+
380
+ print(f"Проверяем, что директория НЕ создана...")
381
+ assert not debug_dir.exists()
382
+
383
+
384
+ class TestDebugLoggerHelperMethods:
385
+ """Тесты для вспомогательных методов DebugLogger."""
386
+
387
+ def test_is_enabled_returns_true_for_errors(self):
388
+ """
389
+ Что он делает: Проверяет _is_enabled() для режима errors.
390
+ Цель: Убедиться, что режим errors считается включённым.
391
+ """
392
+ print("Настройка: Режим errors...")
393
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'errors'):
394
+ from kiro_gateway.debug_logger import DebugLogger
395
+ logger = DebugLogger.__new__(DebugLogger)
396
+ logger._initialized = False
397
+ logger.__init__()
398
+
399
+ print(f"Проверяем _is_enabled()...")
400
+ assert logger._is_enabled() is True
401
+
402
+ def test_is_enabled_returns_true_for_all(self):
403
+ """
404
+ Что он делает: Проверяет _is_enabled() для режима all.
405
+ Цель: Убедиться, что режим all считается включённым.
406
+ """
407
+ print("Настройка: Режим all...")
408
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
409
+ from kiro_gateway.debug_logger import DebugLogger
410
+ logger = DebugLogger.__new__(DebugLogger)
411
+ logger._initialized = False
412
+ logger.__init__()
413
+
414
+ print(f"Проверяем _is_enabled()...")
415
+ assert logger._is_enabled() is True
416
+
417
+ def test_is_enabled_returns_false_for_off(self):
418
+ """
419
+ Что он делает: Проверяет _is_enabled() для режима off.
420
+ Цель: Убедиться, что режим off считается выключенным.
421
+ """
422
+ print("Настройка: Режим off...")
423
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'off'):
424
+ from kiro_gateway.debug_logger import DebugLogger
425
+ logger = DebugLogger.__new__(DebugLogger)
426
+ logger._initialized = False
427
+ logger.__init__()
428
+
429
+ print(f"Проверяем _is_enabled()...")
430
+ assert logger._is_enabled() is False
431
+
432
+ def test_is_immediate_write_returns_true_for_all(self):
433
+ """
434
+ Что он делает: Проверяет _is_immediate_write() для режима all.
435
+ Цель: Убедиться, что режим all пишет сразу.
436
+ """
437
+ print("Настройка: Режим all...")
438
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
439
+ from kiro_gateway.debug_logger import DebugLogger
440
+ logger = DebugLogger.__new__(DebugLogger)
441
+ logger._initialized = False
442
+ logger.__init__()
443
+
444
+ print(f"Проверяем _is_immediate_write()...")
445
+ assert logger._is_immediate_write() is True
446
+
447
+ def test_is_immediate_write_returns_false_for_errors(self):
448
+ """
449
+ Что он делает: Проверяет _is_immediate_write() для режима errors.
450
+ Цель: Убедиться, что режим errors буферизует.
451
+ """
452
+ print("Настройка: Режим errors...")
453
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'errors'):
454
+ from kiro_gateway.debug_logger import DebugLogger
455
+ logger = DebugLogger.__new__(DebugLogger)
456
+ logger._initialized = False
457
+ logger.__init__()
458
+
459
+ print(f"Проверяем _is_immediate_write()...")
460
+ assert logger._is_immediate_write() is False
461
+
462
+
463
+ class TestDebugLoggerJsonHandling:
464
+ """Тесты для обработки JSON в DebugLogger."""
465
+
466
+ def test_log_request_body_formats_json_pretty(self, tmp_path):
467
+ """
468
+ Что он делает: Проверяет, что JSON форматируется красиво.
469
+ Цель: Убедиться, что JSON читаем в файле.
470
+ """
471
+ print("Настройка: Режим all...")
472
+ debug_dir = tmp_path / "debug_logs"
473
+ debug_dir.mkdir()
474
+
475
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
476
+ from kiro_gateway.debug_logger import DebugLogger
477
+ logger = DebugLogger.__new__(DebugLogger)
478
+ logger._initialized = False
479
+ logger.__init__()
480
+ logger.debug_dir = debug_dir
481
+
482
+ print("Действие: Вызов log_request_body с JSON...")
483
+ logger.log_request_body(b'{"key":"value"}')
484
+
485
+ print(f"Проверяем форматирование...")
486
+ content = (debug_dir / "request_body.json").read_text()
487
+ # Должен быть отформатирован с отступами
488
+ assert " " in content or "\n" in content
489
+
490
+ def test_log_request_body_handles_invalid_json(self, tmp_path):
491
+ """
492
+ Что он делает: Проверяет обработку невалидного JSON.
493
+ Цель: Убедиться, что невалидный JSON записывается как есть.
494
+ """
495
+ print("Настройка: Режим all...")
496
+ debug_dir = tmp_path / "debug_logs"
497
+ debug_dir.mkdir()
498
+
499
+ with patch('kiro_gateway.debug_logger.DEBUG_MODE', 'all'):
500
+ from kiro_gateway.debug_logger import DebugLogger
501
+ logger = DebugLogger.__new__(DebugLogger)
502
+ logger._initialized = False
503
+ logger.__init__()
504
+ logger.debug_dir = debug_dir
505
+
506
+ print("Действие: Вызов log_request_body с невалидным JSON...")
507
+ invalid_data = b'not a json {{'
508
+ logger.log_request_body(invalid_data)
509
+
510
+ print(f"Проверяем, что данные записаны как есть...")
511
+ content = (debug_dir / "request_body.json").read_bytes()
512
+ assert content == invalid_data