Initial commit of current state

test_observer.py

@@ -0,0 +1,48 @@
+"""The turn must close even if the reply observer explodes, and the observer
+must be the one we passed rather than pipecat's."""
+import asyncio, argparse, sys
+sys.path.insert(0, "/Users/adolforeyna/voice-agent")
+from pathlib import Path
+from bot import build_claude_options
+from claude_llm import ClaudeCodeLLM
+from pipecat.frames.frames import EndFrame, Frame, LLMContextFrame, LLMFullResponseEndFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.worker import PipelineWorker
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.workers.runner import WorkerRunner
+
+class Sink(FrameProcessor):
+    def __init__(self):
+        super().__init__(); self.ended = asyncio.Event()
+    async def process_frame(self, f, d):
+        await super().process_frame(f, d)
+        if isinstance(f, LLMFullResponseEndFrame): self.ended.set()
+        await self.push_frame(f, d)
+
+async def run(observer, label):
+    args = argparse.Namespace(allow_writes=False, cwd=str(Path.home()/"Workspace"),
+                              claude_model="claude-sonnet-4-6", load_settings=False)
+    llm = ClaudeCodeLLM(options=build_claude_options(args, None, None), observer=observer)
+    sink = Sink()
+    worker = PipelineWorker(Pipeline([llm, sink]))
+    runner = WorkerRunner(handle_sigint=False)
+    await runner.add_workers(worker)
+    task = asyncio.create_task(runner.run())
+    await asyncio.sleep(0.4)
+    ctx = LLMContext(); ctx.add_message({"role":"user","content":"Say hi in three words."})
+    await worker.queue_frames([LLMContextFrame(context=ctx)])
+    try:
+        await asyncio.wait_for(sink.ended.wait(), timeout=90)
+        print(f"  PASS  {label}: turn closed")
+    except asyncio.TimeoutError:
+        print(f"  FAIL  {label}: LLMFullResponseEndFrame never arrived")
+    await worker.queue_frames([EndFrame()]); await task
+
+async def main():
+    seen = []
+    await run(seen.append, "normal observer")
+    print(f"  {'PASS' if seen else 'FAIL'}  observer actually called ({len(seen)} reply)")
+    def boom(_): raise RuntimeError("observer blew up")
+    await run(boom, "observer raises")
+asyncio.run(main())