Address Copilot feedback (5)

Signed-off-by: Sergio Herrera <627709+seherv@users.noreply.github.com>

Author: seherv

examples/workflow/async_activities.py

@@ -80,9 +80,9 @@ def summarize_fetches(ctx: wf.WorkflowActivityContext, results: list[dict]) -> s
 
 def main() -> None:
     urls = [
-        'https://httpbin.org/uuid',
-        'https://httpbin.org/get',
-        'https://httpbin.org/headers',
+        'https://example.com',
+        'https://example.org',
+        'https://example.net',
     ]
 
     wfr.start()

ext/dapr-ext-strands/pyproject.toml

@@ -21,6 +21,7 @@ classifiers = [
 dependencies = [
     "dapr",
     "strands-agents>=1.30.0,<2.0.0",
+    "strands-agents-tools>=0.2.22,<1.0.0",
     "python-ulid>=3.0.0,<4.0.0",
     "msgpack-python>=0.4.5,<1.0.0",
 ]

ext/dapr-ext-workflow/AGENTS.md

@@ -109,7 +109,7 @@ Internally wraps user functions: workflow functions get a `DaprWorkflowContext`,
 
 Activities can be either `def my_activity(ctx, inp)` or `async def my_activity(ctx, inp)`. At registration, `_make_activity_wrapper` calls `_is_async_callable(fn)` to detect async-ness. That helper unwraps `functools.partial`, `@functools.wraps` chains, and callable-class `__call__` so common decorator patterns route correctly. The wrapper is built `async def` or `def` to match, then stored in the registry.
 
-At dispatch time (the gRPC stream loop in `_durabletask/worker.py`), `inspect.iscoroutinefunction(activity_fn)` on the wrapper selects between two handlers.
+At dispatch time (the gRPC stream loop in `_durabletask/worker.py`), `is_async_callable(activity_fn)` on the wrapper selects between two handlers.
 
 - **Async activities** go through `_execute_activity_async`, then `_ActivityExecutor.execute_async`, which awaits `fn(...)` directly on the event loop. The gRPC response is delivered via `loop.run_in_executor(self._async_worker_manager.thread_pool, stub.CompleteActivityTask, ...)` — the same pool sync activities use, sized by `maximum_thread_pool_workers`.
 - **Sync activities** go through `_execute_activity`, dispatched to the thread pool by `_AsyncWorkerManager._run_func`. The activity runs on a worker thread, and the response is delivered from the same thread.

ext/dapr-ext-workflow/benchmarks/bench_async_activities.py

@@ -37,7 +37,6 @@
 import math
 import os
 import platform
-import resource
 import shutil
 import socket
 import statistics
@@ -165,9 +164,19 @@ def _percentile(sorted_samples_ms: list[float], q: float) -> float:
     return sorted_samples_ms[lo] + frac * (sorted_samples_ms[hi] - sorted_samples_ms[lo])
 
 
+try:
+    import resource as _resource  # POSIX only
+except ImportError:
+    _resource = None
+
+
 def _current_rss_kb() -> int:
-    """Process RSS in KB. macOS returns bytes from getrusage; Linux returns KB."""
-    rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+    """Process RSS in KB. macOS returns bytes from getrusage; Linux returns KB.
+    Returns 0 on Windows since `resource` is unavailable there.
+    """
+    if _resource is None:
+        return 0
+    rss = _resource.getrusage(_resource.RUSAGE_SELF).ru_maxrss
     if IS_DARWIN:
         return rss // 1024
     return rss

ext/dapr-ext-workflow/dapr/ext/workflow/_durabletask/worker.py

@@ -2141,7 +2141,7 @@ def execute(
         """Run a sync activity function and return the serialized result, if any.
 
         Raises ``RuntimeError`` if the activity returns a coroutine, which happens when
-        ``_is_async_callable`` fails to detect an async callable at registration.
+        ``is_async_callable`` fails to detect an async callable at registration.
         """
         resolved_fn, ctx, activity_input = self._resolve(
             fn,
@@ -2157,7 +2157,9 @@ def execute(
             activity_output.close()
             raise RuntimeError(
                 f"Activity '{name}' returned a coroutine on the sync path. "
-                f'Declare it with ``async def`` so the worker dispatches it on the event loop.'
+                f'Declare it with ``async def``, or if it already is, check that any wrapping '
+                f'decorator uses ``@functools.wraps(fn)`` and does not wrap the async callable '
+                f'in a sync ``def`` (``is_async_callable`` needs to see through the decorator).'
             )
         return self._encode_output(orchestration_id, name, task_id, activity_output)
 

ext/dapr-ext-workflow/docs/concurrency.md

@@ -27,18 +27,17 @@ backpressure.
 
 ## Sizing the thread pool
 
-Two distinct uses of threads exist.
+The worker thread pool, sized by `maximum_thread_pool_workers`, has two uses.
 
 **Sync activity execution.** Each `def` activity holds one thread for its
 duration. Size to peak concurrent sync-activity count.
 
 **Async response delivery.** Each async activity, on completion, schedules
-`stub.CompleteActivityTask` on the worker thread pool to avoid blocking the loop
-during the gRPC send. The pool is the same one sync activities use, sized by
-`maximum_thread_pool_workers`. If the sidecar takes >5 ms to acknowledge and the
-worker runs many concurrent async activities, response delivery can serialize
-through the pool and tail latency inflates. Raise `maximum_thread_pool_workers`
-to widen response-delivery throughput.
+`stub.CompleteActivityTask` on the same pool to avoid blocking the loop during
+the gRPC send. If the sidecar takes >5 ms to acknowledge and the worker runs
+many concurrent async activities, response delivery can serialize through the
+pool and tail latency inflates. Raise `maximum_thread_pool_workers` to widen
+response-delivery throughput.
 
 Mixed workloads with long-running sync activities can starve async response
 delivery (and vice versa) since they share the pool. If that becomes an issue,

ext/dapr-ext-workflow/tests/durabletask/test_activity_dispatch_routing.py

@@ -13,8 +13,8 @@
 
 The work-item dispatcher at the top of ``worker.py``'s gRPC loop selects between
 ``_execute_activity`` (sync, runs in the thread pool) and ``_execute_activity_async``
-(coroutine, awaited on the event loop) using ``inspect.iscoroutinefunction(handler)``
-via ``_AsyncWorkerManager._run_func``. These tests pin the async-ness of each handler so
+(coroutine, awaited on the event loop) using ``is_async_callable(handler)`` via
+``_AsyncWorkerManager._run_func``. These tests pin the async-ness of each handler so
 the dispatch routing stays correct.
 """