Add database agent

[CTY-git]

PR Checklist

• The commit message follows our guidelines: Code of conduct
• Tests for the changes have been added (for bug fixes / features)
• Docs have been added / updated (for bug fixes / features)
• Does this PR introduce a breaking change?
• Include PR in release notes?

PR Type

• Bugfix
• Feature
• Refactoring
• Build /CI
• Documentation
• Others

What is the current behavior?

Issue Number: N/A

What is the new behavior?

Other information

[patched-admin]

File Changed: patchwork/common/multiturn_strategy/planning_strategy.py

Rule 1: Do not ignore potential bugs in the code

Details: Several potential bugs have been identified:

1. No explicit handling of asyncio event loop closure in case of exceptions
2. No input validation for conversation_limit parameter
3. Potential race condition in plan cursor management

Affected Code Snippet:

def __agent_run(self, agent: Agent, prompt: str, **kwargs) -> AgentRunResult[Any]:
    loop = asyncio.new_event_loop()
    planner_response = loop.run_until_complete(agent.run(prompt, **kwargs))
    loop.close()
    self.__request_tokens += planner_response.usage().request_tokens
    self.__response_tokens += planner_response.usage().response_tokens
    return planner_response

Start Line: 173
End Line: 180

---

Rule 2: Do not overlook possible security vulnerabilities

Details: Several security concerns identified:

1. Unsanitized input in task string interpolation
2. No rate limiting on token usage
3. Potential for injection attacks through task parameter

Affected Code Snippet:

def run(self, task: str, conversation_limit: int = 10) -> dict:
    planner_response = self.__agent_run(self.planner, f"Produce the initial plan for {task}")
    planner_history = planner_response.all_messages()

Start Line: 182
End Line: 184

File Changed: patchwork/common/tools/db_query_tool.py

Rule 1: Do not ignore potential bugs in the code

Details: The code has a potential bug in error handling where it returns different types (Union[list[dict[str, Any]], str]) which could cause type-related issues downstream if not properly handled by the calling code.

Affected Code Snippet:

def execute(self, query: str) -> Union[list[dict[str, Any]], str]:
    db_settings = self.db_settings.copy()
    db_settings["db_query"] = query
    try:
        return CallSQL(db_settings).run().get("results", [])
    except Exception as e:
        return str(e)

Start Line: 31
End Line: 38

---

Rule 2: Do not overlook possible security vulnerabilities

Details: The code accepts raw SQL queries without any input validation or sanitization, making it vulnerable to SQL injection attacks. Additionally, broad exception handling could potentially mask specific database security issues.

Affected Code Snippet:

def execute(self, query: str) -> Union[list[dict[str, Any]], str]:
    db_settings = self.db_settings.copy()
    db_settings["db_query"] = query
    try:
        return CallSQL(db_settings).run().get("results", [])
    except Exception as e:
        return str(e)

Start Line: 31
End Line: 38

File Changed: patchwork/steps/AgenticLLM/typed.py

Rule 2: Do not overlook possible security vulnerabilities

Details: While the code handles API keys, the modifications don't introduce new security vulnerabilities. The type annotations and configurations for API key handling remain unchanged functionally. However, it's worth noting that the code uses multiple API keys with OR operations, which maintains the existing security model.

Affected Code Snippet: N/A

Start Line: N/A

End Line: N/A
In this case, I have to remove all the code reviews since none of them are actionable or useful. Here's why:

1. Rule 1 review is not actionable because it only states that no bugs were found and the changes were purely formatting-related. There are no specific issues to address.

2. Rule 2 review is not actionable as it just confirms no security vulnerabilities were introduced and the changes were cosmetic.

3. Rule 3 review is not useful as it simply states that the changes improve code standards without providing any specific actionable feedback.

The summary further confirms that these are purely formatting changes with no substantive issues to address.

Since no reviews provide actionable or useful feedback that requires developer attention, the response should be empty.

File Changed: patchwork/steps/DatabaseAgent/DatabaseAgent.py

Rule 1: Do not ignore potential bugs in the code

Details: The code has a potential bug where prompt_value is retrieved from inputs without checking if it exists, which could lead to KeyError.

Affected Code Snippet:

data = inputs.get("prompt_value", {})
task = mustache_render(inputs["task"], data)

Start Line: 18
End Line: 19

Additionally, there's no error handling for the mustache_render function which could fail if the template is malformed.

---

Rule 2: Do not overlook possible security vulnerabilities

Details: The code introduces potential SQL injection vulnerabilities through direct templating of user input into database queries. The DatabaseQueryTool is being initialized with raw inputs without proper sanitization.

Affected Code Snippet:

tool_set=dict(db_tool=DatabaseQueryTool(inputs)),
system_prompt=f"""\
You are a {db_dialect} database query execution assistant. Assist me in completing a task.

Start Line: 35
End Line: 39

Additionally, user input from task is being rendered into prompts without sanitization:

task = mustache_render(inputs["task"], data)

Start Line: 19
End Line: 19

File Changed: patchwork/steps/DatabaseAgent/typed.py

Rule 1 - Do not ignore potential bugs in the code
Details:

• There's a potential bug where db_port is typed as 'int' without any validation constraints, which could allow invalid port numbers.
• The db_params and db_driver_args dictionaries use Any type which could lead to runtime errors if unexpected types are passed.

Affected Code Snippet:

    db_port: int
    db_params: dict[str, Any]
    db_driver_args: dict[str, Any]

Start Line: 15

End Line: 17

---

Rule 2 - Do not overlook possible security vulnerabilities
Details: Several security concerns identified:

1. Sensitive credentials (db_password, API keys) are handled as plain string types without any secure string handling mechanisms
2. No input validation for db_params and db_driver_args which could lead to SQL injection vulnerabilities
3. Connection parameters exposed in type hints could reveal system architecture

Affected Code Snippet:

    db_password: str
    db_params: dict[str, Any]
    db_driver_args: dict[str, Any]
    openai_api_key: Annotated[
        str, StepTypeConfig(is_config=True, or_op=["patched_api_key", "google_api_key", "anthropic_api_key"])
    ]
    anthropic_api_key: Annotated[
        str, StepTypeConfig(is_config=True, or_op=["patched_api_key", "google_api_key", "openai_api_key"])
    ]
    google_api_key: Annotated[
        str, StepTypeConfig(is_config=True, or_op=["patched_api_key", "openai_api_key", "anthropic_api_key"])
    ]

Start Line: 13

End Line: 29
Since all the code reviews provided for patchwork/steps/FixIssue/typed.py are not actionable (they all indicate "No violations detected" or just mention formatting changes), and contain no specific code changes or concrete suggestions for improvement, I will return an empty response as these reviews don't provide actionable feedback that would help improve the code quality or functionality.

File Changed: patchwork/steps/GitHubAgent/GitHubAgent.py

Rule 1: Do not ignore potential bugs in the code

Details: Potential bug detected - Model configuration inconsistency. The code introduces two different LLM models (claude-3-5-sonnet-latest and gemini-2.0-flash) within the same agent configuration, which could lead to unexpected behavior or conflicts in the execution flow.

Affected Code Snippet:

self.agentic_strategy = AgenticStrategyV2(
    model="claude-3-5-sonnet-latest",
    llm_client=AioLlmClient.create_aio_client(inputs),
    template_data=dict(),
    ...
)
...
AgentConfig(
    name="Assistant",
    model="gemini-2.0-flash",
    tool_set=dict(github_tool=GitHubTool(base_path, inputs["github_api_token"]))
)

Start Line: 20
End Line: 37

Summary of Findings:

The primary concern identified is a potential bug due to inconsistent model configuration between the AgenticStrategyV2 and AgentConfig classes. This could lead to confusion about which model is actually being used for different operations. The code should be reviewed to ensure proper model coordination between these components.

Recommendations:

1. Clarify the relationship between the top-level model configuration and the agent-specific model configuration
2. Document the intended behavior when different models are specified at different levels
3. Consider consolidating model configuration to a single location to prevent potential conflicts

Rule 2: Do not overlook possible security vulnerabilities

Details: The code contains sensitive API key configurations. While the changes are purely formatting-related, it's worth noting that these configurations handle multiple API keys (OpenAI, Anthropic, Google) which are sensitive credentials. However, the changes themselves don't introduce new security vulnerabilities as they only modify line formatting.

Affected Code Snippet:

openai_api_key: Annotated[
    str,
    StepTypeConfig(
        is_config=True, or_op=["patched_api_key", "google_api_key", "client_is_gcp", "anthropic_api_key"]
    ),
]

Start Line: 14

End Line: 18

File Changed: patchwork/steps/SendEmail/SendEmail.py

Rule 1: Do not ignore potential bugs in the code

Details: Potential bug found - The code doesn't handle the case where timestamp could be None or when original_email_data.get() returns None for required fields. This could lead to NoneType exceptions.

Affected Code Snippet:

timestamp: datetime = original_email_data.get("datetime")
date_str = timestamp.date().strftime("%-d %b %Y")
time_str = timestamp.time().strftime("%H:%M")

Start Line: 36
End Line: 38

---

Rule 2: Do not overlook possible security vulnerabilities

Details: Security vulnerability identified - The code directly uses unsanitized input from email data in string formatting. This could potentially lead to format string injection attacks or unwanted content injection through maliciously crafted email fields.

Affected Code Snippet:

self.body += f"\n\nOn {date_str} at {time_str}, {from_} wrote:\n\n" + textwrap.indent(
    original_email_data.get("body"), "> "
)

Start Line: 41
End Line: 43

File Changed: patchwork/steps/SendEmail/typed.py

Rule 3: Do not deviate from the original coding standards

Details: This change actually improves adherence to coding standards by alphabetically ordering imports, which is a common Python coding standard (PEP 8 recommends that imports should be grouped and ordered alphabetically).

Original:

from typing_extensions import Any, TypedDict, Annotated

Modified to:

from typing_extensions import Annotated, Any, TypedDict

Start Line: 1

End Line: 1

Analysis: The modification follows better Python coding standards by ordering imports alphabetically (Annotated, Any, TypedDict), which is an improvement over the original ordering.

File Changed: patchwork/steps/SimplifiedLLM/typed.py

Rule 3: Do not deviate from the original coding standards

Details: The changes actually improve adherence to coding standards by making the code more readable through proper line breaks and indentation. The modifications follow Python's style guidelines (like PEP 8) for line length and formatting of long parameter lists.

Before the change, lines were too long and harder to read:

    openai_api_key: Annotated[str, StepTypeConfig(is_config=True, or_op=["patched_api_key", "google_api_key", "client_is_gcp", "anthropic_api_key"])]

After the change, the code is more readable with proper line breaks:

    openai_api_key: Annotated[
        str,
        StepTypeConfig(
            is_config=True, or_op=["patched_api_key", "google_api_key", "client_is_gcp", "anthropic_api_key"]
        ),
    ]

Start Line: 16

End Line: 52

The changes actually represent an improvement in coding standards rather than a violation.

File Changed: patchwork/steps/SimplifiedLLMOnce/typed.py

Rule 3: Do not deviate from the original coding standards

Details: The changes actually improve code standards by following Python's PEP 8 guidelines for line length and readability. The modifications consistently break long lines into multiple lines with proper indentation, making the code more readable while maintaining the original functionality.

Affected Code Snippet: N/A

Start Line: N/A

End Line: N/A