signalwire-sdk 3.4.3.dev118__tar.gz → 3.4.3.dev119__tar.gz

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/CHANGELOG.md

@@ -5,8 +5,9 @@
 Webhook signatures and SWAIG tokens are now enforced on every path, including
 serverless. Skills that fetch URLs no longer reach internal addresses through
 redirects, the agent's `/mcp` endpoint requires basic auth, and `async def`
-tool handlers run. The package now installs its documentation, and
-`sw-pydocs` prints it.
+tool handlers run. Synchronous handlers and callbacks run in worker threads,
+so a slow one no longer holds up every other call. The package now installs
+its documentation, and `sw-pydocs` prints it.
 
 ### Added
 - `sw-pydocs`: the SDK's documentation for the installed version, for people
@@ -22,6 +23,31 @@ tool handlers run. The package now installs its documentation, and
 - The package's `llms.txt` lists the installed docs.
 
 ### Changed
+- The web server runs synchronous user code in a worker thread, from AnyIO's
+  thread pool (40 threads by default), instead of on its event loop: `def`
+  tool handlers, the per-request configuration callback and the render of the
+  copy it configures, routing callbacks, `on_summary`, the debug event handler
+  and tools called through `/mcp`. Before, a handler that waited on an API or
+  a database held up every other request on the server, including other
+  calls' SWML. The context variables that code sets are applied to the
+  request's context when it returns, so they still reach the request's later
+  steps, such as the configuration callback's to the tool. `async def`
+  handlers are still awaited directly on the event loop, without a worker
+  thread.
+  An `on_swml_request` override (including `InfoGathererAgent`'s question
+  callback) and the render of the agent's own document stay on the event
+  loop too, as do a plain `SWMLService`'s `on_request` and render. Set
+  `SWML_SYNC_HANDLERS_INLINE=true` to run everything on the event loop, as
+  before.
+- With a per-request configuration callback set, a tool handler that's a
+  method of the agent (an `@AgentBase.tool` method, or `self.method` passed to
+  `define_tool()`, or a partial of one) runs with `self` as that request's
+  configured copy, as `on_summary` already did. It used to run on the
+  original agent, so it couldn't see what the callback configured. Tools
+  called through `/mcp` don't use the callback and still run on the agent.
+- The per-request copy starts with the skills the agent loaded, instead of
+  loading each one again, which ran every skill's `setup()` on every
+  request and left the copy's skill list empty.
 - Importing `signalwire.cli` no longer imports `swaig-test`, so the SDK's other
   commands start about 0.8 seconds sooner.
 
@@ -164,6 +190,15 @@ tool handlers run. The package now installs its documentation, and
   `schema.json` without `SWML_SCHEMA_PATH`.
 - The MCP gateway's Docker image builds and runs, and Compose passes its
   defaults instead of empty strings for unset variables.
+- The per-request copy of an agent shared the agent's SWML document until its
+  render, so a verb method such as `play()` called on the copy in the
+  per-request callback added the verb to the agent's own document. The copy
+  now starts with its own.
+- `add_mcp_server()` in the per-request callback added the server to the
+  agent's own list, so every call added another, and later calls saw them
+  all. The copy now has its own list, as it does for SIP usernames.
+- The spider skill's page cache could raise `KeyError` when two fetches ran
+  at once, which they now can. It's locked.
 
 ### Deprecated
 - `keyword_weight` (`SearchEngine.search()`, the pgvector backend,
@@ -201,6 +236,21 @@ tool handlers run. The package now installs its documentation, and
   Set `auth_password` (or `MCP_AUTH_PASSWORD`) to accept other connections.
   Compose now requires `MCP_AUTH_PASSWORD`, and the sample configuration,
   Compose file and scripts use port 8080, the code's default, instead of 8100.
+- With a per-request configuration callback set, a tool method's `self` is
+  the request's copy of the agent. A method that kept state across calls by
+  assigning an attribute (`self.count += 1`) now assigns it on the copy, and
+  the value is gone after the request. Keep that state in an object the
+  agent already holds, or in your own storage.
+- Synchronous tool handlers and callbacks can now run at the same time as each
+  other. Guard state they share, such as a module-level dictionary, with a
+  `threading.Lock`, and don't share one `sqlite3` connection between them.
+  A synchronous handler no longer runs on the event loop, so
+  `asyncio.create_task()`, `asyncio.get_running_loop()` and similar calls in
+  it raise `RuntimeError`; make such a handler `async def`.
+  Without a per-request configuration callback, a handler that's a method of
+  the agent runs with `self` as the agent every call shares. Setting
+  `SWML_SYNC_HANDLERS_INLINE=true` restores the previous behavior while you
+  check.
 - The MCP gateway's Docker image installs `signalwire-sdk` from PyPI (pin one
   with `--build-arg SDK_VERSION=x.y.z`), so it gets these fixes only from a
   release that includes them.

{signalwire_sdk-3.4.3.dev118/signalwire/signalwire_sdk.egg-info → signalwire_sdk-3.4.3.dev119}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire-sdk
-Version: 3.4.3.dev118
+Version: 3.4.3.dev119
 Summary: SignalWire SDK for AI voice agents, live call control (RELAY) and REST. Run sw-pydocs for its documentation.
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/docs/agent_guide.md

@@ -331,6 +331,21 @@ def get_weather(self, args, raw_data):
 
 A handler can also be an `async def` function, so it can await other asynchronous calls. When the agent serves `/swaig`, the SDK awaits the handler on the request's event loop. In serverless deployments and in `swaig-test`, it runs the handler to completion.
 
+#### Handlers and Concurrency
+
+The agent's web server handles every call on one event loop. A plain `def` handler, such as one that calls an API with `requests`, runs in a worker thread, so a slow handler on one call doesn't hold up the others. The same is true of the per-request configuration callback, routing callbacks, `on_summary`, the debug event handler and tools called through `/mcp`. The threads come from AnyIO's thread pool, the one FastAPI uses for `def` routes, which runs 40 at a time by default. An `async def` handler runs on the event loop, so it must not block it: await asynchronous calls instead.
+
+Because handlers for different calls can run at the same time, treat anything they share as shared between threads:
+
+- A handler that's a method of your agent, such as one defined with `@AgentBase.tool` or passed to `define_tool()` as `self.method`, runs with `self` as the agent, which every call shares. With a per-request configuration callback set, a tool call from SignalWire runs the method on that request's copy instead, so `self` sees what the callback configured, and an attribute it assigns stays on the copy. A function that captures the agent in a closure always sees the shared agent, and so does a tool called through `/mcp`, which doesn't use the callback. Don't change the shared agent's configuration from a handler; return a `FunctionResult` with actions, such as `update_global_data()`, to change the call instead.
+- Protect module-level or instance state that handlers change, such as a dictionary of orders by call ID, with a `threading.Lock`, or keep it in a database.
+- Open a database connection in the handler, or use a pool. A `sqlite3` connection opened in one thread can't be used from another.
+- A plain `def` handler has no running event loop, so `asyncio.create_task()`, `asyncio.get_running_loop()` and similar calls raise `RuntimeError` there. Make a handler that needs the loop `async def`.
+
+An `on_swml_request` override still runs on the event loop, because it can change the agent just before the agent's own document is rendered. So does `InfoGathererAgent`'s question callback, which its `on_swml_request` calls. Keep them fast, or do per-request work in the per-request configuration callback instead.
+
+Set `SWML_SYNC_HANDLERS_INLINE=true` to run synchronous handlers and callbacks on the event loop instead, one at a time, as earlier releases did. The serverless entry points call handlers directly, as before.
+
 ### 2. External Webhook Functions
 
 External webhook functions allow you to delegate function execution to external services instead of handling them locally. This is useful when you want to:
@@ -1389,7 +1404,9 @@ The callback function receives four parameters:
 
 ### Dynamic Configuration Methods
 
-The `agent` parameter in your callback is a copy of the agent made for this request, so you can use all the same configuration methods you would use during initialization, and the changes apply to this request only. The configuration the SDK manages, such as the prompt, tools, skills, languages, parameters, hints and global data, is copied. Other attributes, such as ones your own class adds, are shared with the agent and with other requests: assign a new value to one rather than changing the shared object in place, and keep per-caller state in global data or your own storage.
+The `agent` parameter in your callback is a copy of the agent made for this request, so you can use all the same configuration methods you would use during initialization, and the changes apply to this request only. The configuration the SDK manages, such as the prompt, tools, skills, languages, parameters, hints, global data and MCP servers, is copied. Other attributes, such as ones your own class adds, are shared with the agent and with other requests: assign a new value to one rather than changing the shared object in place, and keep per-caller state in global data or your own storage.
+
+The callback, and the rendering of the copy it configured, run in a worker thread, so the callback can look up a tenant in a database without holding up other calls. Callbacks for different calls run at the same time, which is why changing a shared object in place is unsafe: two requests can change it at once. See [Handlers and Concurrency](#handlers-and-concurrency).
 
 #### Language Configuration
 

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/docs/architecture.md

@@ -1207,6 +1207,8 @@ Proxy / request-trust knobs (all default OFF, enable only behind a trusted proxy
 - `SWML_PROXY_DEBUG`: verbose proxy-header resolution logging
 
 Other knobs:
+- `SWML_SYNC_HANDLERS_INLINE`: run synchronous tool handlers and callbacks on the
+  event loop, one at a time, instead of in worker threads (`1`/`true`/`yes`)
 - `SWML_SKIP_SCHEMA_VALIDATION`: skip SWML schema validation (`1`), for debugging only
 - `SIGNALWIRE_LOG_FORMAT`: log renderer, `console` (default) or `json`
 - `SIGNALWIRE_SPACE_NAME`: default space name used by `sw-agent-init` scaffolding

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/docs/pgi_agent_guide.md

@@ -294,7 +294,7 @@ Handlers typically receive full SWAIG data in `raw_data` and can access `raw_dat
 
 `define_tool` supports explicit schemas and a handler receiving `(args, raw_data)`. Type-hinted decorators can infer schemas, but inspect the result instead of assuming the decorator knows your policy. Use narrow inputs, explicit required fields, and backend validation. The registered tool name and the Python handler name may differ. [S05]
 
-A handler can be `async def`; the SDK awaits it on the request's event loop. A plain `def` handler runs on that loop too, so move slow blocking work, such as a database call that can wait on a lock, off the loop. [S27]
+A handler can be `async def`; the SDK awaits it on the request's event loop, so it must not block. At this guide's baseline, a plain `def` handler runs on that loop too, so move slow blocking work, such as a database call that can wait on a lock, off the loop. Later code runs a plain `def` handler in a worker thread instead, so a slow one doesn't hold up other calls, but handlers for different calls can then run at the same time: protect state they share, and don't share one `sqlite3` connection between threads. `SWML_SYNC_HANDLERS_INLINE=true` restores the baseline's behavior. [S27]
 
 **Verify:** malformed values, omitted required fields, unexpected fields, tenant mismatch, stale state, replay, and backend failures. Descriptions help the model use a tool; they do not validate its inputs. Avoid returning stack traces, credentials, full records, or untrusted instructions as a tool prompt.
 

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "signalwire-sdk"
-version = "3.4.3.dev118"
+version = "3.4.3.dev119"
 description = "SignalWire SDK for AI voice agents, live call control (RELAY) and REST. Run sw-pydocs for its documentation."
 authors = [
     {name = "SignalWire Team", email = "info@signalwire.com"}

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/signalwire/signalwire/__init__.py

@@ -58,7 +58,7 @@ if TYPE_CHECKING:
     from signalwire.utils.schema_utils import SchemaValidationError
     from signalwire.web import WebService
 
-__version__ = "3.4.3.dev118"
+__version__ = "3.4.3.dev119"
 
 # §6.2-python (owner decision: NO packaging split — one package, all deps required;
 # IMPORT-TIME behavior only): the agent/web symbols are lazy-imported via module

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/signalwire/signalwire/agent_server.py

@@ -68,7 +68,7 @@ class AgentServer:
         self.app = FastAPI(
             title="SignalWire AI Agents",
             description="Hosted SignalWire AI Agents",
-            version="3.4.3.dev118",
+            version="3.4.3.dev119",
             redirect_slashes=False,
             docs_url=None,
             redoc_url=None,

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/signalwire/signalwire/cli/pydocs/_topics.py

@@ -133,7 +133,8 @@ existing FastAPI app.
 
 Per-call configuration: `set_dynamic_config_callback()` configures a copy of
 the agent for each request, from its query parameters, body and headers, for
-per-tenant prompts, voices and tools. Don't keep per-caller state on the
+per-tenant prompts, voices and tools. The callback runs in a worker thread,
+at the same time as other calls' callbacks. Don't keep per-caller state on the
 shared agent instance.
 
 Configuration precedence: constructor arguments, then the config file, then
@@ -231,8 +232,10 @@ _TOOLS = Topic(
     summary="Functions the model can call, and what they return",
     body="""\
 A tool is a function the model can ask to call. SignalWire sends the call to
-the agent's `/swaig` endpoint, and the SDK runs your handler. Handlers can be
-`async def`.
+the agent's `/swaig` endpoint, and the SDK runs your handler. A plain `def`
+handler runs in a worker thread, so handlers for different calls run at the
+same time: guard state they share. An `async def` handler runs on the event
+loop and must not block it.
 
 Declare a tool with type hints, and the SDK builds its schema. The docstring's
 summary is the tool's description, and its `Args:` describe the parameters:

signalwire_sdk-3.4.3.dev119/signalwire/signalwire/core/_sync_handlers.py

@@ -0,0 +1,113 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+
+Run synchronous user code off the event loop.
+
+The web server's endpoints are async and share one event loop. Synchronous
+user code called directly on that loop, such as a tool handler that makes an
+HTTP request, blocks every other request, on every call, until it returns.
+The endpoints call that code through ``run_sync_handler``, which runs it in a
+worker thread from AnyIO's thread pool, the pool FastAPI uses for ``def``
+routes. That pool runs 40 threads at a time by default.
+
+The code runs in the worker's copy of the request's context, as for a
+``def`` route, and the context variables it sets are applied to the request's
+context when it returns. So a variable one step sets reaches the request's
+later steps, such as the per-request configuration callback's to the tool
+handler, as it did when every step ran inline.
+
+An ``async def`` handler runs on the event loop, awaited directly, and needs
+no worker thread. When an endpoint can't tell a handler is async, calling it
+in the thread only creates its coroutine, which the endpoint then awaits.
+
+Setting ``SWML_SYNC_HANDLERS_INLINE`` to ``1``, ``true`` or ``yes`` calls the
+code on the event loop instead, as earlier releases did.
+"""
+
+import contextvars
+import functools
+import inspect
+import os
+from collections.abc import Callable
+from typing import Any, ParamSpec, TypeVar
+
+from starlette.concurrency import run_in_threadpool
+
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+_UNSET = object()
+
+
+def sync_handlers_inline() -> bool:
+    """True when ``SWML_SYNC_HANDLERS_INLINE`` asks for the event loop."""
+    return os.getenv("SWML_SYNC_HANDLERS_INLINE", "").lower() in ("1", "true", "yes")
+
+
+def is_async_callable(obj: object) -> bool:
+    """True for an ``async def`` function or method, a partial of one, or an
+    object whose ``__call__`` is ``async def``: calling it only creates a
+    coroutine."""
+    while isinstance(obj, functools.partial):
+        obj = obj.func
+    if inspect.iscoroutinefunction(obj):
+        return True
+    # An instance of a class whose __call__ is async def
+    return callable(obj) and inspect.iscoroutinefunction(type(obj).__call__)
+
+
+async def run_sync_handler(
+    func: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs
+) -> _T:
+    """Call ``func`` in a worker thread, or inline when so configured.
+
+    ``func`` sees the caller's context variables, such as the per-request
+    proxy URL and structlog's bound context. The ones it sets, even if it
+    then raises, are set in the caller's context once it finishes, as they
+    would have been had it run inline. If the caller is cancelled first, they
+    aren't.
+    """
+    if sync_handlers_inline():
+        return func(*args, **kwargs)
+    changes = _Changes()
+    try:
+        return await run_in_threadpool(
+            functools.partial(_recording_changes, changes, func, *args, **kwargs)
+        )
+    finally:
+        if changes.complete:
+            for var, value in changes.values:
+                var.set(value)
+
+
+class _Changes:
+    """The context variables a function set in its worker thread."""
+
+    def __init__(self) -> None:
+        self.values: list[tuple[contextvars.ContextVar[Any], Any]] = []
+        # Set last, once values is final
+        self.complete = False
+
+
+def _recording_changes(
+    changes: _Changes, func: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs
+) -> _T:
+    """Call ``func``, and record in ``changes`` the context variables it sets.
+
+    It runs in the worker's context, where the thread pool has already made
+    its own settings, so only what ``func`` itself changes is recorded.
+    """
+    before = contextvars.copy_context()
+    try:
+        return func(*args, **kwargs)
+    finally:
+        changes.values = [
+            (var, value)
+            for var, value in contextvars.copy_context().items()
+            if before.get(var, _UNSET) is not value
+        ]
+        changes.complete = True

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/signalwire/signalwire/core/agent/tools/type_inference.py

@@ -287,14 +287,33 @@ def create_typed_handler_wrapper(
         A wrapper function with signature (args, raw_data).
     """
 
-    def wrapper(args: dict[str, Any], raw_data: dict[str, Any] | None) -> Any:
-        if has_raw_data:
-            return func(raw_data=raw_data, **args)
-        return func(**args)
+    wrapper: Callable[..., Any]
+    if inspect.iscoroutinefunction(func):
+        # An async wrapper, so the dispatcher can tell the handler is async
+        # and await it on the event loop without a worker thread.
+        async def async_wrapper(
+            args: dict[str, Any], raw_data: dict[str, Any] | None
+        ) -> Any:
+            if has_raw_data:
+                return await func(raw_data=raw_data, **args)
+            return await func(**args)
+
+        wrapper = async_wrapper
+    else:
+
+        def sync_wrapper(args: dict[str, Any], raw_data: dict[str, Any] | None) -> Any:
+            if has_raw_data:
+                return func(raw_data=raw_data, **args)
+            return func(**args)
+
+        wrapper = sync_wrapper
 
     # Preserve original function metadata for debugging
     wrapper.__name__ = getattr(func, "__name__", "typed_handler")
     wrapper.__doc__ = getattr(func, "__doc__", None)
-    wrapper.__wrapped__ = func  # type: ignore[attr-defined]  # standard functools __wrapped__ convention
+    wrapper.__wrapped__ = func  # type: ignore[union-attr]  # standard functools __wrapped__ convention
+    # Marks the SDK's own wrapper, so a per-request copy of the agent can
+    # rebuild it around a method bound to the copy
+    wrapper._typed_has_raw_data = has_raw_data  # type: ignore[union-attr]  # marker attribute on a function
 
     return wrapper

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/signalwire/signalwire/core/agent_base.py

@@ -13,6 +13,7 @@ The SDK's installed documentation covers this module: run ``sw-pydocs agents``,
 """
 
 import contextlib
+import copy
 import functools
 import inspect
 import logging
@@ -20,6 +21,7 @@ import os
 import json
 import uuid
 import re
+import types
 from typing import (
     Any,
     ClassVar,
@@ -112,6 +114,56 @@ def _record_explicit_args(init: Callable[_P, None]) -> Callable[_P, None]:
     return wrapper
 
 
+def _bound_to(function: Any, original: object, ephemeral: object) -> Any:
+    """``function``, with its handler bound to ``ephemeral`` if it's bound to ``original``."""
+    rebound = _rebound(getattr(function, "handler", None), original, ephemeral)
+    if rebound is None:
+        return function
+    function = copy.copy(function)
+    function.handler = rebound
+    return function
+
+
+def _rebound(handler: Any, original: object, ephemeral: object) -> Any:
+    """``handler`` bound to ``ephemeral``, or None if it isn't bound to ``original``.
+
+    Covers a method of ``original``, a partial of one, and the SDK's typed
+    wrapper around one. A function that captures ``original`` in a closure
+    can't be rebound.
+    """
+    if isinstance(handler, types.MethodType) and handler.__self__ is original:
+        return types.MethodType(handler.__func__, ephemeral)
+    if isinstance(handler, functools.partial):
+        inner = _rebound(handler.func, original, ephemeral)
+        if inner is None:
+            return None
+        return functools.partial(inner, *handler.args, **handler.keywords)
+    has_raw_data = getattr(handler, "_typed_has_raw_data", None)
+    if has_raw_data is not None:
+        inner = _rebound(getattr(handler, "__wrapped__", None), original, ephemeral)
+        if inner is None:
+            return None
+        from signalwire.core.agent.tools.type_inference import (
+            create_typed_handler_wrapper,
+        )
+
+        return create_typed_handler_wrapper(inner, has_raw_data)
+    return None
+
+
+def _slot_names(klass: type) -> list[str]:
+    """The attribute names ``klass``'s own ``__slots__`` declares, as stored."""
+    slots = klass.__dict__.get("__slots__", ())
+    names = []
+    for slot in (slots,) if isinstance(slots, str) else slots:
+        if slot in ("__dict__", "__weakref__"):
+            continue
+        if slot.startswith("__") and not slot.endswith("__"):
+            slot = f"_{klass.__name__.lstrip('_')}{slot}"  # name mangling
+        names.append(slot)
+    return names
+
+
 class AgentBase(  # type: ignore[misc]  # intentional diamond: WebMixin's serve/_proxy_url_base override SWMLService/ServerlessMixin's by MRO order; mypy flags the base-vs-base shape diff but the resolution is deliberate
     AuthMixin,
     WebMixin,
@@ -1587,6 +1639,9 @@ class AgentBase(  # type: ignore[misc]  # intentional diamond: WebMixin's serve/
         self.log.debug("swml_rendered", swml_size=len(swml))
         return Response(content=swml, media_type="application/json")
 
+    def _swaig_configures_per_call(self) -> bool:
+        return self._dynamic_config_callback is not None
+
     def _swaig_pre_dispatch(
         self,
         request: Request,
@@ -1806,11 +1861,13 @@ class AgentBase(  # type: ignore[misc]  # intentional diamond: WebMixin's serve/
             _internal_fillers, _swaig_query_params, _native_functions,
             native_functions, pom, _contexts_builder, _contexts_defined,
             skill_manager, _debug_events_enabled, _debug_events_level,
-            _debug_event_handler,
+            _debug_event_handler, _mcp_servers, _sip_usernames,
+            _current_document (a new, empty document; the render rebuilds it),
             _prompt_manager (fresh instance; its _sections, _prompt_text,
                 _post_prompt_text and _contexts are copied),
             _tool_registry (fresh instance; its _swaig_functions and
-                _tool_instances are copied)
+                _tool_instances are copied, and a tool whose handler is a
+                method of this agent gets a handler bound to the copy)
 
         Anything NOT in that list is the master's own object, shared with
         every other request in flight. The distinction that matters is between
@@ -1824,7 +1881,9 @@ class AgentBase(  # type: ignore[misc]  # intentional diamond: WebMixin's serve/
         Getting this wrong does not raise. It produces one visitor's data
         appearing in another visitor's prompt, under concurrency, which is why
         the safe set is enumerated here rather than left to be inferred from
-        the code below.
+        the code below. The concurrency is real: the web server runs the
+        callback and the copy's render in a worker thread, so copies for
+        different calls are configured at the same time.
 
         Callers who need per-request state of their own should keep it in
         `_global_data` (copied) or rebind a fresh object onto the ephemeral
@@ -1839,9 +1898,24 @@ class AgentBase(  # type: ignore[misc]  # intentional diamond: WebMixin's serve/
         cls = self.__class__
         ephemeral_agent = cls.__new__(cls)
 
-        # Copy all attributes as shallow references first
-        for key, value in self.__dict__.items():
+        # Copy all attributes as shallow references first. The items are
+        # snapshotted, because this runs in a worker thread while other
+        # requests use the agent.
+        for key, value in list(self.__dict__.items()):
             setattr(ephemeral_agent, key, value)
+        # A subclass's __slots__ attributes aren't in __dict__
+        for klass in cls.__mro__:
+            for slot in _slot_names(klass):
+                try:
+                    value = klass.__dict__[slot].__get__(self, klass)
+                except AttributeError:
+                    continue  # declared but not set
+                klass.__dict__[slot].__set__(ephemeral_agent, value)
+
+        # The copy's own document. Sharing this agent's would let a verb
+        # method called on the copy, such as play(), add to the document
+        # another request is rendering.
+        ephemeral_agent._current_document = ephemeral_agent._create_empty_document()
 
         # Deep copy only the configuration that affects SWML generation
         # These are the parts that dynamic config might modify
@@ -1852,6 +1926,9 @@ class AgentBase(  # type: ignore[misc]  # intentional diamond: WebMixin's serve/
         ephemeral_agent._pronounce = copy.deepcopy(self._pronounce)
         ephemeral_agent._global_data = copy.deepcopy(self._global_data)
         ephemeral_agent._function_includes = copy.deepcopy(self._function_includes)
+        ephemeral_agent._mcp_servers = copy.deepcopy(self._mcp_servers)
+        if "_sip_usernames" in self.__dict__:
+            ephemeral_agent._sip_usernames = set(self._sip_usernames)
 
         # Deep copy routing callbacks to prevent cross-agent mutation
         if hasattr(self, "_routing_callbacks"):
@@ -1923,12 +2000,15 @@ class AgentBase(  # type: ignore[misc]  # intentional diamond: WebMixin's serve/
 
         # Create new tool registry for the ephemeral agent
         ephemeral_agent._tool_registry = ToolRegistry(ephemeral_agent)
-        # Copy the SWAIG functions - we need a shallow copy here because
-        # the functions themselves can be shared, we just need a new dict
+        # Copy the SWAIG functions. Most can be shared; one whose handler is
+        # a method of this agent is copied with the handler bound to the
+        # copy, so the handler's self sees what the per-request callback
+        # configured, as on_summary does.
         if hasattr(self._tool_registry, "_swaig_functions"):
-            ephemeral_agent._tool_registry._swaig_functions = (
-                self._tool_registry._swaig_functions.copy()
-            )
+            ephemeral_agent._tool_registry._swaig_functions = {
+                name: _bound_to(function, self, ephemeral_agent)
+                for name, function in self._tool_registry._swaig_functions.items()
+            }
         if hasattr(self._tool_registry, "_tool_instances"):
             ephemeral_agent._tool_registry._tool_instances = (  # type: ignore[attr-defined]  # ToolRegistry internal state, guarded by hasattr above
                 self._tool_registry._tool_instances.copy()
@@ -1940,25 +2020,11 @@ class AgentBase(  # type: ignore[misc]  # intentional diamond: WebMixin's serve/
 
         ephemeral_agent.skill_manager = SkillManager(ephemeral_agent)
 
-        # Copy any already loaded skills from the original agent
-        # This ensures skills loaded during __init__ are available in the ephemeral agent
-        if hasattr(self.skill_manager, "loaded_skills"):
-            for skill_instance in self.skill_manager.loaded_skills.values():
-                # Re-load the skill in the ephemeral agent's context
-                # We need to get the skill name and params from the existing instance
-                skill_name = skill_instance.SKILL_NAME
-                skill_params = getattr(skill_instance, "params", {})
-                try:
-                    if skill_name is not None:
-                        ephemeral_agent.skill_manager.load_skill(
-                            skill_name, type(skill_instance), skill_params
-                        )
-                except Exception as e:
-                    self.log.warning(
-                        "failed_to_copy_skill_to_ephemeral",
-                        skill_name=skill_name,
-                        error=str(e),
-                    )
+        # The copy starts with the skills this agent has loaded, sharing their
+        # instances. Their tools, hints, prompt sections and global data are
+        # already in the copied configuration. Skills the callback adds load
+        # on the copy only.
+        ephemeral_agent.skill_manager._inherit(self.skill_manager.loaded_skills)
 
         # Re-bind the tool decorator method to the new instance
         ephemeral_agent.tool = ephemeral_agent._tool_decorator  # type: ignore[method-assign]  # intentional per-instance decorator binding

{signalwire_sdk-3.4.3.dev118 → signalwire_sdk-3.4.3.dev119}/signalwire/signalwire/core/mixins/mcp_server_mixin.py

@@ -13,6 +13,8 @@ import logging
 from collections.abc import Awaitable
 from typing import Any
 
+from signalwire.core._sync_handlers import is_async_callable
+
 logger = logging.getLogger(__name__)
 
 
@@ -56,6 +58,15 @@ class MCPServerMixin:
 
         return tools
 
+    def _mcp_request_runs_sync_code(self, body: dict[str, Any]) -> bool:
+        """True when ``body`` is a tools/call for a synchronous handler."""
+        if not isinstance(body, dict) or body.get("method") != "tools/call":
+            return False
+        params = body.get("params")
+        name = params.get("name", "") if isinstance(params, dict) else ""
+        tool = self._mcp_tools().get(name)
+        return tool is not None and not is_async_callable(tool.handler)
+
     def _handle_mcp_request(
         self, body: dict[str, Any]
     ) -> dict[str, Any] | Awaitable[dict[str, Any]]: