shotgun-sh 0.1.0.dev12__py3-none-any.whl → 0.1.0.dev14__py3-none-any.whl

shotgun/agents/tools/web_search/anthropic.py

@@ -11,10 +11,10 @@ logger = get_logger(__name__)
 
 
 def anthropic_web_search_tool(query: str) -> str:
-    """Perform a web search using Anthropic's Claude API.
+    """Perform a web search using Anthropic's Claude API with streaming.
 
     This tool uses Anthropic's web search capabilities to find current information
-    about the given query.
+    about the given query. Results are streamed for faster response times.
 
     Args:
         query: The search query
@@ -27,7 +27,7 @@ def anthropic_web_search_tool(query: str) -> str:
     span = trace.get_current_span()
     span.set_attribute("input.value", f"**Query:** {query}\n")
 
-    logger.debug("📡 Executing Anthropic web search with prompt: %s", query)
+    logger.debug("📡 Executing Anthropic web search with streaming prompt: %s", query)
 
     # Get API key from centralized configuration
     try:
@@ -41,11 +41,13 @@ def anthropic_web_search_tool(query: str) -> str:
 
     client = anthropic.Anthropic(api_key=api_key)
 
-    # Use the Messages API with web search tool
+    # Use the Messages API with web search tool and streaming
     try:
-        response = client.messages.create(
+        result_text = ""
+
+        with client.messages.stream(
             model="claude-3-5-sonnet-latest",
-            max_tokens=8192,  # Increased from 4096 for more comprehensive results
+            max_tokens=8192,  # Maximum for Claude 3.5 Sonnet
             messages=[{"role": "user", "content": f"Search for: {query}"}],
             tools=[
                 {
@@ -54,17 +56,17 @@ def anthropic_web_search_tool(query: str) -> str:
                 }
             ],
             tool_choice={"type": "tool", "name": "web_search"},
-        )
-
-        # Extract the search results from the response
-        result_text = ""
-        if hasattr(response, "content") and response.content:
-            for content in response.content:
-                if hasattr(content, "text"):
-                    result_text += content.text
-                elif hasattr(content, "tool_use") and content.tool_use:
-                    # Handle tool use response
-                    result_text += f"Search performed for: {query}\n"
+        ) as stream:
+            logger.debug("🌊 Started streaming Anthropic web search response")
+
+            for event in stream:
+                if event.type == "content_block_delta":
+                    if hasattr(event.delta, "text"):
+                        result_text += event.delta.text
+                elif event.type == "message_start":
+                    logger.debug("🚀 Streaming started")
+                elif event.type == "message_stop":
+                    logger.debug("✅ Streaming completed")
 
         if not result_text:
             result_text = "No content returned from search"
@@ -84,3 +86,62 @@ def anthropic_web_search_tool(query: str) -> str:
         logger.debug("💥 Full error details: %s", error_msg)
         span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
         return error_msg
+
+
+def main() -> None:
+    """Main function for testing the Anthropic web search tool."""
+    import logging
+    import os
+    import sys
+
+    # Set up basic console logging for testing
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+        stream=sys.stdout,
+    )
+
+    if len(sys.argv) < 2:
+        print(
+            "Usage: python -m shotgun.agents.tools.web_search.anthropic <search_query>"
+        )
+        print(
+            "Example: python -m shotgun.agents.tools.web_search.anthropic 'latest Python updates'"
+        )
+        sys.exit(1)
+
+    # Join all arguments as the search query
+    query = " ".join(sys.argv[1:])
+
+    print("🔍 Testing Anthropic Web Search with streaming")
+    print(f"📝 Query: {query}")
+    print("=" * 60)
+
+    # Check if API key is available
+    if not (
+        os.getenv("ANTHROPIC_API_KEY")
+        or (
+            callable(get_provider_model)
+            and get_provider_model(ProviderType.ANTHROPIC).api_key
+        )
+    ):
+        print("❌ Error: ANTHROPIC_API_KEY environment variable not set")
+        print("   Please set it with: export ANTHROPIC_API_KEY=your_key_here")
+        sys.exit(1)
+
+    try:
+        result = anthropic_web_search_tool(query)
+        print(f"✅ Search completed! Result length: {len(result)} characters")
+        print("=" * 60)
+        print("📄 RESULTS:")
+        print("=" * 60)
+        print(result)
+    except KeyboardInterrupt:
+        print("\n⏹️  Search interrupted by user")
+    except Exception as e:
+        print(f"❌ Error during search: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

shotgun/agents/tools/web_search/gemini.py

@@ -62,7 +62,7 @@ Instructions:
             search_prompt,
             generation_config=genai.GenerationConfig(  # type: ignore[attr-defined]
                 temperature=0.3,
-                max_output_tokens=8192,  # Explicit limit for comprehensive results
+                max_output_tokens=8192,
             ),
         )
 

shotgun/agents/tools/web_search/openai.py

@@ -40,17 +40,31 @@ def openai_web_search_tool(query: str) -> str:
             span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
             return error_msg
 
+        prompt = f"""Please provide current and accurate information about the following query:
+
+Query: {query}
+
+Instructions:
+- Provide comprehensive, factual information
+- Include relevant details and context
+- Focus on current and recent information
+- Be specific and accurate in your response
+- You can't ask the user for details, so assume the most relevant details for the query
+
+ALWAYS PROVIDE THE SOURCES (urls) TO BACK UP THE INFORMATION YOU PROVIDE.
+"""
+
         client = OpenAI(api_key=api_key)
         response = client.responses.create(  # type: ignore[call-overload]
             model="gpt-5-mini",
             input=[
-                {"role": "user", "content": [{"type": "input_text", "text": query}]}
+                {"role": "user", "content": [{"type": "input_text", "text": prompt}]}
             ],
             text={
                 "format": {"type": "text"},
                 "verbosity": "high",
             },  # Increased from medium
-            reasoning={"effort": "high", "summary": "auto"},  # Increased from medium
+            reasoning={"effort": "medium", "summary": "auto"},
             tools=[
                 {
                     "type": "web_search",

shotgun/artifacts/__init__.py

@@ -0,0 +1,17 @@
+"""Artifact system for managing structured content in .shotgun directory."""
+
+__all__ = [
+    "ArtifactService",
+    "ArtifactManager",
+    "Artifact",
+    "ArtifactSection",
+    "ArtifactSummary",
+    "AgentMode",
+    "generate_artifact_name",
+    "parse_agent_mode_string",
+]
+
+from .manager import ArtifactManager
+from .models import AgentMode, Artifact, ArtifactSection, ArtifactSummary
+from .service import ArtifactService
+from .utils import generate_artifact_name, parse_agent_mode_string

shotgun/artifacts/exceptions.py

@@ -0,0 +1,89 @@
+"""Exception classes for the artifact system."""
+
+
+class ArtifactError(Exception):
+    """Base exception for all artifact-related errors."""
+
+
+class ArtifactNotFoundError(ArtifactError):
+    """Raised when an artifact is not found."""
+
+    def __init__(self, artifact_id: str, agent_mode: str | None = None) -> None:
+        if agent_mode:
+            message = f"Artifact '{artifact_id}' not found in agent mode '{agent_mode}'"
+        else:
+            message = f"Artifact '{artifact_id}' not found"
+        super().__init__(message)
+        self.artifact_id = artifact_id
+        self.agent_mode = agent_mode
+
+
+class SectionNotFoundError(ArtifactError):
+    """Raised when a section is not found within an artifact."""
+
+    def __init__(self, section_identifier: str | int, artifact_id: str) -> None:
+        message = (
+            f"Section '{section_identifier}' not found in artifact '{artifact_id}'"
+        )
+        super().__init__(message)
+        self.section_identifier = section_identifier
+        self.artifact_id = artifact_id
+
+
+class SectionAlreadyExistsError(ArtifactError):
+    """Raised when trying to create a section that already exists."""
+
+    def __init__(self, section_identifier: str | int, artifact_id: str) -> None:
+        message = (
+            f"Section '{section_identifier}' already exists in artifact '{artifact_id}'"
+        )
+        super().__init__(message)
+        self.section_identifier = section_identifier
+        self.artifact_id = artifact_id
+
+
+class ArtifactAlreadyExistsError(ArtifactError):
+    """Raised when trying to create an artifact that already exists."""
+
+    def __init__(self, artifact_id: str, agent_mode: str) -> None:
+        message = (
+            f"Artifact '{artifact_id}' already exists in agent mode '{agent_mode}'"
+        )
+        super().__init__(message)
+        self.artifact_id = artifact_id
+        self.agent_mode = agent_mode
+
+
+class InvalidArtifactPathError(ArtifactError):
+    """Raised when an artifact path is invalid or outside allowed directories."""
+
+    def __init__(self, path: str, reason: str | None = None) -> None:
+        message = f"Invalid artifact path: {path}"
+        if reason:
+            message += f" - {reason}"
+        super().__init__(message)
+        self.path = path
+        self.reason = reason
+
+
+class ArtifactFileSystemError(ArtifactError):
+    """Raised when file system operations fail."""
+
+    def __init__(self, operation: str, path: str, reason: str) -> None:
+        message = f"File system error during {operation} on '{path}': {reason}"
+        super().__init__(message)
+        self.operation = operation
+        self.path = path
+        self.reason = reason
+
+
+class ArtifactValidationError(ArtifactError):
+    """Raised when artifact data validation fails."""
+
+    def __init__(self, message: str, field: str | None = None) -> None:
+        if field:
+            message = f"Validation error for field '{field}': {message}"
+        else:
+            message = f"Validation error: {message}"
+        super().__init__(message)
+        self.field = field