File size: 6,878 Bytes
f98dc3e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 | from __future__ import annotations
import json
import logging
from typing import Any, AsyncGenerator, Dict, List, Optional
from pydantic import TypeAdapter
from vam import prompts
from vam.config import get_settings
from vam.protocol import RetrieveToolArgs, SummarizeToolArgs, WsAgentDecision
from vam.llm.openrouter import OpenRouterClient
from vam.retrieval.agent_search import search_generator as retrieval_search_generator
from vam.retrieval.frame_store import resolve_memory_store
logger = logging.getLogger(__name__)
_ROUTER_DECISION_ADAPTER = TypeAdapter(WsAgentDecision)
def append_history(history: List[Dict[str, Any]], *, user_text: str, assistant_text: str) -> None:
history.append({"role": "user", "content": user_text})
history.append({"role": "assistant", "content": assistant_text})
async def route_text_request(*, transcript: str) -> WsAgentDecision:
cfg = get_settings()
router_client = OpenRouterClient(
model_id=cfg.openrouter_model_id_light or cfg.openrouter_model_id_main or cfg.openrouter_model_id
)
messages = [
{"role": "system", "content": prompts.ws_agent_system()},
{"role": "user", "content": transcript},
]
text, _ = await router_client.chat(messages, temperature=0.0, max_tokens=300)
raw = (text or "").strip()
if raw.startswith("```json"):
raw = raw[7:]
if raw.startswith("```"):
raw = raw[3:]
if raw.endswith("```"):
raw = raw[:-3]
raw = raw.strip()
payload = json.loads(raw)
decision = _ROUTER_DECISION_ADAPTER.validate_python(payload)
return decision
async def stream_retrieve_tool_request(
*,
transcript: str,
history: List[Dict[str, Any]],
) -> AsyncGenerator[Dict[str, Any], None]:
store = resolve_memory_store()
tool_args = RetrieveToolArgs(question=transcript)
yield {"type": "tool_use", "tool": "retrieve", "input": tool_args.model_dump()}
final_result: Optional[Dict[str, Any]] = None
async for event in retrieval_search_generator(
semantic=tool_args.question,
store_instance=store,
chat_history=history,
):
if str(event.get("type") or "") == "final":
maybe_result = event.get("result")
final_result = maybe_result if isinstance(maybe_result, dict) else None
continue
yield event
answer = ""
if isinstance(final_result, dict):
answer = str(final_result.get("answer") or "").strip()
if not answer and final_result.get("found") and isinstance(final_result.get("best"), dict):
best = final_result["best"]
t_sec = float(best.get("t") or 0.0)
detail = str(best.get("inspection") or best.get("caption") or "").strip()
answer = f"Found relevant evidence at {t_sec:.1f}s: {detail}" if detail else f"Found relevant evidence at {t_sec:.1f}s."
if not answer:
answer = "No relevant evidence found."
result = final_result or {"found": False, "answer": answer, "turns": []}
yield {
"type": "final",
"text": answer,
"result": result,
}
append_history(history, user_text=transcript, assistant_text=answer)
async def stream_summarize_tool_request(
*,
args: SummarizeToolArgs,
history: List[Dict[str, Any]],
) -> AsyncGenerator[Dict[str, Any], None]:
store = resolve_memory_store()
payload = args.model_dump()
yield {"type": "tool_use", "tool": "summarize", "input": payload}
max_time = float("inf") if args.max_time is None else float(args.max_time)
created_docs = await store.summarize_time_range(
min_time=float(args.min_time),
max_time=max_time,
time_mode=str(args.time_mode),
granularity_s=float(args.granularity_seconds),
summary_structure=str(args.summary_structure) if args.summary_structure is not None else None,
prompt=str(args.prompt),
)
results: List[Dict[str, Any]] = []
for doc in created_docs:
frame = await store.get_frame_by_id(str(doc.representative_frame_id or ""))
results.append(
{
"doc_id": doc.doc_id,
"layer": doc.layer,
"kind": doc.kind,
"text": doc.text,
"representative_frame_id": doc.representative_frame_id,
"frame_ids": list(doc.frame_ids or []),
"metadata": dict(doc.metadata or {}),
"time_range": {
"start_t": float(doc.start_t),
"end_t": float(doc.end_t),
"absolute_start_t": doc.absolute_start_t,
"absolute_end_t": doc.absolute_end_t,
},
"image": frame.image_data_uri if frame is not None else "",
}
)
answer = f"Created {len(results)} summary documents in Hierarchical Memory."
yield {
"type": "final",
"text": answer,
"result": {
"created": len(results),
"documents": results,
"answer": answer,
},
}
append_history(
history,
user_text=f"summarize:{json.dumps(payload, ensure_ascii=False)}",
assistant_text=answer,
)
async def stream_agent_response(
*,
transcript: str,
history: Optional[List[Dict[str, Any]]] = None,
) -> AsyncGenerator[Dict[str, Any], None]:
session_history = history if history is not None else []
clean_transcript = str(transcript or "").strip()
if not clean_transcript:
return
try:
decision = await route_text_request(transcript=clean_transcript)
except Exception as exc:
logger.warning("top_level_router_failed; falling back to direct Agentic Retrieval: %s", exc)
yield {"type": "user_text", "text": clean_transcript}
async for event in stream_retrieve_tool_request(
transcript=clean_transcript,
history=session_history,
):
yield event
return
if decision.type == "final":
text = str(decision.text).strip()
yield {"type": "final", "text": text, "result": {"answer": text}}
append_history(session_history, user_text=clean_transcript, assistant_text=text)
return
if decision.name == "retrieve":
routed_question = decision.args.question
yield {"type": "user_text", "text": routed_question}
async for event in stream_retrieve_tool_request(
transcript=routed_question,
history=session_history,
):
yield event
return
if decision.name == "summarize":
async for event in stream_summarize_tool_request(
args=decision.args,
history=session_history,
):
yield event
return
raise ValueError(f"unsupported routed decision: {decision}")
|