marvin 3.2.0__tar.gz → 3.2.2__tar.gz

{marvin-3.2.0 → marvin-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marvin
-Version: 3.2.0
+Version: 3.2.2
 Summary: a simple and powerful tool to get things done with AI
 License:                                  Apache License
                                    Version 2.0, January 2004

{marvin-3.2.0 → marvin-3.2.2}/docs/api-reference/marvin-fns-run.mdx

@@ -32,11 +32,13 @@ def run_stream(instructions: str | Sequence[UserContent], result_type: type[T] =
 ```python
 def run_tasks(tasks: list[Task[Any]], thread: Thread | str | None = None, raise_on_failure: bool = True, handlers: list[Handler | AsyncHandler] | None = None) -> list[Task[Any]]
 ```
+Run tasks either concurrently (if independent) or sequentially.
 
 ### `run_tasks_async`
 ```python
 def run_tasks_async(tasks: list[Task[Any]], thread: Thread | str | None = None, raise_on_failure: bool = True, handlers: list[Handler | AsyncHandler] | None = None) -> list[Task[Any]] | AsyncGenerator[Event, None]
 ```
+Run tasks either concurrently (if independent) or sequentially via orchestrator.
 
 ### `run_tasks_stream`
 ```python

marvin-3.2.2/examples/slackbot/src/slackbot/_internal/thread_status.py

@@ -0,0 +1,94 @@
+"""Thread status tracking for Slack events (cross-process safe).
+
+This module encapsulates a tiny SQLite-backed status mechanism to avoid duplicate
+processing of the same Slack thread when users edit their original post or when
+Slack delivers multiple events. It keeps the rest of the app simple and avoids
+sprawling status logic across files.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from slackbot.core import Database
+
+Status = Literal["in_progress", "completed"]
+
+
+async def ensure_schema(db: Database) -> None:
+    """Ensure the status table exists.
+
+    Using CREATE TABLE IF NOT EXISTS is idempotent and cheap enough to call
+    whenever we touch the status table, avoiding module-level state or locks.
+    """
+
+    def _create() -> None:
+        db.con.execute(
+            """
+            CREATE TABLE IF NOT EXISTS slack_thread_status (
+                thread_ts TEXT PRIMARY KEY,
+                status TEXT NOT NULL CHECK (status IN ('in_progress','completed')),
+                updated_at REAL NOT NULL
+            );
+            """
+        )
+        db.con.commit()
+
+    await db.loop.run_in_executor(db.executor, _create)
+
+
+async def try_acquire(db: Database, thread_ts: str) -> bool:
+    """Attempt to mark a thread as in_progress; returns True if acquired.
+
+    Uses an atomic INSERT OR IGNORE on a PRIMARY KEY to prevent duplicates across
+    concurrent processes or tasks.
+    """
+    await ensure_schema(db)
+
+    def _insert() -> int:
+        cur = db.con.cursor()
+        cur.execute(
+            """
+            INSERT OR IGNORE INTO slack_thread_status (thread_ts, status, updated_at)
+            VALUES (?, 'in_progress', strftime('%s','now'))
+            """,
+            (thread_ts,),
+        )
+        db.con.commit()
+        return cur.rowcount
+
+    rowcount: int = await db.loop.run_in_executor(db.executor, _insert)
+    return rowcount == 1
+
+
+async def get_status(db: Database, thread_ts: str) -> Status | None:
+    await ensure_schema(db)
+
+    def _query() -> Status | None:
+        cur = db.con.cursor()
+        cur.execute(
+            "SELECT status FROM slack_thread_status WHERE thread_ts = ?",
+            (thread_ts,),
+        )
+        row = cur.fetchone()
+        return row[0] if row else None  # type: ignore[return-value]
+
+    return await db.loop.run_in_executor(db.executor, _query)
+
+
+async def mark_completed(db: Database, thread_ts: str) -> None:
+    await ensure_schema(db)
+
+    def _update() -> None:
+        cur = db.con.cursor()
+        cur.execute(
+            """
+            UPDATE slack_thread_status
+            SET status = 'completed', updated_at = strftime('%s','now')
+            WHERE thread_ts = ?
+            """,
+            (thread_ts,),
+        )
+        db.con.commit()
+
+    await db.loop.run_in_executor(db.executor, _update)

{marvin-3.2.0 → marvin-3.2.2}/examples/slackbot/src/slackbot/api.py

@@ -17,6 +17,15 @@ from pydantic_ai.messages import ModelMessage
 
 from slackbot._internal.constants import WORKSPACE_TO_CHANNEL_ID
 from slackbot._internal.templates import CHANNEL_REDIRECT_MESSAGE, WELCOME_MESSAGE
+from slackbot._internal.thread_status import (
+    get_status as get_thread_status,
+)
+from slackbot._internal.thread_status import (
+    mark_completed as mark_thread_completed,
+)
+from slackbot._internal.thread_status import (
+    try_acquire as try_acquire_thread,
+)
 from slackbot.assets import summarize_thread
 from slackbot.core import (
     Database,
@@ -40,6 +49,9 @@ BOT_MENTION = r"<@(\w+)>"
 
 logger = get_logger(__name__)
 
+# Duplicate handling is coordinated via a small SQLite table in
+# _internal.thread_status to work across processes.
+
 
 def get_designated_channel_for_workspace(team_id: str) -> str | None:
     """Get the designated channel ID for a given workspace team ID."""
@@ -106,6 +118,33 @@ async def run_agent(
         raise
 
 
+def _extract_message_context(event: Any) -> tuple[bool, str | None, str | None, str]:
+    """Return (is_edit, message_ts, thread_ts, text) for Slack events.
+
+    - For `message_changed` events, Slack nests the edited message under `event.message`.
+    - For normal app_mention events, fields are at the top level.
+    """
+    is_edit = getattr(event, "subtype", None) == "message_changed"
+    msg = (getattr(event, "message", None) or {}) if is_edit else {}
+
+    # Prefer the message ts for idempotency; fall back to event_ts if needed
+    message_ts = (
+        msg.get("ts")
+        if is_edit
+        else (getattr(event, "ts", None) or getattr(event, "event_ts", None))
+    )
+    # Thread anchor where we should post replies
+    thread_ts = (
+        (msg.get("thread_ts") or msg.get("ts"))
+        if is_edit
+        else (getattr(event, "thread_ts", None) or getattr(event, "ts", None))
+    )
+    # Text used for bot mention detection
+    text = (msg.get("text") if is_edit else (getattr(event, "text", None) or "")) or ""
+
+    return is_edit, message_ts, thread_ts, text
+
+
 @flow(name="Handle Slack Message", retries=1)
 async def handle_message(payload: SlackPayload, db: Database):
     logger = get_run_logger()
@@ -115,9 +154,10 @@ async def handle_message(payload: SlackPayload, db: Database):
         return Completed(message="Invalid event", name="SKIPPED")
 
     USER_MESSAGE_MAX_TOKENS = settings.user_message_max_tokens
-    user_message = event.text or ""
-    thread_ts = event.thread_ts or event.ts
+    # Determine message context accommodating edit events
+    is_edit, message_ts, thread_ts, user_message = _extract_message_context(event)
     assert thread_ts is not None, "No thread_ts found"
+    assert message_ts is not None, "No message_ts found"
     cleaned_message = re.sub(BOT_MENTION, "", user_message).strip()
     msg_len = count_tokens(cleaned_message)
 
@@ -137,6 +177,34 @@ async def handle_message(payload: SlackPayload, db: Database):
         return Completed(message="Message too long", name="SKIPPED")
 
     if re.search(BOT_MENTION, user_message) and payload.authorizations:
+        # Per-message acquire: prevent duplicate handling for this specific message
+        acquired = await try_acquire_thread(db, message_ts)
+        if not acquired:
+            status = await get_thread_status(db, message_ts)
+            if status == "in_progress" and is_edit:
+                assert event.channel is not None, (
+                    "Event channel is None when posting edit-ignored notice"
+                )
+                await post_slack_message(
+                    message=(
+                        "✋ I noticed you edited your original message. "
+                        "I'm already working on your first version — please add any "
+                        "clarifications as new messages in this thread so I don't lose track."
+                    ),
+                    channel_id=event.channel,
+                    thread_ts=thread_ts,
+                )
+                return Completed(
+                    message="Ignored edit while in progress",
+                    name="IGNORED_EDIT",
+                    data=dict(message_ts=message_ts, thread_ts=thread_ts),
+                )
+            return Completed(
+                message="Duplicate event for message",
+                name="SKIPPED_DUPLICATE",
+                data=dict(message_ts=message_ts, thread_ts=thread_ts),
+            )
+
         # Check if this is the designated channel
         team_id = payload.team_id or ""
         is_designated = check_if_designated_channel(event.channel, team_id)
@@ -188,7 +256,11 @@ async def handle_message(payload: SlackPayload, db: Database):
 
         try:
             result = await run_agent(
-                cleaned_message, conversation, user_context, event.channel, thread_ts
+                cleaned_message,
+                conversation,
+                user_context,
+                event.channel,
+                thread_ts,
             )  # type: ignore
 
             await db.add_thread_messages(thread_ts, result.new_messages())
@@ -213,6 +285,12 @@ async def handle_message(payload: SlackPayload, db: Database):
                 name="ERROR_HANDLED",
                 data=dict(error=str(e), user_context=user_context),
             )
+        finally:
+            try:
+                await mark_thread_completed(db, message_ts)
+            except Exception:
+                logger.warning("Failed to mark message as completed")
+
         return Completed(
             message="Responded to mention",
             data=dict(user_context=user_context, conversation=conversation),

{marvin-3.2.0 → marvin-3.2.2}/examples/slackbot/src/slackbot/core.py

@@ -129,6 +129,9 @@ class Database:
 
         await self.loop.run_in_executor(self.executor, _insert)
 
+    # Note: Thread status tracking is handled in-process within api.py to keep
+    # persistence minimal for the examples package.
+
 
 @task(task_run_name="build user context for {user_id}")
 def build_user_context(

{marvin-3.2.0 → marvin-3.2.2}/examples/slackbot/src/slackbot/slack.py

@@ -29,7 +29,10 @@ class EventBlock(BaseModel):
 class SlackEvent(BaseModel):
     client_msg_id: str | None = None
     type: str
+    subtype: str | None = None
     text: str | None = None
+    # For message_changed edit events, Slack nests the edited message here
+    message: dict[str, Any] | None = None
     user: str | dict[str, Any] | None = None
     ts: str | None = None
     team: str | None = None

{marvin-3.2.0 → marvin-3.2.2}/src/marvin/agents/actor.py

@@ -76,7 +76,17 @@ class Actor(ABC):
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any):
         """Reset the current actor in context."""
         if self._tokens:  # Only reset if we have tokens
-            _current_actor.reset(self._tokens.pop())
+            try:
+                _current_actor.reset(self._tokens.pop())
+            except ValueError as e:
+                # Token was created in a different async context (e.g., asyncio.gather)
+                # This happens when tasks run concurrently and is expected behavior
+                if "was created in a different Context" in str(e):
+                    # This is the expected concurrent execution case - ignore safely
+                    pass
+                else:
+                    # Some other ValueError - re-raise it
+                    raise
 
     @classmethod
     def get_current(cls) -> "Actor | None":

{marvin-3.2.0 → marvin-3.2.2}/src/marvin/engine/orchestrator.py

@@ -143,7 +143,22 @@ class Orchestrator:
         if actor is None:
             actor = tasks[0].get_actor()
 
-        assigned_tasks = [t for t in tasks if actor is t.get_actor()]
+        # Get tasks assigned to this actor
+        potential_tasks = [t for t in tasks if actor is t.get_actor()]
+
+        # For independent tasks, only assign one per turn to avoid EndTurn conflicts
+        if len(potential_tasks) > 1:
+            # Check if any tasks depend on each other
+            has_deps = any(
+                t2 in t1.depends_on or t1 in t2.depends_on
+                for t1 in potential_tasks
+                for t2 in potential_tasks
+                if t1 != t2
+            )
+            # If independent, process one at a time
+            assigned_tasks = [potential_tasks[0]] if not has_deps else potential_tasks
+        else:
+            assigned_tasks = potential_tasks
 
         # Mark tasks as running if they're pending
         for task in assigned_tasks:

{marvin-3.2.0 → marvin-3.2.2}/src/marvin/fns/run.py

@@ -15,19 +15,43 @@ from marvin.handlers.handlers import AsyncHandler, Handler
 T = TypeVar("T")
 
 
+def _tasks_are_independent(tasks: list[Task[Any]]) -> bool:
+    """Check if tasks have no dependencies between each other."""
+    for i, task1 in enumerate(tasks):
+        for j, task2 in enumerate(tasks):
+            if i != j:
+                # Check if task1 depends on task2 or vice versa
+                if task2 in task1.depends_on or task1 in task2.depends_on:
+                    return False
+                # Check if they share subtasks or parent relationships
+                if task1.parent == task2 or task2.parent == task1:
+                    return False
+                if task1 in task2.subtasks or task2 in task1.subtasks:
+                    return False
+    return True
+
+
 async def run_tasks_async(
     tasks: list[Task[Any]],
     thread: Thread | str | None = None,
     raise_on_failure: bool = True,
     handlers: list[Handler | AsyncHandler] | None = None,
 ) -> list[Task[Any]] | AsyncGenerator[Event, None]:
-    orchestrator = Orchestrator(
-        tasks=tasks,
-        thread=thread,
-        handlers=handlers,
-    )
-    await orchestrator.run(raise_on_failure=raise_on_failure)
-    return tasks
+    """Run tasks either concurrently (if independent) or sequentially via orchestrator."""
+    # If we have multiple independent tasks, run them concurrently
+    if len(tasks) > 1 and _tasks_are_independent(tasks):
+        # Run independent tasks concurrently using asyncio.gather
+        await asyncio.gather(*[task.run_async() for task in tasks])
+        return tasks
+    else:
+        # Use orchestrator for dependent tasks or single tasks
+        orchestrator = Orchestrator(
+            tasks=tasks,
+            thread=thread,
+            handlers=handlers,
+        )
+        await orchestrator.run(raise_on_failure=raise_on_failure)
+        return tasks
 
 
 async def run_tasks_stream(
@@ -79,6 +103,7 @@ def run_tasks(
     raise_on_failure: bool = True,
     handlers: list[Handler | AsyncHandler] | None = None,
 ) -> list[Task[Any]]:
+    """Run tasks either concurrently (if independent) or sequentially."""
     return marvin.utilities.asyncio.run_sync(
         run_tasks_async(
             tasks=tasks,

{marvin-3.2.0 → marvin-3.2.2}/src/marvin/tasks/task.py

@@ -20,6 +20,7 @@ from typing import (
     Sequence,
     TypeAlias,
     TypeVar,
+    get_args,
 )
 
 from pydantic import TypeAdapter
@@ -452,7 +453,10 @@ class Task(Generic[T]):
             else:
                 raise ValueError("Result type is None but result is not None")
         elif raw_result is None:
-            raise ValueError("Result is None but result type is not None")
+            # Check if None is allowed in the type (e.g., Optional[str] = str | None)
+            type_args = get_args(result_type)
+            if type(None) not in type_args:
+                raise ValueError("Result is None but result type is not None")
 
         type_adapter = get_type_adapter(result_type)
         return type_adapter.validate_python(raw_result)

marvin-3.2.2/tests/ai/tasks/test_tasks.py

@@ -0,0 +1,34 @@
+from marvin import Task
+
+
+class TestTaskPrompt:
+    async def test_task_return_string_prompt(self):
+        # default tasks return a list; ensure strings work as well
+        class MyTask(Task):
+            def get_prompt(self) -> str:
+                return 'Say the word "hello"'
+
+        task = MyTask("")
+        prompt = task.get_prompt()
+        assert prompt == 'Say the word "hello"'
+        assert task.run() == "hello"
+
+
+class TestOptionalResults:
+    async def test_optional_result_returns_none(self):
+        """Test that tasks with optional result types can actually return None from AI."""
+        task = Task(
+            instructions="return null",
+            result_type=str | None,
+        )
+        result = await task.run_async()
+        assert result is None
+
+    async def test_optional_result_returns_value(self):
+        """Test that optional tasks can also return actual values."""
+        task = Task(
+            instructions='say "hello"',
+            result_type=str | None,
+        )
+        result = await task.run_async()
+        assert result == "hello"

{marvin-3.2.0 → marvin-3.2.2}/tests/basic/tasks/test_tasks.py

@@ -258,6 +258,13 @@ async def test_task_mark_successful():
     assert task.result == "test result"
 
 
+async def test_task_optional_result_type():
+    """Test that tasks with Optional result types can validate None."""
+    task = Task(instructions="test", result_type=str | None)
+    validated = task.validate_result(None)
+    assert validated is None
+
+
 async def test_task_mark_failed():
     """Test marking task as failed."""
     task = Task(instructions="Test failure")

marvin-3.2.2/tests/test_concurrent_execution.py

@@ -0,0 +1,191 @@
+"""Unit tests for concurrent task execution."""
+
+import asyncio
+
+import pytest
+
+from marvin import Task
+from marvin.agents.agent import Agent
+from marvin.fns.run import _tasks_are_independent, run_tasks, run_tasks_async
+
+
+class TestTaskIndependenceDetection:
+    """Test the independence detection logic."""
+
+    def test_independent_tasks(self):
+        """Test that truly independent tasks are detected as such."""
+        task1 = Task("Say 'one'", result_type=str)
+        task2 = Task("Say 'two'", result_type=str)
+        task3 = Task("Say 'three'", result_type=str)
+
+        assert _tasks_are_independent([task1, task2, task3])
+
+    def test_dependent_tasks_depends_on(self):
+        """Test that tasks with depends_on are not independent."""
+        task1 = Task("Say 'one'", result_type=str)
+        task2 = Task("Say 'two'", result_type=str, depends_on=[task1])
+
+        assert not _tasks_are_independent([task1, task2])
+
+    def test_dependent_tasks_parent_child(self):
+        """Test that parent-child tasks are not independent."""
+        parent = Task("Parent task", result_type=str)
+        child = Task("Child task", result_type=str)
+        parent.subtasks.add(child)  # subtasks is a set, not list
+        child.parent = parent
+
+        assert not _tasks_are_independent([parent, child])
+
+    def test_single_task_is_independent(self):
+        """Test that a single task is considered independent."""
+        task = Task("Solo task", result_type=str)
+        assert _tasks_are_independent([task])
+
+    def test_empty_task_list(self):
+        """Test empty task list."""
+        assert _tasks_are_independent([])
+
+
+class TestConcurrentExecution:
+    """Test actual concurrent execution behavior."""
+
+    @pytest.mark.asyncio
+    async def test_independent_tasks_run_without_errors(self):
+        """Test that independent tasks run without Multiple EndTurn warnings or errors."""
+        task1 = Task("Say 'one'", result_type=str)
+        task2 = Task("Say 'two'", result_type=str)
+        task3 = Task("Say 'three'", result_type=str)
+
+        # Should not raise any errors (no Multiple EndTurn warnings, no infinite loops)
+        results = await run_tasks_async([task1, task2, task3])
+
+        assert len(results) == 3
+        assert all(task.is_successful() for task in results)
+
+        # Verify results
+        result_values = [task.result for task in results]
+        assert set(result_values) == {"one", "two", "three"}
+
+    @pytest.mark.asyncio
+    async def test_dependent_tasks_run_in_order(self):
+        """Test that dependent tasks run in correct order."""
+        task1 = Task("Say 'A'", result_type=str)
+        task2 = Task("Say 'B'", result_type=str, depends_on=[task1])
+        task3 = Task("Say 'C'", result_type=str, depends_on=[task2])
+
+        results = await run_tasks_async([task1, task2, task3])
+
+        assert len(results) == 3
+        assert all(task.is_successful() for task in results)
+
+        # Verify correct order
+        result_values = [task.result for task in results]
+        assert result_values == ["A", "B", "C"]
+
+    def test_sync_run_tasks_independent(self):
+        """Test synchronous run_tasks with independent tasks."""
+        task1 = Task("Say 'one'", result_type=str)
+        task2 = Task("Say 'two'", result_type=str)
+
+        results = run_tasks([task1, task2])
+
+        assert len(results) == 2
+        assert all(task.is_successful() for task in results)
+        assert set(t.result for t in results) == {"one", "two"}
+
+    def test_sync_run_tasks_dependent(self):
+        """Test synchronous run_tasks with dependent tasks."""
+        task1 = Task("Say 'A'", result_type=str)
+        task2 = Task("Say 'B'", result_type=str, depends_on=[task1])
+
+        results = run_tasks([task1, task2])
+
+        assert len(results) == 2
+        assert all(task.is_successful() for task in results)
+
+        # Verify correct order
+        result_values = [task.result for task in results]
+        assert result_values == ["A", "B"]
+
+
+class TestAsyncioGatherCompatibility:
+    """Test that asyncio.gather works without ContextVar errors."""
+
+    @pytest.mark.asyncio
+    async def test_asyncio_gather_no_context_errors(self):
+        """Test that asyncio.gather doesn't throw ContextVar errors."""
+        task1 = Task("Say 'async1'", result_type=str)
+        task2 = Task("Say 'async2'", result_type=str)
+        task3 = Task("Say 'async3'", result_type=str)
+
+        # This should not raise ContextVar token errors
+        results = await asyncio.gather(
+            task1.run_async(), task2.run_async(), task3.run_async()
+        )
+
+        assert len(results) == 3
+        assert set(results) == {"async1", "async2", "async3"}
+
+    @pytest.mark.asyncio
+    async def test_mixed_execution_patterns(self):
+        """Test mixing run_tasks_async and asyncio.gather in same event loop."""
+        # First batch via run_tasks_async
+        task1 = Task("Say 'batch1'", result_type=str)
+        task2 = Task("Say 'batch2'", result_type=str)
+        batch1_results = await run_tasks_async([task1, task2])
+
+        # Second batch via asyncio.gather
+        task3 = Task("Say 'gather1'", result_type=str)
+        task4 = Task("Say 'gather2'", result_type=str)
+        batch2_results = await asyncio.gather(task3.run_async(), task4.run_async())
+
+        # Both should work without errors
+        assert len(batch1_results) == 2
+        assert all(task.is_successful() for task in batch1_results)
+        assert len(batch2_results) == 2
+        assert set(batch2_results) == {"gather1", "gather2"}
+
+
+class TestContextVarHandling:
+    """Test ContextVar token handling across async contexts."""
+
+    @pytest.mark.asyncio
+    async def test_actor_context_across_asyncio_gather(self):
+        """Test that Actor context management handles asyncio.gather correctly."""
+        from marvin.agents.actor import _current_actor
+
+        async def task_with_actor(name):
+            actor = Agent(name=f"Agent_{name}")
+            # This should not raise an error even with asyncio.gather
+            with actor:
+                assert _current_actor.get() == actor
+                await asyncio.sleep(0.1)  # Simulate async work
+            # Context should be reset without errors
+            return name
+
+        # Test that concurrent context management works
+        results = await asyncio.gather(
+            task_with_actor("1"), task_with_actor("2"), task_with_actor("3")
+        )
+
+        assert results == ["1", "2", "3"]
+        # Context should be None after all tasks complete
+        assert _current_actor.get() is None
+
+    def test_actor_context_sequential(self):
+        """Test that Actor context works normally in sequential execution."""
+        from marvin.agents.actor import _current_actor
+
+        actor1 = Agent(name="Sequential_1")
+        actor2 = Agent(name="Sequential_2")
+
+        # Test nested contexts work correctly
+        assert _current_actor.get() is None
+
+        with actor1:
+            assert _current_actor.get() == actor1
+            with actor2:
+                assert _current_actor.get() == actor2
+            assert _current_actor.get() == actor1
+
+        assert _current_actor.get() is None

marvin-3.2.0/tests/ai/tasks/test_tasks.py

@@ -1,14 +0,0 @@
-from marvin import Task
-
-
-class TestTaskPrompt:
-    async def test_task_return_string_prompt(self):
-        # default tasks return a list; ensure strings work as well
-        class MyTask(Task):
-            def get_prompt(self) -> str:
-                return 'Say the word "hello"'
-
-        task = MyTask("")
-        prompt = task.get_prompt()
-        assert prompt == 'Say the word "hello"'
-        assert task.run() == "hello"