OUTPUT #895 | 5575 karakter | 134 satır
========== YENİ KOMUT | 21.09.2026 16:22:22 ==========
========== YENİ KOMUT | 21.09.2026 16:22:22 ==========
def _get_auxiliary_task_config(task: str) -> Dict[str, Any]:
"""Config dict for auxiliary.<task>, or {} when unavailable. Plugin-registered tasks get their
declared defaults layered under user config (user wins); built-in defaults live in DEFAULT_CONFIG."""
if not task:
return {}
try:
from hermes_cli.config import load_config_readonly
config = load_config_readonly()
except ImportError:
return {}
aux = config.get("auxiliary", {}) if isinstance(config, dict) else {}
task_config = aux.get(task, {}) if isinstance(aux, dict) else {}
if not isinstance(task_config, dict):
task_config = {}
try:
from hermes_cli.plugins import get_plugin_auxiliary_tasks
for _entry in get_plugin_auxiliary_tasks():
if _entry.get("key") == task:
_defaults = _entry.get("defaults") or {}
if isinstance(_defaults, dict):
return {**_defaults, **task_config}
break
except Exception:
pass # plugin discovery failure must not break aux task config reads
return task_config
class CompressionFastLane(NamedTuple):
"""Explicit, non-reasoning compression route."""
certified_non_reasoning: bool
def _cached_semaphore(store: dict, key: Any, limit: int, factory: Callable[[int], Any]) -> Any:
"""Return the cached semaphore for ``key``, rebuilding it when the limit changed."""
with _aux_sem_lock:
entry = store.get(key)
if entry is None or entry[0] != limit:
store[key] = entry = (limit, factory(limit))
return entry[1]
def _acquire_sync_aux_semaphore(task: Optional[str]) -> Optional[threading.BoundedSemaphore]:
"""Get a per-task sync semaphore, rebuilding it after a config change."""
limit = _get_task_max_concurrency(task)
return None if limit is None else _cached_semaphore(_aux_sync_semaphores, task, limit, threading.BoundedSemaphore)
def _acquire_async_aux_semaphore(task: Optional[str]):
"""Get a per-task, per-event-loop async semaphore after config lookup."""
limit = _get_task_max_concurrency(task)
if limit is None:
return None
import asyncio
try:
loop = asyncio.get_running_loop()
except RuntimeError:
return None
return _cached_semaphore(_aux_async_semaphores, (task, id(loop)), limit, asyncio.Semaphore)
def _reset_aux_semaphores() -> None:
"""Drop cached semaphores (test helper)."""
with _aux_sem_lock:
_aux_sync_semaphores.clear()
_aux_async_semaphores.clear()
# Anthropic-compatible endpoints reached via the OpenAI SDK wrapper; their image content blocks
# must use Anthropic format.
_ANTHROPIC_COMPAT_PROVIDERS = frozenset({"minimax", "minimax-oauth", "minimax-cn"})
def _is_anthropic_compat_endpoint(provider: str, base_url: str) -> bool:
"""True for known Anthropic-compatible providers or any ``/anthropic`` URL path."""
return provider in _ANTHROPIC_COMPAT_PROVIDERS or "/anthropic" in (base_url or "").lower()
# OpenAI block type → (Anthropic block type, default media type for data: URLs). MiniMax's
# Anthropic-compatible endpoint wants type="video" (not "video_url"/"input_video") with the same
# ``source`` shape as "image".
_ANTHROPIC_MEDIA_BLOCKS = {"image_url": ("image", "image/png"), "video_url": ("video", "video/mp4")}
def _convert_openai_images_to_anthropic(messages: list) -> list:
"""Convert OpenAI ``image_url``/``video_url`` blocks to Anthropic ``image``/``video``;
only list-content messages with such blocks change."""
converted = []
for msg in messages:
content = msg.get("content")
if not isinstance(content, list):
converted.append(msg)
continue
new_content = []
changed = False
for block in content:
block_type = block.get("type")
if block_type not in _ANTHROPIC_MEDIA_BLOCKS:
new_content.append(block)
continue
url = (block.get(block_type) or {}).get("url", "")
anth_type, media_type = _ANTHROPIC_MEDIA_BLOCKS[block_type]
if url.startswith("data:"):
header, _, b64data = url.partition(",")
if ":" in header and ";" in header:
media_type = header.split(":", 1)[1].split(";", 1)[0]
source = {"type": "base64", "media_type": media_type, "data": b64data}
else:
source = {"type": "url", "url": url}
new_content.append({"type": anth_type, "source": source})
changed = True
converted.append({**msg, "content": new_content} if changed else msg)
return converted
_PROFILE_REASONING_KEYS = {
"reasoning", "reasoning_effort", "thinking", "thinking_config", "thinkingconfig",
"thinking_budget", "thinkingbudget", "enable_thinking", "think", "verbosity",
}
def _contains_profile_reasoning_fields(value: Any) -> bool:
"""Return whether a profile payload contains a reasoning wire control (recursive)."""
if not isinstance(value, dict):
return False
return any(
str(key).strip().lower() in _PROFILE_REASONING_KEYS or _contains_profile_reasoning_fields(nested)
for key, nested in value.items()
root@213-238-170-219:~#