475 lines
21 KiB
Python
475 lines
21 KiB
Python
from __future__ import annotations
|
||
|
||
import json
|
||
from typing import Any, Dict, List, Optional
|
||
|
||
from agentui.providers.adapters.base import ( # [ProviderAdapter](agentui/providers/adapters/base.py:10)
|
||
ProviderAdapter,
|
||
insert_items,
|
||
split_pos_spec,
|
||
)
|
||
|
||
|
||
def _is_data_url(u: str) -> bool: # [_is_data_url()](agentui/providers/adapters/claude.py:14)
|
||
return isinstance(u, str) and u.strip().lower().startswith("data:")
|
||
|
||
|
||
def _split_data_url(u: str) -> tuple[str, str]: # [_split_data_url()](agentui/providers/adapters/claude.py:18)
|
||
"""
|
||
Возвращает (mime, b64) для data URL.
|
||
Поддерживаем форму: data:<mime>;base64,<b64>
|
||
"""
|
||
try:
|
||
header, b64 = u.split(",", 1)
|
||
mime = "application/octet-stream"
|
||
if header.startswith("data:"):
|
||
header2 = header[5:]
|
||
if ";base64" in header2:
|
||
mime = header2.split(";base64", 1)[0] or mime
|
||
elif ";" in header2:
|
||
mime = header2.split(";", 1)[0] or mime
|
||
elif header2:
|
||
mime = header2
|
||
return mime, b64
|
||
except Exception:
|
||
return "application/octet-stream", ""
|
||
|
||
|
||
def _try_json(s: str) -> Any: # [_try_json()](agentui/providers/adapters/claude.py:38)
|
||
try:
|
||
obj = json.loads(s)
|
||
except Exception:
|
||
try:
|
||
obj = json.loads(s, strict=False) # type: ignore[call-arg]
|
||
except Exception:
|
||
return None
|
||
for _ in range(2):
|
||
if isinstance(obj, str):
|
||
st = obj.strip()
|
||
if (st.startswith("{") and st.endswith("}")) or (st.startswith("[") and st.endswith("]")):
|
||
try:
|
||
obj = json.loads(st)
|
||
continue
|
||
except Exception:
|
||
break
|
||
break
|
||
return obj
|
||
|
||
|
||
class ClaudeAdapter(ProviderAdapter): # [ClaudeAdapter.__init__()](agentui/providers/adapters/claude.py:56)
|
||
name = "claude"
|
||
|
||
# --- Дефолты HTTP ---
|
||
def default_base_url(self) -> str:
|
||
return "https://api.anthropic.com"
|
||
|
||
def default_endpoint(self, model: str) -> str:
|
||
return "/v1/messages"
|
||
|
||
# --- PROMPT: построение провайдерных структур ---
|
||
|
||
def blocks_struct_for_template(
|
||
self,
|
||
unified_messages: List[Dict[str, Any]],
|
||
context: Dict[str, Any],
|
||
node_config: Dict[str, Any],
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
Совместимо с веткой provider=='claude' из
|
||
[ProviderCallNode._blocks_struct_for_template()](agentui/pipeline/executor.py:2022).
|
||
"""
|
||
# Системные сообщения как текст
|
||
sys_msgs = []
|
||
for m in (unified_messages or []):
|
||
if m.get("role") == "system":
|
||
c = m.get("content")
|
||
if isinstance(c, list):
|
||
sys_msgs.append("\n".join([str(p.get("text") or "") for p in c if isinstance(p, dict) and p.get("type") == "text"]))
|
||
else:
|
||
sys_msgs.append(str(c or ""))
|
||
sys_text = "\n\n".join([s for s in sys_msgs if s]).strip()
|
||
|
||
out_msgs = []
|
||
for m in (unified_messages or []):
|
||
if m.get("role") == "system":
|
||
continue
|
||
role = m.get("role")
|
||
role = role if role in {"user", "assistant"} else "user"
|
||
c = m.get("content")
|
||
blocks: List[Dict[str, Any]] = []
|
||
if isinstance(c, list):
|
||
for p in c:
|
||
if not isinstance(p, dict):
|
||
continue
|
||
if p.get("type") == "text":
|
||
blocks.append({"type": "text", "text": str(p.get("text") or "")})
|
||
elif p.get("type") in {"image_url", "image"}:
|
||
url = str(p.get("url") or "")
|
||
if _is_data_url(url):
|
||
mime, b64 = _split_data_url(url)
|
||
blocks.append({"type": "image", "source": {"type": "base64", "media_type": mime, "data": b64}})
|
||
else:
|
||
blocks.append({"type": "image", "source": {"type": "url", "url": url}})
|
||
else:
|
||
blocks.append({"type": "text", "text": str(c or "")})
|
||
out_msgs.append({"role": role, "content": blocks})
|
||
|
||
claude_no_system = False
|
||
try:
|
||
claude_no_system = bool((node_config or {}).get("claude_no_system", False))
|
||
except Exception:
|
||
claude_no_system = False
|
||
|
||
if claude_no_system:
|
||
if sys_text:
|
||
out_msgs = [{"role": "user", "content": [{"type": "text", "text": sys_text}]}] + out_msgs
|
||
return {
|
||
"messages": out_msgs,
|
||
"system_text": sys_text,
|
||
}
|
||
|
||
d = {
|
||
"system_text": sys_text,
|
||
"messages": out_msgs,
|
||
}
|
||
if sys_text:
|
||
# Prefer system as a plain string (proxy compatibility)
|
||
d["system"] = sys_text
|
||
return d
|
||
|
||
def normalize_segment(self, x: Any) -> List[Dict[str, Any]]:
|
||
"""
|
||
Совместимо с [_as_claude_messages()](agentui/pipeline/executor.py:2602).
|
||
"""
|
||
msgs: List[Dict[str, Any]] = []
|
||
try:
|
||
if isinstance(x, dict):
|
||
# Dict with messages (OpenAI-like)
|
||
if isinstance(x.get("messages"), list):
|
||
x = x.get("messages") or []
|
||
# fallthrough to list mapping below
|
||
elif isinstance(x.get("contents"), list):
|
||
# Gemini -> Claude
|
||
for c in (x.get("contents") or []):
|
||
if not isinstance(c, dict):
|
||
continue
|
||
role_raw = str(c.get("role") or "user")
|
||
role = "assistant" if role_raw == "model" else ("user" if role_raw not in {"user", "assistant"} else role_raw)
|
||
parts = c.get("parts") or []
|
||
text = "\n".join([str(p.get("text")) for p in parts if isinstance(p, dict) and isinstance(p.get("text"), str)]).strip()
|
||
msgs.append({"role": role, "content": [{"type": "text", "text": text}]})
|
||
return msgs
|
||
|
||
if isinstance(x, list):
|
||
# Gemini contents list -> Claude messages
|
||
if all(isinstance(c, dict) and "parts" in c for c in x):
|
||
for c in x:
|
||
role_raw = str(c.get("role") or "user")
|
||
role = "assistant" if role_raw == "model" else ("user" if role_raw not in {"user", "assistant"} else role_raw)
|
||
blocks: List[Dict[str, Any]] = []
|
||
for p in (c.get("parts") or []):
|
||
if isinstance(p, dict) and isinstance(p.get("text"), str):
|
||
txt = p.get("text").strip()
|
||
if txt:
|
||
blocks.append({"type": "text", "text": txt})
|
||
msgs.append({"role": role, "content": blocks or [{"type": "text", "text": ""}]})
|
||
return msgs
|
||
# OpenAI messages list -> Claude
|
||
if all(isinstance(m, dict) and "content" in m for m in x):
|
||
out: List[Dict[str, Any]] = []
|
||
for m in x:
|
||
role = m.get("role", "user")
|
||
cont = m.get("content")
|
||
blocks: List[Dict[str, Any]] = []
|
||
if isinstance(cont, str):
|
||
blocks.append({"type": "text", "text": cont})
|
||
elif isinstance(cont, list):
|
||
for p in cont:
|
||
if not isinstance(p, dict):
|
||
continue
|
||
if p.get("type") == "text":
|
||
blocks.append({"type": "text", "text": str(p.get("text") or "")})
|
||
elif p.get("type") in {"image_url", "image"}:
|
||
url = ""
|
||
if isinstance(p.get("image_url"), dict):
|
||
url = str((p.get("image_url") or {}).get("url") or "")
|
||
elif "url" in p:
|
||
url = str(p.get("url") or "")
|
||
if url:
|
||
blocks.append({"type": "image", "source": {"type": "url", "url": url}})
|
||
else:
|
||
blocks.append({"type": "text", "text": json.dumps(cont, ensure_ascii=False)})
|
||
out.append({"role": role if role in {"user", "assistant"} else "user", "content": blocks})
|
||
return out
|
||
# Fallback
|
||
return [{"role": "user", "content": [{"type": "text", "text": json.dumps(x, ensure_ascii=False)}]}]
|
||
|
||
if isinstance(x, str):
|
||
try_obj = _try_json(x)
|
||
if try_obj is not None:
|
||
return self.normalize_segment(try_obj)
|
||
return [{"role": "user", "content": [{"type": "text", "text": x}]}]
|
||
return [{"role": "user", "content": [{"type": "text", "text": json.dumps(x, ensure_ascii=False)}]}]
|
||
except Exception:
|
||
return [{"role": "user", "content": [{"type": "text", "text": str(x)}]}]
|
||
|
||
def filter_items(self, arr: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
|
||
"""
|
||
Совместимо с [_filter_claude()](agentui/pipeline/executor.py:2820).
|
||
"""
|
||
out: List[Dict[str, Any]] = []
|
||
for m in (arr or []):
|
||
if not isinstance(m, dict):
|
||
continue
|
||
blocks = m.get("content")
|
||
if isinstance(blocks, list):
|
||
norm = []
|
||
for b in blocks:
|
||
if isinstance(b, dict) and b.get("type") == "text":
|
||
txt = str(b.get("text") or "")
|
||
if txt.strip():
|
||
norm.append({"type": "text", "text": txt})
|
||
if norm:
|
||
out.append({"role": m.get("role", "user"), "content": norm})
|
||
return out
|
||
|
||
def extract_system_text_from_obj(self, x: Any, render_ctx: Dict[str, Any]) -> Optional[str]:
|
||
"""
|
||
Поведение совместимо с [_extract_sys_text_from_obj()](agentui/pipeline/executor.py:2676).
|
||
"""
|
||
try:
|
||
# Dict objects
|
||
if isinstance(x, dict):
|
||
# Gemini systemInstruction
|
||
if "systemInstruction" in x:
|
||
si = x.get("systemInstruction")
|
||
|
||
def _parts_to_text(siobj: Any) -> str:
|
||
try:
|
||
parts = siobj.get("parts") or []
|
||
texts = [
|
||
str(p.get("text") or "")
|
||
for p in parts
|
||
if isinstance(p, dict) and isinstance(p.get("text"), str) and p.get("text").strip()
|
||
]
|
||
return "\n".join([t for t in texts if t]).strip()
|
||
except Exception:
|
||
return ""
|
||
|
||
if isinstance(si, dict):
|
||
t = _parts_to_text(si)
|
||
if t:
|
||
return t
|
||
if isinstance(si, list):
|
||
texts = []
|
||
for p in si:
|
||
if isinstance(p, dict) and isinstance(p.get("text"), str) and p.get("text").strip():
|
||
texts.append(p.get("text").strip())
|
||
t = "\n".join(texts).strip()
|
||
if t:
|
||
return t
|
||
if isinstance(si, str) and si.strip():
|
||
return si.strip()
|
||
# Claude system (string or blocks)
|
||
if "system" in x and not ("messages" in x and isinstance(x.get("messages"), list)):
|
||
sysv = x.get("system")
|
||
if isinstance(sysv, str) and sysv.strip():
|
||
return sysv.strip()
|
||
if isinstance(sysv, list):
|
||
texts = [
|
||
str(b.get("text") or "")
|
||
for b in sysv
|
||
if isinstance(b, dict)
|
||
and (b.get("type") == "text")
|
||
and isinstance(b.get("text"), str)
|
||
and b.get("text").strip()
|
||
]
|
||
t = "\n".join([t for t in texts if t]).strip()
|
||
if t:
|
||
return t
|
||
# OpenAI messages with role=system
|
||
if isinstance(x.get("messages"), list):
|
||
sys_msgs = []
|
||
for m in (x.get("messages") or []):
|
||
try:
|
||
if (str(m.get("role") or "").lower().strip() == "system"):
|
||
cont = m.get("content")
|
||
if isinstance(cont, str) and cont.strip():
|
||
sys_msgs.append(cont.strip())
|
||
elif isinstance(cont, list):
|
||
for p in cont:
|
||
if isinstance(p, dict) and p.get("type") == "text" and isinstance(p.get("text"), str) and p.get("text").strip():
|
||
sys_msgs.append(p.get("text").strip())
|
||
except Exception:
|
||
continue
|
||
if sys_msgs:
|
||
return "\n\n".join(sys_msgs).strip()
|
||
|
||
# List objects
|
||
if isinstance(x, list):
|
||
# OpenAI messages list with role=system
|
||
if all(isinstance(m, dict) and "role" in m for m in x):
|
||
sys_msgs = []
|
||
for m in x:
|
||
try:
|
||
if (str(m.get("role") or "").lower().strip() == "system"):
|
||
cont = m.get("content")
|
||
if isinstance(cont, str) and cont.strip():
|
||
sys_msgs.append(cont.strip())
|
||
elif isinstance(cont, list):
|
||
for p in cont:
|
||
if isinstance(p, dict) and p.get("type") == "text" and isinstance(p.get("text"), str) and p.get("text").strip():
|
||
sys_msgs.append(p.get("text").strip())
|
||
except Exception:
|
||
continue
|
||
if sys_msgs:
|
||
return "\n\n".join(sys_msgs).strip()
|
||
# Gemini 'contents' list: попробуем прочитать systemInstruction из входящего snapshot
|
||
if all(isinstance(c, dict) and "parts" in c for c in x):
|
||
try:
|
||
inc = (render_ctx.get("incoming") or {}).get("json") or {}
|
||
si = inc.get("systemInstruction")
|
||
if si is not None:
|
||
return self.extract_system_text_from_obj({"systemInstruction": si}, render_ctx)
|
||
except Exception:
|
||
pass
|
||
return None
|
||
except Exception:
|
||
return None
|
||
|
||
def combine_segments(
|
||
self,
|
||
blocks_struct: Dict[str, Any],
|
||
pre_segments_raw: List[Dict[str, Any]],
|
||
raw_segs: List[str],
|
||
render_ctx: Dict[str, Any],
|
||
pre_var_paths: set[str],
|
||
render_template_simple_fn,
|
||
var_macro_fullmatch_re,
|
||
detect_vendor_fn,
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
Повторяет ветку provider=='claude' из prompt_combine
|
||
([ProviderCallNode.run()](agentui/pipeline/executor.py:2998)).
|
||
"""
|
||
built3: List[Dict[str, Any]] = []
|
||
sys_texts: List[str] = []
|
||
|
||
# Нода-конфиг (для claude_no_system) передан через render_ctx['_node_config'], см. интеграцию
|
||
node_cfg = {}
|
||
try:
|
||
nc = render_ctx.get("_node_config")
|
||
if isinstance(nc, dict):
|
||
node_cfg = nc
|
||
except Exception:
|
||
node_cfg = {}
|
||
claude_no_system = False
|
||
try:
|
||
claude_no_system = bool(node_cfg.get("claude_no_system", False))
|
||
except Exception:
|
||
claude_no_system = False
|
||
|
||
# Пред‑сегменты
|
||
for _pre in (pre_segments_raw or []):
|
||
try:
|
||
_obj = _pre.get("obj")
|
||
items = self.normalize_segment(_obj)
|
||
items = self.filter_items(items)
|
||
built3 = insert_items(built3, items, _pre.get("pos"))
|
||
try:
|
||
sx = self.extract_system_text_from_obj(_obj, render_ctx)
|
||
if isinstance(sx, str) and sx.strip():
|
||
sys_texts.append(sx.strip())
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
|
||
# Основные сегменты
|
||
for raw_seg in (raw_segs or []):
|
||
body_seg, pos_spec = split_pos_spec(raw_seg)
|
||
if body_seg == "[[PROMPT]]":
|
||
items = self.filter_items(list(blocks_struct.get("messages", []) or []))
|
||
built3 = insert_items(built3, items, pos_spec)
|
||
continue
|
||
m_pre = var_macro_fullmatch_re.fullmatch(body_seg)
|
||
if m_pre:
|
||
_p = (m_pre.group(1) or "").strip()
|
||
try:
|
||
if _p in pre_var_paths:
|
||
# Skip duplicate var segment - already inserted via prompt_preprocess (filtered)
|
||
continue
|
||
except Exception:
|
||
pass
|
||
resolved = render_template_simple_fn(body_seg, render_ctx, render_ctx.get("OUT") or {})
|
||
obj = _try_json(resolved)
|
||
try:
|
||
pg = detect_vendor_fn(obj if isinstance(obj, dict) else {})
|
||
print(f"DEBUG: prompt_combine seg provider_guess={pg} -> target=claude pos={pos_spec}")
|
||
except Exception:
|
||
pass
|
||
items = self.normalize_segment(obj if obj is not None else resolved)
|
||
items = self.filter_items(items)
|
||
built3 = insert_items(built3, items, pos_spec)
|
||
try:
|
||
sx = self.extract_system_text_from_obj(obj, render_ctx) if obj is not None else None
|
||
if isinstance(sx, str) and sx.strip():
|
||
sys_texts.append(sx.strip())
|
||
except Exception:
|
||
pass
|
||
|
||
if not built3:
|
||
built3 = self.filter_items(list(blocks_struct.get("messages", []) or []))
|
||
|
||
# Merge system blocks from PROMPT blocks + gathered sys_texts
|
||
existing_sys = blocks_struct.get("system") or []
|
||
sys_blocks: List[Dict[str, Any]] = []
|
||
if isinstance(existing_sys, list):
|
||
sys_blocks.extend(existing_sys)
|
||
st0 = blocks_struct.get("system_text") or ""
|
||
# Ensure PROMPT system_text from blocks is included as a Claude system block
|
||
if isinstance(st0, str) and st0.strip():
|
||
sys_blocks.append({"type": "text", "text": st0})
|
||
for s in sys_texts:
|
||
sys_blocks.append({"type": "text", "text": s})
|
||
st = "\n\n".join([t for t in [st0] + sys_texts if isinstance(t, str) and t.strip()])
|
||
|
||
if claude_no_system:
|
||
# Prepend system text as a user message instead of top-level system
|
||
if st:
|
||
built3 = [{"role": "user", "content": [{"type": "text", "text": st}]}] + built3
|
||
return {"messages": built3, "system_text": st}
|
||
|
||
pm_struct = {"messages": built3, "system_text": st}
|
||
# Prefer array of system blocks when possible; fallback to single text block
|
||
if sys_blocks:
|
||
pm_struct["system"] = sys_blocks
|
||
elif st:
|
||
pm_struct["system"] = [{"type": "text", "text": st}]
|
||
return pm_struct
|
||
|
||
def prompt_fragment(self, pm_struct: Dict[str, Any], node_config: Dict[str, Any]) -> str:
|
||
"""
|
||
Совместимо с веткой provider=='claude' в построении [[PROMPT]]
|
||
([ProviderCallNode.run()](agentui/pipeline/executor.py:3125)).
|
||
"""
|
||
parts: List[str] = []
|
||
# Учитываем флаг совместимости: при claude_no_system не добавляем top-level "system"
|
||
claude_no_system = False
|
||
try:
|
||
claude_no_system = bool((node_config or {}).get("claude_no_system", False))
|
||
except Exception:
|
||
claude_no_system = False
|
||
|
||
if not claude_no_system:
|
||
# Предпочитаем массив блоков system, если он есть; иначе строковый system_text
|
||
sys_val = pm_struct.get("system", None)
|
||
if sys_val is None:
|
||
sys_val = pm_struct.get("system_text")
|
||
if sys_val:
|
||
parts.append('"system": ' + json.dumps(sys_val, ensure_ascii=False))
|
||
|
||
msgs = pm_struct.get("messages")
|
||
if msgs is not None:
|
||
parts.append('"messages": ' + json.dumps(msgs, ensure_ascii=False))
|
||
return ", ".join(parts) |