agentengine-sdk-python 0.6.9__py3-none-any.whl → 0.8.0__py3-none-any.whl

ksadk/conversations/model_context.py

@@ -79,12 +79,12 @@ def _coerce_token_limit(value: Any, *, assume_k_for_plain_values: bool = False)
         text = text[:-1]
 
     try:
-        parsed = float(text)
+        parsed_number = float(text)
     except (TypeError, ValueError):
         return None
-    if parsed <= 0:
+    if parsed_number <= 0:
         return None
-    resolved = int(parsed * multiplier)
+    resolved = int(parsed_number * multiplier)
     if multiplier == 1 and assume_k_for_plain_values and text.isdigit() and 0 < resolved <= 1000:
         return resolved * 1000
     return resolved
@@ -182,6 +182,18 @@ def estimate_text_tokens(text: str) -> int:
     return max(1, cjk_tokens + math.ceil(ascii_chars / 4))
 
 
+def get_context_window_tokens(model_metadata: Mapping[str, Any] | None = None) -> int:
+    limits = dict(DEFAULT_MODEL_LIMITS)
+    if isinstance(model_metadata, Mapping):
+        limits.update(dict(model_metadata.get("limits") or {}))
+        if model_metadata.get("context_window_tokens"):
+            limits["context_window_tokens"] = model_metadata["context_window_tokens"]
+
+    return (
+        _coerce_positive_int(limits.get("context_window_tokens")) or DEFAULT_CONTEXT_WINDOW_TOKENS
+    )
+
+
 def get_effective_context_window_tokens(model_metadata: Mapping[str, Any] | None = None) -> int:
     limits = dict(DEFAULT_MODEL_LIMITS)
     if isinstance(model_metadata, Mapping):
@@ -191,8 +203,10 @@ def get_effective_context_window_tokens(model_metadata: Mapping[str, Any] | None
         if model_metadata.get("max_output_tokens"):
             limits["max_output_tokens"] = model_metadata["max_output_tokens"]
 
-    context_window = _coerce_positive_int(limits.get("context_window_tokens")) or DEFAULT_CONTEXT_WINDOW_TOKENS
-    max_output_tokens = _coerce_positive_int(limits.get("max_output_tokens")) or DEFAULT_MAX_OUTPUT_TOKENS
+    context_window = get_context_window_tokens(model_metadata)
+    max_output_tokens = (
+        _coerce_positive_int(limits.get("max_output_tokens")) or DEFAULT_MAX_OUTPUT_TOKENS
+    )
     reserved_tokens = min(max_output_tokens, AUTOCOMPACT_SUMMARY_RESERVE_TOKENS)
     return max(1, context_window - reserved_tokens)
 
@@ -356,5 +370,7 @@ def normalize_model_metadata(raw_model: Mapping[str, Any] | str | None) -> dict[
         "pricing": pricing,
     }
     normalized["auto_compact_threshold_tokens"] = get_auto_compact_threshold_tokens(normalized)
-    normalized["auto_compact_threshold_percentage"] = get_auto_compact_threshold_percentage(normalized)
+    normalized["auto_compact_threshold_percentage"] = get_auto_compact_threshold_percentage(
+        normalized
+    )
     return normalized

ksadk/conversations/model_options.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import Any, Mapping
 
-
 _VALID_REASONING_EFFORTS = {"none", "minimal", "low", "medium", "high", "xhigh"}
 _CHAT_COMPLETIONS_REASONING_EFFORTS = {"low", "medium", "high"}
 _PASSTHROUGH_OPTION_KEYS = {"temperature", "top_p", "max_tokens", "max_completion_tokens"}

ksadk/conversations/normalize.py

@@ -1,21 +1,15 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
 from pathlib import Path
+from typing import Any, Dict, List, Optional
 
 from ksadk.conversations.attachments import (
     build_attachment_prompt_text,
     build_attachment_results,
-    compact_attachment_result_for_session,
     decode_inline_data,
-    extract_pdf_text,
-    is_textual_mime,
     looks_like_textual_attachment,
-    read_attachment_bytes,
     resolve_attachment_storage_path,
-    resolve_uploads_dir,
 )
-from ksadk.conversations.context import canonical_event_type
 from ksadk.server.api_models import Part
 
 
@@ -110,7 +104,9 @@ def _inline_data_from_openai_file(item: Dict[str, Any]) -> Optional[Dict[str, An
     display_name = _openai_file_display_name(item)
     return {
         "data": data.strip(),
-        "mimeType": str(item.get("mime_type") or item.get("mimeType") or _guess_mime_type(display_name)),
+        "mimeType": str(
+            item.get("mime_type") or item.get("mimeType") or _guess_mime_type(display_name)
+        ),
         "displayName": display_name,
     }
 
@@ -122,7 +118,9 @@ def _file_data_from_openai_file(item: Dict[str, Any]) -> Optional[Dict[str, Any]
     display_name = _openai_file_display_name(item)
     return {
         "fileUri": file_uri.strip(),
-        "mimeType": str(item.get("mime_type") or item.get("mimeType") or _guess_mime_type(display_name)),
+        "mimeType": str(
+            item.get("mime_type") or item.get("mimeType") or _guess_mime_type(display_name)
+        ),
         "displayName": display_name,
     }
 
@@ -173,9 +171,7 @@ def _canonical_input_content_from_part_payload(payload: Dict[str, Any]) -> Optio
 
 def _canonical_input_content_from_item(item: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     item_type = str(item.get("type") or "").strip()
-    if item_type in {"input_text", "text"} or (
-        not item_type and item.get("text") is not None
-    ):
+    if item_type in {"input_text", "text"} or (not item_type and item.get("text") is not None):
         return {"type": "input_text", "text": str(item.get("text") or "")}
 
     if item_type in {"input_image", "image_url"}:
@@ -318,7 +314,9 @@ def attachment_from_part(part: Part) -> Optional[Dict[str, Any]]:
         mime_type = (file_data.mimeType or "").strip() or "application/octet-stream"
         storage_path = resolve_attachment_storage_path(file_data.fileUri or "")
         try:
-            size_bytes = storage_path.stat().st_size if storage_path and storage_path.exists() else None
+            size_bytes = (
+                storage_path.stat().st_size if storage_path and storage_path.exists() else None
+            )
         except OSError:
             size_bytes = None
         return {
@@ -360,7 +358,9 @@ def display_content_from_parts(parts: List[Part]) -> str:
 
 
 def normalize_parts_content(parts: List[Part]) -> dict[str, Any]:
-    attachments = [attachment for attachment in (attachment_from_part(part) for part in parts) if attachment]
+    attachments = [
+        attachment for attachment in (attachment_from_part(part) for part in parts) if attachment
+    ]
     attachment_results = build_attachment_results(attachments)
     display_content = display_content_from_parts(parts)
     segments: List[str] = []
@@ -373,7 +373,9 @@ def normalize_parts_content(parts: List[Part]) -> dict[str, Any]:
             segments.append(build_attachment_prompt_text(attachment_results[attachment_index]))
             attachment_index += 1
     return {
-        "content": "\n\n".join(segment.strip() for segment in segments if str(segment).strip()).strip(),
+        "content": "\n\n".join(
+            segment.strip() for segment in segments if str(segment).strip()
+        ).strip(),
         "display_content": display_content,
         "parts": [part.model_dump(exclude_none=True) for part in parts],
         "attachments": attachments,
@@ -436,7 +438,9 @@ def normalize_responses_input(input_payload: Any) -> List[Dict[str, Any]]:
                 "content": input_payload,
                 "display_content": input_payload,
                 "parts": [{"text": input_payload}] if input_payload else [],
-                "input_content": [{"type": "input_text", "text": input_payload}] if input_payload else [],
+                "input_content": (
+                    [{"type": "input_text", "text": input_payload}] if input_payload else []
+                ),
                 "attachments": [],
                 "attachment_results": [],
             }

ksadk/conversations/reasoning_markup.py

@@ -30,7 +30,7 @@ class ReasoningMarkupParser:
             index = self._buffer.find(tag)
             if index >= 0:
                 self._append(parts, self._buffer[:index])
-                self._buffer = self._buffer[index + len(tag):]
+                self._buffer = self._buffer[index + len(tag) :]
                 self._in_think = not self._in_think
                 continue