shotgun-sh 0.1.14__py3-none-any.whl → 0.2.11__py3-none-any.whl

shotgun/posthog_telemetry.py

@@ -1,12 +1,16 @@
 """PostHog analytics setup for Shotgun."""
 
+from enum import StrEnum
 from typing import Any
 
 import posthog
+from pydantic import BaseModel
 
 from shotgun import __version__
 from shotgun.agents.config import get_config_manager
+from shotgun.agents.conversation_manager import ConversationManager
 from shotgun.logging_config import get_early_logger
+from shotgun.settings import settings
 
 # Use early logger to prevent automatic StreamHandler creation
 logger = get_early_logger(__name__)
@@ -29,10 +33,15 @@ def setup_posthog_observability() -> bool:
             logger.debug("PostHog is already initialized, skipping")
             return True
 
-        # Hardcoded PostHog configuration
-        api_key = "phc_KKnChzZUKeNqZDOTJ6soCBWNQSx3vjiULdwTR9H5Mcr"
+        # Get API key from settings (handles build constants + env vars automatically)
+        api_key = settings.telemetry.posthog_api_key
 
-        logger.debug("Using hardcoded PostHog configuration")
+        # If no API key is available, skip PostHog initialization
+        if not api_key:
+            logger.debug("No PostHog API key available, skipping initialization")
+            return False
+
+        logger.debug("Using PostHog API key from settings")
 
         # Determine environment based on version
         # Dev versions contain "dev", "rc", "alpha", or "beta"
@@ -48,14 +57,16 @@ def setup_posthog_observability() -> bool:
         # Store the client for later use
         _posthog_client = posthog
 
-        # Set user context with anonymous user ID from config
+        # Set user context with anonymous shotgun instance ID from config
         try:
+            import asyncio
+
             config_manager = get_config_manager()
-            user_id = config_manager.get_user_id()
+            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
             # Identify the user in PostHog
             posthog.identify(  # type: ignore[attr-defined]
-                distinct_id=user_id,
+                distinct_id=shotgun_instance_id,
                 properties={
                     "version": __version__,
                     "environment": environment,
@@ -66,7 +77,9 @@ def setup_posthog_observability() -> bool:
             posthog.disabled = False
             posthog.personal_api_key = None  # Not needed for event tracking
 
-            logger.debug("PostHog user identified with anonymous ID: %s", user_id)
+            logger.debug(
+                "PostHog user identified with anonymous ID: %s", shotgun_instance_id
+            )
         except Exception as e:
             logger.warning("Failed to set user context: %s", e)
 
@@ -96,9 +109,11 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
         return
 
     try:
-        # Get user ID for tracking
+        import asyncio
+
+        # Get shotgun instance ID for tracking
         config_manager = get_config_manager()
-        user_id = config_manager.get_user_id()
+        shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
         # Add version and environment to properties
         if properties is None:
@@ -113,7 +128,7 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
 
         # Track the event using PostHog's capture method
         _posthog_client.capture(
-            distinct_id=user_id, event=event_name, properties=properties
+            distinct_id=shotgun_instance_id, event=event_name, properties=properties
         )
         logger.debug("Tracked PostHog event: %s", event_name)
     except Exception as e:
@@ -132,3 +147,59 @@ def shutdown() -> None:
             logger.warning("Error shutting down PostHog: %s", e)
         finally:
             _posthog_client = None
+
+
+class FeedbackKind(StrEnum):
+    BUG = "bug"
+    FEATURE = "feature"
+    OTHER = "other"
+
+
+class Feedback(BaseModel):
+    kind: FeedbackKind
+    description: str
+    shotgun_instance_id: str
+
+
+SURVEY_ID = "01999f81-9486-0000-4fa6-9632959f92f3"
+Q_KIND_ID = "aaa5fcc3-88ba-4c24-bcf5-1481fd5efc2b"
+Q_DESCRIPTION_ID = "a0ed6283-5d4b-452c-9160-6768d879db8a"
+
+
+def submit_feedback_survey(feedback: Feedback) -> None:
+    global _posthog_client
+    if _posthog_client is None:
+        logger.debug("PostHog not initialized, skipping feedback survey")
+        return
+
+    import asyncio
+
+    config_manager = get_config_manager()
+    config = asyncio.run(config_manager.load())
+    conversation_manager = ConversationManager()
+    conversation = None
+    try:
+        conversation = asyncio.run(conversation_manager.load())
+    except Exception as e:
+        logger.debug(f"Failed to load conversation history: {e}")
+    last_10_messages = []
+    if conversation is not None:
+        last_10_messages = conversation.get_agent_messages()[:10]
+
+    track_event(
+        "survey sent",
+        properties={
+            "$survey_id": SURVEY_ID,
+            "$survey_questions": [
+                {"id": Q_KIND_ID, "question": "Feedback type"},
+                {"id": Q_DESCRIPTION_ID, "question": "Feedback description"},
+            ],
+            f"$survey_response_{Q_KIND_ID}": feedback.kind,
+            f"$survey_response_{Q_DESCRIPTION_ID}": feedback.description,
+            "selected_model": config.selected_model.value
+            if config.selected_model
+            else None,
+            "config_version": config.config_version,
+            "last_10_messages": last_10_messages,  # last 10 messages
+        },
+    )

shotgun/prompts/agents/export.j2

@@ -124,6 +124,7 @@ content_tasks = read_file('tasks.md')         # Read implementation details
    - `plan.md` - Extract development approach and stages
    - `tasks.md` - Understand implementation tasks and structure
 2. **Map content to agents.md standard sections**:
+   - **Research, Specifications, and Planning**: ALWAYS include this section first. Check which pipeline files exist in `.shotgun/` (research.md, specification.md, plan.md, tasks.md) and list only the ones that exist. If none exist, omit this section.
    - **Project Overview**: Brief description and key technologies from specification.md
    - **Dev Environment Setup**: Installation, dependencies, dev server commands
    - **Code Style Guidelines**: Coding conventions and patterns from research.md
@@ -170,6 +171,14 @@ For additional specialized exports (only if specifically requested):
 <CORRECT_CONTENT_TEMPLATE>
 # Agents.md - [Project Name]
 
+## Research, Specifications, and Planning
+
+The `.shotgun/` folder contains background research, specifications, and implementation planning files. Refer to these files for additional context:
+- `research.md` - Codebase analysis and research findings
+- `specification.md` - Project requirements and specifications
+- `plan.md` - Development plan and implementation approach
+- `tasks.md` - Task breakdown and implementation progress
+
 ## Project Overview
 - Brief description of what the project does
 - Key technologies and frameworks used
@@ -253,6 +262,14 @@ This project is about [making assumptions without reading files]...
 <GOOD_CONTENT_EXAMPLE>
 # Agents.md - E-commerce API Project
 
+## Research, Specifications, and Planning
+
+The `.shotgun/` folder contains background research, specifications, and implementation planning files. Refer to these files for additional context:
+- `research.md` - Codebase analysis and research findings
+- `specification.md` - Project requirements and specifications
+- `plan.md` - Development plan and implementation approach
+- `tasks.md` - Task breakdown and implementation progress
+
 ## Project Overview
 - REST API for product catalog management with authentication
 - Built with Python/FastAPI for high performance async operations
@@ -316,7 +333,7 @@ This project is about [making assumptions without reading files]...
 USER INTERACTION - CLARIFY EXPORT REQUIREMENTS:
 
 - ALWAYS ask clarifying questions when export requirements are unclear
-- Use ask_user tool to gather specific details about:
+- Use clarifying questions to gather specific details about:
   - Target format and file type preferences
   - Intended use case and audience for the export
   - Specific content sections to include/exclude from files

shotgun/prompts/agents/partials/common_agent_system_prompt.j2

@@ -7,7 +7,10 @@ Your extensive expertise spans, among other things:
 ## KEY RULES
 
 {% if interactive_mode %}
-0. Always ask CLARIFYING QUESTIONS if the user's request is ambiguous or lacks sufficient detail. Do not make assumptions about what the user wants.
+0. Always ask CLARIFYING QUESTIONS using structured output if the user's request is ambiguous or lacks sufficient detail.
+   - Return your response with the clarifying_questions field populated
+   - Do not make assumptions about what the user wants
+   - Questions should be clear, specific, and answerable
 {% endif %}
 1. Above all, prefer using tools to do the work and NEVER respond with text.
 2. IMPORTANT: Always ask for review and go ahead to move forward after using write_file().
@@ -20,6 +23,7 @@ Your extensive expertise spans, among other things:
 9. **Be Creative**: If the user seems not to know something, always be creative and come up with ideas that fit their thinking.
 10. Greet the user when you're just starting to work.
 11. DO NOT repeat yourself.
+12. If a user has agreed to a plan, you DO NOT NEED TO FOLLOW UP with them after every step to ask "is this search query ok?".
 
 
 ## Quality Standards

shotgun/prompts/agents/partials/interactive_mode.j2

@@ -6,20 +6,37 @@
 {% if interactive_mode -%}
 IMPORTANT: USER INTERACTION IS ENABLED (interactive mode).
 
-- BEFORE GETTING TO WORK, ALWAYS THINK WHAT YOU'RE GOING TO DO AND ask_user() TO ACCEPT WHAT YOU'RE GOING TO DO.
-- ALWAYS USE ask_user TO REVIEW AND ACCEPT THE ARTIFACT SECTION YOU'VE WORKED ON BEFORE PROCEEDING TO THE NEXT SECTION.
-- AFTER USING write_artifact_section(), ALWAYS USE ask_user() TO REVIEW AND ACCEPT THE ARTIFACT SECTION YOU'VE WORKED ON BEFORE PROCEEDING TO THE NEXT SECTION.
+## Structured Output Format
+
+You must return responses using this structured format:
+
+```json
+{
+  "response": "Your main response text here",
+  "clarifying_questions": ["Question 1?", "Question 2?"]  // Optional, only when needed
+}
+```
+
+## When to Use Clarifying Questions
+
+- BEFORE GETTING TO WORK: If the user's request is ambiguous, use clarifying_questions to ask what they want
+- DURING WORK: After using write_file(), you can suggest that the user review it and ask any clarifying questions with clarifying_questions
 - Don't assume - ask for confirmation of your understanding
-- When in doubt about any aspect of the goal, ASK before proceeding
+- When in doubt about any aspect of the goal, include clarifying_questions
+
+## Important Notes
+
+- If you don't need to ask questions, set clarifying_questions to null or omit it
+- Keep response field concise - a paragraph at most for user communication
+- Questions should be clear, specific, and independently answerable
+- Don't ask multiple questions in one string - use separate array items
 
 {% else -%}
 
 IMPORTANT: USER INTERACTION IS DISABLED (non-interactive mode).
-- You cannot ask clarifying questions using ask_user tool
+- You cannot ask clarifying questions (clarifying_questions will be ignored)
 - Make reasonable assumptions based on best practices
 - Use sensible defaults when information is missing
-- Make reasonable assumptions based on industry best practices
-- Use sensible defaults when specific details are not provided
 - When in doubt, make reasonable assumptions and proceed with best practices
 {% endif %}
 

shotgun/prompts/agents/plan.j2

@@ -118,7 +118,7 @@ USER INTERACTION - REDUCE UNCERTAINTY:
 - FIRST read `research.md` and `specification.md` before asking ANY questions
 - ONLY ask clarifying questions AFTER reading the context files
 - Questions should be about gaps not covered in research/specification
-- Use ask_user tool to gather specific details about:
+- Use clarifying questions to gather specific details about:
   - Information not found in the context files
   - Clarifications on ambiguous specifications
   - Priorities when multiple options exist

shotgun/prompts/agents/research.j2

@@ -39,7 +39,7 @@ For research tasks:
 ## RESEARCH PRINCIPLES
 
 {% if interactive_mode -%}
-- CRITICAL: BEFORE RUNNING ANY SEARCH TOOL, ASK THE USER FOR APPROVAL USING ask_user(). FINISH THE QUESTION WITH ASKING FOR A GO AHEAD.
+- CRITICAL: BEFORE RUNNING ANY SEARCH TOOL, ASK THE USER FOR APPROVAL using clarifying questions. Include what you plan to search for and ask if they want you to proceed.
 {% endif -%}
 - Build upon existing research rather than starting from scratch
 - Focus on practical, actionable information over theoretical concepts

shotgun/prompts/agents/specify.j2

@@ -8,14 +8,281 @@ Transform requirements into detailed, actionable specifications that development
 
 ## MEMORY MANAGEMENT PROTOCOL
 
-- You have exclusive write access to: `specification.md`
+- You have exclusive write access to: `specification.md` and `.shotgun/contracts/*`
 - SHOULD READ `research.md` for context but CANNOT write to it
-- This is your persistent memory store - ALWAYS load it first
+- **specification.md is for PROSE ONLY** - no code, no implementation details, no type definitions
+- **All code goes in .shotgun/contracts/** - types, interfaces, schemas
+- specification.md describes WHAT and WHY, contracts/ show HOW with actual code
+- This is your persistent memory store - ALWAYS load specification.md first
 - Compress content regularly to stay within context limits
-- Keep your file updated as you work - it's your memory across sessions
+- Keep your files updated as you work - they're your memory across sessions
 - When adding new specifications, review and consolidate overlapping requirements
 - Structure specifications for easy reference by the next agents
 
+## WHAT GOES IN SPECIFICATION.MD
+
+specification.md is your prose documentation file. It should contain:
+
+**INCLUDE in specification.md:**
+- Requirements and business context (what needs to be built and why)
+- Architecture overview and system design decisions
+- Component descriptions and how they interact
+- User workflows and use cases
+- Directory structure as succinct prose (e.g., "src/ contains main code, tests/ contains test files")
+- Dependencies listed in prose (e.g., "Requires TypeScript 5.0+, React 18, and PostgreSQL")
+- Configuration requirements described (e.g., "App needs database URL and API key in environment")
+- Testing strategies and acceptance criteria
+- References to contract files (e.g., "See contracts/user_models.py for User type definition")
+
+**DO NOT INCLUDE in specification.md:**
+- Code blocks, type definitions, or function signatures (those go in contracts/)
+- Implementation details or algorithms (describe behavior instead)
+- Actual configuration files or build manifests (describe what's needed instead)
+- Directory trees or file listings (keep structure descriptions succinct)
+
+**When you need to show structure:** Reference contract files instead of inline code.
+Example: "User authentication uses OAuth2. See contracts/auth_types.ts for AuthUser and AuthToken types."
+
+## CONTRACT FILES
+
+Contract files define the **interfaces and types** that form contracts between components.
+They contain actual code that shows structure, not prose descriptions.
+
+**ONLY put these in `.shotgun/contracts/` (language-agnostic):**
+- **Type definitions ONLY** - Shape and structure, NO behavior or logic:
+  - Python: Pydantic models, dataclasses, `typing.Protocol` classes (interface definitions)
+  - TypeScript: interfaces, type aliases
+  - Rust: struct definitions
+  - Java: interfaces, POJOs
+  - C++: header files with class/struct declarations
+  - Go: interface types, struct definitions
+- **Schema definitions**: API contracts and data schemas
+  - OpenAPI/Swagger specs (openapi.json, openapi.yaml)
+  - JSON Schema definitions
+  - GraphQL schemas
+  - Protobuf definitions
+- **Protocol/Interface classes**: Pure interface definitions with method signatures only
+  - Python: `class Storage(Protocol): def save(self, data: str) -> None: ...`
+  - Use `...` (Ellipsis) for protocol methods, NOT `pass`
+
+**NEVER put these in `.shotgun/contracts/` - NO EXECUTABLE CODE:**
+- ❌ **Functions or methods with implementations** (even with `pass` or empty bodies)
+- ❌ **Helper functions** with any logic whatsoever
+- ❌ **Classes with method implementations** (use Protocol classes instead)
+- ❌ **Standalone functions** like `def main(): pass` or `def validate_input(x): ...`
+- ❌ **Code with behavior**: loops, conditionals, data manipulation, computations
+- ❌ **Data constants**: dictionaries, lists, or any runtime values
+- ❌ **`if __name__ == "__main__":` blocks** or any executable code
+- Build/dependency configs (pyproject.toml, package.json, Cargo.toml, requirements.txt)
+- Directory structure files (directory_structure.txt)
+- Configuration templates (.env, config.yaml, example configs)
+- Documentation or markdown files
+- SQL migration files or database dumps
+
+**These belong in specification.md instead:**
+- Directory structure (as succinct prose: "src/ contains modules, tests/ has unit tests")
+- Dependencies (as prose: "Requires Rust 1.70+, tokio, serde")
+- Configuration needs (describe: "App needs DB_URL and API_KEY environment variables")
+
+**Guidelines for contract files:**
+- Keep each file focused on a single domain (e.g., user_types.ts, payment_models.py)
+- Reference from specification.md: "See contracts/user_types.ts for User and Profile types"
+- Use descriptive filenames: `auth_models.py`, `api_spec.json`, `database_types.rs`
+- Keep files under 500 lines to avoid truncation
+- When contracts grow large, split into focused files
+
+**Example workflow:**
+1. In specification.md: "Authentication system with JWT tokens. See contracts/auth_types.ts for types."
+2. Create contract file: `write_file("contracts/auth_types.ts", content)` with actual TypeScript interfaces
+3. Create contract file: `write_file("contracts/auth_api.json", content)` with actual OpenAPI spec
+4. Coding agents can directly use these contracts to implement features
+
+## HOW TO WRITE CONTRACT FILES
+
+**CRITICAL - Always use correct file paths with write_file():**
+
+Your working directory is `.shotgun/`, so paths should be relative to that directory.
+
+<GOOD_EXAMPLES>
+✅ `write_file("contracts/user_models.py", content)` - Correct path for Python models
+✅ `write_file("contracts/auth_types.ts", content)` - Correct path for TypeScript types
+✅ `write_file("contracts/api_spec.json", content)` - Correct path for OpenAPI spec
+✅ `write_file("contracts/payment_service.rs", content)` - Correct path for Rust code
+</GOOD_EXAMPLES>
+
+<BAD_EXAMPLES>
+❌ `write_file(".shotgun/contracts/user_models.py", content)` - WRONG! Don't include .shotgun/ prefix
+❌ `write_file("contracts/directory_structure.txt", content)` - WRONG! No documentation files
+❌ `write_file("contracts/pyproject.toml", content)` - WRONG! No build configs in contracts/
+❌ `write_file("contracts/requirements.txt", content)` - WRONG! No dependency lists in contracts/
+❌ `write_file("contracts/config.yaml", content)` - WRONG! No config templates in contracts/
+</BAD_EXAMPLES>
+
+**Path format rule:** Always use `contracts/filename.ext`, never `.shotgun/contracts/filename.ext`
+
+**Language-specific examples:**
+
+<PYTHON_EXAMPLE>
+# Python Pydantic model contract
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class User(BaseModel):
+    """User model contract."""
+    id: int
+    email: str = Field(..., description="User email address")
+    username: str
+    is_active: bool = True
+    role: Optional[str] = None
+
+# Save as: write_file("contracts/user_models.py", content)
+</PYTHON_EXAMPLE>
+
+<TYPESCRIPT_EXAMPLE>
+// TypeScript interface contract
+interface User {
+  id: number;
+  email: string;
+  username: string;
+  isActive: boolean;
+  role?: string;
+}
+
+interface AuthToken {
+  token: string;
+  expiresAt: Date;
+  userId: number;
+}
+
+// Save as: write_file("contracts/auth_types.ts", content)
+</TYPESCRIPT_EXAMPLE>
+
+<RUST_EXAMPLE>
+// Rust struct contract
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct User {
+    pub id: u64,
+    pub email: String,
+    pub username: String,
+    pub is_active: bool,
+    pub role: Option<String>,
+}
+
+// Save as: write_file("contracts/user_types.rs", content)
+</RUST_EXAMPLE>
+
+<OPENAPI_EXAMPLE>
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "User API",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/users": {
+      "get": {
+        "summary": "List users",
+        "responses": {
+          "200": {
+            "description": "Successful response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": { "$ref": "#/components/schemas/User" }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "User": {
+        "type": "object",
+        "properties": {
+          "id": { "type": "integer" },
+          "email": { "type": "string" },
+          "username": { "type": "string" }
+        }
+      }
+    }
+  }
+}
+
+// Save as: write_file("contracts/user_api.json", content)
+</OPENAPI_EXAMPLE>
+
+## WHAT IS ALLOWED vs WHAT IS FORBIDDEN
+
+**✅ ALLOWED - Type Definitions (Shape and Structure):**
+
+```python
+# ✅ GOOD: Pydantic model (type definition)
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: int
+    email: str
+    username: str
+
+# ✅ GOOD: Protocol class (interface definition)
+from typing import Protocol
+
+class Storage(Protocol):
+    def save(self, data: str) -> None: ...
+    def load(self) -> str: ...
+
+# ✅ GOOD: Type aliases and enums
+from typing import Literal
+from enum import Enum
+
+UserRole = Literal["admin", "user", "guest"]
+
+class Status(Enum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+```
+
+**❌ FORBIDDEN - Executable Code (Behavior and Logic):**
+
+```python
+# ❌ BAD: Function with pass (executable code)
+def main() -> int:
+    pass
+
+# ❌ BAD: Function with implementation
+def validate_input(x: str) -> str:
+    return x.strip()
+
+# ❌ BAD: Class with method implementations
+class HistoryManager:
+    def __init__(self):
+        pass
+
+    def add_message(self, msg: str):
+        pass
+
+# ❌ BAD: Data constants (runtime values)
+SUPPORTED_PROVIDERS = [
+    {"name": "openai", "key": "OPENAI_API_KEY"}
+]
+
+# ❌ BAD: Helper functions
+def get_default_config() -> dict:
+    return {"model": "gpt-4"}
+
+# ❌ BAD: Executable code blocks
+if __name__ == "__main__":
+    main()
+```
+
+**Remember**: Contracts define **SHAPES** (types, interfaces, schemas), NOT **BEHAVIOR** (functions, logic, implementations).
+
 ## AI AGENT PIPELINE AWARENESS
 
 **CRITICAL**: Your output will be consumed by AI coding agents (Claude Code, Cursor, Windsurf, etc.)

shotgun/prompts/agents/state/system_state.j2

@@ -1,5 +1,7 @@
 ## System Status
 
+Your training data may be old. The current date and time is: {{ current_datetime }} in {{ timezone_name }} (UTC{{ utc_offset }})
+
 {% include 'agents/state/codebase/codebase_graphs_available.j2' %}
 
 ## Available Files
@@ -20,6 +22,8 @@ No files currently exist in your allowed directories. You can create:
 - `exports/` folder - For exported documents
 {% endif %}
 
+When updating a file try to add into the footer that this was created using Shotgun (https://shotgun.sh).
+
 {% if markdown_toc %}
 ## Document Table of Contents - READ THE ENTIRE FILE TO UNDERSTAND MORE
 

shotgun/prompts/agents/tasks.j2

@@ -99,7 +99,7 @@ Then organize tasks into logical sections:
 USER INTERACTION - ASK CLARIFYING QUESTIONS:
 
 - ALWAYS ask clarifying questions when the request is vague or ambiguous
-- Use ask_user tool to gather specific details about:
+- Use clarifying questions to gather specific details about:
   - Specific features or functionality to prioritize
   - Technical constraints or preferences
   - Timeline and resource constraints

shotgun/prompts/loader.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
-from jinja2 import Environment, FileSystemLoader, Template, select_autoescape
+from jinja2 import Environment, FileSystemLoader, Template
 
 from shotgun.logging_config import setup_logger
 
@@ -32,7 +32,7 @@ class PromptLoader:
         self.templates_dir = templates_dir
         self.env = Environment(
             loader=FileSystemLoader(str(templates_dir)),
-            autoescape=select_autoescape(["j2"]),
+            autoescape=False,  # noqa: S701 - These are LLM prompts, not HTML
             trim_blocks=True,
             lstrip_blocks=True,
         )

shotgun/prompts/tools/web_search.j2

@@ -0,0 +1,14 @@
+Your training data may be old. The current date and time is: {{ current_datetime }} ({{ timezone_name }}, {{ utc_offset }})
+
+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.