anycode-py 0.1.0__py3-none-any.whl

anycode/__init__.py

@@ -0,0 +1,121 @@
+"""AnyCode — scalable multi-agent AI orchestration framework for Python."""
+
+from anycode.collaboration.kv_store import InMemoryStore
+from anycode.collaboration.message_bus import MessageBus
+from anycode.collaboration.shared_mem import SharedMemory
+from anycode.collaboration.team import Team
+from anycode.core.agent import Agent
+from anycode.core.orchestrator import AnyCode, TaskSpec
+from anycode.core.pool import AgentPool
+from anycode.core.runner import AgentRunner
+from anycode.core.scheduler import Scheduler
+from anycode.helpers.concurrency_gate import Semaphore
+from anycode.helpers.usage_tracker import EMPTY_USAGE, merge_usage
+from anycode.providers.adapter import create_adapter
+from anycode.tasks.queue import TaskQueue
+from anycode.tasks.task import create_task, get_task_dependency_order, is_task_ready, validate_task_dependencies
+from anycode.tools.built_in import BUILT_IN_TOOLS, register_built_in_tools
+from anycode.tools.executor import ToolExecutor
+from anycode.tools.registry import ToolRegistry, define_tool
+from anycode.types import (
+    AgentConfig,
+    AgentInfo,
+    AgentRunResult,
+    AgentState,
+    ContentBlock,
+    ImageBlock,
+    LLMAdapter,
+    LLMChatOptions,
+    LLMMessage,
+    LLMResponse,
+    LLMStreamOptions,
+    LLMToolDef,
+    MemoryEntry,
+    MemoryStore,
+    OrchestratorConfig,
+    OrchestratorEvent,
+    PoolStatus,
+    RunnerOptions,
+    RunResult,
+    SchedulingStrategy,
+    StreamEvent,
+    Task,
+    TaskStatus,
+    TeamConfig,
+    TeamRunResult,
+    TextBlock,
+    TokenUsage,
+    ToolCallRecord,
+    ToolDefinition,
+    ToolResult,
+    ToolResultBlock,
+    ToolUseBlock,
+    ToolUseContext,
+)
+
+__all__ = [
+    # Core
+    "AnyCode",
+    "Agent",
+    "AgentRunner",
+    "AgentPool",
+    "Scheduler",
+    "TaskSpec",
+    # Providers
+    "create_adapter",
+    # Collaboration
+    "Team",
+    "MessageBus",
+    "SharedMemory",
+    "InMemoryStore",
+    # Tasks
+    "TaskQueue",
+    "create_task",
+    "is_task_ready",
+    "get_task_dependency_order",
+    "validate_task_dependencies",
+    # Tools
+    "ToolRegistry",
+    "ToolExecutor",
+    "define_tool",
+    "BUILT_IN_TOOLS",
+    "register_built_in_tools",
+    # Helpers
+    "Semaphore",
+    "EMPTY_USAGE",
+    "merge_usage",
+    # Types
+    "ContentBlock",
+    "TextBlock",
+    "ToolUseBlock",
+    "ToolResultBlock",
+    "ImageBlock",
+    "LLMMessage",
+    "TokenUsage",
+    "LLMResponse",
+    "StreamEvent",
+    "LLMToolDef",
+    "ToolUseContext",
+    "AgentInfo",
+    "ToolResult",
+    "ToolDefinition",
+    "AgentConfig",
+    "AgentState",
+    "ToolCallRecord",
+    "AgentRunResult",
+    "TeamConfig",
+    "TeamRunResult",
+    "TaskStatus",
+    "Task",
+    "OrchestratorEvent",
+    "OrchestratorConfig",
+    "MemoryEntry",
+    "MemoryStore",
+    "LLMChatOptions",
+    "LLMStreamOptions",
+    "LLMAdapter",
+    "RunnerOptions",
+    "RunResult",
+    "PoolStatus",
+    "SchedulingStrategy",
+]

anycode/collaboration/__init__.py

@@ -0,0 +1,6 @@
+from anycode.collaboration.kv_store import InMemoryStore
+from anycode.collaboration.message_bus import MessageBus
+from anycode.collaboration.shared_mem import SharedMemory
+from anycode.collaboration.team import Team
+
+__all__ = ["InMemoryStore", "MessageBus", "SharedMemory", "Team"]

anycode/collaboration/kv_store.py

@@ -0,0 +1,49 @@
+"""Async key-value store backed by a dict."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from anycode.types import MemoryEntry
+
+
+class InMemoryStore:
+    """Async in-memory key-value store implementing the MemoryStore protocol."""
+
+    def __init__(self) -> None:
+        self._data: dict[str, MemoryEntry] = {}
+
+    async def get(self, key: str) -> MemoryEntry | None:
+        return self._data.get(key)
+
+    async def set(self, key: str, value: str, metadata: dict[str, Any] | None = None) -> None:
+        existing = self._data.get(key)
+        self._data[key] = MemoryEntry(
+            key=key,
+            value=value,
+            metadata=dict(metadata) if metadata else None,
+            created_at=existing.created_at if existing else datetime.now(UTC),
+        )
+
+    async def list(self) -> list[MemoryEntry]:
+        return list(self._data.values())
+
+    async def delete(self, key: str) -> None:
+        self._data.pop(key, None)
+
+    async def clear(self) -> None:
+        self._data.clear()
+
+    async def search(self, query: str) -> list[MemoryEntry]:
+        if not query:
+            return await self.list()
+        lower = query.lower()
+        return [e for e in self._data.values() if lower in e.key.lower() or lower in e.value.lower()]
+
+    @property
+    def size(self) -> int:
+        return len(self._data)
+
+    def has(self, key: str) -> bool:
+        return key in self._data

anycode/collaboration/message_bus.py

@@ -0,0 +1,70 @@
+"""Agent-to-agent message bus with pub/sub and read-state tracking."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from datetime import UTC, datetime
+from uuid import uuid4
+
+from anycode.types import Message
+
+
+class MessageBus:
+    """Pub/sub messaging between agents."""
+
+    def __init__(self) -> None:
+        self._messages: list[Message] = []
+        self._read_state: dict[str, set[str]] = {}
+        self._subscribers: dict[str, dict[int, Callable[[Message], None]]] = {}
+        self._next_id = 0
+
+    def send(self, from_agent: str, to_agent: str, content: str) -> Message:
+        msg = Message(id=str(uuid4()), from_agent=from_agent, to_agent=to_agent, content=content, timestamp=datetime.now(UTC))
+        self._dispatch(msg)
+        return msg
+
+    def broadcast(self, from_agent: str, content: str) -> Message:
+        return self.send(from_agent, "*", content)
+
+    def get_unread(self, agent_name: str) -> list[Message]:
+        read = self._read_state.get(agent_name, set())
+        return [m for m in self._messages if _is_recipient(m, agent_name) and m.id not in read]
+
+    def get_all(self, agent_name: str) -> list[Message]:
+        return [m for m in self._messages if _is_recipient(m, agent_name)]
+
+    def mark_read(self, agent_name: str, message_ids: list[str]) -> None:
+        if not message_ids:
+            return
+        read = self._read_state.setdefault(agent_name, set())
+        read.update(message_ids)
+
+    def get_conversation(self, agent1: str, agent2: str) -> list[Message]:
+        return [
+            m for m in self._messages
+            if (m.from_agent == agent1 and m.to_agent == agent2) or (m.from_agent == agent2 and m.to_agent == agent1)
+        ]
+
+    def subscribe(self, agent_name: str, callback: Callable[[Message], None]) -> Callable[[], None]:
+        subs = self._subscribers.setdefault(agent_name, {})
+        sub_id = self._next_id
+        self._next_id += 1
+        subs[sub_id] = callback
+        return lambda: subs.pop(sub_id, None)
+
+    def _dispatch(self, message: Message) -> None:
+        self._messages.append(message)
+        if message.to_agent == "*":
+            for agent_name, subs in self._subscribers.items():
+                if agent_name != message.from_agent:
+                    for cb in subs.values():
+                        cb(message)
+        else:
+            for cb in self._subscribers.get(message.to_agent, {}).values():
+                cb(message)
+
+
+def _is_recipient(message: Message, agent_name: str) -> bool:
+    if message.to_agent == "*":
+        return message.from_agent != agent_name
+    return message.to_agent == agent_name

anycode/collaboration/shared_mem.py

@@ -0,0 +1,55 @@
+"""Namespaced shared memory for coordinated agent teams."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from anycode.collaboration.kv_store import InMemoryStore
+from anycode.types import MemoryEntry, MemoryStore
+
+
+class SharedMemory:
+    """Keys are scoped as <agent_name>/<key> to avoid collisions."""
+
+    def __init__(self) -> None:
+        self._store = InMemoryStore()
+
+    async def write(self, agent_name: str, key: str, value: str, metadata: dict[str, Any] | None = None) -> None:
+        namespaced = f"{agent_name}/{key}"
+        await self._store.set(namespaced, value, {**(metadata or {}), "agent": agent_name})
+
+    async def read(self, key: str) -> MemoryEntry | None:
+        return await self._store.get(key)
+
+    async def list_all(self) -> list[MemoryEntry]:
+        return await self._store.list()
+
+    async def list_by_agent(self, agent_name: str) -> list[MemoryEntry]:
+        prefix = f"{agent_name}/"
+        return [e for e in await self._store.list() if e.key.startswith(prefix)]
+
+    async def get_summary(self) -> str:
+        """Build a markdown summary grouped by agent."""
+        all_entries = await self._store.list()
+        if not all_entries:
+            return ""
+
+        by_agent: dict[str, list[tuple[str, str]]] = {}
+        for entry in all_entries:
+            slash_idx = entry.key.find("/")
+            agent = entry.key[:slash_idx] if slash_idx != -1 else "_unknown"
+            local_key = entry.key[slash_idx + 1:] if slash_idx != -1 else entry.key
+            by_agent.setdefault(agent, []).append((local_key, entry.value))
+
+        lines = ["## Collective Agent Knowledge", ""]
+        for agent, entries in by_agent.items():
+            lines.append(f"### {agent}")
+            for local_key, value in entries:
+                display = f"{value[:177]}\u2026" if len(value) > 180 else value
+                lines.append(f"- {local_key}: {display}")
+            lines.append("")
+
+        return "\n".join(lines).rstrip()
+
+    def get_store(self) -> MemoryStore:
+        return self._store  # type: ignore[return-value]

anycode/collaboration/team.py

@@ -0,0 +1,96 @@
+"""Manages a named group of agents with messaging, task queue, and shared memory."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from anycode.collaboration.message_bus import MessageBus
+from anycode.collaboration.shared_mem import SharedMemory
+from anycode.tasks.queue import TaskQueue
+from anycode.tasks.task import create_task
+from anycode.types import AgentConfig, MemoryStore, Message, OrchestratorEvent, Task, TaskStatus, TeamConfig
+
+
+class _EventBus:
+    def __init__(self) -> None:
+        self._listeners: dict[str, dict[int, Callable[[Any], None]]] = {}
+        self._next_id = 0
+
+    def on(self, event: str, handler: Callable[[Any], None]) -> Callable[[], None]:
+        subs = self._listeners.setdefault(event, {})
+        sub_id = self._next_id
+        self._next_id += 1
+        subs[sub_id] = handler
+        return lambda: subs.pop(sub_id, None)
+
+    def emit(self, event: str, data: Any) -> None:
+        for handler in self._listeners.get(event, {}).values():
+            handler(data)
+
+
+class Team:
+    """Agent team with messaging, task queue, and shared memory."""
+
+    def __init__(self, config: TeamConfig) -> None:
+        self.name = config.name
+        self.config = config
+        self._agent_map: dict[str, AgentConfig] = {a.name: a for a in config.agents}
+        self._bus = MessageBus()
+        self._queue = TaskQueue()
+        self._memory = SharedMemory() if config.shared_memory else None
+        self._events = _EventBus()
+
+        # Relay queue events
+        self._queue.on("task:ready", lambda t: self._events.emit("task:ready", OrchestratorEvent(type="task_start", task=t.id, data=t)))
+        self._queue.on("task:complete", lambda t: self._events.emit("task:complete", OrchestratorEvent(type="task_complete", task=t.id, data=t)))
+        self._queue.on("task:failed", lambda t: self._events.emit("task:failed", OrchestratorEvent(type="error", task=t.id, data=t)))
+        self._queue.on("all:complete", lambda: self._events.emit("all:complete", None))
+
+    def get_agents(self) -> list[AgentConfig]:
+        return list(self._agent_map.values())
+
+    def get_agent(self, name: str) -> AgentConfig | None:
+        return self._agent_map.get(name)
+
+    def send_message(self, from_agent: str, to_agent: str, content: str) -> None:
+        msg = self._bus.send(from_agent, to_agent, content)
+        self._events.emit("message", OrchestratorEvent(type="message", agent=from_agent, data=msg))
+
+    def get_messages(self, agent_name: str) -> list[Message]:
+        return self._bus.get_all(agent_name)
+
+    def broadcast(self, from_agent: str, content: str) -> None:
+        msg = self._bus.broadcast(from_agent, content)
+        self._events.emit("broadcast", OrchestratorEvent(type="message", agent=from_agent, data=msg))
+
+    def add_task(self, *, title: str, description: str, status: TaskStatus = "pending",
+                 assignee: str | None = None, depends_on: list[str] | None = None, result: str | None = None) -> Task:
+        created = create_task(title=title, description=description, assignee=assignee, depends_on=depends_on)
+        final = created.model_copy(update={"status": status, "result": result}) if status != "pending" else created
+        self._queue.add(final)
+        return final
+
+    def get_tasks(self) -> list[Task]:
+        return self._queue.list()
+
+    def get_tasks_by_assignee(self, agent_name: str) -> list[Task]:
+        return [t for t in self._queue.list() if t.assignee == agent_name]
+
+    def update_task(self, task_id: str, **kwargs: Any) -> Task:
+        return self._queue.update(task_id, **kwargs)
+
+    def get_next_task(self, agent_name: str) -> Task | None:
+        return self._queue.next(agent_name) or self._queue.next_available()
+
+    def get_shared_memory(self) -> MemoryStore | None:
+        return self._memory.get_store() if self._memory else None
+
+    def get_shared_memory_instance(self) -> SharedMemory | None:
+        return self._memory
+
+    def on(self, event: str, handler: Callable[[Any], None]) -> Callable[[], None]:
+        return self._events.on(event, handler)
+
+    def emit(self, event: str, data: Any) -> None:
+        self._events.emit(event, data)

anycode/core/__init__.py

@@ -0,0 +1,7 @@
+from anycode.core.agent import Agent
+from anycode.core.orchestrator import AnyCode, TaskSpec
+from anycode.core.pool import AgentPool
+from anycode.core.runner import AgentRunner
+from anycode.core.scheduler import Scheduler
+
+__all__ = ["Agent", "AgentRunner", "AgentPool", "AnyCode", "TaskSpec", "Scheduler"]

anycode/core/agent.py

@@ -0,0 +1,141 @@
+"""Wraps AgentRunner with persistent conversation history, lifecycle state, and streaming."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+
+from anycode.core.runner import AgentRunner
+from anycode.helpers.usage_tracker import EMPTY_USAGE, merge_usage
+from anycode.providers.adapter import create_adapter
+from anycode.tools.executor import ToolExecutor
+from anycode.tools.registry import ToolRegistry
+from anycode.types import (
+    AgentConfig,
+    AgentInfo,
+    AgentRunResult,
+    AgentState,
+    LLMMessage,
+    RunnerOptions,
+    RunResult,
+    StreamEvent,
+    TextBlock,
+    ToolDefinition,
+    ToolUseContext,
+)
+
+
+class Agent:
+    """High-level agent with state management, conversation history, and streaming support."""
+
+    def __init__(self, config: AgentConfig | dict[str, object], tool_registry: ToolRegistry, tool_executor: ToolExecutor) -> None:
+        typed_config = AgentConfig.model_validate(config) if isinstance(config, dict) else config
+        self.name = typed_config.name
+        self.config = typed_config
+        self._registry = tool_registry
+        self._executor = tool_executor
+        self._runner: AgentRunner | None = None
+        self._state = AgentState()
+        self._history: list[LLMMessage] = []
+
+    async def _get_runner(self) -> AgentRunner:
+        if self._runner is not None:
+            return self._runner
+
+        provider = self.config.provider or "anthropic"
+        adapter = await create_adapter(provider)
+
+        opts = RunnerOptions(
+            model=self.config.model,
+            system_prompt=self.config.system_prompt,
+            max_turns=self.config.max_turns,
+            max_tokens=self.config.max_tokens,
+            temperature=self.config.temperature,
+            allowed_tools=self.config.tools,
+            agent_name=self.name,
+            agent_role=(self.config.system_prompt or "assistant")[:50],
+        )
+        self._runner = AgentRunner(adapter, self._registry, self._executor, opts)
+        return self._runner
+
+    async def run(self, prompt: str) -> AgentRunResult:
+        """Execute prompt as a standalone conversation (history is ignored)."""
+        messages = [LLMMessage(role="user", content=[TextBlock(text=prompt)])]
+        return await self._execute_run(messages)
+
+    async def prompt(self, message: str) -> AgentRunResult:
+        """Continue the ongoing conversation with a new user message."""
+        user_msg = LLMMessage(role="user", content=[TextBlock(text=message)])
+        self._history.append(user_msg)
+        result = await self._execute_run(list(self._history))
+        self._history.extend(result.messages)
+        return result
+
+    async def stream(self, prompt: str) -> AsyncGenerator[StreamEvent, None]:
+        """Stream a standalone conversation response as incremental events."""
+        messages = [LLMMessage(role="user", content=[TextBlock(text=prompt)])]
+        async for event in self._execute_stream(messages):
+            yield event
+
+    def get_state(self) -> AgentState:
+        return self._state.model_copy(deep=True)
+
+    def get_history(self) -> list[LLMMessage]:
+        return list(self._history)
+
+    def reset(self) -> None:
+        self._history.clear()
+        self._state = AgentState()
+
+    def add_tool(self, tool: ToolDefinition) -> None:
+        self._registry.register(tool)
+
+    def remove_tool(self, name: str) -> None:
+        self._registry.deregister(name)
+
+    def get_tools(self) -> list[str]:
+        return [t.name for t in self._registry.list()]
+
+    async def _execute_run(self, messages: list[LLMMessage]) -> AgentRunResult:
+        self._state.status = "running"
+        try:
+            runner = await self._get_runner()
+            result = await runner.run(messages, on_message=lambda msg: self._state.messages.append(msg))
+            self._state.token_usage = merge_usage(self._state.token_usage, result.token_usage)
+            self._state.status = "completed"
+            return AgentRunResult(
+                success=True,
+                output=result.output,
+                messages=result.messages,
+                token_usage=result.token_usage,
+                tool_calls=result.tool_calls,
+            )
+        except Exception as e:
+            self._state.status = "error"
+            self._state.error = str(e)
+            return AgentRunResult(success=False, output=str(e), messages=[], token_usage=EMPTY_USAGE, tool_calls=[])
+
+    async def _execute_stream(self, messages: list[LLMMessage]) -> AsyncGenerator[StreamEvent, None]:
+        self._state.status = "running"
+        try:
+            runner = await self._get_runner()
+            async for event in runner.stream(messages):
+                if event.type == "done" and isinstance(event.data, RunResult):
+                    self._state.token_usage = merge_usage(self._state.token_usage, event.data.token_usage)
+                    self._state.status = "completed"
+                elif event.type == "error":
+                    self._state.status = "error"
+                    self._state.error = str(event.data)
+                yield event
+        except Exception as e:
+            self._state.status = "error"
+            self._state.error = str(e)
+            yield StreamEvent(type="error", data=e)
+
+    def build_tool_context(self) -> ToolUseContext:
+        return ToolUseContext(
+            agent=AgentInfo(
+                name=self.name,
+                role=(self.config.system_prompt or "assistant")[:60],
+                model=self.config.model,
+            )
+        )