yapwrap 0.0.1a1__py3-none-any.whl

yapwrap/__init__.py

@@ -0,0 +1,36 @@
+"""YapWrap: Framework-agnostic, ultra-low-latency streaming voice pipeline for AI agents."""
+
+from yapwrap.core.base import BaseAgent, BaseSTT, BaseTTS, BaseVAD, BaseTransport
+from yapwrap.core.yapwrap import YapWrap
+from yapwrap.core.protocols import Transport, VAD, STT, Agent, TTS, SessionEventSink
+from yapwrap.core.events import AgentEvent, SessionEvent, TranscriptEvent
+from yapwrap.core.session import VoiceSession
+from yapwrap.core.memory import InMemoryHistory, ConversationTurn
+
+# Yapper is an alias for YapWrap
+Yapper = YapWrap
+
+__all__ = [
+    "BaseAgent",
+    "BaseSTT",
+    "BaseTTS",
+    "BaseVAD",
+    "BaseTransport",
+    "YapWrap",
+    "Yapper",
+    "Transport",
+    "VAD",
+    "STT",
+    "Agent",
+    "TTS",
+    "AgentEvent",
+    "SessionEvent",
+    "SessionEventSink",
+    "TranscriptEvent",
+    "VoiceSession",
+    "InMemoryHistory",
+    "ConversationTurn",
+]
+
+__version__ = "0.0.1a1"
+

yapwrap/agents/__init__.py

@@ -0,0 +1,30 @@
+"""Python Agent SDK adapters for yapwrap."""
+
+from yapwrap.core.base import BaseAgent
+from yapwrap.agents.agno import AgnoAgent
+from yapwrap.agents.langgraph import LangGraphAgent
+from yapwrap.agents.openai_agents import OpenAIAgentsSDKAgent
+from yapwrap.agents.pydantic_ai import PydanticAIAgent
+from yapwrap.agents.google_adk import GoogleADKAgent
+from yapwrap.agents.claude import ClaudeAgentSDKAgent
+from yapwrap.agents.crewai import CrewAIAgent
+from yapwrap.agents.llamaindex import LlamaIndexAgent
+from yapwrap.agents.microsoft_agent import MicrosoftAgentFrameworkAgent
+from yapwrap.agents.smolagents import SmolAgentsAgent
+from yapwrap.agents.callable import CallableAgent
+
+__all__ = [
+    "BaseAgent",
+    "AgnoAgent",
+    "LangGraphAgent",
+    "OpenAIAgentsSDKAgent",
+    "PydanticAIAgent",
+    "GoogleADKAgent",
+    "ClaudeAgentSDKAgent",
+    "CrewAIAgent",
+    "LlamaIndexAgent",
+    "MicrosoftAgentFrameworkAgent",
+    "SmolAgentsAgent",
+    "CallableAgent",
+]
+

yapwrap/agents/agno.py

@@ -0,0 +1,54 @@
+"""Agno Agent adapter for yapwrap."""
+
+import asyncio
+import inspect
+from typing import Any, AsyncIterator
+
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class AgnoAgent(BaseAgent):
+    """Adapts an Agno Agent into a yapwrap Agent."""
+
+    def __init__(self, agent: Any, **run_kwargs: Any) -> None:
+        self.agent = agent
+        self.run_kwargs = run_kwargs
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        """Stream events from an Agno agent run."""
+        # Agno agents support async streaming with stream=True
+        if hasattr(self.agent, "arun"):
+            stream = self.agent.arun(text, **{**self.run_kwargs, "stream": True, "stream_events": True})
+            if inspect.isawaitable(stream):
+                stream = await stream
+            try:
+                async for event in stream:
+                    kind = getattr(event, "event", "")
+                    content = getattr(event, "content", None)
+
+                    if kind == "RunContent" and isinstance(content, str):
+                        yield AgentEvent.text(content)
+                    elif kind in ("ToolCallStarted", "ToolCallCompleted"):
+                        tool = getattr(event, "tool", None)
+                        name = getattr(tool, "tool_name", "tool")
+                        if kind == "ToolCallStarted":
+                            yield AgentEvent.tool_start(name, getattr(tool, "tool_args", None))
+                        else:
+                            yield AgentEvent.tool_end(name, getattr(tool, "result", None))
+                    elif kind in ("RunError", "RunCancelled"):
+                        raise RuntimeError(f"Agno {kind}: {content or ''}")
+                    elif isinstance(content, str) and content and not kind:
+                        yield AgentEvent.text(content)
+            finally:
+                close = getattr(stream, "aclose", None)
+                if close is not None:
+                    await close()
+        elif hasattr(self.agent, "run"):
+            # Synchronous fallback
+            resp = await asyncio.to_thread(self.agent.run, text, **self.run_kwargs)
+            content = getattr(resp, "content", str(resp))
+            yield AgentEvent.text(content)
+        else:
+            raise TypeError("AgnoAgent expects an object with arun() or run()")
+

yapwrap/agents/callable.py

@@ -0,0 +1,57 @@
+"""Adapt plain Python callables without importing an agent framework."""
+
+import asyncio
+import inspect
+from collections.abc import AsyncIterable, Iterable
+from typing import Any, AsyncIterator, Callable
+
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class CallableAgent(BaseAgent):
+    """Accept text, events, and synchronous or asynchronous streams of either.
+
+    Async callables are preferred for cancellable network work. Synchronous
+    callables run in a worker thread; Python cannot interrupt that thread.
+    """
+
+    def __init__(self, func: Callable[[str], Any]) -> None:
+        self.func = func
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        if inspect.iscoroutinefunction(self.func) or inspect.isasyncgenfunction(self.func):
+            result = self.func(text)
+        else:
+            result = await asyncio.to_thread(self.func, text)
+        if inspect.isawaitable(result):
+            result = await result
+        if isinstance(result, (str, AgentEvent)):
+            yield self._event(result)
+        elif isinstance(result, AsyncIterable):
+            stream = result.__aiter__()
+            try:
+                async for item in stream:
+                    yield self._event(item)
+            finally:
+                close = getattr(stream, "aclose", None)
+                if close is not None:
+                    await close()
+        elif isinstance(result, Iterable):
+            iterator = iter(result)
+            end = object()
+            while True:
+                item = await asyncio.to_thread(next, iterator, end)
+                if item is end:
+                    break
+                yield self._event(item)
+        else:
+            raise TypeError("CallableAgent must return text, AgentEvent, or an iterable of either")
+
+    @staticmethod
+    def _event(item: Any) -> AgentEvent:
+        if isinstance(item, AgentEvent):
+            return item
+        if isinstance(item, str):
+            return AgentEvent.text(item)
+        raise TypeError("Agent stream items must be strings or AgentEvent objects")

yapwrap/agents/claude.py

@@ -0,0 +1,49 @@
+"""Claude Agent SDK client adapter."""
+
+from contextlib import aclosing
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class ClaudeAgentSDKAgent(BaseAgent):
+    """Adapt a connected ClaudeSDKClient owned by an async context manager."""
+
+    def __init__(self, agent: Any) -> None:
+        self.agent = agent
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        await self.agent.query(text)
+        finished = False
+        partial = False
+        try:
+            async with aclosing(self.agent.receive_response()) as stream:
+                async for message in stream:
+                    kind = type(message).__name__
+                    if kind == "StreamEvent":
+                        event = message.event
+                        if event.get("type") == "message_start":
+                            partial = False
+                        delta = event.get("delta", {})
+                        if delta.get("type") == "text_delta":
+                            partial = True
+                            if delta.get("text"):
+                                yield AgentEvent.text(delta["text"])
+                    elif kind == "AssistantMessage":
+                        if not partial:
+                            for block in message.content:
+                                if type(block).__name__ == "TextBlock" and block.text:
+                                    yield AgentEvent.text(block.text)
+                        partial = False
+                    elif kind == "ResultMessage":
+                        finished = True
+                        if message.is_error:
+                            raise RuntimeError(message.result or "Claude agent run failed")
+            finished = True
+        finally:
+            if not finished:
+                await self.agent.interrupt()
+                # Drain the interrupted run before the next query.
+                async for _ in self.agent.receive_response():
+                    pass
+

yapwrap/agents/crewai.py

@@ -0,0 +1,25 @@
+"""CrewAI Crew adapter."""
+
+import asyncio
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class CrewAIAgent(BaseAgent):
+    """Speak a Crew's final output. Tasks receive the utterance as {input}."""
+
+    def __init__(self, crew_or_agent: Any) -> None:
+        self.crew = crew_or_agent
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        inputs = {"input": text}
+        if hasattr(self.crew, "akickoff"):
+            result = await self.crew.akickoff(inputs=inputs)
+        elif hasattr(self.crew, "kickoff_async"):
+            result = await self.crew.kickoff_async(inputs=inputs)
+        else:
+            result = await asyncio.to_thread(self.crew.kickoff, inputs=inputs)
+        if result.raw:
+            yield AgentEvent.text(result.raw)
+

yapwrap/agents/google_adk.py

@@ -0,0 +1,47 @@
+"""Google ADK Runner adapter."""
+
+from contextlib import aclosing
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class GoogleADKAgent(BaseAgent):
+    """Adapt a Runner and an existing ADK session, owned by the application."""
+
+    def __init__(self, runner: Any, *, user_id: str, session_id: str, run_config: Any = None) -> None:
+        self.runner = runner
+        self.user_id = user_id
+        self.session_id = session_id
+        self.run_config = run_config
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        from google.genai import types
+
+        message = types.Content(role="user", parts=[types.Part(text=text)])
+        stream = self.runner.run_async(
+            user_id=self.user_id, session_id=self.session_id,
+            new_message=message, run_config=self.run_config,
+        )
+        partial = False
+        async with aclosing(stream):
+            async for event in stream:
+                if getattr(event, "error_code", None):
+                    raise RuntimeError(event.error_message or event.error_code)
+                content = getattr(event, "content", None)
+                if content is None or content.role == "user":
+                    continue
+                output = "".join(
+                    part.text for part in (content.parts or [])
+                    if part.text and not getattr(part, "thought", False)
+                )
+                if event.partial:
+                    partial = True
+                    if output:
+                        yield AgentEvent.text(output)
+                else:
+                    # ADK emits an aggregate after partial tokens of each response.
+                    if output and not partial:
+                        yield AgentEvent.text(output)
+                    partial = False
+

yapwrap/agents/langgraph.py

@@ -0,0 +1,59 @@
+"""LangGraph and LangChain create_agent adapter."""
+
+from contextlib import aclosing
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+def _text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "".join(
+            block if isinstance(block, str) else block.get("text", "")
+            for block in content
+            if isinstance(block, str) or isinstance(block, dict) and block.get("type") == "text"
+        )
+    return ""
+
+
+class LangGraphAgent(BaseAgent):
+    """Adapt a compiled graph, optionally passing config (e.g. thread_id)."""
+
+    def __init__(self, graph: Any, **run_kwargs: Any) -> None:
+        self.graph = graph
+        self.run_kwargs = run_kwargs
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        inputs = {"messages": [{"role": "user", "content": text}]}
+        if hasattr(self.graph, "astream_events"):
+            stream = self.graph.astream_events(inputs, **{**self.run_kwargs, "version": "v2"})
+            async with aclosing(stream):
+                async for event in stream:
+                    kind, data = event.get("event"), event.get("data", {})
+                    if kind == "on_chat_model_stream":
+                        content = _text(getattr(data.get("chunk"), "content", ""))
+                        if content:
+                            yield AgentEvent.text(content)
+                    elif kind == "on_tool_start":
+                        yield AgentEvent.tool_start(event.get("name", "tool"), data.get("input"))
+                    elif kind == "on_tool_end":
+                        yield AgentEvent.tool_end(event.get("name", "tool"), data.get("output"))
+            return  # Never execute tools again as a fallback after an error.
+
+        async with aclosing(self.graph.astream(inputs, **self.run_kwargs)) as stream:
+            async for chunk in stream:
+                if isinstance(chunk, str):
+                    yield AgentEvent.text(chunk)
+                    continue
+                states = [chunk] if "messages" in chunk else chunk.values()
+                for state in states:
+                    if not isinstance(state, dict):
+                        continue
+                    for message in state.get("messages", []):
+                        role = message.get("role") if isinstance(message, dict) else getattr(message, "type", None)
+                        if role in ("assistant", "ai"):
+                            content = _text(message.get("content") if isinstance(message, dict) else message.content)
+                            if content:
+                                yield AgentEvent.text(content)

yapwrap/agents/llamaindex.py

@@ -0,0 +1,27 @@
+"""LlamaIndex FunctionAgent / AgentWorkflow adapter."""
+
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class LlamaIndexAgent(BaseAgent):
+    """Adapt a workflow; pass ctx=Context(agent) to retain conversation state."""
+
+    def __init__(self, agent: Any, **run_kwargs: Any) -> None:
+        self.agent = agent
+        self.run_kwargs = run_kwargs
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        handler = self.agent.run(user_msg=text, **self.run_kwargs)
+        finished = False
+        try:
+            async for event in handler.stream_events():
+                if type(event).__name__ == "AgentStream" and event.delta:
+                    yield AgentEvent.text(event.delta)
+            await handler  # Surface failures without repeating the final text.
+            finished = True
+        finally:
+            if not finished:
+                await handler.cancel_run()
+

yapwrap/agents/microsoft_agent.py

@@ -0,0 +1,20 @@
+"""Microsoft Agent Framework adapter."""
+
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class MicrosoftAgentFrameworkAgent(BaseAgent):
+    """Adapt an Agent's ResponseStream, closing it when speech is interrupted."""
+
+    def __init__(self, agent: Any, **run_kwargs: Any) -> None:
+        self.agent = agent
+        self.run_kwargs = run_kwargs
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        async with self.agent.run(text, **{**self.run_kwargs, "stream": True}) as stream:
+            async for update in stream:
+                if update.text:
+                    yield AgentEvent.text(update.text)
+

yapwrap/agents/openai_agents.py

@@ -0,0 +1,34 @@
+"""OpenAI Agents SDK adapter; the SDK is an optional dependency."""
+
+from contextlib import aclosing
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class OpenAIAgentsSDKAgent(BaseAgent):
+    """Adapt an SDK Agent, with optional Runner and run options (e.g. session)."""
+
+    def __init__(self, agent: Any, runner: Any = None, **run_kwargs: Any) -> None:
+        self.agent = agent
+        self.runner = runner
+        self.run_kwargs = run_kwargs
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        runner = self.runner
+        if runner is None:
+            from agents import Runner
+            runner = Runner
+        result = runner.run_streamed(self.agent, input=text, **self.run_kwargs)
+        finished = False
+        try:
+            async with aclosing(result.stream_events()) as stream:
+                async for event in stream:
+                    if event.type == "raw_response_event" and event.data.type == "response.output_text.delta":
+                        if event.data.delta:
+                            yield AgentEvent.text(event.data.delta)
+            finished = True
+        finally:
+            if not finished:
+                result.cancel()
+

yapwrap/agents/pydantic_ai.py

@@ -0,0 +1,27 @@
+"""Pydantic AI text agent adapter."""
+
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class PydanticAIAgent(BaseAgent):
+    """Adapt a text-output Agent; pass dependencies/history as run options."""
+
+    def __init__(self, agent: Any, **run_kwargs: Any) -> None:
+        self.agent = agent
+        self.run_kwargs = run_kwargs
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        if hasattr(self.agent, "run_stream"):
+            async with self.agent.run_stream(text, **self.run_kwargs) as result:
+                async for delta in result.stream_text(delta=True):
+                    if delta:
+                        yield AgentEvent.text(delta)
+        else:
+            result = await self.agent.run(text, **self.run_kwargs)
+            if not isinstance(result.output, str):
+                raise TypeError("PydanticAIAgent requires a text-output agent")
+            if result.output:
+                yield AgentEvent.text(result.output)
+

yapwrap/agents/smolagents.py

@@ -0,0 +1,37 @@
+"""Hugging Face smolagents adapter."""
+
+import asyncio
+from typing import Any, AsyncIterator
+from yapwrap.core.base import BaseAgent
+from yapwrap.core.events import AgentEvent
+
+
+class SmolAgentsAgent(BaseAgent):
+    """Speak final answers without reading intermediate reasoning/tool logs.
+
+    Synchronous agent work runs in a worker thread. A running thread cannot be
+    forcibly cancelled; the next turn waits for it to finish before reusing it.
+    """
+
+    def __init__(self, agent: Any) -> None:
+        self.agent = agent
+        self._pending: Any = None
+
+    async def respond(self, text: str) -> AsyncIterator[AgentEvent]:
+        if self._pending is not None:
+            try:
+                await asyncio.shield(self._pending)
+            finally:
+                if self._pending.done():
+                    self._pending = None
+        self._pending = asyncio.create_task(asyncio.to_thread(self.agent.run, text))
+        # Retrieve exceptions even if the session ends during the worker.
+        self._pending.add_done_callback(lambda task: task.exception() if not task.cancelled() else None)
+        try:
+            result = await asyncio.shield(self._pending)
+            if result is not None:
+                yield AgentEvent.text(str(result))
+        finally:
+            if self._pending.done():
+                self._pending = None
+

yapwrap/core/__init__.py

@@ -0,0 +1,27 @@
+"""YapWrap core architecture: base classes, events, audio processing, memory, and session pipeline."""
+
+from yapwrap.core.base import BaseAgent, BaseSTT, BaseTTS, BaseVAD, BaseTransport
+from yapwrap.core.protocols import Transport, VAD, STT, Agent, TTS
+from yapwrap.core.events import AgentEvent, SessionEvent, TranscriptEvent
+from yapwrap.core.memory import InMemoryHistory, ConversationTurn
+from yapwrap.core.session import VoiceSession
+
+__all__ = [
+    "BaseAgent",
+    "BaseSTT",
+    "BaseTTS",
+    "BaseVAD",
+    "BaseTransport",
+    "Transport",
+    "VAD",
+    "STT",
+    "Agent",
+    "TTS",
+    "AgentEvent",
+    "SessionEvent",
+    "TranscriptEvent",
+    "InMemoryHistory",
+    "ConversationTurn",
+    "VoiceSession",
+]
+