pipeline.py 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498
  1. """Pipeline orchestration for Microsoft Teams meeting summaries."""
  2. from __future__ import annotations
  3. import asyncio
  4. import json
  5. import logging
  6. import shutil
  7. import tempfile
  8. import uuid
  9. from dataclasses import dataclass
  10. from pathlib import Path
  11. from typing import Any, Awaitable, Callable, Optional
  12. import httpx
  13. from agent.auxiliary_client import async_call_llm, extract_content_or_reasoning
  14. from agent.secret_scope import get_secret
  15. from hermes_constants import get_hermes_home
  16. from plugins.teams_pipeline.meetings import (
  17. download_recording_artifact,
  18. enrich_meeting_with_call_record,
  19. fetch_preferred_transcript_text,
  20. list_recording_artifacts,
  21. looks_like_transcript_id,
  22. parse_graph_meeting_resource,
  23. resolve_meeting_reference)
  24. from plugins.teams_pipeline.models import (
  25. MeetingArtifact, TeamsMeetingPipelineJob, TeamsMeetingRef, TeamsMeetingSummaryPayload)
  26. from plugins.teams_pipeline.store import TeamsPipelineStore
  27. from tools.transcription_tools import transcribe_audio
  28. logger = logging.getLogger(__name__)
  29. TERMINAL_PIPELINE_STATES = {"completed", "failed", "retry_scheduled"}
  30. ACTIVE_PIPELINE_STATES = {
  31. "received", "resolving_meeting", "fetching_transcript", "downloading_recording",
  32. "transcribing_audio", "summarizing", "writing_notion", "writing_linear", "sending_teams"}
  33. _AUDIO_SUFFIXES = {".wav", ".mp3", ".m4a", ".ogg", ".flac", ".aac", ".webm"}
  34. _SUMMARY_SYSTEM_PROMPT = (
  35. "You summarize meeting transcripts. Return only valid JSON with keys: "
  36. "summary, key_decisions, action_items, risks, confidence, confidence_notes.")
  37. class TeamsPipelineError(RuntimeError): """Base class for Teams meeting pipeline failures."""
  38. class TeamsPipelineRetryableError(TeamsPipelineError): """Raised when the pipeline should be retried later."""
  39. class TeamsPipelineSinkError(TeamsPipelineError): """Raised when an output sink fails."""
  40. class TeamsPipelineArtifactNotFoundError(TeamsPipelineRetryableError): """Raised when meeting artifacts are not yet available."""
  41. TranscribeFn = Callable[[str, Optional[str]], dict[str, Any]]
  42. SummarizeFn = Callable[..., Awaitable[dict[str, Any] | TeamsMeetingSummaryPayload]]
  43. SinkFn = Callable[[TeamsMeetingSummaryPayload, dict[str, Any], Optional[dict[str, Any]]], Awaitable[dict[str, Any]]]
  44. @dataclass
  45. class TeamsPipelineConfig:
  46. transcript_preferred: bool = True
  47. transcript_required: bool = False
  48. transcription_fallback: bool = True
  49. stt_model: str | None = None
  50. ffmpeg_extract_audio: bool = True
  51. transcript_min_chars: int = 80
  52. tmp_dir: Path | None = None
  53. notion: dict[str, Any] | None = None
  54. linear: dict[str, Any] | None = None
  55. teams_delivery: dict[str, Any] | None = None
  56. @classmethod
  57. def from_dict(cls, payload: Optional[dict[str, Any]]) -> TeamsPipelineConfig:
  58. data = dict(payload or {})
  59. tmp_dir = data.get("tmp_dir") or data.get("tmpDir")
  60. flags = {"transcript_preferred": True, "transcript_required": False, "transcription_fallback": True, "ffmpeg_extract_audio": True}
  61. return cls(
  62. **{name: bool(data.get(name, default)) for name, default in flags.items()},
  63. stt_model=data.get("stt_model") or data.get("sttModel"), transcript_min_chars=int(data.get("transcript_min_chars", 80)),
  64. tmp_dir=Path(tmp_dir) if tmp_dir else None, notion=data.get("notion"), linear=data.get("linear"),
  65. teams_delivery=data.get("teams_delivery") or data.get("teamsDelivery"))
  66. def _rich_text(content: str) -> dict[str, Any]:
  67. return {"rich_text": [{"text": {"content": content}}]}
  68. def _bullets(items: list[str]) -> str:
  69. return "\n".join(f"- {item}" for item in items)
  70. def _sections(payload: TeamsMeetingSummaryPayload) -> list[tuple[str, str]]:
  71. return [("Summary", payload.summary or ""), ("Key Decisions", _bullets(payload.key_decisions)),
  72. ("Action Items", _bullets(payload.action_items)), ("Risks", _bullets(payload.risks))]
  73. class _HttpSinkWriter:
  74. """Shared API-key + httpx transport plumbing for the Notion/Linear sinks."""
  75. SECRET_NAME = ""
  76. def __init__(self, *, api_key: str | None = None, transport: httpx.AsyncBaseTransport | None = None) -> None:
  77. self.api_key = (api_key or get_secret(self.SECRET_NAME, "") or "").strip()
  78. self._transport = transport
  79. def _require_api_key(self) -> None:
  80. if not self.api_key:
  81. raise TeamsPipelineSinkError(f"{self.SECRET_NAME} is not configured.")
  82. async def _request(self, method: str, url: str, *, headers: dict[str, str], body: dict[str, Any]) -> dict[str, Any]:
  83. async with httpx.AsyncClient(timeout=30.0, transport=self._transport) as client:
  84. response = await client.request(method, url, headers=headers, json=body)
  85. response.raise_for_status()
  86. return response.json()
  87. class NotionWriter(_HttpSinkWriter):
  88. API_BASE = "https://api.notion.com/v1"
  89. API_VERSION = "2025-09-03"
  90. SECRET_NAME = "NOTION_API_KEY"
  91. async def write_summary(
  92. self, payload: TeamsMeetingSummaryPayload, config: dict[str, Any], existing_record: Optional[dict[str, Any]] = None,
  93. ) -> dict[str, Any]:
  94. self._require_api_key()
  95. database_id = str(config.get("database_id") or config.get("databaseId") or "").strip()
  96. page_id = (existing_record or {}).get("page_id")
  97. if not database_id and not page_id:
  98. raise TeamsPipelineSinkError("Notion sink requires database_id or an existing page_id.")
  99. headers = {"Authorization": f"Bearer {self.api_key}", "Notion-Version": self.API_VERSION, "Content-Type": "application/json"}
  100. properties = self._build_properties(payload, config)
  101. # Re-runs update the existing page's properties only; body blocks are written once on create.
  102. if page_id:
  103. record = await self._request("PATCH", f"{self.API_BASE}/pages/{page_id}", headers=headers, body={"properties": properties})
  104. else:
  105. body = {"parent": {"database_id": database_id}, "properties": properties, "children": self._build_blocks(payload)}
  106. record = await self._request("POST", f"{self.API_BASE}/pages", headers=headers, body=body)
  107. return {"page_id": record["id"], "url": record.get("url")}
  108. def _build_properties(self, payload: TeamsMeetingSummaryPayload, config: dict[str, Any]) -> dict[str, Any]:
  109. title = payload.title or f"Meeting {payload.meeting_ref.meeting_id}"
  110. properties: dict[str, Any] = {config.get("title_property", "Name"): {"title": [{"text": {"content": title}}]}}
  111. if summary_property := config.get("summary_property"):
  112. properties[summary_property] = _rich_text((payload.summary or "")[:1900])
  113. if meeting_id_property := config.get("meeting_id_property"):
  114. properties[meeting_id_property] = _rich_text(payload.meeting_ref.meeting_id)
  115. return properties
  116. def _build_blocks(self, payload: TeamsMeetingSummaryPayload) -> list[dict[str, Any]]:
  117. return [block for heading, body in _sections(payload) for block in (
  118. {"object": "block", "type": "heading_2", "heading_2": _rich_text(heading)},
  119. {"object": "block", "type": "paragraph", "paragraph": _rich_text(body or "None")})]
  120. class LinearWriter(_HttpSinkWriter):
  121. API_URL = "https://api.linear.app/graphql"
  122. SECRET_NAME = "LINEAR_API_KEY"
  123. _UPDATE_MUTATION = "mutation($id: String!, $input: IssueUpdateInput!) { issueUpdate(id: $id, input: $input) { success issue { id identifier url } } }"
  124. _CREATE_MUTATION = "mutation($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id identifier url } } }"
  125. async def write_summary(
  126. self, payload: TeamsMeetingSummaryPayload, config: dict[str, Any], existing_record: Optional[dict[str, Any]] = None,
  127. ) -> dict[str, Any]:
  128. self._require_api_key()
  129. headers = {"Authorization": self.api_key, "Content-Type": "application/json"}
  130. team_id = str(config.get("team_id") or config.get("teamId") or "").strip()
  131. issue_input = {"title": payload.title or f"Meeting Summary: {payload.meeting_ref.meeting_id}", "description": _render_summary_markdown(payload)}
  132. if existing_issue_id := (existing_record or {}).get("issue_id"):
  133. body = {"query": self._UPDATE_MUTATION, "variables": {"id": existing_issue_id, "input": issue_input}}
  134. elif not team_id:
  135. raise TeamsPipelineSinkError("Linear sink requires team_id when creating a new issue.")
  136. else:
  137. body = {"query": self._CREATE_MUTATION, "variables": {"input": {"teamId": team_id, **issue_input}}}
  138. payload_json = await self._request("POST", self.API_URL, headers=headers, body=body)
  139. data = payload_json.get("data") or {}
  140. issue = (data.get("issueUpdate") or {}).get("issue") or (data.get("issueCreate") or {}).get("issue")
  141. if not isinstance(issue, dict) or not issue.get("id"):
  142. raise TeamsPipelineSinkError(f"Linear write failed: {payload_json}")
  143. return {"issue_id": issue["id"], "identifier": issue.get("identifier"), "url": issue.get("url")}
  144. class TeamsMeetingPipeline:
  145. """Transcript-first Teams meeting pipeline with durable lifecycle state."""
  146. def __init__(
  147. self, *, graph_client: Any, store: TeamsPipelineStore,
  148. config: TeamsPipelineConfig | dict[str, Any] | None = None, transcribe_fn: TranscribeFn = transcribe_audio,
  149. summarize_fn: Optional[SummarizeFn] = None, notion_writer: Optional[NotionWriter] = None,
  150. linear_writer: Optional[LinearWriter] = None, teams_sender: Optional[SinkFn] = None) -> None:
  151. self.graph_client, self.store, self.transcribe_fn = graph_client, store, transcribe_fn
  152. self.config = config if isinstance(config, TeamsPipelineConfig) else TeamsPipelineConfig.from_dict(config)
  153. self.summarize_fn = summarize_fn or self._generate_summary_payload
  154. self.notion_writer, self.linear_writer, self.teams_sender = notion_writer, linear_writer, teams_sender
  155. def create_job_from_notification(self, notification: dict[str, Any]) -> TeamsMeetingPipelineJob:
  156. event_id = TeamsPipelineStore.build_notification_receipt_key(notification)
  157. self.store.record_notification_receipt(event_id, notification)
  158. existing_job = self._find_job_by_dedupe_key(event_id)
  159. if existing_job is not None:
  160. return existing_job
  161. resource_data = notification.get("resourceData") or {}
  162. meeting_id, organizer_user_id, extra_metadata = _meeting_ids_from_notification(notification)
  163. job = TeamsMeetingPipelineJob(
  164. job_id=f"teams-job-{uuid.uuid4().hex[:12]}", event_id=event_id, dedupe_key=event_id, status="received",
  165. source_event_type=str(notification.get("changeType") or "graph.notification"),
  166. meeting_ref=TeamsMeetingRef(
  167. meeting_id=str(meeting_id), organizer_user_id=organizer_user_id,
  168. tenant_id=resource_data.get("tenantId") or notification.get("tenantId"),
  169. metadata={"notification": dict(notification), "join_web_url": resource_data.get("joinWebUrl"),
  170. "call_record_id": resource_data.get("callRecordId") or notification.get("callRecordId"), **extra_metadata},
  171. ),
  172. )
  173. self.store.upsert_job(job.job_id, job.to_dict())
  174. return job
  175. async def run_notification(self, notification: dict[str, Any]) -> TeamsMeetingPipelineJob:
  176. job = self.create_job_from_notification(notification)
  177. # Only freshly "received" jobs run; terminal or in-flight duplicates are returned as-is.
  178. if job.status in TERMINAL_PIPELINE_STATES or job.status in ACTIVE_PIPELINE_STATES - {"received"}:
  179. return job
  180. return await self.run_job(job.job_id)
  181. async def run_job(self, job_or_id: TeamsMeetingPipelineJob | str) -> TeamsMeetingPipelineJob:
  182. job = self._coerce_job(job_or_id)
  183. meeting_ref = job.meeting_ref
  184. if meeting_ref is None:
  185. raise TeamsPipelineError(f"Job {job.job_id} has no meeting_ref.")
  186. artifacts: list[MeetingArtifact] = []
  187. try:
  188. job, resolved_meeting, notification = await self._resolve_meeting(job, meeting_ref)
  189. job, transcript_text = await self._obtain_transcript(job, resolved_meeting, artifacts)
  190. call_record_id = notification.get("callRecordId") or (meeting_ref.metadata or {}).get("call_record_id")
  191. call_record = await enrich_meeting_with_call_record(self.graph_client, resolved_meeting, call_record_id=call_record_id)
  192. if call_record is not None:
  193. artifacts.append(call_record)
  194. job = self._persist_job(job, status="summarizing")
  195. summary_payload = await self.summarize_fn(resolved_meeting=resolved_meeting, transcript_text=transcript_text or "", artifacts=artifacts)
  196. if not isinstance(summary_payload, TeamsMeetingSummaryPayload):
  197. summary_payload = TeamsMeetingSummaryPayload.from_dict(summary_payload)
  198. job.summary_payload = summary_payload
  199. job = self._persist_job(job, summary_payload=summary_payload.to_dict())
  200. await self._write_sinks(job, summary_payload)
  201. return self._persist_job(job, status="completed")
  202. except TeamsPipelineRetryableError as exc:
  203. return self._persist_job(job, status="retry_scheduled", error_info={"message": str(exc), "retryable": True})
  204. except Exception as exc:
  205. return self._persist_job(job, status="failed", error_info={"message": str(exc), "type": type(exc).__name__})
  206. async def _resolve_meeting(
  207. self, job: TeamsMeetingPipelineJob, meeting_ref: TeamsMeetingRef) -> tuple[TeamsMeetingPipelineJob, TeamsMeetingRef, Any]:
  208. """Phase 1: resolve the Graph meeting; returns (job, resolved_meeting, stored notification)."""
  209. job = self._persist_job(job, status="resolving_meeting")
  210. notification = meeting_ref.metadata.get("notification") if isinstance(meeting_ref.metadata, dict) else {}
  211. meeting_id, organizer_user_id = meeting_ref.meeting_id, meeting_ref.organizer_user_id
  212. # Re-parse the stored notification: older jobs may have persisted a transcript id as meeting_id.
  213. if isinstance(notification, dict) and notification:
  214. parsed_id, parsed_org, _extra = _meeting_ids_from_notification(notification)
  215. if parsed_org:
  216. organizer_user_id = organizer_user_id or parsed_org
  217. if parsed_id and not looks_like_transcript_id(parsed_id):
  218. meeting_id = parsed_id
  219. resolved_meeting = await resolve_meeting_reference(
  220. self.graph_client, meeting_id=meeting_id, tenant_id=meeting_ref.tenant_id,
  221. join_web_url=meeting_ref.join_web_url or meeting_ref.metadata.get("join_web_url"), organizer_user_id=organizer_user_id)
  222. if meeting_ref.metadata:
  223. resolved_meeting.metadata = {**meeting_ref.metadata, **resolved_meeting.metadata}
  224. resolved_meeting.organizer_user_id = resolved_meeting.organizer_user_id or meeting_ref.organizer_user_id
  225. job.meeting_ref = resolved_meeting
  226. return self._persist_job(job, meeting_ref=resolved_meeting.to_dict()), resolved_meeting, notification
  227. async def _obtain_transcript(
  228. self, job: TeamsMeetingPipelineJob, resolved_meeting: TeamsMeetingRef, artifacts: list[MeetingArtifact]
  229. ) -> tuple[TeamsMeetingPipelineJob, str | None]:
  230. """Phase 2: transcript first, then the recording->STT fallback (appends chosen artifacts)."""
  231. transcript_text: str | None = None
  232. if self.config.transcript_preferred:
  233. job = self._persist_job(job, status="fetching_transcript")
  234. transcript_artifact, transcript_text = await fetch_preferred_transcript_text(self.graph_client, resolved_meeting)
  235. if transcript_artifact and transcript_text:
  236. artifacts.append(transcript_artifact)
  237. if len(transcript_text.strip()) < self.config.transcript_min_chars:
  238. transcript_text = None
  239. if transcript_text:
  240. return self._persist_job(job, selected_artifact_strategy="transcript_first"), transcript_text
  241. if self.config.transcript_required:
  242. raise TeamsPipelineRetryableError(f"Transcript unavailable for meeting {resolved_meeting.meeting_id}.")
  243. if not self.config.transcription_fallback:
  244. raise TeamsPipelineArtifactNotFoundError(
  245. f"No transcript available and transcription fallback disabled for {resolved_meeting.meeting_id}.")
  246. job = self._persist_job(job, status="downloading_recording")
  247. recordings = await list_recording_artifacts(self.graph_client, resolved_meeting)
  248. if not recordings:
  249. raise TeamsPipelineRetryableError(f"Recording unavailable for meeting {resolved_meeting.meeting_id}.")
  250. artifacts.append(recordings[0])
  251. transcript_text = await self._transcribe_recording(job, resolved_meeting, recordings[0])
  252. return self._persist_job(job, selected_artifact_strategy="recording_stt_fallback"), transcript_text
  253. def _coerce_job(self, job_or_id: TeamsMeetingPipelineJob | str) -> TeamsMeetingPipelineJob:
  254. if isinstance(job_or_id, TeamsMeetingPipelineJob):
  255. return job_or_id
  256. payload = self.store.get_job(str(job_or_id))
  257. if not payload:
  258. raise TeamsPipelineError(f"Unknown Teams pipeline job: {job_or_id}")
  259. return TeamsMeetingPipelineJob.from_dict(payload)
  260. def _find_job_by_dedupe_key(self, dedupe_key: str) -> TeamsMeetingPipelineJob | None:
  261. for payload in self.store.list_jobs().values():
  262. if isinstance(payload, dict) and str(payload.get("dedupe_key") or "") == dedupe_key:
  263. return TeamsMeetingPipelineJob.from_dict(payload)
  264. return None
  265. def _persist_job(self, job: TeamsMeetingPipelineJob, **updates: Any) -> TeamsMeetingPipelineJob:
  266. return TeamsMeetingPipelineJob.from_dict(self.store.upsert_job(job.job_id, {**job.to_dict(), **updates}))
  267. async def _transcribe_recording(self, job: TeamsMeetingPipelineJob, meeting_ref: TeamsMeetingRef, recording: MeetingArtifact) -> str:
  268. temp_root = self.config.tmp_dir or (get_hermes_home() / "tmp" / "teams_pipeline")
  269. temp_root.mkdir(parents=True, exist_ok=True)
  270. with tempfile.TemporaryDirectory(dir=str(temp_root), prefix="teams-recording-") as tmp_dir:
  271. # display_name is organizer-controlled Graph data: keep only the basename so a crafted
  272. # "../../etc/cron.d/evil" cannot escape tmp_dir. Path(...).name leaves "." / ".." / ""
  273. # unchanged (joining "tmp/.." resolves to the parent), so reject those explicitly.
  274. fallback_name = f"{recording.artifact_id}.mp4"
  275. recording_name = Path(recording.display_name or fallback_name).name
  276. recording_path = Path(tmp_dir) / (fallback_name if recording_name in ("", ".", "..") else recording_name)
  277. await download_recording_artifact(self.graph_client, meeting_ref, recording, recording_path)
  278. audio_path = await self._prepare_audio_path(recording_path)
  279. job = self._persist_job(job, status="transcribing_audio")
  280. result = await asyncio.to_thread(self.transcribe_fn, str(audio_path), self.config.stt_model)
  281. if not result.get("success"):
  282. raise TeamsPipelineRetryableError(str(result.get("error") or "Unknown STT failure"))
  283. transcript = str(result.get("transcript") or "").strip()
  284. if not transcript:
  285. raise TeamsPipelineRetryableError("STT returned an empty transcript.")
  286. return transcript
  287. async def _prepare_audio_path(self, recording_path: Path) -> Path:
  288. if recording_path.suffix.lower() in _AUDIO_SUFFIXES or not self.config.ffmpeg_extract_audio:
  289. return recording_path
  290. ffmpeg = shutil.which("ffmpeg")
  291. if not ffmpeg:
  292. raise TeamsPipelineRetryableError("Recording fallback requires ffmpeg for audio extraction, but ffmpeg was not found.")
  293. audio_path = recording_path.with_suffix(".wav")
  294. proc = await asyncio.create_subprocess_exec(
  295. ffmpeg, "-y", "-i", str(recording_path), str(audio_path), stdin=asyncio.subprocess.DEVNULL, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
  296. _stdout, stderr = await proc.communicate()
  297. if proc.returncode != 0:
  298. raise TeamsPipelineRetryableError(f"ffmpeg audio extraction failed: {stderr.decode('utf-8', errors='replace').strip()}")
  299. return audio_path
  300. async def _generate_summary_payload(
  301. self, *, resolved_meeting: TeamsMeetingRef, transcript_text: str, artifacts: list[MeetingArtifact]) -> TeamsMeetingSummaryPayload:
  302. prompt = _build_summary_prompt(resolved_meeting, transcript_text, artifacts)
  303. try:
  304. response = await async_call_llm(
  305. task="call", temperature=0.2, max_tokens=900,
  306. messages=[{"role": "system", "content": _SUMMARY_SYSTEM_PROMPT}, {"role": "user", "content": prompt}])
  307. parsed = _parse_summary_json(extract_content_or_reasoning(response))
  308. except Exception as exc:
  309. logger.info("Teams pipeline LLM summary unavailable, using heuristic summary: %s", exc)
  310. parsed = _heuristic_summary(transcript_text)
  311. teams_delivery = self.config.teams_delivery or {}
  312. return TeamsMeetingSummaryPayload(
  313. meeting_ref=resolved_meeting, transcript_text=transcript_text, source_artifacts=artifacts,
  314. title=str(resolved_meeting.metadata.get("subject") or f"Meeting {resolved_meeting.meeting_id}"),
  315. start_time=resolved_meeting.metadata.get("startDateTime"), end_time=resolved_meeting.metadata.get("endDateTime"),
  316. participants=_collect_participants(resolved_meeting), call_metrics=_collect_call_metrics(artifacts),
  317. summary=parsed.get("summary"), confidence=parsed.get("confidence"), confidence_notes=parsed.get("confidence_notes"),
  318. **{key: list(parsed.get(key) or []) for key in ("key_decisions", "action_items", "risks")},
  319. notion_target=(self.config.notion or {}).get("database_id"), linear_target=(self.config.linear or {}).get("team_id"),
  320. teams_target=teams_delivery.get("channel_id") or teams_delivery.get("chat_id"))
  321. async def _write_sinks(self, job: TeamsMeetingPipelineJob, payload: TeamsMeetingSummaryPayload) -> None:
  322. # Sink order is part of the contract: Notion, then Linear, then Teams delivery.
  323. sinks = (
  324. ("notion", "writing_notion", self.config.notion, self.notion_writer),
  325. ("linear", "writing_linear", self.config.linear, self.linear_writer),
  326. ("teams", "sending_teams", self.config.teams_delivery, self.teams_sender))
  327. for name, status, config, sink in sinks:
  328. if not (config and config.get("enabled") and sink):
  329. continue
  330. job = self._persist_job(job, status=status)
  331. sink_key = f"{name}:{payload.meeting_ref.meeting_id}"
  332. existing = self.store.get_sink_record(sink_key)
  333. # Sinks may be writer objects (write_summary) or bare async callables.
  334. write: Any = getattr(sink, "write_summary", sink)
  335. self.store.upsert_sink_record(sink_key, await write(payload, config, existing))
  336. def _collect_call_metrics(artifacts: list[MeetingArtifact]) -> dict[str, Any]:
  337. metrics: dict[str, Any] = {}
  338. for artifact in artifacts:
  339. if artifact.artifact_type == "call_record":
  340. metrics.update(dict(artifact.metadata.get("metrics") or {}))
  341. return {**metrics, "artifact_count": len(artifacts)}
  342. def _collect_participants(meeting_ref: TeamsMeetingRef) -> list[str]:
  343. participants = meeting_ref.metadata.get("participants") or []
  344. if not isinstance(participants, list):
  345. return []
  346. names = (item.get("displayName") or (((item.get("identity") or {}).get("user") or {}).get("displayName"))
  347. for item in participants if isinstance(item, dict))
  348. return [str(name) for name in names if name]
  349. def _odata_field(payload: dict[str, Any], name: str) -> Any:
  350. return payload.get(f"@{name}") or payload.get(name)
  351. def _organizer_user_id_from_payload(payload: dict[str, Any]) -> str | None:
  352. organizer = payload.get("meetingOrganizer") or payload.get("organizer")
  353. if isinstance(organizer, dict):
  354. user = organizer.get("user")
  355. if user is None and isinstance(organizer.get("identity"), dict):
  356. user = organizer["identity"].get("user")
  357. if isinstance(user, dict) and user.get("id"):
  358. return str(user["id"]).strip() or None
  359. return str(payload.get("organizerUserId") or payload.get("organizer_user_id") or "").strip() or None
  360. def _resource_data_id_is_artifact(notification: dict[str, Any], resource_data: dict[str, Any]) -> bool:
  361. odata_type = str(_odata_field(resource_data, "odata.type") or "")
  362. if "calltranscript" in odata_type.lower() or "callrecording" in odata_type.lower():
  363. return True
  364. resource = str(notification.get("resource") or "").lower()
  365. if any(marker in resource for marker in ("getalltranscripts", "getallrecordings", "/transcripts", "/recordings")):
  366. return True
  367. return looks_like_transcript_id(str(resource_data.get("id") or ""), odata_type=odata_type)
  368. def _meeting_ids_from_notification(notification: dict[str, Any]) -> tuple[str, str | None, dict[str, Any]]:
  369. """Return (meeting_id, organizer_user_id, extra_metadata) from a Graph change notification: parsed
  370. resource paths win over flat fields; resourceData.id counts as a meeting id only when it is not an
  371. artifact id; meeting_id never comes back empty (falls back to an artifact id, then the receipt key)."""
  372. resource_data = notification.get("resourceData")
  373. resource_data = resource_data if isinstance(resource_data, dict) else {}
  374. odata_type = str(_odata_field(resource_data, "odata.type") or "")
  375. parsed_paths = [parse_graph_meeting_resource(str(raw or "")) for raw in (
  376. _odata_field(resource_data, "odata.id"), notification.get("resource"), resource_data.get("transcriptContentUrl"))]
  377. first = {key: next((parsed[key] for parsed in parsed_paths if parsed.get(key)), None)
  378. for key in ("organizer_user_id", "meeting_id", "transcript_id", "recording_id")}
  379. organizer_user_id = first["organizer_user_id"] or _organizer_user_id_from_payload(resource_data) or _organizer_user_id_from_payload(notification)
  380. meeting_id = first["meeting_id"] or (str(resource_data.get("meetingId") or notification.get("meetingId") or "").strip() or None)
  381. transcript_id, recording_id = first["transcript_id"], first["recording_id"]
  382. resource_data_id = str(resource_data.get("id") or "").strip() or None
  383. if resource_data_id and not _resource_data_id_is_artifact(notification, resource_data):
  384. meeting_id = meeting_id or resource_data_id
  385. elif resource_data_id and not transcript_id and looks_like_transcript_id(resource_data_id, odata_type=odata_type):
  386. transcript_id = resource_data_id
  387. meeting_id = meeting_id or transcript_id or recording_id or TeamsPipelineStore.build_notification_receipt_key(notification)
  388. extra_metadata = {k: v for k, v in (("transcript_id", transcript_id), ("recording_id", recording_id)) if v}
  389. return str(meeting_id), organizer_user_id, extra_metadata
  390. def _build_summary_prompt(meeting_ref: TeamsMeetingRef, transcript_text: str, artifacts: list[MeetingArtifact]) -> str:
  391. artifact_lines = [f"- {artifact.artifact_type}:{artifact.artifact_id}:{artifact.display_name or ''}" for artifact in artifacts]
  392. return (
  393. f"Meeting ID: {meeting_ref.meeting_id}\n"
  394. f"Title: {meeting_ref.metadata.get('subject') or 'Unknown'}\n"
  395. f"Artifacts:\n{chr(10).join(artifact_lines) or '- none'}\n\n"
  396. f"Transcript:\n{transcript_text[:18000]}")
  397. def _clean_items(values: Any) -> list[str]:
  398. return [str(item).strip() for item in values if str(item).strip()]
  399. def _parse_summary_json(content: str) -> dict[str, Any]:
  400. text = (content or "").strip()
  401. if not text:
  402. return _heuristic_summary("")
  403. # Tolerate prose or code fences around the JSON object.
  404. start, end = text.find("{"), text.rfind("}")
  405. if start >= 0 and end > start:
  406. text = text[start : end + 1]
  407. payload = json.loads(text)
  408. return {
  409. "summary": str(payload.get("summary") or "").strip(),
  410. **{key: _clean_items(payload.get(key, [])) for key in ("key_decisions", "action_items", "risks")},
  411. "confidence": str(payload.get("confidence") or "medium").strip(),
  412. "confidence_notes": str(payload.get("confidence_notes") or "").strip()}
  413. def _heuristic_summary(transcript_text: str) -> dict[str, Any]:
  414. lines = [line.strip(" -*\t") for line in transcript_text.splitlines() if line.strip()]
  415. lowered = [line.lower() for line in lines]
  416. return {
  417. "summary": " ".join(lines[:3])[:1200] or "Transcript unavailable or too sparse for a confident summary.",
  418. "key_decisions": [line for line, low in zip(lines, lowered) if "decide" in low or "decision" in low][:6],
  419. "action_items": [line for line, low in zip(lines, lowered) if low.startswith(("action:", "todo:", "next step:", "follow up:"))][:8],
  420. "risks": [line for line, low in zip(lines, lowered) if "risk" in low or "blocker" in low][:6],
  421. "confidence": "low" if len(transcript_text.strip()) < 300 else "medium",
  422. "confidence_notes": "Generated with heuristic fallback because no LLM summary response was available."}
  423. def _render_summary_markdown(payload: TeamsMeetingSummaryPayload) -> str:
  424. lines = [f"# {payload.title or f'Meeting {payload.meeting_ref.meeting_id}'}"]
  425. for heading, body in _sections(payload):
  426. lines += ["", f"## {heading}", body or ("No summary available." if heading == "Summary" else "- None")]
  427. lines += ["", f"Confidence: {payload.confidence or 'unknown'}", payload.confidence_notes or ""]
  428. return "\n".join(lines).strip()