code-puppy 0.0.342__py3-none-any.whl → 0.0.344__py3-none-any.whl

code_puppy/config.py

@@ -47,7 +47,6 @@ MODELS_FILE = os.path.join(DATA_DIR, "models.json")
 EXTRA_MODELS_FILE = os.path.join(DATA_DIR, "extra_models.json")
 AGENTS_DIR = os.path.join(DATA_DIR, "agents")
 CONTEXTS_DIR = os.path.join(DATA_DIR, "contexts")
-_DEFAULT_SQLITE_FILE = os.path.join(DATA_DIR, "dbos_store.sqlite")
 
 # OAuth plugin model files (XDG_DATA_HOME)
 GEMINI_MODELS_FILE = os.path.join(DATA_DIR, "gemini_models.json")
@@ -60,21 +59,6 @@ AUTOSAVE_DIR = os.path.join(CACHE_DIR, "autosaves")
 
 # State files (XDG_STATE_HOME)
 COMMAND_HISTORY_FILE = os.path.join(STATE_DIR, "command_history.txt")
-DBOS_DATABASE_URL = os.environ.get(
-    "DBOS_SYSTEM_DATABASE_URL", f"sqlite:///{_DEFAULT_SQLITE_FILE}"
-)
-# DBOS enable switch is controlled solely via puppy.cfg using key 'enable_dbos'.
-# Default: False (DBOS disabled) unless explicitly enabled.
-
-
-def get_use_dbos() -> bool:
-    """Return True if DBOS should be used based on 'enable_dbos' (default False)."""
-    cfg_val = get_value("enable_dbos")
-    if cfg_val is None:
-        return False
-    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
-
-
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
 
@@ -209,8 +193,6 @@ def get_config_keys():
         "default_agent",
         "temperature",
     ]
-    # Add DBOS control key
-    default_keys.append("enable_dbos")
     # Add cancel agent key configuration
     default_keys.append("cancel_agent_key")
     # Add banner color keys
@@ -1047,11 +1029,6 @@ def set_http2(enabled: bool) -> None:
     set_config_value("http2", "true" if enabled else "false")
 
 
-def set_enable_dbos(enabled: bool) -> None:
-    """Enable DBOS via config (true enables, default false)."""
-    set_config_value("enable_dbos", "true" if enabled else "false")
-
-
 def get_message_limit(default: int = 1000) -> int:
     """
     Returns the user-configured message/request limit for the agent.

code_puppy/mcp_/async_lifecycle.py

@@ -108,10 +108,17 @@ class AsyncServerLifecycleManager:
 
         try:
             logger.info(f"Starting server lifecycle for {server_id}")
+            logger.info(
+                f"Server {server_id} _running_count before enter: {getattr(server, '_running_count', 'N/A')}"
+            )
 
             # Enter the server's context
             await exit_stack.enter_async_context(server)
 
+            logger.info(
+                f"Server {server_id} _running_count after enter: {getattr(server, '_running_count', 'N/A')}"
+            )
+
             # Store the managed context
             async with self._lock:
                 self._servers[server_id] = ManagedServerContext(
@@ -122,26 +129,50 @@ class AsyncServerLifecycleManager:
                     task=asyncio.current_task(),
                 )
 
-            logger.info(f"Server {server_id} started successfully")
+            logger.info(
+                f"Server {server_id} started successfully and stored in _servers"
+            )
 
             # Keep the task alive until cancelled
+            loop_count = 0
             while True:
                 await asyncio.sleep(1)
+                loop_count += 1
 
                 # Check if server is still running
-                if not server.is_running:
-                    logger.warning(f"Server {server_id} stopped unexpectedly")
+                running_count = getattr(server, "_running_count", "N/A")
+                is_running = server.is_running
+                logger.debug(
+                    f"Server {server_id} heartbeat #{loop_count}: "
+                    f"is_running={is_running}, _running_count={running_count}"
+                )
+
+                if not is_running:
+                    logger.warning(
+                        f"Server {server_id} stopped unexpectedly! "
+                        f"_running_count={running_count}"
+                    )
                     break
 
         except asyncio.CancelledError:
             logger.info(f"Server {server_id} lifecycle task cancelled")
             raise
         except Exception as e:
-            logger.error(f"Error in server {server_id} lifecycle: {e}")
+            logger.error(f"Error in server {server_id} lifecycle: {e}", exc_info=True)
         finally:
+            running_count = getattr(server, "_running_count", "N/A")
+            logger.info(
+                f"Server {server_id} lifecycle ending, _running_count={running_count}"
+            )
+
             # Clean up the context
             await exit_stack.aclose()
 
+            running_count_after = getattr(server, "_running_count", "N/A")
+            logger.info(
+                f"Server {server_id} context closed, _running_count={running_count_after}"
+            )
+
             # Remove from managed servers
             async with self._lock:
                 if server_id in self._servers:

code_puppy/mcp_/managed_server.py

@@ -28,6 +28,31 @@ from code_puppy.mcp_.blocking_startup import BlockingMCPServerStdio
 from code_puppy.messaging import emit_info
 
 
+def _expand_env_vars(value: Any) -> Any:
+    """
+    Recursively expand environment variables in config values.
+
+    Supports $VAR and ${VAR} syntax. Works with:
+    - Strings: expands env vars
+    - Dicts: recursively expands all string values
+    - Lists: recursively expands all string elements
+    - Other types: returned as-is
+
+    Args:
+        value: The value to expand env vars in
+
+    Returns:
+        The value with env vars expanded
+    """
+    if isinstance(value, str):
+        return os.path.expandvars(value)
+    elif isinstance(value, dict):
+        return {k: _expand_env_vars(v) for k, v in value.items()}
+    elif isinstance(value, list):
+        return [_expand_env_vars(item) for item in value]
+    return value
+
+
 class ServerState(Enum):
     """Enumeration of possible server states."""
 
@@ -153,9 +178,9 @@ class ManagedMCPServer:
                 if "url" not in config:
                     raise ValueError("SSE server requires 'url' in config")
 
-                # Prepare arguments for MCPServerSSE
+                # Prepare arguments for MCPServerSSE (expand env vars in URL)
                 sse_kwargs = {
-                    "url": config["url"],
+                    "url": _expand_env_vars(config["url"]),
                 }
 
                 # Add optional parameters if provided
@@ -177,21 +202,23 @@ class ManagedMCPServer:
                 if "command" not in config:
                     raise ValueError("Stdio server requires 'command' in config")
 
-                # Handle command and arguments
-                command = config["command"]
+                # Handle command and arguments (expand env vars)
+                command = _expand_env_vars(config["command"])
                 args = config.get("args", [])
                 if isinstance(args, str):
-                    # If args is a string, split it
-                    args = args.split()
+                    # If args is a string, split it then expand
+                    args = [_expand_env_vars(a) for a in args.split()]
+                else:
+                    args = _expand_env_vars(args)
 
                 # Prepare arguments for MCPServerStdio
                 stdio_kwargs = {"command": command, "args": list(args) if args else []}
 
-                # Add optional parameters if provided
+                # Add optional parameters if provided (expand env vars in env and cwd)
                 if "env" in config:
-                    stdio_kwargs["env"] = config["env"]
+                    stdio_kwargs["env"] = _expand_env_vars(config["env"])
                 if "cwd" in config:
-                    stdio_kwargs["cwd"] = config["cwd"]
+                    stdio_kwargs["cwd"] = _expand_env_vars(config["cwd"])
                 if "timeout" in config:
                     stdio_kwargs["timeout"] = config["timeout"]
                 if "read_timeout" in config:
@@ -212,9 +239,9 @@ class ManagedMCPServer:
                 if "url" not in config:
                     raise ValueError("HTTP server requires 'url' in config")
 
-                # Prepare arguments for MCPServerStreamableHTTP
+                # Prepare arguments for MCPServerStreamableHTTP (expand env vars in URL)
                 http_kwargs = {
-                    "url": config["url"],
+                    "url": _expand_env_vars(config["url"]),
                 }
 
                 # Add optional parameters if provided
@@ -223,13 +250,14 @@ class ManagedMCPServer:
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
 
-                # Handle http_client vs headers (mutually exclusive)
-                if "http_client" in config:
-                    # Use provided http_client
-                    http_kwargs["http_client"] = config["http_client"]
-                elif config.get("headers"):
-                    # Create HTTP client if headers are provided but no client specified
-                    http_kwargs["http_client"] = self._get_http_client()
+                # Pass headers directly instead of creating http_client
+                # Note: There's a bug in MCP 1.25.0 where passing http_client
+                # causes "'_AsyncGeneratorContextManager' object has no attribute 'stream'"
+                # The workaround is to pass headers directly and let pydantic-ai
+                # create the http_client internally.
+                if config.get("headers"):
+                    # Expand environment variables in headers
+                    http_kwargs["headers"] = _expand_env_vars(config["headers"])
 
                 self._pydantic_server = MCPServerStreamableHTTP(
                     **http_kwargs, process_tool_call=process_tool_call

code_puppy/mcp_/manager.py

@@ -469,41 +469,57 @@ class MCPManager:
     def start_server_sync(self, server_id: str) -> bool:
         """
         Synchronous wrapper for start_server.
+
+        IMPORTANT: This schedules the server start as a background task.
+        The server subprocess will start asynchronously - it may not be
+        immediately ready when this function returns.
         """
         try:
-            asyncio.get_running_loop()
-            # We're in an async context, but we need to wait for completion
-            # Create a future and schedule the coroutine
+            loop = asyncio.get_running_loop()
+            # We're in an async context - schedule the server start as a background task
+            # DO NOT use blocking time.sleep() here as it freezes the event loop!
+
+            # First, enable the server immediately so it's recognized as "starting"
+            managed_server = self._managed_servers.get(server_id)
+            if managed_server:
+                managed_server.enable()
+                self.status_tracker.set_status(server_id, ServerState.STARTING)
+                self.status_tracker.record_start_time(server_id)
 
-            # Use run_in_executor to run the async function synchronously
-            async def run_async():
-                return await self.start_server(server_id)
+            # Schedule the async start_server to run in the background
+            # This will properly start the subprocess and lifecycle task
+            async def start_server_background():
+                try:
+                    result = await self.start_server(server_id)
+                    if result:
+                        logger.info(f"Background server start completed: {server_id}")
+                    else:
+                        logger.warning(f"Background server start failed: {server_id}")
+                    return result
+                except Exception as e:
+                    logger.error(f"Background server start error for {server_id}: {e}")
+                    self.status_tracker.set_status(server_id, ServerState.ERROR)
+                    return False
 
-            # Schedule the task and wait briefly for it to complete
-            task = asyncio.create_task(run_async())
+            # Create the task - it will run when the event loop gets control
+            task = loop.create_task(
+                start_server_background(), name=f"start_server_{server_id}"
+            )
 
-            # Give it a moment to complete - this fixes the race condition
-            import time
+            # Store task reference to prevent garbage collection
+            if not hasattr(self, "_pending_start_tasks"):
+                self._pending_start_tasks = {}
+            self._pending_start_tasks[server_id] = task
 
-            time.sleep(0.1)  # Small delay to let async tasks progress
+            # Add callback to clean up task reference when done
+            def cleanup_task(t):
+                if hasattr(self, "_pending_start_tasks"):
+                    self._pending_start_tasks.pop(server_id, None)
 
-            # Check if task completed, if not, fall back to sync enable
-            if task.done():
-                try:
-                    result = task.result()
-                    return result
-                except Exception:
-                    pass
+            task.add_done_callback(cleanup_task)
 
-            # If async didn't complete, enable synchronously
-            managed_server = self._managed_servers.get(server_id)
-            if managed_server:
-                managed_server.enable()
-                self.status_tracker.set_status(server_id, ServerState.RUNNING)
-                self.status_tracker.record_start_time(server_id)
-                logger.info(f"Enabled server synchronously: {server_id}")
-                return True
-            return False
+            logger.info(f"Scheduled background start for server: {server_id}")
+            return True  # Return immediately - server will start in background
 
         except RuntimeError:
             # No async loop, just enable the server
@@ -582,39 +598,52 @@ class MCPManager:
     def stop_server_sync(self, server_id: str) -> bool:
         """
         Synchronous wrapper for stop_server.
+
+        IMPORTANT: This schedules the server stop as a background task.
+        The server subprocess will stop asynchronously.
         """
         try:
-            asyncio.get_running_loop()
+            loop = asyncio.get_running_loop()
+            # We're in an async context - schedule the server stop as a background task
+            # DO NOT use blocking time.sleep() here as it freezes the event loop!
 
-            # We're in an async context, but we need to wait for completion
-            async def run_async():
-                return await self.stop_server(server_id)
+            # First, disable the server immediately
+            managed_server = self._managed_servers.get(server_id)
+            if managed_server:
+                managed_server.disable()
+                self.status_tracker.set_status(server_id, ServerState.STOPPING)
+                self.status_tracker.record_stop_time(server_id)
 
-            # Schedule the task and wait briefly for it to complete
-            task = asyncio.create_task(run_async())
+            # Schedule the async stop_server to run in the background
+            async def stop_server_background():
+                try:
+                    result = await self.stop_server(server_id)
+                    if result:
+                        logger.info(f"Background server stop completed: {server_id}")
+                    return result
+                except Exception as e:
+                    logger.error(f"Background server stop error for {server_id}: {e}")
+                    return False
 
-            # Give it a moment to complete - this fixes the race condition
-            import time
+            # Create the task - it will run when the event loop gets control
+            task = loop.create_task(
+                stop_server_background(), name=f"stop_server_{server_id}"
+            )
 
-            time.sleep(0.1)  # Small delay to let async tasks progress
+            # Store task reference to prevent garbage collection
+            if not hasattr(self, "_pending_stop_tasks"):
+                self._pending_stop_tasks = {}
+            self._pending_stop_tasks[server_id] = task
 
-            # Check if task completed, if not, fall back to sync disable
-            if task.done():
-                try:
-                    result = task.result()
-                    return result
-                except Exception:
-                    pass
+            # Add callback to clean up task reference when done
+            def cleanup_task(t):
+                if hasattr(self, "_pending_stop_tasks"):
+                    self._pending_stop_tasks.pop(server_id, None)
 
-            # If async didn't complete, disable synchronously
-            managed_server = self._managed_servers.get(server_id)
-            if managed_server:
-                managed_server.disable()
-                self.status_tracker.set_status(server_id, ServerState.STOPPED)
-                self.status_tracker.record_stop_time(server_id)
-                logger.info(f"Disabled server synchronously: {server_id}")
-                return True
-            return False
+            task.add_done_callback(cleanup_task)
+
+            logger.info(f"Scheduled background stop for server: {server_id}")
+            return True  # Return immediately - server will stop in background
 
         except RuntimeError:
             # No async loop, just disable the server

code_puppy/summarization_agent.py

@@ -4,10 +4,7 @@ from typing import List
 
 from pydantic_ai import Agent
 
-from code_puppy.config import (
-    get_global_model_name,
-    get_use_dbos,
-)
+from code_puppy.config import get_global_model_name
 from code_puppy.model_factory import ModelFactory, make_model_settings
 
 # Keep a module-level agent reference to avoid rebuilding per call
@@ -106,13 +103,6 @@ def reload_summarization_agent():
         retries=1,  # Fewer retries for summarization
         model_settings=model_settings,
     )
-    if get_use_dbos():
-        from pydantic_ai.durable_exec.dbos import DBOSAgent
-
-        global _reload_count
-        _reload_count += 1
-        dbos_agent = DBOSAgent(agent, name=f"summarization-agent-{_reload_count}")
-        return dbos_agent
     return agent
 
 

code_puppy/tools/agent_tools.py

@@ -1,7 +1,6 @@
 # agent_tools.py
 import asyncio
 import hashlib
-import itertools
 import json
 import pickle
 import re
@@ -10,7 +9,6 @@ from datetime import datetime
 from pathlib import Path
 from typing import List, Set
 
-from dbos import DBOS, SetWorkflowID
 from pydantic import BaseModel
 
 # Import Agent from pydantic_ai to create temporary agents for invocation
@@ -20,7 +18,6 @@ from pydantic_ai.messages import ModelMessage
 from code_puppy.config import (
     DATA_DIR,
     get_message_limit,
-    get_use_dbos,
 )
 from code_puppy.messaging import (
     SubAgentInvocationMessage,
@@ -37,27 +34,6 @@ from code_puppy.tools.common import generate_group_id
 # Set to track active subagent invocation tasks
 _active_subagent_tasks: Set[asyncio.Task] = set()
 
-# Atomic counter for DBOS workflow IDs - ensures uniqueness even in rapid back-to-back calls
-# itertools.count() is thread-safe for next() calls
-_dbos_workflow_counter = itertools.count()
-
-
-def _generate_dbos_workflow_id(base_id: str) -> str:
-    """Generate a unique DBOS workflow ID by appending an atomic counter.
-
-    DBOS requires workflow IDs to be unique across all executions.
-    This function ensures uniqueness by combining the base_id with
-    an atomically incrementing counter.
-
-    Args:
-        base_id: The base identifier (e.g., group_id from generate_group_id)
-
-    Returns:
-        A unique workflow ID in format: {base_id}-wf-{counter}
-    """
-    counter = next(_dbos_workflow_counter)
-    return f"{base_id}-wf-{counter}"
-
 
 def _generate_session_hash_suffix() -> str:
     """Generate a short SHA1 hash suffix based on current timestamp for uniqueness.
@@ -468,9 +444,11 @@ def register_invoke_agent(agent):
             instructions = prepared.instructions
             prompt = prepared.user_prompt
 
-            subagent_name = f"temp-invoke-agent-{session_id}"
             model_settings = make_model_settings(model_name)
 
+            # Load MCP servers so sub-agents have access to the same tools as the main agent
+            mcp_servers = agent_config.load_mcp_servers()
+
             temp_agent = Agent(
                 model=model,
                 instructions=instructions,
@@ -478,6 +456,7 @@ def register_invoke_agent(agent):
                 retries=3,
                 history_processors=[agent_config.message_history_accumulator],
                 model_settings=model_settings,
+                toolsets=mcp_servers if mcp_servers else [],
             )
 
             # Register the tools that the agent needs
@@ -486,44 +465,21 @@ def register_invoke_agent(agent):
             agent_tools = agent_config.get_available_tools()
             register_tools_for_agent(temp_agent, agent_tools)
 
-            if get_use_dbos():
-                from pydantic_ai.durable_exec.dbos import DBOSAgent
-
-                dbos_agent = DBOSAgent(temp_agent, name=subagent_name)
-                temp_agent = dbos_agent
-
             # Run the temporary agent with the provided prompt as an asyncio task
             # Pass the message_history from the session to continue the conversation
-            workflow_id = None  # Track for potential cancellation
-            if get_use_dbos():
-                # Generate a unique workflow ID for DBOS - ensures no collisions in back-to-back calls
-                workflow_id = _generate_dbos_workflow_id(group_id)
-                with SetWorkflowID(workflow_id):
-                    task = asyncio.create_task(
-                        temp_agent.run(
-                            prompt,
-                            message_history=message_history,
-                            usage_limits=UsageLimits(request_limit=get_message_limit()),
-                        )
-                    )
-                    _active_subagent_tasks.add(task)
-            else:
-                task = asyncio.create_task(
-                    temp_agent.run(
-                        prompt,
-                        message_history=message_history,
-                        usage_limits=UsageLimits(request_limit=get_message_limit()),
-                    )
+            task = asyncio.create_task(
+                temp_agent.run(
+                    prompt,
+                    message_history=message_history,
+                    usage_limits=UsageLimits(request_limit=get_message_limit()),
                 )
-                _active_subagent_tasks.add(task)
+            )
+            _active_subagent_tasks.add(task)
 
             try:
                 result = await task
             finally:
                 _active_subagent_tasks.discard(task)
-                if task.cancelled():
-                    if get_use_dbos() and workflow_id:
-                        DBOS.cancel_workflow(workflow_id)
 
             # Extract the response from the result
             response = result.output

code_puppy/tools/browser/vqa_agent.py

@@ -7,7 +7,7 @@ from functools import lru_cache
 from pydantic import BaseModel, Field
 from pydantic_ai import Agent, BinaryContent
 
-from code_puppy.config import get_use_dbos, get_vqa_model_name
+from code_puppy.config import get_vqa_model_name
 from code_puppy.model_factory import ModelFactory
 
 
@@ -50,12 +50,6 @@ def _load_vqa_agent(model_name: str) -> Agent[None, VisualAnalysisResult]:
         retries=2,
     )
 
-    if get_use_dbos():
-        from pydantic_ai.durable_exec.dbos import DBOSAgent
-
-        dbos_agent = DBOSAgent(vqa_agent, name="vqa-agent")
-        return dbos_agent
-
     return vqa_agent
 
 

{code_puppy-0.0.342.dist-info → code_puppy-0.0.344.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.342
+Version: 0.0.344
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -16,7 +16,6 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: <3.14,>=3.11
 Requires-Dist: camoufox>=0.4.11
-Requires-Dist: dbos>=2.5.0
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: httpx[http2]>=0.24.1
 Requires-Dist: json-repair>=0.46.2
@@ -174,27 +173,6 @@ These providers are automatically configured with correct OpenAI-compatible endp
 - **⚠️ Unsupported Providers** - Providers like Amazon Bedrock and Google Vertex that require special authentication are clearly marked
 - **⚠️ No Tool Calling** - Models without tool calling support show a big warning since they can't use Code Puppy's file/shell tools
 
-### Durable Execution
-
-Code Puppy now supports **[DBOS](https://github.com/dbos-inc/dbos-transact-py)** durable execution.
-
-When enabled, every agent is automatically wrapped as a `DBOSAgent`, checkpointing key interactions (including agent inputs, LLM responses, MCP calls, and tool calls) in a database for durability and recovery.
-
-You can toggle DBOS via either of these options:
-
-- CLI config (persists): `/set enable_dbos true` (or `false` to disable)
-
-
-Config takes precedence if set; otherwise the environment variable is used.
-
-### Configuration
-
-The following environment variables control DBOS behavior:
-- `DBOS_CONDUCTOR_KEY`: If set, Code Puppy connects to the [DBOS Management Console](https://console.dbos.dev/). Make sure you first register an app named `dbos-code-puppy` on the console to generate a Conductor key. Default: `None`.
-- `DBOS_LOG_LEVEL`: Logging verbosity: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, or `DEBUG`. Default: `ERROR`.
-- `DBOS_SYSTEM_DATABASE_URL`: Database URL used by DBOS. Can point to a local SQLite file or a Postgres instance. Example: `postgresql://postgres:dbos@localhost:5432/postgres`. Default: `dbos_store.sqlite` file in the config directory.
-- `DBOS_APP_VERSION`: If set, Code Puppy uses it as the [DBOS application version](https://docs.dbos.dev/architecture#application-and-workflow-versions) and automatically tries to recover pending workflows for this version. Default: Code Puppy version + Unix timestamp in millisecond (disable automatic recovery).
-
 ### Custom Commands
 Create markdown files in `.claude/commands/`, `.github/prompts/`, or `.agents/commands/` to define custom slash commands. The filename becomes the command name and the content runs as a prompt.